Maison > Java > javaDidacticiel > le corps du texte

Introduction à la définition et à l'utilisation des annotations Java (exemples de code)

不言
Libérer: 2019-02-21 14:41:00
avant
2506 Les gens l'ont consulté

Le contenu de cet article concerne la définition et l'utilisation des annotations Java (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Les annotations Java sont beaucoup utilisées dans les projets réels, surtout après avoir utilisé Spring.

Cet article présentera la syntaxe des annotations Java et des exemples d'utilisation des annotations dans Spring.

Syntaxe d'annotation

Exemple d'annotation

Prenons l'annotation @Test dans Junit comme exemple

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
    long timeout() default 0L;
}
Copier après la connexion

Vous pouvez voir que l'annotation @Test a @Target() et @Retention() deux annotations.
Ce type d'annotation qui annote les annotations est appelé méta-annotation.
Cela a la même signification que les données qui déclarent les données, appelées métadonnées. Le format des annotations après

est

修饰符 @interface 注解名 {   
    注解元素的声明1 
    注解元素的声明2   
}
Copier après la connexion

La déclaration de l'élément annoté a deux formes

type elementName();
type elementName() default value;  // 带默认值
Copier après la connexion

Méta-annotations communes

@Target Annotation

@Target L'annotation est utilisée pour limiter les éléments auxquels l'annotation peut être appliquée sans que @Target puisse être appliquée à n'importe quel élément.

Vous pouvez voir tous les java.lang.annotation.ElementType éléments acceptés dans la @Target classe

  • TYPE Utilisez

    sur [classe, interface, annotation]
  • FIELD Utilisez

  • METHOD sur [Champs, constantes d'énumération] Utilisez

  • Utilisez PARAMETER

  • sur [Paramètre] Utilisez CONSTRUCTOR

  • Utilisez

    LOCAL_VARIABLE

  • sur [Variables locales] Utilisez

    ANNOTATION_TYPE

  • sur [Package]

    PACKAGE

  • Utilisé sur [paramètres de type] Introduit dans Java 1.8

    TYPE_PARAMETER

  • Utilisé sur [partout où un type est déclaré] Java 1.8 a introduit le

    TYPE_USE

annotation dont l'utilisation est autorisée uniquement sur les méthodes.

@Test

Si vous souhaitez prendre en charge plusieurs éléments, transmettez plusieurs valeurs.
@Target(ElementType.METHOD)
public @interface Test { ... }
Copier après la connexion

De plus, les méta-annotations sont également des annotations et sont conformes à la syntaxe des annotations, telles que les annotations
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface MyAnnotation { ... }
Copier après la connexion
.

@Target indique que l'annotation
ne peut être utilisée que sur les annotations. @Target(ElementType.ANNOTATION_TYPE)@Target

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    ElementType[] value();
}
Copier après la connexion
Annotation

@Retention

Spécifie la durée pendant laquelle l'annotation doit être conservée, la valeur par défaut est

. @RetentionTous les éléments peuvent être vus dans RetentionPolicy.CLASS
java.lang.annotation.RetentionPolicy

  • Non inclus dans le fichier de classe

    SOURCE

  • Inclus dans le fichier de classe, la machine virtuelle n'est pas chargée

    CLASS

  • Il est inclus dans le fichier de classe, chargé par la machine virtuelle, et peut être obtenu grâce à l'API de réflexion

    RUNTIME

Les annotations seront chargées dans la machine virtuelle et pourront être obtenues via le code

@Test

@Retention(RetentionPolicy.RUNTIME)
public @interface Test { ... }
Copier après la connexion
Les annotations

@Documented sont principalement utilisées pour l'archivage identification des outils. Les éléments annotés peuvent être documentés à l'aide de

ou d'outils similaires.

Javadoc

Annotation

@InheritedAvec l'annotation de

annotation ajoutée, les sous-classes de la classe annotée auront également cette annotation

@InheritedAnnotation

Classe parent
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface MyAnnotation { ... }
Copier après la connexion

Sous-classe
@MyAnnotation 
class Parent { ... }
Copier après la connexion
héritera des

ajoutées aux ChildParent@MyAnnotation

class Child extends Parent { ... }
Copier après la connexion
Annotations

@RepeatableAnnotations introduites dans Java 1.8 marque les annotations comme réutilisables.

Note 1

Note 2
public @interface MyAnnotations {   
    MyAnnotation[] value();   
}
Copier après la connexion

À utiliser lorsque
@Repeatable(MyAnnotations.class)
public @interface MyAnnotation {   
    int value();
}
Copier après la connexion
est utilisé

@Repeatable()

Non utilisé
@MyAnnotation(1)
@MyAnnotation(2)
@MyAnnotation(3)
public class MyTest { ... }
Copier après la connexion
Lorsque en utilisant,

supprimez la méta annotation @Repeatable() @MyAnnotation@Repeatable

Cette annotation est toujours très utile et rend notre code beaucoup plus simple
@MyAnnotations({
    @MyAnnotation(1), 
    @MyAnnotation(2),
    @MyAnnotation(3)})
public class MyTest { ... }
Copier après la connexion
Cette méta-. l'annotation est également utilisée.


Types d'élémentsSpring@ComponentScanTypes d'éléments pris en charge

8 types de données de base (

,
    ,
  • ,

    , byte, short, char, int) longfloatdoubleboolean

  • String

  • Class

  • enumType d'annotation

  • Tableau (tous les tableaux des types ci-dessus)

  • Exemple

  • Classe Enum

Annotation 1

public enum Status {
    GOOD,
    BAD
}
Copier après la connexion
Annotation 2

@Target(ElementType.ANNOTATION_TYPE)
public @interface MyAnnotation1 {
    int val();
}
Copier après la connexion
Quand utilisé, les éléments sans valeurs par défaut doivent transmettre des valeurs

@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();
    
}
Copier après la connexion

Annotations intégrées

@MyAnnotation2(
        cla = String.class,
        enu = Status.BAD,
        anno = @MyAnnotation1(val = 2),
        arr = {"a", "b"})
public class MyTest { ... }
Copier après la connexion

AnnotationsJava

indiquent au compilateur que cela est une méthode de classe parent prioritaire. Si la classe parent supprime cette méthode, la sous-classe signalera une erreur.

@Override

L'annotation

indique que l'élément annoté est obsolète. L'annotation

@Deprecated

indique au compilateur d'ignorer l'avertissement.

@SuppressWarnings

Annotations

Annotations introduites dans Java 1.8. Cette annotation oblige le compilateur à

vérifier si une interface est conforme au standard d'interface fonctionnelle. @FunctionalInterface

特别的注解

有两种比较特别的注解

  • 标记注解 : 注解中没有任何元素,使用时直接是 @XxxAnnotation, 不需要加括号

  • 单值注解 : 注解只有一个元素,且名字为value,使用时直接传值,不需要指定元素名@XxxAnnotation(100)

利用反射获取注解

JavaAnnotatedElement接口中有getAnnotation()等获取注解的方法。
MethodFieldClassPackage等类均实现了这个接口,因此均有获取注解的能力。

例子

注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
public @interface MyAnno {   
    String value();   
}
Copier après la connexion

被注解的元素

@MyAnno("class")
public class MyClass {
    
    @MyAnno("feild")
    private String str;
    
    @MyAnno("method")
    public void method() { }
    
}
Copier après la connexion

获取注解

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());
    }
    
}
Copier après la connexion

Spring中使用自定义注解

注解本身不会有任何的作用,需要有其他代码或工具的支持才有用。

需求

设想现有这样的需求,程序需要接收不同的命令CMD
然后根据命令调用不同的处理类Handler
很容易就会想到用Map来存储命令和处理类的映射关系。

由于项目可能是多个成员共同开发,不同成员实现各自负责的命令的处理逻辑。
因此希望开发成员只关注Handler的实现,不需要主动去Map中注册CMDHandler的映射。

最终效果

最终希望看到效果是这样的

@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");
    }
}
Copier après la connexion

开发人员增加自己的Handler,只需要创建新的类并注上@CmdMapping(Cmd.Xxx)即可。

具体做法

具体的实现是使用Spring和一个自定义的注解
定义@CmdMapping注解

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface CmdMapping {
    int value();   
}
Copier après la connexion

@CmdMapping中有一个int类型的元素value,用于指定CMD。这里做成一个单值注解。
这里还加了Spring@Component注解,因此注解了@CmdMapping的类也会被Spring创建实例。

然后是CMD接口,存储命令。

public interface Cmd {
    int REGISTER = 1;
    int LOGIN    = 2;
    int LOGOUT   = 3;
}
Copier après la connexion

之后是处理类接口,现实情况接口会复杂得多,这里简化了。

public interface ICmdHandler { 
    void handle();   
}
Copier après la connexion

上边说过,注解本身是不起作用的,需要其他的支持。下边就是让注解生效的部分了。
使用时调用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;
    }

}
Copier après la connexion

主要工作都是Spring做,这里只是将实例化后的对象putMap中。

测试代码

@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();
    }
}
Copier après la connexion

> 完整项目

总结

可以看到使用注解能够写出很灵活的代码,注解也特别适合做为使用框架的一种方式。
所以学会使用注解还是很有用的,毕竟这对于上手框架或实现自己的框架都是非常重要的知识。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Étiquettes associées:
source:segmentfault.com
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal