คำอธิบายประกอบเช่น @Override ทำงานภายใน Java ได้อย่างไร

ใครช่วยอธิบายให้ฉันฟังว่าคำอธิบายประกอบทำงานภายใน java ได้อย่างไร

ฉันรู้ว่าเราสามารถสร้างคำอธิบายประกอบแบบกำหนดเองได้อย่างไรโดยใช้ไลบรารี java.lang.annotation ใน java แต่ฉันยังไม่เข้าใจว่ามันทำงานอย่างไรภายในเช่นคำอธิบายประกอบ @Override

ฉันจะขอบคุณมากถ้าใครสามารถอธิบายโดยละเอียดได้

ความแตกต่างหลักประการแรกระหว่างประเภทของคำอธิบายประกอบคือไม่ว่าจะใช้ในเวลาคอมไพล์แล้วทิ้ง (ชอบ@Override) หรือวางไว้ในไฟล์คลาสที่คอมไพล์แล้วและพร้อมใช้งานที่รันไทม์ (เช่น Spring's @Component) ซึ่งกำหนดโดยนโยบาย@Retentionของคำอธิบายประกอบ หากคุณกำลังเขียนคำอธิบายประกอบของคุณเองคุณจะต้องตัดสินใจว่าคำอธิบายประกอบนั้นมีประโยชน์ในรันไทม์ (สำหรับการกำหนดค่าอัตโนมัติอาจ) หรือเฉพาะในเวลาคอมไพล์ (สำหรับการตรวจสอบหรือการสร้างโค้ด)

เมื่อรวบรวมรหัสที่มีคำอธิบายประกอบคอมไพเลอร์เห็นคำอธิบายประกอบเช่นเดียวกับมันเห็นการปรับเปลี่ยนองค์ประกอบอื่น ๆ เกี่ยวกับแหล่งที่มาเช่นการปรับเปลี่ยนการเข้าถึง ( public/ private) finalหรือ เมื่อพบคำอธิบายประกอบจะเรียกใช้ตัวประมวลผลคำอธิบายประกอบซึ่งเหมือนกับคลาสปลั๊กอินที่ระบุว่าสนใจคำอธิบายประกอบเฉพาะ โดยทั่วไปตัวประมวลผลคำอธิบายประกอบจะใช้ Reflection API เพื่อตรวจสอบองค์ประกอบที่กำลังคอมไพล์และอาจเรียกใช้การตรวจสอบแก้ไขแก้ไขหรือสร้างโค้ดใหม่เพื่อรวบรวม @Overrideเป็นตัวอย่างแรก; ใช้ Reflection API เพื่อให้แน่ใจว่าสามารถค้นหาลายเซ็นเมธอดที่ตรงกันใน superclasses ใดคลาสหนึ่งและใช้Messagerเพื่อทำให้เกิดข้อผิดพลาดในการคอมไพล์หากไม่สามารถทำได้

มีบทเรียนมากมายเกี่ยวกับการเขียนตัวประมวลผลคำอธิบายประกอบ นี่เป็นประโยชน์อย่างใดอย่างหนึ่ง มองผ่านวิธีการในอินเตอร์เฟซสำหรับวิธีคอมไพเลอร์จะเรียกหน่วยประมวลผลคำอธิบายประกอบ; การดำเนินการหลักเกิดขึ้นในเมธอดซึ่งถูกเรียกทุกครั้งที่คอมไพเลอร์เห็นองค์ประกอบที่มีคำอธิบายประกอบที่ตรงกันProcessorprocess

นอกเหนือจากสิ่งที่คนอื่นแนะนำฉันขอแนะนำให้คุณเขียนคำอธิบายประกอบที่กำหนดเองและตัวประมวลผลตั้งแต่ต้นเพื่อดูว่าคำอธิบายประกอบทำงานอย่างไร

ตัวอย่างเช่นในตัวของฉันเองฉันได้เขียนคำอธิบายประกอบเพื่อตรวจสอบว่าเมธอดนั้นโอเวอร์โหลดหรือไม่ในเวลาคอมไพล์

Overloadประการแรกการสร้างคำอธิบายประกอบที่มีชื่อว่า คำอธิบายประกอบนี้ใช้กับวิธีการดังนั้นฉันจึงใส่คำอธิบายประกอบด้วย@Target(value=ElementType.METHOD)

package gearon.customAnnotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target(value=ElementType.METHOD)
public @interface Overload {

}

จากนั้นสร้างตัวประมวลผลที่สอดคล้องกันเพื่อจัดการกับองค์ประกอบที่มีคำอธิบายประกอบที่กำหนดไว้ สำหรับวิธีการที่ใส่คำอธิบายประกอบ@Overloadลายเซ็นจะต้องปรากฏมากกว่าหนึ่งครั้ง หรือพิมพ์ข้อผิดพลาด

package gearon.customAnnotation;

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic.Kind;

@SupportedAnnotationTypes("gearon.customAnnotation.Overload")

public class OverloadProcessor extends AbstractProcessor{

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        // TODO Auto-generated method stub
        HashMap<String, Integer> map = new HashMap<String, Integer>();

        for(Element element : roundEnv.getElementsAnnotatedWith(Overload.class)){
            String signature = element.getSimpleName().toString();
            int count = map.containsKey(signature) ? map.get(signature) : 0;
            map.put(signature, ++count);
        }

        for(Entry<String, Integer> entry: map.entrySet()){
            if(entry.getValue() == 1){
                processingEnv.getMessager().printMessage(Kind.ERROR, "The method which signature is " + entry.getKey() +  " has not been overloaded");
            }
        }
        return true;
    }
}

หลังจากบรรจุคำอธิบายประกอบและกระบวนการลงในไฟล์ jar แล้วให้สร้างคลาสด้วย@Overloadและใช้ javac.exe เพื่อคอมไพล์

import gearon.customAnnotation.Overload;

public class OverloadTest {
    @Overload
    public static void foo(){
    }

    @Overload
    public static void foo(String s){

    }

    @Overload
    public static void nonOverloadedMethod(){

    }
} 

เนื่องจากnonOverloadedMethod()ไม่ได้รับการโหลดมากเกินไปเราจะได้ผลลัพธ์ดังนี้:

ต่อไปนี้คือ@Override: http://www.docjar.com/html/api/java/lang/Override.java.html

ไม่มีอะไรพิเศษเกี่ยวกับเรื่องนี้ที่ทำให้แตกต่างจากคำอธิบายประกอบที่คุณอาจเขียนเอง บิตที่น่าสนใจอยู่ในผู้บริโภคของคำอธิบายประกอบ สำหรับคำอธิบายประกอบเช่น@Overrideนั้นจะอยู่ในคอมไพเลอร์ Java เองหรือเครื่องมือวิเคราะห์โค้ดแบบคงที่หรือ IDE ของคุณ

โดยทั่วไปคำอธิบายประกอบเป็นเพียงเครื่องหมายซึ่งอ่านโดยคอมไพเลอร์หรือแอปพลิเคชัน ขึ้นอยู่กับนโยบายการเก็บรักษาของพวกเขาพวกเขาพร้อมใช้งานในเวลาคอมไพล์เท่านั้นหรือสามารถอ่านได้ที่รันไทม์โดยใช้การสะท้อน

เฟรมเวิร์กจำนวนมากใช้การเก็บรักษารันไทม์กล่าวคือตรวจสอบอย่างไตร่ตรองว่าคำอธิบายประกอบบางส่วนมีอยู่ในคลาสวิธีการฟิลด์และอื่น ๆ หรือไม่และทำอะไรบางอย่างหากมีคำอธิบายประกอบอยู่ (หรือไม่) นอกจากนี้สมาชิกของคำอธิบายประกอบสามารถใช้เพื่อส่งต่อข้อมูลเพิ่มเติมได้

ตามลิงค์นี้เลย สิ่งนี้จะให้คำตอบที่ใกล้เคียงสำหรับปัญหาของคุณ หากเรามุ่งเน้นไปที่คำอธิบายประกอบคำอธิบายJavaประกอบจะถูกนำมาใช้ใน Java 5 และไม่ใช่เฉพาะฤดูใบไม้ผลิ โดยทั่วไปคำอธิบายประกอบช่วยให้คุณสามารถเพิ่มข้อมูลเมตาลงในคลาสวิธีการหรือตัวแปรได้ คอมไพเลอร์สามารถตีความคำอธิบายประกอบ (ตัวอย่างเช่นคำอธิบายประกอบ @Override) หรือตามกรอบงานเช่น spring (ตัวอย่างเช่นคำอธิบายประกอบ @Component)

นอกจากนี้ฉันกำลังเพิ่มการอ้างอิงเพิ่มเติม

1. http://www.codeproject.com/Articles/272736/Understand-Annotations-in-Java
2. http://docs.oracle.com/javase/7/docs/api/java/lang/annotation/package-summary.html
3. http://www.coderanch.com/how-to/java/AnnotationsExample

แม้แต่ฉันก็กำลังมองหาคำตอบของคำถามเดียวกัน ลิงก์ด้านล่างนี้มีเนื้อหาดีๆที่รวมอยู่ในคำอธิบายประกอบ https://dzone.com/articles/how-annotations-work-java หวังว่าจะช่วยได้!