Это ограничение Spring AOP (динамические объекты и cglib).

Если вы настроите Spring для использования AspectJ для обработки транзакций, ваш код будет работать.

Простая и, вероятно, лучшая альтернатива - это рефакторинг вашего кода. Например, один класс, который обрабатывает пользователей, и один, который обрабатывает каждого пользователя. Тогда будет работать обработка транзакций по умолчанию с помощью Spring AOP.

Советы по настройке для обработки транзакций с AspectJ

Чтобы Spring мог использовать AspectJ для транзакций, вы должны установить режим AspectJ:

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

Если вы используете Spring с более ранней версией, чем 3.0, вы также должны добавить это в свою конфигурацию Spring:

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

Проблема здесь в том, что прокси-серверы Spring AOP не расширяют, а скорее обертывают ваш экземпляр службы для перехвата вызовов. Это приводит к тому, что любой вызов this из вашего экземпляра службы напрямую вызывается в этом экземпляре и не может быть перехвачен прокси-сервером-оболочкой (прокси даже не знает ни о каком таком вызове). Одно из решений уже упоминалось. Еще один интересный вариант - просто заставить Spring внедрить экземпляр службы в саму службу и вызвать ваш метод на внедренном экземпляре, который будет прокси-сервером, который обрабатывает ваши транзакции. Но имейте в виду, что это также может иметь плохие побочные эффекты, если ваш служебный компонент не является синглтоном:

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

В Java 8+ есть еще одна возможность, которую я предпочитаю по причинам, указанным ниже:

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

Такой подход имеет следующие преимущества:

1. Его можно применять к частным методам. Таким образом, вам не нужно нарушать инкапсуляцию, делая метод общедоступным, чтобы удовлетворить ограничения Spring.

2. Один и тот же метод может быть вызван в рамках разных транзакций, и вызывающий абонент должен выбрать подходящий. Сравните эти 2 строки:

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

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

3. Он явный, поэтому более читаемый.

С Spring 4 возможно самостоятельное автоматическое подключение

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

Это мое решение для самостоятельного вызова:

public class SBMWSBL {
    private SBMWSBL self;

    @Autowired
    private ApplicationContext applicationContext;

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

    // ...
}

Вы можете автоматически подключить BeanFactory внутри того же класса и выполнить

getBean(YourClazz.class)

Он автоматически проксифицирует ваш класс и примет во внимание вашу @Transactional или другую аннотацию aop.

Вот что я делаю для небольших проектов с минимальным использованием вызовов методов в одном классе. Настоятельно рекомендуется внутренняя документация, поскольку она может показаться коллегам странной. Но он работает с синглтонами, его легко протестировать, просто, быстро реализовать и избавить меня от полноценного инструментария AspectJ. Однако для более интенсивного использования я бы посоветовал решение AspectJ, как описано в ответе Эспенса.

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

Проблема связана с тем, как классы и прокси-серверы Spring загружают. Это не сработает, пока вы не напишете свой внутренний метод / транзакцию в другом классе или не перейдете в другой класс, а затем снова перейдете в свой класс, а затем напишете внутренний вложенный метод трансляции.

Подводя итог, прокси-серверы Spring не допускают сценариев, с которыми вы сталкиваетесь. вам нужно написать второй метод транзакции в другом классе

Нет смысла использовать AspectJ или другие способы. Достаточно просто использовать АОП. Итак, мы можем добавить @Transactional к addUsers(List<User> users), чтобы решить текущую проблему.

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

        }
    }

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