手写模拟Spring的底层原理2.1

先来引入两个问题

第一个懒加载还是立即加载的问题，这个问题还是在于就是说，当我们xml配置了一个对象bean的时候，它在spring容器里面是什么时候开始会给我们创建这个对象

那如果我们想对某个对象启动懒加载，可以添加@lazy这个注解

 这个注解一加上，它就只会在得到对象的时候给我们在容器中创建对象

也就是在使用下面的方法的时候才会去创建一个对象

那么默认这个对象得到的是单例还是多例，我们先来说一个小知识点

那么我们测试一下多例还是单例

 

很明显上面是单例设计模式

那么我们如何把它变成多例，就得靠下面这个注解来做

 

 java的三个类加载器分别是什么

 

 下面说关于注解的一些反射方法的用法

1.要判断在一个类上面有没有某个注解接口

configClass.isAnnotationPresent(ComponentScan.class)

利用这个类的字节码对象去调用上面的方法，内部传入我们需要去判断注解接口的字节码对象

2.如果有这个注解，我们需要去拿到这个注解对象

ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);

还是利用当前类字节码对象去调用getAnnotation()方法，内部传入一个我们需要得到的这个注解对象的字节码对象

3.当拿到这个注解对象之后，我们现在想要去拿到值，也就是调用内部的方法就可以了，比如value的值，直接调用value()方法

String path = componentScanAnnotation.value();

这样就可以得到配置在这个注解上面的值，重点还是value属性的值

下面讲解一下关于class文件资源路径获取的问题

 我们一般在程序的开发当中，生成的class文件会直接放到下面这个目录里面，然后我一般通过内存操作判定就是这个文件的信息

上面两者包都是对应的，只是说在target里面，他还有前面两个固定的包

 那么我们如果想获取target里面的User怎么获取

上面就是拿到类加载器，然后去调用getResource(),里面传入一个你需要查找类的相对包的路径，然后会给我们返回一个URL ，这个URL就是一个在target上面的绝对路径，他包括了整个硬盘的位置

也就是说类加载器会给我们自动凭借好target/classses这两个目录

然后通过URL的resource对象调用getFile()，就可以把这个路径变成一个字符串，然后可以传入到一个FIle对象里面，然后利用File对象我们就可以做一些事儿

 下面说一下文件对象里面的listFiles()的用法

 

 比如我刚噶上面的操作，贴过来

 

他就可以找到这个class文件的完整路径

我们还可以做一些截取操作直接拿到com\pxx\domain\User这部分

循环遍历就可以拿到domain下面的所有class文件

下面写一个简单一点的spring的源码

 这个就是先跑通最基础的程序吧，就是我们可以通过getBean去得到一个单例或者多例的对象

先把项目结构简单的弄出来

下面做一个简单的分析，怎么着手

首先我们在spring容器中我们需要一个容器对象，就类似于下面这个容器对象

所以我们把这个容器对象在我们的spring里面给创建出来，我们这里叫PxxApplicationContext对象

 下面我们要干嘛，是不是要去扫描包，为什么说我们要去扫描包，因为我们主要是扫描上面的注解

比如我们要去判断这个类上面有没有component这个注解啊，有的话，我们就要去创建这个对象

还有比如说这个对象上面有没有scope这个注解，这个注解里面给我们配置的值是单例还是多例

这些注解都要被扫描到

因为现在我们要去扫描到这些注解嘛，所以，我们先去写几个常用的注解在上面

这些注解先都是放到spring下面的annotation的包下面

第一个注解：Component注册对象用的

第二个注解： ComponentScan配置要扫描哪一个包用的

 第三个注解：Scope注解这个对象的生成是单例还是多例

好了，现就写上面三个注解

下面我们去扫描包，扫描类，扫描注解，还是去完成scan方法

大概步骤如下

写到下面我发现需要一个BeanDefinition对象来保存一些对象的信息

比如它是什么类型的Class,它的Scope是什么值，他是否采用延迟加载

于是我们去构建一个这样的对象，放到了spring下面的domain包里面

package com.spring.domian;

public class BeanDefinition {

    private Class type;
    private String scope;
    private boolean isLazy;

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

    public boolean isLazy() {
        return isLazy;
    }

    public void setLazy(boolean lazy) {
        isLazy = lazy;
    }
}

 既然有了这个我们就可以继续去改写我们的代码

写到下面这个位置，我又开始迷茫了

 于是我做了集合对象保存他们

做好了这个映射关系的集合之后，scan这个方法方法就做完了，下面贴一下代码，这个代码有详细的注释，可以结合着前面来看

package com.spring;

import com.spring.annotation.Component;
import com.spring.annotation.ComponentScan;
import com.spring.annotation.Scope;
import com.spring.domian.BeanDefinition;

import java.io.File;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

/**
 * @author pxx
 */
public class PxxApplicationContext {

    //内部需要传入一个配置类的class字节码文件
    private Class configClass;
    //这个集合用来存放对象与它的BeanDefinitionMap的映射信息
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();

    //写一个构造函数
    //这个构造函数不止是帮我们传入这个配置类的calss对象
    //还要帮我们做一些初始化操作，比如如果一个对象是单例
    //这个ApplicationContext new出来之后，就会创建这个对象

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

        //写一个函数做一些扫描的动作
        scan(configClass);//从这个配置类上面的包开始进行解析

    }

    //下面我们定义scan这个扫描的方法
    private void scan(Class configClass) {
        //先来判断有没有ComponentScan这个注解
        if(configClass.isAnnotationPresent(ComponentScan.class)) {
            //如果上面这个配置类有需要扫描的包的注解
            //那么我们就要取出里面的值=》然后去扫描相应的包
            //既然有了，那么我们就拿到这个ComponentScan这个对象
            ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
            String path = componentScanAnnotation.value();//就能得到我们需要扫描的包
            path = path.replace(".","/");//因为得到的是com.pxx.service
            //但是我们下面要去利用文件扫描，我们需要一个真实的路径，所以上面需要替换一下

            //上面就得到了我们需要扫描的包
            //那么我们真正要扫描的是什么？是源代码文件吗？并不是，我们需要的是一个class字节码对象文件
            //我们真正要去扫的是这个class文件，这个文件很多对象的信息嘛
            //怎么得到这个文件位置，我们用类加载器器来做
            //类加载器一般就用来寻找资源文件
            ClassLoader classLoader = PxxApplicationContext.class.getClassLoader();
            //这里你可以这样，他会自动去开始从target/classes下面开始拼接你这个额path路径
            URL resource = classLoader.getResource(path);//这个就会绝对的路径URl对象，是在target里面
            //把这个路径变成字符串然后封装到File对象，我们用Filed对象再去遍历这个文件夹下面的每一个类
            File file = new File(resource.getFile());

            //下面开始遍历这个绝对路径下面的文件
            if (file.isDirectory()) {
                for (File f : file.listFiles()) {
                    //我们要去拿到的是什么
                    //其实就是com.pxx.servcie下面的每一个类的全限定类名
                    //比如com.pxx.service.User com.pxx.service.Order ..
                    String absolutePath = f.getAbsolutePath();
                    //主要在于这里我们需要按照字符串位置截取
                    //这里会截出一个com\pxx\service\User  比如com\pxx\service\Ortder
                    absolutePath = absolutePath.substring(absolutePath.indexOf("com"),absolutePath.indexOf(".class"));
                    //我们把上面的\全部变成.,因为后面我们需要加载进内存
                    absolutePath = absolutePath.replace("\\",".");

                    //上面基本的找类的字节码对象就已经找到了
                    //下面我们就需要把这些类加载到内存里面，然后变成一个Class字节码对象
                    //因为只有变成Class字节码对象，我们才能去查找这个类上面有什么注解
                    try {
                        Class<?> clazz = classLoader.loadClass(absolutePath);
                        //判断这个字节码对象有没有Component注解
                        if(clazz.isAnnotationPresent(Component.class)) {
                            //如果有这个注解，说明这个对象需要被getBean创建
                            //我们拿到一个注解的名字，在Component里面，可能配了名字，可能没有
                            Component componentAnno = clazz.getAnnotation(Component.class);
                            String beanName = componentAnno.value();
                            //结合下面来看每一个对象好像都有一些信息配置
                            //那么我们就考虑到为了灵活性
                            //我们就把这些信息封装到一个BeanDefinition对象里面
                            BeanDefinition beanDefinition = new BeanDefinition();
                            //设置一下它的class类型
                            beanDefinition.setType(clazz);//什么类的字节码对象
                            //然后我们又要去判断有没有Scope这个注解
                            if(clazz.isAnnotationPresent(Scope.class)) {
                                //如果有这个注解，我们就要去得到这个注解的对象
                                Scope scopeAnn = clazz.getAnnotation(Scope.class);//从内存中就得到了这个注解对象
                                String value = scopeAnn.value();//用来判断这里是单例还是多例
                                //这里还是把信息封装到BeanDefinition里面
                                beanDefinition.setScope(value);
                            } else {
                                //如果没有这个注解说明它就是一个单例
                                beanDefinition.setScope("singleton");//这是这个Scope注解的可用取值
                            }

                            //写到这，我们又得来考虑一个问题
                            //首先就是说在com.pxx.service下面他不止一个class,有很多
                            //那么也就是说产生的BeanDefinition就会有很多，就是会有很多对象的信息的嘛
                            //那么我们这里为了区分，我们指定用beanName->BeanDefinition对象
                            //上面有一个映射关系，那么我们就做一个集合存进去
                            beanDefinitionMap.put(beanName,beanDefinition);
                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

下面我们测一下，写几个类，看看这个map里面有没有把对象收录进去

下面在service包里面做了两个service对象

 

下面这个service是一个什么都没有加的service

 

然后我们要去写一个配置类用于开启包扫描

 

然后写我们主方法，写之前我在scan里面打印了一下保存对象信息的map集合

 然后主方法直接new，上面的构造方法开始运行

看一下运行结果

 

打印了两个对象，完美，因为有一个对象没有加任何注解，所以下面 他根本进不去

找到Class字节码对象之后，验证了有Component注解才会进去

还有一个小问题是，我刚刚没在@Component注解里面写名字，所有对象进来都没有名字，去测试一下发现确实为空

 

我们先去给注解加上名字，方便后面进行测试

 

 下面再去测名字就进去了

 下面我们就要去写getBean方法来给我们生产对象

写到这个位置，我又卡住了单例多例这里怎么来设计

单例必须保证每次取出来的对象都是同一个对象，我考虑用一个集合来做，如果同一个对象过来，都从集合里面取出唯一的键，然后获取固定的对象不就好了

因此我在做一个下面的映射集合存放名字与对象的映射集合

 

 上面除了createBean这个方法没有之外，还是存在一个问题的，也就是，单例从集合中取，第一次过来数据从哪里来的？

这个时候，我们考虑一个问题，那就是spirng的加载模式，是在new 一个容器之后就创建出来对象，还是getBean时创建出来对象吗，这里我们默认是立即加载

既然这样，那么我们创建对象的工作，就必须放到容器的构造函数里面执行，也就是说，san包扫描完成之后，把相应的对象信息都放到集合里面去了之后，就要卡死给我们生产对象

于是我们去修改代码

先来看一个方法

这个是HashMap里面的饿方法，把集合里面元素放到Set集合里面，Set集合内部保存的是一个Entry对象，有 下面两个方法

好了继续我们的代码，说这个只是因为等会我要用增强for循环来遍历beanDefinitionMap里面的数据

再来说一点

 这个位置加载不同类的class文件，会返回不同类Class类的信息。

所以这里放进来的也不是不同类的Class字节码对象

下面直接上完整代码

package com.spring;

import com.spring.annotation.Component;
import com.spring.annotation.ComponentScan;
import com.spring.annotation.Scope;
import com.spring.domian.BeanDefinition;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

/**
 * @author pxx
 */
public class PxxApplicationContext {

    //内部需要传入一个配置类的class字节码文件
    private Class configClass;
    //这个集合用来存放对象与它的BeanDefinitionMap的映射信息
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
    //这个用来存放bean名字与之对应的对象
    private Map<String, Object> singletonObjects = new HashMap<>();

    //写一个构造函数
    //这个构造函数不止是帮我们传入这个配置类的calss对象
    //还要帮我们做一些初始化操作，比如如果一个对象是单例
    //这个ApplicationContext new出来之后，就会创建这个对象

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

        //写一个函数做一些扫描的动作
        scan(configClass);//从这个配置类上面的包开始进行解析

        //立即加载，new一个对象之后马上创建Bean对象
        //采用循环，遍历出beanDefinitionMap里面能的beanName
        for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
            String beanName = entry.getKey();//得到bean的名字
            BeanDefinition beanDefinition = entry.getValue();//得到对应的对象信息
            //这里不管是单例都应该马上创建一个对象出来
            Object bean = createBean(beanName, beanDefinition);
            //再来判断一把,如果这个对象是单例，放到集合里面去
            if (beanDefinition.getScope().equals("singleton")) {
                singletonObjects.put(beanName,bean);
            }
        }

    }

    //下面我们定义scan这个扫描的方法
    private void scan(Class configClass) {
        //先来判断有没有ComponentScan这个注解
        if(configClass.isAnnotationPresent(ComponentScan.class)) {
            //如果上面这个配置类有需要扫描的包的注解
            //那么我们就要取出里面的值=》然后去扫描相应的包
            //既然有了，那么我们就拿到这个ComponentScan这个对象
            ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
            String path = componentScanAnnotation.value();//就能得到我们需要扫描的包
            path = path.replace(".","/");//因为得到的是com.pxx.service
            //但是我们下面要去利用文件扫描，我们需要一个真实的路径，所以上面需要替换一下

            //上面就得到了我们需要扫描的包
            //那么我们真正要扫描的是什么？是源代码文件吗？并不是，我们需要的是一个class字节码对象文件
            //我们真正要去扫的是这个class文件，这个文件很多对象的信息嘛
            //怎么得到这个文件位置，我们用类加载器器来做
            //类加载器一般就用来寻找资源文件
            ClassLoader classLoader = PxxApplicationContext.class.getClassLoader();
            //这里你可以这样，他会自动去开始从target/classes下面开始拼接你这个额path路径
            URL resource = classLoader.getResource(path);//这个就会绝对的路径URl对象，是在target里面
            //把这个路径变成字符串然后封装到File对象，我们用Filed对象再去遍历这个文件夹下面的每一个类
            File file = new File(resource.getFile());

            //下面开始遍历这个绝对路径下面的文件
            if (file.isDirectory()) {
                for (File f : file.listFiles()) {
                    //我们要去拿到的是什么
                    //其实就是com.pxx.servcie下面的每一个类的全限定类名
                    //比如com.pxx.service.User com.pxx.service.Order ..
                    String absolutePath = f.getAbsolutePath();
                    //主要在于这里我们需要按照字符串位置截取
                    //这里会截出一个com\pxx\service\User  比如com\pxx\service\Ortder
                    absolutePath = absolutePath.substring(absolutePath.indexOf("com"),absolutePath.indexOf(".class"));
                    //我们把上面的\全部变成.,因为后面我们需要加载进内存
                    absolutePath = absolutePath.replace("\\",".");

                    //上面基本的找类的字节码对象就已经找到了
                    //下面我们就需要把这些类加载到内存里面，然后变成一个Class字节码对象
                    //因为只有变成Class字节码对象，我们才能去查找这个类上面有什么注解
                    try {
                        Class<?> clazz = classLoader.loadClass(absolutePath);
                        //判断这个字节码对象有没有Component注解
                        if(clazz.isAnnotationPresent(Component.class)) {
                            //如果有这个注解，说明这个对象需要被getBean创建
                            //我们拿到一个注解的名字，在Component里面，可能配了名字，可能没有
                            Component componentAnno = clazz.getAnnotation(Component.class);
                            String beanName = componentAnno.value();
                            //结合下面来看每一个对象好像都有一些信息配置
                            //那么我们就考虑到为了灵活性
                            //我们就把这些信息封装到一个BeanDefinition对象里面
                            BeanDefinition beanDefinition = new BeanDefinition();
                            //设置一下它的class类型
                            beanDefinition.setType(clazz);//什么类的字节码对象
                            //然后我们又要去判断有没有Scope这个注解
                            if(clazz.isAnnotationPresent(Scope.class)) {
                                //如果有这个注解，我们就要去得到这个注解的对象
                                Scope scopeAnn = clazz.getAnnotation(Scope.class);//从内存中就得到了这个注解对象
                                String value = scopeAnn.value();//用来判断这里是单例还是多例
                                //这里还是把信息封装到BeanDefinition里面
                                beanDefinition.setScope(value);
                            } else {
                                //如果没有这个注解说明它就是一个单例
                                beanDefinition.setScope("singleton");//这是这个Scope注解的可用取值
                            }

                            //写到这，我们又得来考虑一个问题
                            //首先就是说在com.pxx.service下面他不止一个class,有很多
                            //那么也就是说产生的BeanDefinition就会有很多，就是会有很多对象的信息的嘛
                            //那么我们这里为了区分，我们指定用beanName->BeanDefinition对象
                            //上面有一个映射关系，那么我们就做一个集合存进去
                            beanDefinitionMap.put(beanName,beanDefinition);
                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    //下面我们去实现一个创建对象的方法
    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        //这里先简单写一些，等会方便测试
        Class clazz = beanDefinition.getType();//它是哪一个类的对象实例，之前scan就已经扫进去了
        Object instance = null;
        try {
            instance = clazz.getConstructor().newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return instance;

    }


    public Object getBean(String beanName) {
        //先从map集合中去看有没有名字与之对应的BeanDefinition信息
        if (!beanDefinitionMap.containsKey(beanName)) {
            throw new NullPointerException();
        }

        //如果有，我们从beanDefinitionMap中取出这个相应对象的信息
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);

        //然后根据内部属性判断这个对象是单例还是多例
        if (beanDefinition.getScope().equals("singleton")) {
            //单例设计
            Object singleBean = singletonObjects.get(beanName);
            return singleBean;
        } else {
            //多例
            //多例，其实就是每次都要重新创建一个对象
            Object prototypeBean = createBean(beanName, beanDefinition);
            return prototypeBean;
        }
    }



}

测试

下面改成多例测试一下

 

 

明显一测试就不一样了

下面说一下@Scope这里设置值的问题