AI专业者开发社区 1 号成员
  •  0 回帖  •  4 浏览  •  5 个月前
   

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) {

    <span class="hljs-type">B</span> <span class="hljs-variable">b</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">B</span>();
    <span class="hljs-type">SpringBootApplication</span> <span class="hljs-variable">annotation</span> <span class="hljs-operator">=</span> b.getClass().getAnnotation(SpringBootApplication.class);
    String[] excludeNames = annotation.excludeName();
    System.out.println(<span class="hljs-string">"excludeNames"</span> + Arrays.toString(excludeNames));
    String[] basePackages = annotation.scanBasePackages();
    System.out.println(<span class="hljs-string">"basePackages"</span> + Arrays.toString(basePackages));

}

<span class="hljs-meta">@SpringBootApplication(excludeName = {"class1"}, scanBasePackages = {"com"})</span>
<span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">class</span> <span class="hljs-title class_">A</span> {

}

<span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">class</span> <span class="hljs-title class_">B</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_">A</span> {
}

上面的 @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 {

<span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">main</span><span class="hljs-params">(String[] args)</span> {
    Class&lt;Demo&gt; demoClass = Demo.class;
    <span class="hljs-type">String</span> <span class="hljs-variable">name</span> <span class="hljs-operator">=</span> demoClass.getPackage().getName();
    List&lt;Class&lt;?&gt;&gt; classes = getClasses(name);
    <span class="hljs-keyword">for</span> (Class&lt;?&gt; aClass : classes) {
        <span class="hljs-type">Description</span> <span class="hljs-variable">annotation</span> <span class="hljs-operator">=</span> aClass.getAnnotation(Description.class);
        <span class="hljs-keyword">if</span>(annotation!=<span class="hljs-literal">null</span>){
            System.out.println(annotation.author()+<span class="hljs-string">":"</span>+annotation.desc());
        }
    }
    System.out.println(<span class="hljs-string">"end..."</span>);

}


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

    <span class="hljs-keyword">return</span> classes;
}

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

参考#

公众号推荐#

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