Spring @Transactional inheritance behavior

I have the following structure:

@Transactional
public abstract class BaseServiceImpl<E, K extends Serializable, R extends BaseRepository<E, K>> implements BaseService<E, K> {
protected BaseServiceImpl(R repository) {
this.repository = repository;
}
@Override
public E save(E entity) {
return repository.save(entity);
}
@Override
public List<E> saveAll(List<E> entities) {
return repository.saveAll(entities);
}
@Override
public Optional<E> findByKey(K entityKey) {
if (entityKey != null) {
return repository.findById(entityKey);
}
return Optional.empty();
}
@Override
public List<E> search(String filter, Integer page, Integer limit, String orderBy) {
return repository.findAll(filter, page, limit, orderBy);
}
@Override
public E update(E entity) {
return repository.save(entity);
}
@Override
public void deleteAll() {
repository.deleteAll();
}
@Override
public void delete(E entity) {
repository.delete(entity);
}
@Override
public void deleteByKey(K entityKey) {
repository.deleteById(entityKey);
}
@Override
public Long count() {
return repository.count();
}
}
@Service
public class CustomerService extends BaseServiceImpl<CustomerEntity, String, CustomerRepository> {
public CustomerService(CustomerRepository repository) {
super(repository);
}
}

The question is: will all the methods of CustomerService inherit @Transactional and behave inside transactional context?
Also I know that Spring doc recommends to put @Transactional on specific classes or methods, but I'm interested in the best way to avoid code duplication using @Transactional within class hierarchy.

@Transactional annotation itself is annotated with the @Inherited annotation, which means that if you put it on a base class, such as BaseServiceImpl in your example, it will be propagated to the subclasses, CustomerService for you. https://docs.oracle.com/javase/8/docs/api/java/lang/annotation/Inherited.html

It will behave exactly as if you annotated CustomerService directly.

As you noticed yourself, it is adviced to put @Transactional on a more granular level, such as methods.

Take into consideration that as your project evolves, you may not want the @Transactional annotations on every method and decision to annotate the base class early on may require future changes.

Also, take into consideration that it may be more difficult to maintain as usage of @Transactional may not be as visible for future maintainers as it will be kind of hidden behind the base class.

Take the pros a cons into consideration and choose whatever is most suitable for you.

@Transactional on a class level will be applied to every public method. private and protected methods will be ignored.

But what you are doing is really not good practice. For read-only operation (e.g getting from the database), you should use @Transactional(readonly = true) because it has optimizations compared to only @Transactional.

Therefore, I suggest not worrying about duplications and just put the annotation where you need it.

Extra: Be aware that calling method annotated with @Transactional(propagation = Propagation.REQUIRES_NEW) from another @Transactional method within the same bean will not create new transaction due to Spring proxy behavior.