35.学源码最快的方式：带你手写一个Spring

简单实现以下spring流程

UserService.class > 无参构造方法 （推断构造方法）> 普通对象 > 依赖注入（属性赋值） > 初始化前@PostConstruct > 初始化InitializingBean > 初始化后（AOP）> 代理对象 > Bean

关于里面实现的代理对象，看起来像是栈逻辑

courseService执行after切面逻辑 com.lywtimer.service.MyBeanPostProcessor
courseService执行after切面逻辑 com.lywtimer.service.FilterBeanPostProcessor
courseService执行before切面逻辑
CourseService Testing

代码中 postProcessBeforeInitialization 和 postProcessAfterInitialization 的实现并不合理，感觉也没有必要

package com.spring;

import com.lywtimer.AppConfig;

import java.beans.Introspector;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MyApplicationContext {

    private Class configClass;
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
    private Map<String, Object> singletonObjects = new HashMap<>();
    private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();

    public MyApplicationContext(Class<AppConfig> configClass) {
        this.configClass = configClass;
        //扫描class文件，获取Bean
        scan(configClass);
        //遍历扫描好的map
        for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = entry.getValue();
            if (beanDefinition.getScope().equals("singleton")) {
                //创建单例对象并存储
                Object instance = createBean(beanName, beanDefinition);
                singletonObjects.put(beanName, instance);
            }
        }
    }

    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        Object instance = null;
        Class clazz = beanDefinition.getType();
        try {
            //选择构造方法
            Constructor constructor = clazz.getDeclaredConstructor();
            instance = constructor.newInstance();
            //遍历属性
            for (Field declaredField : clazz.getDeclaredFields()) {
                if (declaredField.isAnnotationPresent(Autowired.class)) {
                    //简单化处理,存在循环依赖问题
                    declaredField.setAccessible(true);
                    declaredField.set(instance, getBean(declaredField.getName()));
                }
            }
            //初始化前执行切面逻辑
            for (BeanPostProcessor processor : beanPostProcessorList) {
                instance = processor.postProcessBeforeInitialization(instance, beanName);
            }
            //初始化执行
            if (instance instanceof InitializingBean) {
                ((InitializingBean) instance).afterPropertiesSet();
            }
            //初始化后执行切面逻辑
            for (BeanPostProcessor processor : beanPostProcessorList) {
                instance = processor.postProcessAfterInitialization(instance, beanName);
            }
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException |
                 InvocationTargetException e) {
            throw new RuntimeException(e);
        }
        return instance;
    }


    public Object getBean(String beanName) {
        if (!beanDefinitionMap.containsKey(beanName)) {
            throw new NullPointerException("Bean " + beanName + " not found ");
        }

        var beanDefinition = beanDefinitionMap.get(beanName);

        if (beanDefinition.getScope().equals("singleton")) {
            Object bean = singletonObjects.get(beanName);
            if (bean == null) {
                bean = createBean(beanName, beanDefinition);
                singletonObjects.put(beanName, bean);
            }
            return bean;
        } else {
            //重新新建bean对象
            return createBean(beanName, beanDefinition);
        }
    }

    private void scan(Class<AppConfig> configClass) {
        if (configClass.isAnnotationPresent(ComponentScan.class)) {
            var annotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
            String packageName = annotation.value();

            var path = packageName.replace(".", "/");
            //查找类加载器指定的目录
            ClassLoader classLoader = MyApplicationContext.class.getClassLoader();
            URL resource = classLoader.getResource(path);
            //转换成目录文件读取
            File file = new File(resource.getFile());
            if (file.isDirectory()) {
                for (File f : file.listFiles()) {
                    String p = packageName + "." + f.getName().replace(".class", "");
                    try {
                        var clazz = classLoader.loadClass(p);
                        //查找Bean
                        if (clazz.isAnnotationPresent(Component.class)) {
                            //查找实现类
                            boolean find = BeanPostProcessor.class.isAssignableFrom(clazz);
                            if (find) {
                                BeanPostProcessor instance = (BeanPostProcessor) clazz.getDeclaredConstructor().newInstance();
                                beanPostProcessorList.add(instance);
                            }

                            //获取 beanName
                            String beanName = clazz.getAnnotation(Component.class).value();
                            if ("".equals(beanName)) {
                                beanName = Introspector.decapitalize(clazz.getSimpleName());
                            }
                            String scope = "singleton";
                            if (clazz.isAnnotationPresent(Scope.class)) {
                                scope = clazz.getAnnotation(Scope.class).value();
                            }
                            //构建BeanDefinition
                            var beanDefinition = new BeanDefinition();
                            beanDefinition.setType(clazz);
                            beanDefinition.setScope(scope);
                            beanDefinitionMap.put(beanName, beanDefinition);
                        }
                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException(e);
                    } catch (InvocationTargetException e) {
                        throw new RuntimeException(e);
                    } catch (InstantiationException e) {
                        throw new RuntimeException(e);
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException(e);
                    } catch (NoSuchMethodException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }
}