Spring框架核心功能手写实现

文章目录

概要

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

Spring启动以及扫描流程实现

在这里插入图片描述

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

基础环境搭建

首先搭建好基础环境：
在这里插入图片描述

我们的测试类：

publicclassMySpringTest{publicstaticvoidmain(String[] args){MyApplicationContext applicationContext =newMyApplicationContext(AppConfig.class);Object bean = applicationContext.getBean("");System.out.println(bean);}}

我们的容器类MyApplicationContext ：

publicclassMyApplicationContext{privateClass configClass;publicMyApplicationContext(Class configClass){this.configClass = configClass;}publicObjectgetBean(String beanName){returnnull;}}

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

@Retention(RetentionPolicy.RUNTIME)@Target({ElementType.TYPE})public@interfaceComponentScan{Stringvalue();}

Retention指定该注解的生命周期，设置成RUNTIME便于反射获取
Target指定注解的使用位置，设置为TYPE表示能在类上使用

我们的AppConfig；

@ComponentScan("com.zyb.service")publicclassAppConfig{}

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

@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public@interfaceComponent{Stringvalue();}

@Component("userService")publicclassUserService{}

扫描逻辑实现

我们的思路就是；

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

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

publicMyApplicationContext(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对象操作

代码如下：

publicMyApplicationContext(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 =newFile(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@interfaceScope{Stringvalue()default"single";}

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

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

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

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

publicclassBeanDefinition{privateClass beanClass;privateString scope;publicClassgetBeanClass(){return beanClass;}publicvoidsetBeanClass(Class beanClass){this.beanClass = beanClass;}publicStringgetScope(){return scope;}publicvoidsetScope(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

代码如下：

publicclassMyApplicationContext{privateClass configClass;privateConcurrentHashMap<String,Object> singleBeanHashMap =newConcurrentHashMap<>();privateHashMap<String,BeanDefinition> beanDefinitionHashMap  =newHashMap<>();publicMyApplicationContext(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 =newFile(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 =newBeanDefinition();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();}}}}}publicObjectgetBean(String beanName){//首先判断是否存在该bean的BeanDefinitionif(beanDefinitionHashMap.containsKey(beanName)){BeanDefinition beanDefinition = beanDefinitionHashMap.get(beanName);if(beanDefinition.getScope().equals("single")){//单例模式创建bean}else{//原型模式创建bean}}else{thrownewNullPointerException("不存在该bean");}}}

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

publicclassMyApplicationContext{privateClass configClass;privateConcurrentHashMap<String,Object> singleBeanHashMap =newConcurrentHashMap<>();privateHashMap<String,BeanDefinition> beanDefinitionHashMap  =newHashMap<>();publicMyApplicationContext(Class configClass){this.configClass = configClass;scan(configClass);}privatevoidscan(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 =newFile(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 =newBeanDefinition();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();}}}}}publicObjectgetBean(String beanName){//首先判断是否存在该bean的BeanDefinitionif(beanDefinitionHashMap.containsKey(beanName)){BeanDefinition beanDefinition = beanDefinitionHashMap.get(beanName);if(beanDefinition.getScope().equals("single")){//单例模式创建bean}else{//原型模式创建bean}}else{thrownewNullPointerException("不存在该bean");}}}

bean创建的简单实现

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

在getBean方法中：

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

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

整体代码如下：

publicclassMyApplicationContext{privateClass configClass;privateConcurrentHashMap<String,Object> singleBeanHashMap =newConcurrentHashMap<>();privateHashMap<String,BeanDefinition> beanDefinitionHashMap  =newHashMap<>();publicMyApplicationContext(Class configClass){this.configClass = configClass;scan(configClass);//scan之后就得到了beanDefinitionHashMap，然后我们根据此来构建singleBeanHashMapfor(String beanName:beanDefinitionHashMap.keySet()){BeanDefinition beanDefinition = beanDefinitionHashMap.get(beanName);if(beanDefinition.getScope().equals("single")){
                singleBeanHashMap.put(beanName,createBean(beanName));}}}publicObjectcreateBean(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;}privatevoidscan(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 =newFile(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 =newBeanDefinition();
                            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();}}}}}publicObjectgetBean(String beanName){//首先判断是否存在该bean的BeanDefinitionif(beanDefinitionHashMap.containsKey(beanName)){BeanDefinition beanDefinition = beanDefinitionHashMap.get(beanName);if(beanDefinition.getScope().equals("single")){//单例模式创建beanreturn singleBeanHashMap.get(beanName);}else{//原型模式创建beanreturncreateBean(beanName);}}else{thrownewNullPointerException("不存在该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方法，创建依赖，再对依赖进行赋值

代码如下：

publicObjectcreateBean(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接口：

publicinterfaceBeanNameAware{voidsetBeanNameAware(String beanName);}

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

publicObjectcreateBean(String name){
        ···
       
            //进行依赖注入
            ···

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

        ···
    }

初始化机制模拟实现

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

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

InitializingBean接口定义如下：

publicinterfaceInitializingBean{voidafterPropertiesSet();}

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

publicObjectcreateBean(String name){
        ···
       
            //进行依赖注入
            ···

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

        ···
    }

BeanPostProcessor模拟实现

BeanPostProcessor：bean的后置处理器

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

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

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

我们来看一下Spring的源码：

publicinterfaceBeanPostProcessor{@NullabledefaultObjectpostProcessBeforeInitialization(Object bean,String beanName)throwsBeansException{return bean;}@NullabledefaultObjectpostProcessAfterInitialization(Object bean,String beanName)throwsBeansException{return bean;}}

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

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

publicinterfaceInstantiationAwareBeanPostProcessorextendsBeanPostProcessor{@NullabledefaultObjectpostProcessBeforeInstantiation(Class<?> beanClass,String beanName)throwsBeansException{returnnull;}defaultbooleanpostProcessAfterInstantiation(Object bean,String beanName)throwsBeansException{returntrue;}@NullabledefaultPropertyValuespostProcessProperties(PropertyValues pvs,Object bean,String beanName)throwsBeansException{returnnull;}/** @deprecated */@Deprecated@NullabledefaultPropertyValuespostProcessPropertyValues(PropertyValues pvs,PropertyDescriptor[] pds,Object bean,String beanName)throwsBeansException{return pvs;}}

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

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

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

实现思路如下：

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

代码实现：

publicinterfaceBeanPostProcessor{ObjectpostProcessBeforeInitialization(Object bean,String beanName);ObjectpostProcessAfterInitialization(Object bean,String beanName);}

publicclassMyBeanPostProcessorimplementsBeanPostProcessor{@OverridepublicObjectpostProcessBeforeInitialization(Object bean,String beanName){System.out.println("初始化之前");if(beanName.equals("userService")){System.out.println("为userService初始化之前追加的功能");}return bean;}@OverridepublicObjectpostProcessAfterInitialization(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方法：
在这里插入图片描述

我们测试一下：

publicclassMySpringTest{publicstaticvoidmain(String[] args){MyApplicationContext applicationContext =newMyApplicationContext(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动态代理的情况，所以先要为委托类编写接口方法，方便根据接口实现代理对象：

publicinterfaceProxyInterface{voidshow();}

@Component("userService")@Scope("single")publicclassUserServiceimplementsBeanNameAware,InitializingBean,ProxyInterface{@AutowiredprivateOrderService orderService;privateString beanName;publicStringgetBeanName(){return beanName;}@OverridepublicvoidafterPropertiesSet(){System.out.println("自定义初始化");}@OverridepublicvoidsetBeanNameAware(String beanName){this.beanName = beanName;}publicOrderServicegetOrderService(){return orderService;}publicvoidshow(){System.out.println("这里是UserService的实例");}}

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

@Component("myBeanPostProcessor")publicclassMyBeanPostProcessorimplementsBeanPostProcessor{@OverridepublicObjectpostProcessBeforeInitialization(Object bean,String beanName){System.out.println("初始化之前");if(beanName.equals("userService")){System.out.println("为userService初始化之前追加的功能");}return bean;}@OverridepublicObjectpostProcessAfterInitialization(Object bean,String beanName){System.out.println("初始化之后");if(beanName.equals("userService")){returnProxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(),
                    bean.getClass().getInterfaces(),newInvocationHandler(){@OverridepublicObjectinvoke(Object proxy,Method method,Object[] args)throwsThrowable{if(method.getName().equals("show")){System.out.println("这里是对show方法的前置增强");}return method.invoke(bean, args);}});}return bean;}}

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

测试：

publicclassMySpringTest{publicstaticvoidmain(String[] args){MyApplicationContext applicationContext =newMyApplicationContext(AppConfig.class);ProxyInterface proxyInterface =(ProxyInterface) applicationContext.getBean("userService");
        proxyInterface.show();}}

结果：
在这里插入图片描述

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

而这个bean你往上一直寻找会发现，他其实就是一个BeanPostProcessor！
在这里插入图片描述

标签： spring java spring boot

本文转载自: https://blog.csdn.net/zyb18507175502/article/details/129333353
版权归原作者 十八岁讨厌编程 所有，如有侵权，请联系我们删除。

Spring框架核心功能手写实现

文章目录

概要

Spring启动以及扫描流程实现

基础环境搭建

扫描逻辑实现

bean创建的简单实现

依赖注入实现

BeanNameAware回调实现

初始化机制模拟实现

BeanPostProcessor模拟实现

AOP模拟实现

发表评论

“Spring框架核心功能手写实现”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航