Spring笔记上（基于XML配置）

爱被打了一巴掌 2023-09-24 16:21 42阅读 0赞

![在这里插入图片描述][a6b6700f37544dc28ed3e939149f5d18.png]

> 新年快乐。

#### 文章目录 ####

*  一、Spring概述
 *   *  1. 为什么要用Spring框架？
     *  2. Spring介绍
 *  二、IOC/DI快速入门
 *   *  1. IOC控制反转
     *  2. DI依赖注入
 *  三、Bean的配置
 *   *  1. Bean的基础配置
     *  2. Bean的别名配置
     *  3. Bean的作用范围配置
 *  四、Bean的实例化
 *   *  1. 构造方法方式
     *  2. 静态工厂方式
     *  3. 实例工厂方式
     *  4. 实现FactoryBean\\<T>方式
 *  五、Bean的生命周期
 *   *  1. Bean的生命周期控制
     *   *  1.1 提供生命周期控制方法
         *  1.2 实现InitializingBean，DisposableBean接口
     *  2. bean的生命周期控制执行流程
     *  3. Bean的销毁时机
 *  六、依赖注入(DI配置)
 *   *  1.依赖的注入方式
     *   *  1.1 setter方式注入
         *   *  使用set方式注入引用类型（property-ref）
             *  使用set方式注入简单类型（property-value）
         *  1.2 构造方式注入
         *   *  使用构造方式注入引用类型（ constructor-arg--ref）
             *  使用构造方式注入简单类型（ constructor-arg--value）
             *  参数适配（扩展）
     *  2. 依赖自动装配
     *  3. 集合注入
     *   *  3.1 注入数组类型数据
         *  3.2 注入List类型数据
         *  3.3 注入Set类型数据
         *  3.4 注入Map类型数据
         *  3.5 注入Properties类型数据

![在这里插入图片描述][91b1ab2841cd4defb67375d5a8347664.png_pic_center]

## 一、Spring概述 ##

--------------------

### 1. 为什么要用Spring框架？ ###

--------------------

*  Spring 是一款轻量级、非侵入式的开源框架，企业用的人非常多，或者解耦合。
 *  Spring可以简化开发，降低企业级开发的复杂度。（IOC控制反转、AOP面向切面编程）
 *  Spring可以和许多优秀的框架整合(MyBatis、MP、Struts2、Hibernate、Junit、JPA等等)。

Spring框架应该怎么学：学Spring框架设计思想和基本使用。

### 2. Spring介绍 ###

--------------------

> Spring官网：https://spring.io/

> Spring文档地址：https://docs.spring.io/spring-framework/docs/5.2.10.RELEASE/spring-framework-reference/core.html\#spring-core

![在这里插入图片描述][2cb3e704c0254d1081fa0b290349d629.png]

Spring 是 JavaEE 领域的一款轻量级、非侵入式的开源框架，该框架由Rod Johnson于 2002 年提出并随后创建（最初版本是interface21）。其目的是为了简化Java企业级应用程序开发的复杂度（简单来讲是解耦合）。

Spring是一个开源容器框架，它集成各类型的工具，通过核心的BeanFactory实现了底层的类的实例化和生命周期的管理。在整个框架中，各类型的功能被抽象成一个个的 Bean，这样就可以实现各种功能的管理，包括动态加载和切面编程。

Spring两大特性：IOC控制反转、AOP面向切面编程。

IOC（Inversion of Control）：控制反转。

*  IoC思想：把之前自己主动new对象的过程，转换成`外部`提供对象，然后对象创建控制权由`自己`转移到`外部`，这就是控制反转。
 *  Spring提供了一个容器，称为IOC容器，用来充当IoC思想中的 ''外部"。
 *  IOC容器负责对象的创建、初始化等，被创建或被管理的对象在IoC容器中统称为Bean。
 *  控制反转，就是把创建对象的权利交给 Spring管理，我们从Spring中获取对象使用即可。

DI（Dependency Injection）：依赖注入，在IoC容器内将有依赖关系的bean进行关系绑定。（成员变量有两种注入方式：set、构造方法）

AOP：面向切面编程，AOP 用来封装多个类的公共行为，将那些与业务无关，却为业务模块所共同调用的逻辑封装起来，减少系统的重复代码，降低模块间的耦合度。另外，AOP 还解决一些系统层面上的问题，比如日志、事务处理、权限等。

> Spring生态

![在这里插入图片描述][918df6a1ae57478aba44f00778f2e60a.png]

*  Spring Framework（Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基）。
 *  Spring MVC（ Web应用开发）。
 *  SpringBoot（它为 Spring 以及第三方库提供一些开箱即用的配置，简化 Spring 应用的搭建及开发过程）。
 *  SpringCloud（基于 Spring Boot 实现的微服务框架。它并不是某一门技术，而是一系列微服务解决方案或框架的有序集合。它将市面上成熟的、经过验证的微服务框架整合起来，并通过 Spring Boot 的思想进行再封装，屏蔽掉其中复杂的配置和实现原理，最终为开发人员提供了一套简单易懂、易部署和易维护的分布式系统开发工具包）。
 *  Spring Data （数据访问模块，对JDBC和ORM提供了很好的支持。通过它，开发人员可以使用一种相对统一的方式，来访问位于不同类型数据库中的数据）。
 *  Spring Security （前身 Acegi，是 Spring 中较成熟的子模块之一，它是一款可以定制化的身份验证和访问控制框架）。

…

> Spring Framework系统架构图

Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基。

![在这里插入图片描述][5eec9fb9a98b446b8503314860b36d3b.png]

## 二、IOC/DI快速入门 ##

--------------------

### 1. IOC控制反转 ###

--------------------

> IOC：控制反转，将bean的创建权交给spring管理。

> 问题分析：

*  哪些对象需要管理？(service与dao)
 *  如何将被管理的对象告知IOC容器？(配置文件或注解)
 *  被管理的对象交给IOC容器，如何获取到IoC容器？(使用Spring提供的API)
 *  IOC容器得到后，如何从容器中获取bean？(使用Spring提供的API)
 *  使用Spring需要导入哪些依赖坐标？（spring-context）

> IOC快速入门：

1、创建一个maven工程。

![在这里插入图片描述][918090cd43d34ee89db0a6a13a3400d7.png]

![在这里插入图片描述][08bf935248e642fe8522d0100b413fe7.png]

2、导入Spring依赖坐标。

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>

![在这里插入图片描述][e57e7515823f4206aa8c8961fc3eb4e7.png]

![在这里插入图片描述][575057e8a0a14d0db8c76fa63b2984cd.png]

3、定义Spring管理的类（接口和实现类）

(1) 编写BookDao接口和BookDaoImpl实现类

package com.baidou.dao;
    public interface BookDao {
        
        void save();
    }

package com.baidou.dao;
    
    public class BookDaoImpl implements BookDao {
        
        @Override
        public void save() {
        
            System.out.println("bookDao save~");
        }
    }

![在这里插入图片描述][1f501675cc854429b69e6cad2b9af126.png]

(2) 编写BookService接口和BookServiceImpl实现类

package com.baidou.service;
    
    public interface BookService {
        
        void save();
    }

package com.baidou.service;
    
    import com.baidou.dao.BookDao;
    import com.baidou.dao.BookDaoImpl;
    
    public class BookServiceImpl implements BookService {
        
    	// 传统的依赖注入写法:直接在成员变量处创建对象、为成员变量提供set方法、通过构造器为成员变量初始化
        private BookDao bookDao = new BookDaoImpl(); 
        
        @Override
        public void save() {
        
            System.out.println("bookService save...");
            bookDao.save();
        }
    }

![在这里插入图片描述][778a7fa349134ab49c6ca4b6ff4da6c1.png]

4、创建spring配置文件，配置spring管理的bean对象。

![在这里插入图片描述][05c77cc1a7f14d76841c320bf41ddecb.png]

定义applicationContext.xml配置文件，并对并BookServiceImpl进行配置。

![在这里插入图片描述][f854f4fd8242415e802a60c6900a65b8.png]

注意事项：bean定义时，id属性在同一个spring配置文件(IOC容器中)不能重复出现。

5、初始化IOC容器（Spring容器），通过容器获取Bean对象。

package com.baidou;
    
    import com.baidou.service.BookService;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Application {
        
        public static void main(String[] args) {
        
            // 1.创建IoC容器对象,加载spring核心配置文件
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            //System.out.println(ctx);//org.springframework.context.support.ClassPathXmlApplicationContext@1d56ce6a 表示ioc容器对象已经成功创建
    
            // 2. 从IOC容器中获取Bean对象  (例如我们配置的BookService对象)
            BookService bookService = (BookService) ctx.getBean("bookService"); // 通过id获取bean
                                             // 也可以通过name获取bean
            							  // 也可以通过类型获取bean: ctx.getBean(BookService.class)
    
            // 3.调用Bean对象(BookService对象)的方法
            bookService.save();
        }
    }

![在这里插入图片描述][7cdfc2de6c314304b4e9a29bd7f31722.png]

### 2. DI依赖注入 ###

--------------------

> DI：依赖注入，在spring容器中将bean的依赖关系绑定。（给bean设置成员变量）

DI使用分析：

*  基于IoC管理bean。
 *  service中需要使用dao对象，如何引入？（提供方法，set方法或者构造器）
 *  通过一些配置来描述service和dao之间的关系。

> DI快速入门：

1、为成员变量提供setter方法

package com.baidou.service;
    
    import com.baidou.dao.BookDao;
    import com.baidou.dao.BookDaoImpl;
    
    public class BookServiceImpl implements BookService {
        
    	
        //   private BookDao bookDao=new BookDaoImpl();
        private BookDao bookDao;
    
        // 提供set方法
        public void setBookDao(BookDao bookDao) {
        
            this.bookDao = bookDao;
        }
    
        @Override
        public void save() {
        
            System.out.println("bookService save...");
            bookDao.save();
        }
    }

![在这里插入图片描述][a10c092c3b5e49bc82a170e507f382dd.png]

2、在spring配置文件中，配置service与dao的依赖关系。

<?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="bookService" class="com.baidou.service.BookServiceImpl">
            
            
            <property name="bookDao" ref="bookDao"/>
        </bean>
    
        
        <bean id="bookDao" class="com.baidou.dao.BookDaoImpl"></bean>
    
    </beans>

注意：在spring中通过setter注入的属性的话，就必须为该属性提供对应的set方法。

3、测试

![在这里插入图片描述][374485ff61cd480b99fa6813747fcdce.png]

## 三、Bean的配置 ##

--------------------

### 1. Bean的基础配置 ###

--------------------

*  bean标签的作用：定义bean对象，让Sring容器管理。这个标签所属beans标签。
 *  id属性：bean的id，在容器中通过id值获取对应的bean，在一个容器中id值是唯一的。
 *  class属性：bean的类型，即配置bean的全路径类名。

### 2. Bean的别名配置 ###

--------------------

我们知道bean标签的id属性可以定义bean的名字，那么name属性就可以定义bean的**别名**。

bean的别名可以定义多个，多个别名之间用 逗号(,)、分号(; ) 、空格分隔。

注意：无论通过id还是name获取bean，如果容器中找不到bean，就会抛出异常：NoSuchBeanDefinitionException。（没有这样的bean）

![在这里插入图片描述][360b860ce4474178ad4288e2937d8699.png]

示例：别名的使用

![在这里插入图片描述][60b6d6ddd2624a20abbd95d688151ac0.png]

![在这里插入图片描述][688df56fd86e4d4193cbb6dce9c41536.png]

### 3. Bean的作用范围配置 ###

--------------------

通过bean标签的**scope属性**定义bean作用范围，常用的scope属性值有：

*  singleton：单例（ioc容器管理的对象默认是单例的，就不用配置scope属性）
 *  prototype：非单例（需要配置scope属性，表示每次都能获取不同的对象，通过地址值判断）

扩展：scope的取值不仅仅只有singleton和prototype，还有request、session、global session等 ，表示创建出的对象放置在web容器(tomcat)对应的位置。比如：request表示保存到request域中。

示例：

![在这里插入图片描述][b8437a1cc0144411bf161d8c2a6f0d24.png]

![在这里插入图片描述][4fdeb48265fc4b308cefb869d7180327.png]

> 小结

bean的配置：

*  scope:作用范围(单实例还是多实例) 默认单实例。
 *  name:别名。（不常用）
 *  init-method和destory-method:生命周期。（了解即可）

## 四、Bean的实例化 ##

--------------------

> 传统创建对象的方式：
> 
>  *  new 类名() ; // 调用无参构造器。
>  *  工厂类.方法()； // 调用某个类的静态方法
>  *  某个对象.方法(); //调用某个对象的普通方法创建目标对象。例如 sqlSessionFactory.openSession();
>  *  反射
>  *  序列化
>  *  …

> Bean的实例化方式有四种：构造方法方式、静态工厂方式、实例工厂方式、实现FactoryBean<T>方式（扩展）。

### 1. 构造方法方式 ###

--------------------

> bean本质上就是对象，可以通过构造方法方式实例化bean。（重点）

1、为实现类BookDaoImpl提供一个构造方法

public class BookDaoImpl implements BookDao {
        
    
        // 显示定义一个无参构造方法
        public BookDaoImpl() {
        
            System.out.println("bookDao的构造方法执行了~");
        }
    
        @Override
        public void save() {
        
            System.out.println("bookDao save~");
        }
    }

2、配置bean：

3、编写测试

public class Application {
        
        public static void main(String[] args) {
        
            // 创建IOC容器对象,并加载spring核心配置文件
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            // 获取容器中的bean对象
            BookDao bookDao = (BookDao) ctx.getBean("bookDao");
    
            //  调用bean的方法
            bookDao.save();
        }
    }

![在这里插入图片描述][9001a9b255be48e8b24976fbfae08366.png]

注意：如果定义了有参构造器方法，没有提供无参构造方法，就会抛出异常：BeanInstantiationException（bean实例化异常）

![在这里插入图片描述][a0c06215f8e34da8bf9326366d894b65.png]

![在这里插入图片描述][97e54e3f7d094866be9f98b885e9e40a.png]

### 2. 静态工厂方式 ###

--------------------

> 通过示例静态工厂方式实例化bean。

1、定义接口和实现类

package com.baidou.dao;
    
    public interface OrderDao {
        
        public void save();
    }

package com.baidou.dao;
    
    public class OrderDaoImpl implements OrderDao {
        
        
        public void save() {
        
            System.out.println("orderDao save ...");
        }
    }

2、编写工厂类

package com.baidou.factory;
    
    import com.baidou.dao.OrderDao;
    import com.baidou.dao.OrderDaoImpl;
    
    // 静态工厂创建对象
    public class OrderDaoFactory {
        
    
        public static OrderDao getOrderDao() {
        
            return new OrderDaoImpl() ;
        }
    }

3、在applicationContext.xml中，配置bean:

![在这里插入图片描述][c69ff584413e4165a4425daced717be8.png]

4、编写测试

package com.baidou;
    
    import com.baidou.dao.OrderDao;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Application {
        
        public static void main(String[] args) {
        
            // 创建IOC容器对象,并加载spring核心配置文件
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            // 获取容器中的bean对象
            OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
    
            //  调用bean的方法
            orderDao.save();
        }
    }

![在这里插入图片描述][d25a6b3f734a4b29adb663842d2c4954.png]

### 3. 实例工厂方式 ###

--------------------

> 通过实例工厂方式实例化bean。

1、定义接口和实现类

package com.baidou.dao;
    
    public interface UserDao {
        
        public void save();
    }

package com.baidou.dao;
    
    public class UserDaoImpl implements UserDao {
        
        @Override
        public void save() {
        
            System.out.println("userDao save ...");
        }
    }

2、编写工厂类

package com.baidou.factory;
    
    import com.baidou.dao.UserDao;
    import com.baidou.dao.UserDaoImpl;
    
    //实例工厂创建对象
    public class UserDaoFactory {
        
        public UserDao getUserDao(){
        
            return new UserDaoImpl();
        }
    }

3、在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="userFactory" class="com.baidou.factory.UserDaoFactory"/>
        
        <bean id="userDao"  factory-bean="userFactory" factory-method="getUserDao"></bean>
    
    </beans>

![在这里插入图片描述][8b04e78c8a9842299b621e91438b8006.png]

4、编写测试

public class Application {
        
        public static void main(String[] args) {
        
            // //创建实例工厂对象
            // UserDaoFactory userDaoFactory = new UserDaoFactory();
            // //通过实例工厂对象创建对象
            // UserDao userDao = userDaoFactory.getUserDao();
            // userDao.save();
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            UserDao userDao = (UserDao) ctx.getBean("userDao");
            userDao.save();
        }
    }

![在这里插入图片描述][9a8bbed3d97148deb75158aa108d46f1.png]

### 4. 实现FactoryBean<T>方式 ###

--------------------

> spring底层会用

1、定义UserDaoFactoryBean类，去实现FactoryBean<UserDao>接口。

*  UserDaoFactoryBean中实例化什么类型的对象，泛型就设置对应的类型。

//FactoryBean创建对象
    public class UserDaoFactoryBean implements FactoryBean<UserDao> {
        
        // 重写接口中的两个方法
        
        //代替原始实例工厂中创建对象的方法
        public UserDao getObject() throws Exception {
        
            return new UserDaoImpl();
        }
    
        public Class<?> getObjectType() {
        
            return UserDao.class;
        }
    }

2、配置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="userDao" class="com.baidou.factory.UserDaoFactoryBean"/>
    <beans/>

3、编写测试：

public class Application {
        
        public static void main(String[] args) {
        
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            UserDao userDao = (UserDao) ctx.getBean("userDao");
            userDao.save();
        }
    }

![在这里插入图片描述][20d86597034d47438351ed9983cc76e3.png]

> 小结：

bean实例化方式：构造器方式（无参构造）。

## 五、Bean的生命周期 ##

--------------------

> 生命周期：就是从创建到消亡的完整过程。
> 
> bean生命周期：bean从创建到销毁的整体过程。
> 
> bean生命周期控制：bean从创建后到销毁前做一些事情。

### 1. Bean的生命周期控制 ###

--------------------

#### 1.1 提供生命周期控制方法 ####

--------------------

1、提供声明周期方法（init和destory方法）

public class BookDaoImpl implements BookDao {
        
        public void save() {
        
            System.out.println("bookDao save ...");
        }
        //表示bean初始化对应的操作
        public void init(){
        
            System.out.println("init...");
        }
        //表示bean销毁前对应的操作
        public void destory(){
        
            System.out.println("destory...");
        }
    }

2、在spring核心配置文件中，配置生命周期控制方法：

3、编写测试

public class App {
        
        public static void main(String[] args) {
        
            ClassPathXmlApplicationContext ctx =  new ClassPathXmlApplicationContext("applicationContext.xml");
           
            ctx.registerShutdownHook(); //优雅的关闭容器写法:先注册一下,当这些代码全部执行完毕后就销毁容器
            
            BookDao bookDao = (BookDao) ctx.getBean("bookDao");
            bookDao.save();
            
            // 若想执行destory销毁方法,需要关闭spring容器
            //ctx.close(); //缺点:close()方法必须放在最后一行执行
        }
    }
    /*
    	当创建spring容器的时候,默认它会将配置文件中的所有单实例对象都创建好,且放入spring容器中;
    	若配置init-method、destroy-method,就会去调用指定的方法。
    */

![在这里插入图片描述][81235bbbaafc4b718e8dafe269826bd1.png]

单实例的话，也可以在bean标签中配置`lazy-init="true"`，表示用的时候创建bean。

--------------------

多实例的话，用的时候才会去创建bean，bean的销毁由垃圾回收机制处理。

![在这里插入图片描述][295b8da1db5a4c9b9f6dbdbf7255c7af.png]

#### 1.2 实现InitializingBean，DisposableBean接口 ####

--------------------

> 实现InitializingBean、DisposableBean接口，重写接口中的两个方法:destroy、afterPropertiesSet

package com.baidou.dao;
    
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    
    public class BookDaoImpl implements BookDao, InitializingBean, DisposableBean {
        
    
        public BookDaoImpl() {
        
            System.out.println("bookDao 无参构造方法执行了");
        }
    
        public void save() {
        
            System.out.println("bookDao save ...");
        }
    
        // 在bean对象销毁前要执行的方法
        @Override
        public void destroy() throws Exception {
        
            System.out.println("destroy ...");
        }
    
        // 在bean设置完属性之后会执行的方法 （相当于init-method配置）
        @Override
        public void afterPropertiesSet() throws Exception {
        
            System.out.println("init ...");
        }
    }

![在这里插入图片描述][a6229d669c2342cd9469ba13fc819a04.png]

### 2. bean的生命周期控制执行流程 ###

--------------------

1、初始化容器

2、创建对象（内存分配）

3、执行构造方法

4、执行属性注入（set操作）

5、执行bean初始化方法：

*  若在bean中配置了init-method，就会执行指定的方法。
 *  若实现了InitializingBean接口的话就会执行afterPropertiesSet。

6、使用bean执行业务操作

7、关闭/销毁容器之前执行bean销毁方法：

*  若实现了DisposableBean接口的话，就会执行destroy方法。
 *  若在bean中配置了destroy-method的话就会执行指定的方法。

### 3. Bean的销毁时机 ###

--------------------

> IOC容器关闭前才会触发bean的销毁。

关闭容器的两种方式：

1、手动关闭容器：通过`ConfigurableApplicationContext`接口的`close()`方法。

2、注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机：通过`ConfigurableApplicationContext`接口的`registerShutdownHook()`方法。

## 六、依赖注入(DI配置) ##

--------------------

### 1.依赖的注入方式 ###

> 依赖注入有两种方式：setter方式、构造器方式。

#### 1.1 setter方式注入 ####

--------------------

> setter方式：
> 
>  *  在类中提供给成员变量提供setter方法。
>  *  在配置文件中通过 <property name=“属性名” ref|value=“”/>。
>  *  ref:注入引用类型。
>  *  value:注入简单类型。

##### 使用set方式注入引用类型（property-ref） #####

package com.baidou.service;
    
    import com.baidou.dao.BookDao;
    
    public class BookServiceImpl implements BookService {
        
    
        private BookDao bookDao;
    
        // 为成员变量提供set方法
        public void setBookDao(BookDao bookDao) {
        
            this.bookDao = bookDao;
        }
    
        @Override
        public void save() {
        
            System.out.println("bookService save...");
        }
    }

<bean id="bookService" class="com.baidou.service.BookServiceImpl">
        
        <property name="bookDao" ref="bookDao"></property>
    </bean>
    
    
    <bean class="com.baidou.dao.BookDaoImpl" id="bookDao"></bean>

![在这里插入图片描述][fdd53b65f2964523a50f74d83676845f.png]

##### 使用set方式注入简单类型（property-value） #####

package com.baidou.dao;
    
    public class BookDaoImpl implements BookDao {
        
        // 定义简单类型成员变量
        private int connectionNumber;
    
        // 提供set方法
        public void setConnectionNumber(int connectionNumber) {
        
            this.connectionNumber = connectionNumber;
        }
    
        public void save() {
        
            System.out.println("bookDao save ...");
        }
    }

![在这里插入图片描述][f4795086c3d74ca79b6fc815724e3d7f.png]

#### 1.2 构造方式注入 ####

--------------------

> 构造器方式：
> 
>  *  在类中提供给成员变量赋值的构造器。
>  *  在配置文件中通过 <constructor-arg name=“参数名字” ref|value=“”/>。
>  *  ref:注入引用类型。
>  *  value:注入简单类型。

##### 使用构造方式注入引用类型（ constructor-arg–ref） #####

package com.baidou.service;
    
    import com.baidou.dao.BookDao;
    
    public class BookServiceImpl implements BookService {
        
    
        private BookDao bookDao;
        
        // 提供无参构造器
        public BookServiceImpl() {
        }
    
        //  通过带参构造器
        public BookServiceImpl(BookDao bookDao) {
        
            this.bookDao = bookDao;
        }
    
        @Override
        public void save() {
        
            System.out.println("bookService save...");
        }
    }

<bean id="bookService" class="com.baidou.service.BookServiceImpl">
        
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>
    
    
    <bean class="com.baidou.dao.BookDaoImpl" id="bookDao"></bean>

![在这里插入图片描述][37cb9e28bc974a709de0312042462d26.png]

##### 使用构造方式注入简单类型（ constructor-arg–value） #####

public class BookDaoImpl implements BookDao {
        
        // 定义简单类型成员变量
        private int connectionNumber;
        private String databaseName;
    
        // 提供无参构造器
        public BookDaoImpl() {
        }
    
        // 提供带参构造器
        public BookDaoImpl(int connectionNumber, String databaseName) {
        
            this.connectionNumber = connectionNumber;
            this.databaseName = databaseName;
        }
    
        public void save() {
        
            System.out.println("bookDao save ...");
        }
    }

![在这里插入图片描述][ef9d2e5b209a4db79c3dc21354e028de.png]

##### 参数适配（扩展） #####

1、通过constructor-arg标签的type属性设置按照形参类型注入：

![在这里插入图片描述][6667428de02844918b351141f26e0350.png]

<bean class="com.baidou.dao.BookDaoImpl" id="bookDao">
        <constructor-arg type="int" value="10"/>
        <constructor-arg type="java.lang.String" value="redis"/>
    </bean>

--------------------

2、通过constructor-arg标签的index属性设置按照形参位置注入：

<bean class="com.baidou.dao.BookDaoImpl" id="bookDao">
        <constructor-arg index="0" value="10"/>
        <constructor-arg index="1" value="mysql"/>
    </bean>

> 依赖注入方式选择：

1.  强制依赖使用构造器进行，使用setter注入有概率导致null对象出现。
2.  可选依赖使用setter注入进行，灵活性强。
3.  Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨。
4.  如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入。
5.  实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入。
6.  自己开发的模块推荐使用setter注入。

### 2. 依赖自动装配 ###

--------------------

> IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配。（后面会用@autowire注解实现）

自动装配方式有：

*  按类型进行装配（常用）
 *  按名称进行装配
 *  按构造方法进行装配
 *  不启用自动装配

> 在配置文件中，通过bean标签的autowire属性设置自动装配的类型：（给成员变量提供setter方法）

**依赖自动装配特征:**

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

### 3. 集合注入 ###

--------------------

> property标签通过setter方式注入，内部可以写<array>、<list>、<set>、<map>、<props>标签。
> 
> constructor-arg标签通过构造方式注入，constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签。

> 单列集合:array、set、list。
> 
> 双列集合:map、props。

#### 3.1 注入数组类型数据 ####

#### 3.2 注入List类型数据 ####

<property name="list">
        <list>
            <value>java</value>
            <value>php</value>
            <value>python</value>
            <value>c++</value>
        </list>
    </property>

#### 3.3 注入Set类型数据 ####

<property name="set">
        <set>
            <value>java</value>
            <value>php</value>
            <value>python</value>
            <value>java</value>
        </set>
    </property>

#### 3.4 注入Map类型数据 ####

#### 3.5 注入Properties类型数据 ####

<property name="properties">
        <props>
            <prop key="country">china</prop>
            <prop key="province">zhejiang</prop>
            <prop key="city">hangzhou</prop>
        </props>
    </property>

[a6b6700f37544dc28ed3e939149f5d18.png]: https://img-blog.csdnimg.cn/a6b6700f37544dc28ed3e939149f5d18.png
[91b1ab2841cd4defb67375d5a8347664.png_pic_center]: https://img-blog.csdnimg.cn/91b1ab2841cd4defb67375d5a8347664.png#pic_center
[2cb3e704c0254d1081fa0b290349d629.png]: https://img-blog.csdnimg.cn/2cb3e704c0254d1081fa0b290349d629.png
[918df6a1ae57478aba44f00778f2e60a.png]: https://img-blog.csdnimg.cn/918df6a1ae57478aba44f00778f2e60a.png
[5eec9fb9a98b446b8503314860b36d3b.png]: https://img-blog.csdnimg.cn/5eec9fb9a98b446b8503314860b36d3b.png
[918090cd43d34ee89db0a6a13a3400d7.png]: https://img-blog.csdnimg.cn/918090cd43d34ee89db0a6a13a3400d7.png
[08bf935248e642fe8522d0100b413fe7.png]: https://img-blog.csdnimg.cn/08bf935248e642fe8522d0100b413fe7.png
[e57e7515823f4206aa8c8961fc3eb4e7.png]: https://img-blog.csdnimg.cn/e57e7515823f4206aa8c8961fc3eb4e7.png
[575057e8a0a14d0db8c76fa63b2984cd.png]: https://img-blog.csdnimg.cn/575057e8a0a14d0db8c76fa63b2984cd.png
[1f501675cc854429b69e6cad2b9af126.png]: https://img-blog.csdnimg.cn/1f501675cc854429b69e6cad2b9af126.png
[778a7fa349134ab49c6ca4b6ff4da6c1.png]: https://img-blog.csdnimg.cn/778a7fa349134ab49c6ca4b6ff4da6c1.png
[05c77cc1a7f14d76841c320bf41ddecb.png]: https://img-blog.csdnimg.cn/05c77cc1a7f14d76841c320bf41ddecb.png
[f854f4fd8242415e802a60c6900a65b8.png]: https://img-blog.csdnimg.cn/f854f4fd8242415e802a60c6900a65b8.png
[7cdfc2de6c314304b4e9a29bd7f31722.png]: https://img-blog.csdnimg.cn/7cdfc2de6c314304b4e9a29bd7f31722.png
[a10c092c3b5e49bc82a170e507f382dd.png]: https://img-blog.csdnimg.cn/a10c092c3b5e49bc82a170e507f382dd.png
[374485ff61cd480b99fa6813747fcdce.png]: https://img-blog.csdnimg.cn/374485ff61cd480b99fa6813747fcdce.png
[360b860ce4474178ad4288e2937d8699.png]: https://img-blog.csdnimg.cn/360b860ce4474178ad4288e2937d8699.png
[60b6d6ddd2624a20abbd95d688151ac0.png]: https://img-blog.csdnimg.cn/60b6d6ddd2624a20abbd95d688151ac0.png
[688df56fd86e4d4193cbb6dce9c41536.png]: https://img-blog.csdnimg.cn/688df56fd86e4d4193cbb6dce9c41536.png
[b8437a1cc0144411bf161d8c2a6f0d24.png]: https://img-blog.csdnimg.cn/b8437a1cc0144411bf161d8c2a6f0d24.png
[4fdeb48265fc4b308cefb869d7180327.png]: https://img-blog.csdnimg.cn/4fdeb48265fc4b308cefb869d7180327.png
[9001a9b255be48e8b24976fbfae08366.png]: https://img-blog.csdnimg.cn/9001a9b255be48e8b24976fbfae08366.png
[a0c06215f8e34da8bf9326366d894b65.png]: https://img-blog.csdnimg.cn/a0c06215f8e34da8bf9326366d894b65.png
[97e54e3f7d094866be9f98b885e9e40a.png]: https://img-blog.csdnimg.cn/97e54e3f7d094866be9f98b885e9e40a.png
[c69ff584413e4165a4425daced717be8.png]: https://img-blog.csdnimg.cn/c69ff584413e4165a4425daced717be8.png
[d25a6b3f734a4b29adb663842d2c4954.png]: https://img-blog.csdnimg.cn/d25a6b3f734a4b29adb663842d2c4954.png
[8b04e78c8a9842299b621e91438b8006.png]: https://img-blog.csdnimg.cn/8b04e78c8a9842299b621e91438b8006.png
[9a8bbed3d97148deb75158aa108d46f1.png]: https://img-blog.csdnimg.cn/9a8bbed3d97148deb75158aa108d46f1.png
[20d86597034d47438351ed9983cc76e3.png]: https://img-blog.csdnimg.cn/20d86597034d47438351ed9983cc76e3.png
[81235bbbaafc4b718e8dafe269826bd1.png]: https://img-blog.csdnimg.cn/81235bbbaafc4b718e8dafe269826bd1.png
[295b8da1db5a4c9b9f6dbdbf7255c7af.png]: https://img-blog.csdnimg.cn/295b8da1db5a4c9b9f6dbdbf7255c7af.png
[a6229d669c2342cd9469ba13fc819a04.png]: https://img-blog.csdnimg.cn/a6229d669c2342cd9469ba13fc819a04.png
[fdd53b65f2964523a50f74d83676845f.png]: https://img-blog.csdnimg.cn/fdd53b65f2964523a50f74d83676845f.png
[f4795086c3d74ca79b6fc815724e3d7f.png]: https://img-blog.csdnimg.cn/f4795086c3d74ca79b6fc815724e3d7f.png
[37cb9e28bc974a709de0312042462d26.png]: https://img-blog.csdnimg.cn/37cb9e28bc974a709de0312042462d26.png
[ef9d2e5b209a4db79c3dc21354e028de.png]: https://img-blog.csdnimg.cn/ef9d2e5b209a4db79c3dc21354e028de.png
[6667428de02844918b351141f26e0350.png]: https://img-blog.csdnimg.cn/6667428de02844918b351141f26e0350.png