Sono nuovo in Spring Transaction. Qualcosa che ho trovato davvero strano, probabilmente l'ho capito bene.

Volevo avere un livello di metodo transazionale e ho un metodo chiamante all'interno della stessa classe e sembra che non piaccia, deve essere chiamato dalla classe separata. Non capisco come sia possibile.

Se qualcuno ha un'idea di come risolvere questo problema, lo apprezzerei molto. Vorrei utilizzare la stessa classe per chiamare il metodo transazionale annotato.

Ecco il codice:

public class UserService {

    @Transactional
    public boolean addUser(String userName, String password) {
        try {
            // call DAO layer and adds to database.
        } catch (Throwable e) {
            TransactionAspectSupport.currentTransactionStatus()
                    .setRollbackOnly();

        }
    }

    public boolean addUsers(List<User> users) {
        for (User user : users) {
            addUser(user.getUserName, user.getPassword);
        }
    } 
}

È una limitazione di Spring AOP (oggetti dinamici e cglib ).

Se configuri Spring per utilizzare AspectJ per gestire le transazioni, il tuo codice funzionerà.

L'alternativa semplice e probabilmente migliore è il refactoring del codice. Ad esempio una classe che gestisce gli utenti e una che elabora ogni utente. Quindi la gestione delle transazioni predefinita con Spring AOP funzionerà.

Suggerimenti per la configurazione per la gestione delle transazioni con AspectJ

Per consentire a Spring di utilizzare AspectJ per le transazioni, è necessario impostare la modalità su AspectJ:

<tx:annotation-driven mode="aspectj"/>

Se stai usando Spring con una versione precedente alla 3.0, devi aggiungerla anche alla tua configurazione Spring:

<bean class="org.springframework.transaction.aspectj
        .AnnotationTransactionAspect" factory-method="aspectOf">
    <property name="transactionManager" ref="transactionManager" />
</bean>

Il problema qui è che i proxy AOP di Spring non si estendono ma piuttosto avvolgono l'istanza del servizio per intercettare le chiamate. Ciò ha l'effetto che qualsiasi chiamata a "this" dall'interno dell'istanza del servizio viene invocata direttamente su quell'istanza e non può essere intercettata dal proxy di wrapping (il proxy non è nemmeno a conoscenza di tale chiamata). Una delle soluzioni è già menzionata. Un altro interessante sarebbe semplicemente fare in modo che Spring inietti un'istanza del servizio nel servizio stesso e chiami il tuo metodo sull'istanza iniettata, che sarà il proxy che gestisce le tue transazioni. Ma tieni presente che questo potrebbe avere anche effetti collaterali negativi, se il tuo bean di servizio non è un singleton:

<bean id="userService" class="your.package.UserService">
  <property name="self" ref="userService" />
    ...
</bean>

public class UserService {
    private UserService self;

    public void setSelf(UserService self) {
        this.self = self;
    }

    @Transactional
    public boolean addUser(String userName, String password) {
        try {
        // call DAO layer and adds to database.
        } catch (Throwable e) {
            TransactionAspectSupport.currentTransactionStatus()
                .setRollbackOnly();

        }
    }

    public boolean addUsers(List<User> users) {
        for (User user : users) {
            self.addUser(user.getUserName, user.getPassword);
        }
    } 
}

Con Spring 4 è possibile eseguire l'autowired

@Service
@Transactional
public class UserServiceImpl implements UserService{
    @Autowired
    private  UserRepository repository;

    @Autowired
    private UserService userService;

    @Override
    public void update(int id){
       repository.findOne(id).setName("ddd");
    }

    @Override
    public void save(Users user) {
        repository.save(user);
        userService.update(1);
    }
}

A partire da Java 8 c'è un'altra possibilità, che preferisco per i motivi indicati di seguito:

@Service
public class UserService {

    @Autowired
    private TransactionHandler transactionHandler;

    public boolean addUsers(List<User> users) {
        for (User user : users) {
            transactionHandler.runInTransaction(() -> addUser(user.getUsername, user.getPassword));
        }
    }

    private boolean addUser(String username, String password) {
        // TODO
    }
}

@Service
public class TransactionHandler {

    @Transactional(propagation = Propagation.REQUIRED)
    public <T> T runInTransaction(Supplier<T> supplier) {
        return supplier.get();
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public <T> T runInNewTransaction(Supplier<T> supplier) {
        return supplier.get();
    }
}

Questo approccio presenta i seguenti vantaggi:

1) Può essere applicato a metodi privati . Quindi non devi rompere l'incapsulamento rendendo pubblico un metodo solo per soddisfare i limiti di Spring.

2) Lo stesso metodo può essere chiamato all'interno di diverse propagazioni di transazioni e spetta al chiamante scegliere quello adatto. Confronta queste 2 linee:

transactionHandler.runInTransaction(() -> userService.addUser(user.getUserName, user.getPassword));
transactionHandler.runInNewTransaction(() -> userService.addUser(user.getUserName, user.getPassword));

3) È esplicito, quindi più leggibile.

Questa è la mia soluzione per l' auto invocazione :

public class SBMWSBL {
    private SBMWSBL self;

    @Autowired
    private ApplicationContext applicationContext;

    @PostConstruct
    public void postContruct(){
        self = applicationContext.getBean(SBMWSBL.class);
    }

    // ...
}

Puoi autowired BeanFactory all'interno della stessa classe e fare un file

getBean(YourClazz.class)

Invierà automaticamente la tua classe e terrà conto della tua annotazione @Transactional o di altre annotazioni aop.

Il problema è legato al modo in cui le classi di carico della molla e i proxy. Non funzionerà, finché non scriverai il tuo metodo / transazione interiore in un'altra classe o non andrai in un'altra classe e poi tornerai di nuovo nella tua classe e poi scriverai il metodo di trascrizione annidato interno.

Riassumendo, i proxy primaverili non consentono gli scenari che stai affrontando. devi scrivere il secondo metodo di transazione in un'altra classe

Ecco cosa faccio per piccoli progetti con un utilizzo solo marginale delle chiamate di metodo all'interno della stessa classe. La documentazione in-code è vivamente consigliata, poiché potrebbe sembrare strana ai colleghi. Ma funziona con i singleton , è facile da testare, semplice, veloce da ottenere e mi risparmia la strumentazione AspectJ in piena regola. Tuttavia, per un utilizzo più intenso, consiglierei la soluzione AspectJ come descritto nella risposta di Espens.

@Service
@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
class PersonDao {

    private final PersonDao _personDao;

    @Autowired
    public PersonDao(PersonDao personDao) {
        _personDao = personDao;
    }

    @Transactional
    public void addUser(String username, String password) {
        // call database layer
    }

    public void addUsers(List<User> users) {
        for (User user : users) {
            _personDao.addUser(user.getUserName, user.getPassword);
        }
    }
}