Creare le tue annotazioni in Java

articolo di Jonny Hackett 14 luglio 2014 11:09 Se programmi in Java e utilizzi uno dei framework più diffusi come Spring e Hibernate , allora hai già familiarità con l'uso delle annotazioni. Quando si lavora con un framework esistente, le annotazioni interne sono più che sufficienti. Ma cosa succede se hai bisogno di creare le tue annotazioni? Non molto tempo fa ho avuto un motivo per creare le mie annotazioni per un progetto che richiedeva la conferma di informazioni comuni da diversi database. Scenario Un'azienda disponeva di più database che archiviavano le stesse informazioni e aggiornavano i dati in modi diversi. Si prevedeva di combinare i dati in un unico database principale per eliminare i problemi associati all'ottenimento di dati da fonti diverse. Ma prima di iniziare il progetto, era necessario scoprire quanto non erano sincronizzati i dati e apportare le modifiche necessarie. Il primo passo è stato creare un report che mostrasse gli stessi dati in database diversi e confermasse i valori o evidenziasse i record che non corrispondevano, in base alle regole di riconciliazione stabilite. Di seguito è riportato un estratto dei principali requisiti al momento del progetto: • Confrontare i dati in diversi database per trovare gli stessi dati, come nome del cliente, nome dell'azienda o informazioni sulla directory. • Per impostazione predefinita, il valore dovrebbe essere esattamente lo stesso in tutti i database in base al tipo di dati. • Per alcuni campi volevamo solo mostrare che il valore era stato trovato, ma il valore non era stato confrontato. • Per gli altri campi volevamo solo confrontare il valore con quanto trovato e confermare i dati con i dati della fonte specificata. • Per i terzi campi, volevamo effettuare un confronto di dati complesso basato sul valore di altri campi all'interno del record. • Per il quarto tipo di campo, volevamo formattare i dati, ad esempio nel formato valuta $ 000.000,00. • Il rapporto doveva essere in formato MS Excel, ogni riga doveva contenere un valore proveniente da una fonte separata. Qualsiasi riga il cui valore non corrisponde alle condizioni di conferma dei dati deve essere evidenziata in giallo. Annotazioni Dopo aver letto i requisiti e aver elaborato alcune idee diverse su ciò che era richiesto, ho deciso di utilizzare le annotazioni che avrebbero attivato la configurazione del confronto dei dati e il processo di reporting. Avevamo bisogno di una soluzione semplice, ma flessibile ed estensibile. Queste annotazioni saranno a livello di campo e mi piace il fatto che la configurazione non sarà nascosta in un file da qualche parte nel percorso della classe. Potrò invece vedere le annotazioni associate al campo in modo da sapere esattamente come verrà elaborato. In parole povere, un'annotazione non sarà altro che un marker, metadati che forniranno informazioni, ma non influenzeranno direttamente il funzionamento del codice stesso. Se hai già programmato in Java, dovresti avere familiarità con l'uso delle annotazioni, ma potresti non aver mai avuto bisogno di crearne di tue. Per fare ciò, è necessario creare un nuovo tipo che utilizzi il tipo Java @interface , che conterrà elementi che a loro volta definiscono i dettagli dei metadati. Ecco un esempio di progetto: 1@Target(ElementType.FIELD) 2@Retention(RetentionPolicy.RUNTIME) 3public @interface ReconField { 4 5 /** 6 * Значение, которое определяет из Howого источника сравниваются данные, or будет использоваться для 7 отображения значения or для ссылки на правило. 8 * 9 * @return Значение, если источники должны быть сравнены, по умолчанию true. 10 */ 11 boolean compareSources() default true; 12 13 /** 14 * Значение показывает формат, который используется для отображения значения в отчете. 15 * 16 * @return Установленный формам, по умолчанию native. 17 */ 18 ReconDisplayFormat displayFormat() default ReconDisplayFormat.NATIVE; 19 20 /** 21 * Значение, показывающее meaning ID используемого поля для одинаковых значений из источника до поля. 22 * 23 * @return ID поля. 24 */ 25 String id(); 26 27 /** 28 * Значение, показывающее ярлык, который будет отображается в отчете для поля. 29 * 30 * @return Значение ярлыка, по умолчанию пустая строка. 31 */ 32 String label() default ""; 33 34 /** 35 * Значение, показывающее источник, который должен быть сравнен на предмет различий. 36 * 37 * @return Список источников для сравнения. 38 */ 39 ReconSource[] sourcesToCompare() default {}; 40 } Questa è l'annotazione principale con cui avviare il processo di confronto dei dati. Contiene gli elementi di base richiesti, come richiesto, per confrontare dati provenienti da diverse origini dati. @ReconField dovrebbe gestire la maggior parte di ciò di cui abbiamo bisogno, ad eccezione dei confronti di dati più complessi, di cui parleremo più avanti. La maggior parte di questi elementi sono spiegati dai commenti nel codice. Indipendentemente da ciò, un paio delle annotazioni principali nel nostro @ReconField devono essere spiegate separatamente. • @Target – Questa annotazione consentirà di specificare gli elementi Java a cui applicare l'annotazione. I possibili tipi da utilizzare sono: ANNOTATION_TYPE, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER e TYPE. Nella nostra annotazione @ReconField per il livello FIELD. • @Retention – Questa annotazione consentirà di specificare quando l'annotazione sarà disponibile. I valori possibili sono CLASS, RUNTIME e SOURCE. Poiché elaboreremo le annotazioni in RUNTIME, dobbiamo impostare questi valori. Il processo di convalida dei dati eseguirà una query su ciascun database e quindi visualizzerà i risultati nei dati complessivi, ovvero tutti i campi per un particolare tipo di record. Un'annotazione per ciascun campo nei dati condivisi indicherà al processore come confrontare i dati per quel particolare campo, nonché il valore trovato in ciascun database. Diamo un'occhiata ad alcuni esempi di come queste annotazioni possono essere utilizzate per varie configurazioni di confronto dei dati. Per confermare che un valore esiste e corrisponde esattamente in ciascuna origine dati, devi semplicemente fornire un ID campo e un'etichetta che verranno visualizzati nel campo del rapporto. 1 @ReconField(id = CUSTOMER_ID, label = "Customer ID") 2 private String customerId; Per visualizzare i valori trovati da ciascuna origine dati, ma effettuare confronti tra i dati, è necessario specificare un elemento compareSources e impostare il valore su false. 1 @ReconField(id = NAME, label = "NAME", compareSources = false) 2 private String name; Per confermare che un valore viene trovato in una determinata origine dati, ma non in tutte, è necessario utilizzare l' elemento sourceToCompare . Verranno visualizzati tutti i valori trovati, ma qualsiasi confronto dei dati nelle origini dati verrà eseguito in base all'elenco degli elementi. Questo è il caso in cui alcuni dati non vengono salvati in tutte le origini dati. ReconSource è un'enumerazione in cui le origini dati sono disponibili per il confronto. 1 @ReconField(id = PRIVATE_PLACEMENT_FLAG, label = "PRIVATE PLACEMENT FLAG", sourcesToCompare ={ 2 ReconSource.LEGACY, ReconSource.PACE }) private String privatePlacementFlag; Ora che abbiamo soddisfatto i requisiti di base, dobbiamo eseguire confronti di dati più complessi specifici del campo. Per fare ciò creeremo una seconda annotazione che attiverà l'elaborazione delle regole. 1 @Target(ElementType.FIELD) 2 @Retention(RetentionPolicy.RUNTIME) 3 public @interface ReconCustomRule { 4 5 /** 6 * Значение, указывающее используемые параметры, прописанные обработчику правила, meaning по умолчанию - 7 отсутствие параметров. 8 * 9 * @return The String[] параметры, прописанные обработчику правила 10 */ 11 String[] params() default {}; 12 13 /** 14 * Значение, указывающее класс обработчика правила, которое используется для сравнения значений из 15 каждого источника данных. 16 * 17 * @return Класс обработчика правила 18 */ 19 Class processor() default DefaultReconRule.class; 20 } Molto simile all'annotazione precedente, una grande differenza è che in @ReconCustomRule specifichiamo una classe che eseguirà il confronto dei dati all'avvio del processo di ricognizione. Puoi solo specificare la classe che verrà utilizzata, in modo che il tuo gestore assegni un valore e inizializzi qualunque classe tu specifichi. La classe specificata in questa annotazione utilizzerà l'interfaccia della regola, che a sua volta verrà utilizzata dal gestore per eseguire la regola. Diamo un'occhiata ad un paio di esempi di questa annotazione. In questo esempio, stiamo utilizzando una regola che controllerà i cambi di valuta non statunitensi e in questo caso salterà il confronto dei dati. Per fare ciò, dobbiamo controllare il campo Paese nello stesso record. 1 @ReconField(id = STREET_CUSIP, label = "STREET CUSIP", compareSources = false) 2 @ReconCustomRule(processor = SkipNonUSExchangeComparisonRule.class) 3 private String streetCusip; Ecco un esempio in cui impostiamo i parametri della regola, in questo caso il valore di tolleranza. Per confrontare i nostri dati, il valore confrontato non può discostarsi di più di 1.000. L'utilizzo di un parametro per specificare un valore di tolleranza ci consentirà di utilizzare le stesse regole per diversi campi, con valori di tolleranza diversi. L'unico problema è che questi parametri sono statici e non possono essere dinamici a causa della natura dell'annotazione. 1 @ReconField(id = USD_MKT_CAP, label = "MARKET CAP USD", displayFormat = 2 ReconDisplayFormat.NUMERIC_WHOLE, sourcesToCompare = 3 { ReconSource.LEGACY, ReconSource.PACE, ReconSource.BOB_PRCM }) 4 @ReconCustomRule(processor = ToleranceAmountRule.class, params = { "10000" }) 5 private BigDecimal usdMktCap; Come puoi vedere, abbiamo aggiunto una certa flessibilità al processo di confronto dei dati provenienti da database diversi utilizzando due annotazioni abbastanza semplici. In questo caso particolare, le annotazioni guidano il processo di confronto dei dati, in modo che essenzialmente valutiamo le annotazioni che troviamo nei dati condivisi e le utilizziamo per guidare l'elaborazione. Conclusione Ci sono molti articoli sulle annotazioni in Java, cosa fanno e quali sono le regole per usarle. In questo articolo ho voluto mostrare, attraverso degli esempi, perché dovresti utilizzarli e come puoi trarne beneficio. Tieni presente che questo è solo l'inizio. Una volta deciso di creare annotazioni, dovrai capire come utilizzarle nel modo più efficace. Nella Parte 2 ti mostrerò come elaborare le annotazioni utilizzando la riflessione Java. — Jonny Hackett, asktheteam@keyholesoftware.com articolo originale http://www.javacodegeeks.com/2014/07/creating-your-own-java-annotations.html