Spring @Component自定义注解实现详解

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