使ssm的的时候。首先就会找到spring ，为什么？

应为我们需要将对象交给srping来统一管理，

我们先来复习一下，spring的两大特性

ioc

我们同过spring来帮助我们创建类，帮助我们类之间的解耦

aop

可以在不改变类的源码情况下，添加一些增强的方法，可以是前置，后置 ，异常等等

我们想要用框架，实现越来越多的功能的时候，往往要填加很多很多的bean组件，在使用的时候就可以直接去使用ioc容器中的类，

后置处理器

创建类也有区分不同

  • 有工厂创建的单例
  • 有bean的创建

这些都需要有对应的后置处理器，接下来我们就来看看spring给我们提供了那些灵活的处理器，只要是注入到容器中的bean在即将初始化的时候，都会执行后置处理器，完成之后才放入spring的池子中。

bean的处理器

BeanPostProcessor : bean的后置处理器作用是在Bean对象在实例化和依赖注入完毕后，在显示调用初始化方法的前后添加我们自己的逻辑。注意是Bean实例化完毕后及依赖注入完成后触发的。接口的源码如下

源码中有两个方法：

postProcessBeforeInitialization：实例化，依赖注入完毕，再调用显示初始化之前完成游戏额定制初始化的任务

postProcessAfterInitialization：实例化，依赖注入，初始化后执行

这里我们写个小demo来体验一下

新建一个类，叫myBeanPostProcessor,我们实现这个后置处理器的接口

参数解释 :

参数1 bean ：就是我们注入到ioc的对象

参数2 beanName : 就是我们注入到ioc的对象名字

public class MyBeanPostProcessor implements BeanPostProcessor {
   
  public Object postProcessBeforeInitialization(Object bean, String beanName)
      throws BeansException {
   
    System.out.println(beanName+"初始化执行前");
    return bean;
  }

  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
   
    System.out.println(beanName+"初始化执行后");
    return bean;
  }
}

简单实例，实行之后，可以看我们注入对象的初始化前和初始化后的输出信息

Bean工厂后置处理器

这个bean工厂处理器，是在所有bean的创造之前对bean的一些修改，我们可以在没有构造对象之前，对bean做什么，

postProcessBeanFactory方法 ： 参数有bean工厂的对象，可以查看到一些信息

他就是返回一个在bena创建之前的创建工厂对象，我们可以查看工厂中要创建的bean信息

BeanDefinitionRegistryPostProcessor（后置bean组件信息处理器）

为了处理我们在放容器到spring的时候的一些配置，比如是否单例，初始化方法，销毁方法，等等信息的后置处理器

方法

postProcessBeanDefinitionRegistrybean对象的配置信息注册

postProcessBeanFactory之后进到bean的工厂

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry)
      throws BeansException {
   
    System.out.println("postProcessBeanDefinitionRegistry:" + beanDefinitionRegistry);
  }

  public void postProcessBeanFactory(
      ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
   
    System.out.println("ConfigurableListableBeanFactory:" + configurableListableBeanFactory);
  }

Bean组件的各个生命周期

  • bean组件信息处理器：组件信息注册
  • bean工厂创建，我们自己写的后置工厂处理器是一样的，
  • bean创建和注入完成
  • 初始化前
  • 初始化完成
  • 初始后
  • 销毁

小demo，使用Bean工厂操作bean的注入

全新配置文件 : beanFactoryProcessor.xml,就放两个没有任何配置的bean对象

    <bean id="mypostProcessBeanFactory" class="com.hyc.Processor.MypostProcessBeanFactory"/>
    <bean id="demobean" class="com.hyc.springBean.demoBean"></bean>

用beanFactory操作bean对象，实现配置，和属性注入

public class MypostProcessBeanFactory implements BeanFactoryPostProcessor {
   
  public void postProcessBeanFactory(
      ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
   
    System.out.println("configurableListableBeanFactory" + configurableListableBeanFactory);
    // 获取对象
    AbstractBeanDefinition demobean =
        (AbstractBeanDefinition) configurableListableBeanFactory.getBeanDefinition("demobean");
    // 设置初始化方法
    demobean.setInitMethodName("init1");
    // 注入name值
    MutablePropertyValues propertyValues = demobean.getPropertyValues();
    propertyValues.add("name", "PostProcessorFactory bane name");
    // 设置销毁方法
    demobean.setDestroyMethodName("destroy1");
  }
}

之后输出查看信息

接下来我们复制一个自定义bean工厂

配置文件新增一个bean

    <bean id="mypostProcessBeanFactory2" class="com.hyc.Processor.MypostProcessBeanFactory2"/>

给两个工厂实现优先级接口，设置优先级，

一号工厂优先级为5

二号工厂优先级为10

public class MypostProcessBeanFactory2 implements BeanFactoryPostProcessor, Ordered {
   
 //之前工厂的代码省略

  public int getOrder() {
   
    return 10;
  }

启动测试

可以看到有级别为5的是线执行的

完美，以上就是用后置处理器来操作bean属性的是实战了

spring事件***

可以监听我们spring中发生的时间，我们也可以自定义一个spring的事件***

我们学习这个主要是要知道spring在容器中执行的时候都派发了什么事件

这里我们实现ApplicationListener<ApplicationEvent>

这里泛型里的对象是全局的消息，我们也可以写一个自己的自定义的

public class MyApplicationEvent extends ApplicationEvent {
   
  public MyApplicationEvent(Object source) {
   
    super(source);
  }

  String username;
  String emial;

  public String getUsername() {
   
    return username;
  }

  public void setUsername(String username) {
   
    this.username = username;
  }

  public String getEmial() {
   
    return emial;
  }

  public void setEmial(String emial) {
   
    this.emial = emial;
  }

  public MyApplicationEvent(Object source, String username, String emial) {
   
    super(source);
    this.username = username;
    this.emial = emial;
  }
}

之后创建新的配置文件 Listener.xml将事件***加入到spring容器中

  <bean id="listener" class="com.hyc.listener.myApplicationListener"></bean>

修改事件***，让我们来看看是在生成bean的时候都派发了什么事件吧

public class myApplicationListener implements ApplicationListener<ApplicationEvent> {
   
  public void onApplicationEvent(ApplicationEvent event) {
   
    System.out.println("接受到的事件" + event);
      //这里怕判断是如果有我们自己的定义内容将事件***强转成我们的自定***，保证自己的自定义事件也可以输出
    if (event instanceof MyApplicationEvent) {
   
      MyApplicationEvent myApplicationEvent = (MyApplicationEvent) event;
      System.out.println("用户名" + myApplicationEvent.getUsername());
      System.out.println("用户邮箱" + myApplicationEvent.getEmial());
    }
  }
}

之后测试

public class listenerMain {
   
  public static void main(String[] args) {
   
    ClassPathXmlApplicationContext ApplicationContext =
        new ClassPathXmlApplicationContext("Listener.xml");
    //创建事件对象
    MyApplicationEvent event = new MyApplicationEvent("事件内容", "james", "123@qq,com");
    //发送事件
    ApplicationContext.publishEvent(event);
    ApplicationContext.close();
    //
  }
}

可以看到图中spring的加载过程越来越明显清晰了起来

探究源码

我们进入调试查看源码

由于源码非常之多，这里就只记录执行过程中做的一些事情

工厂源码

加载过程

新建对象找到spring对象的位置，找到配置文件的位置

之后判断refresh，开始刷新

refresh

spring最核心的方法，refresh都做了什么呢？

首先就是准备刷新：

  • 记录毫秒值，是不是关闭，选择启动
  • 日志打印，给子类做一些默认的事情，校验一些属性，有没有子类复写的一些属性，如果有就执行，没有继续往下走
  • 判断，之后将应用的一些初始化事件放到集合里

准备好刷新之后，

准备bean工厂

  • 添加bean的加载器，spring表达式的解析器，属性编辑器
  • 设置一些必要的后置处理器
  • 忽略一些接口
  • 将bean的信息注册，加入资源解析器，注册事件发布，上下文对象
  • 获取一些系统属性判断加载，如：jre的名字，user.home的路径，语言环境等等
  • 之后返回工厂对象

工厂对象创建

  • 判断是否有工厂，没有的话创建
  • 创建一个默认的工厂返回。默认创建的工厂包含了很多的默认信息
  • 之后给bean工厂按满足的条件赋值
  • 解析描述信息类，加载描述信息，如果是xml那么就是解析xml
  • 将解析完的类描述i信息，复制到Bean工厂里

到这里工厂的创建就完成了

后置处理器

注册全部的后置处理器，一般来说。有多少注入的类就有多少后置处理器

执行流程

  • 遍历，有多少后置处理器，创建集合，循环判断所有处理器，是否属于当前接口，之后将所有的后置处理器放在对应的集合里，给处理器id
    • 优先级
    • 内部的
    • 等等
  • 之后，给优先级集合中的处理器排序，有序的注册
  • 之后判断其他的处理器的集合
  • 最后判断没有优先级的集合，最终全部注册到容器中

国际化和事件***

  • 判断是否有国际化，如果包含，加入到工厂里，输出日志调用
  • 事件***也是，判断是否有，如果保函就从里面拿出来，日志输出，如果不保函就创建一个事件***，

注册事件***

  • 默认是没有，如果有，拿到全部的默认***
  • 设置临时类加载器
  • 判断事件***是否是空的，如果不是就全都拿来发出去，

创建bean

创建单例对象，不能是懒加载的

  • 首先先寻找工厂里有没有值解析器，如果没有就创建一个新的值解析器
  • 查看冻结配置，为true就将存放再配置文件的bean组件们，转换成字符串数组
  • 根据名字从集合中拿出来，遍历创建对象，根据名字拿到bean的信息，满足三个条件才往后走
    • 不能是抽象的
    • 必须是单例的
    • 不能是懒加载的
  • 如果不满足，那就是工厂创建
  • 从缓存拿到单例对象，要是没有就去看是否满足判断条件，查看是否多次创建对象，之后查看bean工厂，
  • 标记当前对象，正在创建，之后放到set集合中，表示最后一次创建，
  • 检查当前bean的信息，查看是否需要其他的依赖来创建，判断是不是单例，
  • 用集合存放对象和一个构造工厂
  • 有一个实例resolveBeforeInstantiation的创建，通过后置处理器，来实现创建代理对象，这一步就是有可能创建对象的，当我们要用aop的时候就用这个方法拿到代理对象.
  • 如果没有就创建对象，传入对象信息，再次判断是不是单例的，之后创建单例对象，
  • 之后判断对象，看是不是需要必须指定的构造方法，默认是空参数构造方法，
  • 之后拿到bean实例，判断是否为空，判断接口类型，检查对象，拿到无参数构造方法
  • 创建对象，用反射标记当前的构造方法，用无参构造方法构建实例，到这里bean对象就创建成功了
  • 这里的bean对象是最初始的状态，包装给BeanWapper做一个初始化，到这里空的对象就创建好了。
  • 之后调用后置处理器，回调如果组件里有就调后置处理器，最后到了这里开始对空对象赋值
  • 之后再次拿到单例对象，之后就去拿到赋值，返回创建的对象
  • 通过单例工厂创建出对象，将新建的对象放入单例对象集合中
  • 移除用来检查循环依赖的单例工厂，确认注册对象成功，set的不会存放重复值的，所以就一个
  • 经过大量判断之后返回对象实例

完成刷新，发布事件消息

  • 初始化包含的处理器，如果有就get拿进去，如果没有那就创建
  • 之后刷新后置处理器
  • 发送创建事件信息，告诉spring初始化完成了
  • 之后注册上下文拿到当前的名字。如果不等于空那就加入到applicationContext中，至此完成

循环依赖问题

我们创建两个对象，

UserA的构造方法调用UserB对象

循环依赖，

这个是调试断点进入到有参构造方法

  • 进入之后，可以看到需要参数要引用到UserB，UserB也是个bean所以spring要去创建userB所以userB就需要参数创建userA导致一直循环创建
  • 当spring发现UserB还在创建userA的时候spring就会抛出异常为什么再次创建的时候就异常了呢？
  • 因为存放获取bean的是set之前创建bean的时候我们有提到，只要创建bean就会放在里，有个判断，set是没有重复值的只要判断没通过，就证明之前有正在创建的对象·，于是抛出异常
  • 通过缓存的要创建的bean来判断是否重复引用bean，解决循环依赖问题

如何解决呢？

  • 我们用构造方法调用引用其他类，创建的时候，一直在重复的创建对象
  • 我们只需要，用属性来声明一个应用对象，需要的时候调用，使用的完就销毁
  • 就不会存在循环依赖的问题了

总结

spring框架的精妙之处，太多值得我们学习，这次的bean的一生只是将思想和大致过程讲解，还有很多需要结合场景的细节，需要我们自己的去探索，不断地深究才可以让自己的技术变得强大