## 注解的基础知识
- 元注解：@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 注解。
```java
@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) ///包
```
**3.@Document**
说明该注解将被包含在javadoc中
**4.@Inherited**
说明子类可以继承父类中的该注解。如果一个注解@XX被元注解@Inherited修饰，然后使用@XX修饰了一个类A，那么类A的子类B也可以继承@XX注解。
## 自定义注解
```java
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Description {
String[] name();
String desc();
String author() default "JTZeng";
int age() default 21;
}
```
想要处理这些注解信息，我们必须使用反射技术获取这些注解然后再做相应的处理。
下面举个列子：使用反射获取当前包下面所有标注了`Description`的类信息。
```java
@Description(desc = "Java lover", author = "csx")
public class CSX {
}
@Description(desc = "PHP lover", author = "zr")
public class ZR {
}
```
上面定义了两个类，分别用`Description`标注。
下面的代码首先获取了当前类所在的包名，然后将这个包下面的Class遍历了一遍。通过反射将标注有`Description`注解的类信息打印了出来。
```java
public class Demo {
public static void main(String[] args) {
Class demoClass = Demo.class;
String name = demoClass.getPackage().getName();
List> 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> getClasses(String packageName){
//第一个class类的集合
List> classes = new ArrayList>();
//是否循环迭代
boolean recursive = true;
//获取包的名字 并进行替换
String packageDirName = packageName.replace('.', '/');
//定义一个枚举的集合 并进行循环来处理这个目录下的things
Enumeration 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 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> 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 以前，同一个程序元素前最多只能有一个相同类型的注解；如果需要在同一个元素前使用多个相同类型的注解，则必须使用注解“容器”。
```java
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 新增了重复注解，其使用方式为：
```java
//这边还是需要定义注解容器
@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中的语法糖](https://www.cnblogs.com/54chensongxia/p/11665843.html)）
## 参考
- https://www.cnblogs.com/a591378955/p/8350499.html
- https://blog.csdn.net/liupeifeng3514/articlehttps://img.qb5200.com/download-x/details/80722003
