Java註解之自定義
本文將從如下幾點爲你介紹java註解以及如何自定義java
- 引言
- 註解定義
- 註解意義
- 註解分類
- 自定義
- 結束語
引言
Java註解在平常開發中常常遇到，但一般咱們只是用它，難道你不會好奇註解是怎麼實現的嗎？爲何@Data的註解能夠生成getter和setter呢？爲何@BindView能夠作到不須要findViewById呢？爲何retrofit2只要寫個接口就能夠作網絡請求呢？本文將爲你一一解答其中的奧妙。另外註解依賴於反射，我相信絕大多數的Java開發者都寫過反射，也都知道反射是咋回事，因此若是你還不理解反射，請先花幾分鐘熟悉後再閱讀本文。git
註解定義
Annotation也叫元數據，是代碼層面的說明。它在JDK1.5之後被引入，與類、接口、枚舉是在同一個層次。它能夠聲明在包、類、字段、方法、局部變量、方法參數等的前面，用來對這些元素進行說明，註釋。咱們能夠簡單的理解註解只是一種語法標註，它是一種約束、標記。程序員
註解意義
在JDK1.5之前，描述元數據都是使用xml的，可是xml老是表現出鬆散的關聯度，致使文件過多時難以維護，好比Spring早期的注入xml。所以Java1.5引入註解最大的緣由就是想把元數據與代碼強關聯，好比Spring 2.0大多轉爲註解注入。 雖然註解作到了強關聯，可是一些常量參數使用xml會顯結構更加清晰，因此在平常使用時，老是會把xml和Annotation結合起來使用以達到最優使用。github
註解分類
一般咱們會按照註解的運行機制將其分類，可是在按照註解的運行機制分類以前，咱們先按基本分類來看一遍註解。bash
基本分類
- 內置註解（基本註解） 內置註解只有三個，位於java.lang包下，他們分別是
- @Override - 檢查該方法是不是重載方法，若是發現其父類，或者是引用的接口中並無該方法時，會報編譯錯誤。
- @Deprecated - 標記過期方法，若是使用該方法，會報編譯警告。
- @SuppressWarnings - 指示編譯器去忽略註解中聲明的警告。
- 元註解 元註解只有四個，位於java.lang.annotation包中
- @Retention - 標識這個註解怎麼保存，是隻在代碼中，仍是編入class文件中，或者是在運行時能夠經過反射訪問
- @Documented - 標記這些註解是否包含在用戶文檔中
- @Target - 標記這個註解應該是哪一種 Java 成員
- ElementType.CONSTRUCTOR 構造方法聲明
- ElementType.FIELD 字段聲明
- ElementType.LOCAL_VARIABLE 局部變量聲明
- ElementType.METHOD 方法聲明
- ElementType.PACKAGE 包聲明
- ElementType.PARAMETER 參數聲明
- ElementType.TYPE 類、接口方法
- @Inherited - 標記註解可繼承
- 自定義註解 能夠經過元註解來自定義
運行機制分類
主要是按照元註解中的@Retention參數將其分爲三類網絡
- 源碼註解(@Retention(RetentionPolicy.SOURCE)) 註解只在源碼中存在，編譯時丟棄，編譯成.class文件就不存在了
- 編譯時註解(@Retention(RetentionPolicy.CLASS)) 編譯時會記錄到.class中，運行時忽略
- 運行時註解(@Retention(RetentionPolicy.RUNTIME)) 運行時存在起做用，影響運行邏輯，能夠經過反射讀取
咱們能夠簡單的把Java程序從源文件建立到程序運行的過程看做爲兩大步驟app
- 源文件由編譯器編譯成字節碼
- 字節碼由java虛擬機解釋運行
那麼被標記爲RetentionPolicy.SOURCE的註解只能保留在源碼級別，即最多隻能在源碼中對其操做，被標記爲RetentionPolicy.CLASS的被保留到字節碼，因此最多隻到字節碼級別操做，那麼對應的RetentionPolicy.RUNTIME能夠在運行時操做。框架
自定義
前面的都是司空見慣的知識點，可能你們都知道或有有了解過，可是一說到自定義，估計夠嗆，那麼下面就按運行機制的分類，每一類都自定義一個註解看下註解究竟是怎麼回事。ide
RetentionPolicy.RUNTIME
運行時註解一般須要先經過類的實例反射拿到類的屬性、方法等，而後再遍歷屬性、方法獲取位於其上方的註解，而後就能夠作相應的操做了。 好比如今有一個Person的接口以及其實現類Student。工具
public interface Person {
@PrintContent("來自注解 PrintContent 唱歌")
void sing(String value);
@PrintContent("來自注解 PrintContent 跑步")
void run(String value);
@PrintContent("來自注解 PrintContent 吃飯")
void eat(String value);
@PrintContent("來自注解 PrintContent 工做")
void work(String value);
}
複製代碼
實現類
public class Student implements Person {
@Override
public void sing(String value) {
System.out.println(value == null ? "這是音樂課，咱們在唱歌" : value);
}
@Override
public void run(String value) {
System.out.println(value == null ? "這是體育課，咱們在跑步" : value);
}
@Override
public void eat(String value) {
System.out.println(value == null ? "中午咱們在食堂吃飯" : value);
}
@Override
public void work(String value) {
System.out.println(value == null ? "咱們的工做是學習" : value);
}
}
複製代碼
執行邏輯
@Autowired
private Person person;
public void student() {
person.eat(null);
person.run(null);
person.sing(null);
person.work(null);
}
複製代碼
咱們須要實現的點
- 自定義屬性註解@Autowired表示自動注入Student對象給person。
- 提供方法註解@PrintContent表示當value爲null時打印的默認值，並在調用的方法先後插入本身想作的操做。
由於這是一個運行時的註解，因此咱們須要反射先拿到這個註解，而後再對其進行操做。 Autowired的實現，能夠看到很是簡單，僅僅是先拿到類的全部屬性，而後對其遍歷，發現屬性使用了Autowired註解而且是Person類型，那麼就new一個Student爲其賦值，這樣就作到了自動注入的效果。
private static void inject(Object obj) {
Field[] declaredFields = obj.getClass().getDeclaredFields();
for (Field field : declaredFields) {
if (field.getType() == Person.class) {
if (field.isAnnotationPresent(Autowired.class)) {
field.setAccessible(true);
try {
Person student = new Student();
field.set(obj, student);
} catch (IllegalAccessException e) {
e.printStackTrace();
}}}
}}
複製代碼
若是是想當value爲null時打印的註解的默認值，並在調用的方法先後插入本身想作的操做。這種對接口方法進行攔截並操做的稱爲動態代理，java提供Proxy.newProxyInstance支持。
private static void inject(Object obj) {
Field[] declaredFields = obj.getClass().getDeclaredFields();
for (Field field : declaredFields) {
if (field.getType() == Person.class) {
if (field.isAnnotationPresent(Autowired.class)) {
field.setAccessible(true);
try {
Person student = new Student();
Class<?> cls = student.getClass();
Person person = (Person) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), new DynamicSubject(student));
field.set(obj, person);
} catch (IllegalAccessException e) {
e.printStackTrace();
}}}
}}
複製代碼
其中須要自定義DynamicSubject，即對方法的真實攔截操做。這樣就會把@PrintContent註解的值做爲參數打印處理。
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.isAnnotationPresent(PrintContent.class)) {
PrintContent printContent = method.getAnnotation(PrintContent.class);
System.out.println(String.format("----- 調用 %s 以前 -----", method.getName()));
method.invoke(object, printContent.value());
System.out.println(String.format("----- 調用 %s 以後 -----\n", method.getName()));
return proxy;
}
return null;
}
複製代碼
最後附上兩個自定義的註解
@Target({ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
}
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PrintContent {
String value();
}
複製代碼
以上能夠幫助你對retorfit2的理解，由於動態代理就是它的核心之一。若是你想學習更多，能夠參考仿retorfit2設計實現的Activity參數注入
RetentionPolicy.SOURCE
你們或許對@BindView生成代碼有所懷疑，對@Data如何生成代碼有所好奇，那麼咱們就自定義個@Data來看看怎麼註解是怎麼生成代碼的。本文依賴於idea工具，並不是google提供的@AutoService實現。 bean是開發中常常被使用的，getter、setter方法是被咱們所厭棄寫的，idea幫咱們作了一鍵生成的插件工具，可是若是這一步都都不想操做呢？我只想用一個註解生成，好比下面的User類。
@Data
public class User {
private Integer age;
private Boolean sex;
private String address;
private String name;
}
複製代碼
經過@Data就能夠生成這樣的類，是否是很神奇？
public class User{
private Integer age;
private Boolean sex;
private String address;
private String name;
public User() {
}
public Integer getAge() {
return this.age;
}
public void setAge(Integer age) {
this.age = age;
}
public Boolean hasSex() {
return this.sex;
}
public void isSex(Boolean sex) {
this.sex = sex;
}
public String getAddress() {
return this.address;
}
public void setAddress(String address) {
this.address = address;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}
複製代碼
要實現這樣的神奇操做，大概的思路是先自定義某個RetentionPolicy.SOURCE級別的註解，而後實現一個註解處理器並設置SupportedAnnotationTypes爲當前的註解，最後在META-INF註冊該註解處理器。因此首先咱們定義Data註解。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
@Documented
public @interface Data {
}
複製代碼
而後須要自定義註解處理器來處理Data註解
@SupportedAnnotationTypes("com.data.Data")
public class DataProcessor extends AbstractProcessor {
}
複製代碼
而後在resources/META-INF文件夾下新建services文件夾，若是沒有META-INF也新建。而後在services文件夾裏新建javax.annotation.processing.Processor文件，注意名字是固定的，打開文件後寫上前面定義的註解處理器全稱，好比com.data.DataProcessor，這樣就表示該註解處理器被註冊了。 待程序要執行的時候，編譯器會先讀取這裏的文件而後掃描整個工程，若是工程中有使用已註冊的註解處理器中的SupportedAnnotationTypes裏的註解，那麼就會執行對應的註解處理中的process方法。下面重點處理註解處理器AbstractProcessor，把大部分的解釋都寫在註解裏。
@SupportedAnnotationTypes("com.data.Data")
public class DataProcessor extends AbstractProcessor {
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "-----開始自動生成源代碼");
try {
// 返回被註釋的節點
Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Data.class);
for (Element e : elements) {
// 若是註釋在類上
if (e.getKind() == ElementKind.CLASS && e instanceof TypeElement) {
TypeElement element = (TypeElement) e;
// 類的全限定名
String classAllName = element.getQualifiedName().toString() + "New";
// 返回類內的全部節點
List<? extends Element> enclosedElements = element.getEnclosedElements();
// 保存字段的集合
Map<Name, TypeMirror> fieldMap = new HashMap<>();
for (Element ele : enclosedElements) {
if (ele.getKind() == ElementKind.FIELD) {
//字段的類型
TypeMirror typeMirror = ele.asType();
//字段的名稱
Name simpleName = ele.getSimpleName();
fieldMap.put(simpleName, typeMirror);
}
}
// 生成一個Java源文件
String targetClassName = classAllName;
if (classAllName.contains(".")) {
targetClassName = classAllName.substring(classAllName.lastIndexOf(".") + 1);
}
JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(targetClassName);
// 寫入代碼
createSourceFile(classAllName, fieldMap, sourceFile.openWriter());
} else {
return false;
}
}
} catch (IOException e) {
processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getMessage());
}
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "-----完成自動生成源代碼");
return true;
}
/**
* 屬性首字母大寫
*/
private String humpString(String name) {
String result = name;
if (name.length() == 1) {
result = name.toUpperCase();
}
if (name.length() > 1) {
result = name.substring(0, 1).toUpperCase() + name.substring(1);
}
return result;
}
private void createSourceFile(String className, Map<Name, TypeMirror> fieldMap, Writer writer) throws IOException {
// 檢查屬性是否以 "get", "set", "is", "has" 這樣的關鍵字開頭，若是有這樣的 屬性就報錯
String[] errorPrefixes = {"get", "set", "is", "has"};
for (Map.Entry<Name, TypeMirror> map : fieldMap.entrySet()) {
String name = map.getKey().toString();
for (String prefix : errorPrefixes) {
if (name.startsWith(prefix)) {
throw new RuntimeException("Properties do not begin with 'get'、'set'、'is'、'has' in " + name);
}
}
}
String packageName;
String targetClassName = className;
if (className.contains(".")) {
packageName = className.substring(0, className.lastIndexOf("."));
targetClassName = className.substring(className.lastIndexOf(".") + 1);
} else {
packageName = "";
}
// 生成源代碼
JavaWriter jw = new JavaWriter(writer);
jw.emitPackage(packageName);
jw.beginType(targetClassName, "class", EnumSet.of(Modifier.PUBLIC));
jw.emitEmptyLine();
for (Map.Entry<Name, TypeMirror> map : fieldMap.entrySet()) {
String name = map.getKey().toString();
String type = map.getValue().toString();
//字段
jw.emitField(type, name, EnumSet.of(Modifier.PRIVATE));
jw.emitEmptyLine();
}
for (Map.Entry<Name, TypeMirror> map : fieldMap.entrySet()) {
String name = map.getKey().toString();
String type = map.getValue().toString();
String prefixGet = "get";
String prefixSet = "set";
if (type.equals("java.lang.Boolean")) {
prefixGet = "has";
prefixSet = "is";
}
//getter
jw.beginMethod(type, prefixGet + humpString(name), EnumSet.of(Modifier.PUBLIC))
.emitStatement("return " + name)
.endMethod();
jw.emitEmptyLine();
//setter
jw.beginMethod("void", prefixSet + humpString(name), EnumSet.of(Modifier.PUBLIC), type, name)
.emitStatement("this." + name + " = " + name)
.endMethod();
jw.emitEmptyLine();
}
jw.endType().close();
}
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}
}
複製代碼
至此整個Data的註解生成器就寫完了，因爲咱們的idea沒有對應的插件幫助咱們作一些操做，因此生成的類編譯生成字節碼時會報已存在異常，因此若是你想更進一步，能夠考慮寫個插件，本文僅限註解，未提供這樣的插件。 以上完成後，只要在data class頭添加@Data註解，在編譯程序以前，就能夠看到target/classes中存在了咱們生成的代碼。至此你應該瞭解@BindView或者@Data的原理，或許你也能夠嘗試自定義一個ButterKnife框架。
RetentionPolicy.CLASS
字節碼級別的實際上對應用程序員來講沒多大做用，由於此類註解通常是在字節碼文件上進行操做，咱們通常理解整個過程是在.java編譯爲.class後在將要被加載到虛擬機以前。那麼很顯然RetentionPolicy.CLASS類別的註解是直接修改字節碼文件的。因此通常用此註解須要底層開發人員的配合，或者當你須要造輪子了能夠考慮用一下，不過須要ASM的配合來使用的，若是僅僅是開發應用基本用不到。 不過這裏仍是介紹下它的使用，先造場景：如今有個People類，其中有個size屬性等於9，觀察到上方的類註解是@Prinln(12)，如今想在字節碼層面把size的9替換爲12。
@Prinln(12)
public class People {
int size = 9;
double phone = 12.0;
Boolean sex;
String name;
}
複製代碼
因爲咱們並不知道字節碼文件是怎麼寫的，因此須要先經過Show Bytecode的插件來查看類的字節碼是啥樣子的
// class version 52.0 (52)
// access flags 0x21
public class com/People {
// compiled from: People.java
@Lcom/ann/Prinln;(value=12) // invisible
// access flags 0x0
I size
// access flags 0x2
private D phone
// access flags 0x2
private Ljava/lang/Boolean; sex
// access flags 0x2
private Ljava/lang/String; name
// access flags 0x1
public <init>()V
L0
LINENUMBER 12 L0
ALOAD 0
INVOKESPECIAL java/lang/Object.<init> ()V
L1
LINENUMBER 14 L1
ALOAD 0
BIPUSH 9
PUTFIELD com/People.size : I
L2
LINENUMBER 16 L2
ALOAD 0
LDC 12.0
PUTFIELD com/People.phone : D
RETURN
L3
LOCALVARIABLE this Lcom/People; L0 L3 0
MAXSTACK = 3
MAXLOCALS = 1
}
複製代碼
雖然知道了是這樣的，但仍是看不懂啊，咋整呢？不要緊，咱們看ASMified。ASM 是一個 Java 字節碼操控框架。它能被用來動態生成類或者加強既有類的功能。ASM 能夠直接產生二進制 class 文件，也能夠在類被加載入 Java 虛擬機以前動態改變類行爲。並且ASMified咱們是能夠看得懂的，雖然沒學過，可是很好理解。好比上面的People的ASMified就是這樣的。
public class PeopleDump implements Opcodes {
public static byte[] dump() throws Exception {
ClassWriter cw = new ClassWriter(0);
FieldVisitor fv;
MethodVisitor mv;
AnnotationVisitor av0;
cw.visit(52, ACC_PUBLIC + ACC_SUPER, "com/People", null, "java/lang/Object", null);
cw.visitSource("People.java", null);
{
av0 = cw.visitAnnotation("Lcom/ann/Prinln;", false);
av0.visit("value", new Integer(12));
av0.visitEnd();
}
{
fv = cw.visitField(0, "size", "I", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(ACC_PRIVATE, "phone", "D", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(ACC_PRIVATE, "sex", "Ljava/lang/Boolean;", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(ACC_PRIVATE, "name", "Ljava/lang/String;", null, null);
fv.visitEnd();
}
{
mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
mv.visitCode();
Label l0 = new Label();
mv.visitLabel(l0);
mv.visitLineNumber(12, l0);
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
Label l1 = new Label();
mv.visitLabel(l1);
mv.visitLineNumber(14, l1);
mv.visitVarInsn(ALOAD, 0);
mv.visitIntInsn(BIPUSH, 9);
mv.visitFieldInsn(PUTFIELD, "com/People", "size", "I");
Label l2 = new Label();
mv.visitLabel(l2);
mv.visitLineNumber(16, l2);
mv.visitVarInsn(ALOAD, 0);
mv.visitLdcInsn(new Double("12.0"));
mv.visitFieldInsn(PUTFIELD, "com/People", "phone", "D");
mv.visitInsn(RETURN);
Label l3 = new Label();
mv.visitLabel(l3);
mv.visitLocalVariable("this", "Lcom/People;", null, l0, l3, 0);
mv.visitMaxs(3, 1);
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
}
複製代碼
這樣的話，咱們大概能夠知道若是要改size=12，就只要把mv.visitIntInsn(BIPUSH, 9);這句話的9改成12就行了。不過ASM在原有的字節碼文件中插入或刪除或更改，本文未仔細研究。本文是簡單粗暴的用新的字節碼替換原字節碼文件。
public void asm() {
try {
ClassReader classReader = new ClassReader(new FileInputStream("target/classes/com/People.class"));
ClassNode classNode = new ClassNode();
classReader.accept(classNode, ClassReader.SKIP_DEBUG);
System.out.println("Class Name: " + classNode.name);
AnnotationNode anNode = null;
if (classNode.invisibleAnnotations.size() == 1) {
anNode = classNode.invisibleAnnotations.get(0);
System.out.println("Annotation Descriptor : " + anNode.desc);
System.out.println("Annotation attribute pairs : " + anNode.values);
}
File file = new File("target/classes/com/People.class");
FileOutputStream outputStream = new FileOutputStream(file);
outputStream.write(copyFromBytecode(anNode == null ? 0 : (int) anNode.values.get(1)));
} catch (IOException e) {
e.printStackTrace();
}
People people = new People();
System.out.println("people : " + people.size);
}
private byte[] copyFromBytecode(int value) {
ClassWriter cw = new ClassWriter(0);
FieldVisitor fv;
MethodVisitor mv;
AnnotationVisitor av0;
cw.visit(52, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, "com/People", null, "java/lang/Object", null);
cw.visitSource("People.java", null);
{
av0 = cw.visitAnnotation("Lcom.ann.Prinln;", false);
av0.visit("value", new Integer(12));
av0.visitEnd();
}
{
fv = cw.visitField(0, "size", "I", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(0, "phone", "D", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(0, "sex", "Ljava/lang/Boolean;", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(0, "name", "Ljava/lang/String;", null, null);
fv.visitEnd();
}
{
mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
mv.visitCode();
Label l0 = new Label();
mv.visitLabel(l0);
mv.visitLineNumber(10, l0);
mv.visitVarInsn(Opcodes.ALOAD, 0);
mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
Label l1 = new Label();
mv.visitLabel(l1);
mv.visitLineNumber(12, l1);
mv.visitVarInsn(Opcodes.ALOAD, 0);
mv.visitIntInsn(Opcodes.BIPUSH, value);
mv.visitFieldInsn(Opcodes.PUTFIELD, "com/People", "size", "I");
Label l2 = new Label();
mv.visitLabel(l2);
mv.visitLineNumber(14, l2);
mv.visitVarInsn(Opcodes.ALOAD, 0);
mv.visitLdcInsn(new Double("12.0"));
mv.visitFieldInsn(Opcodes.PUTFIELD, "com/People", "phone", "D");
mv.visitInsn(Opcodes.RETURN);
Label l3 = new Label();
mv.visitLabel(l3);
mv.visitLocalVariable("this", "Lcom/People;", null, l0, l3, 0);
mv.visitMaxs(3, 1);
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
複製代碼
實際上RetentionPolicy.CLASS的使用，ASM的配合很重要，因此當你在本身的框架中須要使用這種類型的註解的時候，建議仍是學好ASM再嘗試寫此類註解，而不是像我這樣所有替換。
結束語
本文註解雖然講解的多，可是若是你能看完到這裏，相信經過了幾個例子的描述，你已經知道了幾類註解的基本操做過程，已經讓你對各類類型的註解有基本的認識，或許看了本文你真的理解了retrofit二、ButterKnife，甚至能夠本身寫個簡單的retrofit2或ButterKnife的框架，那就再好不過了。 最後附上源碼，感謝閱讀。
本文版權屬於再惠研發團隊，歡迎轉載，轉載請保留出處。@Dpuntu
相關文章
- 1. Java註解之自定義
- 2. java自定義註解
- 3. java自定義註解（Annotation）
- 4. 20.java自定義註解
- 5. JAVA自定義註解[二]
- 6. Java自定義註解
- 7. 自定義Java註解（annotation）
- 8. java 自定義註解
- 9. Java 自定義註解
- 10. java的自定義註解
- 更多相關文章...
- • 自定義TypeHandler - MyBatis教程
- • MySQL自定義函數（CREATE FUNCTION） - MySQL教程
- • RxJava操作符（十）自定義操作符
- • SpringBoot中properties文件不能自動提示解決方法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Java註解之自定義
- 2. java自定義註解
- 3. java自定義註解（Annotation）
- 4. 20.java自定義註解
- 5. JAVA自定義註解[二]
- 6. Java自定義註解
- 7. 自定義Java註解（annotation）
- 8. java 自定義註解
- 9. Java 自定義註解
- 10. java的自定義註解