SpringIOC的高级特性

SpringIOC的高级特性

1. lazy-Init延迟加载

Bean对象的延迟加载(延迟创建)

ApplicationContext 容器的默认⾏为是在启动服务器时将所有 singleton bean 提前进⾏实例化。提前实例化意味着作为初始化过程的⼀部分,ApplicationContext实例会创建并配置所有的singleton bean。

1.1 XML方式开启延迟加载:

lazy-init="" 配置bean对象的延迟加载 ,true或者false false就是立即加载

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

我们先来看一下当lazy-init="false" 也就是立即加载的时候:

可以看到,在容器启动后,getBean之前,lazyResult这个bean已经存在了

然后我们把lazy-init="true",设置为true

然后我们F8往下走一步:

发现出现了lazyResult

1.2 注解开启延迟加载:

@Lazy
image-20201123000352548

1.3全局配置——default-lazy-init="":

在bean的根标签中:

应用场景:

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

2. FactoryBean和BeanFactory

2.1 BeanFactory

容器的顶级接口,定义了容器的一些基础行为,负责生产和管理Bean的一个工厂,具体使用它下面的子接口类型,比如ApplicationContext

2.2 FactoryBean

spring中的bean有两种

  • 普通bean
  • 工厂bean(FactoryBean)
    可以生产某一个类型的bean实例(返回给我们),也就是说我们可以借助于它自定义bean的创建过程。

Bean创建的三种⽅式中的静态⽅法和实例化⽅法和FactoryBean作⽤类似,FactoryBean使⽤较多,尤其在Spring框架⼀些组件中会使⽤,还有其他框架和Spring框架整合时使⽤

//可以让我们自定义Bean的创建过程,完成复杂bean定义
public interface FactoryBean<T> {
	//返回FactoryBean创建的实例,如果isSingleton返回true,则该实例会放到Spring容器的单例缓存池中Map
	@Nullable
	T getObject() throws Exception;

    //返回FactoryBean创建的bean类型
	@Nullable
	Class<?> getObjectType();

	//返回作用域是否单例
	default boolean isSingleton() {
		return true;
	}
}

2.2.1 新建类CompanyFactoryBean,实现FactoryBean接口,并重写方法:

public class CompanyFactoryBean implements FactoryBean<Company> {
    private String companyInfo;//注入公司名称,地址,规模  以逗号分隔

    public void setCompanyInfo(String companyInfo) {
        this.companyInfo = companyInfo;
    }

    @Override
    public Company getObject() throws Exception {
        //创建复杂对象Company
        Company company=new Company();
        String[] split = companyInfo.split(",");
        company.setName(split[0]);
        company.setAddress(split[1]);
        company.setScale(Integer.parseInt(split[2]));

        return company;
    }

    @Override
    public Class<?> getObjectType() {
        //返回bean的类型
        return Company.class;
    }

    @Override
    public boolean isSingleton() {
        //是否是单例
        return true;
    }
}
public class Company {
    private String name;
    private String address;
    private int scale;
	//省略getset 和toString
}

2.2.2 xml文件中配置bean

<bean id="companyBean" class="com.lagou.edu.factory.CompanyFactoryBean">
   <property name="companyInfo" value="拉钩,中关村,500"></property>
</bean>

2.2.3 测试

    @org.junit.Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Object companyBean = applicationContext.getBean("companyBean");
        System.out.println(companyBean);
    }
//结果返回的是 Company{name='拉钩', address='中关村', scale=500}   

虽然在xml配置文件中配置的bean的class="com.lagou.edu.factory.CompanyFactoryBean" 但是返回的Company类型。

如何返回CompanyFactoryBean类型呢?


打印结果为:com.lagou.edu.factory.CompanyFactoryBean@545b995e

3. 后置处理器

Spring提供了两种后处理bean的扩展接⼝,分别为 BeanPostProcessorBeanFactoryPostProcessor,两者在使⽤上是有所区别的。

⼯⼚初始化(BeanFactory)—> Bean对象

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

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

注意:对象不⼀定是springbean,⽽springbean⼀定是个对象

3.1 SpringBean生命周期图

按照上述描述的打印一下。看看是否一致:

//实现了BeanNameAware、BeanFactoryAware、ApplicationContextAware、InitializingBean,DisposableBean接口
public class Result implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {
    private String status;
    private String message;
	//省略getset toString方法

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4.BeanFactoryAware:"+beanFactory);
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("3.BeanNameAware:"+name);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("5.ApplicationContextAware:"+applicationContext);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("7.InitializingBean");
    }

    public void initMethodTest(){
        System.out.println("8.initMethod");
    }

    @PostConstruct
    public void postCoustrcut(){
        System.out.println("postCoustrcut");
    }

    //销毁之前执行
    @PreDestroy
    public void preDestroy(){
        System.out.println("销毁之前执行");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean");
    }
}

/**
    拦截实例化之后的对象(实例化了 并且属性注入了)
    拦截所有的
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("lazyResult".equalsIgnoreCase(beanName)){
            System.out.println("MyBeanPostProcessor before");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("lazyResult".equalsIgnoreCase(beanName)){
            System.out.println("MyBeanPostProcessor After");
        }
        return bean;
    }
}

//XML配置文件中:    
<bean id="lazyResult" class="com.lagou.edu.pojo.Result"  init-method="initMethodTest"></bean>
//测试:
    @org.junit.Test
    public void testBeanLazy(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        Object lazyResult =  applicationContext.getBean("lazyResult");
        System.out.println(lazyResult);
        applicationContext.close();
    }

打印出:

4. 其他:


原文:https://www.cnblogs.com/isdxh/p/14033760.html
作者: 邓晓晖