Comment assurer les annotations de l'ordre d'exécution de java?

Vous pouvez vous assurer que la commande de votre custom avec annotations @Afin d'annotation.

https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/annotation/Order.html

Exemple:

Première annotation:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CustomAnnotation {
}

@Aspect
@Component
@Order(value = 1)
public class CustomAnnotationInterceptor {

    @Before("@annotation(customAnnotation )")
    public void intercept(JoinPoint method, CustomAnnotation customAnnotation ) {
        //Code here
    }
}

Deuxième annotation:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CustomAnnotationTwo {
}

@Aspect
@Component
@Order(value = 2)
public class CustomAnnotationInterceptorTwo {

    @Before("@annotation(customAnnotationTwo )")
    public void intercept(JoinPoint method, CustomAnnotationTwo customAnnotationTwo ) {
        //Code here
    }

:

@CustomAnnotationTwo
@CustomAnnotation
public void someMethod(){
}

Dans cet exemple, CustomAnnotationInterceptor exécuté en premier.

OriginalL'auteur Roman

De http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/aop.html#aop-ataspectj-advice-ordering

Spring AOP suit les mêmes règles de priorité comme AspectJ pour déterminer l'ordre des conseils de l'exécution. La priorité la plus élevée des conseils s'exécute en premier "sur le chemin" (donc deux morceaux avant de les conseils, l'un avec la plus haute priorité s'exécute en premier). "Sur le chemin" à partir d'un point de rejoindre, la priorité la plus élevée des conseils s'exécute en dernier (donc deux pièces d'après les conseils, l'un avec la priorité la plus élevée sera exécuté à la seconde).

Quand deux morceaux de conseils définies dans les différents aspects à la fois besoin de courir à la même rejoindre le point, sauf spécification contraire, l'ordre d'exécution n'est pas défini. Vous pouvez contrôler l'ordre d'exécution en précisant la priorité. Cela se fait dans les conditions normales de Printemps façon, soit par la mise en œuvre de l'org.springframework.de base.Commandé interface dans l'aspect de la classe ou de l'annotation avec l'Ordre d'annotation. Étant donné deux aspects, l'aspect de retourner la valeur la plus faible de Commandé.getValue() (ou l'annotation de la valeur) a la priorité plus élevée.

Quand deux morceaux de conseils définies dans le même aspect à la fois besoin de courir à la même rejoindre le point, l'ordre n'est pas défini (car il n'y a aucun moyen de récupérer l'ordre de déclaration, par la réflexion, pour javac-classes compilées). Envisager l'effondrement de tels conseils dans l'un des conseils de méthode pour rejoindre le point dans chaque aspect de la classe, ou de refactoriser les pièces de conseils en aspect distinct des classes - qui peut être commandé auprès de l'aspect de niveau.

OriginalL'auteur Emerson Farrugia

Caisse https://stackoverflow.com/a/30222541/810109: Au moins dans Java 8, vous pouvez récupérer les annotations dans un ordre garanti, de sorte que vous devez les déclarer dans le bon ordre.

OriginalL'auteur mkurz

Première annotation:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface FirstAnnotation {
  String value() default "";
}

Deuxième annotation:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface SecondAnnotation {
  String value() default "";
}

Exemple d'utilisation:

public class Test {
@SecondAnnotation("second annotation")
@FirstAnnotation("first annotation")
private String annotatedField1 = "value of field 1";
@SecondAnnotation("second annotation")
@FirstAnnotation("first annotation")
private String annotatedField2 = "value of field 2";
@SecondAnnotation("second annotation")
private String annotatedField3 = "value of field 3";
@FirstAnnotation("first annotation")
private String annotatedField4 = "value of field 4";
//Sample
public static void processAnnotatedFields( final Object obj ) throws IllegalArgumentException, IllegalAccessException {
for ( final Field field : getFieldsFornAnotation( obj, FirstAnnotation.class ) ) {
//Do something with fields that are annotated with @FirstAnnotation
final FirstAnnotation an = field.getAnnotation( FirstAnnotation.class );
System.out.print( "@" +an.annotationType().getSimpleName()+ "(" +an.value()+ "): " );
System.out.println( field.getName()+ " = '" +field.get(obj)+ "'" );
}
System.out.println();
for ( final Field field : getFieldsFornAnotation( obj, SecondAnnotation.class ) ) {
//Do something with fields that are annotated with @SecondAnnotation
final SecondAnnotation an = field.getAnnotation( SecondAnnotation.class );
System.out.print( "@" +an.annotationType().getSimpleName()+ "(" +an.value()+ "): " );
System.out.println( field.getName()+ " = '" +field.get(obj)+ "'" );
}
}
/**
* Collect object fields annotated with "annotationClass"
* This can be saved in static map to increase performance.
*/
private static final Set<Field> getFieldsFornAnotation( final Object o, final Class<? extends Annotation> annotationClass ) {
final Set<Field> fields = new LinkedHashSet<Field>();
if ( o == null || annotationClass == null )
return fields;
for (final Field field : o.getClass().getDeclaredFields()) {
if (field.isAnnotationPresent(annotationClass)) {
field.setAccessible( true );
fields.add( field );
}
}
return fields;
}
public static void main(final String[] args) throws IllegalArgumentException, IllegalAccessException {
processAnnotatedFields( new Test() );
}
}

Résultat/sortie:

@FirstAnnotation(first annotation): annotatedField1 = 'value of field 1'
@FirstAnnotation(first annotation): annotatedField2 = 'value of field 2'
@FirstAnnotation(first annotation): annotatedField4 = 'value of field 4'
@SecondAnnotation(second annotation): annotatedField1 = 'value of field 1'
@SecondAnnotation(second annotation): annotatedField2 = 'value of field 2'
@SecondAnnotation(second annotation): annotatedField3 = 'value of field 3'

OriginalL'auteur mdolanci