学到自闭之- Spring IOC 高级特性

超、凢脫俗 2022-12-04 01:28 71阅读 0赞

自闭也得学

![20200905121456622.png][]

# 1 **lazy-Init** 延迟加载 #

## 1.1 扯概念 ##

ApplicationContext 容器的默认⾏为是在启动服务器时将所有 singleton bean 提前进⾏实例化。

<bean id="testBean" class="cn.LazyBean" />
    该bean默认的设置为: 
    <bean id="testBean" calss="cn.LazyBean" lazy-init="false" />

lazy-init="false"，表示在 spring 启动时，⽴刻进⾏实例化。如果不想让⼀个 singleton bean 在 ApplicationContext 实现初始化时被提前实例化，那么可以将 bean 设置为延迟实例化。

设置 lazy-init 为 true 的 bean 将不会在 ApplicationContext 启动时提前被实例化，⽽是第⼀次向容器通过 getBean 索取 bean 时实例化的。 如果⼀个设置了⽴即加载的 bean1，引⽤了⼀个延迟加载的 bean2 ，那么 bean1 在容器启动时被实例化，⽽ bean2 由于被 bean1 引⽤，所以也被实例化，这种情况也符合延时加载的 bean 在第⼀次调⽤时才被实例化的规则。

容器层次中通过在元素上使⽤ "default-lazy-init" 属性来控制延时初始化。如下：

如果⼀个 bean 的 scope 属性为 scope="pototype" 时，即使设置了 lazy-init="false"，容器启动时也不会实例化bean，⽽是调⽤ getBean ⽅法实例化的。

## **1.2 证明一下是真的** ##

### **1.2.1 关闭懒加载** ###

（1）applicationContext.xml

<bean id="lazyResult" class="com.pojo.Result" lazy-init="false"/>

（2）测试

@Test
    public void testBeanLazy(){
            ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    Object lazyResult = applicationContext.getBean("lazyResult");
            System.out.println(lazyResult);
            applicationContext.close();
    }

（3）debug 一下

查看 applicationContext 的 beanFactory 的

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70][]

![20200905135411217.png][]

注意：

> singletonObjects 实质是 ConcurrentHashMap

### 1.2.2 开启懒加载 ###

<bean id="lazyResult" class="com.pojo.Result" lazy-init="true"/>

![20200905135725762.png][]

applicationContext 实例化完时，beanFactory 里找不到 lazyResult 了。

通过 getBean 索取 lazyResult 时，beanFactory 里又出现 lazyResult 了

![20200905140253586.png][]

## 1.3 应⽤场景  ##

*  开启延迟加载⼀定程度提⾼容器启动和运转性
 *  对于不常使⽤的 Bean 设置延迟加载，这样偶尔使⽤的时候再加载，不必要从⼀开始该 Bean 就占⽤资源

# 2 FactoryBean #

## 2.1 扯概念 ##

BeanFactory 接⼝：容器的顶级接⼝，定义了容器的⼀些基础⾏为，负责⽣产和管理Bean的⼀个⼯⼚，具体使⽤它的⼦接⼝类型，如ApplicationContext；

FactoryBean 接口：可以自定义 Bean 的创建过程

// 可以让我们⾃定义Bean的创建过程（完成复杂Bean的定义）
    public interface FactoryBean<T> {
    
        // 返回FactoryBean创建的Bean实例，如果isSingleton返回true，则该实例会放到Spring容器的单例对象缓存池中Map
        @Nullable
        T getObject() throws Exception;
    
        @Nullable
        // 返回FactoryBean创建的Bean类型
        Class<?> getObjectType();
        
        // 返回作⽤域是否单例
        default boolean isSingleton() {
            return true; 
        } 
    }

## 2.2 多举例 ##

（1）Company 类

public class Company {
        private String name;
        private String address;
        private int scale;
    }

（2）CompanyFactoryBean 类

public class CompanyFactoryBean implements FactoryBean {
    
        /**
         * 公司名称，地址，规模
         */
        private String companyInfo;
    
        public void setCompanyInfo(String companyInfo) {
            this.companyInfo = companyInfo;
        }
    
        @Override
        public Object getObject() throws Exception {
           // 创建复杂对象 Company
            Company company = new Company();
            String[] strings = companyInfo.split(",");
            company.setName(strings[0]);
            company.setAddress(strings[1]);
            company.setScale(Integer.parseInt(strings[2]));
            return company;
        }
    
        @Override
        public Class<?> getObjectType() {
            return Company.class;
        }
    
        @Override
        public boolean isSingleton() {
            return true;
        }
    
    }

（3）xml 配置

（4）测试

@Test
    public void testIoC() throws Exception {
    
         Object companyBean = applicationContext.getBean("companyBean");
         System.out.println(companyBean);
    
         // 获取FactoryBean，需要在id之前添加“&”
         Object companyFactoryBean = applicationContext.getBean("&companyBean");
         System.out.println(companyFactoryBean);
    
         applicationContext.close();
    }

结果：

Company{name='羊腿', address='羊场', scale=500}
    com.lagou.edu.factory.CompanyFactoryBean@78fb9a67

# 3 后置处理器 #

## 3.1 扯概念 ##

后置处理器用来给我们增强功能，用于在特定的时机完成特定的功能，一般以接口的形式提供。

Spring 提供了两种后处理 bean 的扩展接⼝，分别为 BeanPostProcessor（针对 Bean） 和 BeanFactoryPostProcessor（针对 BeanFactory）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1][]

在  BeanFactory  初始化之后可以使⽤  BeanFactoryPostProcessor  进⾏后置处理做⼀些事情

在  Bean  对象实例化（并不是 Bean 的整个⽣命周期完成）之后可以使⽤  BeanPostProcessor  进⾏后置处理做⼀些事情

**注意：**

> 对象不⼀定是 springbean ，⽽ springbean ⼀定是个对象

## 3.2 SpringBean 的生命周期 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3][]

### 3.2.1 **BeanPostProcessor** ###

BeanPostProcessor 是针对 Bean 级别的处理，可以针对具体的 Bean

public interface BeanPostProcessor {
    
    	@Nullable
    	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		return bean;
    	}
    
    	@Nullable
    	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    		return bean;
    	}
    
    }

该接⼝提供了两个⽅法，分别在 Bean 的初始化⽅法前和初始化⽅法后执⾏，这个初始化⽅法类似我们在定义 Bean 时，定义了init-method 所指定的⽅法。定义⼀个类实现了 BeanPostProcessor，默认是会对整个Spring容器中所有的 bean 进⾏处理。如果要对具体的某个bean处理，可以通过⽅法参数判断，两个类型参数分别为 Object 和 String，第⼀个参数是每个 bean 的实例，第⼆个参数是每个 bean 的 name 或者 id 属性的值。所以我们可以通过第⼆个参数，来判断我们将要处理的具体的 bean。

**注意：**

> 处理是发⽣在 Spring 容器的实例化和依赖注⼊之后。

（1）applicationContext.xml

（2）Result 类

@Setter
    @Getter
    public class Result implements BeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean, DisposableBean {
    
        @Override
        public String toString() {
            return "Result{" +
                    "status='" + status + '\'' +
                    ", message='" + message + '\'' +
                    '}';
        }
    
        @Override
        public void setBeanName(String name) {
            System.out.println("1 注册我成为bean时定义的id：" + name);
        }
    
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            System.out.println("2 管理我的beanfactory为：" + beanFactory);
        }
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            System.out.println("3 高级容器接口ApplicationContext：" + applicationContext);
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("5 afterPropertiesSet......");
        }
    
    
        public void initMethod() {
            System.out.println("5 init-method....");
        }
    
        @PostConstruct
        public void postCoustrcut() {
            System.out.println("5 postCoustrcut");
        }
    
        @PreDestroy
        public void PreDestroy(){
            System.out.println("7 PreDestroy...");
        }
    
        @Override
        public void destroy() throws Exception {
            System.out.println("8 destroy.....");
        }
    }

（3）MyBeanPostProcessor 类

/**
     * 拦截实例化之后的对象（实例化了并且属性注入了）
     */
    @Component
    public class MyBeanPostProcessor implements BeanPostProcessor {
    
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            // 拦截具体的对象
            if("lazyResult".equalsIgnoreCase(beanName)) {
                System.out.println("4 MyBeanPostProcessor  before方法拦截处理lazyResult（init-method执行前）");
            }
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if("lazyResult".equalsIgnoreCase(beanName)) {
                System.out.println("6 MyBeanPostProcessor  after方法拦截处理lazyResult（init-method执行后）");
            }
            return bean;
        }
    }

### 3.2.2 **BeanFactoryPostProcessor** ###

BeanFactory 级别的处理，是针对整个Bean的⼯⼚进⾏处理

@FunctionalInterface
    public interface BeanFactoryPostProcessor {
    
    	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
    
    }

参数：ConfigurableListableBeanFactory

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4][]

其中有个⽅法名为 getBeanDefinition 的⽅法，根据此⽅法，可以找到 bean 对应的 BeanDefinition 对象。然后对定义的属性进⾏修改，以下是 BeanDefinition 中的部分⽅法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5][]

⽅法名字类似我们bean标签的属性，setBeanClassName 对应 bean 标签中的 class 属性，所以当我们拿到 BeanDefinition 对象时，我们可以⼿动修改 bean 标签中所定义的属性值。

**BeanDefinition**  对象： 我们在  XML  中定义的  bean 标签， Spring  解析  bean  标签成为⼀个  JavaBean， 这个JavaBean  就是 BeanDefinition。

**注意：**

> 调⽤  BeanFactoryPostProcessor  ⽅法时，这时候 bean 还没有实例化，此时  bean  刚被解析成 BeanDefinition对象

**典型应⽤:** PropertyPlaceholderConfigurer，用于填充属性占位符

>     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
>             <property name="driverClassName" value="${jdbc.driver}"/>
>             ...
>     </bean>

**源码：**

1）class PropertyPlaceholderConfigurer extends PlaceholderConfigurerSupport
    
    2）class PlaceholderConfigurerSupport extends PropertyResourceConfigurer
    
    3）abstract class PropertyResourceConfigurer extends PropertiesLoaderSupport
       implements BeanFactoryPostProcessor{
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    	try {
                    // 加载并去重合并 properties 文件
    		Properties mergedProps = mergeProperties();
    		// 用 properties 中的值替换 xml 中的占位符
    		convertProperties(mergedProps);	
    		processProperties(beanFactory, mergedProps);
    	}catch (IOException ex) {
    		throw new BeanInitializationException("Could not load properties", ex);
    	}
    }

# 4 Spring IOC 源码构建 #

*  下载源码（github或gitee），可以边读边加注释

> [https://github.com/spring-projects/spring-framework][https_github.com_spring-projects_spring-framework]
> 
> [https://gitee.com/mirrors/Spring-Framework/tree/5.1.x/][https_gitee.com_mirrors_Spring-Framework_tree_5.1.x]

*  安装 gradle

brew install gradle

*  导⼊（耗费⼀定时间）
 *  编译⼯程（顺序：core-oxm-context-beans-aspects-aop）
 *  按上面的⼯程顺序依次编译—>Tasks—>other——>compileTestJava，点击运行
 *  new 一个 module，选择用 gradle 构建，用来测试源码

# 5 Spring IOC 循环依赖问题 #

通过三级缓存解决set注入导致的循环依赖问题

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6][]

构造器方式的依赖无法解决，构造函数里没有东西就无法实例化，就无法放入三级缓存。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7][]

[20200905121456622.png]: /images/20221123/0af4642970684fdeb6293d0ea0fbe45a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70]: /images/20221123/68ab320aec8246a29496bc7e0df22a0a.png
[20200905135411217.png]: /images/20221123/06b1d025d55448f3a0032798d7954935.png
[20200905135725762.png]: /images/20221123/1fe22e2e99b5482098c12768b91bbfd0.png
[20200905140253586.png]: /images/20221123/5156b8629909406fbcf65c3880cab79d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1]: /images/20221123/52a02c7571be4fffb1da9dfedcd656de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2]: /images/20221123/c65a9599bbdf4c3a8044993e44d722fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3]: /images/20221123/c4b827641685490ab10c177ab413cc28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4]: /images/20221123/2c2e38635a3b49c8bebd21217d5dc519.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5]: /images/20221123/8ae88dff726d4d75ab0424b25d25c6f7.png
[https_github.com_spring-projects_spring-framework]: https://github.com/spring-projects/spring-framework
[https_gitee.com_mirrors_Spring-Framework_tree_5.1.x]: https://gitee.com/mirrors/Spring-Framework/tree/5.1.x/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6]: /images/20221123/de146a6e88e0452aa6448d95f5caf690.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7]: /images/20221123/c626226ea3a447798aca6c2c8bf8dd17.png