手写spring源码（简易基础篇）

---

前言

通过手写模拟，了解Spring的底层源码启动过程
通过手写模拟，了解BeanDefinition、BeanPostProcessor的概念
通过手写模拟，了解Spring解析配置类等底层源码工作流程
通过手写模拟，了解依赖注入，Aware回调等底层源码工作流程
通过手写模拟，了解Spring AOP的底层源码工作流程

简易版本，重在理解spring底层思想大概做了什么。

---

1、目录结构

2、启动代码

package com.ljc;

import com.ljc.service.UserService;
import com.spring.LjcApplicationContext;

public class Test {
    public static void main(String[] args) {

        /**
         * 1、扫描指定文件下的class文件，转换成class
         * 2、如果带有Component，就生成Bean定义，设置作用域、以及是否延迟加载，放到BeanDefinitionMap里
         * 3、遍历Bean定义生成Bean、属性填充（依赖注入），把单例的放进单例缓存池，原型对象则每次新建
         * 4、执行aware回调、后置处理器、以及看是不是需要aop处理
         *
         */
        // 扫描生成Bean定义--->创建单例Bean BeanDefinition BeanPostPRocess
        LjcApplicationContext applicationContext = new LjcApplicationContext(AppConfig.class);
		UserInteface userService = (UserInteface) applicationContext.getBean("userService");
        userService.test();
        userService.testOrder();
    }
}

3、初始化applicationContext

做了几件事情
1、初始化配置类
2、扫描配置类下的文件类
3、遍历Bean定义Map，是单例就进行创建，添加到单例池

public class LjcApplicationContext {

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

    public LjcApplicationContext(Class appConfigClass) {
        loadClass = appConfigClass;
        // 扫描
        sacn(appConfigClass);
		// 遍历Bean定义
        for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = entry.getValue();
            // 判断是不是单例
            if("singleton".equals(entry.getValue().getScope())){
            	// 创建Bean
                Object instance = createBean(beanDefinition,beanName);
                // 添加到单例池
                singletonObjects.put(beanName,instance);
            }
        }
    }

4、初始化扫描配置类下的所有文件类

做了几件事情
1、获取配置类的注解扫描路径，加载路径下的所有类文件
2、遍历文件类，判断是当前类是不是一个Bean
3、获取&初始化beanName，创建Bean定义，添加到Bean定义集合

/**
     * 扫描配置类下的文件
     * @param appConfigClass
     */
    private void sacn(Class appConfigClass) {
        // 配置类上面是否配置了@ComponentScan注解
        if (appConfigClass.isAnnotationPresent(ComponentScan.class)) {
            // 获取@ComponentScan注解的value，拿到扫描的路径
            ComponentScan ComponentScan = (com.spring.ComponentScan) appConfigClass.getAnnotation(ComponentScan.class);
            String path = ComponentScan.value();
            path = path.replace(".", "/");

            // 获取类加载器（appclassloader加载器，他是获取的target下面的文件，这是重点！！！）
            ClassLoader classLoader = LjcApplicationContext.class.getClassLoader();
            // 获取路径下的文件夹
            URL resource = classLoader.getResource(path);
            File file = new File(resource.getFile());
            // 是文件夹则进行处理
            if (file.isDirectory()) {
                // 遍历文件夹下所有的文件
                for (File f : file.listFiles()) {
                    try {
                        // 通过截取路径获取
                        String absolutePath = f.getAbsolutePath();
                        absolutePath = absolutePath.substring(absolutePath.indexOf("com"),absolutePath.indexOf(".class"));
                        absolutePath = absolutePath.replace("\\",".");
                        // 通过类加载器加载，获取类
                        Class<?> clazz = classLoader.loadClass(absolutePath);
                        // 判断有没有被@Component过，有的话进行增强
                        if (clazz.isAnnotationPresent(Component.class)) {
                            // 扫描后置处理器
                            if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
                                // getConstructor获取类的构造方法
                                BeanPostProcessor instance = (BeanPostProcessor) clazz.getConstructor().newInstance();
                                beanPostProcessorList.add(instance);
                            }
                            // 获取注解的beanName
                            Component component = clazz.getAnnotation(Component.class);
                            String beanName = component.value();
                            // 如果没有写，则默认首字母小写
                            if ("".equals(beanName)) {
                                beanName = Introspector.decapitalize(clazz.getSimpleName());
                            }
                            // 创建Bean定义
                            BeanDefinition beanDefinition = new BeanDefinition();
                            // 设置是单例还是多例
                            if (clazz.isAnnotationPresent(Scope.class)) {
                                Scope scope = clazz.getAnnotation(Scope.class);
                                beanDefinition.setScope(scope.value());
                            }else{
                                beanDefinition.setScope("singleton");
                            }
                            // 设置Bean定义的类型
                            beanDefinition.setType(clazz);
                            // 添加到Bean定义Map
                            beanDefinitionMap.put(beanName,beanDefinition);
                        }

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

5、创建Bean

主要做了几件事情
1、遍历类属性，是否有依赖注入
2、有没有实现Aware接口、BeanPostPorcess接口、有没有实现初始化，有就处理

/**
     * 创建bean
     * @param beanDefinition
     * @param beanName
     * @return
     */
    private Object createBean(BeanDefinition beanDefinition,String beanName) {
        Class classz = beanDefinition.getType();
        Object instance = null;
        try {
            // 反射出实体类
            instance = classz.getConstructor().newInstance();
            // 获取实体的所有属性
            Field[] fields = classz.getDeclaredFields();
            // 遍历、属性填充
            for (Field field : fields) {
                // 属性是否被@Autowired注解（依赖注入）
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    // 注入
                    field.set(instance,getBean(field.getName()));
                }
            }
            // 实现BeanNameAware
            if (instance instanceof BeanNameAware) {
                ((BeanNameAware)instance).setBeanName(beanName);
            }
            // 遍历、初始化前
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
            }
            // 实现了InitializingBean,则调用初始化
            if (instance instanceof InitializingBean) {
                ((InitializingBean)instance).afterPropertiesSet();
            }
            // 遍历、初始化前
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessAfterInitialization(instance, beanName);
            }

        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return instance;
    }

6、getBean

主要做了几件事情
1、判断Bean定义有没有这个beanName，没有就报错
2、有的话就去Bean定义集合里面拿
3、如果是单例就从单例池拿，没有就创建
4、不是单例就i直接创建Bean。

/**
     * 获取Bean
     * @param beanName
     * @return
     */
    public Object getBean(String beanName) {
        // Bean定义如果不存在，则空指针
        if (!beanDefinitionMap.containsKey(beanName)) {
            throw new NullPointerException();
        }
        // 如果不存在，则需要创建，根据beanName从Bean定义Map里获取到Bean定义
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        Object instance = null;
        // 判断是否为单例
        if (beanDefinition.getScope().equals("singleton")) {
            // 从单例池获取
            instance = singletonObjects.get(beanName);
            // 单例池没有则去创建Bean
            if(instance == null){
                instance = createBean(beanDefinition,beanName);
            }
        }else{
            // 不是单例则去创建Bean
            instance = createBean(beanDefinition,beanName);
        }
        return instance;
    }

7、BeanPostProcess实现

@Component
public class AopBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("BeforeInitialization——"+bean+"——"+beanName);
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if("userService".equals(beanName)){

            Object proxyInstance = Proxy.newProxyInstance(LjcApplicationContext.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("切面逻辑");
                    return method.invoke(bean, args);
                }
            });
            return proxyInstance;
        }
        return bean;
    }
}

8、运行结果