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

目录

• 引子
• Java里的注解
• 注解是什么
• 元注解
• 注解的保存策略
• 自定义注解
• 注解元素
• 注解处理器
• 注解是什么
• 自己写一个@Component注解
• 准备工作
• 代码实现
• 准备@MyComponent注解
• 准备一个自定义类
• 准备一个简易的ApplicationContext
• 实现代码
• 测试自定义注解和容器

引子

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

通过测试，发现我们自定义的@MyComponet注解生效了。

到此这篇关于Spring @Component自定义注解实现详解的文章就介绍到这了,更多相关Spring @Component内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！