[spring学习]7、手写spring注解扫描机制-天翼云

前言

在这一篇文章中，我们将会手动实现一个和spring包扫描类似的功能，这里先说明一下这篇文章中要使用到的一些核心技术，主要用到了注解、I/O、反射，不说废话了，直接开始吧

总体设计思路

我们会参照spring的实现思路，实现一个类似的，总体设计图如下

[spring学习]7、手写spring注解扫描机制

具体功能实现

实现自定义注解

首先新建一个项目，然后创建一个包，存放自定义的一些注解

[spring学习]7、手写spring注解扫描机制

自定义注解都会放到myAnnotation下面，下面开始写5个自定义注解，由于它们功能基本都一样，所以仅对@MyRepository注解进行详细的说明

首先先创建该注解类

public @interface MyRepository {
}

设置@Target注解，表示修饰到哪些元素上。设置@Retention注解，表示注解保留时间

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)

创建一个value属性，用于保存用户自定义bean的名称

    String value() default "";

最终该注解全部内容如下

@MyRepository

package com.ttpfx.mySpring.myAnnotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

另外四个注解类似的，换个名称即可，如下

@MyService

package com.ttpfx.mySpring.myAnnotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

@MyController

package com.ttpfx.mySpring.myAnnotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

@MyComponent

package com.ttpfx.mySpring.myAnnotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

@MyComponentScan

package com.ttpfx.mySpring.myAnnotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

实现配置类

创建一个config包，然后在里面创建MySpringConfig类

[spring学习]7、手写spring注解扫描机制

加上@MyComponentScan注解，最终代码如下

package com.ttpfx.mySpring.config;

import com.ttpfx.mySpring.myAnnotation.MyComponentScan;

@MyComponentScan
public class MySpringConfig {
}

实现MySpring容器

第一步先创建MySpringApplicationContext类

[spring学习]7、手写spring注解扫描机制

设置3个成员属性

    //要传入的配置类
    private Class<?> configClass;
    //单例对象池
    private final ConcurrentHashMap<String, Object> singletonObjects;
    //存放要实例化的一些自定义注解
    private final Class<? extends Annotation>[] classes;

然后在代码块中进行初始化

    {
        //初始化
        singletonObjects = new ConcurrentHashMap<>();
        classes = new Class[]{MyRepository.class, MyService.class,
                MyController.class, MyComponent.class};
    }

下一步就是创建构造器，在创建容器时要传入一个配置类

    public MySpringApplicationContext(Class<?> configClass) {
        this.configClass = configClass;
    }

创建一个方法，在这个方法中会根据配置类来完成初始化工作，也就是扫描包，我就创建了一个init方法

    public void init(){
        
    }

在这个方法中，首先通过配置类拿到@MyConponentScan注解，然后通过该注解获取到要进行包扫描的路径

//得到配置类上的MyComponentScan注解
MyComponentScan annotation = configClass.getAnnotation(MyComponentScan.class);
//获取包扫描路径
String path = annotation.path();

由于配置路径的形式是以.进行分割的，我们要将其变为/,还要注意路径中的中文问题

//处理中文
path = URLDecoder.decode(path,"UTF-8");
//用/替换.
String newPath = path.replace(".", "/");

这个路径只是相对于该项目的，我们通过配置类获取到ClassLoader，然后获取到实际的路径，并进行拼接，获取到最终路径

//得到配置类的ClassLoader
ClassLoader classLoader = configClass.getClassLoader();
//得到最终的绝对扫描路径
String fullPath = classLoader.getResource(newPath).getPath();
//处理中文
fullPath = URLDecoder.decode(fullPath,"UTF-8");

然后创建文件，遍历该目录下的所有文件，对于子目录，这里不进行处理

//创建文件
File rootFile = new File(fullPath);
//判断是不是一个目录
if (rootFile.isDirectory()) {
    //得到该目录下的所以文件
    File[] files = rootFile.listFiles();
    if (files == null)return;
    //遍历所以文件
    for (File file : files) {

    }
}

判断该文件是不是一个java文件

//得到文件名
String fileName = file.getName();
//判断该文件是不是java文件
if (fileName.endsWith(".class")) {
                    
}

得到类的全路径

//得到类名
String className = fileName.substring(0, fileName.lastIndexOf(".class"));
//得到类的全路径
String fullClassName = path + "." + className;

得到类的加载器

//得到类的加载器
Class<?> loadClass = classLoader.loadClass(fullClassName);

判断该类是否存在我们自定义的那几个注解

Class<? extends Annotation> legalAnnotation = null;
//对所有我们自己定义的合法注解进行遍历
for (Class<? extends Annotation> aClass : classes) {
//判断该类是否存在我们自定义的合法注解
    if (loadClass.isAnnotationPresent(aClass)){
        legalAnnotation = aClass;
        break;
    }
}
if (legalAnnotation == null)return;

下一步就是设置一个id变量，表示用户给bean设置的名字

//id表示用户给bean设置的名称
String id = "";

然后判断该注解是那一个注解，然后获取注解的value

//判断该注解是哪一个注解
if (legalAnnotation == MyRepository.class) {
    //获取该注解
    MyRepository loadClassAnnotation = loadClass.getAnnotation(MyRepository.class);
    //获取注解的值
    id = loadClassAnnotation.value();
} else if (legalAnnotation == MyService.class) {
    MyService loadClassAnnotation = loadClass.getAnnotation(MyService.class);
    id = loadClassAnnotation.value();
} else if (legalAnnotation == MyController.class) {
    MyController loadClassAnnotation = loadClass.getAnnotation(MyController.class);
    id = loadClassAnnotation.value();
} else if (legalAnnotation == MyComponent.class) {
    MyComponent loadClassAnnotation = loadClass.getAnnotation(MyComponent.class);
    id = loadClassAnnotation.value();
}

如果用户没有设置bean的名称，那么就默认该类目首字母小写作为名称

//如果id为空，那么就默认该类目首字母小写作为名称
if ("".equals(id)){
    id = className.substring(0,1).toLowerCase()+className.substring(1);
}

下一步就是实例化该对象

//得到该类的实例化对象
Object o = Class.forName(fullClassName).newInstance();

然后将该对象放入单例对象池

//将对象放入单例对象池
singletonObjects.put(id, o);

最后，我们在构造器方法中调用init方法，然后我们的初始化容器就结束了，init方法的完整代码如下

    public void init() throws UnsupportedEncodingException, ClassNotFoundException, InstantiationException, IllegalAccessException {
        //得到配置类上的MyComponentScan注解
        MyComponentScan annotation = configClass.getAnnotation(MyComponentScan.class);
        //获取包扫描路径
        String path = annotation.path();
        //处理中文
        path = URLDecoder.decode(path, "UTF-8");
        //用/替换.
        String newPath = path.replace(".", "/");
        //得到配置类的ClassLoader
        ClassLoader classLoader = configClass.getClassLoader();
        //得到最终的绝对扫描路径
        String fullPath = classLoader.getResource(newPath).getPath();
        //处理中文
        fullPath = URLDecoder.decode(fullPath, "UTF-8");
        //创建文件
        File rootFile = new File(fullPath);
        //判断是不是一个目录
        if (rootFile.isDirectory()) {
            //得到该目录下的所以文件
            File[] files = rootFile.listFiles();
            if (files == null) return;
            //遍历所以文件
            for (File file : files) {
                //得到文件名
                String fileName = file.getName();
                //判断该文件是不是java文件
                if (fileName.endsWith(".class")) {
                    //得到类名
                    String className = fileName.substring(0, fileName.lastIndexOf(".class"));
                    //得到类的全路径
                    String fullClassName = path + "." + className;
                    //得到类的加载器
                    Class<?> loadClass = classLoader.loadClass(fullClassName);
                    Class<? extends Annotation> legalAnnotation = null;
                    //对所有我们自己定义的合法注解进行遍历
                    for (Class<? extends Annotation> aClass : classes) {
                        //判断该类是否存在我们自定义的合法注解
                        if (loadClass.isAnnotationPresent(aClass)) {
                            legalAnnotation = aClass;
                            break;
                        }
                    }
                    if (legalAnnotation == null) return;
                    //id表示用户给bean设置的名称
                    String id = "";
                    //判断该注解是哪一个注解
                    if (legalAnnotation == MyRepository.class) {
                        //获取该注解
                        MyRepository loadClassAnnotation = loadClass.getAnnotation(MyRepository.class);
                        //获取注解的值
                        id = loadClassAnnotation.value();
                    } else if (legalAnnotation == MyService.class) {
                        MyService loadClassAnnotation = loadClass.getAnnotation(MyService.class);
                        id = loadClassAnnotation.value();
                    } else if (legalAnnotation == MyController.class) {
                        MyController loadClassAnnotation = loadClass.getAnnotation(MyController.class);
                        id = loadClassAnnotation.value();
                    } else if (legalAnnotation == MyComponent.class) {
                        MyComponent loadClassAnnotation = loadClass.getAnnotation(MyComponent.class);
                        id = loadClassAnnotation.value();
                    }
                    //如果id为空，那么就默认该类目首字母小写作为名称
                    if ("".equals(id)) {
                        id = className.substring(0, 1).toLowerCase() + className.substring(1);
                    }
                    //得到该类的实例化对象
                    Object o = Class.forName(fullClassName).newInstance();
                    //将对象放入单例对象池
                    singletonObjects.put(id, o);
                }
            }
        }
    }

提供getBean方法

我们像spring那样提供getBean方法，很简单，就是根据key返回value，下面直接上代码

    public Object getBean(String name){
        return singletonObjects.get(name);
    }

    public <T>T getBean(String name,Class<T> aclass){
        return (T)singletonObjects.get(name);
    }

提供一个getAllObjectName的方法

为了方便测试，我们提供一个显示所有bean名称的方法

    public String[] getAllObjectName(){
        //存放所有对象的名称
        String[] names = new String[singletonObjects.size()];
        //设置当前索引
        int index = 0;
        //获取所有的名称
        ConcurrentHashMap.KeySetView<String, Object> keySet = singletonObjects.keySet();
        for (String s : keySet) {
            //将名称加入到数组中
            names[index++] = s;
        }
        //返回所有对象名称
        return names;
    }

测试

创建一个use包，里面创建4个类，分别是UserDao，UserService，UserController，UserComponent，每个类加上相应的注解。如下

UserDao

package com.ttpfx.mySpring.use;

import com.ttpfx.mySpring.myAnnotation.MyRepository;

@MyRepository
public class UserDao {
}

UserService

package com.ttpfx.mySpring.use;

import com.ttpfx.mySpring.myAnnotation.MyService;

@MyService
public class UserService {
}

UserController

package com.ttpfx.mySpring.use;

import com.ttpfx.mySpring.myAnnotation.MyController;

@MyController
public class UserController {
}

UserComponent

package com.ttpfx.mySpring.use;

import com.ttpfx.mySpring.myAnnotation.MyController;

@MyController
public class UserController {
}

这时我们的项目结构如下

[spring学习]7、手写spring注解扫描机制

在MySpringConfig中配置包扫描路径，如下

package com.ttpfx.mySpring.config;

import com.ttpfx.mySpring.myAnnotation.MyComponentScan;

@MyComponentScan(path = "com.ttpfx.mySpring.use")
public class MySpringConfig {
}

创建一个测试包，然后里面创建一个测试类，然后创建我们自己的spring容器

package com.ttpfx.mySpring.test;

import com.ttpfx.mySpring.config.MySpringConfig;
import com.ttpfx.mySpring.spring.MySpringApplicationContext;

public class MySpringTest {

    public static void main(String[] args) throws Exception {
        MySpringApplicationContext ioc = new MySpringApplicationContext(MySpringConfig.class);
    }
}

获取所有bean对象名称

通过前面我们编写的方法获取全部bean的名称，看是否成功将我们的对象装入到容器中

    public static void main(String[] args) throws Exception {
        MySpringApplicationContext ioc = new MySpringApplicationContext(MySpringConfig.class);
        String[] names = ioc.getAllObjectName();
        for (String name : names) {
            System.out.println(name);
        }
    }

输入如下

[spring学习]7、手写spring注解扫描机制

由于我们没有设置bean的名称，所以默认首字母小写作为bean的名称，下面我们将每个bean的名称都设置为my+类名，输出如下

[spring学习]7、手写spring注解扫描机制

可以发现，我们编写的MySpring容器没有问题

测试getBean方法

我们上面测试了获取所有bean名称的方法，现在测试获取bean的方法，由于我们的bean名称都设置为了my+类名的形式，所以我们就按照设置的来获取名称，代码如下

    public static void main(String[] args) throws Exception {
        MySpringApplicationContext ioc = new MySpringApplicationContext(MySpringConfig.class);
        UserDao userDao = ioc.getBean("myUserDao", UserDao.class);
        UserService myUserService = ioc.getBean("myUserService", UserService.class);
        System.out.println("userDao："+userDao);
        System.out.println("userService："+myUserService);

    }

控制台输出如下

[spring学习]7、手写spring注解扫描机制

可以发现，我们的getBean也没有问题，到此，我们的MySpring就测试完毕了

总结

在这篇文章中，我们自己手动实现了spring基于包扫描创建bean的机制，虽然不是很完善，但是核心功能都已经实现了，相信在自己手动实现之后，对spring又有了更深的认识。这里只是简单实现了下，在后面介绍完AOP之后，将会手动实现一个相对完善的spring，解开spring的神秘面纱，深入理解spring

活动

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

[spring学习]7、手写spring注解扫描机制

[spring学习]7、手写spring注解扫描机制

前言

总体设计思路

具体功能实现

实现自定义注解

实现配置类

实现MySpring容器

提供getBean方法

提供一个getAllObjectName的方法

测试

获取所有bean对象名称

测试getBean方法

总结

相关文章

Spring第八发—自动装配及让Spring自动扫描和管理Bean

Spring中基于Java的配置@Configuration和@Bean用法

spring boot 自定义过滤器链

Spring第五弹—–配置Spring管理的bean的作用域和生命周期

Spring第四弹—–Spring的三种实例化bean的方式

最新版Spring Security入门

详解Spring IOC

吃透 Spring IoC

spring JPA整合hibernate，IDEA社区版，Java

seata-spring-boot-starter 启动配置

作者介绍

最新文章

spring boot 自定义过滤器链

Failed to start bean ‘eurekaAutoServiceRegistration‘

class java.time.LocalDateTime cannot be cast to class java.util.Date

springboot启动失败的问题（'hibernate.dialect' not set）

服务注册与发现

Maven 再学习之 bom 与 parent pom

热门文章

axios&spring前后端分离传参规范总结

Bean的作用域

Content type ‘application/x-www-form-urlencoded；charset=UTF-8‘ not supported错误的多种解决方法及说明Content-Type

[手写spring](5)实现AOP机制（完结）

[spring学习]10、AOP思想提出

springboot启动失败的问题（'hibernate.dialect' not set）

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

Maven的生命周期与插件

认识spring

每次创建Maven工程总是自动使用替他版本JDK15导致项目到处爆红问题

springboot中AutowiredAnnotationBeanPostProcessor在哪冒出来的

先导引入spring

spring的DI/IOC机制