注解的基礎知識
-
元注解：@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中的語法糖）
參考
- https://www.cnblogs.com/a591378955/p/8350499.html
- https://blog.csdn.net/liupeifeng3514/article/details/80722003
公眾號推薦
歡迎大家關注我的微信公眾號「程序員自由之路」
