😀前言
手动实现 Spring 底层机制【初始化 IOC容器+依赖注入+BeanPostProcessor 机制+AOP】的第五篇具体实现了任务阶段 5- bean 后置处理器

🏠个人主页：尘觉主页
在这里插入图片描述

🧑个人简介：大家好，我是尘觉，希望我的文章可以帮助到大家，您的满意是我的动力😉😉

在csdn获奖荣誉: 🏆csdn城市之星2名
⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　💓Java全栈群星计划top前5
⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　🤗 端午大礼包获得者

💕欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，感谢大家的观看🥰
如果文章有什么需要改进的地方还请大佬不吝赐教先在次感谢啦😊

文章目录

🤩实现任务阶段 5- bean 后置处理器
- ● 分析示意图
- 创建InitializingBean接口
- 修改MonsterService.java类
- 修改WyxSpringApplicationContext类
- 😋运行完成测试
- 创建 BeanPostProcessor接口
- 创建 WyxBeanPostProcessor类
- 修改WyxSpringApplicationContext类
- 😎运行完成测试
- 😄总结

🤩实现任务阶段 5- bean 后置处理器

● 分析示意图

● 代码实现, 说明，整个实现思路，就是参考 Spring 规范

创建InitializingBean接口

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

修改MonsterService.java类

去实现 InitializingBean 接口

\1. afterPropertiesSet就是在bean的setter方法执行完毕后被spring容器调用
2 即就是初始化方法

@Component//(value = "monsterService") //把MonsterService注入我们自己的spring容器中
@Scope(value = "prototype")
public class MonsterService implements InitializingBean {
    //这里我们使用自己的@Autowired来修饰属性
    //表示该属性，是通过容器完成依赖注入
    //说明: 我们实现按照名字来进行组装即可
    @Autowired
    private MonsterDao monsterDao;

    public void m1() {
        monsterDao.hi();
    }

    /**
     * 1. afterPropertiesSet就是在bean的setter方法执行完毕后被spring容器调用
     * 2 即就是初始化方法
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("MonsterService 初始化方法被调用 程序员在这里加入初始化的业务..");
    }
}

修改WyxSpringApplicationContext类

在创建好 Bean 实例后，判断是否需要进行初始化【容器中常.否实现了某个接口，来判断是否要执行某个业务逻辑, 这里其实就是 java 基础的接口编程实际运用

 //先简单实现实现，后面在完善.
    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        //得到 bean 的类型
        Class clazz = beanDefinition.getClazz();
        try {
            //使用反射得到实例
            Object instance = clazz.getDeclaredConstructor().newInstance();
            //完成依赖注入
            for (Field declaredField : clazz.getDeclaredFields()) {
                if (declaredField.isAnnotationPresent(Autowired.class)) {
                    // 处理@Autowired 注解的属性 required, 很简单，自己完成
                    // Autowired annotation =declaredField.getAnnotation(Autowired.class);
                    // System.out.println(annotation.required());
                    //如果该属性有@Autowired, 就进行组装
                    Object bean = getBean(declaredField.getName());
                    declaredField.setAccessible(true);//因为属性是 private,需要暴破
                    declaredField.set(instance, bean);
                }
            }
            //这里还有其他，比如 Aware 回调. 不写了
            //这里调用初始化,如果 bean 实现了 InitializingBean
            System.out.println("======创建好了====" + instance);
            if (instance instanceof InitializingBean) {
                try {
                    ((InitializingBean) instance).afterPropertiesSet();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return instance;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        //如果没有创建成功，返回 null
        return null;
    }

😋运行完成测试

创建 BeanPostProcessor接口

该接口可以参考原生 Spring 规范 , 注注意体会切面编程

参考原生Spring容器定义一个接口BeanPostProcessor
该接口有两个方法postProcessBeforeInitialization 和 postProcessAfterInitialization
这两个方法，会对Spring容器的所有Bean生效, 已经是切面编程的概念.

public interface BeanPostProcessor {

    /**
     * 1. postProcessBeforeInitialization在Bean的初始化方法前调用
     * @param bean
     * @param beanName
     * @return
     */
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    /**
     * 1. postProcessAfterInitialization在Bean的初始化方法后调用
     * @param bean
     * @param beanName
     * @return
     */
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

创建 WyxBeanPostProcessor类

@Component
public class WyxBeanPostProcessor implements BeanPostProcessor {
    /**
     * 该方法时在 bean 创建好后，进行初始化前调用
     * @param bean : 创建好的 bean 对象
     * @param beanName 创建好的 bean 的名字
     * @return
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        //这里程序员来决定业务逻辑，spring 只是提供处理机制
        System.out.println("postProcessBeforeInitialization 被调用 " + beanName + " bean= " + bean.getClass());
        return bean;
    }
    /**
     * 该方法时在 bean 创建好后，初始化完成后调用
     * @param bean : 创建好的 bean 对象
     * @param beanName : 创建好的 bean 的名字
     * @return
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        //这里程序员来决定业务逻辑，spring 只是提供处理机制
        System.out.println("postProcessAfterInitialization 被调用 " + beanName + " bean= " + bean.getClass());
        return bean;
    }
}

修改WyxSpringApplicationContext类

注意：这里 createBean(String beanName, BeanDefinition beanDefinition) 需要增加入参 beanName, 就会导致好几个位置错误，需要根据错误提示，对应解决即可.

    private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();

    private void beanDefinitionsByscan(Class configClass) {
        this.configClass = configClass;
        ComponentScan componentScan = (ComponentScan)
                this.configClass.getDeclaredAnnotation(ComponentScan.class);
        String path = componentScan.value();
        System.out.println("扫描路径 = " + path);
        path = path.replace(".", "/");
        URL resource = classLoader.getResource(path);
        File file = new File(resource.getFile());
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                String fileAbsolutePath = f.getAbsolutePath();
                System.out.println("=======================================");
                System.out.println("文件绝对路径 = " + fileAbsolutePath);
                if (fileAbsolutePath.endsWith(".class")) {// 说明是类文件
                    // 通过类加载器获取来类文件的 Clazz 对象
                    // 先 得 到 类 的 完 整 类 路 径 形 式 为
                    com.wyxedu.spring.component.MonsterService
                    String className =
                            fileAbsolutePath.substring(fileAbsolutePath.lastIndexOf("\\") + 1,
                                    fileAbsolutePath.indexOf(".class"));
                    String classFullPath = path.replace("/", ".") + "." + className;
                    System.out.println("类名 = " + className);
                    System.out.println("类的全路径 = " + classFullPath);
                    try {
                        // 获取到扫描包下的类的 clazz 对象
                        Class<?> clazz = classLoader.loadClass(classFullPath);
                        if (clazz.isAnnotationPresent(Component.class)) {
                    
                        // 如果这个类有@Commponent, 说明是一个 spring bean
                            System.out.println("是一个 bean = " + clazz);
                        
                        // 1. 增 加 一 个 逻 辑 ， 如 果 这 个 clazz 类 型 是 实 现 了BeanPostProcessor 接口, 说明是一个 bean 处理器，特殊处理
                        // 2. 注意不能使用 clazz instanceof BeanPostProcessor 判断因为 clazz 并不是一个实例对象, 而是一个类对象
                        // 3. 这里实现是为了方便获取 bean 处理器对象，所以放在一个 beanPostProcessorList, spring 底层源码,
                        // 还 是 走 的 createBean(),getBean(), 只 是 需 要 在singletonObjects, 增加代码处理, 
                            // 我这里主要讲的是 bean 处理器的工作机制，就不处理了，知道即可
                            if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
                                // 创建一个实例对象
                                BeanPostProcessor beanPostProcessor =
                                        (BeanPostProcessor) clazz.newInstance();
                                // 放入到 beanPostProcessorList
                                beanPostProcessorList.add(beanPostProcessor);
                                continue;
                            // 1. 因为这里不能直接将 bean 实例放入 singletonObjects
                            // 2. 原因是如果 bean 是 prototype 是需要每次创建新的 bean 对象
                            // 3. 所 以 ， Spring 底 层 是 这 样 设 计 的 : 将 bean 信 息 封 装 到
                            BeanDefinition 对象中, 便于 getBean 的操作
                            BeanDefinition beanDefinition = new BeanDefinition();
                            beanDefinition.setClazz(clazz);
                            // 获取 bean 的 name
                            Component componentAnnotation =
                                    clazz.getDeclaredAnnotation(Component.class);
                            String beanName = componentAnnotation.value();
                            // 获取 bean 的 scope
                            if (clazz.isAnnotationPresent(Scope.class)) { // 如果有@Scope
                                Scope scopeAnnotation =
                                        clazz.getDeclaredAnnotation(Scope.class);
                                beanDefinition.setScope(scopeAnnotation.value());
                            } else { // 如果没有@Scope, 默认是 singleton
                                beanDefinition.setScope("singleton");
                            }
                    // 放入到 beanDefinitionMap
                            beanDefinitionMap.put(beanName, beanDefinition);

                        } else {
                    // 如果这个类没有@Commponent, 说明不是一个 spring bean
                            System.out.println("不是一个 bean = " + clazz);
                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InstantiationException e) {
                        e.printStackTrace();
                    }
                    System.out.println("=======================================");
                }
            }
        }
    }

        // 先简单实现实现，后面在完善. private Object createBean(String beanName, BeanDefinition beanDefinition) {
    // 得到 bean 的类型

    Class clazz = beanDefinition.getClazz();
    try
    {
        // 使用反射得到实例
        Object instance = clazz.getDeclaredConstructor().newInstance();
        // 完成依赖注入
        for (Field declaredField : clazz.getDeclaredFields()) {
            if (declaredField.isAnnotationPresent(Autowired.class)) {
            // 处理@Autowired 注解的属性 required, 很简单，自己完成
            // Autowired annotation = declaredField.getAnnotation(Autowired.class);
            // System.out.println(annotation.required());
            // 如果该属性有@Autowired, 就进行组装
                Object bean = getBean(declaredField.getName());
                declaredField.setAccessible(true);// 因为属性是 private,需要暴破
                declaredField.set(instance, bean);
            }
        }
        // 这里还有其他，比如 Aware 回调. 不写了
        // 说明
        // 1. 在 bean 初始化前调用所有 bean 处理器的 postProcessBeforeInitialization
        // 2. 调用时，不能保证顺序
        // 3. 可以通过加入@Order("值"), 来指定 bean 处理器调用顺序，同学们可以自行完成, 不难
        // 4. 如果希望指定对哪些 bean 进行初始化前处理 ， 可以在处理器的postProcessBeforeInitialization()
        // 加入相关业务判断即可.比如:
        /**
         * @Override
         * public Object postProcessBeforeInitialization(Object bean, String
        beanName) {
         * if("monsterService".equalsIgnoreCase(beanName)) {
         * //这里程序员来决定业务逻辑，spring 只是提供处理机制
         * System.out.println("postProcessBeforeInitialization 被调用 " * + beanName + " bean= " + bean.getClass());
         * return bean;
         * }else {
         * return bean;
         * }
         * }
         */
        for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
        // 4. 也会返回一个对象，这个返回的对象是什么，由程序员在编写 bean 处理器决定，可能是原来的 bean, 也可能被改变了

            instance = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
        }
            // 这里调用初始化,如果 bean 实现了 InitializingBean
            if (instance instanceof InitializingBean) {
            try {
                ((InitializingBean) instance).afterPropertiesSet();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 说明
        // 1. 在 bean 初始化后调用所有 bean 处理器的 postProcessAfterInitialization
        // 2. 调用时，不能保证顺序
        // 3. 可以通过加入@Order("值"), 来指定 bean 处理器调用顺序，同学们可以自行完成, 不难
        // 4. 如 果 希 望 指 定 对 哪 些 bean 进 行 初 始 化 后 处 理 ， 可 以 在 处 理 器 的postProcessAfterInitialization()
        // 加入相关业务判断即可
        for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
        // 4. 也会返回一个对象，这个返回的对象是什么，由程序员在编写 bean 处理器决定，可能是原来的 bean, 也可能被改变了
            instance = beanPostProcessor.postProcessAfterInitialization(instance, beanName);
        }
        return instance;
    } catch(InstantiationException e){
        e.printStackTrace();
    } catch(IllegalAccessException e){
        e.printStackTrace();
    } catch(InvocationTargetException e){
        e.printStackTrace();
    } catch(NoSuchMethodException e){
        e.printStackTrace();
    }
        // 如果没有创建成功，返回 null
        return null;

😎运行完成测试

😄总结

本篇我们完成了bean 后置处理器是我们的手写进一步完善了手动实现 Spring 底层机制
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
😉手动实现 Spring 底层机制【初始化 IOC容器+依赖注入+BeanPostProcessor 机制+AOP】系列

手动实现 Spring 底层机制实现任务阶段一编写自己 Spring 容器-准备篇【1】

手动实现 Spring 底层机制实现任务阶段一编写自己 Spring 容器-准备篇【2】

手动实现 Spring 底层机制实现任务阶段一编写自己 Spring 容器，实现任务阶段 2- 扫描将 bean 信息封装到 BeanDefinition 对象

手动实现 Spring 底层机制【初始化 IOC容器+依赖注入+BeanPostProcessor 机制+AOP】实现任务阶段 3- 初始化 bean 单例池和实现任务阶段 4- 完成依赖注入
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
😁热门专栏推荐
想学习vue的可以看看这个
java基础合集
数据库合集
redis合集
nginx合集
linux合集
等等等还有许多优秀的合集在主页等着大家的光顾感谢大家的支持

🤔欢迎大家加入我的社区尘觉社区