概要

• 手写Spring启动以及扫描流程
• 手写getBean流程
• 手写Bean生命周期流程
• 手写依赖注入流程
• 手写BeanPostProcessor机制
• 手写Aop机制

Spring启动以及扫描流程实现

我们平时都是使用这两种方法获得spring容器，上面的是通过加载类路径上的配置文件来获得容器。下面的方式和上面的原理相同只不过是通过注解的形式去实现，我们传入的也是一个配置类的class文件，我们可以把这个文件类比成第一种方法中的xml文件，然后这个xml文件里的一个个标签都变成了注解。

基础环境搭建

首先搭建好基础环境：

我们的测试类：

public class MySpringTest {
    public static void main(String[] args) {
        MyApplicationContext applicationContext = new MyApplicationContext(AppConfig.class);

        Object bean = applicationContext.getBean("");

        System.out.println(bean);
    }
}

我们的容器类MyApplicationContext ：

public class MyApplicationContext {
    private Class configClass;

    public MyApplicationContext(Class configClass) {
        this.configClass = configClass;
    }

    public Object getBean(String beanName){
        return null;
    }
}

我们原来在编写Spring的配置文件的时候会使用一个注解@ComponentScan，来定义一个扫描路径。所以我们这里也定义了一个。

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface ComponentScan {

    String value();
}

• Retention指定该注解的生命周期，设置成RUNTIME便于反射获取

• Target指定注解的使用位置，设置为TYPE表示能在类上使用

我们的AppConfig；

@ComponentScan("com.zyb.service")
public class AppConfig {
}

根据扫描包我们再创建一个业务层类UseService，这个UseService我们一般会使用@Component注解进行标记，这里我们也是如此：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {
    String value();
}

@Component("userService")
public class UserService {

}

扫描逻辑实现

我们的思路就是；

• 解析配置类
• 拿到ComponentScan注解
• 得到扫描路径
• 进行扫描

首先我们可以通过如下代码拿到AppConfig中ComponentScan的内容：

public MyApplicationContext(Class configClass) {
        this.configClass = configClass;
        //解析配置类
        //ComponentScan注解 --》 扫描路径 --》 扫描

        ComponentScan componentScanAnnotation = (ComponentScan)configClass.getDeclaredAnnotation(ComponentScan.class);
        String path = componentScanAnnotation.value();
        System.out.println(path);

}

我们测试一下：

拿到路径之后我们就可以开始扫描了。而扫描的目的并不是包下的所有类，而是那些带有@Component注解的类，而Spring会将他们的对象当作Spring中的一个bean。

这里我们扫描的思路如下：

• 通过类加载器，得到类路径上的class文件
• 对文件进行筛选
  • 是否以class结尾(判断是否为class文件)
  • 对class文件名进行处理
    • 替换\为.
    • 截取全限定名
• 然后将类加载进jvm虚拟机
• 判断运行时类是否有@Component注解，如果有则进行相关的创建bean对象操作

代码如下：

    public MyApplicationContext(Class configClass) {
        this.configClass = configClass;
        //解析配置类
        //ComponentScan注解 --》 扫描路径 --》 扫描
        ComponentScan componentScanAnnotation = (ComponentScan)configClass.getDeclaredAnnotation(ComponentScan.class);
        String path = componentScanAnnotation.value();
        String searchPath = path.replace(".", "/");
        ClassLoader classLoader = MyApplicationContext.class.getClassLoader();
        URL resource = classLoader.getResource(searchPath);
        File file = new File(resource.getFile());
        if (file.isDirectory()) {
            //首先筛选末尾是.class文件的
            File[] files = file.listFiles();
            for (File classFile: files) {
                String absolutePath = classFile.getAbsolutePath();
                if (absolutePath.endsWith(".class")) {
                    //拼接全限定名
                    String fullyQualifiedClassName = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
                    fullyQualifiedClassName = fullyQualifiedClassName.replace("\\", ".");
                    //使用app类加载器加载这个类
                    Class<?> aClass = null;
                    try {
                        aClass = classLoader.loadClass(fullyQualifiedClassName);
                        if (aClass.isAnnotationPresent(Component.class)) {
                            //然后加载bean

                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                    
                }
            }
        }
    }

注意；

• classLoader.loadClass接收的是类的全限定名

当我们确认当前类有@Component注解的时候并不是急着去给其创建bean，我们在使用spring的时候是可以决定该bean是否为单例的。我们在这里还是创建一个同名注解@Scope：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Scope {
    String value() default "single";
}

默认是single单例的，如果是原型bean则传入prototype。

而我们实现单例bean是通过一个Map单例池，不考虑懒加载。

现在我们的大致思路就是在通过@Scope注解确定bean是单例模式还是原型模式之后，在进行相应的bean的创建，但是这里我们考虑到一个问题，我们在getBean的时候如果每次都去解析这个类获得@Scope是很麻烦的。所以我们在这里引入一个新的概念BeanDefinition。

BeanDefinition中包含了当前bean的所有定义，例如bean的类型、作用域、是否懒加载等等。注意bean的name不在BeanDefinition中：

public class BeanDefinition {
    private Class beanClass;
    private String scope;

    public Class getBeanClass() {
        return beanClass;
    }

    public void setBeanClass(Class beanClass) {
        this.beanClass = beanClass;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }
}

在Spring中每扫描到一个bean都会对其进行解析然后生成各自的BeanDefinition实例，随后将这个BeanDefinition对象放在map中，key为bean的name，BeanDefinition对象作为value。以后当我们要获取一个bean时先会去map中查看，如果查找不到bean的BeanDefinition才会去解析类，以此来减少解析类的次数提高效率。

接下来我们完善一下代码，思路如下：

• 判断运行时类是否有Component注解
• 如果有，再获取该类的@Scope
  • 如果没有注解则为默认的单例模式
  • 如果有此注解则为原型模式
• 然后再把对应的模式添加到BeanDefinition
• 将此BeanDefinition和对应的bean name添加到beanDefinitionMap中

getBean方法思路：

• 判断要获取的bean的BeanDefinition是否存在于beanDefinitionMap
  • 如果不存在，说明容器中不存在该bean则直接报错
  • 如果存在则在BeanDefinition中拿到该bean的scope，根据scope再去具体的创建bean

代码如下：

public class MyApplicationContext {
    private Class configClass;
    private ConcurrentHashMap<String,Object> singleBeanHashMap = new ConcurrentHashMap<>();
    private HashMap<String,BeanDefinition> beanDefinitionHashMap  = new HashMap<>();

    public MyApplicationContext(Class configClass) {
        this.configClass = configClass;
        //解析配置类
        //ComponentScan注解 --》 扫描路径 --》 扫描
        ComponentScan componentScanAnnotation = (ComponentScan)configClass.getDeclaredAnnotation(ComponentScan.class);
        String path = componentScanAnnotation.value();
        String searchPath = path.replace(".", "/");
        ClassLoader classLoader = MyApplicationContext.class.getClassLoader();
        URL resource = classLoader.getResource(searchPath);
        File file = new File(resource.getFile());
        if (file.isDirectory()) {
            //首先筛选末尾是.class文件的
            File[] files = file.listFiles();
            for (File classFile: files) {
                String absolutePath = classFile.getAbsolutePath();
                if (absolutePath.endsWith(".class")) {
                    //拼接全限定名
                    System.out.println(classFile);
                    String fullyQualifiedClassName = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
                    fullyQualifiedClassName = fullyQualifiedClassName.replace("\\", ".");
                    //使用app类加载器加载这个类
                    Class<?> aClass = null;
                    try {
                        aClass = classLoader.loadClass(fullyQualifiedClassName);
                        if (aClass.isAnnotationPresent(Component.class)) {
                            BeanDefinition beanDefinition = new BeanDefinition();
                            if (aClass.isAnnotationPresent(Scope.class)) {
                                Scope scopeAnnotation = aClass.getAnnotation(Scope.class);
                                String scope = scopeAnnotation.value();
                                beanDefinition.setScope(scope);
                            }else{
                                beanDefinition.setScope("single");
                            }

                            Component componentAnnotation = aClass.getDeclaredAnnotation(Component.class);
                            String beanName = componentAnnotation.value();
                            beanDefinitionHashMap.put(beanName,beanDefinition);

                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }

                }
            }
        }
    }

    public Object getBean(String beanName){
        //首先判断是否存在该bean的BeanDefinition
        if (beanDefinitionHashMap.containsKey(beanName)) {
            BeanDefinition beanDefinition = beanDefinitionHashMap.get(beanName);
            if (beanDefinition.getScope().equals("single")) {
                //单例模式创建bean
            }else {
                //原型模式创建bean
            }
        }else {
            throw new NullPointerException("不存在该bean");
        }
    }
}

最后我们可以把扫描这部分逻辑提取出来重新建立一个scan方法：

public class MyApplicationContext {
    private Class configClass;
    private ConcurrentHashMap<String,Object> singleBeanHashMap = new ConcurrentHashMap<>();
    private HashMap<String,BeanDefinition> beanDefinitionHashMap  = new HashMap<>();

    public MyApplicationContext(Class configClass) {
        this.configClass = configClass;
        scan(configClass);
    }

    private void scan(Class configClass) {
        //解析配置类
        //ComponentScan注解 --》 扫描路径 --》 扫描
        ComponentScan componentScanAnnotation = (ComponentScan)configClass.getDeclaredAnnotation(ComponentScan.class);
        String path = componentScanAnnotation.value();
        String searchPath = path.replace(".", "/");
        ClassLoader classLoader = MyApplicationContext.class.getClassLoader();
        URL resource = classLoader.getResource(searchPath);
        File file = new File(resource.getFile());
        if (file.isDirectory()) {
            //首先筛选末尾是.class文件的
            File[] files = file.listFiles();
            for (File classFile: files) {
                String absolutePath = classFile.getAbsolutePath();
                if (absolutePath.endsWith(".class")) {
                    //拼接全限定名
                    System.out.println(classFile);
                    String fullyQualifiedClassName = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
                    fullyQualifiedClassName = fullyQualifiedClassName.replace("\\", ".");
                    //使用app类加载器加载这个类
                    Class<?> aClass = null;
                    try {
                        aClass = classLoader.loadClass(fullyQualifiedClassName);
                        if (aClass.isAnnotationPresent(Component.class)) {
                            BeanDefinition beanDefinition = new BeanDefinition();
                            if (aClass.isAnnotationPresent(Scope.class)) {
                                Scope scopeAnnotation = aClass.getAnnotation(Scope.class);
                                String scope = scopeAnnotation.value();
                                beanDefinition.setScope(scope);
                            }else{
                                beanDefinition.setScope("single");
                            }

                            Component componentAnnotation = aClass.getDeclaredAnnotation(Component.class);
                            String beanName = componentAnnotation.value();
                            beanDefinitionHashMap.put(beanName,beanDefinition);

                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }

                }
            }
        }
    }

    public Object getBean(String beanName){
        //首先判断是否存在该bean的BeanDefinition
        if (beanDefinitionHashMap.containsKey(beanName)) {
            BeanDefinition beanDefinition = beanDefinitionHashMap.get(beanName);
            if (beanDefinition.getScope().equals("single")) {
                //单例模式创建bean
            }else {
                //原型模式创建bean
            }
        }else {
            throw new NullPointerException("不存在该bean");
        }
    }
}

bean创建的简单实现

spring容器启动之后，先进行扫描步骤，而这个扫描的主要作用就是得到BeanDefinition，这样我们就有了BeanDefinitionMap，然后我们就可以根据BeanDefinitionMap去创建单例池singleBeanHashMap为我们的getBean方法提供支持。

在getBean方法中：

• 如果是单例模式的bean就直接在singleBeanHashMap中去拿
• 如果是原型模式的bean就直接使用creatBean方法创建bean

我们这里的creatBean方法就是用来创建bean的方法，我们这里暂时只对此方法进行一个简单的实现。

整体代码如下：

public class MyApplicationContext {
    private Class configClass;
    private ConcurrentHashMap<String,Object> singleBeanHashMap = new ConcurrentHashMap<>();
    private HashMap<String,BeanDefinition> beanDefinitionHashMap  = new HashMap<>();

    public MyApplicationContext(Class configClass) {
        this.configClass = configClass;
        scan(configClass);
        //scan之后就得到了beanDefinitionHashMap，然后我们根据此来构建singleBeanHashMap
        for (String beanName:beanDefinitionHashMap.keySet()) {
            BeanDefinition beanDefinition = beanDefinitionHashMap.get(beanName);
            if (beanDefinition.getScope().equals("single")) {
                singleBeanHashMap.put(beanName,createBean(beanName));
            }
        }
    }

    public Object createBean(String name){
        BeanDefinition beanDefinition = beanDefinitionHashMap.get(name);
        Class beanClass = beanDefinition.getBeanClass();
        Object instance = null;
        try {
            instance = beanClass.getConstructor().newInstance();
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return instance;
    }

    private void scan(Class configClass) {
        //解析配置类
        //ComponentScan注解 --》 扫描路径 --》 扫描
        ComponentScan componentScanAnnotation = (ComponentScan)configClass.getDeclaredAnnotation(ComponentScan.class);
        String path = componentScanAnnotation.value();
        String searchPath = path.replace(".", "/");
        ClassLoader classLoader = MyApplicationContext.class.getClassLoader();
        URL resource = classLoader.getResource(searchPath);
        File file = new File(resource.getFile());
        if (file.isDirectory()) {
            //首先筛选末尾是.class文件的
            File[] files = file.listFiles();
            for (File classFile: files) {
                String absolutePath = classFile.getAbsolutePath();
                if (absolutePath.endsWith(".class")) {
                    //拼接全限定名
                    System.out.println(classFile);
                    String fullyQualifiedClassName = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
                    fullyQualifiedClassName = fullyQualifiedClassName.replace("\\", ".");
                    //使用app类加载器加载这个类
                    Class<?> aClass = null;
                    try {
                        aClass = classLoader.loadClass(fullyQualifiedClassName);
                        if (aClass.isAnnotationPresent(Component.class)) {
                            BeanDefinition beanDefinition = new BeanDefinition();
                            beanDefinition.setBeanClass(aClass);
                            if (aClass.isAnnotationPresent(Scope.class)) {
                                Scope scopeAnnotation = aClass.getAnnotation(Scope.class);
                                String scope = scopeAnnotation.value();
                                beanDefinition.setScope(scope);
                            }else{
                                beanDefinition.setScope("single");
                            }

                            Component componentAnnotation = aClass.getDeclaredAnnotation(Component.class);
                            String beanName = componentAnnotation.value();
                            beanDefinitionHashMap.put(beanName,beanDefinition);

                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }

                }
            }
        }
    }

    public Object getBean(String beanName){
        //首先判断是否存在该bean的BeanDefinition
        if (beanDefinitionHashMap.containsKey(beanName)) {
            BeanDefinition beanDefinition = beanDefinitionHashMap.get(beanName);
            if (beanDefinition.getScope().equals("single")) {
                //单例模式创建bean
                return singleBeanHashMap.get(beanName);
            }else {
                //原型模式创建bean
                return createBean(beanName);
            }
        }else {
            throw new NullPointerException("不存在该bean");
        }
    }
}

我们测试一下效果：

• 当UserService类上的Scope Vablue值为prototype
  

• 当UserService类上的Scope Vablue值为single或者去掉Scope注解
  

依赖注入实现

前面我们对createBean方法进行了一个简单地实现，这里依赖注入的实现就是将createBean写完整。我们知道不管是单例bean还是原型bean他们的作用范围可能不同，但是他们在创建某一个对象的时候步骤是一样的，这也就是我们为什么要单独抽取一个方法出来专门用来创建bean。

这里我们只考虑使用@Autowired注解进行注入，createBean方法思路：

• 首先通过beanName在BeanDefinition中拿到Class对象
• 通过空参构造器创建instance对象
• 遍历当前Class所有成员变量，检查是否有@Autowired注解
  • 如果没有则直接调用空参构造器返回bean
  • 如果有，那么我们此时只能根据当前属性的属性名以及类型进行依赖注入，这里我们选择简单一点的按照名称注入，思路就是将属性名传入到getBean方法中尝试去获取bean，在getBean方法我们会对当前依赖进行一个判断
    • 如果是单例模式，则将依赖直接从单例池中拿出来对依赖进行赋值
    • 如果不是单例模式，则递归调用createBean方法，创建依赖，再对依赖进行赋值

代码如下：

    public Object createBean(String name){
        BeanDefinition beanDefinition = beanDefinitionHashMap.get(name);
        Class beanClass = beanDefinition.getBeanClass();

        Object instance = null;
        try {
            instance = beanClass.getConstructor().newInstance();
            for (Field field:beanClass.getDeclaredFields()) {
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    //拿到属性名
                    String fieldName = field.getName();
                    field.set(instance,getBean(fieldName));
                }
            }
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return instance;
    }

我们测试一下：

结果：

BeanNameAware回调实现

我们思考一个场景：

如果我们想获得当前的beanName，这里是不能使用Autowired的。Spring为我们提供了一种接口BeanNameAware，将当前的beanName返回给我们。

我们将这个功能实现一下：

首先写一个BeanNameAware接口：

public interface BeanNameAware {
    void setBeanNameAware(String beanName);
}

然后我们在createBean方法中调用接口方法，传入bean的name：

    public Object createBean(String name){
        ···
       
            //进行依赖注入
            ···

            //BeanNameAware返回bean name
            if (instance instanceof BeanNameAware) {
                BeanNameAware beanNameAware = (BeanNameAware) instance;
                beanNameAware.setBeanNameAware(name);
            }

		···
    }

初始化机制模拟实现

在bean的属性默认初始化设置完之后，我们程序员可以自定义进行业务方面的初始化，例如bean中的属性是否为空或者说是否符合业务方面的要求，或者你想对某一个属性赋值。那么这个功能如何完成呢？

在Spring中我们可以去实现InitializingBean接口来完成这一个功能，Spring在检测到当前类实现了InitializingBean接口之后，就会帮我们调用接口方法完成我们自定义的初始化。

InitializingBean接口定义如下：

public interface InitializingBean {
    void afterPropertiesSet();
}

然后我们在createBean方法中调用接口方法：

    public Object createBean(String name){
        ···
       
            //进行依赖注入
            ···

            //BeanNameAware返回bean name
            if (instance instanceof BeanNameAware) {
                BeanNameAware beanNameAware = (BeanNameAware) instance;
                beanNameAware.setBeanNameAware(name);
            }
            //自定义初始化
            if (instance instanceof InitializingBean) {
                InitializingBean initializingBean = (InitializingBean) instance;
                initializingBean.afterPropertiesSet();
            }

		···
    }

BeanPostProcessor模拟实现

BeanPostProcessor：bean的后置处理器

我们在前文中提到的初始化机制、Aware回调机制都是Spring提供给我们的拓展功能，我们只需要在需求类上实现相应接口，Spring即可帮我们完成需求。

那么Spring能否给我们提供帮助：在实例化之前或之后给我们提供额外的功能追加，或者说在初始化之前或初始化之后给我们提供额外的功能追加。

为了实现这一需求Spring为我们提供了BeanPostProcessor。

我们来看一下Spring的源码：

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;
    }
}

• postProcessBeforeInitialization：初始化前追加功能
• postProcessAfterInitialization：初始化后追加功能
  

BeanPostProcessor有很多子接口，其中InstantiationAwareBeanPostProcessor的源码如下：

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return null;
    }

    /** @deprecated */
    @Deprecated
    @Nullable
    default PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

• postProcessBeforeInstantiation：实例化之前追加功能
• postProcessAfterInstantiation：实例化之后追加功能
  

我们在Spring框架中要想使用这一个功能，一般是新创建一个类然后去实现相应的接口，而不会去在业务层的类中去实现。因为初始化、实例化都是相对于每一个bean来说的，我们理应将他们单独抽离出来，而且这样不会污染业务代码。

接下来我们开始BeanPostProcessor的代码实现：

实现思路如下：

• 扫描类的时候(也就是scan方法中) 看是否有类实现了BeanPostProcessor接口
• 如果实现了该接口，则创建该类的实例
• 将实例放入beanPostProcessorList中
• 在createBean方法的相应的位置将列表中的实例一个个取出来，然后调用他们的方法

代码实现：

public interface BeanPostProcessor {

    Object postProcessBeforeInitialization(Object bean, String beanName);


    Object postProcessAfterInitialization(Object bean, String beanName);
}

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("初始化之前");
        if (beanName.equals("userService")) {
            System.out.println("为userService初始化之前追加的功能");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("初始化之后");
        return bean;
    }
}

在MyApplicationContext中新建一个成员属性beanPostProcessorList：

scan方法：

注意：

• 这里的isAssignableFrom方法和instanceof要区别开
  • instanceof是判断某一个对象与父类或者接口的关系
  • isAssignableFrom是判断某一个类与父类或者接口的关系
• 同时isAssignableFrom方法与instanceof的用法也不一样，例如
  • 判断a对象是否实现b接口：a instanceof b
  • 判断a类是否实现b接口：b.isAssignableFrom(a)
• 这里的代码逻辑与Spring源码并不相同，在Spring源码中这里创建BeanPostProcessor的实例对象时使用的getBean方法，这样走的是Spring内部的逻辑可以处理当BeanPostProcessor的实现类里面存在使用@Autowired进行依赖注入的情况。但是我们这里并没有考虑这样的情况，所以我们直接得到类的构造器去创建BeanPostProcessor的实例对象

createBean方法：

我们测试一下：

public class MySpringTest {
    public static void main(String[] args) {
        MyApplicationContext applicationContext = new MyApplicationContext(AppConfig.class);

//        UserService userService = (UserService) applicationContext.getBean("userService");
//        System.out.println(userService.getOrderService());
//        System.out.println(userService.getBeanName());

    }
}

结果：

我们的扫描范围时service包下，而我们的service包下有三个类，与结果相吻合。

AOP模拟实现

在spring框架中，使用代理模式比较典型的场景就是AOP的实现了，代理逻辑核心要点如下：

• 默认使用 JDK 动态代理，这样可以代理所有的接口类型；
• 如果目标对象没有实现任何接口，则默认采用CGLIB代理；
• 可强制使用CGLIB，指定proxy-target-class = “true” 或者 基于注解@EnableAspectJAutoProxy(proxyTargetClass = true)

AOP的工作流程可以直接看我的另一篇文章：
[Spring Framework]AOP工作流程

除了动态代理技术之外，AOP在Spring中的实现还需要借助BeanPostProcessor。我们知道BeanPostProcessor是bean的后置处理器，其可以在bean初始化的前后对bean造成额外的影响。

这里我们可以借助BeanPostProcessor接口中的postProcessAfterInitialization方法，返回需要增强类的代理对象。

接下来我们进行代码实现：

这里我们实现JDK动态代理的情况，所以先要为委托类编写接口方法，方便根据接口实现代理对象：

public interface ProxyInterface {
    void show();
}

@Component("userService")
@Scope("single")
public class UserService implements BeanNameAware, InitializingBean,ProxyInterface {

    @Autowired
    private  OrderService orderService;

    private String beanName;

    public String getBeanName() {
        return beanName;
    }
    @Override
    public void afterPropertiesSet() {
        System.out.println("自定义初始化");
    }


    @Override
    public void setBeanNameAware(String beanName) {
        this.beanName = beanName;
    }

    public OrderService getOrderService() {
        return orderService;
    }

    public void show(){
        System.out.println("这里是UserService的实例");
    }
    
}

然后我们重写一下postProcessAfterInitialization方法：

@Component("myBeanPostProcessor")
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("初始化之前");
        if (beanName.equals("userService")) {
            System.out.println("为userService初始化之前追加的功能");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("初始化之后");
        if (beanName.equals("userService")) {
            return Proxy.newProxyInstance(
                    MyBeanPostProcessor.class.getClassLoader(),
                    bean.getClass().getInterfaces(),
                    new InvocationHandler() {
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            if (method.getName().equals("show")) {
                                System.out.println("这里是对show方法的前置增强");
                            }
                            return method.invoke(bean, args);
                        }
                    }
            );
        }
        return bean;
    }
}

我们这里省略了是否进行AOP的判断以及找切点的逻辑

测试：

public class MySpringTest {
    public static void main(String[] args) {
        MyApplicationContext applicationContext = new MyApplicationContext(AppConfig.class);
        ProxyInterface proxyInterface = (ProxyInterface) applicationContext.getBean("userService");
        proxyInterface.show();
    }
}

结果：

我们在Spring中使用AOP时会在配置类上使用一个注解@EnableAspectJAutoProxy。这个注解会向Spring的容器中注册一个bean：

而这个bean你往上一直寻找会发现，他其实就是一个BeanPostProcessor！