Chamada de método Spring @Transaction pelo método dentro da mesma class, não funciona?

Eu sou novo no Spring Transaction. Alguma coisa que achei muito estranha, provavelmente eu entendi isso corretamente. Eu queria ter um nível de método transacional em torno e eu tenho um método de chamador dentro da mesma class e parece que não gosta disso, tem que ser chamado da class separada. Eu não entendo como isso é possível. Se alguém tiver uma idéia de como resolver esse problema, eu agradeceria muito. Eu gostaria de usar a mesma class para chamar o método transacional anotado.

Aqui está o código:

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 users) { for (User user : users) { addUser(user.getUserName, user.getPassword); } } } 

    É uma limitação do Spring AOP (objects dynamics e cglib ).

    Se você configurar o Spring para usar o AspectJ para lidar com as transactions, seu código funcionará.

    A alternativa simples e provavelmente melhor é refatorar seu código. Por exemplo, uma class que manipula usuários e uma que processa cada usuário. Em seguida, o manuseio de transação padrão com o Spring AOP funcionará.


    Dicas de configuração para lidar com transactions com AspectJ

    Para permitir que o Spring use o AspectJ para transactions, você deve definir o modo como AspectJ:

      

    Se você estiver usando o Spring com uma versão mais antiga que 3.0, você também deve adicionar isso à sua configuração do Spring:

        

    O problema aqui é que os proxies AOP do Spring não se estendem, mas envolvem sua instância de serviço para interceptar chamadas. Isso tem o efeito de que qualquer chamada para “isto” de dentro de sua instância de serviço é invocada diretamente nessa instância e não pode ser interceptada pelo proxy de agrupamento (o proxy nem sequer está ciente de tal chamada). Uma solução já é mencionada. Outro bacana seria simplesmente fazer com que Spring injete uma instância do serviço no próprio serviço e chame seu método na instância injetada, que será o proxy que manipula suas transactions. Mas esteja ciente de que isso pode ter efeitos colaterais ruins também, se seu bean de serviço não for um singleton:

       ...  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 users) { for (User user : users) { self.addUser(user.getUserName, user.getPassword); } } } 

    Esta é a minha solução para auto-invocação :

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

    Com o Spring 4 é possível autofechar

     @Service @Transactional public class UserServiceImpl implements UserService{ @Autowired private UserRepositroy repositroy; @Autowired private UserService userService; @Override public void update(int id){ repository.findOne(id).setName("ddd"); } @Override public void save(Users user) { repositroy.save(user); userService.update(1)l } } 

    Você pode usar o BeanFactory dentro da mesma class e fazer um

    getBean(YourClazz.class)

    Ele irá automaticamente aproximar sua class e levar em conta sua anotação @Transactional ou outra anotação.

    O problema está relacionado a como classs de carga de mola e proxies. Ele não funcionará, até que você escreva seu método / transação interna em outra class ou vá para outra class e, em seguida, venha para sua turma e, em seguida, escreva o método de transcação nested interno.

    Para resumir, os proxies de mola não permitem os cenários que você está enfrentando. você tem que escrever o segundo método de transação em outra class