มีการใช้คำอธิบายประกอบใน Java อย่างไร?

พื้นที่สำคัญที่เราสามารถใช้คำอธิบายประกอบมีอะไรบ้าง คุณลักษณะนี้ใช้แทนที่การกำหนดค่าตาม XML หรือไม่

คำอธิบายประกอบmeta-meta-วัตถุที่สามารถนำมาใช้เพื่ออธิบายอื่น ๆmeta-วัตถุ เมตาวัตถุคือคลาสฟิลด์และเมธอด ขอวัตถุสำหรับวัตถุ meta (เช่นanObj.getClass()) เรียกว่าวิปัสสนา วิปัสสนาสามารถไปต่อไปและเราสามารถขอ meta-วัตถุสิ่งที่เป็นคำอธิบายประกอบ (เช่นaClass.getAnnotations) วิปัสสนาและคำอธิบายประกอบอยู่ในสิ่งที่เรียกว่าการสะท้อนและเมตาการเขียนโปรแกรม

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

การประมวลผลคำอธิบายประกอบเป็นกลไกที่ทรงพลังมากและสามารถใช้งานได้หลายวิธี:

• เพื่ออธิบายข้อ จำกัด หรือการใช้องค์ประกอบ: เช่น@Deprecated, @Overrideหรือ@NotNull
• เพื่ออธิบาย "ธรรมชาติ" ขององค์ประกอบเช่น @Entity, @TestCase, @WebService
• เพื่ออธิบายพฤติกรรมขององค์ประกอบ: @Statefull, @Transaction
• เพื่ออธิบายวิธีประมวลผลองค์ประกอบ: @Column, @XmlElement

ในทุกกรณีคำอธิบายประกอบที่ใช้ในการอธิบายองค์ประกอบและชี้แจงของความหมาย

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

การใช้คำอธิบายประกอบ:

• เอกสารประกอบเช่น XDoclet
• การรวบรวม
• IDE
• กรอบการทดสอบเช่น JUnit
• คอนเทนเนอร์ IoC เช่นสปริง
• การทำให้เป็นอันดับเช่น XML
• การเขียนโปรแกรมแบบ Aspect-oriented (AOP) เช่น Spring AOP
• แอ็พพลิเคชันเซิร์ฟเวอร์เช่นคอนเทนเนอร์ EJB เว็บเซอร์วิส
• การทำแผนที่วัตถุสัมพันธ์ (ORM) เช่น Hibernate, JPA
• และอื่น ๆ อีกมากมาย...

... ดูตัวอย่างโครงการลอมบอกซึ่งใช้คำอธิบายประกอบเพื่อกำหนดวิธีการสร้างequalsหรือhashCodeวิธีการ

มีแอ็พพลิเคชัน mutiple สำหรับหมายเหตุประกอบของ Java ก่อนอื่นพวกเขาอาจใช้คอมไพเลอร์ (หรือส่วนขยายคอมไพเลอร์) พิจารณาตัวอย่างคำอธิบายประกอบแบบแทนที่ :

class Foo {

    @Override public boolean equals(Object other) {
        return ...;
    }
}

อันนี้จริงๆแล้วสร้างขึ้นใน Java JDK คอมไพเลอร์จะส่งสัญญาณข้อผิดพลาดหากมีการติดแท็กด้วยวิธีการบางอย่างซึ่งไม่ได้แทนที่วิธีการที่สืบทอดมาจากคลาสฐาน คำอธิบายประกอบนี้อาจเป็นประโยชน์ในการหลีกเลี่ยงข้อผิดพลาดทั่วไปที่คุณต้องการแทนที่วิธีการ แต่ไม่สามารถทำได้เนื่องจากลายเซ็นที่ระบุในวิธีการของคุณไม่ตรงกับลายเซ็นของวิธีการที่ถูกแทนที่:

class Foo {

    @Override public boolean equals(Foo other) {  // Compiler signals an error for this one
        return ...;
    }
}

ในฐานะของ JDK7 คำอธิบายประกอบจะได้รับอนุญาตในทุกประเภท ตอนนี้คุณลักษณะนี้สามารถใช้สำหรับคำอธิบายประกอบคอมไพเลอร์เช่นNotNullเช่นใน:

public void processSomething(@NotNull String text) {
    ...
}

ซึ่งจะช่วยให้คอมไพเลอร์จะเตือนคุณเกี่ยวกับการที่ไม่เหมาะสมการใช้ / ไม่ถูกตรวจสอบของตัวแปรและnullค่า

แอปพลิเคชันขั้นสูงสำหรับการทำหมายเหตุประกอบเพิ่มเติมนั้นเกี่ยวข้องกับการสะท้อนและการทำหมายเหตุประกอบในขณะใช้งาน นี่คือ (ฉันคิดว่า) สิ่งที่คุณคำนึงถึงเมื่อคุณพูดถึงคำอธิบายประกอบว่า "แทนที่การกำหนดค่าตาม XML" นี่คือการประมวลผลคำอธิบายประกอบที่ใช้ตัวอย่างเช่นโดยกรอบงานที่หลากหลายและมาตรฐาน JCP (การติดตา, การฉีดพึ่งพาคุณตั้งชื่อ) เพื่อให้ข้อมูล meta-data และการกำหนดค่าที่จำเป็น

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

• JUnit 4 - คุณเพิ่ม@Testคำอธิบายประกอบให้กับแต่ละวิธีการทดสอบที่คุณต้องการให้นักวิ่ง JUnit ทำงาน นอกจากนี้ยังมีคำอธิบายประกอบเพิ่มเติมเกี่ยวกับการตั้งค่าการทดสอบ (เช่น@Beforeและ@BeforeClass) ทั้งหมดนี้ดำเนินการโดยนักวิ่ง JUnit ซึ่งจะทำการทดสอบตามนั้น คุณสามารถพูดได้ว่ามันเป็นการแทนที่สำหรับการกำหนดค่า XML แต่บางครั้งคำอธิบายประกอบก็มีประสิทธิภาพมากกว่า (สามารถใช้การไตร่ตรองเป็นต้น) และพวกเขายังอยู่ใกล้กับรหัสที่พวกเขาอ้างถึง ( @Testหมายเหตุประกอบนั้นอยู่ตรงหน้าวิธีทดสอบดังนั้นวัตถุประสงค์ ของวิธีการนั้นชัดเจน - ทำหน้าที่เป็นเอกสารประกอบเช่นกัน) การกำหนดค่า XML ในทางกลับกันอาจมีความซับซ้อนและสามารถรวมข้อมูลได้มากกว่าคำอธิบายประกอบ

• Terracotta - ใช้ทั้งคำอธิบายประกอบและไฟล์กำหนดค่า XML ตัวอย่างเช่น@Rootคำอธิบายประกอบบอกรันไทม์ Terracotta ว่าฟิลด์คำอธิบายประกอบเป็นรูทและหน่วยความจำควรถูกแชร์ระหว่างอินสแตนซ์ VM ไฟล์กำหนดค่า XML ใช้เพื่อกำหนดค่าเซิร์ฟเวอร์และแจ้งให้คลาสทราบถึงเครื่องมือ

• Google Guice - ตัวอย่างจะเป็น@Injectคำอธิบายประกอบซึ่งเมื่อนำไปใช้กับตัวสร้างทำให้รันไทม์ของ Guice ค้นหาค่าสำหรับแต่ละพารามิเตอร์ตามหัวฉีดที่กำหนดไว้ @Injectคำอธิบายประกอบจะค่อนข้างยากที่จะทำซ้ำโดยใช้ไฟล์คอนฟิกูเรชัน XML และใกล้ชิดกับตัวสร้างอ้างอิงมันจะเป็นประโยชน์มาก (คิดที่มีการค้นหาเป็นไฟล์ XML ขนาดใหญ่เพื่อค้นหาทุกฉีดพึ่งพาคุณได้ตั้งค่า)

หวังว่าฉันจะบอกคุณถึงวิธีการใช้คำอธิบายประกอบในกรอบงานต่าง ๆ

คำอธิบายประกอบใน Java, ให้ค่าเฉลี่ยเพื่ออธิบายคลาสฟิลด์และเมธอด โดยพื้นฐานแล้วมันเป็นรูปแบบของข้อมูลเมตาที่ถูกเพิ่มเข้าไปในไฟล์ต้นฉบับ Java พวกเขาไม่สามารถส่งผลกระทบต่อความหมายของโปรแกรมโดยตรง อย่างไรก็ตามคำอธิบายประกอบสามารถอ่านได้ในขณะใช้งานโดยใช้ Reflection & กระบวนการนี้เรียกว่าการวิปัสสนา จากนั้นสามารถใช้เพื่อปรับเปลี่ยนคลาสฟิลด์หรือเมธอด

คุณลักษณะนี้มักถูกใช้งานโดย Libraries & SDK (hibernate, JUnit, Spring Framework) เพื่อลดความซับซ้อนหรือลดจำนวนรหัสที่โปรแกรมเมอร์จะทำเว้นแต่จะทำงานใน orer เพื่อทำงานกับ Library หรือ SDK เหล่านี้ Reflection work-hand ใน Java

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

Driver.java

package io.hamzeen;

import java.lang.annotation.Annotation;

public class Driver {

    public static void main(String[] args) {
        Class<TestAlpha> obj = TestAlpha.class;
        if (obj.isAnnotationPresent(IssueInfo.class)) {

            Annotation annotation = obj.getAnnotation(IssueInfo.class);
            IssueInfo testerInfo = (IssueInfo) annotation;

            System.out.printf("%nType: %s", testerInfo.type());
            System.out.printf("%nReporter: %s", testerInfo.reporter());
            System.out.printf("%nCreated On: %s%n%n",
                    testerInfo.created());
        }
    }
}

TestAlpha.java

package io.hamzeen;

import io.hamzeen.IssueInfo;
import io.hamzeen.IssueInfo.Type;

@IssueInfo(type = Type.IMPROVEMENT, reporter = "Hamzeen. H.")
public class TestAlpha {

}

IssueInfo.java

package io.hamzeen;

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

/**
 * @author Hamzeen. H.
 * @created 10/01/2015
 * 
 * IssueInfo annotation definition
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface IssueInfo {

    public enum Type {
        BUG, IMPROVEMENT, FEATURE
    }

    Type type() default Type.BUG;

    String reporter() default "Vimesh";

    String created() default "10/01/2015";
}

มันเป็นการทดแทนสำหรับการกำหนดค่าตาม XML?

ไม่สมบูรณ์ แต่การรวมกันที่สอดคล้องอย่างใกล้ชิดกับโครงสร้างรหัส (เช่นการแมป JPA หรือการฉีดพึ่งพาในฤดูใบไม้ผลิ) มักจะถูกแทนที่ด้วยคำอธิบายประกอบและจากนั้นมักจะ verbose น้อยน่ารำคาญและเจ็บปวด เฟรมเวิร์กที่โดดเด่นเกือบทั้งหมดได้ทำสวิตช์นี้แม้ว่าการกำหนดค่า XML เก่ามักจะยังคงเป็นตัวเลือก

มีคำอธิบายประกอบ 2 มุมมอง

1. มุมมองผู้ใช้เวลาส่วนใหญ่คำอธิบายประกอบทำงานเหมือนทางลัดช่วยให้คุณประหยัดจังหวะสำคัญหรือทำให้โปรแกรมอ่านง่ายขึ้น

2. มุมมองของผู้จัดจำหน่ายมุมมองของตัวประมวลผลของคำอธิบายประกอบเป็น 'อินเทอร์เฟซ' ที่มีน้ำหนักเบามากกว่าโปรแกรมของคุณเผชิญหน้ากับบางสิ่ง แต่ไม่มี "ใช้งาน" อินเทอร์เฟซเฉพาะอย่างชัดเจน (นี่คือคำอธิบายประกอบ)

เช่นใน jpa คุณให้นิยามสิ่งที่คล้ายกัน

@Entity class Foo {...}

แทน

class Foo implements Entity {...}

ทั้งคู่พูดในสิ่งเดียวกัน "Foo is Entity class"

สามารถใช้คำอธิบายประกอบได้ที่ไหน

คำอธิบายประกอบสามารถนำไปใช้กับการประกาศ:ประกาศของคลาสฟิลด์วิธีการและองค์ประกอบโปรแกรมอื่น ๆ เมื่อใช้กับการประกาศแต่ละคำอธิบายประกอบมักจะปรากฏขึ้นตามการประชุมในบรรทัดของตัวเอง

การอัพเดต Java SE 8:คำอธิบายประกอบสามารถนำไปใช้กับการใช้งานประเภท นี่คือตัวอย่างบางส่วน:

• นิพจน์การสร้างอินสแตนซ์คลาส:

  ใหม่ @Interned MyObject ();

• ประเภทหล่อ:

  myString = (@NonNull String) str;

• ดำเนินการข้อ:

  คลาส UnmodifiableList ใช้ @Readonly List <@Readonly T> {... }

• ประกาศข้อยกเว้นโยน:

  void monitorTemperature () พ่น @Critical TemperatureException {... }

กรอบงานเช่นไฮเบอร์เนตมีการกำหนดค่าจำนวนมาก / การทำแผนที่จำเป็นต้องใช้คำอธิบายประกอบอย่างมาก

ดูคำอธิบายประกอบ Hibernate

JPA (จาก Java EE 5) เป็นตัวอย่างที่ยอดเยี่ยมของการใช้หมายเหตุประกอบ Java EE 6 จะแนะนำคำอธิบายประกอบในหลายพื้นที่ใหม่เช่นเว็บเซอร์ RESTful และคำอธิบายประกอบใหม่สำหรับแต่ละ Servlet API เก่าที่ดี

นี่คือแหล่งข้อมูลหลายแห่ง:

• ซัน - Java Persistence API
• Java EE 5 บทช่วยสอน - JPA
• แนะนำแพลตฟอร์ม Java EE 6 (เลือกทั้งสามหน้า)

มันไม่เพียง แต่เฉพาะการกำหนดค่าที่จะ / สามารถถูกครอบงำโดยคำอธิบายประกอบ แต่พวกเขายังสามารถใช้ในการควบคุมพฤติกรรม คุณเห็นสิ่งนี้ได้ดีในตัวอย่าง JAX-RS ของ Java EE 6

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

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

คุณสามารถใช้คำอธิบายประกอบเพื่อจัดเก็บข้อมูลเมตาบางอย่างเช่นในกรอบงานปลั๊กอินเช่นชื่อของปลั๊กอิน

มันเป็นอีกเครื่องมือหนึ่งมันมีจุดประสงค์มากมาย

มันแนบข้อมูลเพิ่มเติมเกี่ยวกับรหัสโดย (a) ตรวจสอบคอมไพเลอร์หรือ (b) การวิเคราะห์รหัส

**

• ต่อไปนี้เป็นคำอธิบายประกอบในตัว :: 2 ประเภท

**

ประเภทที่ 1) คำอธิบายประกอบที่ใช้กับรหัส java:

@Override // gives error if signature is wrong while overriding.
Public boolean equals (Object Obj) 

@Deprecated // indicates the deprecated method
Public doSomething()....

@SuppressWarnings() // stops the warnings from printing while compiling.
SuppressWarnings({"unchecked","fallthrough"})

ประเภท 2) คำอธิบายประกอบที่ใช้กับคำอธิบายประกอบอื่น ๆ :

@Retention - Specifies how the marked annotation is stored—Whether in code only, compiled into the class, or available at run-time through reflection.

@Documented - Marks another annotation for inclusion in the documentation.

@Target - Marks another annotation to restrict what kind of java elements the annotation may be applied to

@Inherited - Marks another annotation to be inherited to subclasses of annotated class (by default annotations are not inherited to subclasses).

**

• คำอธิบายประกอบที่กำหนดเอง ::

** http://en.wikipedia.org/wiki/Java_annotation#Custom_annotations

สำหรับการทำความเข้าใจที่ดีขึ้นลองลิงค์ด้านล่าง: จัดทำด้วยตัวอย่าง

http://www.javabeat.net/2007/08/annotations-in-java-5-0/

คำอธิบายประกอบอาจใช้เป็นทางเลือกแทนไฟล์กำหนดค่าภายนอก แต่ไม่สามารถนำมาใช้แทนได้อย่างสมบูรณ์ คุณสามารถค้นหาตัวอย่างมากมายที่มีการใช้คำอธิบายประกอบเพื่อแทนที่ไฟล์การกำหนดค่าเช่น Hibernate, JPA, EJB 3 และเทคโนโลยีเกือบทั้งหมดที่รวมอยู่ใน Java EE

อย่างไรก็ตามนี่ไม่ใช่ตัวเลือกที่ดีเสมอไป วัตถุประสงค์ของการใช้ไฟล์กำหนดค่าคือเพื่อแยกรหัสจากรายละเอียดของสภาพแวดล้อมที่แอปพลิเคชันทำงานอยู่ ในสถานการณ์เช่นนี้และส่วนใหญ่เมื่อมีการใช้การกำหนดค่าเพื่อแมปแอปพลิเคชันกับโครงสร้างของระบบภายนอกการเพิ่มความคิดเห็นจะไม่สามารถแทนที่ไฟล์การกำหนดค่าได้ดีเนื่องจากจะทำให้คุณรวมรายละเอียดของระบบภายนอกภายในซอร์สโค้ดของ ใบสมัครของคุณ. นี่คือไฟล์ภายนอกที่ถือว่าเป็นตัวเลือกที่ดีที่สุดมิฉะนั้นคุณจะต้องแก้ไขซอร์สโค้ดและคอมไพล์ใหม่ทุกครั้งที่คุณเปลี่ยนรายละเอียดที่เกี่ยวข้องในสภาพแวดล้อมการทำงาน

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

ในท้ายที่สุดกฎก็เหมือนกันเสมอ: เก็บสิ่งที่เปลี่ยนแปลงกับแหล่งที่มาไว้ในแหล่งข้อมูลและเก็บสิ่งที่เปลี่ยนแปลงโดยอิสระจากแหล่งภายนอก

Java EE 5 สนับสนุนการใช้คำอธิบายประกอบผ่านการกำหนดค่า XML ตัวอย่างเช่นใน EJB3 จะมีการระบุแอททริบิวต์ธุรกรรมในวิธี EJB โดยใช้คำอธิบายประกอบ พวกเขายังใช้คำอธิบายประกอบเพื่อทำเครื่องหมาย POJOs เป็น EJB และเพื่อระบุวิธีการเฉพาะเป็นวิธีวงจรชีวิตแทนการกำหนดให้มีการใช้อินเทอร์เฟซนั้น

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

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

อ่านรายละเอียดเกี่ยวกับJava คำอธิบายประกอบ

ต่อไปนี้เป็นสถานที่บางแห่งที่คุณสามารถใช้คำอธิบายประกอบ

a. Annotations can be used by compiler to detect errors and suppress warnings
b. Software tools can use annotations to generate code, xml files, documentation etc., For example, Javadoc use annotations while generating java documentation for your class.
c. Runtime processing of the application can be possible via annotations.
d. You can use annotations to describe the constraints (Ex: @Null, @NotNull, @Max, @Min, @Email).
e. Annotations can be used to describe type of an element. Ex: @Entity, @Repository, @Service, @Controller, @RestController, @Resource etc.,
f. Annotation can be used to specify the behaviour. Ex: @Transactional, @Stateful
g. Annotation are used to specify how to process an element. Ex: @Column, @Embeddable, @EmbeddedId
h. Test frameworks like junit and testing use annotations to define test cases (@Test), define test suites (@Suite) etc.,
i. AOP (Aspect Oriented programming) use annotations (@Before, @After, @Around etc.,)
j. ORM tools like Hibernate, Eclipselink use annotations

คุณสามารถอ้างอิงลิงค์นี้สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับคำอธิบายประกอบ

คุณสามารถอ้างอิงลิงค์นี้เพื่อดูว่ามีการใช้คำอธิบายประกอบเพื่อสร้างชุดทดสอบง่ายๆ