Java 中的注解

注解的基础知识

元注解：@Retention @Target @Document @Inherited
Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口。
参数成员只能用public或默认(default)这两个访问权修饰
参数成员只能用基本类型byte，short，char，int，long，float，double，boolean八种基本数据类型和String、Enum、Class、annotations等数据类型，以及这一些类型的数组。
要获取类、方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation对象,除此之外没有别的获取注解对象的方法
注解也可以没有定义成员, 不过这样注解就没啥用了，只起到标识作用

JDK的元注解

JDK提供了4种元注解，分别是@Retention、@Target、@Document和@Inherited四种。这4个注解是用来修饰我们自定义的其他注解的，因此称为元注解。

1. @Retention

定义注解的保留策略。首先要明确生命周期长度 SOURCE < CLASS < RUNTIME ，所以前者能作用的地方后者一定也能作用。一般如果需要在运行时去动态获取注解信息，那只能用 RUNTIME 注解；如果要在编译时进行一些预处理操作，比如生成一些辅助代码（如 ButterKnife），就用 CLASS注解；如果只是做一些检查性的操作，比如
@Override 和@SuppressWarnings，则可选用 SOURCE 注解。

@Retention(RetentionPolicy.SOURCE)   //注解仅存在于源码中，在class字节码文件中不包含
@Retention(RetentionPolicy.CLASS)     // 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，
@Retention(RetentionPolicy.RUNTIME)  // 注解会在class字节码文件中存在，在运行时可以通过反射获取到

2. @Target
定义注解的作用目标。也就是这个注解能加在类的哪些元素上。

@Target(ElementType.TYPE)   //接口、类、枚举、注解
@Target(ElementType.FIELD) //字段、枚举的常量
@Target(ElementType.METHOD) //方法
@Target(ElementType.PARAMETER) //方法参数
@Target(ElementType.CONSTRUCTOR)  //构造函数
@Target(ElementType.LOCAL_VARIABLE)//局部变量
@Target(ElementType.ANNOTATION_TYPE)//注解
@Target(ElementType.PACKAGE) //包    

// Java8 中新加了下面两种
`TYPE_PARAMETER`
`TYPE_USE`

3.@Document
说明该注解将被包含在javadoc中

4.@Inherited

说明子类可以继承父类中的该注解。如果一个注解@XX被元注解@Inherited修饰，然后使用@XX修饰了一个类A，那么类A的子类B也可以继承@XX注解。

关于 @Inherited 注解，我举个列子多说两句。

public static void main(String[] args) {

        B b = new B();
        SpringBootApplication annotation = b.getClass().getAnnotation(SpringBootApplication.class);
        String[] excludeNames = annotation.excludeName();
        System.out.println("excludeNames" + Arrays.toString(excludeNames));
        String[] basePackages = annotation.scanBasePackages();
        System.out.println("basePackages" + Arrays.toString(basePackages));

    }

    @SpringBootApplication(excludeName = {"class1"}, scanBasePackages = {"com"})
    public static class A {

    }

    public static class B extends A {
    }

上面的 @SpringBootApplication 注解是用 @Inherited 标注的，所以子类 B 可以继承这个注解，上面的 main 方法会输出：

excludeNames[class1]
basePackages[com]

但是一旦，子类B也标注 @SpringBootApplication 注解的话，就不再继承父类的 @SpringBootApplication。

@SpringBootApplication(excludeName = {"class2"})
public static class B extends A {}

输出：

excludeNames[class2]
basePackages[]

自定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Description {
    String[] name();
    String desc();
    String author() default "JTZeng";
    int age() default 21;
}

想要处理这些注解信息，我们必须使用反射技术获取这些注解然后再做相应的处理。

下面举个列子：使用反射获取当前包下面所有标注了Description的类信息。

@Description(desc = "Java lover", author = "csx")
public class CSX {
}

@Description(desc = "PHP lover", author = "zr")
public class ZR {
}

上面定义了两个类，分别用Description标注。

下面的代码首先获取了当前类所在的包名，然后将这个包下面的Class遍历了一遍。通过反射将标注有Description注解的类信息打印了出来。

public class Demo {

    public static void main(String[] args) {
        Class<Demo> demoClass = Demo.class;
        String name = demoClass.getPackage().getName();
        List<Class<?>> classes = getClasses(name);
        for (Class<?> aClass : classes) {
            Description annotation = aClass.getAnnotation(Description.class);
            if(annotation!=null){
                System.out.println(annotation.author()+":"+annotation.desc());
            }
        }
        System.out.println("end...");

    }


    public static List<Class<?>> getClasses(String packageName){
        //第一个class类的集合
        List<Class<?>> classes = new ArrayList<Class<?>>();
        //是否循环迭代
        boolean recursive = true;
        //获取包的名字 并进行替换
        String packageDirName = packageName.replace('.', '/');
        //定义一个枚举的集合 并进行循环来处理这个目录下的things
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            //循环迭代下去
            while (dirs.hasMoreElements()){
                //获取下一个元素
                URL url = dirs.nextElement();
                //得到协议的名称
                String protocol = url.getProtocol();
                //如果是以文件的形式保存在服务器上
                if ("file".equals(protocol)) {
                    //获取包的物理路径
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    //以文件的方式扫描整个包下的文件 并添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                } else if ("jar".equals(protocol)){
                    //如果是jar包文件
                    //定义一个JarFile
                    JarFile jar;
                    try {
                        //获取jar
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        //从此jar包 得到一个枚举类
                        Enumeration<JarEntry> entries = jar.entries();
                        //同样的进行循环迭代
                        while (entries.hasMoreElements()) {
                            //获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            //如果是以/开头的
                            if (name.charAt(0) == '/') {
                                //获取后面的字符串
                                name = name.substring(1);
                            }
                            //如果前半部分和定义的包名相同
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                //如果以"/"结尾 是一个包
                                if (idx != -1) {
                                    //获取包名 把"/"替换成"."
                                    packageName = name.substring(0, idx).replace('/', '.');
                                }
                                //如果可以迭代下去 并且是一个包
                                if ((idx != -1) || recursive){
                                    //如果是一个.class文件 而且不是目录
                                    if (name.endsWith(".class") && !entry.isDirectory()) {
                                        //去掉后面的".class" 获取真正的类名
                                        String className = name.substring(packageName.length() + 1, name.length() - 6);
                                        try {
                                            //添加到classes
                                            classes.add(Class.forName(packageName + '.' + className));
                                        } catch (ClassNotFoundException e) {
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return classes;
    }

    public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, List<Class<?>> classes){
        //获取此包的目录 建立一个File
        File dir = new File(packagePath);
        //如果不存在或者 也不是目录就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }
        //如果存在 就获取包下的所有文件 包括目录
        File[] dirfiles = dir.listFiles(new FileFilter() {
            //自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
            public boolean accept(File file) {
                return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
            }
        });
        //循环所有文件
        for (File file : dirfiles) {
            //如果是目录 则继续扫描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "." + file.getName(),
                        file.getAbsolutePath(),
                        recursive,
                        classes);
            }
            else {
                //如果是java类文件 去掉后面的.class 只留下类名
                String className = file.getName().substring(0, file.getName().length() - 6);
                try {
                    //添加到集合中去
                    classes.add(Class.forName(packageName + '.' + className));
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

输出如下：

csx:Java lover
zr:PHP lover
end...

JDK8可重复注解

重复注解：即允许在同一申明类型（类，属性，或方法）前多次使用同一个类型注解。

在java8 以前，同一个程序元素前最多只能有一个相同类型的注解；如果需要在同一个元素前使用多个相同类型的注解，则必须使用注解“容器”。

public @interface Authority {
     String role();
}

public @interface Authorities {   //@Authorities注解作为可以存储多个@Authority注解的容器
    Authority[] value();
}

public class RepeatAnnotationUseOldVersion {
    @Authorities({@Authority(role="Admin"), @Authority(role="Manager")})
    public void doSomeThing(){
    }
}

java8 新增了重复注解，其使用方式为：

//这边还是需要定义注解容器
@Repeatable(Authorities.class)
public @interface Authority {
     String role();
}

public @interface Authorities {
    Authority[] value();
}

public class RepeatAnnotationUseNewVersion {
    @Authority(role="Admin")
    @Authority(role="Manager")
    public void doSomeThing(){ }
}

不同的地方是，创建重复注解 Authority 时，加上@Repeatable，指向存储注解 Authorities，在使用时候，直接可以重复使用 Authority 注解。从上面例子看出，java 8里面做法更适合常规的思维，可读性强一点。但是，仍然需要定义容器注解。

两种方法获得的效果相同。重复注解只是一种简化写法，这种简化写法是一种假象：多个重复注解其实会被作为“容器”注解的 value 成员的数组元素处理。（一种语法糖而已，Java中类似的语法还有很多。具体内容可以参考博客Java中的语法糖）

参考

公众号推荐

欢迎大家关注我的微信公众号「程序员自由之路」

posted @ 2020-03-13 11:16 程序员自由之路阅读(1012) 评论(0) 编辑收藏举报

刷新页面返回顶部

Loading

程序员自由之路