spring-demo(IOC)

系列文章目录

利用摸鱼时间写了一个spring的小demo 以便于后续看spring源码做铺垫。

---

public class LaoShuAiDaMiApplicationContext {

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

    public LaoShuAiDaMiApplicationContext(Class configClass) {
        this.configClass = configClass;

        //扫描
        scan(configClass);
        for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = entry.getValue();
            //判断是不是单例，如果是单例就直接去创建bean了
            if (beanDefinition.getScope().equals("singleton")){
                //创建bean的时候 把bean的名字和属性传过去
               Object bean = createBean(beanName,beanDefinition);
                //创建好的bean放在map中 ioc
                singletonObjects.put(beanName,bean);
            }
        }
    }

    private Object createBean(String beanName,BeanDefinition beanDefinition) {
        Class aClass = beanDefinition.getType();
        Object instance = null;
        try {
            instance = aClass.getConstructor().newInstance();
            //拿到每个类 然后判断是否有Autowired
            for (Field field : aClass.getDeclaredFields()) {
                if (field.isAnnotationPresent(Autowired.class)){
                    field.setAccessible(true);
                    field.set(instance,getBean(field.getName()));
                }
            }
            //看那些ben实现了aware 接口 钩子函数会回调
            if (instance instanceof BeanNameAware) {
                ((BeanNameAware)instance).setBeanName(beanName);
            }
            //实现了beanPostProcessor接口的 创建bena的时候去调用 实例化前 这边可以对bean进行更改
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
            }

            //初始化中 ben会去调用这个 同样的对bean进行加工
            if (instance instanceof InitializingBean) {
                ((InitializingBean)instance).afterPropertiesSet();
            }

            //实例化后 去调用自己写的逻辑对bean进行加工

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

    private Object getBean(String beanName) {
        //判断bean是否在map中存在
        if (!beanDefinitionMap.containsKey(beanName)){
            throw new NullPointerException();
        }
        //拿到bean定义
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        //看看是单例还是多例
        if (beanDefinition.getScope().equals("singleton")){
            //从容器中拿到创建好的bean
            Object singletonBean = singletonObjects.get(beanName);
            if (singletonBean==null){
                //如果没有就在给他创建一个e
                 singletonBean = createBean(beanName, beanDefinition);
                 //给他加入到容器中
                singletonObjects.put(beanName,singletonBean);
            }
            return singletonBean;
        }else {
            //多例ben 每次去拿都去创建一个新的
            Object prototypeBean = createBean(beanName, beanDefinition);
            return prototypeBean;
        }
    }

    private void scan(Class configClass) {
        //首先判断 该类上 有没有ComponentScan注解 扫包
        if (configClass.isAnnotationPresent(ComponentScan.class)){
            ComponentScan annotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
            //获取到这个注解的路径
            String value = annotation.value();
            String replace = value.replace(".", "/");
            //获取该类加载器 利用类加载器获取到 该路径
            ClassLoader classLoader = LaoShuAiDaMiApplicationContext.class.getClassLoader();
            URL resource = classLoader.getResource(replace);
            //利用file 拿到所有的 资源
            File file = new File(resource.getFile());
            //遍历这个file
            if (file.isDirectory()){
                for (File listFile : file.listFiles()) {
                    String absolutePath = listFile.getAbsolutePath();
                    //把文件路径替换成相对路径

                    absolutePath = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
                    absolutePath = absolutePath.replace("\\", ".");
                    
                    //利用类加载器拿到文件
                    try {
                        Class<?> aClass = classLoader.loadClass(absolutePath);
                        //拿到这些类看看是否包含Component注解
                        if (aClass.isAnnotationPresent(Component.class)){
                            //看看这个类有没有实现BeanPostProcessor 接口
                            if (BeanPostProcessor.class.isAssignableFrom(aClass)){
                                //如果实现了那么就用反射取到他的实现类
                                BeanPostProcessor instance = (BeanPostProcessor) aClass.getConstructor().newInstance();
                                //添加到BeanPostProcessor的这个list中去
                                beanPostProcessorList.add(instance);
                            }
                            //看看Component注解里面的名字是什么
                            Component annotation1 = aClass.getAnnotation(Component.class);
                            String beanName = annotation1.value();
                            if ("".equals(beanName)){
                                //如果没有写那么就直接用他自己的名称
                                beanName = Introspector.decapitalize(aClass.getSimpleName());
                            }
                            //我们把他们都扫描出来了，避免创建bean的时候再去扫一变，我们可以直接存起来里面可以定义bean的类型 是否单例 是否懒加载。。。
                            BeanDefinition beanDefinition = new BeanDefinition();
                            beanDefinition.setType(aClass);
                            //看他是单例的还是多例的
                            if (aClass.isAnnotationPresent(Scope.class)){
                                Scope annotation2 = aClass.getAnnotation(Scope.class);
                                String value1 = annotation2.value();
                                beanDefinition.setScope(value1);
                            }else {
                                beanDefinition.setScope("singleton");
                            }
                            //创建bean的时候可以直接取出来，可能还有其他的需要
                            beanDefinitionMap.put(beanName,beanDefinition);
                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    } catch (InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                    }

                }
            }

        }

    }
}

总结

提示：这里对文章进行总结：
这里只是大致的描述了下spring-IOC的一个流程，其核心无非要明白一下几点
Q：spring的底层源码启动过程
A：首先通过ComponentScan 配置找到类，然后判断有没有其相对应的注解，解析注解放到map中，去创建bean,创建的时候会看有没有Autowired，实现了没有aware以及BeanPostProcessor的接口，如果实现了就去调用相对应的方法，然后去填充bean。大概流程是这样
Q 了解beanDefinition,BeanPostProcessor的概念
A: beanDefinition存放bean的属性，例如：是否单例，是否懒加载等。
BeanPostProcessor我理解更多是一个可以更改bean的入口，也就是说你创建了这个bean又后悔了不想这样干，或者想给这个bean加点料，这个也是spring厉害的地方
Q spring解析配置类等底层源码的工作流程
A 其实就是通过扫描包，然后解析包下面的注解，以及注解里面的值。
Q 依赖注入，Aware回调等底层源码的工作流程
A Aware其实就是一个钩子函数可以回调，例如我可以实现这个接口去更改我beanName.
Q springAOP工作流程
A springAOP是在bean实例化之后通过动态代理实现的，分为cglab(类)、JDK（接口）这两种方式去实现的，事务其实AOP实现的。