写在前面

本文一起看下spring aop 和 IOC相关的内容。

1：spring bean核心原理

1.1：spring bean的生命周期

在这里插入图片描述

spring bean生命周期，参考下图：
在这里插入图片描述

我们来一步步的看下。

1
其中1构造函数就是执行类的构造函数完成对象的创建，如下：

public User() {
    System.out.println("User 被实例化");
}

2
2是通过xml配置或者是@Resource等相关注入bean的注解，从容器中获取相关的spring bean进行赋值，如下：

在这里插入图片描述

3
3BeanNameAware，其中BeanNameAware是一个接口，只定义了一个唯一的方法void setBeanName(String name);,如果bean实现了该接口，则会回调setBeanName方法并将当前bean的beanName作为参数传递进去，这样，bean就能够获取自己的名称了，如下：

@Component
public class TestAware implements BeanNameAware {
    private String name;
    
    @Override
    public void setBeanName(String name) {
        this.name = name;
        System.out.println("TestAware.setBeanName, name is: " + this.name);
    }
}

4,5
4,5类似于3，也都分别定义了相关的xxxAware接口，以及对应的setXxx抽象方法，如下：

public class TestAware implements BeanFactoryAware, ApplicationContextAware {
    private BeanFactory beanFactory;
    private ApplicationContext applicationContext;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("TestAware.setBeanFactory");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("TestAware.setApplicationContext");
    }
}

6
6是spring留给我们的一个扩展的口，对应的接口是BeanPostProcessor，定义了初始化前执行的方法postProcessBeforeInitailization和初始化后执行的方法postProcessAfterInitialization如下：

public interface BeanPostProcessor {
    // 1：在InitailizingBean的afterProperties方法执行之前执行
    // 2：在自定义的init方法执行之前执行
    // 3:接收的参数是bean本身以及bean的名称
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	// 1：在InitailizingBean的afterProperties方法执行之后执行
    // 2：在自定义的init方法执行之后执行
    // 3:接收的参数是bean本身以及bean的名称
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

使用BeanPostProcessor的方式也比较简单，只需要实现该接口，对前置bean处理和后置bean处理两个方法提供具体实现后，将实现类注册为spring bean就可以了，如下可能实现：

public class MyBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("before--实例化的bean对象:"+bean+"\t"+beanName);
		// 可以根据beanName不同执行不同的处理操作
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("after...实例化的bean对象:"+bean+"\t"+beanName);
		// 可以根据beanName不同执行不同的处理操作
		return bean;
	}
}

7
InitializingBean也是一个扩展接口，定义了一个方法afterProperties，是在bean的属性都设置完毕后调用的方法,可以在该接口检测不可为空属性是否有值等操作，接口定义如下：

package org.springframework.beans.factory;

// 1：在所有属性设置完毕后执行
// 2：可以检测强制属性是否设置完成
// 3：可以使用自定义的init方法作为该方式的替代品
public interface InitializingBean {
	void afterPropertiesSet() throws Exception;

}

使用实例如下：

public class MyInitializingBeanTest implements InitializingBean {
    private String name;
    private int age;

    @Override
    public void afterPropertiesSet() throws Exception {
        String newName = "李四的歌";
        System.out.println("修改name属性值从 " + this.name + " -> " + newName);
        // 修改name属性的值
        this.name = newName;
    }
    ...
}

8
自定义的初始化方法，在bean标签中通过init-method设置，如下：

public class MyBeanWithInitMethod {
    private String name;

    public void changeNameProp() {
        String newName = "李四的歌";
        System.out.println("通过init-method修改name属性值从 "
                + this.name + " -> " + newName);
        this.name = newName;
    }
    ...
}

<bean class="yudaosourcecode.studyhelp.MyBeanWithInitMethod"
        id="myBeanWithInitMethod" init-method="changeNameProp">
    <property name="name" value="张三的歌"/>
</bean>

9
参考6,只不过是在InitialiBean和自定义init初始化方法执行完毕之后执行。
10
使用期。
11
当容器关闭时执行操作的接口规范，一般用来执行一些释放资源，收尾等操作，接口定义如下

package org.springframework.beans.factory;

// 1：当bean销毁时想要释放资源可以让bean实现该接口
// 2：可以使用自定义销毁方法作为另一个选择
public interface DisposableBean {
	void destroy() throws Exception;
}

实例如下：

public class MyLifeCycleBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean#destroy被调用了。。。");
    }
}

12
类似于11,自定义销毁方法，如下：

public class MyLifeCycleBean {

    public void destroyMethdo(){
        System.out.println("destroy-method 被调用...");
    }
}

<bean id="lifeCycle" 
      class="yudaosourcecode.studyhelp.MyLifeCycleBean"
      destroy-method="destroyMethdo"/>

1.2：spring bean生命周期完整实例

BeanPostProcessor

public class BeanPostProcessor123 implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("6：BeanPostProcessor#postProcessBeforeInitialization被调用了。。。");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("9：BeanPostProcessor#postProcessAfterInitialization被调用了。。。");
        return bean;
    }

}

bean

public class MyLifeCycleBean implements BeanNameAware,
        BeanFactoryAware,
        ApplicationContextAware,
//        BeanClassLoaderAware,
//        BeanPostProcessor,
        InitializingBean,
        DisposableBean {
    private String test;

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

    // 普通方法
    public void display(){
//        System.out.println("普通类实例方法调用...");
        System.out.println("10:使用中。。。");
    }

    public String getTest() {
        return test;
    }

    public void setTest(String test) {
        System.out.println("2:依赖注入");
        this.test = test;
    }

    public MyLifeCycleBean() {
        System.out.println("1:构造函数");
    }
//    @Override
//    public void setBeanClassLoader(ClassLoader classLoader) {
//        System.out.println("BeanClassLoaderAware 被调用了。。。");
//    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4:BeanFactoryAware 被调用了。。。");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("3:BeanNameAware 被调用了。。。");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("11:DisposableBean#destroy被调用了。。。");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("7:InitializingBean#afterPropertiesSet被调用了。。。");
    }
//
//    @Override
//    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
//        System.out.println("BeanPostProcessor#postProcessBeforeInitialization被调用了。。。");
//        return bean;
//    }
//
//    @Override
//    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
//        System.out.println("BeanPostProcessor#postProcessAfterInitialization被调用了。。。");
//        return bean;
//    }

    public void initMethod(){
        System.out.println("8: init-method 被调用...");
    }

    public void destroyMethdo(){
        System.out.println("12：destroy-method 被调用...");
    }
}

xml配置

<?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="lifeCycle" class="yudaosourcecode.studyhelp.MyLifeCycleBean"
          init-method="initMethod" destroy-method="destroyMethdo">
        <property name="test" value="test"/>
    </bean>

    <bean class="yudaosourcecode.studyhelp.BeanPostProcessor123"/>
</beans>

测试

@Test
public void mylifecyclebeantest111() {
//        ClassPathResource resource
//                = new ClassPathResource("mylifecyclebeantest.xml");
//        XmlBeanFactory xbf = new XmlBeanFactory(resource);
    AbstractApplicationContext ac = new ClassPathXmlApplicationContext("mylifecyclebeantest.xml");
//        Closeable
    // 手动添加后置bean处理器
//        xbf.addBeanPostProcessor(new MyLifeCycleBean());
//        ac.addBeanPostProcessor(new BeanPostProcessor123());
//        ac.
//        MyLifeCycleBean lifeCycle
//                =
    ac.getBean("lifeCycle", MyLifeCycleBean.class).display();
//        lifeCycle.display();
    // 销毁容器
    ac.close();
}

运行：

1:构造函数
2:依赖注入
3:BeanNameAware 被调用了。。。
4:BeanFactoryAware 被调用了。。。
5:ApplicationContextAware 被调用。。。
6：BeanPostProcessor#postProcessBeforeInitialization被调用了。。。
7:InitializingBean#afterPropertiesSet被调用了。。。
8: init-method 被调用...
9：BeanPostProcessor#postProcessAfterInitialization被调用了。。。
10:使用中。。。
11:DisposableBean#destroy被调用了。。。
12：destroy-method 被调用...

对比如下图：

在这里插入图片描述

1.3：spring xml配置原理

这部分来看看下我们在xml配置的<bean>标签是如何解析为spring bean的，我们会定义如下的xml配置文件：

<?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="lifeCycle" class="yudaosourcecode.studyhelp.MyLifeCycleBean"
          init-method="initMethod" destroy-method="destroyMethdo">
        <property name="test" value="test"/>
    </bean>

    <bean class="yudaosourcecode.studyhelp.BeanPostProcessor123"/>
</beans>

其中在<beans中声明的我们叫做是命名空间，然后在命名空间中就可以定义各种各样的标签，并定义了校验xml的xsd，为了解决通过互联网直接加载xsd慢，或者是加载不到的问题，定义了配置文件spring.schemas，配置了命名空间和对应的本地xsd文件的对应关系：

在这里插入图片描述

这样就可以直接从jar包中获取xsd文件了，那么标签如何解析呢？需要使用到spring.handlers，如下：

在这里插入图片描述

当然我们也可以自定义标签，同样也需要在spring.schemas中配置我们自己的xsd，以及并实现并配置解析对应标签的handler到spring.handles配置文件中，具体可以参考spring的自定义标签一文。

1.4：spring bean配置方式演进

1.0/2.0 XML配置bean，@Autowire注解注入bean
2.5 @Service xml配置和注解配置bean方式混用的半自动注解配置
3.0 @Bean,@Condition Javaconfig方式配置bean
4.0 @Condition，@AutoConfigureX 全自动注解配置

在这里插入图片描述

2：spring AOP

通过前面分析的spring bean的功能，我们已经能够灵活地定义各种对象实例，并设置其各种依赖关系了，此时假定我们现在有类似于下面这样的需求：

1:怀疑某个方法执行的慢，影响性能，但又无法直接修改源代码看其耗时
2：想要记录某一批方法的调用日志，因为方法很多，一个个改的话非常麻烦
3：程序有bug，但是程序年代久远，源程序早已经遗失，但又必须解决

该怎么做呢？在计算机领域有这样一个至理名言，计算机领域所有的问题都可以通过加一层来解决，这里的问题可以吗？可以的，我们只要在方法执行的前和后都加一层就行了，如下：

在这里插入图片描述

spring为了实现这个加一层的功能就提供了对应的功能实现，首先我们需要定义要对那些方法加一层，通过如下红框方式来表示：

在这里插入图片描述

spring给其起个一个专门的名称切点,即要切的点，要拦截的方法，这样还不够，知道要对哪些方法加一层了，但是需要做什么呢，这个时候就可以这样定义：

在这里插入图片描述

spring也给其起了一个专门的名称通知，其中在方法执行前执行的叫做前置通知，在方法执行后执行的叫做后置通知，所有的同志加在一起，spring也起了一个专门的名称切面。

以上这个实现加一层的功能，spring也提供了一个专门的名称，aspect oriented programming，即面向切面编程，即AOP。

写在后面

参考文章列表

Java 操作 XML(11)–XMLBeans 使用。

spring的自定义标签。

Java框架之spring 的 AOP 和 IOC

写在前面

1：spring bean核心原理

1.1：spring bean的生命周期

1.2：spring bean生命周期完整实例

1.3：spring xml配置原理

1.4：spring bean配置方式演进

2：spring AOP

写在后面

参考文章列表

相关文章

代码随想录再战day3

Yolov5-Face 原理解析及算法解析

Ubuntu连不上网，在windows安装docker后

MongoDB简介

【AcWing算法基础课】第二章数据结构（部分待更）

短视频矩阵抖音账号矩阵系统源码开发者自研（一）

charles unknown 问题和手机代理设置（iOS手机）

buuctf re（二）+ web CheckIn

蓝桥杯专题-试题版-【九宫重排】【格子刷油漆】【回文数字】【国王的烦恼】

高级第二个月复习

Flutter悬浮UI的设计Overlay组件

【记录】实践场景

css新特性（五）

多元分类预测 | Matlab粒子群算法(PSO)优化混合核极限学习机(HKELM)分类预测，多特征输入模型，PSO-HKELM分类预测

面向切面编程-AOP

Spring Boot中的事务隔离级别

Jmeter（jmeter-plugins插件的安装使用）

Chrome/Edge 浏览器多账号登录，测试同一业务系统的不同账号角色

vue+elementui实现英雄联盟道具城

【SQL应知应会】分析函数的点点滴滴（一）