学到闷骚之 - Spring IOC 基础

﹏ヽ暗。殇╰゛Y 2022-12-03 05:29 161阅读 0赞

这么多年过去了，我还在学 Spring。

![2020090208114133.png][]

还不是因为你基础不扎实。

# 1 xml 与 BeanFactory #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70][]

注解就是纯Java类啦，所以要用监听器去加载注解配置类。

# 2 BeanFactory 与 ApplicationContex #

BeanFactory ：Spring 框架中 IoC 容器的顶层接⼝，它只是⽤来定义⼀些基础功能，定义⼀些基础规范。

ApplicationContext ：BeanFactory 的⼀个⼦接⼝，具备 BeanFactory 提供的全部功能。

通常，我们称 BeanFactory 为 SpringIOC 的基础容器，ApplicationContext 是容器的⾼级接⼝，⽐ BeanFactory 要拥有更多的功能，⽐如说国际化⽀持和资源访问（xml，java 配置类）等等。

BeanFactory：The root interface for accessing a Spring bean container

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2][]

# 3 启动 IoC 容器的方式 #

## 3.1 Java 环境下启动 IOC 容器（一般用于 Junit 测试） ##

（1）ClassPathXmlApplicationContext：从类的根路径下加载配置⽂件（推荐使⽤）

（2）FileSystemXmlApplicationContext：从磁盘路径上加载配置⽂件

（3）AnnotationConfifigApplicationContext：纯注解模式下启动Spring容器

@Transactional
    public class BaseTest {
    
         public static ApplicationContext applicationContext;
    
         public static ApplicationContext getApplicationContext() {
              return applicationContext;
         }
    
         static {
             // 通过读取classpath下的xml文件来启动容器（xml模式SE应用下推荐）
             applicationContext = new FileSystemXmlApplicationContext(
                    "classpath:applicationContext.xml");
    
            // 不推荐使用，文件移动需要修改路径
            applicationContext1 = new FileSystemXmlApplicationContext("文件系统的绝对路径");
         }
    }

IoCTest

public class IoCTest extends BaseTest{
    
        @Test
        public void testIoC() throws Exception {
            // 第一次getBean该对象
            Object accountPojo = applicationContext.getBean("accountPojo");
            System.out.println(accountPojo);
        }
    }

## 3.2 Web 环境下启动 IOC 容器 ##

引入依赖

<dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-web</artifactId>
          <version>5.1.12.RELEASE</version>
    </dependency>

### 3.2.1 从 xml 启动容器 ###

（1）web.xml

<!DOCTYPE web-app PUBLIC
    "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd" >
    <web-app> 
        <display-name>Archetype Created Web Application</display-name>
        
        <context-param> 
            
            <param-name>contextConfigLocation</param-name> 
            <param-value>classpath:applicationContext.xml</param-value>
        </context-param>
        
        <listener>         
            <listenerclass>
                org.springframework.web.context.ContextLoaderListener
            </listenerclass>
        </listener>
    </web-app>

（2）applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
    
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/tx
            https://www.springframework.org/schema/tx/spring-tx.xsd
    ">
       
        <bean id="accountDao" class="com.lagou.edu.dao.impl.JdbcTemplateDaoImpl">
            <property name="ConnectionUtils" ref="connectionUtils"/>
        </bean>
        <bean id="transferService" class="com.lagou.edu.service.impl.TransferServiceImpl">
            
            <property name="AccountDao" ref="accountDao"></property>
        </bean>
    
        
        <bean id="connectionUtils" class="com.lagou.edu.utils.ConnectionUtils"></bean>
    
        
        <bean id="transactionManager" class="com.lagou.edu.utils.TransactionManager">
            <property name="ConnectionUtils" ref="connectionUtils"/>
        </bean>
    
        
        <bean id="proxyFactory" class="com.lagou.edu.factory.ProxyFactory">
            <property name="TransactionManager" ref="transactionManager"/>
        </bean>
    
    </beans>

web 项目已启动，IOC 容器拥有的实例化对象：transferService，transactionManager，AccountDao，proxyFactory，connectionUtils

（3）TransferServlet 从 IOC 容器中获取对象

// WebApplicationContext 是针对 web 项目专门封装的
    // interface WebApplicationContext extends ApplicationContext
    // 获取 IOC 容器
    WebApplicationContext webApplicationContext = WebApplicationContextUtils
    .getWebApplicationContext(this.getServletContext());
    
    ProxyFactory proxyFactory =(ProxyFactory)webApplicationContext.getBean("proxyFactory");
    
    transferService = (TransferService) proxyFactory
    .getJdkProxy(webApplicationContext.getBean("transferService")) ;

### 3.2.2 从配置类启动容器 ###

web.xml

<!DOCTYPE web-app PUBLIC
    "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd" >
    <web-app> <display-name>Archetype Created Web Application</display-name>
    
    
    <context-param> 
        <param-name>contextClass</param-name> 
        <param-value>
          org.springframework.web.context.support.AnnotationConfigWebApplicationContext
        </param-value>
    </context-param>
    
    <context-param> 
        <param-name>contextConfigLocation</param-name> 
        <param-value>com.SpringConfig</param-value>
    </context-param>
    
    <listener> 
        <listenerclass>
            org.springframework.web.context.ContextLoaderListener
        </listenerclass>
    </listener>
    </web-app>

# 4 Spring IOC 的纯 xml 模式  #

**引入依赖**

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

**插播小技巧：**

> mac idea
> 
> 查找文件的快捷键：Command + O
> 
> 文件内查找：Command + F
> 
> 查询任何东西：Double Shift
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3][]

## 4.1 实例化 Bean 的三种方式 ##

### 4.1.1 使用无参构造函数 ###

在默认情况下，它会通过反射调⽤⽆参构造函数来创建对象。如果类中没有⽆参构造函数，将创建失败。

<bean id="userService" class="com.service.impl.TransferServiceImpl"></bean>

### 4.1.2 使⽤静态⽅法创建 ###

public class CreateBeanFactory {
    
        public static ConnectionUtils getInstanceStatic() {
            return new ConnectionUtils();
        }
    }

<bean id="connectionUtils" class="com.factory.CreateBeanFactory" factory-method="getInstanceStatic"/>

### 4.1.3 使⽤实例化⽅法创建 ###

public class CreateBeanFactory {
    
        public ConnectionUtils getInstance() {
            return new ConnectionUtils();
        }
    }

## 4.2 Bean 的作用范围及生命周期 ##

### 4.2.1 作用范围 ###

在spring框架管理Bean对象的创建时，Bean对象默认都是单例的，但是它⽀持配置的⽅式改变作⽤范围。作⽤范围官⽅提供的说明如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4][]

在上图中提供的这些选项中，我们实际开发中⽤到最多的作⽤范围就是singleton（单例模式）和 prototype（原型模式，也叫多例模式）。配置⽅式参考下⾯的代码：

<bean id="transferService"
    class="com.lagou.service.impl.TransferServiceImpl" scope="singleton">
    </bean>

### 4.2.2 不同作用范围的生命周期 ###

**（1）单例模式：singleton**

*  对象出⽣：当创建容器时，对象就被创建了。 
 *  对象活着：只要容器在，对象⼀直活着。 
 *  对象死亡：当销毁容器时，对象就被销毁了。 
 *  总结：单例模式的 bean 对象⽣命周期与容器相同。

**（2）多例模式：prototype**

*  对象出⽣：当使⽤对象时，创建新的对象实例。 
 *  对象活着：只要对象在使⽤中，就⼀直活着。 
 *  对象死亡：当对象⻓时间不⽤时，会被java的 GC 回收。 
 *  总结：多例模式的 bean 对象，spring 框架只负责创建，不负责销毁。

## 4.3 DI 依赖注入的 xml 配置 ##

### 4.3.1 注入方式 ###

*  **构造函数注⼊：**利⽤带参构造函数实现对类成员的数据赋值。

public class JdbcAccountDaoImpl implements AccountDao {
    
        public JdbcAccountDaoImpl(ConnectionUtils connectionUtils, String name, int sex, float money) {
            this.connectionUtils = connectionUtils;
            this.name = name;
            this.sex = sex;
            this.money = money;
        }
    }

<constructor-arg index="0" ref="connectionUtils"/>
    <constructor-arg index="1" value="zhangsan"/>
    <constructor-arg index="2" value="1"/>
    <constructor-arg index="3" value="100.5"/>
    
    
    <constructor-arg name="connectionUtils" ref="connectionUtils"/>
    <constructor-arg name="name" value="zhangsan"/>
    <constructor-arg name="sex" value="1"/>
    <constructor-arg name="money" value="100.6"/>

*  **set ⽅法注⼊：**通过类成员的 set ⽅法实现数据的注⼊。（使⽤最多的）

public class JdbcAccountDaoImpl implements AccountDao {
    
        private ConnectionUtils connectionUtils;
        private String name;
        private int sex;
        private float money;
    
        public void setConnectionUtils(ConnectionUtils connectionUtils) {
            this.connectionUtils = connectionUtils;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setSex(int sex) {
            this.sex = sex;
        }
    
        public void setMoney(float money) {
            this.money = money;
        }
    }

<property name="ConnectionUtils" ref="connectionUtils"/>
    <property name="name" value="zhangsan"/>
    <property name="sex" value="1"/>
    <property name="money" value="100.3"/>

### 4.3.2 注入的数据类型 ###

*  **基本类型和 String：**注⼊的数据类型是基本类型或者是字符串类型的数据。 
 *  **Bean 类型：**注⼊的数据类型是对象类型，且这个对象是要求出现在 IoC 容器中的。
 *  **复杂类型（集合类型）：**注⼊的数据类型是Aarry，List，Set，Map，Properties 中的⼀种类型。

public class JdbcAccountDaoImpl implements AccountDao {
    
        private String[] myArray;
        private Map<String,String> myMap;
        private Set<String> mySet;
        private Properties myProperties;
    
        public void setMyArray(String[] myArray) {
            this.myArray = myArray;
        }
    
        public void setMyMap(Map<String, String> myMap) {
            this.myMap = myMap;
        }
    
        public void setMySet(Set<String> mySet) {
            this.mySet = mySet;
        }
    
        public void setMyProperties(Properties myProperties) {
            this.myProperties = myProperties;
        }
    }

<property name="myArray">
        <array>
            <value>array1</value>
            <value>array2</value>
            <value>array3</value>
        </array>
    </property>
    <property name="myMap">
        <map>
            <entry key="key1" value="value1"/>
            <entry key="key2" value="value2"/>
        </map>
    </property>
    <property name="mySet">
        <set>
             <value>set1</value>
             <value>set2</value>
        </set>
    </property>
    <property name="myProperties">
        <props>
             <prop key="prop1">value1</prop>
             <prop key="prop2">value2</prop>
        </props>
    </property>

# 5 xml 与 注解相结合 #

**注意：**

（1）实际企业开发中，纯 xml 模式使⽤已经很少了

（2）引⼊注解功能，不需要引⼊额外的  jar

（3）xml+ 注解结合模式， xml  ⽂件依然存在，所以， spring IOC  容器的启动仍然从加载  xml  开始

（4）哪些  bean  的定义写在  xml 中，哪些  bean  的定义使⽤注解

*  第三⽅ **jar** 中的 **bean** 定义在 **xml**，⽐如 Druid 连接池

<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** 定义使⽤注解

**使用注解的准备工作：**

<beans  xmlns:context="http://www.springframework.org/schema/context"
            http://www.springframework.org/schema/context">
    
    
    <context:component-scan base-package="com"/>

## 5.1 xml中标签与注解的对应（IoC） ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5][]

## 5.2 DI 依赖注⼊的注解实现⽅式 ##

### 5.2.1 **@Autowired**（推荐使⽤） ###

@Autowired 为 Spring 提供的注解，需要导⼊包

org.springframework.beans.factory.annotation.Autowired

@Autowired 采取的策略为按照类型注⼊

public class TransferServiceImpl {
      
        //IOC 容器中找到类型为 AccountDao 的类，然后将其注⼊进来
        @Autowired
        private AccountDao accountDao;
    }

当⼀个类型有多个  bean  值的时候，会造成⽆法选择具体注⼊哪⼀个的情况， 这个时候我们需要配合着  @Qualififier  使⽤， 告诉 Spring  具体去装配哪个对象。

public class TransferServiceImpl {
       
        @Autowired
        private AccountDao accountDao;
    }
    
    public class TransferServiceImpl {
       
        // @Autowired 按照类型注入 ,如果按照类型无法唯一锁定对象，可以结合 @Qualifier 指定具体的id
        @Autowired
        @Qualifier(name="jdbcAccountDaoImpl")
        private AccountDao accountDao;
    }

### 5.2.2 **@Resource** ###

@Resource 注解由 J2EE 提供，需要导⼊包 javax.annotation.Resource

@Resource  默认按照  ByName  ⾃动注⼊

public class TransferService {
    
        // 如果既没有指定 name，⼜没有指定 type，则⾃动按照 byName ⽅式进⾏装配
        @Resource
        private AccountDao accountDao;
    
        // 如果指定了 name，则从上下⽂中查找名称（id）匹配的 bean 进⾏装配，找不到则抛出异常
        @Resource(name="studentDao") 
        private StudentDao studentDao;
    
        // 如果指定了 type，则从上下⽂中找到类似匹配的唯⼀ bean 进⾏装配，找不到或是找到多个，都会抛出异常 
        @Resource(type="TeacherDao") 
        private TeacherDao teacherDao;
    
        // 如果同时指定了 name 和 type，则从 Spring 上下⽂中找到唯⼀匹配的 bean 进⾏装配，找不到则抛出异常
        @Resource(name="manDao",type="ManDao") 
        private ManDao manDao;
    }

**注意:**

@Resource  在  Jdk 11 中已经移除，如果要使⽤，需要单独引⼊  jar  包

<dependency>
        <groupId>javax.annotation</groupId>
        <artifactId>javax.annotation-api</artifactId>
        <version>1.3.2</version>
    </dependency>

# 6 纯注解模式 #

改造 xml + 注解模式，将 xml 中遗留的内容全部以注解的形式迁移出去，最终删除 xml，从 Java 配置类启动

**（1）对应注解**

> @Confifiguration 注解，表名当前类是⼀个配置类 
> 
> @ComponentScan 注解，替代 context:component-scan
> 
> @PropertySource，引⼊外部属性配置⽂件
> 
> @Import 引⼊其他配置类 
> 
> @Value 对变量赋值，可以直接赋值，也可以使⽤ $\{\} 读取资源配置⽂件中的信息 
> 
> @Bean 将⽅法返回对象加⼊ SpringIOC 容器

// @Configuration 注解表明当前类是一个配置类
    @Configuration
    @ComponentScan({"com"})
    @PropertySource({"classpath:jdbc.properties"})
    // @Import() 导入其他配置
    public class SpringConfig {
    
        @Value("${jdbc.driver}")
        private String driverClassName;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String username;
        @Value("${jdbc.password}")
        private String password;
    
        // 表明该方法的返回对象要交给 IOC 容器管理
        @Bean("dataSource")
        public DataSource createDataSource(){
            DruidDataSource druidDataSource = new DruidDataSource();
            druidDataSource.setDriverClassName(driverClassName);
            druidDataSource.setUrl(url);
            druidDataSource.setUsername(username);
            druidDataSource.setPassword(password);
            return  druidDataSource;
        }
    }

**（2）JAVA 环境纯注解模式启动 IOC 容器**

public class IoCTest {
    
        @Test
        public void testIoC() throws Exception {
    
            // 通过读取classpath下的xml文件来启动容器（xml模式SE应用下推荐）
            ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
            AccountDao accountDao = (AccountDao) applicationContext.getBean("accountDao");
            System.out.println(accountDao);
    
        }
    }

**（3）Web 环境纯注解模式启动 IOC 容器**

web.xml

<!DOCTYPE web-app PUBLIC
     "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
     "http://java.sun.com/dtd/web-app_2_3.dtd" >
    
    <web-app>
      <display-name>Archetype Created Web Application</display-name>
    
      
      <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
      </context-param>
      
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>com.SpringConfig</param-value>
      </context-param>
      
      <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
    </web-app>

[2020090208114133.png]: /images/20221123/01f2331d51ea4251a443237faaa53eb0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70]: /images/20221123/1f7bcc59f25a476da43cbcf6d5531af0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1]: /images/20221123/4207c43518704839918e5537f7d9e582.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2]: /images/20221123/7c529accae5a4431ae6838cf48332068.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3]: /images/20221123/ef46ea5fd1c24f7992c0a94314f6a348.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4]: /images/20221123/976ae973c0354b4b93eb7df9914f0cdd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5]: /images/20221123/dae5f0435bab4347811f05007dcae82c.png