Si utilizzano (o definiscono) annotazioni non standard e per quale motivo. Che ne dici di annotazioni ricorsive?

Question

La domanda dice tutto.

Per gli esperti, c'è un motivo per cui il compilatore SUN java 5 accetta annotazioni ricorsive (contrariamente a langspec), mentre i compilatori successivi no? Voglio dire, quale potrebbe essere un argomento contro le annotazioni ricorsive.

Edit: un ricorsiva un'annotazione è qualcosa di simile:

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

Answer 1

In primo luogo - Non sono sicuro di cosa si intende per annotazioni ricorsive. Intendi annotazioni che possono contenere riferimenti ad altre annotazioni dello stesso tipo? Qualcosa di simile

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

(che sarebbe un esempio di dove mi piacerebbe utilizzarlo se fosse possibile ...)

Per quanto riguarda il mio uso di annotazioni personalizzati (e trasformatori): la generazione di codice .

Vedi http://code.google.com/p/javadude/wiki/Annotations

Per esempio, le proprietà JavaBean:

@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... 
} 

o un po 'di confusione in esempio

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 
} 

Vedi The drawbacks of annotation processing in Java? e la mia risposta ad esso per alcuni potenziali problemi con il loro utilizzo .

Answer 2

Ho utilizzato le annotazioni di recente, in quanto viene utilizzato pesantemente da Oracle Weblogic Server per modificare il comportamento dei servizi Web Java. C'è un elenco completo delle annotazioni che definiscono here. In particolare, finisco per usare più semplicemente il loro Policy annotation, poiché questo è il motivo del loro modello di sicurezza; puoi vedere i loro esempi dettagliati sul loro documentation page.

Non ho mai sentito parlare di annotazioni ricorsive.

Answer 3

Uso annotazioni non standard, in genere per contrassegnare i campi di classe come obiettivi per un processo riflessivo, ad esempio la memorizzazione nella cache nelle chiamate RPC o le procedure di inizializzazione specifiche. Non ho mai avuto bisogno di annotazioni ricorsive, comunque ... E penso che ci sia un potenziale problema con questo, dato che le annotazioni devono essere elaborate in tempo di definizione della classe, prima che gli inizializzatori standard siano pronti ... che credo fosse il motivo principale per limitare il contenuto delle annotazioni ai tipi di base ...

Answer 4

Non conosco alcun argomento valido contro l'autorizzazione delle annotazioni ricorsive in generale, a parte il fatto che alcuni casi patologici che potresti scrivere per caso potrebbero portare a cicli infiniti (durante la compilazione o il runtime) se non vietato.

javac proibisce le definizioni di annotazione ricorsiva semplicemente perché è quello che richiede la specifica. Che cosa la specifica dovrebbe dire in un futuro aggiornamento del JLS (per esempio, per JDK 7) è un'altra questione.

Così prega di leggere e votare:

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