Ich bin neu bei Spring Transaction. Etwas, das ich wirklich seltsam fand, wahrscheinlich habe ich das richtig verstanden.

Ich wollte eine Transaktion auf Methodenebene haben und ich habe eine Aufrufmethode innerhalb derselben Klasse, und es scheint, als würde sie das nicht mögen, sie muss von der separaten Klasse aufgerufen werden. Ich verstehe nicht, wie das möglich ist.

Wenn jemand eine Idee hat, wie man dieses Problem lösen kann, wäre ich sehr dankbar. Ich möchte dieselbe Klasse verwenden, um die annotierte Transaktionsmethode aufzurufen.

Hier ist der Code:

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);
        }
    } 
}

Es ist eine Einschränkung von Frühling AOP (dynamische Objekte und cglib).

Wenn Sie Spring für die Verwendung konfigurieren AspektJ Um die Transaktionen abzuwickeln, funktioniert Ihr Code.

Die einfache und wahrscheinlich beste Alternative besteht darin, Ihren Code umzugestalten. Beispielsweise eine Klasse, die Benutzer behandelt, und eine, die jeden Benutzer verarbeitet. Dann Ursprünglich Transaktionsabwicklung mit Spring AOP funktioniert.

Konfigurationstipps zum Umgang mit Transaktionen mit AspectJ

Damit Spring AspectJ für Transaktionen verwenden kann, müssen Sie den Modus auf AspectJ setzen:

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

Wenn Sie Spring mit einer älteren Version als 3.0 verwenden, müssen Sie dies auch zu Ihrer Spring-Konfiguration hinzufügen:

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

Das Problem hierbei ist, dass die AOP-Proxys von Spring Ihre Dienstinstanz nicht erweitern, sondern umhüllen, um Anrufe abzufangen. Dies hat den Effekt, dass jeder Aufruf von „this“ aus Ihrer Dienstinstanz direkt auf dieser Instanz aufgerufen wird und nicht vom Wrapping-Proxy abgefangen werden kann (der Proxy ist sich eines solchen Aufrufs nicht einmal bewusst). Eine Lösung ist bereits erwähnt. Eine andere raffinierte Methode wäre, Spring einfach eine Instanz des Dienstes in den Dienst selbst einzufügen und Ihre Methode für die eingefügte Instanz aufzurufen, die der Proxy ist, der Ihre Transaktionen verarbeitet. Beachten Sie jedoch, dass dies auch negative Nebenwirkungen haben kann, wenn Ihre Service-Bean kein Singleton ist:

<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);
        }
    } 
}

In Java 8+ gibt es eine andere Möglichkeit, die ich aus den unten angegebenen Gründen bevorzuge:

@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 call userRepository
    }
}

@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();
    }
}

Diese Vorgehensweise hat folgende Vorteile:

1. Es kann angewendet werden Privat Methoden. Sie müssen also die Kapselung nicht aufheben, indem Sie eine Methode öffentlich machen, nur um die Einschränkungen von Spring zu erfüllen.

2. Dieselbe Methode kann innerhalb verschiedener Transaktionsweitergaben und aufgerufen werden es liegt am Anrufer das passende auszuwählen. Vergleichen Sie diese 2 Zeilen:

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

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

3. Es ist explizit, also besser lesbar.

Mit Spring 4 ist es möglich, sich selbst automatisch zu verdrahten

@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);
    }
}

Das ist meine Lösung für Selbstaufruf:

public class SBMWSBL {
    private SBMWSBL self;

    @Autowired
    private ApplicationContext applicationContext;

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

    // ...
}

Sie können BeanFactory innerhalb derselben Klasse automatisch verdrahten und Folgendes tun

getBean(YourClazz.class)

Es wird automatisch Ihre Klasse proxifizieren und Ihre @Transactional- oder andere Aop-Anmerkung berücksichtigen.

Folgendes mache ich für kleine Projekte mit nur marginaler Verwendung von Methodenaufrufen innerhalb derselben Klasse. Eine In-Code-Dokumentation wird dringend empfohlen, da sie für Kollegen seltsam aussehen kann. Aber Es funktioniert mit Singletons, ist einfach zu testen, einfach, schnell zu erreichen und erspart mir die vollständige AspectJ-Instrumentierung. Für eine stärkere Nutzung würde ich jedoch die AspectJ-Lösung empfehlen, wie in der Espens-Antwort beschrieben.

@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);
        }
    }
}