Spring源码解析

package cn.jiedada.spring;

import java.io.File;
import java.lang.annotation.Annotation;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

public class JieDaDaApplicationContext {

    private Class configClass;

    //在getBean中通过名字找到对象
    private Map<String,BeanDefinition> beanDefinitionMap = new HashMap<>();

    //单列池,里面的是currenthashmap
    private Map<String,Object> singletonObjects = new HashMap<>();

    public JieDaDaApplicationContext(Class configClass) {
        this.configClass = configClass;
        //解析配置类
        scopCompenent(configClass);
        //实力化创建单列bean并且保存
        preInstantiateSingleton();
    }

    private void preInstantiateSingleton() {
        for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
            BeanDefinition beanDefinition = entry.getValue();
            String beanName = entry.getKey();
            //我们这里只保留单列的bean，因为多列的创建为使用时候在创建，而且不知道多列能够创建多少
            if ("singleton".equals(beanDefinition.getScope())){
                //如果为单列就创建bean
                Object bean = createBean(beanName, beanDefinition);
                singletonObjects.put(beanName,bean);
            }
        }
    }

    //创建bean的方法
    public Object createBean(String beanName,BeanDefinition beanDefinition){
        Class clazz = beanDefinition.getClazz();
        Object instance = null;
        try {
            instance = clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return instance;
    }

    private void scopCompenent(Class configClass) {
        ComponentScan annotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
        //扫秒路径
        String path = annotation.value();//cn.jiedada
        String replace = path.replace(".", "/");

        //扫描component类 1.单列 2.多列
        //通过类加载器获得文件路径
        ClassLoader classLoader = JieDaDaApplicationContext.class.getClassLoader();
        URL resource = classLoader.getResource(replace);
        File file = new File(resource.getFile());
        File[] files = file.listFiles();
        //遍历文件判断是否包含component注解
        for (File f : files) {
            //文件路径
            String filePath = f.getAbsolutePath();
            //判断是否是含有.class
            if (filePath.endsWith(".class")){
                //获得真实路径
                String realPath1 = filePath.substring(filePath.indexOf("cn"), filePath.indexOf(".class"));
                //通过类加载器获得对象应为类加载器需要使用的路径不为cn/jiedada/test/Main需要转化
                String fileRealPath = realPath1.replace("/", ".");
                try {
                    Class clazz = classLoader.loadClass(fileRealPath);
                    //获得component类对象
                    //获得类对象需要判断多列和单列所以需要添加一个注解
                    //因为是通过getBean获得对象，所以不可能再去getBean中在遍历一次，所以我们需要把对象保存BeanDefinition
                    //又因为通过名字获得对象所以需要通过先存入Map对象的方式实现
                    if(clazz.isAnnotationPresent(Component.class)){
                        Component component = (Component) clazz.getAnnotation(Component.class);
                        //保存beanDefinitionMap
                        BeanDefinition beanDefinition = new BeanDefinition();
                        beanDefinition.setClazz(clazz);
                        if (clazz.isAnnotationPresent(Scope.class)){
                            //设置类的scope
                            Scope scope = (Scope) clazz.getAnnotation(Scope.class);
                            String value = scope.value();
                            beanDefinition.setScope(value);
                        }else {
                            beanDefinition.setScope("singleton");
                        }
                        beanDefinitionMap.put(component.value(),beanDefinition);
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    public Object getBean(String beanName){
        //获得beanDefinition
        if (beanDefinitionMap.containsKey(beanName)){
            BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
            if (beanDefinition.getScope().equals("singleton")){
                //单列
                Object o = singletonObjects.get(beanName);
                return o;
            }else {
                //多列
                Object bean = createBean(beanName, beanDefinition);
                return bean;
            }
        }else {
            throw new RuntimeException();
        }
    }
}

package cn.jiedada.spring;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {
    String value() default "";
}

for (File f : files) {
            //文件路径
            String filePath = f.getAbsolutePath();
            //判断是否是含有.class
            if (filePath.endsWith(".class")){
                //获得真实路径
                String realPath1 = filePath.substring(filePath.indexOf("cn"), filePath.indexOf(".class"));
                //通过类加载器获得对象应为类加载器需要使用的路径不为cn/jiedada/test/Main需要转化
                String fileRealPath = realPath1.replace("/", ".");
                try {
                    Class clazz = classLoader.loadClass(fileRealPath);
                    //获得component类对象
                    //获得类对象需要判断多列和单列所以需要添加一个注解
                    //因为是通过getBean获得对象，所以不可能再去getBean中在遍历一次，所以我们需要把对象保存BeanDefinition
                    //又因为通过名字获得对象所以需要通过先存入Map对象的方式实现
                    if(clazz.isAnnotationPresent(Component.class)){
                        Component component = (Component) clazz.getAnnotation(Component.class);
                        //保存beanDefinitionMap
                        BeanDefinition beanDefinition = new BeanDefinition();
                        beanDefinition.setClazz(clazz);
                        if (clazz.isAnnotationPresent(Scope.class)){
                            //设置类的scope
                            Scope scope = (Scope) clazz.getAnnotation(Scope.class);
                            String value = scope.value();
                            beanDefinition.setScope(value);
                        }else {
                            beanDefinition.setScope("singleton");
                        }
                        beanDefinitionMap.put(component.value(),beanDefinition);
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }

        }

package cn.jiedada.spring;

public class BeanDefinition {
    private Class clazz;
    private String scope;

    public Class getClazz() {
        return clazz;
    }

    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }
}