一个简易的Spring-Ioc容器

最新推荐文章于 2023-02-26 21:59:14 发布

CN_XiaoHei

最新推荐文章于 2023-02-26 21:59:14 发布

阅读量654

点赞数

分类专栏： Spring 知识分享文章标签： java leetcode 算法

本文链接：https://blog.csdn.net/CN_XiaoHei/article/details/121663442

版权

知识分享同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

Spring

1 篇文章 0 订阅

订阅专栏

Spring是一个Java开发框架，核心内容包括spring-ioc、spring-aop等组件，支持对象的控制反转，依赖自动注入.

学习Spring是每一个Java开发者都要做的事，正所谓读万卷书不如行万里路，所以在此开始练习完善一个Spring框架，今天首先模拟一个简单的ioc容器实现过程. Spring在进行ioc时，首先要确定容器包含类的范围，然后将此范围内的所有被标记的类加载到容器中，最后对这些类进行初始化，生成对象并存储在容器中.
步骤：

得到包扫描路径
扫描路径，将路径下所有class文件存储
初始化对象，存入容器

所有的系统都存在一个入口，Java程序中就是启动类的main方法，我们可以通过在启动类上增加注解，
利用注解记录包扫描的路径

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
    //包扫描路径
    String value() default "";
}

首先，新建容器ApplicationContext,创建容器时将将启动类的class对象作为参数初始化容器

public class ApplicationContext {
    
    private Class<?> clazz;
    
    public ApplicationContext(Class<?> clazz) {
        this.clazz = clazz;
    }

    public void run() {
        //1.获取扫描路径
        ComponentScan componentScan = clazz.getAnnotation(ComponentScan.class);
        String basePackage = componentScan.value();
    }
}

在启动类上加上@Component,启动后检测该注解的value,解析为包路径

@ComponentScan(value = "com.spring")
public class SpringApplication {

    public static void main(String[] args) {
        ApplicationContext context = new ApplicationContext(SpringApplication.class);
        context.run();
        Scanner sc = new Scanner(System.in);
        sc.next();
    }
}

我们需要把该路径下的所有被标记的类加载到容器中，这里使用的标记是注解@Component

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

加载包路径下的class文件

public class ApplicationContext {
    
    ...

    //存储bean的class对象
    private final Map<String, Class<?>> beanClassMap = new ConcurrentHashMap<>();
    //存储bean的容器
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    
    public void run() {
        //扫描包文件
        //1.获取扫描路径
        ComponentScan componentScan = clazz.getAnnotation(ComponentScan.class);
        String basePackage = componentScan.value();
        String path = basePackage.replace('.', '/');
        try {
            //获取该路径下的文件
            Enumeration<URL> dirs = Thread.currentThread().getContextClassLoader().getResources(path);
            while (dirs.hasMoreElements()) {
                URL url = dirs.nextElement();
                String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                //获取包路径的File对象
                File file = new File(filePath);
                File[] files = file.listFiles();
                //这里转成List是为了使用广度优先遍历，需要add待扫描文件夹
                List<File> fileList = new ArrayList<>();
                for (File file1 : files) {
                    fileList.add(file1);
                }
                //广度优先遍历
                for (int i = 0; i < fileList.size(); i++) {
                    File file1 = fileList.get(i);
                    if (file1.isDirectory()) {
                        File[] files1 = file1.listFiles();
                        if (files1==null) {
                            continue;
                        }
                        for (File file2 : files1) {
                            //存在子文件则直接加入遍历队列
                            fileList.add(file2);
                        }
                        continue;
                    }else {
                        //扫描.class文件
                        if (file1.getName().endsWith(".class")) {
                            String className = file1.getName().substring(0, file1.getName().length() - 6);
                            try {
                                String absolutePath = file1.getAbsolutePath();
                                int i1 = absolutePath.indexOf(path.replace("/", "\\"));
                                String substring = absolutePath.substring(i1);
                                substring = substring.replace('\\', '.').substring(0, substring.length() - 6);
                                //这里是因为发现在使用过程中会出现以$1结尾的.class文件，所以处理一下
                                if (substring.endsWith("$1")) {
                                    continue;
                                }
                                Class<?> clazz = Class.forName(substring);
                                beanClassMap.put(clazz.getCanonicalName(), clazz);
                            } catch (ClassNotFoundException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        } catch (IOException e) {
            log.error("包扫描error: ", e);
        }
        //将类注入进容器
        Set<Map.Entry<String, Class<?>>> entries = beanClassMap.entrySet();
        for (Map.Entry<String, Class<?>> entry : entries) {
            String beanName = entry.getKey();
            Class<?> beanClass = entry.getValue();
            //检查是否包含@Component注解
            if (beanClass.isAnnotationPresent(Component.class)) {
                if (!singletonObjects.containsKey(beanName)) {
                    Object bean = null;
                    try {
                        //简单粗暴
                        bean = beanClass.newInstance();
                    } catch (InstantiationException | IllegalAccessException e) {
                        log.error("反射bean出现错误，beanName: {}", beanName, e);
                    }
                    singletonObjects.put(beanName, bean);
                }
            }
        }
    }
}

然后我们在com.spring目录下新建两个类，一个使用注解，一个不使用

@Component
public class Test1 {
}
public class Test2 {
}

运行后可以看到，beanClassMap扫描到了com.spring下的所有.class对象，然后将包含@Component注解的对象注入到容器中