Jestem nowy w Spring Transaction. Coś, co wydało mi się naprawdę dziwne, prawdopodobnie dobrze to zrozumiałem.

Chciałem mieć transakcję na poziomie metody i mam metodę wywołującą w tej samej klasie i wygląda na to, że nie podoba mi się to, musi być wywoływana z oddzielnej klasy. Nie rozumiem, jak to możliwe.

Jeśli ktoś ma pomysł, jak rozwiązać ten problem, byłbym bardzo wdzięczny. Chciałbym użyć tej samej klasy do wywołania metody transakcyjnej z adnotacjami.

Oto kod:

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

Jest to ograniczenie Spring AOP (dynamiczne obiekty i cglib ).

Jeśli skonfigurujesz Springa, aby używał AspectJ do obsługi transakcji, twój kod będzie działał.

Prostą i prawdopodobnie najlepszą alternatywą jest refaktoryzacja kodu. Na przykład jedna klasa obsługująca użytkowników i jedna przetwarzająca każdego użytkownika. Wtedy domyślna obsługa transakcji za pomocą Spring AOP będzie działać.

Wskazówki dotyczące konfiguracji obsługi transakcji z AspectJ

Aby umożliwić Springowi używanie AspectJ do transakcji, musisz ustawić tryb na AspectJ:

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

Jeśli używasz Springa ze starszą wersją niż 3.0, musisz również dodać to do swojej konfiguracji Springa:

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

Problem polega na tym, że serwery proxy AOP Springa nie rozszerzają się, ale raczej opakowują instancję usługi w celu przechwytywania połączeń. W efekcie każde wywołanie „this” z Twojej instancji usługi jest bezpośrednio wywoływane w tej instancji i nie może być przechwycone przez opakowujący serwer proxy (proxy nie wie nawet o takim wywołaniu). Wspomniano już o jednym rozwiązaniu. Innym fajnym rozwiązaniem byłoby po prostu wstrzyknięcie przez Spring instancji usługi do samej usługi i wywołanie metody na wstrzykniętej instancji, która będzie serwerem proxy obsługującym transakcje. Ale pamiętaj, że może to mieć również złe skutki uboczne, jeśli Twój komponent bean nie jest singletonem:

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

Dzięki Spring 4 możliwe jest Self 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);
    }
}

Zaczynając od Java 8 istnieje inna możliwość, którą wolę z powodów podanych poniżej:

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

Takie podejście ma następujące zalety:

1) Może być stosowany do metod prywatnych . Nie musisz więc przerywać hermetyzacji, upubliczniając metodę, aby spełnić ograniczenia Spring.

2) Ta sama metoda może być wywołana w ramach różnych propagacji transakcji i od wywołującego zależy wybór odpowiedniej. Porównaj te 2 linie:

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

3) Jest wyraźny, a przez to bardziej czytelny.

Oto moje rozwiązanie do samodzielnego wywoływania :

public class SBMWSBL {
    private SBMWSBL self;

    @Autowired
    private ApplicationContext applicationContext;

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

    // ...
}

Możesz automatycznie przypisać BeanFactory w tej samej klasie i wykonać

getBean(YourClazz.class)

Automatycznie przekaże twoją klasę i weźmie pod uwagę twoją @Transactional lub inną adnotację aop.

Problem jest związany z klasami obciążenia sprężyn i proxy. To nie zadziała, dopóki nie napiszesz swojej wewnętrznej metody / transakcji w innej klasie lub nie przejdziesz do innej klasy, a następnie ponownie przejdziesz do swojej klasy i nie napiszesz wewnętrznej metody zagnieżdżonej transkacji.

Podsumowując, wiosenne proxy nie pozwalają na scenariusze, z którymi się mierzysz. musisz napisać drugą metodę transakcji w innej klasie

Oto, co robię dla małych projektów z tylko marginalnym wykorzystaniem wywołań metod w tej samej klasie. Zdecydowanie zaleca się, aby dokumentacja w kodzie była dziwna dla współpracowników. Ale działa z singletonami , jest łatwy do przetestowania, prosty, szybki do osiągnięcia i oszczędza mi pełnego oprzyrządowania AspectJ. Jednak w przypadku bardziej intensywnego użytkowania radziłbym rozwiązanie AspectJ, jak opisano w odpowiedzi 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);
        }
    }
}