Nel tentativo di progettare componenti il più possibile riutilizzabili, ho iniziato a pensare recentemente alla possibilità delle cosiddette "annotazioni dell'adattatore". Con questo intendo l'applicazione del classico pattern OO Adapter alle annotazioni Java. Ad esempio, supponiamo di avere una suite di test unitaria interamente basata su JUnit. Avrei bisogno di annotare tutti i miei metodi di prova come segue:Annotazioni dell'adattatore Java
public class WidgetTest
{
@Test
public void test_WidgetConstructor()
{
// ...
}
}
Ma cosa succede se, dopo aver creato una suite di test con, diciamo, 1000 classi di test, decido che voglio iniziare a test di unità con una certa marca nuovo super framework di test -Cool che impone a tutti i metodi di prova per essere annotato come segue:
public class WidgetTest
{
@SuperCoolUnitTest(someParam="true")
public void test_WidgetConstructor()
{
// ...
}
}
Ora, in questo particolare esempio si potrebbe essere perfettamente fattibile per cercare-n-sostituire i vecchi annotazioni per quelli nuovi, ma in un'applicazione pratica, questa non sarebbe una soluzione fattibile.
Quindi sarebbe possibile per me "Wrap" La mia unità annotazioni di prova con qualcosa homegrown, come:
public class WidgetTest
{
@HomegrownUnitTestAnnotation
public void test_WidgetConstructor()
{
// ...
}
}
e poi costruire il mio proprio processore annotazione che convertire le istanze di @HomegrownUnitTestAnnotation a qualsiasi annotazione Attualmente bisogno (@Test o @SuperCoolUnitTest(someParam="true"))?
Ovviamente, questa domanda si applica a tutte le annotazioni, non solo a quelle fornite da JUnit. In sostanza, sto chiedendo se è possibile avvolgere le annotazioni di terze parti per motivi di riusabilità/separazione delle preoccupazioni/ecc. Grazie in anticipo!
Quindi il "nuovissimo framework di test" è necessario per eseguire il dump dell'API JUnit (come Assert ...)? – home
Esistono molti casi in cui solo le annotazioni vengono utilizzate per decorare classi e metodi, senza che vengano invocate chiamate API all'interno di tali metodi. Come ho affermato nella domanda, questo non è uno scenario specifico di JUnit, sto chiedendo se è possibile anche creare processori di annotazione in grado di mappare un tipo di annotazione a un altro. – IAmYourFaja
Ahhhhh molto carino! Grazie a casa. Immagino che la risposta breve alla mia domanda sia "sì", anche se mi chiedo se c'è un modo "puro Java" (non Spring) per farlo. Ovviamente, però, se Spring lo fa con queste meta-annotazioni, allora deve essere possibile creare una soluzione per la casa. Se cambi il tuo commento in una risposta, lo controllerò felicemente per te. Grazie ancora. – IAmYourFaja