Ho scritto in Java e C # per un po ', ma ho difficoltà a identificare i luoghi in cui l'utilizzo di un'annotazione personalizzata sarebbe vantaggioso.
Posso vedere che JUnit utilizza annotazioni nelle classi di test per identificare l'ordine in cui dovrebbe eseguire i metodi nelle classi di test, il che evita la necessità di una configurazione di qualche tipo.
Quali sono altri esempi di problemi che le annotazioni risolvono elegantemente?
Come altri hanno sottolineato, le annotazioni sono metadati su classi / proprietà / metodi. In generale, li trovo molto utili quando i dati devono essere trasformati tra il dominio Java e un altro dominio o formato, come
Gli ultimi due sono esempi reali del progetto su cui sto lavorando.
Un altro compito correlato è la convalida dei dati. Utilizziamo le annotazioni di Hibernate Validator (che è un'implementazione di JSR 303 - Bean Validation) per convalidare pezzi critici di i dati ricevuti dal mainframe sopra menzionato, prima di lasciarlo entrare nel nostro dominio.
Come altri hanno notato, tutte le informazioni rappresentate dalle annotazioni potrebbero in teoria essere rappresentate in altre forme, ad es. in file di configurazione distinti (in XML o in altro formato). Tuttavia, spesso è molto più comodo avere le annotazioni proprio nel codice, accanto all'entità cui si riferisce. Tipicamente (come negli esempi precedenti) i metadati rappresentati dalle annotazioni sono strettamente legati al codice. Quindi - una volta creato - molto raramente cambia indipendentemente dal codice corrispondente stesso. Quindi tenerlo fisicamente insieme al codice lo rende più pulito e più manutenibile.
A seconda delle annotazioni che utilizzi e del modo in cui esegui JUnit, JUnit analizza il classpath e esegue tutto con le annotazioni appropriate (o, nelle versioni della vecchia scuola, che implementano una determinata interfaccia)
Hai ragione, nel senso che le annotazioni sono per lo più utili per la configurazione - sono essenzialmente metadati sul metodo / classe. Ecco un esempio del mio lavoro: per qualche motivo non ricordo, avevamo bisogno di scaricare oggetti in un log, ma volevamo filtrare alcuni attributi. Abbiamo creato un'annotazione Loggable che potrebbe essere applicata a singoli getter o a una classe, quindi abbiamo utilizzato il reflection per determinare cosa scaricare e cosa no.
Mi azzarderei a indovinare che qualsiasi cosa tu possa fare con un'annotazione che potresti fare con una sorta di file di configurazione. Alcune annotazioni sono fondamentalmente commenti formalizzati (ad esempio, @Deprecated). Quindi il fatto che non riesci a trovare casi comuni non è davvero sorprendente.
Puoi anche aggiungerli come suggerimenti per gli strumenti di analisi del codice temporale statico ed eseguire. per esempio. @ThreadSafe, @Immutable e così via. Questi forniscono suggerimenti allo sviluppatore su come l'oggetto dovrebbe essere trattato / comportarsi e gli strumenti possono spesso dare un certo livello di sicurezza su quello.
Ho provato a utilizzare le annotazioni per fornire specifiche eseguibili per codificare e generare test unitari per il mio progetto algebra . Ad esempio, ho un'interfaccia con un metodo per aggiungere due oggetti insieme e le proprietà che ti aspetteresti dalle aggiunte sono contrassegnate come annotazioni:
interface Group<E> extends Set<E> {
@Commutative @Associative @Identity("zero") @Inverse("neg")
E plus (E, E);
E zero ();
E neg (E e);
}
Ho un processore di annotazioni (parzialmente implementato) che genera test per queste proprietà per qualsiasi classe che afferma di implementare questa interfaccia.
Questo è un esempio di annotazioni "utente": @Commutative , @Associative , ecc. Sono implementate come parte della libreria algebra, non come parte dello strumento di elaborazione delle annotazioni; generare nuove proprietà con i test è una semplice questione di aggiungere un nuovo tipo di annotazione con un metodo speciale che controlla la proprietà.
Le annotazioni sono state moderatamente adatte a questo compito, sebbene ci siano molte lacune. Ad esempio, le annotazioni java non hanno una nozione di ereditarietà, quindi il mio processore deve cercare esplicitamente le annotazioni su tutte le superinterfacce di una classe. Inoltre, Java non supporta la marcatura di un metodo con più copie della stessa annotazione, quindi non posso scrivere @DistributesOver("foo") e @DistributesOver("bar") sullo stesso metodo.
Le annotazioni sono solo metadati, personalmente preferisco le annotazioni alle configurazioni xml, ma non completamente xml off. Il mio consiglio usa annotazioni che renderebbero l'uso dei metadati più chiaro e trasparente. Come esempio, date un'occhiata alle annotazioni JPA, non è meglio dire che la vostra classe è un'entità piuttosto che raddrizzare un file xml su di esso e come si rapporta ad altri @entities. Ad esempio, Spring MVC @Controllers e @RequestMapping, è molto più facile scoprire cos'è la classe e cosa fa semplicemente guardandola, senza dover passare attraverso una pletora di file xml. È importante notare tuttavia che troppe annotazioni rendono il codice difficile da leggere e dovrebbero essere evitati quando possibile. Il mio consiglio, vai con il tuo istinto ma cerca sempre di rendere leggibile il tuo codice.
Spero che aiuti,
Peter
P.S. Non so cosa faccia Junit, non ho mai guardato il suo codice, ma presumo che ci sia una specie di scanner per classpath
Leggi altre domande sui tag java annotations