אנוטציות ב-Java

הערות Java מספקות מידע על הקוד. הערות Java אין להן השפעה ישירה על הקוד שהן מעידות עליו. במדריך להערות Java, נסתכל על הנושאים הבאים:

1. הערות Java מובנות
2. כיצד לכתוב הערה מותאמת אישית
3. שימוש בהערות וכיצד לנתח הערות באמצעות API להיטגות.

הערות Java

Java 1.5 הכניסה אננוטציות וכעת היא משמשת באופן נרחב במסגרות Java EE כמו Hibernate, Jersey, ו-Spring. האננוטציה של Java היא מטא נתונים על התוכנית המוטבעת בעצמה. זה יכול להיות מנותק על ידי כלי ניתוח אננוטציות או על ידי המהדר. אנו יכולים גם לציין זמינות של האננוטציה או עד לזמן ההרצה או עד לזמן הרצה. לפני האננוטציות של Java, המטא נתונים של התוכנית היה זמין דרך הערות Java או באמצעות Javadoc אבל האננוטציה מציעה יותר מזה. המטא נתונים של האננוטציות יכול להיות זמין גם בזמן הרצה וקוראי האננוטציות יכולים להשתמש בזה כדי לקבוע את זרימת התהליך. לדוגמה, בשירות האינטרנט של Jersey אנו מוסיפים אננוטציית PATH עם מחרוזת URI לשיטה ובזמן הרצה, jersey מנתח אותה כדי לקבוע את השיטה לקרוא עבור דפוס URI נתון.

אננוטציה מותאמת אישית של Java

יצירת אישור מותאם אישית דומה לכתיבת ממשק, רק שמילת המפתח של הממשק מתקדמת בסמל _@_. נוכל להצהיר על שיטות באישור. בואו נראה דוגמה לאישור מותאם ב-Java ואז נדבר על תכונותיו ונקודות חשובות.

package com.journaldev.annotations;

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

@Documented
@Target(ElementType.METHOD)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodInfo{
	String author() default "Pankaj";
	String date();
	int revision() default 1;
	String comments();
}

כמה נקודות חשובות על אישורים ב-Java הן:

1. לשיטות האישור אין יכולת לקבל פרמטרים.
2. סוגי ההחזרה של שיטות האישור מוגבלים לפרימיטיבים, מחרוזת, Enums, אישור או מערך של אלה.
3. שיטות האישור ב-Java יכולות להכיל ערכי ברירת מחדל.
4. עיגולים יכולים להכיל מטא עיגולים מחוברים אליהם. מטא עיגולים משמשים לספק מידע על האישור.

מטא עיגולים ב-Java

יש חמישה סוגי מטא עיגולים:

1. @Documented – מציין כי אלמנטים המשתמשים באישור זה צריכים להיות מתועדים על ידי javadoc וכלי דומים. סוג זה צריך לשמש להוספת הערות להגדרות של סוגים שההערות שלהם משפיעות על השימוש באלמנטים שנסופקו ללקוחותיהם. אם הגדרת סוג מסומנת כ-Documented, ההערות שלה הופכות להיות חלק מממשק התכנות הציבורי של האלמנטים המסומנים.
2. @מטרת – מציין את סוגי הרכיבים בתוכנית שבהם ניתן להשתמש בסוג ההערה. כמה ערכים אפשריים הם TYPE, METHOD, CONSTRUCTOR, FIELD וכו '. אם ה meta-annotation של Target לא קיימת, אז ההערה יכולה להיות בשימוש בכל אלמנט בתוכנית.
3. @נירש – מציין כי סוג ההערה מורשה באופן אוטומטי. אם משתמש שואל על סוג ההערה בהצהרת מחלקה, וההצהרת מחלקה אין לה הערה עבור סוג זה, אז המחלקה האב שלה תיבדק באופן אוטומטי עבור סוג ההערה. התהליך יושן עד שהערה עבור סוג זה נמצאת, או שראש הירושכיה של המחלקה (Object) מתקבל.
4. @שימור – מציין כמה זמן ההערות עם סוג המוגדר יישמרו. זה מקבל ארגומנט RetentionPolicy שערכי האפשריים שלו הם SOURCE, CLASS ו-RUNTIME
5. @חוזר – משמש כדי לציין כי סוג ההערה שההצהרה שלו מסמנת הוא ניתן לחזרה.

הערות מובנות ב-Java

Java מספקת חמישה הערות מובנות.

1. @Override – כאשר אנו רוצים לדרוס שיטת מערכת העל, עלינו להשתמש באנוטציה זו כדי ליידע את המהדר כי אנו דורסים שיטה. לכן כאשר שיטת מערכת העל מוסרת או משתנה, המהדר יציג הודעת שגיאה. למדו למה תמיד עלינו להשתמש באנוטציית דריסה ב-Java בעת דריסת שיטה.
2. @Deprecated – כאשר רוצים שהמהדר ידע כי שיטה היא מוטלת, עלינו להשתמש באנוטציה זו. ג'אווה ממליצה שב-Javadoc, נספק מידע על מנת למה השיטה הוטלה ומהו האלטרנטיבה לשימוש.
3. @SuppressWarnings – זאת רק ליידע את המהדר להתעלם מאזהרות מסוימות שהוא מייצר, לדוגמה שימוש בסוגים רגילים ב-ג'נריקס של ג'אווה. מדיניות השמירה שלה היא SOURCE והמהדר משטח אותה.
4. @FunctionalInterface – אנוטציה זו הוזנה ב-ג'אווה 8 כדי לציין שהממשק מיועד להיות ממשק פונקציונלי.
5. @SafeVarargs – הצהרת מתכנת שגוף שיטה או בנאי המסומן לא מבצע פעולות לא בטוחות בפרמטר varargs שלו.

דוגמת אנוטציות ב-Java

בואו נראה דוגמה ב-Java שמדגימה את שימוש באנוטציות מובנות ב-Java, וגם את השימוש באנוטציית מותאמת אישית שיצרנו בדוגמה למעלה.

package com.journaldev.annotations;

import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

public class AnnotationExample {

	public static void main(String[] args) {
	}

	@Override
	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 1)
	public String toString() {
		return "Overriden toString method";
	}

	@Deprecated
	@MethodInfo(comments = "deprecated method", date = "Nov 17 2012")
	public static void oldMethod() {
		System.out.println("old method, don't use it.");
	}

	@SuppressWarnings({ "unchecked", "deprecation" })
	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 10)
	public static void genericsTest() throws FileNotFoundException {
		List l = new ArrayList();
		l.add("abc");
		oldMethod();
	}

}

I believe above java annotation example is self-explanatory and showing the use of annotations in different cases.

ניתוח אנוטציות ב-Java

נשתמש ב-Reflection כדי לנתח אנוטציות ב-Java מתוך מחלקה. יש לשים לב שמדיניות שמירת האנוטציות צריכה להיות RUNTIME אחרת מידע שלה לא יהיה זמין בזמן ריצה ולא נוכל לקבל נתונים ממנה.

package com.journaldev.annotations;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class AnnotationParsing {

	public static void main(String[] args) {
		try {
			for (Method method : AnnotationParsing.class.getClassLoader()
					.loadClass(("com.journaldev.annotations.AnnotationExample")).getMethods()) {
				// בודק אם קיימת אנוטציה MethodInfo עבור השיטה
				if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
					try {
						// עובר על כל האנוטציות הזמינות בשיטה
						for (Annotation anno : method.getDeclaredAnnotations()) {
							System.out.println("Annotation in Method '" + method + "' : " + anno);
						}
						MethodInfo methodAnno = method.getAnnotation(MethodInfo.class);
						if (methodAnno.revision() == 1) {
							System.out.println("Method with revision no 1 = " + method);
						}

					} catch (Throwable ex) {
						ex.printStackTrace();
					}
				}
			}
		} catch (SecurityException | ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

}

פלט של התוכנית לעיל הוא:

Annotation in Method 'public java.lang.String com.journaldev.annotations.AnnotationExample.toString()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=Main method, date=Nov 17 2012)
Method with revision no 1 = public java.lang.String com.journaldev.annotations.AnnotationExample.toString()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @java.lang.Deprecated()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=deprecated method, date=Nov 17 2012)
Method with revision no 1 = public static void com.journaldev.annotations.AnnotationExample.oldMethod()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.genericsTest() throws java.io.FileNotFoundException' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=10, comments=Main method, date=Nov 17 2012)

API השתקפות הוא כלי עוצמתי מאוד ומשמש בצורה רחבה ב-Java, מסגרות J2EE כמו Spring, Hibernate, JUnit, ניתן לבדוק את השתקפות ב-Java. זו כל הדוגמה לשימוש באנוטציות ב-Java, מקווה שלמדת משהו ממנה. עדכוני אנוטציות ב-Java:

1. התקנות של Servlet 3.0 הכינו תכונת השתמשות בהערות עבור הגדרת Servlet ופרמטרי init, קרא עוד ב- מדריך ל-Servlet ב-Java.
2. ניתן להשתמש בהערות ב- Struts 2 כדי להגדיר מחלקות פעולה ודפי תוצאה שלו, בדוק דוגמה פועלת ב- דוגמה ל-Struts 2 Hello World בהערות.

הפנייה: אתר Oracle