From Spring reference 10.5.6 Using @Transactional

Tip

Spring recommends that you only annotate concrete classes (and methods of concrete classes) with the @Transactional annotation, as opposed to annotating interfaces. You certainly can place the @Transactional annotation on an interface (or an interface method), but this works only as you would expect it to if you are using interface-based proxies. The fact that Java annotations are not inherited from interfaces means that if you are using class-based proxies (proxy-target-class="true") or the weaving-based aspect (mode="aspectj"), then the transaction settings are not recognized by the proxying and weaving infrastructure, and the object will not be wrapped in a transactional proxy, which would be decidedly bad.
So even not overriden it will only work if you use Spring-Aop-Proxies (which I can not recommend), but not for AspectJ or CGILib Proxies!

But I do not expect that this work for an method that is overriden in an Interface, even not for Spring-Aop-Proxies.

@NoRepositoryBean
public interface AbstractRepository<T , ID extends Serializable>  extends JpaRepository<T, ID>,JpaSpecificationExecutor<T>{
    
}

public interfaceTemplateRepository extends AbstractRepository<Template, Long> {



//
public interface AbstractService<T, ID> {

public abstract class AbstractServiceImpl<T, ID extends Serializable> implements AbstractService<T, ID>{

//


public interface TemplateService extends AbstractService<Template, Long> {

public class TemplateServiceImpl extends AbstractServiceImpl<Template, Long> implements TemplateService {

@Transactional("transactionManager")


@RolesAllowed({"ROLE_ADMIN"})


@Cacheable({"templates"})


итд 

Spring recommends that you only annotate concrete classes (and methods of concrete classes) with the @Cache* annotation, as opposed to annotating interfaces. You certainly can place the @Cache* annotation on an interface (or an interface method), but this works only as you would expect it to if you are using interface-based proxies. The fact that Java annotations are not inherited from interfaces means that if you are using class-based proxies ( proxy-target-class="true") or the weaving-based aspect ( mode="aspectj"), then the caching settings are not recognized by the proxying and weaving infrastructure, and the object will not be wrapped in a caching proxy, which would be decidedly bad.
[Note]
In proxy mode (which is the default), only external method calls coming in through the proxy are intercepted. This means that self-invocation, in effect, a method within the target object calling another method of the target object, will not lead to an actual caching at runtime even if the invoked method is marked with @Cacheable - considering using the aspectj mode in this case. Also, the proxy must be fully initialized to provide the expected behaviour so you should not rely on this feature in your initialization code, i.e. @PostConstruct.