Dove devo inserire l'annotazione @Transactional: in una definizione di interfaccia o in una classe di implementazione?

La domanda dal titolo in codice:

@Transactional (readonly = true)
public interface FooService {
   void doSmth ();
}


public class FooServiceImpl implements FooService {
   ...
}

vs

public interface FooService {
   void doSmth ();
}

@Transactional (readonly = true)
public class FooServiceImpl implements FooService {
   ...
}

Da http://static.springsource.org/spring/docs/2.0.x/reference/transaction.html

La raccomandazione del team di Spring è di annotare solo le classi concrete con l' @Transactionalannotazione, invece di annotare le interfacce. Puoi certamente posizionare l' @Transactionalannotazione su un'interfaccia (o un metodo di interfaccia), ma funzionerà solo come ti aspetteresti se utilizzi proxy basati su interfaccia. Il fatto che le annotazioni non siano ereditate significa che se si utilizzano proxy basati sulla classe, le impostazioni della transazione non verranno riconosciute dall'infrastruttura proxy basata sulla classe e l'oggetto non verrà avvolto in un proxy transazionale (il che sarebbe decisamente negativo ) . Quindi, per favore, segui il consiglio del team di Spring e annota solo le classi concrete (ei metodi delle classi concrete) con l' @Transactionalannotazione.

Nota: poiché questo meccanismo è basato sui proxy, verranno intercettate solo le chiamate di metodo "esterne" in arrivo tramite il proxy. Ciò significa che 'auto-invocazione', cioè un metodo all'interno dell'oggetto di destinazione che chiama un altro metodo dell'oggetto di destinazione, non porterà a una transazione effettiva in fase di esecuzione anche se il metodo invocato è contrassegnato con @Transactional!

(Enfasi aggiunta alla prima frase, altra enfasi dall'originale.)

Puoi inserirli nell'interfaccia ma tieni presente che le transazioni potrebbero non essere eseguite in alcuni casi. Vedi il secondo suggerimento nella sezione 10.5.6 dei documenti di primavera:

Spring consiglia di annotare solo le classi concrete (e i metodi delle classi concrete) con l'annotazione @Transactional, anziché le interfacce di annotazione. Puoi sicuramente posizionare l'annotazione @Transactional su un'interfaccia (o un metodo di interfaccia), ma funziona solo come ti aspetteresti se utilizzi proxy basati su interfaccia. Il fatto che le annotazioni Java non siano ereditate dalle interfacce significa che se stai utilizzando proxy basati sulla classe (proxy-target-class = "true") o l'aspetto basato sulla tessitura (mode = "aspectj"), le impostazioni della transazione sono non riconosciuto dall'infrastruttura di proxy e tessitura e l'oggetto non verrà avvolto in un proxy transazionale, il che sarebbe decisamente negativo.

Consiglierei di inserirli nell'implementazione per questo motivo.

Inoltre, a me, le transazioni sembrano un dettaglio di implementazione, quindi dovrebbero essere nella classe di implementazione. Immagina di avere implementazioni wrapper per la registrazione o implementazioni di test (mock) che non devono essere transazionali.

Il consiglio di Spring è di annotare le implementazioni concrete invece di un'interfaccia. Non è sbagliato usare l'annotazione su un'interfaccia, è solo possibile abusare di quella funzione e bypassare inavvertitamente la dichiarazione @Transaction.

Se hai contrassegnato qualcosa di transazionale in un'interfaccia e poi fai riferimento a una delle sue classi di implementazione altrove in primavera, non è abbastanza ovvio che l'oggetto creato da Spring non rispetterà l'annotazione @Transactional.

In pratica assomiglia a questo:

public class MyClass implements MyInterface { 

    private int x;

    public void doSomethingNonTx() {}

    @Transactional
    public void toSomethingTx() {}

}

Supportare @Transactional sulle classi concrete:

Preferisco progettare una soluzione in 3 sezioni in generale: un'API, un'implementazione e un Web (se necessario). Faccio del mio meglio per mantenere l'API il più leggera / semplice / POJO possibile riducendo al minimo le dipendenze. È particolarmente importante se lo giochi in un ambiente distribuito / integrato in cui devi condividere molto le API.

Mettere @Transactional richiede le librerie Spring nella sezione API, che IMHO non è efficace. Quindi preferisco aggiungerlo nell'implementazione in cui è in esecuzione la transazione.

Metterlo sull'interfaccia va bene fintanto che tutti gli implementatori prevedibili del tuo IFC si preoccupano dei dati TX (le transazioni non sono problemi che affrontano solo i database). Se al metodo non interessa TX (ma devi metterlo lì per Hibernate o qualsiasi altra cosa), mettilo su impl.

Inoltre, potrebbe essere un po 'meglio inserire @Transactionali metodi nell'interfaccia:

public interface FooService {
    @Transactional(readOnly = true)
    void doSmth();
}