Utilisez-vous (ou définir) annotations non standard, et pour quelle raison. Que diriez-vous des annotations récursifs?

Question

La question dit tout.

Pour les experts, est-il une raison pour laquelle le compilateur Java 5 SUN accepte annotations récursifs (contrairement au langspec), alors que les dernières compilateurs ne le font pas? Je veux dire, ce qui pourrait être un argument contre annotations récursives.

Edit: annotation récursive est quelque chose comme:

@Panel(layout=BorderLayout.class,
    nested={
        @Panel(region=NORTH, layout=FlowLayout.class, ...)
        @Panel(region=SOUTH, layout=FlowLayout.class, ...)
    }
)

Answer 1

D'abord - Je ne sais pas ce que vous entendez par annotations récursives. Voulez-vous dire des annotations qui peuvent contenir des références à d'autres annotations du même type? Quelque chose comme

@Panel(layout=BorderLayout.class,
    nested={
        @Panel(region=NORTH, layout=FlowLayout.class, ...)
        @Panel(region=SOUTH, layout=FlowLayout.class, ...)
    }
)

(ce qui serait un exemple où je voudrais l'utiliser s'il était possible ...)

En ce qui concerne mon utilisation des annotations personnalisées (et processeurs). Génération de code

Voir http://code.google.com/p/javadude/wiki/ annotations

Par exemple, les propriétés JavaBeans:

@Bean(
    properties={    
      @Property(name="name"),
      @Property(name="phone", bound=true),
      @Property(name="friend", type=Person.class, kind=PropertyKind.LIST)
    }
)
public class Person extends PersonGen {
    // generated superclass PersonGen will contain getters/setters
    //    field definitions, property change support...
}

ou un mélange dans exemple

package sample;

import java.util.List;

public interface IFlightAgent {
    List<IFlight> getFlight();
    void reserve(IFlight flight);
}

public interface ICarAgent {
    List<ICar> getCars();
    void reserve(ICar car);
}

public interface IHotelAgent {
    List<IHotel> getHotels();
    void reserve(IHotel hotel);
}

package sample;

import com.javadude.annotation.Bean;
import com.javadude.annotation.Delegate;

@Bean(delegates = {
    @Delegate(type = IHotelAgent.class,
              property = "hotelAgent",
              instantiateAs = HotelAgentImpl.class),
    @Delegate(type = ICarAgent.class,
              property = "carAgent",
              instantiateAs = CarAgentImpl.class),
    @Delegate(type = IFlightAgent.class,
              property = "flightAgent",
              instantiateAs = FlightAgentImpl.class)
    }
)
public class TravelAgent extends TravelAgentGen
    implements IHotelAgent, ICarAgent, IFlightAgent
{
    // generated superclass TravelAgentGen will create instances
    //   of the "instantiateAs" classes and delegate the interface
    //   methods to them
}

Voir Les inconvénients du traitement des annotations en Java? et mon répondre à pour certains problèmes potentiels avec leur utilisation.

Answer 2

J'utilise des annotations récemment, comme il est largement utilisé par Oracle Weblogic serveur modifier le comportement des services Web Java. Il y a une liste complète des annotations qu'ils définissent . Je finis en particulier, en utilisant leur le plus , puisque c'est ce que leur modèle de sécurité est basé sur des; vous pouvez voir leurs exemples détaillés sur leur .

Je ne l'ai jamais entendu parler d'annotations récursives.

Answer 3

J'utilise des annotations non standard, le plus souvent pour marquer les champs de classe comme cibles pour un processus réflexif, comme la mise en cache dans les appels RPC ou de procédures spécifiques initialisations. Je ne ai jamais eu besoin d'annotations récursifs, mais ... Et je pense qu'il ya un problème potentiel avec qui, comme les annotations doivent être traitées à temps de classe définition, avant initializers standard sont prêts ... qui était je pense que la principale raison de limiter le contenu d'annotation aux types de base ...

Answer 4

Je ne sais pas d'un bon argument contre les annotations permettant récursives en général, outre le fait que certains cas pathologiques que vous pourriez écrire par accident pourrait conduire à des boucles infinies (lors de la compilation ou de l'exécution) sinon interdite.

javac interdit les définitions d'annotation récursives simplement parce que c'est ce que le cahier des charges exige. Qu'est-ce que la spécification devrait dire dans une future mise à jour de la JLS (disons, pour 7 JDK) est une autre affaire.

Alors, s'il vous plaît lire et voter pour:

http://bugs.sun.com/view_bug.do?bug_id=6264216