手写Spring源码(简化版)

导航:   

【Java笔记+踩坑汇总】Java基础+进阶+JavaWeb+SSM+SpringBoot+瑞吉外卖+SpringCloud+黑马旅游+谷粒商城+学成在线+MySQL高级篇+设计模式+牛客面试题

目录

一、准备工作

1.0 项目目录

1.1 Spring包下的类

1.1.1 容器类

1.1.2 @ComponentScan注解

1.1.3 @Component注解

1.1.4 @Autowired注解

1.1.5 @Scope注解

1.1.6 Bean的声明类:BeanDefinition

1.1.7 Bean名回调接口:BeanNameAware

1.1.8 初始化接口:InitializingBean

1.1.9 Bean后置处理器接口:BeanPostProcessor 

1.2 用户业务相关类  

1.2.1 测试类创建容器

1.2.2 配置类AppConfig

1.2.3 UserService

1.2.4 OrderService,用于依赖注入 

1.2.5 Bean后置处理器接口实现类:MyBeanPostProcessor

二、完善容器类:VinceApplicationContext

2.0 创建Bean流程

2.1 代码实现

2.1.1 成员变量 

2.1.2 构造方法,参数是配置类

2.1.3 createBean()方法 

2.1.4 getBean()方法

三、所有代码


一、准备工作

1.0 项目目录

手写Spring源码(简化版)_第1张图片

1.1 Spring包下的类

com.vince.spring包下的类:

1.1.1 容器类

 对比一下创建Spring容器的方式,我们需要模拟的是AnnotationConfigApplicationContext类。

  • ClassPathXmlApplicationContext:是需要传入一个xml配置文件,告诉Spring需要按照指定的配置创建一个Spring容器ApplicationContext,创建完之后就可以通过getBean从容器中拿到相应的bean对象
  • AnnotationConfigApplicationContext :也是一个容器,只是传入的是以Java配置类的形式传入。可以在类上加上@ComponentScan定义Spring等下需要扫描的路径。还可以通过@Bean的方法(等于bean标签),通过这种注解的方式,给容器加入一个Bean
public class Test {
	public static void main(String[] args) {
		ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring.xml");
		classPathXmlApplicationContext.getBean("user");

		AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
		
		SpringCodeApplicationContext applicationContext = new SpringCodeApplicationContext(AppConfig.class);
	}
}

参考Spring框架可知,这个容器类需要有构造方法、传入参数、getBean()方法

package com.vince.spring; 

//模拟AnnotationConfigApplicationContext
public class VinceApplicationContext{

    private Class configClass;
//构造方法,参数是配置类的字节码文件
	public SpringCodeApplicationContext(Class configClass) {
        //1.赋值配置类成员变量
    	this.configClass = configClass;

		// 2.解析配置类
        // 通过反射,判断配置类字节码有没有注解@ComponentScan
		// 如果有,就根据@ComponentScan传入的扫描路径,扫描那个包下的Bean

        // 3.实例化bean

    }
//容器里拥有getBean()方法,获取Bean
    public Object getBean(String beanName){
		return null;
	}

1.1.2 @ComponentScan注解

package com.vince.spring; 

/**
 * 用于扫描指定包路径的Bean
 */
@Retention(RetentionPolicy.RUNTIME)//注解生命周期,不仅被保存到class文件中,jvm加载class文件之后,仍然存在
//@Target用来表示注解作用范围,超过这个作用范围,编译的时候就会报错。
@Target(ElementType.TYPE)//注解范围是:接口、类、枚举、注解
public @interface ComponentScan {

    String value() default "";

}

1.1.3 @Component注解

package com.vince.spring; 

/**
 * 注解为Bean
 */
@Retention(RetentionPolicy.RUNTIME)//注解生命周期,不仅被保存到class文件中,jvm加载class文件之后,仍然存在
@Target(ElementType.TYPE)//注解范围是:接口、类、枚举、注解
public @interface Component {

    String value() default "";

}

1.1.4 @Autowired注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Autowired {

}

1.1.5 @Scope注解

@Retention(RetentionPolicy.RUNTIME)//注解生命周期,不仅被保存到class文件中,jvm加载class文件之后,仍然存在
@Target(ElementType.TYPE)//注解范围是:接口、类、枚举、注解
public @interface Scope {

    String value() default "";

}

1.1.6 Bean的声明类:BeanDefinition

BeanDefinition 定义 Bean 的配置元信息,包含:

  • Bean 的类名
  • 设置父 bean 名称、是否为 primary、
  • Bean 行为配置信息,作用域、自动绑定模式、生命周期回调、延迟加载、初始方法、销毁方法等
  • Bean 之间的依赖设置,dependencies
  • 构造参数、属性设置  
//Bean的声明类,用来描述Bean;里面定义的Bean的类型(Class格式)和作用域
public class BeanDefinition {

    private Class type;
    private String scope;

    @Override
    public String toString() {
        return "BeanDefinition{" +
                "type=" + type +
                ", scope='" + scope + '\'' +
                '}';
    }

    public Class getType() {
        return type;
    }

    public void setType(Class type) {
        this.type = type;
    }

    public String getScope() {
        return scope;
    }

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

1.1.7 Bean名回调接口:BeanNameAware

//回调接口,主要setter方法给Bean的beanName变量赋值。Aware译为明白的,意识到的。
public interface BeanNameAware {

    public void setBeanName(String beanName);
}

1.1.8 初始化接口:InitializingBean

//初始化Bean的接口,有个方法,
public interface InitializingBean {

    //在属性填充后执行
    public void afterPropertiesSet();

}

1.1.9 Bean后置处理器接口:BeanPostProcessor 

本接口的两个方法在初始化之前和之后执行,可以通过实现类使用JDK的Proxy 

//Bean后置处理器接口
public interface BeanPostProcessor {

    //在Bean 的初始化方法(如 @PostConstruct 注解的方法)被调用之前被自动调用
    public Object postProcessBeforeInitialization(String beanName,Object bean);

    //在 Bean 的初始化方法被调用之后被自动调用
    public Object postProcessAfterInitialization(String beanName,Object bean);

}

1.2 用户业务相关类  

com.vince.service包下的类: 

1.2.1 测试类创建容器

package com.vince.spring; 

public class Test {
    public static void main(String[] args){
//模拟AnnotationConfigApplicationContext容器,构造参数传入配置类
        VinceApplicationContext applicationContext = new VinceApplicationContext(AppConfig.class);
        UserInterface userService = (UserInterface)applicationContext.getBean("userService");
        userService.test();
    }
}

  

1.2.2 配置类AppConfig

package com.vince.spring; 

// com/springCode/service/UserService.java
@ComponentScan("com.springCode.service")
public class AppConfig {
}

1.2.3 UserService

package com.vince.service; 

public interface UserInterface {

    public void test();

}
@Component
//@Scope("prototype") //多例
public class UserService implements BeanNameAware , InitializingBean ,UserInterface{

    @Autowired
    private OrderService orderService;

    private String beanName;

    @Override
    public void test(){
        System.out.println(orderService);
    }

    @Override
    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("初始化方法");
    }
}

1.2.4 OrderService,用于依赖注入 

@Component
//@Scope("prototype") //多例
public class OrderService {
    public void submitOrder(){
        System.out.println("下单。。。");
    }

}

1.2.5 Bean后置处理器接口实现类:MyBeanPostProcessor

//Bean后置处理器实现类,两个方法在初始化之前和之后执行,可以通过实现类使用JDK的Proxy.newProxyInstance();基于反射实现aop。
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(String beanName, Object bean) {
        if ("userService".equals(beanName)) {
            System.out.println("BeanPostProcessor实现类的postProcessBeforeInitialization()方法");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(String beanName, Object bean) {
        if ("userService".equals(beanName)) {
            //代理对象,通过JDK的Proxy.newProxyInstance();基于反射实现aop。
            // 第一个参数类加载器,第二个参数接口的class对象,第三个参数重写invoke()的InvocationHandler实现类
            Object proxyInstance = Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(),
                    bean.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("切面逻辑,BeanPostProcessor实现类的postProcessAfterInitialization()方法");
                    return method.invoke(bean,args);
                }
            });
            return proxyInstance;
        }
        return bean;
    }
}

二、完善容器类:VinceApplicationContext

2.0 创建Bean流程

注解容器类构造方法创建Bean:

  • 获取Bean扫描路径:获取配置类的Class对象,基于反射获取@ComponentScan注解里设置的扫描路径;
  • 遍历扫描Bean:遍历扫描路径里每个类的字节码文件,用类加载器加载成class对象,基于反射判断@Component等注解,有的话这个类就是Bean类。
    • BeanPostProcessor实例化后存列表:如果Bean类是BeanPostProcessor接口的实现类,那么就将这个Bean类实例化并存进成员变量List里;
    • 创建并赋值BeanDefinition对象:创建BeanDefinition对象并赋值,type变量赋值Bean类的class对象,scope变量赋值作用域(通过反射获取@Scope注解值)。BeanDefinition存储Bean的对象、作用域等元信息。
    • beanDefinitionMap添加键值对:把Bean名和它对应的BeanDefinition对象,以键值对形式添加到容器类成员变量beanDefinitionMap里。beanDefinitionMap线程安全,是ConcurrentHashMap类型。
  • 遍历beanDefinitionMap创建Bean:遍历beanDefinitionMap的键,调用createBean()方法创建Bean。createBean()方法具体逻辑:
    • 实例化:基于反射,根据Bean类的Class对象推断构造方法、创建实例,如果是单例就存入单例池。实例化这个方法在getBean()时候也会用到,所以抽取成私有方法,这个方法获取Bean先判断作用域,单例的话就优先根据Bean名从单例池取,单例池没有就调用createBean()方法,根据Bean名和对应的BeanDefinition创建Object类型的Bean对象。
    • 属性填充:基于反射,根据Bean类的Class对象获取它所有属性,将注解了@Autowired等的属性开启私有成员访问限制,通过getBean(名或类)方法给该属性填充它的Bean对象。getBean()方法:判断作用域,如果单例则调用createBean()再放入单例池再返回,如果原型则调用createBean()后直接返回。简化起见这里暂时只考虑一级缓存,二级三级缓存暂时不考虑。
    • 处理Aware回调:如果Bean实例实现了BeanNameAware接口(通过instanceof判断),调用Bean重写的setBeanName()方法,给Bean实例的beanName变量赋值。
    • 执行所有BeanPostProcessor的初始化前方法:遍历BeanPostProcessor列表,执行每个BeanPostProcessor对象里的postProcessBeforeInitialization()方法。本方法可以通过JDK的Proxy.newProxyInstance()实现动态代理返回目标对象的代理对象。
    • 初始化:如果Bean实例实现了InitializingBean接口(通过instanceof判断),调用Bean重写的afterPropertiesSet()方法,处理初始化逻辑。afterPropertiesSet译为“在属性填充之后”
    • 执行所有BeanPostProcessor的初始化后方法:遍历BeanPostProcessor列表,执行每个BeanPostProcessor对象里的postProcessAfterInitialization()方法。本方法可以通过JDK的Proxy.newProxyInstance()实现动态代理返回目标对象的代理对象。
    • 放进单例池:如果是单例还要把Object类型Bean的代理对象放进单例池singletonObjects。

2.1 代码实现

spring包下的VinceApplicationContext类  

2.1.1 成员变量 

    private Class configClass;//配置类的Class对象

    //Bean名和它对应的BeanDefinition键值对;
    private ConcurrentHashMap beanDefinitionMap = new ConcurrentHashMap<>();

    //单例池;map存各Bean名所对应的Bean实例
    private ConcurrentHashMap singletonObjects = new ConcurrentHashMap<>();
    //存放扫描包路径下的所有BeanPostProcessor类
    private ArrayList beanPostProcessorList = new ArrayList<>();

2.1.2 构造方法,参数是配置类

//构造方法,参数是配置类的Class对象
    public VinceApplicationContext(Class configClass) {
        //1.赋值配置类成员变量
        this.configClass = configClass;
        // 2.通过反射,判断配置类Class对象有没有注解@ComponentScan;如果有,就解析ComponentScan对象
        // --->BeanDefinition -->beanDefinitionMap
        if (configClass.isAnnotationPresent(ComponentScan.class)) {
            //解析ComponentScan对象
            ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
//            获取ComponentScan对象的value,也就是用户传入的扫描路径。例如@ComponentScan("com.vince.service"),扫描这个包下的Bean
            String path = componentScanAnnotation.value();// com.vince.service
            // 将包名中的点号替换为斜杠
            path = path.replace(".","/");//com/vince/service
            // 获取容器类的类加载器
            ClassLoader classLoader = VinceApplicationContext.class.getClassLoader();
            // 类加载器获取扫描包的绝对路径
            URL resource = classLoader.getResource(path);//file:/D:/xxx/com/vince/service
            // 把URL绝对路径对象封装成File对象
            File file = new File(resource.getFile());
            // 如果File对象是目录,则遍历判断扫描目录下的文件是不是bean;
            if (file.isDirectory()) {
                File[] files = file.listFiles();
                //遍历“扫描路径”下所有文件中,找到Bean,创建对应BeanDefinition对象,并存到map里;
                // 判断Bean方式:基于反射,判断该字节码文件对应的类有没有@Component注解
                for (File f: files) {
                    String fileName = f.getAbsolutePath();
                    if (fileName.endsWith(".class")) {
                        //将文件名转为类名;D:\xxx\com\vince\service\AppConfig.class ----> AppConfig
                        //这里其实不应该写死成“com”,只是方便起见,其实应该用更复杂的逻辑截取全名为类名
                        String className = fileName.substring(fileName.indexOf("com"), fileName.indexOf(".class"));
                        className = className.replace("\\",".");
                        try {
                            //根据类的全限定名加载类
                            Class clazz = classLoader.loadClass(className);
                            //如果该类有@Component注解
                            if (clazz.isAnnotationPresent(Component.class)) {
                                System.out.println("容器类构造方法里,扫描@ComponentScan('xx'),发现xx路径下这个类是Bean:"+clazz.getName());
                                //a.如果@Component("类名")有设置类名,Bean名就是设置的这个类名
                                Component component = clazz.getAnnotation(Component.class);
                                String beanName = component.value();

                                //判断这个Bean类是不是BeanPostProcessor接口的实现类,如果是的话就通过反射创建实例,并放进处理器列表里。
                                //注意不能用instanceof,因为instanceof是实例与类的关系比较,isAssignableFrom是类和接口的关系比较
                                if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
                                    BeanPostProcessor instance = (BeanPostProcessor) clazz.newInstance();
                                    beanPostProcessorList.add(instance);
                                    System.out.println("这个Bean是BeanPostProcessor接口的实现类,需要加入list里,以供所有Bean初始化之前和之后增强");
                                }

                                //b.如果@Component没有设置类名,就将首字母小写后的Bean类名设为Bean名
                                if ("".equals(beanName)) {
                                    beanName = Introspector.decapitalize(clazz.getSimpleName());//工具类将字符串校验后首字母小写
                                }

                                // 创建一个BeanDefinition对象,用来描述Bean,里面赋值这个Bean的类型和作用域
                                BeanDefinition beanDefinition = new BeanDefinition();
                                //反射获取@Scope注解指定的作用域,赋值给BeanDefinition对象的scope变量
                                if (clazz.isAnnotationPresent(Scope.class)) {
                                    Scope scopeAnnotation = clazz.getAnnotation(Scope.class);
                                    beanDefinition.setScope(scopeAnnotation.value());
                                }else{
                                    beanDefinition.setScope("singleton");
                                }
                                //把这个Bean的Class对象赋值给BeanDefinition对象的type变量
                                beanDefinition.setType(clazz);
                                //把所有Bean名和它对应的BeanDefinition对象映射关系,存到map里统一管理
                                beanDefinitionMap.put(beanName,beanDefinition);
                                System.out.println("Bean名:"+beanName+",BeanDefinition对象:"+beanDefinition);
                            }
                        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

        // 3.实例化bean,如果作用域是单例,则从单例池中取;取不到就创建新的Bean对象,并存入单例池
        for (String beanName:beanDefinitionMap.keySet()) {
            BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
            if ("singleton".equals(beanDefinition.getScope())) {
                //实例化Bean
                Object bean = createBean(beanName,beanDefinition);
                singletonObjects.put(beanName,bean);
            }
        }
    }

2.1.3 createBean()方法 

    //根据Bean名和BeanDefinition对象实例化Bean的方法;私有,只供本类内部调用
    //BeanDefinition对象的成员变量type就是Bean的类型(Class格式)
    private Object createBean(String beanName,BeanDefinition beanDefinition){
//        获取Bean的Class格式的类型
        Class clazz = beanDefinition.getType();
        try {
            //1.基于反射创建Bean的实例;
            Object instance = clazz.getConstructor().newInstance();
            //2.依赖注入
            //遍历Bean类Class对象的所有属性;
            for (Field f : clazz.getDeclaredFields()) {
                //找出有@Autowired注解的属性,给这些属性进行填充
                if (f.isAnnotationPresent(Autowired.class)) {
                    //破除 private 修饰符访问限制;这样就可以访问注入的这个依赖里面的私有成员
                    f.setAccessible(true);
                    //给该属性填充属性名对应的Bean对象。
                    // 该属性通过getBean能获得Bean,因为上面构造方法里已经扫描了所有的Bean,并创建了BeanDefinition对象加入到“声明map”里了。
                    //void set(Object obj, Object value)
                    //obj 表示要设置属性值的对象;value 表示要为该成员变量设置的新值。
                    f.set(instance,getBean(f.getName()));
                }
            }

            // 3.Aware回调。如果Bean实例实现了BeanNameAware接口,就调用重写的setter方法,给Bean实例的beanName变量赋值
            if (instance instanceof BeanNameAware) {
                ((BeanNameAware) instance).setBeanName(beanName);
            }

            // 遍历后置处理器列表,执行后置处理器的before方法,在Bean 的初始化方法(如 @PostConstruct 注解的方法)被调用之前被自动调用
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessBeforeInitialization(beanName,instance);
            }

            // 初始化
            if (instance instanceof InitializingBean) {
                ((InitializingBean) instance).afterPropertiesSet();
            }

            //Bean后置处理器接口的after方法,在 Bean 的初始化方法被调用之后被自动调用
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessAfterInitialization(beanName,instance);
            }
            return instance;
        } catch (InstantiationException e) {            //异常处理
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }

2.1.4 getBean()方法

//容器类的getBean()方法,根据作用域获取Bean
    public Object getBean(String beanName){
        //从map里获取BeanDefinition对象
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        if (beanDefinition == null) {
            //如果BeanDefinition对象为空,说明这个bean没有创建成功,抛异常;
            throw new NullPointerException();
        }else{
            //如果BeanDefinition对象不为空,则判断作用域后获取Bean
            String scope = beanDefinition.getScope();
            if ("singleton".equals(scope)) {
                //如果是单例则从单例池根据Bean名取Bean;
                Object bean= singletonObjects.get(beanName);
                if (bean == null) {
                    //如果单例池查到的是null,则新创建Bean,再给单例池赋值
                    bean = createBean(beanName, beanDefinition);
                    singletonObjects.put(beanName,bean);
                }
                //返回Bean
                return bean;
            }else{
                // 多例,每次直接创建新的
                return createBean(beanName, beanDefinition);
            }
        }
    }

三、所有代码

https://gitee.com/vincewm/spring-master

你可能感兴趣的:(Java学习路线,spring,java,spring,boot)