JavaEE开发之Spring框架整合1
Posted nuist__NJUPT
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaEE开发之Spring框架整合1相关的知识，希望对你有一定的参考价值。
随着时代发展，软件规模与功能都呈几何式增长，开发难度也在不断递增，该如何解决?
Spring可以简化开发，降低企业级开发的复杂性，使开发变得更简单快捷随着项目规模与功能的增长,遇到的问题就会增多，为了解决问题会引入更多的框架，这些框架如何协调工作?Spring可以框架整合，高效整合其他技术，提高企业级应用开发与运行效率，综上所述，Spring是一款非常优秀而且功能强大的框架。
目录
一、基本概念
1.1、控制反转(IOC)
使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到
外部，此思想称为控制反转。业务层要用数据层的类对象，以前是自己 new 的，现在自己不new了，交给 别人[外部] 来创建对象，别人[外部] 就反转控制了数据层对象的创建权，这种思想就是控制反转。
1.2、Spring和IOC之间的关系
Spring技术对IOC思想进行了实现，Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的"外部"，IOC思想中的 别人[外部] 指的就是Spring的IOC容器。
1.3、IOC容器的作用
IOC容器负责对象的创建、初始化等一系列工作，其中包含了数据层和业务层的类对象，被创建或被管理的对象在IOC容器中统称为Bean，IOC容器中放的就是一个个的Bean对象。
1.4、依赖注入(DI)
在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入，业务层要用数据层的类对象，以前是自己 new 的现在自己不new了，靠 别人[外部其实指的就是IOC容器] 来给注入进来
这种思想就是依赖注入。需要程序员根据业务需求提前建立好关系，如业务层需要依赖数据层，service就要和dao建立依赖关系，介绍完Spring的IOC和DI的概念后，我们会发现这两个概念的最终目标就是:充分解耦，具体实现靠:使用IOC容器管理bean（IOC)，在IOC容器内将有依赖关系的bean进行关系绑定（DI），最终结果为:使用对象时不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系.
二、入门案例
2.1、IOC入门案例
1)创建java的maven项目，并在pom.xml中导入spring依赖jar包，如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>java02</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
</dependencies>
</project>2）创建数据访问层(dao)和业务层(service)的接口和接口实现类，如下：
public interface BookDao
public void save() ;
import com.dao.BookDao;
public class BookDaoImpl implements BookDao
public void save()
System.out.println("book dao save ...");
public interface BookService
public void save() ;
import com.dao.BookDao;
import com.dao.impl.BookDaoImpl;
import com.service.BookService;
public class BookServiceImpl implements BookService
BookDao bookDao = new BookDaoImpl() ;
public void save()
bookDao.save();
System.out.println("book service save...");
3)添加spring的配置文件applicationContext.xml，在配置文件中配置bean对象，这样IOC容器就可以管理bean对象，通过bean对象实现控制反转。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型-->
<bean id="bookDao" class="com.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.service.impl.BookServiceImpl"/>
</beans>4）编写测试类实现获取IOC容器，并通过bean对象调用相应的方法。
import com.dao.BookDao;
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class app
public static void main(String[] args)
//获取IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
//获取bean对象,并执行相应的方法
BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
bookDao.save();
System.out.println("-------------");
BookService bookService = (BookService) applicationContext.getBean("bookService");
bookService.save();
2.2、DI入门案例
1）将上述业务层的new方法删除，并提供对应的setter方法。
import com.dao.BookDao;
import com.service.BookService;
public class BookServiceImpl implements BookService
BookDao bookDao ;
public void save()
bookDao.save();
System.out.println("book service save...");
public void setBookDao(BookDao bookDao)
this.bookDao = bookDao;
2）在配置文件中添加依赖注入的配置。配置文件中两个bookDao的含义不同，name="bookDao"中 bookDao 的作用是让Spring的IOC容器在获取到名称后，将首字母大写，前
面加set找对应的 setBookDao() 方法进行对象注入。ref="bookDao"中 bookDao 的作用是让Spring能在IOC容器中找到id为 bookDao 的Bean对象给bookService 进行注入。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型-->
<bean id="bookDao" class="com.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.service.impl.BookServiceImpl">
<!--name对象参照ref对象-->
<property name="bookDao" ref="bookDao"/>
</bean>
</beans>三、bean的相关知识
3.1、bean的作用范围
使用bean的 scope 属性可以控制bean的创建是否为单例：singleton 默认为单例，prototype 为非单例。
1）为什么bean默认为单例?
bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象，bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高。
2）bean在容器中是单例的，会不会产生线程安全问题?
如果对象是有状态对象，即该对象有成员变量可以用来存储数据的，因为所有请求线程共用一个bean对象，所以会存在线程安全问题。如果对象是无状态对象，即该对象没有成员变量没有进行数据存储的，因方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。
关于bean的基础配置：id表示bean的唯一表示，name表示bean的别名，class表示bean的类全名，scope表示类的作用范围，包括singleton和prototype。
3.2、bean的三种实例化方式
1）构造方法实例化
直接在接口的实现类中定义一个无参构造方法，即可实现bean的实例化。
import com.dao.BookDao;
public class BookDaoImpl implements BookDao
public BookDaoImpl()
System.out.println("构造方法实例化");
public void save()
System.out.println("book dao save ...");
2）静态工厂实例化
第一步，创建一个接口和实现类，如下：
public interface OrderDao
public void save() ;
import com.dao.OrderDao;
public class OrderDaoImpl implements OrderDao
public void save()
System.out.println("oderDao save ...");
第二步，创建一个工厂类OrderDaoFactory并提供一个静态方法
import com.dao.OrderDao;
import com.dao.impl.OrderDaoImpl;
public class OrderDaoFactory
public static OrderDao getOrderDao()
System.out.println("静态工厂实例化");
return new OrderDaoImpl() ;
第三步，在spring的配置文件application.properties中添加以下内容：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<!-- <bean id="bookDao" class="com.dao.impl.BookDaoImpl"/>-->
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>
</beans>第四步，编写运行类，使用从IOC容器中获取bean的方法进行运行测试
import com.dao.OrderDao;
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class app
public static void main(String[] args)
//获取IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
// //获取bean对象,并执行相应的方法
// BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
// bookDao.save();
// System.out.println("-------------");
// BookService bookService = (BookService) applicationContext.getBean("bookService");
// bookService.save();
OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
orderDao.save();
3）实例工厂实例化
第一步，创建一个接口和一个实现类，如下：
public interface UserDao
public void save() ;
import com.dao.UserDao;
public class UserDaoImpl implements UserDao
public void save()
System.out.println("userDao save ...");
第二步，创建工厂类，并提供实例方法，如下：
import com.dao.UserDao;
import com.dao.impl.UserDaoImpl;
public class UserDaoFactory
public UserDao getUserDao()
return new UserDaoImpl() ;
第三，在spring的配置文件中添加以下内容:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<!-- <bean id="bookDao" class="com.dao.impl.BookDaoImpl"/>-->
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<!-- <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>-->
<!-- 实例工厂配置-->
<bean id="userDaoFactory" class="UserDaoFactory"/>
<bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>
</beans>第四步，编写测试类，获取IOC容器，并使用bean对象执行方法
import com.dao.UserDao;
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class app
public static void main(String[] args)
//获取IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
// //获取bean对象,并执行相应的方法
// BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
// bookDao.save();
// System.out.println("-------------");
// BookService bookService = (BookService) applicationContext.getBean("bookService");
// bookService.save();
// OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
// orderDao.save();
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.save();
3.3、bean的生命周期
关于Spring中对bean生命周期控制提供了两种方式:
在配置文件中的bean标签中添加 init-method 和 destroy-method 属性
类实现 InitializingBean 与 DisposableBean 接口，这种方式了解下即可
下面演示在配置文件中配置去控制bean的生命周期，如下：
第一步，创建接口和实现方法，如下：
public interface BookDao
public void save() ;
public void init() ;
public void destroy() ;
import com.dao.BookDao;
public class BookDaoImpl implements BookDao
public void save()
System.out.println("book dao save ...");
//bean初始化对应的操作
public void init()
System.out.println("bean 初始化...");
//bean销毁前的操作
public void destroy()
System.out.println("bean 销毁...");
第二步，在spring的配置文件中配置bean的初始化方法和销毁方法。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<!-- <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>-->
<!-- 实例工厂配置-->
<!-- <bean id="userDaoFactory" class="UserDaoFactory"/>-->
<!-- <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>-->
</beans>第三步，编写测试类，获取IOC容器，根据bean对象执行相应的方法。
import com.dao.BookDao;
import com.dao.OrderDao;
import com.dao.UserDao;
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class app
public static void main(String[] args)
//获取IOC容器
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
// //获取bean对象,并执行相应的方法
BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
bookDao.save();
applicationContext.close();
// System.out.println("-------------");
// BookService bookService = (BookService) applicationContext.getBean("bookService");
// bookService.save();
// OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
// orderDao.save();
// UserDao userDao = (UserDao) applicationContext.getBean("userDao");
// userDao.save();
四、依赖注入(DI)相关知识
4.1、setter注入
1）需要定义两个接口和接口的实现类（略），在业务层使用setter方法进行注入，可以同时注入多个，如下：
import com.dao.BookDao;
import com.dao.UserDao;
import com.service.BookService;
public class BookServiceImpl implements BookService
BookDao bookDao ;
UserDao userDao ;
public void save()
bookDao.save();
userDao.save();
System.out.println("book service save...");
public void setBookDao(BookDao bookDao)
this.bookDao = bookDao;
public void setUserDao(UserDao userDao)
this.userDao = userDao;
2）在spring的配置文件中对注入的对象进行配置，如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<!-- <bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>-->
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<!-- <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>-->
<!-- 实例工厂配置-->
<!-- <bean id="userDaoFactory" class="UserDaoFactory"/>-->
<!-- <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>-->
<bean id="bookDao" class="com.dao.impl.BookDaoImpl">
<property name="database" value="mysql"/>
<property name="connectionNum" value="10"/>
</bean>
<bean id="userDao" class="com.dao.impl.UserDaoImpl"/>
<bean id="bookService" class="com.service.impl.BookServiceImpl">
<property name="bookDao" ref="bookDao"/>
<property name="userDao" ref="userDao"/>
</bean>
</beans>3）编写测试类，获得IOC容器，通过bean实现方法。
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class app
public static void main(String[] args)
//获取IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
// //获取bean对象,并执行相应的方法
BookService bookService = (BookService) applicationContext.getBean("bookService");
bookService.save();
// applicationContext.close();
// System.out.println("-------------");
// BookService bookService = (BookService) applicationContext.getBean("bookService");
// bookService.save();
// OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
// orderDao.save();
// UserDao userDao = (UserDao) applicationContext.getBean("userDao");
// userDao.save();
4.2、构造器注入
1）创建接口和实现类,如下：
public interface BookDao
public void save() ;
import com.dao.BookDao;
public class BookDaoImpl implements BookDao
private String database ;
private int connectionNum ;
public BookDaoImpl(String database, int connectionNum)
this.database = database;
this.connectionNum = connectionNum;
public void save()
System.out.println("book dao save ...");
System.out.println(database + " " + connectionNum);
public interface UserDao
public void save() ;
import com.dao.UserDao;
public class UserDaoImpl implements UserDao
public void save()
System.out.println("userDao save ...");
2)在业务层，进行构造器注入，如下：
public interface BookService
public void save() ;
import com.dao.BookDao;
import com.dao.UserDao;
import com.service.BookService;
public class BookServiceImpl implements BookService
BookDao bookDao ;
UserDao userDao ;
public BookServiceImpl(BookDao bookDao, UserDao userDao)
this.bookDao = bookDao;
this.userDao = userDao;
public void save()
bookDao.save();
userDao.save();
System.out.println("book service save...");
3）配置spring的配置文件，如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<!-- <bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>-->
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<!-- <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>-->
<!-- 实例工厂配置-->
<!-- <bean id="userDaoFactory" class="UserDaoFactory"/>-->
<!-- <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>-->
<bean id="bookDao" class="com.dao.impl.BookDaoImpl">
<constructor-arg name="database" value="mysql"/>
<constructor-arg name="connectionNum" value="100"/>
</bean>
<bean id="userDao" class="com.dao.impl.UserDaoImpl"/>
<bean id="bookService" class="com.service.impl.BookServiceImpl">
<constructor-arg name="bookDao" ref="bookDao"/>
<constructor-arg name="userDao" ref="userDao"/>
</bean>
</beans>4）编写测试方法，获取IOC，通过bean对象进行方法测试。
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class app
public static void main(String[] args)
//获取IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
// //获取bean对象,并执行相应的方法
BookService bookService = (BookService) applicationContext.getBean("bookService");
bookService.save();
// applicationContext.close();
// System.out.println("-------------");
// BookService bookService = (BookService) applicationContext.getBean("bookService");
// bookService.save();
// OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
// orderDao.save();
// UserDao userDao = (UserDao) applicationContext.getBean("userDao");
// userDao.save();
4.3、自动装配
1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作。
2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用。
3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用。
4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效。
1）使用setter方法进行注入，可以使用自动装配，setter方法注入如下：
import com.dao.BookDao;
import com.dao.UserDao;
import com.service.BookService;
public class BookServiceImpl implements BookService
BookDao bookDao ;
UserDao userDao ;
public void setBookDao(BookDao bookDao)
this.bookDao = bookDao;
public void setUserDao(UserDao userDao)
this.userDao = userDao;
public void save()
bookDao.save();
userDao.save();
System.out.println("book service save...");
2）在配置文件中加上autowire=byType可以实现按照类型进行装配。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<!-- <bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>-->
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<!-- <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>-->
<!-- 实例工厂配置-->
<!-- <bean id="userDaoFactory" class="UserDaoFactory"/>-->
<!-- <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>-->
<bean id="bookDao" class="com.dao.impl.BookDaoImpl">
<constructor-arg name="database" value="mysql"/>
<constructor-arg name="connectionNum" value="100"/>
</bean>
<bean id="userDao" class="com.dao.impl.UserDaoImpl" />
<bean id="bookService" class="com.service.impl.BookServiceImpl" autowire="byType">
</bean>
</beans>3）当然也可以将autowire=byName，按照名称进行装配。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<!-- <bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>-->
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<!-- <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>-->
<!-- 实例工厂配置-->
<!-- <bean id="userDaoFactory" class="UserDaoFactory"/>-->
<!-- <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>-->
<bean id="bookDao" class="com.dao.impl.BookDaoImpl">
<constructor-arg name="database" value="mysql"/>
<constructor-arg name="connectionNum" value="100"/>
</bean>
<bean id="userDao" class="com.dao.impl.UserDaoImpl" />
<bean id="bookService" class="com.service.impl.BookServiceImpl" autowire="byName">
</bean>
</beans>4.4、集合注入
1）定义一个接口，并定义一个接口实现类，在实现类中使用setter方法完成集合注入。
public interface BooksDao
public void save() ;
import java.util.*;
public class BooksDaoImpl implements BooksDao
private int [] array ;
private List<String> list ;
private Set<String> set ;
private Map<String, String> map ;
private Properties properties ;
public void setArray(int[] array)
this.array = array;
public void setList(List<String> list)
this.list = list;
public void setSet(Set<String> set)
this.set = set;
public void setMap(Map<String, String> map)
this.map = map;
public void setProperties(Properties properties)
this.properties = properties;
public void save()
System.out.println("book dao save ...");
System.out.println("遍历数组" + Arrays.toString(array));
System.out.println("遍历list" + list);
System.out.println("遍历set" + set);
System.out.println("遍历map" + map);
System.out.println("遍历properties" + properties);
2）在spring的配置文件中，注入具体的数据，如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<!-- <bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>-->
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<!-- <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>-->
<!-- 实例工厂配置-->
<!-- <bean id="userDaoFactory" class="UserDaoFactory"/>-->
<!-- <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>-->
<bean id="bookDao" class="com.dao.impl.BookDaoImpl">
<constructor-arg name="database" value="mysql"/>
<constructor-arg name="connectionNum" value="100"/>
</bean>
<bean id="booksDao" class="com.dao.impl.BooksDaoImpl">
<!--注入数组类型的数据-->
<property name="array">
<array>
<value>10</value>
<value>20</value>
<value>100</value>
</array>
</property>
<!--注入list类型数据-->
<property name="list">
<list>
<value>baidu</value>
<value>aili</value>
<value>zijie</value>
</list>
</property>
<!--注入set类型数据-->
<property name="set">
<set>
<value>beijing</value>
<value>nanjing</value>
<value>shanghai</value>
</set>
</property>
<!--注入map类型数据-->
<property name="map">
<map>
<entry key="country" value="China"/>
<entry key="province" value="jiangsu"/>
<entry key="city" value="nanjing"/>
</map>
</property>
<!--注入Properties类型数据-->
<property name="properties">
<props>
<prop key="fruit">香蕉</prop>
<prop key="hobby">跑步</prop>
<prop key="running">篮球</prop>
</props>
</property>
</bean>
</beans>3）编写测试类进行测试，获取IOC容器，通过bean对象访问方法。
import com.dao.impl.BooksDao;
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class app
public static void main(String[] args)
//获取IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
// //获取bean对象,并执行相应的方法
BooksDao booksDao = (BooksDao) applicationContext.getBean("booksDao");
booksDao.save();
// applicationContext.close();
// System.out.println("-------------");
// BookService bookService = (BookService) applicationContext.getBean("bookService");
// bookService.save();
// OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
// orderDao.save();
// UserDao userDao = (UserDao) applicationContext.getBean("userDao");
// userDao.save();
五、IOC/DI配置管理第三方bean
5.1、实现c3p0管理
1）在pom.xml文件中导入相关依赖jar包，如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>java02</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.5</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.20</version>
</dependency>
</dependencies>
</project>2）在applicationContext.xml配置文件中配置第三方bean
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<!-- <bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>-->
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<!-- <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>-->
<!-- 实例工厂配置-->
<!-- <bean id="userDaoFactory" class="UserDaoFactory"/>-->
<!-- <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/sping_db"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>
</beans>3）编写测试类，获取IOC容器，进行测试
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.sql.DataSource;
public class app
public static void main(String[] args)
//获取IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
// //获取bean对象,并执行相应的方法
DataSource dataSource = (DataSource) applicationContext.getBean("dataSource");
System.out.println(dataSource);
5.2、实现Druid管理
1）在pom.xml文件中引入druid的jar包的依赖，如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>java02</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
</dependencies>
</project>2）在applicationContext.xml配置文件中配置第三方bean
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- <!–配置bean对象实现控制反转,id是bean的名称,class是表示bean的定义类型–>-->
<!-- <bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>-->
<!-- <bean id="bookService" class="com.service.impl.BookServiceImpl">-->
<!-- <!–name对象参照ref对象–>-->
<!-- <property name="bookDao" ref="bookDao"/>-->
<!-- </bean>-->
<!-- 静态工厂实例配置-->
<!-- <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao"></bean>-->
<!-- 实例工厂配置-->
<!-- <bean id="userDaoFactory" class="UserDaoFactory"/>-->
<!-- <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/sping_db"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
</beans>3）编写测试类测试
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.sql.DataSource;
public class app
public static void main(String[] args)
//获取IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
// //获取bean对象,并执行相应的方法
DataSource dataSource = (DataSource) applicationContext.getBean("dataSource");
System.out.println(dataSource);
5.3、spring加载properties文件
1）resources下创建一个jdbc.properties文件,并添加对应的属性键值对
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root2）开启context命名空间，加载properties配置文件，完成属性注入
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<context:property-placeholder location="jdbc.properties"/>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="$jdbc.driver"/>
<property name="url" value="$jdbc.url"/>
<property name="username" value="$jdbc.username"/>
<property name="password" value="$jdbc.password"/>
</bean>
<bean id="orderDao" class="com.dao.impl.OrderDaoImpl">
<property name="name" value="$jdbc.username"/>
</bean>
</beans>以上是关于JavaEE开发之Spring框架整合1的主要内容，如果未能解决你的问题，请参考以下文章
JAVAEE框架整合技术之spring03-SpringJdbcTemplate模板技术和事务处理