手写Spring IOC源码

跟风。

已于 2022-11-16 14:09:10 修改

阅读量169

点赞数

分类专栏： Spring 文章标签： spring java 后端

于 2022-11-16 13:39:08 首次发布

本文链接：https://blog.csdn.net/qq_59415584/article/details/127881174

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文详细介绍了Spring IOC基于注解的执行原理，从扫描带有注解的组件，到创建BeanDefinition，再到动态创建Bean并进行属性注入。通过自定义`MyAnnotationConfigApplicationContext`模拟了Spring的这一过程，包括获取类、封装BeanDefinition、反射创建对象及Autowired自动装配等功能。

摘要由CSDN通过智能技术生成

手写Spring IOC源码

1、IOC基于注解的执行原理

在这里插入图片描述

1、扫描包的组件

找出所有添加了注解（@Component等）的目标类

2、获取原材料的组件

BeanDefinitions通过Class（目标类）、BeanName来创建Bean。

3、根据原材料动态创建Bean

动态的遍历BeanDefinitions，放入IOC容器

了解了IOC容器的执行原理，我们就可以试着去模拟这样的执行流程了。

2、模拟Spring IOC源码

思路：

自定义一个MyAnnotationConfigApplicationContext，构造器中要传入要扫描的包;
获取包下的所有类;
遍历这些类，找出添加了@Component注解的类，获取它的Class和对应的beanName，封装成一个BeanDefinition，存入集合Set，这个就是IOC自动装载的原材料;
遍历Set集合，通过反射机制创建对象，同时检查属性是否添加@Value注解，如果有还需要给属性赋值，再将这些动态创建的对象以K-V的形式存入缓存区;
提供getBean方法，通过beanName取出对应的bean即可;

1. 基本环境

1.1 注解

Component注解

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

Value注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Value {
    String value();
}

Autowired注解

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

}

qualifier注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Qualifier {
    String value();
}

1.2 实体类

student

@Data
@Component
public class Student {
    private String name;
    private String sex;
    private Integer age;
}

teacher

@Data
@Component
public class Teacher {
    private String name;
    private String sex;
    private Integer age;
}

BeanDefinition

封装beanName和beanClass属性，用来描述bean

@Data
@NoArgsConstructor
@AllArgsConstructor
public class BeanDefinition {
    private String beanName;
    private Class beanClass;
}

1.3 工具类

ClassUtil

获取指定包下的所有类

public class ClassUtil {
    private static Set<Class<?>> classList;
    static {
        classList = getClasses("com.esri.rest");
    }
    /**
     * 从包package中获取所有的Class
     *
     * @param pack
     * @return
     */
    public static Set<Class<?>> getClasses(String pack) {

        // 第一个class类的集合
        Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
        // 是否循环迭代
        boolean recursive = true;
        // 获取包的名字 并进行替换
        String packageName = pack;
        String packageDirName = packageName.replace('.', '/');
        // 定义一个枚举的集合 并进行循环来处理这个目录下的things
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            // 循环迭代下去
            while (dirs.hasMoreElements()) {
                // 获取下一个元素
                URL url = dirs.nextElement();
                // 得到协议的名称
                String protocol = url.getProtocol();
                // 如果是以文件的形式保存在服务器上
                if ("file".equals(protocol)) {
                    // System.err.println("file类型的扫描");
                    // 获取包的物理路径
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    // 以文件的方式扫描整个包下的文件 并添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                } else if ("jar".equals(protocol)) {
                    // 如果是jar包文件
                    // 定义一个JarFile
                    // System.err.println("jar类型的扫描");
                    JarFile jar;
                    try {
                        // 获取jar
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        // 从此jar包 得到一个枚举类
                        Enumeration<JarEntry> entries = jar.entries();
                        // 同样的进行循环迭代
                        while (entries.hasMoreElements()) {
                            // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 如果是以/开头的
                            if (name.charAt(0) == '/') {
                                // 获取后面的字符串
                                name = name.substring(1);
                            }
                            // 如果前半部分和定义的包名相同
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                // 如果以"/"结尾 是一个包
                                if (idx != -1) {
                                    // 获取包名 把"/"替换成"."
                                    packageName = name.substring(0, idx).replace('/', '.');
                                }
                                // 如果可以迭代下去 并且是一个包
                                if ((idx != -1) || recursive) {
                                    // 如果是一个.class文件 而且不是目录
                                    if (name.endsWith(".class") && !entry.isDirectory()) {
                                        // 去掉后面的".class" 获取真正的类名
                                        String className = name.substring(packageName.length() + 1, name.length() - 6);
                                        try {
                                            // 添加到classes
                                            classes.add(Class.forName(packageName + '.' + className));
                                        } catch (ClassNotFoundException e) {
                                            // log
                                            // .error("添加用户自定义视图类错误
                                            // 找不到此类的.class文件");
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        // log.error("在扫描用户定义视图时从jar包获取文件出错");
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return classes;
    }

    /**
     * 以文件的形式来获取包下的所有Class
     *
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
                                                        Set<Class<?>> classes) {
        // 获取此包的目录 建立一个File
        File dir = new File(packagePath);
        // 如果不存在或者 也不是目录就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
            return;
        }
        // 如果存在 就获取包下的所有文件 包括目录
        File[] dirfiles = dir.listFiles(new FileFilter() {
            // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
            public boolean accept(File file) {
                return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
            }
        });
        // 循环所有文件
        for (File file : dirfiles) {
            // 如果是目录 则继续扫描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
                        classes);
            } else {
                // 如果是java类文件 去掉后面的.class 只留下类名
                String className = file.getName().substring(0, file.getName().length() - 6);
                try {
                    // 添加到集合中去
                    // classes.add(Class.forName(packageName + '.' +
                    // className));
                    // 经过回复同学的提醒，这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净
                    classes.add(
                            Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
                } catch (ClassNotFoundException e) {
                    // log.error("添加用户自定义视图类错误 找不到此类的.class文件");
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        System.out.println(classList);
        Object[] ts =   classList.toArray();
        for(Object t:ts){
            Class<?> tt = (Class<?>) t;
            System.out.println(tt.getName());
        }
    }
}

2. MyAnnotationConfigApplicationContext

构造方法

传入要扫描的包路径

public MyAnnotationConfigApplicationContext(String park) {

        // 获取BeanDefinition集合
        Set<BeanDefinition> beanDefinitions = findBeanDefinitions(park);
        // 根据原材料创建bean
        createObject(beanDefinitions);

    }

findBeanDefinitions

获取包下的所有类，并找到是否添加Component注解，如果有则将这些类封装成BeanDefinnition

public Set<BeanDefinition> findBeanDefinitions(String park) {

        Set<BeanDefinition> beanDefinitions = new HashSet<BeanDefinition>();

        // 1. 获取包下的所有类
        Set<Class<?>> classes = ClassUtil.getClasses(park);
        // 2. 遍历这些类，找到添加注解的类
        Iterator<Class<?>> iterator = classes.iterator();
        while (iterator.hasNext()) {
            // 获取到每个类
            Class<?> clazz = iterator.next();
            // 查看是否有Component注解
            Component annotation = clazz.getAnnotation(Component.class);
            if (annotation != null) {
                // 已添加Component注解
                String beanName = annotation.value();
                if (beanName.equals("")) {
                    // 获取类名 首字母小写
                    String className = clazz.getName().replaceAll(clazz.getPackage().getName() + ".", "");
                    beanName = className.substring(0, 1).toLowerCase() + className.substring(1);
                    System.out.println("beanName:" + beanName + ",beanClazz:" + clazz);
                }
                // 3. 将这些类封装成BeanDefinition ，装载到集合中
                beanDefinitions.add(new BeanDefinition(beanName, clazz));
            }
        }
        return beanDefinitions;
    }

CreateObject

遍历Set集合，通过反射创建对象，同时检测属性是否添加了@Value注解，如果有还需要给属性赋值，再将这些动态创建的对象以K-V的形式存入缓存区

public void createObject(Set<BeanDefinition> beanDefinitions) {
        // 遍历Set集合
        Iterator<BeanDefinition> iterator = beanDefinitions.iterator();
        while (iterator.hasNext()) {
            BeanDefinition beanDefinition = iterator.next();
            Class clazz = beanDefinition.getBeanClass();
            String beanName = beanDefinition.getBeanName();
            // 创建对象
            Object obj = null;
            try {
                obj = clazz.getConstructor().newInstance();
                // 属性赋值
                Field[] declaredFields = clazz.getDeclaredFields();
                for (Field declaredField : declaredFields) {
                    Value valueAnnotation = declaredField.getAnnotation(Value.class);
                    // 判断是否存在Value注解
                    if (valueAnnotation != null) {
                        String value = valueAnnotation.value();
                        // 获取set方法
                        String fieldName = declaredField.getName();
                        String methodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                        Method method = clazz.getMethod(methodName, declaredField.getType());
                        // 类型转换
                        Object val = null;
                        switch (declaredField.getType().getName()) {
                            case "java.lang.Integer":
                                val = Integer.parseInt(value);
                                break;
                            case "java.lang.String":
                                val = value;
                                break;
                            case "java.lang.Float":
                                val = Float.parseFloat(value);
                                break;
                        }
                        // 为属性注入值
                        method.invoke(obj, val);
                    }
                }
                // 存入map集合中
                map.put(beanName, obj);

            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

getBean

用于返回缓存区中的bean对象

public Object getBean(String beanName) {
    return map.get(beanName);
}

3. Test

public class Test {
    public static void main(String[] args) {
        MyAnnotationConfigApplicationContext applicationContext = new MyAnnotationConfigApplicationContext("com.demo.entity");

        System.out.println(applicationContext.getBean("student"));
        System.out.println(applicationContext.getBean("teacher"));
    }
}

没有@Value注解
在这里插入图片描述
为student添加了@Value注解

4. Autowired自动装载

在这里插入图片描述

public void  autowiredObject(Set<BeanDefinition> beanDefinitions){
        Iterator<BeanDefinition> iterator = beanDefinitions.iterator();
        while (iterator.hasNext()){
            BeanDefinition beanDefinition = iterator.next();
            Class clazz = beanDefinition.getBeanClass();
            Field[] declaredFields = clazz.getDeclaredFields();
            for (Field declaredField : declaredFields) {
                Autowired annotation = declaredField.getAnnotation(Autowired.class);
                if(annotation!=null){
                    Qualifier qualifier = declaredField.getAnnotation(Qualifier.class);
                    if (qualifier!=null){
                        // byName
                        String beanName = qualifier.value();
                        Object bean = getBean(beanName);
                        String fieldName = declaredField.getName();
                        String methodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                        Method method = null;
                        try {
                            method = clazz.getMethod(methodName, declaredField.getType());
                            Object obj = getBean(beanDefinition.getBeanName());
                            method.invoke(obj,bean);
                        } catch (NoSuchMethodException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        } catch (InvocationTargetException e) {
                            e.printStackTrace();
                        }
                    }else{
                        // byType
                    }
                }
            }
        }
    }