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

1: คำแนะนำเบื้องต้นเกี่ยวกับ Java Annotations

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

แสดงรายการคำอธิบายประกอบร่วมกันในการพัฒนา

@Override: ใช้เพื่อระบุว่าวิธีการที่สืบทอดมาจาก superclass เมื่อวิธีการของคลาสพาเรนต์ถูกลบหรือแก้ไขคอมไพเลอร์จะแจ้งข้อความแสดงข้อผิดพลาด (คุณสามารถเห็นสิ่งนี้ได้เสมอบนวิธี ToString () ที่เราเห็นบ่อยที่สุด)

@Deprecated: หมายความว่าคลาสหรือวิธีนี้เลิกใช้แล้วและหมดอายุแล้ว หากผู้ใช้ยังต้องการใช้มันจะมีการสร้างคำเตือนการรวบรวม

@suppresswarnings: ข้อความเตือนคอมไพเลอร์สำหรับการละเว้น

การทดสอบ Junit: @Test

คำอธิบายประกอบของฤดูใบไม้ผลิ: @controller, @requestmapping, @requestparam, @ResponseBody, @Service, @Component, @repository, @Resource, @Autowire

คำอธิบายประกอบสำหรับการตรวจสอบ Java: @NotNull, @Email

ลองมาดูใบหน้าที่แท้จริงของ Mount Lu ในการยกเลิกคำอธิบายประกอบ. java

 @Target (ElementType.Method) @retention (RetentionPolicy.Source) Public @Interface Override {}

2: ความรู้พื้นฐานเกี่ยวกับคำอธิบายประกอบ Java

1. ประเภทข้อมูลคำอธิบายประกอบ Java

คำอธิบายประกอบถูกเขียนในไฟล์. java และใช้ @Interface เป็นคำหลักดังนั้นคำอธิบายประกอบจึงเป็นประเภทข้อมูลของ Java จากคำจำกัดความกว้างคลาสอินเตอร์เฟส enum และคำอธิบายประกอบเป็นคลาสทั้งหมด

2. คำอธิบายประกอบ Java Meta

เมื่อสร้างคำอธิบายประกอบคุณต้องใช้คำอธิบายประกอบบางอย่างเพื่ออธิบายคำอธิบายประกอบที่คุณสร้างนั่นคือคำอธิบายประกอบที่เขียนบน @Interface คำอธิบายประกอบเหล่านี้เรียกว่าคำอธิบายประกอบเมตาเช่น @target, @retention ฯลฯ เห็นในการแทนที่ นี่คือคำอธิบายประกอบเมตาบางส่วน

@Documented: ใช้เพื่อทำเครื่องหมายว่ามีการรวมคำอธิบายประกอบเมื่อสร้าง javadoc หรือไม่ คุณจะเห็นว่าคำอธิบายประกอบนี้เหมือนกับ @Override คำอธิบายประกอบว่างเปล่าและไม่มีอะไรเลย

 @documented@retention (RetentionPolicy.runtime) @Target (ElementType.annotation_type) public @interface เอกสาร {}

@Target: ใช้เพื่อกำหนดตำแหน่งที่สามารถใช้คำอธิบายประกอบได้ โดยค่าเริ่มต้นสามารถใช้งานได้ทุกที่หรือสามารถระบุขอบเขตการใช้งานได้ ในการพัฒนามันเป็นเรื่องธรรมดามากที่จะใช้คำอธิบายประกอบในคลาส (เช่น @Controller), ฟิลด์ (เช่น @autowire), วิธีการ (เช่น @requestmapping), พารามิเตอร์วิธีการ (เช่น @requestparam) ฯลฯ

ประเภท: คลาสอินเตอร์เฟสหรือการประกาศ enum
ฟิลด์: การประกาศโดเมน (แอตทริบิวต์)
วิธีการ: การประกาศวิธีการ
พารามิเตอร์: การประกาศพารามิเตอร์
ตัวสร้าง: การประกาศวิธีการสร้าง
local_variable: การประกาศตัวแปรท้องถิ่น
Annotation_type: การประกาศประเภทความคิดเห็น
แพ็คเกจ: คำสั่งแพ็คเกจ

target.java

 @documented@retention (RetentionPolicy.runtime) @Target (ElementType.Annotation_Type) เป้าหมายสาธารณะ @Interface เป้าหมาย { /** * ส่งคืนอาร์เรย์ขององค์ประกอบประเภทที่คำอธิบายประกอบ * สามารถนำไปใช้ได้ * @return อาร์เรย์ขององค์ประกอบชนิดที่คำอธิบายประกอบ * สามารถนำไปใช้กับ */ elementType [] ค่า ();}

 public enum elementType { /** คลาสอินเตอร์เฟส (รวมถึงประเภทคำอธิบายประกอบ) หรือการประกาศ enum* /ประเภท, /** การประกาศฟิลด์ (รวมถึงค่าคงที่ enum)* /ฟิลด์, /** การประกาศวิธีการ* /วิธีการประกาศพารามิเตอร์* การประกาศ*/ Annotation_type,/ ** การประกาศแพ็คเกจ*/ แพ็คเกจ,/ ** ประเภทการประกาศพารามิเตอร์*/ type_parameter,/ ** ใช้ประเภท*/ type_use}

@Inherited: อนุญาตให้คลาสย่อยสามารถสืบทอดคำอธิบายประกอบในคลาสหลักและสามารถรับคำอธิบายประกอบของคลาสแม่ผ่านการสะท้อน

 @documented@retention (RetentionPolicy.Runtime) @Target (ElementType.Annotation_type) สาธารณะ @Interface ที่สืบทอดมา {}

@Constraint: ใช้เพื่อตรวจสอบว่าค่าแอตทริบิวต์นั้นถูกกฎหมายหรือไม่

 @Documented@Target ({ElementType.Annotation_type})@retention (RetentionPolicy.runtime) ข้อ จำกัด สาธารณะ @Interface {class <? ขยาย ConstraintValidator <?,? >> [] ตรวจสอบความถูกต้องโดย ();}

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

แหล่งที่มา: ระดับซอร์สโค้ดคำอธิบายประกอบมีอยู่ในซอร์สโค้ดเท่านั้นและโดยทั่วไปจะใช้เพื่อโต้ตอบกับคอมไพเลอร์และใช้ในการตรวจจับรหัส เช่น @Override, @suppresswarings

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

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

 @documented@retention (RetentionPolicy.runtime) @Target (ElementType.Annotation_type) การเก็บรักษาสาธารณะ @interface retention { /*** ส่งคืนนโยบายการเก็บรักษา * @return นโยบายการเก็บรักษา */ มูลค่าการเก็บรักษา () ();}

3. เนื้อหาของคำอธิบายประกอบ Java

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

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

มาดูคำสั่งของคำอธิบายประกอบการร้องขอใน SpringMVC

 @Target ({ElementType.Method, ElementType.type})@retention (retentionPolicy.runtime)@documented@mapingpublic @interface Requestmapping {ชื่อสตริง () ค่าเริ่มต้น ""; @aliasfor ("path") string [] value () ค่าเริ่มต้น {}; @aliasfor ("value") สตริง [] path () ค่าเริ่มต้น {}; requestMethod [] เมธอด () ค่าเริ่มต้น {}; String [] params () ค่าเริ่มต้น {}; สตริง [] ส่วนหัว () ค่าเริ่มต้น {}; สตริง [] ผู้บริโภค () ค่าเริ่มต้น {}; สตริง [] ผลิต () ค่าเริ่มต้น {};}

การใช้คำอธิบายประกอบการร้องขอใน SpringMVC

 @RequestMapping (value = "/list", method = requestMethod.post, ผลิต = {"แอปพลิเคชัน/json; charset = utf-8;"}) รายการสตริงสาธารณะ () {}

4. ใช้สถานการณ์ของคำอธิบายประกอบ

คุณสามารถวิเคราะห์สถานการณ์การใช้งานของคำอธิบายประกอบผ่านระยะเวลาการประกาศของคำอธิบายประกอบ:

ระดับแหล่งที่มาของซอร์สโค้ด: สำหรับคอมไพเลอร์เช่น @Override, @deprecated ฯลฯ มีสถานการณ์ไม่มากนักที่นักพัฒนาควรใช้

คลาส: ระดับ bytecode ส่วนนี้ไม่ค่อยเห็น

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

คำอธิบายประกอบโดยไม่มีคุณลักษณะใด ๆ ในคำอธิบายประกอบ ส่วนหนึ่งของคำอธิบายประกอบนี้มักจะมีบทบาทเป็นคำอธิบายประกอบเช่น @Test, @Before, @After โดยการได้รับคำอธิบายประกอบแท็กเหล่านี้การประมวลผลเชิงตรรกะบางอย่างจะเสร็จสิ้น

คุณสามารถใช้คำอธิบายประกอบข้อ จำกัด @Constraint เพื่อตรวจสอบค่าแอตทริบิวต์เช่น @Email, @NotNull ฯลฯ

คุณสามารถกำหนดค่าพารามิเตอร์บางอย่างโดยใช้คุณสมบัติในคำอธิบายประกอบจากนั้นคุณสามารถใช้การสะท้อนกลับเพื่อรับพารามิเตอร์เหล่านี้ คำอธิบายประกอบเหล่านี้ไม่มีฟังก์ชั่นพิเศษอื่น ๆ เพียงแค่กำหนดค่าพารามิเตอร์บางอย่างแทนการกำหนดค่า XML การใช้คำอธิบายประกอบเพื่อกำหนดค่าพารามิเตอร์ซึ่งเป็นที่นิยมใน Spring Boot เช่น @configuration

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

สาม: คำอธิบายประกอบ Java และการสะท้อน API ขั้นพื้นฐาน

 // รับคำอธิบายประกอบของ Public Public บางประเภท <a ขยายคำอธิบายประกอบ> getannotation (คลาส <a> คำอธิบายประกอบ); // รับคำอธิบายประกอบทั้งหมด (รวมถึงคำอธิบายประกอบที่แก้ไขโดยมรดกในคลาสพาเรนต์) คำอธิบายประกอบสาธารณะ [] getannotations (); // รับคำอธิบายประกอบที่ประกาศ (แต่ไม่รวมถึงคำอธิบายประกอบที่แก้ไขโดยมรดกในชั้นเรียนหลัก) คำอธิบายประกอบสาธารณะ [] getDeclaredannotations (); // ทดสอบว่าวัตถุนั้นถูกอธิบายโดยคำอธิบายประกอบโดยการเพิ่มความสามารถในการเพิ่มจำนวน SecurityException; // รับวิธีการสาธารณะวิธีการ getMethod (ชื่อสตริง, คลาส <?> ... parameterTypes);

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

ใช้คำอธิบายประกอบที่กำหนดเอง + interceptors หรือ AOPS เพื่อควบคุมการอนุญาต

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

ขั้นตอนที่ 1: กำหนดคำอธิบายประกอบ

ต้องใช้ login.java

 @documented@target ({elementtype.method})@retention (retentionpolicy.runtime) สาธารณะ @interface ต้องการ {}

ขั้นตอนที่ 2: ใช้คำอธิบายประกอบ

 @controller @requestmapping ("/user") คลาสสาธารณะ userController {@requireslogin @requestmapping (value = "/list", ผลิต = {"application/json; charset = utf-8;"}) สตริงสาธารณะ getUserList () {system.out.println ( return "[{'id': 1, 'ชื่อผู้ใช้': 'Zhangsan'}]"; -

ขั้นตอนที่ 3: ใช้ AOP เพื่อสกัดกั้นและแยกวิเคราะห์คำอธิบายประกอบ

 LoginAdvices คลาสสาธารณะ {โมฆะสาธารณะก่อน (JoinPoint JoinPoint) โยนข้อยกเว้น {Object เป้าหมาย = JoinPoint.getTarget (); String methodName = joinPoint.getSignature (). getName (); System.out.println (Target + "-------" + MethodName); วิธีการ = target.getClass (). getMethod (ชื่อวิธี); คำอธิบายประกอบแบบบูลีน = method.isannotationpresent (chanteslogin.class); if (คำอธิบายประกอบ) {// ผู้ใช้จะต้องเข้าสู่ระบบบูลีน islogin = false; if (! islogin) {โยนข้อยกเว้นใหม่ ("คุณต้องเข้าสู่ระบบเพื่อเข้าถึงอินเทอร์เฟซนี้"); } else {system.out.println ("เข้าสู่ระบบ ... "); -

กำหนดค่า AOP ใน ApplicationContext.xml

 <bean id = "LoginAdvices"/> <!-การกำหนดค่า AOP-> <aop: config proxy-target-class = "true"> <!-ส่วน-> <aop: ref = "loginadvices"> <!-จุด-> <aop: pointcut id = "pointcut1 วิธีการแจ้งเตือนและจุด-> <aop: ก่อนวิธี = "ก่อน" pointcut-ref = "pointcut1"/> </aop: แง่มุม> </aop: config>

ข้อยกเว้นที่กำหนดเอง

ทำไมต้องปรับแต่งข้อยกเว้น

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

หรือในบางกรณีข้อยกเว้นเดียวกันใน Java อาจเกิดจากเหตุผลหลายประการ ไม่ใช่เรื่องง่ายที่จะค้นหาข้อผิดพลาดเมื่อแก้ไขปัญหา ในเวลานี้คุณสามารถใช้การปรับแต่งข้อยกเว้นที่ชัดเจนยิ่งขึ้น

ประโยชน์ของข้อยกเว้นที่กำหนดเอง: ข้อยกเว้นที่กำหนดเองสามารถทำให้ข้อยกเว้นชัดเจนขึ้นและซ่อนข้อยกเว้นพื้นฐานซึ่งปลอดภัยกว่าและใช้งานง่ายมากขึ้น

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

ด้านล่างเป็นตัวอย่างของข้อยกเว้นที่กำหนดเองใน Apache Shiro

 Shiroexception ระดับสาธารณะขยาย RuntimeException {Shiroexception สาธารณะ () {} Shiroexception สาธารณะ (ข้อความสตริง) {Super (ข้อความ); } Shiroexception สาธารณะ (สาเหตุที่สามารถโยนได้) {super (สาเหตุ); } Shiroexception สาธารณะ (ข้อความสตริง, สาเหตุที่สามารถจดจำได้) {super (ข้อความ, สาเหตุ); -

ข้างต้นเป็นคำอธิบายโดยละเอียดเกี่ยวกับคำอธิบายประกอบ Java และคำอธิบายประกอบที่กำหนดเอง