• JavaEE开发之Spring框架整合1

    随着时代发展，软件规模与功能都呈几何式增长，开发难度也在不断递增，该如何解决?
    Spring可以简化开发，降低企业级开发的复杂性，使开发变得更简单快捷随着项目规模与功能的增长,遇到的问题就会增多，为了解决问题会引入更多的框架，这些框架如何协调工作?Spring可以框架整合，高效整合其他技术，提高企业级应用开发与运行效率，综上所述，Spring是一款非常优秀而且功能强大的框架。

    目录

    一、基本概念

    1.1、控制反转(IOC)

    1.2、Spring和IOC之间的关系

    1.3、IOC容器的作用

    1.4、依赖注入(DI)

    二、入门案例

    2.1、IOC入门案例

    2.2、DI入门案例

    三、bean的相关知识

    3.1、bean的作用范围

    3.2、bean的三种实例化方式

    3.3、bean的生命周期

    四、依赖注入(DI)相关知识

    4.1、setter注入

    4.2、构造器注入

    4.3、自动装配

    4.4、集合注入

    五、IOC/DI配置管理第三方bean

    5.1、实现c3p0管理

    5.2、实现Druid管理

    5.3、spring加载properties文件

    一、基本概念

    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包，如下：

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.  
    7.     <groupId>org.examplegroupId>
    8.     <artifactId>java02artifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.  
    11.     <dependencies>
    12.         <dependency>
    13.             <groupId>org.springframeworkgroupId>
    14.             <artifactId>spring-contextartifactId>
    15.             <version>5.2.10.RELEASEversion>
    16.         dependency>
    17.     dependencies>
    18.  
    19.  
    20. project>

    2）创建数据访问层(dao)和业务层(service)的接口和接口实现类，如下：

    1. public interface BookDao {
    2.     public void save() ;
    3. }
    1. import com.dao.BookDao;
    2.  
    3. public class BookDaoImpl implements BookDao {
    4.     public void save() {
    5.         System.out.println("book dao save ...");
    6.     }
    7. }
    1. public interface BookService {
    2.     public void save() ;
    3. }
    1. import com.dao.BookDao;
    2. import com.dao.impl.BookDaoImpl;
    3. import com.service.BookService;
    4.  
    5. public class BookServiceImpl implements BookService {
    6.     BookDao bookDao = new BookDaoImpl() ;
    7.     public void save() {
    8.         bookDao.save();
    9.         System.out.println("book service save...");
    10.     }
    11. }

    3)添加spring的配置文件applicationContext.xml，在配置文件中配置bean对象，这样IOC容器就可以管理bean对象，通过bean对象实现控制反转。

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    6.     
    7.     <bean id="bookDao" class="com.dao.impl.BookDaoImpl"/>
    8.     <bean id="bookService" class="com.service.impl.BookServiceImpl"/>
    9. beans>

    4）编写测试类实现获取IOC容器，并通过bean对象调用相应的方法。

    1. import com.dao.BookDao;
    2. import com.service.BookService;
    3. import org.springframework.context.ApplicationContext;
    4. import org.springframework.context.support.ClassPathXmlApplicationContext;
    5.  
    6. public class app {
    7.     public static void main(String[] args) {
    8.         //获取IOC容器
    9.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
    10.         //获取bean对象,并执行相应的方法
    11.         BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
    12.         bookDao.save();
    13.         System.out.println("-------------");
    14.         BookService bookService = (BookService) applicationContext.getBean("bookService");
    15.         bookService.save();
    16.     }
    17. }

    2.2、DI入门案例

    1）将上述业务层的new方法删除，并提供对应的setter方法。

    1. import com.dao.BookDao;
    2. import com.service.BookService;
    3.  
    4. public class BookServiceImpl implements BookService {
    5.     BookDao bookDao  ;
    6.     public void save() {
    7.         bookDao.save();
    8.         System.out.println("book service save...");
    9.     }
    10.  
    11.     public void setBookDao(BookDao bookDao) {
    12.         this.bookDao = bookDao;
    13.     }
    14. }

    2）在配置文件中添加依赖注入的配置。配置文件中两个bookDao的含义不同，name="bookDao"中 bookDao 的作用是让Spring的IOC容器在获取到名称后，将首字母大写，前
    面加set找对应的 setBookDao() 方法进行对象注入。ref="bookDao"中 bookDao 的作用是让Spring能在IOC容器中找到id为 bookDao 的Bean对象给bookService 进行注入。

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    6.     
    7.     <bean id="bookDao" class="com.dao.impl.BookDaoImpl"/>
    8.     <bean id="bookService" class="com.service.impl.BookServiceImpl">
    9.         
    10.         <property name="bookDao" ref="bookDao"/>
    11.     bean>
    12. 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的实例化。

    1. import com.dao.BookDao;
    2.  
    3. public class BookDaoImpl implements BookDao {
    4.     public BookDaoImpl(){
    5.         System.out.println("构造方法实例化");
    6.     }
    7.     public void save() {
    8.         System.out.println("book dao save ...");
    9.     }
    10. }

    2）静态工厂实例化

    第一步，创建一个接口和实现类，如下：

    1. public interface OrderDao {
    2.     public void save() ;
    3. }
    1. import com.dao.OrderDao;
    2.  
    3. public class OrderDaoImpl implements OrderDao {
    4.     public void save() {
    5.         System.out.println("oderDao save ...");
    6.     }
    7. }

    第二步，创建一个工厂类OrderDaoFactory并提供一个静态方法

    1. import com.dao.OrderDao;
    2. import com.dao.impl.OrderDaoImpl;
    3.  
    4. public class OrderDaoFactory {
    5.     public static OrderDao getOrderDao(){
    6.         System.out.println("静态工厂实例化");
    7.         return new OrderDaoImpl() ;
    8.     }
    9. }
    10.

    第三步，在spring的配置文件application.properties中添加以下内容：

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    12.  
    14.     <bean id="OrderDao" class="OrderDaoFactory" factory-method="getOrderDao">bean>
    15. beans>

    第四步，编写运行类，使用从IOC容器中获取bean的方法进行运行测试

    1. import com.dao.OrderDao;
    2. import com.service.BookService;
    3. import org.springframework.context.ApplicationContext;
    4. import org.springframework.context.support.ClassPathXmlApplicationContext;
    5.  
    6. public class app {
    7.     public static void main(String[] args) {
    8.         //获取IOC容器
    9.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
    10. //        //获取bean对象,并执行相应的方法
    11. //        BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
    12. //        bookDao.save();
    13. //        System.out.println("-------------");
    14. //        BookService bookService = (BookService) applicationContext.getBean("bookService");
    15. //        bookService.save();
    16.         OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
    17.         orderDao.save();
    18.     }
    19. }

    3）实例工厂实例化

    第一步，创建一个接口和一个实现类，如下：

    1. public interface UserDao {
    2.     public void save() ;
    3. }
    1. import com.dao.UserDao;
    2.  
    3. public class UserDaoImpl implements UserDao {
    4.     public void save() {
    5.         System.out.println("userDao save ...");
    6.     }
    7. }

    第二步，创建工厂类，并提供实例方法，如下：

    1. import com.dao.UserDao;
    2. import com.dao.impl.UserDaoImpl;
    3.  
    4. public class UserDaoFactory {
    5.     public UserDao getUserDao(){
    6.         return new UserDaoImpl() ;
    7.     }
    8. }

    第三，在spring的配置文件中添加以下内容:

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    12.  
    16.     <bean id="userDaoFactory" class="UserDaoFactory"/>
    17.     <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>
    18. beans>

    第四步，编写测试类，获取IOC容器，并使用bean对象执行方法

    1. import com.dao.UserDao;
    2. import com.service.BookService;
    3. import org.springframework.context.ApplicationContext;
    4. import org.springframework.context.support.ClassPathXmlApplicationContext;
    5.  
    6. public class app {
    7.     public static void main(String[] args) {
    8.         //获取IOC容器
    9.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
    10. //        //获取bean对象,并执行相应的方法
    11. //        BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
    12. //        bookDao.save();
    13. //        System.out.println("-------------");
    14. //        BookService bookService = (BookService) applicationContext.getBean("bookService");
    15. //        bookService.save();
    16. //        OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
    17. //        orderDao.save();
    18.         UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    19.         userDao.save();
    20.     }
    21. }

    3.3、bean的生命周期

    关于Spring中对bean生命周期控制提供了两种方式:
    在配置文件中的bean标签中添加 init-method 和 destroy-method 属性
    类实现 InitializingBean 与 DisposableBean 接口，这种方式了解下即可

    下面演示在配置文件中配置去控制bean的生命周期，如下：
    第一步，创建接口和实现方法，如下：

    1. public interface BookDao {
    2.     public void save() ;
    3.     public void init() ;
    4.     public void destroy() ;
    5. }
    1. import com.dao.BookDao;
    2.  
    3. public class BookDaoImpl implements BookDao {
    4.  
    5.     public void save() {
    6.         System.out.println("book dao save ...");
    7.     }
    8.     //bean初始化对应的操作
    9.     public void init(){
    10.         System.out.println("bean 初始化...");
    11.     }
    12.     //bean销毁前的操作
    13.     public void destroy(){
    14.         System.out.println("bean 销毁...");
    15.     }
    16. }

    第二步，在spring的配置文件中配置bean的初始化方法和销毁方法。

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    7.    <bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>
    12.  
    18. beans>

    第三步，编写测试类，获取IOC容器，根据bean对象执行相应的方法。

    1. import com.dao.BookDao;
    2. import com.dao.OrderDao;
    3. import com.dao.UserDao;
    4. import com.service.BookService;
    5. import org.springframework.context.ApplicationContext;
    6. import org.springframework.context.support.ClassPathXmlApplicationContext;
    7.  
    8. public class app {
    9.     public static void main(String[] args) {
    10.         //获取IOC容器
    11.         ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
    12. //        //获取bean对象,并执行相应的方法
    13.         BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
    14.         bookDao.save();
    15.         applicationContext.close();
    16. //        System.out.println("-------------");
    17. //        BookService bookService = (BookService) applicationContext.getBean("bookService");
    18. //        bookService.save();
    19. //        OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
    20. //        orderDao.save();
    21. //        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    22. //        userDao.save();
    23.     }
    24. }

    四、依赖注入(DI)相关知识

    4.1、setter注入

    1）需要定义两个接口和接口的实现类（略），在业务层使用setter方法进行注入，可以同时注入多个，如下：

    1. import com.dao.BookDao;
    2. import com.dao.UserDao;
    3. import com.service.BookService;
    4.  
    5. public class BookServiceImpl implements BookService {
    6.     BookDao bookDao  ;
    7.     UserDao userDao ;
    8.     public void save() {
    9.         bookDao.save();
    10.         userDao.save();
    11.         System.out.println("book service save...");
    12.     }
    13.  
    14.     public void setBookDao(BookDao bookDao) {
    15.         this.bookDao = bookDao;
    16.     }
    17.  
    18.     public void setUserDao(UserDao userDao) {
    19.         this.userDao = userDao;
    20.     }
    21. }

    2）在spring的配置文件中对注入的对象进行配置，如下：

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    12.  
    18.    <bean id="bookDao" class="com.dao.impl.BookDaoImpl">
    19.       <property name="database" value="mysql"/>
    20.       <property name="connectionNum" value="10"/>
    21.    bean>
    22.    <bean id="userDao" class="com.dao.impl.UserDaoImpl"/>
    23.    <bean id="bookService" class="com.service.impl.BookServiceImpl">
    24.       <property name="bookDao" ref="bookDao"/>
    25.       <property name="userDao" ref="userDao"/>
    26.    bean>
    27.    
    28. beans>

    3）编写测试类，获得IOC容器，通过bean实现方法。

    1. import com.service.BookService;
    2. import org.springframework.context.ApplicationContext;
    3. import org.springframework.context.support.ClassPathXmlApplicationContext;
    4.  
    5. public class app {
    6.     public static void main(String[] args) {
    7.         //获取IOC容器
    8.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
    9. //        //获取bean对象,并执行相应的方法
    10.         BookService bookService = (BookService) applicationContext.getBean("bookService");
    11.         bookService.save();
    12. //        applicationContext.close();
    13. //        System.out.println("-------------");
    14. //        BookService bookService = (BookService) applicationContext.getBean("bookService");
    15. //        bookService.save();
    16. //        OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
    17. //        orderDao.save();
    18. //        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    19. //        userDao.save();
    20.     }
    21. }

    4.2、构造器注入

    1）创建接口和实现类,如下：

    1. public interface BookDao {
    2.     public void save() ;
    3. }
    1. import com.dao.BookDao;
    2.  
    3. public class BookDaoImpl implements BookDao {
    4.     private String database ;
    5.     private int connectionNum ;
    6.  
    7.     public BookDaoImpl(String database, int connectionNum) {
    8.         this.database = database;
    9.         this.connectionNum = connectionNum;
    10.     }
    11.  
    12.     public void save() {
    13.         System.out.println("book dao save ...");
    14.         System.out.println(database + "  " + connectionNum);
    15.     }
    16.  
    17. }
    1. public interface UserDao {
    2.     public void save() ;
    3. }

    1. import com.dao.UserDao;
    2.  
    3. public class UserDaoImpl implements UserDao {
    4.     public void save() {
    5.         System.out.println("userDao save ...");
    6.     }
    7.  
    8.  
    9. }

    2)在业务层，进行构造器注入，如下：

    1. public interface BookService {
    2.     public void save() ;
    3. }
    1. import com.dao.BookDao;
    2. import com.dao.UserDao;
    3. import com.service.BookService;
    4.  
    5. public class BookServiceImpl implements BookService {
    6.     BookDao bookDao  ;
    7.     UserDao userDao ;
    8.  
    9.     public BookServiceImpl(BookDao bookDao, UserDao userDao) {
    10.         this.bookDao = bookDao;
    11.         this.userDao = userDao;
    12.     }
    13.  
    14.     public void save() {
    15.         bookDao.save();
    16.         userDao.save();
    17.         System.out.println("book service save...");
    18.     }
    19.  
    20. }

    3）配置spring的配置文件，如下：

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    12.  
    18.    <bean id="bookDao" class="com.dao.impl.BookDaoImpl">
    19.       <constructor-arg name="database" value="mysql"/>
    20.       <constructor-arg name="connectionNum" value="100"/>
    21.    bean>
    22.    <bean id="userDao" class="com.dao.impl.UserDaoImpl"/>
    23.    <bean id="bookService" class="com.service.impl.BookServiceImpl">
    24.       <constructor-arg name="bookDao" ref="bookDao"/>
    25.       <constructor-arg name="userDao" ref="userDao"/>
    26.    bean>
    27.  
    28. beans>

    4）编写测试方法，获取IOC，通过bean对象进行方法测试。

    1. import com.service.BookService;
    2. import org.springframework.context.ApplicationContext;
    3. import org.springframework.context.support.ClassPathXmlApplicationContext;
    4.  
    5. public class app {
    6.     public static void main(String[] args) {
    7.         //获取IOC容器
    8.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
    9. //        //获取bean对象,并执行相应的方法
    10.         BookService bookService = (BookService) applicationContext.getBean("bookService");
    11.         bookService.save();
    12. //        applicationContext.close();
    13. //        System.out.println("-------------");
    14. //        BookService bookService = (BookService) applicationContext.getBean("bookService");
    15. //        bookService.save();
    16. //        OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
    17. //        orderDao.save();
    18. //        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    19. //        userDao.save();
    20.     }
    21. }

    4.3、自动装配

    1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作。
    2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用。
    3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用。
    4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效。

    1）使用setter方法进行注入，可以使用自动装配，setter方法注入如下：

    1. import com.dao.BookDao;
    2. import com.dao.UserDao;
    3. import com.service.BookService;
    4.  
    5. public class BookServiceImpl implements BookService {
    6.     BookDao bookDao  ;
    7.     UserDao userDao ;
    8.  
    9.     public void setBookDao(BookDao bookDao) {
    10.         this.bookDao = bookDao;
    11.     }
    12.  
    13.     public void setUserDao(UserDao userDao) {
    14.         this.userDao = userDao;
    15.     }
    16.  
    17.     public void save() {
    18.         bookDao.save();
    19.         userDao.save();
    20.         System.out.println("book service save...");
    21.     }
    22.  
    23. }

    2）在配置文件中加上autowire=byType可以实现按照类型进行装配。

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    12.  
    18.    <bean id="bookDao" class="com.dao.impl.BookDaoImpl">
    19.       <constructor-arg name="database" value="mysql"/>
    20.       <constructor-arg name="connectionNum" value="100"/>
    21.    bean>
    22.    <bean id="userDao" class="com.dao.impl.UserDaoImpl" />
    23.    <bean id="bookService" class="com.service.impl.BookServiceImpl" autowire="byType">
    24.    bean>
    25.  
    26. beans>

    3）当然也可以将autowire=byName，按照名称进行装配。

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    12.  
    18.    <bean id="bookDao" class="com.dao.impl.BookDaoImpl">
    19.       <constructor-arg name="database" value="mysql"/>
    20.       <constructor-arg name="connectionNum" value="100"/>
    21.    bean>
    22.    <bean id="userDao" class="com.dao.impl.UserDaoImpl" />
    23.    <bean id="bookService" class="com.service.impl.BookServiceImpl" autowire="byName">
    24.    bean>
    25.  
    26. beans>

    4.4、集合注入

    1）定义一个接口，并定义一个接口实现类，在实现类中使用setter方法完成集合注入。

    1.  
    2. public interface BooksDao {
    3.     public void save() ;
    4. }
    1. import java.util.*;
    2. public class BooksDaoImpl implements BooksDao {
    3.     private int [] array ;
    4.     private List list ;
    5.     private Set set ;
    6.     private Map map ;
    7.     private Properties properties ;
    8.  
    9.     public void setArray(int[] array) {
    10.         this.array = array;
    11.     }
    12.  
    13.     public void setList(List list) {
    14.         this.list = list;
    15.     }
    16.  
    17.     public void setSet(Set set) {
    18.         this.set = set;
    19.     }
    20.  
    21.     public void setMap(Map map) {
    22.         this.map = map;
    23.     }
    24.  
    25.     public void setProperties(Properties properties) {
    26.         this.properties = properties;
    27.     }
    28.  
    29.     public void save() {
    30.         System.out.println("book dao save ...");
    31.         System.out.println("遍历数组" + Arrays.toString(array));
    32.         System.out.println("遍历list" + list);
    33.         System.out.println("遍历set" + set);
    34.         System.out.println("遍历map" + map);
    35.         System.out.println("遍历properties" + properties);
    36.     }
    37. }

    2）在spring的配置文件中，注入具体的数据，如下：

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    12.  
    18.    <bean id="bookDao" class="com.dao.impl.BookDaoImpl">
    19.       <constructor-arg name="database" value="mysql"/>
    20.       <constructor-arg name="connectionNum" value="100"/>
    21.    bean>
    22.    <bean id="booksDao" class="com.dao.impl.BooksDaoImpl">
    23.       
    24.       <property name="array">
    25.          <array>
    26.             <value>10value>
    27.             <value>20value>
    28.             <value>100value>
    29.          array>
    30.       property>
    31.       
    32.       <property name="list">
    33.          <list>
    34.             <value>baiduvalue>
    35.             <value>ailivalue>
    36.             <value>zijievalue>
    37.          list>
    38.       property>
    39.       
    40.       <property name="set">
    41.          <set>
    42.             <value>beijingvalue>
    43.             <value>nanjingvalue>
    44.             <value>shanghaivalue>
    45.          set>
    46.       property>
    47.       
    48.       <property name="map">
    49.          <map>
    50.            <entry key="country" value="China"/>
    51.             <entry key="province" value="jiangsu"/>
    52.             <entry key="city" value="nanjing"/>
    53.          map>
    54.       property>
    55.       
    56.       <property name="properties">
    57.          <props>
    58.             <prop key="fruit">香蕉prop>
    59.             <prop key="hobby">跑步prop>
    60.             <prop key="running">篮球prop>
    61.          props>
    62.       property>
    63.  
    64.    bean>
    65.  
    66. beans>

    3）编写测试类进行测试，获取IOC容器，通过bean对象访问方法。

    1. import com.dao.impl.BooksDao;
    2. import com.service.BookService;
    3. import org.springframework.context.ApplicationContext;
    4. import org.springframework.context.support.ClassPathXmlApplicationContext;
    5.  
    6. public class app {
    7.     public static void main(String[] args) {
    8.         //获取IOC容器
    9.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
    10. //        //获取bean对象,并执行相应的方法
    11.         BooksDao booksDao = (BooksDao) applicationContext.getBean("booksDao");
    12.         booksDao.save();
    13. //        applicationContext.close();
    14. //        System.out.println("-------------");
    15. //        BookService bookService = (BookService) applicationContext.getBean("bookService");
    16. //        bookService.save();
    17. //        OrderDao orderDao = (OrderDao) applicationContext.getBean("OrderDao");
    18. //        orderDao.save();
    19. //        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    20. //        userDao.save();
    21.     }
    22. }

    五、IOC/DI配置管理第三方bean

    5.1、实现c3p0管理

    1）在pom.xml文件中导入相关依赖jar包，如下：

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.  
    7.     <groupId>org.examplegroupId>
    8.     <artifactId>java02artifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.  
    11.     <dependencies>
    12.         <dependency>
    13.             <groupId>org.springframeworkgroupId>
    14.             <artifactId>spring-contextartifactId>
    15.             <version>5.2.10.RELEASEversion>
    16.         dependency>
    17.  
    18.         
    19.         <dependency>
    20.             <groupId>com.mchangegroupId>
    21.             <artifactId>c3p0artifactId>
    22.             <version>0.9.5.5version>
    23.         dependency>
    24.         
    25.         <dependency>
    26.             <groupId>mysqlgroupId>
    27.             <artifactId>mysql-connector-javaartifactId>
    28.             <version>8.0.20version>
    29.         dependency>
    30.  
    31.  
    32.     dependencies>
    33.  
    34.  
    35.  
    36.  
    37. project>

    2）在applicationContext.xml配置文件中配置第三方bean

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    12.  
    18.  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    19.     <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    20.     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/sping_db"/>
    21.     <property name="user" value="root"/>
    22.     <property name="password" value="root"/>
    23.  bean>
    24.  
    25. beans>

    3）编写测试类，获取IOC容器，进行测试

    1. import org.springframework.context.ApplicationContext;
    2. import org.springframework.context.support.ClassPathXmlApplicationContext;
    3.  
    4. import javax.sql.DataSource;
    5.  
    6. public class app {
    7.     public static void main(String[] args) {
    8.         //获取IOC容器
    9.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
    10. //        //获取bean对象,并执行相应的方法
    11.         DataSource dataSource = (DataSource) applicationContext.getBean("dataSource");
    12.         System.out.println(dataSource);
    13.  
    14.  
    15.     }
    16. }

    5.2、实现Druid管理

    1）在pom.xml文件中引入druid的jar包的依赖，如下：

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.  
    7.     <groupId>org.examplegroupId>
    8.     <artifactId>java02artifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.  
    11.     <dependencies>
    12.         <dependency>
    13.             <groupId>org.springframeworkgroupId>
    14.             <artifactId>spring-contextartifactId>
    15.             <version>5.2.10.RELEASEversion>
    16.         dependency>
    17.  
    18.         
    19.         <dependency>
    20.             <groupId>com.alibabagroupId>
    21.             <artifactId>druidartifactId>
    22.             <version>1.1.16version>
    23.         dependency>
    24.     dependencies>
    25.     
    26. project>

    2）在applicationContext.xml配置文件中配置第三方bean

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    12.  
    18.  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    19.     <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    20.     <property name="url" value="jdbc:mysql://localhost:3306/sping_db"/>
    21.     <property name="username" value="root"/>
    22.     <property name="password" value="root"/>
    23.  bean>
    24.  
    25. beans>

    3）编写测试类测试

    1. import org.springframework.context.ApplicationContext;
    2. import org.springframework.context.support.ClassPathXmlApplicationContext;
    3.  
    4. import javax.sql.DataSource;
    5.  
    6. public class app {
    7.     public static void main(String[] args) {
    8.         //获取IOC容器
    9.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
    10. //        //获取bean对象,并执行相应的方法
    11.         DataSource dataSource = (DataSource) applicationContext.getBean("dataSource");
    12.         System.out.println(dataSource);
    13.  
    14.  
    15.     }
    16. }

    5.3、spring加载properties文件

    1）resources下创建一个jdbc.properties文件,并添加对应的属性键值对

    1. jdbc.driver=com.mysql.jdbc.Driver
    2. jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
    3. jdbc.username=root
    4. jdbc.password=root

    2）开启context命名空间，加载properties配置文件，完成属性注入

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        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">
    6.     <context:property-placeholder location="jdbc.properties"/>
    7.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    8.     <property name="driverClassName" value="${jdbc.driver}"/>
    9.     <property name="url" value="${jdbc.url}"/>
    10.     <property name="username" value="${jdbc.username}"/>
    11.     <property name="password" value="${jdbc.password}"/>
    12.     bean>
    13.     <bean id="orderDao" class="com.dao.impl.OrderDaoImpl">
    14.         <property name="name" value="${jdbc.username}"/>
    15.     bean>
    16.  
    17. beans>
  • 相关阅读:
    【FreeRTOS（八）】二值信号量
    STM32CubeMX教程23 FSMC - IS62WV51216(SRAM)驱动
    containerd 镜像构建工具 -- nerdctl 和 buildkit
    硬件基础 - MOS管
    docker容器内缺少命令的解决办法
    CLIPBERT(2021 CVPR)
    现代信号处理——自适应滤波器（卡尔曼滤波）
    Keil setting issue
    C 开源库之cJSON
    PMSM中常用的两种坐标变换——两种参数的由来
  • 原文地址：https://blog.csdn.net/nuist_NJUPT/article/details/126597307