Spring整合AOP

超、凢脫俗 2023-03-01 13:41 26阅读 0赞

### 目录 ###

*   *   *  Spring AOP
         *   *  切面
             *  对应的接口
             *  xml配置文件
             *  说明
         *  AspectJ
         *   *  xml配置方式
             *  注解配置方式
         *  总结

在Spring中使用AOP有2种方式

*  Spring AOP：Spring封装了动态代理实现AOP
 *  AspectJ：专业的AOP框架，更强大

最初spring是自己实现的aop，即spring aop，后来spring集成了aspectj的切面语法，也可以使用aspectj。

### Spring AOP ###

所需依赖：spring-aop

目标接口

public interface UserService { 
        void login();
        void logout();
    }

目标类

@Service
    public class UserServiceImpl implements UserService { 
    
        @Override
        public void login() { 
            System.out.println("正在执行login()...");
        }
    
        @Override
        public void logout() { 
            System.out.println("正在执行logout()...");
        }
        
    }

#### 切面 ####

import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    
    @Component  //根据增强时机实现对应的接口
    public class UserServiceAspect implements MethodInterceptor { 
    
        @Override
        public Object invoke(MethodInvocation methodInvocation) throws Throwable { 
            //前增强
            System.out.println("正在执行前增强...");
    
            //调用目标方法，返回值是Object类型
            Object object=methodInvocation.proceed();
    
            //后增强
            System.out.println("正在执行后增强...");
    
            //返回目标方法的返回值
            return object;
        }
    
    }

#### 对应的接口 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">通知类型</th> 
   <th align="left">增强时机</th> 
   <th align="left">需要实现的接口</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">环绕通知</td> 
   <td align="left">目标方法的整个调用流程，可实现前增强、后增强、异常处理等</td> 
   <td align="left">MethodInterceptor</td> 
  </tr> 
  <tr> 
   <td align="left">前置通知</td> 
   <td align="left">目标方法执行之前</td> 
   <td align="left">MethodBeforeAdvice</td> 
  </tr> 
  <tr> 
   <td align="left">后置通知</td> 
   <td align="left">目标方法执行之后</td> 
   <td align="left">AfterAdvice（空接口）</td> 
  </tr> 
  <tr> 
   <td align="left">异常通知</td> 
   <td align="left">目标方法执行过程中抛出异常后</td> 
   <td align="left">ThrowsAdvice（空接口）</td> 
  </tr> 
  <tr> 
   <td align="left">返回通知</td> 
   <td align="left">目标方法返回值后</td> 
   <td align="left">AfterReturningAdvice</td> 
  </tr> 
 </tbody> 
</table>

一般不使用空接口，AfterReturningAdvice是返回通知，但很多时候都可以当作后置通知使用。

#### xml配置文件 ####

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    	
        <context:component-scan base-package="com.chy.mall" />
    
        
        <bean name="userService" class="org.springframework.aop.framework.ProxyFactoryBean">
            
            <property name="proxyInterfaces" value="service.UserService" />
            
            <property name="target" ref="userService" />
            
            <property name="interceptorNames" value="userServiceAspect" />
            
            
            
            <property name="singleton" value="true" />
        </bean>
    
    </beans>

#### 说明 ####

示例写的是代理接口，会代理该接口所有的实现类。如果只代理目标类

*  目标类不用实现接口
 *  代理中不必配置 proxyInterfaces ，需要将 proxyTargetClass 设置为true  
    true：直接代理目标类，使用的是cglib动态代理  
    false：默认值，代理接口，目标类必须实现接口，使用的是jdk动态代理

spring aop需要在配置文件中给每个目标类|接口代理，很繁琐，且配置文件会很庞大。

### AspectJ ###

所需依赖

*  spring-aop
 *  spring-aspects

目标接口

public interface UserService { 
        void login();
        void logout();
    }

目标类

#### xml配置方式 ####

切面

@Component
    public class UserServiceAspect { 
    
        /** * 前置通知要调用的方法 */
        public void before(){ 
            System.out.println("正在执行前置通知...");
        }
    
    
        /** * 后置通知要调用的方法 */
        public void after(){ 
            System.out.println("正在执行后置通知...");
        }
    
    
        /** * 返回通知要调用的方法 */
        public void afterReturning(Object obj){ 
            System.out.println("正在执行返回通知...");
            System.out.println("目标方法的返回值是："+obj);
        }
    
    
        /** * 异常通知要调用的方法 */
        public void afterThrowing(JoinPoint point, Exception e){ 
            System.out.println("异常信息："+e.getMessage());
        }
    
    }

/** * 环绕通知 */
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { 
        //前增强
        System.out.println("正在执行前增强...");
        //调用目标方法
        Object object=proceedingJoinPoint.proceed();
        //后增强
        System.out.println("正在执行后增强...");
        return object;
    }

xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
        
        <context:component-scan base-package="com.chy.mall" />
    
        
        <aop:config>
            
            
    
            
            <aop:aspect ref="userServiceAspect">
                
                <aop:pointcut id="pointCut" expression="execution(* com.chy.mall.service.UserService.*(..))" />
    
                
                <aop:before method="before" pointcut-ref="pointCut" />
    
                
                
    
                
                <aop:after method="after" pointcut-ref="pointCut" />
    
                
                
                <aop:after-returning method="afterReturning" pointcut-ref="pointCut" returning="obj"/>
    
                
                
                <aop:after-throwing method="afterThrowing" pointcut-ref="pointCut" throwing="e"/>
                
                
                
                 
            </aop:aspect>
    
        </aop:config>
    
    </beans>

#### 注解配置方式 ####

切面

@Component
    @Aspect  //标识为切面
    public class UserServiceAspect { 
    
        /** * 配置切入点。此切入点是局部切入点，只能在当前切面中引用 */
        @Pointcut("execution(* com.chy.mall.service.UserService.*(..))")
        private void pointCut(){ }
    
    
        /** * 前置通知 * 切入点均可现配 @Before("execution(* com.chy.mall.service.UserService.*(..))") */
        @Before("pointCut()")
        public void before(){ 
            System.out.println("正在执行前置通知...");
        }
    
    
        /** * 后置通知 */
        @After("pointCut()")
        public void after(){ 
            System.out.println("正在执行后置通知...");
        }
    
    
        /** * 返回通知。可将目标方法的返回值传给指定形参 */
        @AfterReturning(value = "pointCut()",returning = "obj" )
        public void afterReturning(Object obj){ 
            System.out.println("正在执行返回通知...");
            System.out.println("目标方法的返回值是："+obj);
        }
    
        /** * 异常通知。可将目标方法的抛出的异常传给指定形参 */
        @AfterThrowing(value = "pointCut()",throwing = "e")
        public void afterThrowing(JoinPoint point,Exception e){ 
            System.out.println("异常信息："+e.getMessage());
        }
    
    }

/** * 环绕通知 */
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { 
        //前增强
        System.out.println("正在执行前增强...");
        //调用目标方法
        Object object=proceedingJoinPoint.proceed();
        //后增强
        System.out.println("正在执行后增强...");
        return object;
    }

xml配置文件

### 总结 ###

1、声明是声明为目标类型，注入是注入代理

@Resource(name="userService")  //注入的是代理，按名称注入
    private UserService userService;  //如果代理的是接口，声明为接口类型；如果代理的目标类，声明为目标类

2、常见问题

> <context:component-scan base-package=" " />

没有配置组件扫描，或者包未写全，出现bean未定义异常