Spring中AOP调用失效的处理方式

绝地灬酷狼 2021-11-23 00:42 476阅读 0赞

## 引言 ##

AOP在Spring以及实际项目中使用非常广泛，例如日志、数据库事务、权限校验和访问控制等等领域，其通过优雅的控制方式，优美简练地解决在项目中的开发问题。  
但是对于AOP实现的功能，在特定场景下仍有实效的Case，主要特征描述为：

在同一个类中，调用使用注解方式的AOP功能的方法，目标方法的注解则会失效，即无法实现预期的功能控制，例如事务、权限等。

## 示例 ##

代码示例：

@Service
     public class UserServiceImpl implements UserService {
           @Autowired
           private UserRepository userRepo;
          
           @Override
           @Transactional
           public int insertUser(User user) {
                   int userId = this.userRepo.save(user);
                   return userId;
           }
    
         /**
          *.  数据库事务失效的Case
          */
          @Override
          public int insertUserInvalidAOP(User user) {
               return insertUserInner(user);
          }
          
          @Transactional
          public int insertUserInner(User user) {
              int userId = this.userRepo.save(user);
               return userId;
          }
     }

从上述的case中可以看到，直接调用insertUser()事务正常生效。但是在类内部方法insertUserInvalidAOP()方法中调用在同一个类中定义的insertUserInner()方法，则在insertUserInner方法上使用的事务注解会失效。  
这个问题的原因时说什么呢？

## 原理 ##

AOP方法作用的原理图示如下：  
![AOP 原理][AOP]在项目中正常情况下，调用的对象是AOP代理的对象，而非实际的目标对象或者操作实例对象。 但是在类内部的方法中，调用同一个类中定义的方法，则调用的是当前的对象，而不是代理对象，则代理失效，注解失效。

## 解决办法 ##

明白了问题，则需要寻找一下具体解决的办法：

1.  将需要进行AOP管理的方法，在独立的类中定义，即可解决此类问题。在特定的情况，可以定独立的事务层
2.  强制将AOP对象进行设置，在内部方法调用中，通过AopContext 获取代理对象。
    
        **
          *.  基于AopContext的currentProxy
          */
          @Override
          public int insertUserInvalidAOP(User user) {
               return ((UserService)AopContext.currentProxy)insertUserInner(user);
          }
          
          @Transactional
          public int insertUserInner(User user) {
              int userId = this.userRepo.save(user);
               return userId;
          }
    
    原理：AopContext的实现如下： (1).在进入代理对象之后通过AopContext.serCurrentProxy(proxy)暴露当前代理对象到ThreadLocal，并保存上次ThreadLocal绑定的代理对象为oldProxy。 (2).接下来我们可以通过 AopContext.currentProxy() 获取当前代理对象。 (3).在退出代理对象之前要重新将ThreadLocal绑定的代理对象设置为上一次的代理对象，即 AopContext.serCurrentProxy(oldProxy)。  
    AopContext的实现代码如下：

package org.springframework.aop.framework;
    
    import org.springframework.core.NamedThreadLocal;
    public abstract class AopContext {
    	private static final ThreadLocal<Object> currentProxy = new NamedThreadLocal<Object>("Current AOP proxy");
    	
    	public static Object currentProxy() throws IllegalStateException {
    		Object proxy = currentProxy.get();
    		if (proxy == null) {
    			throw new IllegalStateException(
    					"Cannot find current proxy: Set 'exposeProxy' property on Advised to 'true' to make it available.");
    		}
    		return proxy;
    	}
    
    	static Object setCurrentProxy(Object proxy) {
    		Object old = currentProxy.get();
    		if (proxy != null) {
    			currentProxy.set(proxy);
    		}
    		else {
    			currentProxy.remove();
    		}
    		return old;
    	}
    }

其本质是在AopContext中存放了代理对象，代码对象是放存在threadlocal中的。

1.  往实现类中注入自身。 仍然在同一个类中调用代码，  
    具体的调用形式如下：

@Service
      public class UserServiceImpl implements UserService {
         @Autowired
         private UserRepository userRepo;
    
         @Autowired
         private UserService userService;
        
         @Override
         @Transactional
         public int insertUser(User user) {
                 int userId = this.userRepo.save(user);
                 return userId;
         }
    
      
       //通过自身注入的实例对象来调用     
        @Override
        public int insertUserInvalidAOP(User user) {
             return this.userService.insertUserInner(user);
        }
        
        @Transactional
        public int insertUserInner(User user) {
            int userId = this.userRepo.save(user);
             return userId;
        }
    }

## 总结 ##

(1) 在一个类内部调用时，被调用方法的 AOP 声明将不起作用。

(2) 对于基于接口动态代理的 AOP 事务增强来说，由于接口的方法都必然是 public ，这就要求实现类的实现方法也必须是 public 的（不能是 protected、private 等），同时不能使用 static 的修饰符。所以，可以实施接口动态代理的方法只能是使用 public 或 public final 修饰符的方法，其他方法不可能被动态代理，相应的也就不能实施 AOP 增强，换句话说，即不能进行 Spring 事务增强了。

(3) 基于 CGLib 字节码动态代理的方案是通过扩展被增强类，动态创建其子类的方式进行 AOP 增强植入的。由于使用 final、static、private 修饰符的方法都不能被子类覆盖，这些方法将无法实施 AOP 增强。所以方法签名必须特别注意这些修饰符的使用，以免使方法不小心成为事务管理的漏网之鱼。

(4) 该例中的方法符合上述条件，但注解仍然失效，主要原因是在于同一类中的方法互相调用，调用者指向当前对象，所以无论是接口代理还是 cglib 代理都无法织入增强实现。

[AOP]: /images/20211122/c1c02735953d420f8722972aea330648.png