Der Inhalt dieses Artikels befasst sich mit der Definition und Verwendung von Java-Anmerkungen (Codebeispiele). Ich hoffe, dass er für Freunde hilfreich ist.
Java-Anmerkungen werden häufig in tatsächlichen Projekten verwendet, insbesondere nach der Verwendung von Spring.
In diesem Artikel werden die Syntax von Java-Annotationen und Beispiele für die Verwendung von Annotationen in Spring vorgestellt.Annotationssyntax
Beispiel einer Annotation
Nehmen Sie die @Test-Annotation in Junit als Beispiel
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
long timeout() default 0L;
}Sie können sehen, dass die @Test-Annotation @Target() hat und @Retention()Zwei Anmerkungen.
Diese Art von Annotation, die Annotationen annotiert, wird Meta-Annotation genannt.
Es hat die gleiche Bedeutung wie die Daten, die die Daten deklarieren, die als Metadaten bezeichnet werden. Das Format der Anmerkung nach
ist
修饰符 @interface 注解名 {
注解元素的声明1
注解元素的声明2
}Die Deklaration des annotierten Elements hat zwei Formen
type elementName(); type elementName() default value; // 带默认值
@TargetAnmerkung@Target-Anmerkung wird verwendet, um einzuschränken, auf welche Elemente die Anmerkung angewendet werden kann. Anmerkungen ohne @Target können auf jedes Element angewendet werden.
Sie können alle java.lang.annotation.ElementType akzeptierten Elemente in der @Target-Klasse sehen
TYPE Verwenden Sie
FIELD Verwenden Sie
METHOD für [Felder, Aufzählungskonstanten]. Verwenden Sie
Verwenden Sie PARAMETER
für [Parameter]. Verwenden Sie CONSTRUCTOR
LOCAL_VARIABLE
ANNOTATION_TYPE
PACKAGE
TYPE_PARAMETER
TYPE_USE
@Target(ElementType.METHOD)
public @interface Test { ... }Wenn Sie mehrere Elemente unterstützen möchten, übergeben Sie mehrere Werte. @Test
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface MyAnnotation { ... }-Annotationen.
gibt an, dass die Anmerkung @Target nur für Anmerkungen verwendet werden kann.
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
ElementType[] value();
}@Target(ElementType.ANNOTATION_TYPE)@TargetAnnotation@RetentionGibt an, wie lange die Anmerkung aufbewahrt werden soll, der Standardwert ist Alle Elemente sind zu sehen in @RetentionRetentionPolicy.CLASSjava.lang.annotation.RetentionPolicy
SOURCE
CLASS
RUNTIME
@Retention(RetentionPolicy.RUNTIME)
public @interface Test { ... }@TestAnmerkungen
@Documented oder ähnlichen Tools dokumentiert werden. JavadocAnnotation
@Inherited annotation erhalten Unterklassen der annotierten Klasse auch diese AnnotationAnnotation@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface MyAnnotation { ... }@MyAnnotation
class Parent { ... }erbt die
, die zuChild
class Child extends Parent { ... }Parent@MyAnnotationAnnotation@Repeatable
public @interface MyAnnotations {
MyAnnotation[] value();
}@Repeatable(MyAnnotations.class)
public @interface MyAnnotation {
int value();
} verwendet wird @Repeatable()
@MyAnnotation(1)
@MyAnnotation(2)
@MyAnnotation(3)
public class MyTest { ... } nicht verwendet wird, @Repeatable() Entfernen Sie die @MyAnnotation-Meta-Annotation @Repeatable
@MyAnnotations({
@MyAnnotation(1),
@MyAnnotation(2),
@MyAnnotation(3)})
public class MyTest { ... }-Annotation von Spring verwendet diese Meta-Annotation ebenfalls. @ComponentScan
, byte, short, char , int, long, float, double) boolean
String
Class
enum
public enum Status {
GOOD,
BAD
}@Target(ElementType.ANNOTATION_TYPE)
public @interface MyAnnotation1 {
int val();
}@Target(ElementType.TYPE)
public @interface MyAnnotation2 {
boolean boo() default false;
Class<?> cla() default Void.class;
Status enu() default Status.GOOD;
MyAnnotation1 anno() default @MyAnnotation1(val = 1);
String[] arr();
}@MyAnnotation2(
cla = String.class,
enu = Status.BAD,
anno = @MyAnnotation1(val = 2),
arr = {"a", "b"})
public class MyTest { ... }Java
@Override
@Deprecated
@SuppressWarnings
@FunctionalInterface
zu prüfen, ob eine Schnittstelle dem funktionalen Schnittstellenstandard entspricht. javac
有两种比较特别的注解
标记注解 ： 注解中没有任何元素，使用时直接是 @XxxAnnotation, 不需要加括号
单值注解 ： 注解只有一个元素，且名字为value，使用时直接传值，不需要指定元素名@XxxAnnotation(100)
Java的AnnotatedElement接口中有getAnnotation()等获取注解的方法。
而Method，Field，Class，Package等类均实现了这个接口，因此均有获取注解的能力。
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
public @interface MyAnno {
String value();
}@MyAnno("class")
public class MyClass {
@MyAnno("feild")
private String str;
@MyAnno("method")
public void method() { }
}public class Test {
public static void main(String[] args) throws Exception {
MyClass obj = new MyClass();
Class<?> clazz = obj.getClass();
// 获取对象上的注解
MyAnno anno = clazz.getAnnotation(MyAnno.class);
System.out.println(anno.value());
// 获取属性上的注解
Field field = clazz.getDeclaredField("str");
anno = field.getAnnotation(MyAnno.class);
System.out.println(anno.value());
// 获取方法上的注解
Method method = clazz.getMethod("method");
anno = method.getAnnotation(MyAnno.class);
System.out.println(anno.value());
}
}Spring中使用自定义注解注解本身不会有任何的作用，需要有其他代码或工具的支持才有用。
设想现有这样的需求，程序需要接收不同的命令CMD，
然后根据命令调用不同的处理类Handler。
很容易就会想到用Map来存储命令和处理类的映射关系。
由于项目可能是多个成员共同开发，不同成员实现各自负责的命令的处理逻辑。
因此希望开发成员只关注Handler的实现，不需要主动去Map中注册CMD和Handler的映射。
最终希望看到效果是这样的
@CmdMapping(Cmd.LOGIN)
public class LoginHandler implements ICmdHandler {
@Override
public void handle() {
System.out.println("handle login request");
}
}
@CmdMapping(Cmd.LOGOUT)
public class LogoutHandler implements ICmdHandler {
@Override
public void handle() {
System.out.println("handle logout request");
}
}开发人员增加自己的Handler，只需要创建新的类并注上@CmdMapping(Cmd.Xxx)即可。
具体的实现是使用Spring和一个自定义的注解
定义@CmdMapping注解
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface CmdMapping {
int value();
}@CmdMapping中有一个int类型的元素value，用于指定CMD。这里做成一个单值注解。
这里还加了Spring的@Component注解，因此注解了@CmdMapping的类也会被Spring创建实例。
然后是CMD接口，存储命令。
public interface Cmd {
int REGISTER = 1;
int LOGIN = 2;
int LOGOUT = 3;
}之后是处理类接口，现实情况接口会复杂得多，这里简化了。
public interface ICmdHandler {
void handle();
}上边说过，注解本身是不起作用的，需要其他的支持。下边就是让注解生效的部分了。
使用时调用handle()方法即可。
@Component
public class HandlerDispatcherServlet implements
InitializingBean, ApplicationContextAware {
private ApplicationContext context;
private Map<Integer, ICmdHandler> handlers = new HashMap<>();
public void handle(int cmd) {
handlers.get(cmd).handle();
}
public void afterPropertiesSet() {
String[] beanNames = this.context.getBeanNamesForType(Object.class);
for (String beanName : beanNames) {
if (ScopedProxyUtils.isScopedTarget(beanName)) {
continue;
}
Class<?> beanType = this.context.getType(beanName);
if (beanType != null) {
CmdMapping annotation = AnnotatedElementUtils.findMergedAnnotation(
beanType, CmdMapping.class);
if(annotation != null) {
handlers.put(annotation.value(), (ICmdHandler) context.getBean(beanType));
}
}
}
}
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.context = applicationContext;
}
}主要工作都是Spring做，这里只是将实例化后的对象put到Map中。
测试代码
@ComponentScan("pers.custom.annotation")
public class Main {
public static void main(String[] args) {
AnnotationConfigApplicationContext context
= new AnnotationConfigApplicationContext(Main.class);
HandlerDispatcherServlet servlet = context.getBean(HandlerDispatcherServlet.class);
servlet.handle(Cmd.REGISTER);
servlet.handle(Cmd.LOGIN);
servlet.handle(Cmd.LOGOUT);
context.close();
}
}> 完整项目
可以看到使用注解能够写出很灵活的代码，注解也特别适合做为使用框架的一种方式。
所以学会使用注解还是很有用的，毕竟这对于上手框架或实现自己的框架都是非常重要的知识。
Das obige ist der detaillierte Inhalt vonEinführung in die Definition und Verwendung von Java-Annotationen (Codebeispiele). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
