手写Spring容器

这篇博客主要是记录一下如何简单的实现一个Spring容器

1.首先一个maven项目结构如下 主要有两个包spring这个包就是实现spring容器的代码

2.这里展示的是Test类的代码，我们通过自己定义的BaoboApplicationContext 类根据配置类AppConfig得到我们

UserService 对象

public class Test {
    
    public static void main(String[] args) throws Exception {
    	//BaoboApplicationContext 这个我们自己创建的容器类似于spring的
        BaoboApplicationContext baoboApplicationContext = new BaoboApplicationContext(AppConfig.class);
        UserService UserService = (UserService) baoboApplicationContext.getBean("UserService");


        UserService.test();

    }
}

3.AppConfig使我们自定的类,上面有我们自定的注解ComponentScan标志我们扫描的类的目录

@ComponentScan("com.baobo.service")
public class AppConfig {
}

4.自定义ComponentScan注解,用来告诉spring要扫描的包的路径

@Retention(RetentionPolicy.RUNTIME)//运行时有效
@Target(ElementType.TYPE)//类上
public @interface ComponentScan {
    String value() default "";
}

5.自定义Component注解，用来告诉spring这个注解标注的类交给spring管理

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

6.自定义Scope注解，告诉spring这类是原型还单例

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

7.接下来这个类BaoboApplicationContext 就是我们实现spring容器的重点,下面是这个类的结构：

首先是这个类的构造方法，构造方法通过传入的配置类AppConfig，然后调用scan方法来解析的这个类，可以参照下面的代码，主要的解析过程：
1、通过反射拿到配置类上的注解；
2、通过注解拿到注解的值也就是我们要扫描的包的路径；
3、通过类加载器来加载路径的类
4、加载完类后通过Cpmpomemt注解来确定哪些类是交给spring容器管理的
5. 通过Scope来判断哪些类是单例，哪些类是原型

在这个类里面还有几个比较重要的集合：

   //单例池，用来存放创建好的容器对象
    private ConcurrentHashMap<String, Object> single = new ConcurrentHashMap<>();
    //bean定义集合，用来存放交给spring管理的哪些对象的信息
    private ConcurrentHashMap<String, BeanDefinition> beanDefinitionConcurrentHashMap = new ConcurrentHashMap<>();
    //spring提供的类增强工具
    private ArrayList<BeanPostProcessor> beanPostProcessors = new ArrayList<>();

解析完配置类，接下来就是创建Bean的过程主要调用的是createBean方法，同样可参照下面的代码，主要的创建过程：
1、通过bean的定义信息得到一个对象，接下来就是依赖注入，判断这个类的属性有没有Autowired注解，如果有根据属性的名字创建bean，然后将这个bean注入到对象中
2、判断这个对象是否实现BeanNameAware这个接口 aware回调，这个spring提供的回调方法
3、同理判断这个对象是否实现BeanPostProcessor，InitializingBean这些接口，它们都是spring在创建对象的过程中，提供给程序员可以对对象进行增强的方法

创建完容器之后，我们就可以通过getBean方法得到我们要的对象
这是一个简单的spring的容器的实现过程

package com.spring;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;

import java.util.ArrayList;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class BaoboApplicationContext {
    private Class configClass;
    //单例池
    private ConcurrentHashMap<String, Object> single = new ConcurrentHashMap<>();
    //bean定义集合
    private ConcurrentHashMap<String, BeanDefinition> beanDefinitionConcurrentHashMap = new ConcurrentHashMap<>();
    private ArrayList<BeanPostProcessor> beanPostProcessors = new ArrayList<>();


    public BaoboApplicationContext( Class configClass) throws Exception {

        this.configClass=configClass;
        //调用scan解析配置类，主要是解析配置类上的注解
        scan(configClass);
        //通过bean定义信息来创建帝乡 如果是单例先给它创建好
        Set<Map.Entry<String, BeanDefinition>> entries = beanDefinitionConcurrentHashMap.entrySet();
        for (Map.Entry<String, BeanDefinition> entry : entries) {
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = beanDefinitionConcurrentHashMap.get(beanName);
            if (beanDefinition.getScope().equals("singleton")){
                Object bean = createBean(beanName,beanDefinition);
                single.put(beanName,bean);
            }
        }

    }
    public Object createBean(String beanName,BeanDefinition beanDefinition) throws Exception {
        Class clazz = beanDefinition.getClazz();
        Object instance = clazz.getDeclaredConstructor().newInstance();
        //依赖注入
        Field[] declaredField = clazz.getDeclaredFields();
        for (Field field : declaredField) {
            //如果有自动注入的
            if (field.isAnnotationPresent(Autowired.class)){
                //得到属性的名字，根据名字创建bean，将bean注入
                String name = field.getName();
                Object bean = getBean(name);
                //
                field.setAccessible(true);
                field.set(instance,bean);
            }
        }
        //这个对象是否实现BeanNameAware这个接口 aware回调
        if (instance instanceof BeanNameAware){
            ((BeanNameAware) instance).setBeanName(beanName);
        }
        //初始化前
        for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
            instance = beanPostProcessor.postProcessBeforeInitialization(instance,beanName);
        }
        //初始化
        if (instance instanceof InitializingBean){
            ((InitializingBean) instance).afterPropertiesSet();
        }
        //初始化后
        for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
            instance = beanPostProcessor.postProcessAfterInitialization(instance,beanName);
        }
        //BeanPostProcessor
        return instance;
    }

    private void scan(Class configClass) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        ComponentScan componentScan = (ComponentScan) configClass.getDeclaredAnnotation(ComponentScan.class);
        //得到扫描的路径
        String path = componentScan.value();
        System.out.println(path);
        //扫描
        //得到app类加载器
        ClassLoader classLoader = BaoboApplicationContext.class.getClassLoader();
        //通过注解进行扫描,得到该路径
        String path1 = path.replace(".", "//");
        URL resource = classLoader.getResource(path1);
        System.out.println(resource);
        File file = new File(resource.getFile());
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File file1 : files) {
                String file1Name = file1.getAbsolutePath();
                //返回一个字符串，该字符串是该字符串的子字符串。 *子字符串以指定索引处的字符开头，并且*扩展到该字符串的末尾
                String className = file1Name.substring(file1Name.indexOf("com"),file1Name.indexOf(".class"));
                String replace = className.replace("\\", ".");
                System.out.println(replace);
                //根据路径，用类加载器加载类
                Class<?> aClass = classLoader.loadClass(replace);

                //如果这个类存在component注解，表示这个一个bean
                if (aClass.isAnnotationPresent(Component.class)) {
                    //判断这个类是不是实现BeanPostProcessor
                    if (BeanPostProcessor.class.isAssignableFrom(aClass)) {
                        BeanPostProcessor instance = (BeanPostProcessor) aClass.getConstructor().newInstance();
                        beanPostProcessors.add(instance);

                    }
                    //判断这个类是单例还是原型
                    //BeanDefinition
                    BeanDefinition beanDefinition = new BeanDefinition();
                    Component declaredAnnotation = aClass.getDeclaredAnnotation(Component.class);
                    beanDefinition.setClazz(aClass);
                    //拿到Component注解的值
                    String beanName = declaredAnnotation.value();
                    if (aClass.isAnnotationPresent(Scope.class)){
                        Scope declaredAnnotation1 = aClass.getDeclaredAnnotation(Scope.class);
                        String value2 = declaredAnnotation1.value();
                        beanDefinition.setScope(value2);
                    }else {
                        //默认是单例bbean
                        beanDefinition.setScope("singleton");

                    }
                    beanDefinitionConcurrentHashMap.put(beanName,beanDefinition);


                }

            }
        }
    }


    public Object getBean(String beanName) throws Exception {
        //判断这个bean是不是在容器里面
        if (beanDefinitionConcurrentHashMap.containsKey(beanName)){
            //判断是不是单例bean
            BeanDefinition beanDefinition = beanDefinitionConcurrentHashMap.get(beanName);
            if (single.containsKey(beanName)) {
                Object o = single.get(beanName);
                return o;
            }else {
                //不是单例，就新建一个bean
                Object bean = createBean(beanName,beanDefinition);
                return bean;
            }

        }else {
            //没有这个bean
            throw new NullPointerException();
        }

    }

}