Spring @Component自定义注解实现详解-Java开发

@Component是一个元注解，意思是可以注解其他类注解，如@Controller@Service@Repository@Aspect。官方的原话是：带此注解的类看为组件，当使用基于注解的配置和类路径扫描的时候，这些类就会被实例化

引子

Java里的注解

注解是什么

注解是Java SE5中引入的总要特性，注解的出现使得我们能够以将有编译器来测试和验证的格式，存储有关程序的额外信息.

元注解

Java 中的元注解主要有以下四个

@Target 用来定义你的注解将应用于什么地方，例如类，方法，字段
@Retention用来定义该注解在哪个级别可用 Source,Class Runtime.
@Document将此注解包含在Javadoc中
@Inherited 允许子类继承父类中的注解

注解的保存策略

上面提到@Retention注解的取值有Source，Class，Runtime这三个，这三个值的意思如下

Source注解只保留在源码中，被编译器丢弃，实际开发中几乎没有用到
Class 注解保留在Class文件中，但不在运行时由虚拟机保留
Runtime注解保留在Class文件中，并且在运行时由虚拟机保留，我们知道反射是运行时动态修改类信息的技术，如果我们自定义的注解保存策略声明为Runtime，那么我们就能通过反射在运行时动态获取注解，然后通过注解处理器来实现对应的逻辑。

自定义注解

有了Java中提供的元注解，我们就可以依赖元注解来编写自定义注解了，我们只需要指定两个关键信息：注解在哪个级别可用，以及注解作用的位置就可以了，即给我们的注解打上@Target和@Retention注解。我们来看一个例子，下面的代码声明了一个定义注解MyAnnotion

package com.nightcat.annotaion;
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 MyAnnotation {
}

可以看到@Target制定了我们自定义的注解可以使用在类上，@Rentention中的保存策略指定了我们的注解将在运行期保留（这很重要）。

注解元素

首先我们为自定义注解添加一些属性:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String title() default "";
    int type() default 0;
}

我们向自定义注解中添加了一个String类型的title属性和一个int类型的type属性。

那么自定义注解中可以使用的元素类型有哪些呢？

所有基本类型
String
Class
enum
Annotation
以上所有类型的数组

注解处理器

我们定义好了注解，它能做些什么？这就必须提到注解处理器，因为如果没有用来处理注解的工具，那注解也不会有什么用处，那么什么是注解处理器呢？其实就是由我们自己编写的处理自定义注解的程序。下面我们就来编写一个注解处理器，用来处理我们的自定义注解。

由于我们的注解保存策略指定为Runtime，那么我们就能通过反射技术来获取注解。我们先来看一段代码

package com.nightcat.bean;
import com.nightcat.annotaion.MyAnnotation;
@MyAnnotation(title = "《好好学习》", type = 1)
public class Article {
}

我们声明了一个Article类，并且给它打上了我们自定义的注解，下面我们通过自定义的注解处理器来获取注解中属性的值。

package com.nightcat.test;
import com.nightcat.annotaion.MyAnnotation;
import com.nightcat.bean.Article;
public class AnnotationTest {
    public static void main(String[] args) {
        Class<Article> articleClass = Article.class;
        MyAnnotation annotation = articleClass.getAnnotation(MyAnnotation.class);
        System.out.println("annotation.title() = " + annotation.title()); //《好好学习》
        System.out.println("annotation.type() = " + annotation.type());// 1
    }
}

你会发现，我们用了反射技术获取到了定义注解的属性值，这就是自定义注解的使用方法：

将保存策略声明为Runtime.
通过反射获取注解信息，执行对应的业务逻辑.

注解是什么

学习了上面的知识，我们对注解有了一个基本认识，那么注解究竟是什么呢？

其实注解就是继承了Annotion接口的一个接口而已，拿我们自定义的MyAnnotation举例子：

我们先来看一下MyAnnotation.class文件

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.nightcat.annotaion;
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 MyAnnotation {
    String title() default "";
    int type() default 0;
}

这是IDEA替我们处理好的，接着我们用javap -c命令反编译一下看看

通过反编译我们发现注解其实就是一个接口。

自己写一个@Component注解

准备工作

有了上面的基础我们终于要开始写自己的@Component注解了。我们知道SpringFramework中常用的注解有 @Component @Controller @Service @Bean @Repository 等等，这些注解有一个基础的功能，将注解标记的类加到Spring容器中，交给Spring管理。那么这就涉及到两个问题：

扫描指定路径下被这些注解标记的类
把这些类加入到IOC容器中

好了，接下来我们就开始写代码了

代码实现

准备@MyComponent注解

package com.nightcat.annotaion;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyComponent {
}

你会发现我们的这个注解的保存策略是Runtime，原因不再赘述。

准备一个自定义类

package com.nightcat.bean;
import com.nightcat.annotaion.MyComponent;
@MyComponent
public class Student {
    private Integer age;
    private String stuName;
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", stuName='" + stuName + '\'' +
                '}';
    }
}

注意这个类上打上了我们自定义的@MyComponent注解，方便检测哪些类需要加入到ioc容器，哪些不需要。

准备一个简易的ApplicationContext

我们在使用ioc容器时，主要使用的是ClassPathXmlApplicationContext或者AnnotationConfigApplicationContext，通过这两个类的构造得到ioc容器,然后通过getBean方法获取指定的bean，这个过程涉及到BeanFactory，需要判断以下内容

Bean的scope是单例的还是多例的
是不是IOC容器中已经有这个Bean了

等等。

我们这里不这么麻烦，直接通过一个线程安全的HashMap来模拟oc容器

主要实现思路如下

用ConcurrentHashMap来模拟容器
扫描传入的包路径及其子路径
如果该路径下存在我们自定义注解@MyComponent标记的类，就获取该类的全类名，然后通过反射创建对象，并将其放入我们自定义的ioc容器中
测试我们自定义的注解是否起作用

实现代码

package com.nightcat;
import com.nightcat.annotaion.MyComponent;
import java.io.File;
import java.net.URL;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Logger;
public class ApplicationContext {
    private Logger logger = Logger.getLogger(ApplicationContext.class.toString());
    private Map<String, Object> ioc = new ConcurrentHashMap();
    public Object getBean(String beanName) {
        return ioc.get(beanName);
    }
    public ApplicationContext(String packagePath) {
        scanPackagePath(packagePath);
    }
    private void scanPackagePath(String packagePath) {
        File file = getFile(packagePath);
        File[] allFile = getAllFile(packagePath, file);
        handleClassFile(packagePath, allFile);
    }
    private void handleClassFile(String packagePath, File[] allClassFile) {
        for (File file : allClassFile) {
            String classFileName = file.getName();
            String fileName = classFileName.substring(0, classFileName.lastIndexOf("."));
            String beanName = String.valueOf(fileName.charAt(0)).toLowerCase() + fileName.substring(1);
            String fullClassName = packagePath + "." + fileName;
            try {
                Class<?> aClass = Class.forName(fullClassName);
                if (aClass.isAnnotationPresent(MyComponent.class)) {
                    Object o = aClass.newInstance();
                    ioc.put(beanName, o);
                }
            } catch (Exception e) {
                logger.warning("实例化异常");
            }
        }
    }
    private File[] getAllFile(String packagePath, File file) {
        File[] files = file.listFiles(file1 -> {
            if (file1.isDirectory()) {
                scanPackagePath(packagePath + "." + file1.getName());
            } else {
                String name = file1.getName();
                if (name.endsWith(".class")) return true;
                else return false;
            }
            return false;
        });
        return files;
    }
    private File getFile(String packagePath) {
        String dirPath = packagePath.replaceAll("\\.", "/");
        URL url = this.getClass().getClassLoader().getResource(dirPath);
        String fileName = url.getFile();
        return new File(fileName);
    }
}

通过上面的代码，我们会发现，我们传入的basePackage也就是包名，是以点号分割的，而我们磁盘上的文件是以斜线分割的，所以我们要将点号替换成斜线

再接着我们获取packagePath对应的url资源，通过它获取文件的全路径名，有些小伙伴可能会说，哪里用这么麻烦，我直接用packagePath new File(String path)的形式创建文件不行么，干嘛用url啊，这是因为你传入的类似com.nightcat这种包名，你去直接newFile ,是不是发现少了一些东西?没错，就是你的磁盘路径，发现了么，而Java提供的Url类可以解决这个问题。

剩下的工作就简单了，我们去扫描传入的包路径和自路径，并且检测类上是否有我们自定义的注解，如果有，我们就用创建对象，同时将类名首字母小写，作为ConcurrentHashMap的key，创建的对象作为Value就可以了。

有些小伙伴可能会问，你这个Bean无法保证单例呀，也很简单，你写代码的时候判断一下容器里有没有，有了就不添加了。至于其他的知识，不在这篇文章的范畴，可以自行研究。

测试自定义注解和容器

package com.nightcat.test;
import com.nightcat.ApplicationContext;
import com.nightcat.bean.Student;
public class CodeTest {
    public static void main(String[] args) {
        ApplicationContext context = new ApplicationContext("com.nightcat");
        Student student = (Student) context.getBean("student");
        System.out.println(student);
    }
}