Spring AOP使用-阿里云开发者社区

一、简介

AOP全程是Aspect—Oriented—Programming，面向切面编程。AOP采用横向抽取机制，将分散在各个方法中的重复代码抽取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。

使用AOP编程，可以使开发人员专心于核心业务，而不用过多的关注于其他业务逻辑的是实现，不但提高了开发效率，而且增强了代码的可维护性。

目前最流行的AOP框架有两个，分别是Spring AOP和AspectJ。其中：Spring AOP采用纯Java实现，不需要专门的编译过程和类加载器，在运行期间通过代理方式向目标类织入增强的代码。AspectJ是一个基于Java语言的AOP框架，从Spring 2.0开始，AspectJ扩展了Java语言，扩展了一个专门的编译器，在编译时提供横向代码的织入。

二、重点解析

1、代理分类

Pointcut：全局切入点
Before：前置通知
After-returning：后置通知
Around：环绕通知
After-throwing：异常通知
After：最终通知
Declare-parents：引介通知

2、切入点位置配置(expression)

// 定义切入点表达式
  @Pointcut("execution(* com.lydms.jdk.*.*(..))")
private void myPointCut(){}

第1个*：表示返回类型，*****表示任意返回类型。
com.lydms.jdk：表示需要拦截的包名。
第2个*：表示类名，*****表示所有类。
第3个*：表示方法名，*****表示所有方法。
(…)：表示方法的参数，”…“表示任意参数。
第一个*与包名之间有空格。

3、配置通知

属性名称	描述
pointcut	该属性用于指定一个切入点表达式，Spring将在匹配表达式的连接点时织入该通知。
pointcut-ref	该属性指定一个已经存在的切入点名称。通常pointcut和pointcut-ref两个属性只需要其中之一。
method	该属性指定一个方法名。指定将切面Bean中的该方法转换为增强处理。
throwing	该属性只对`<after-throwing>`元素有效，它用于指定一个形参名，异常通知方法可以通过该形参访问目标方法所抛出的异常。
returning	该属性只对`<after-returning>`元素有效。它用于指定一个形参名，后置通知方法可以通过该形参访问目标方法的返回值。

案例一：表示任意方法的任意类任意参数都走切面。

@Pointcut("execution(* com.lydms.jdk.*.*(..))")
  private void myPointCut(){
  }

案例二：public修饰符，在upload类下的。方法走切面。

@Pointcut("execution(public * com.lydms.controller.upload.*(..))")
    public void webLog() {
    }

二、动态代理

Sring AOP中的代理。可以是JDK动态代理，也可以是CGLIB代理。
JDK动态代理实现很简单，但是有一定局限性—使用动态代理的对象必须实现一个或多个接口。假如没有实现的，则使用CGLIB代理。

1、JDK动态代理

JDK动态代理通过java.lang.reflect.proxy来实现。可以调用Proxy类的newProxyInstance( )方法来创建代理对象。对于使用业务接口的类，Spring 默认使用JDK动态代理来实现AOP。

1)、UserDao接口

public interface UserDao {
  public void addUser();
  public void deleteUser();
}

2)、UserDaoImpl实现类

import org.springframework.stereotype.Repository;
// 目标类
@Repository("userDao")
public class UserDaoImpl implements UserDao {
  public void addUser() {
//    int i = 10/0;
    System.out.println("添加用户");
  }
  public void deleteUser() {
    System.out.println("删除用户");
  }
}

3)、代理实现类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.lydms.aspect.MyAspect;
/**
 * JDK代理类
 */
public class JdkProxy implements InvocationHandler{
  // 声明目标类接口
  private UserDao userDao;
  // 创建代理方法
  public  Object createProxy(UserDao userDao) {
    this.userDao = userDao;
    // 1.类加载器
    ClassLoader classLoader = JdkProxy.class.getClassLoader();
    // 2.被代理对象实现的所有接口
    Class[] clazz = userDao.getClass().getInterfaces();
    // 3.使用代理类，进行增强，返回的是代理后的对象
    return  Proxy.newProxyInstance(classLoader,clazz,this);
  }
  /*
   * 所有动态代理类的方法调用，都会交由invoke()方法去处理
   * proxy 被代理后的对象 
   * method 将要被执行的方法信息（反射） 
   * args 执行方法时需要的参数
   */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // 声明切面
    MyAspect myAspect = new MyAspect();
    // 前增强
    myAspect.check_Permissions();
    // 在目标类上调用方法，并传入参数
    Object obj = method.invoke(userDao, args);
    // 后增强
    myAspect.log();
    return obj;
  }
}

4)、测试类

public class JdkTest{
  public static void main(String[] args) {
    // 创建代理对象
    JdkProxy jdkProxy = new JdkProxy();
         // 创建目标对象
    UserDao userDao= new UserDaoImpl();
    // 从代理对象中获取增强后的目标对象
    UserDao userDao1 = (UserDao) jdkProxy.createProxy(userDao);
    // 执行方法
    userDao1.addUser();
    userDao1.deleteUser();
  }
}

执行结果：

2、CGLIB代理

是一个高性能的开源的代码生成包，采用非常底层字节码技术，对指定的目标类生成子类，并对子类进行加强。

1)、UserDao.java

//目标类
public class UserDao {
  public void addUser() {
    System.out.println("添加用户");
  }
  public void deleteUser() {
    System.out.println("删除用户");
  }
}

2)、代理类

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import com.lydms.aspect.MyAspect;
// 代理类
public class CglibProxy implements MethodInterceptor{
    // 代理方法
  public  Object createProxy(Object target) {
    // 创建一个动态类对象
    Enhancer enhancer = new Enhancer();
    // 确定需要增强的类，设置其父类
    enhancer.setSuperclass(target.getClass());
    // 添加回调函数
    enhancer.setCallback(this);
    // 返回创建的代理类
    return enhancer.create();
  }
  /**
   * proxy CGlib根据指定父类生成的代理对象
   * method 拦截的方法
   * args 拦截方法的参数数组
   * methodProxy 方法的代理对象，用于执行父类的方法 
   */
  @Override
  public Object intercept(Object proxy, Method method, Object[] args, 
                       MethodProxy methodProxy) throws Throwable {
         // 创建切面类对象
    MyAspect myAspect = new MyAspect();
    // 前增强
    myAspect.check_Permissions();
    // 目标方法执行
    Object obj = methodProxy.invokeSuper(proxy, args);
    // 后增强
    myAspect.log(); 
    return obj;
  }
}

3)、测试类

// 测试类
public class CglibTest {
  public static void main(String[] args) {
    // 创建代理对象
    CglibProxy cglibProxy = new CglibProxy();
          // 创建目标对象
    UserDao userDao = new UserDao();
         // 获取增强后的目标对象
    UserDao userDao1 = (UserDao)cglibProxy.createProxy(userDao);
    // 执行方法
    userDao1.addUser();
    userDao1.deleteUser();
  }
}

执行结果:

四、AspectJ开发

1、基于XML的声明式AspectJ

1) 简介

2) 切面类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
/**
 *切面类，在此类中编写通知
 */
public class MyAspect {
  // 前置通知
  public void myBefore(JoinPoint joinPoint) {
    System.out.print("前置通知 ：模拟执行权限检查...,");
    System.out.print("目标类是："+joinPoint.getTarget() );
    System.out.println(",被织入增强处理的目标方法为："
                            +joinPoint.getSignature().getName());
  }
  // 后置通知
  public void myAfterReturning(JoinPoint joinPoint) {
    System.out.print("后置通知：模拟记录日志...," );
    System.out.println("被织入增强处理的目标方法为："
                          + joinPoint.getSignature().getName());
  }
  /**
   * 环绕通知
   * ProceedingJoinPoint 是JoinPoint子接口，表示可以执行目标方法
   * 1.必须是Object类型的返回值
   * 2.必须接收一个参数，类型为ProceedingJoinPoint
   * 3.必须throws Throwable
   */
  public Object myAround(ProceedingJoinPoint proceedingJoinPoint) 
             throws Throwable {
    // 开始
    System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
    // 执行当前目标方法
    Object obj = proceedingJoinPoint.proceed();
    // 结束
    System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
    return obj;
  }
  // 异常通知
  public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
    System.out.println("异常通知：" + "出错了" + e.getMessage());
  }
  // 最终通知
  public void myAfter() {
    System.out.println("最终通知：模拟方法结束后的释放资源...");
  }
}

3) 注解

<?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"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
  <!-- 1 目标类 -->
  <bean id="userDao" class="com.lydms.jdk.UserDaoImpl" />
  <!-- 2 切面 -->
  <bean id="myAspect" class="com.lydms.aspectj.xml.MyAspect" />
  <!-- 3 aop编程 -->
  <aop:config>
        <!-- 配置切面 -->
    <aop:aspect ref="myAspect">
      <!-- 3.1 配置切入点，通知最后增强哪些方法 -->
      <aop:pointcut expression="execution(* com.lydms.jdk.*.*(..))"
                                              id="myPointCut" />
      <!-- 3.2 关联通知Advice和切入点pointCut -->
      <!-- 3.2.1 前置通知 -->
      <aop:before method="myBefore" pointcut-ref="myPointCut" />
      <!-- 3.2.2 后置通知,在方法返回之后执行，就可以获得返回值
       returning属性：用于设置后置通知的第二个参数的名称,类型是Object -->
      <aop:after-returning method="myAfterReturning"
        pointcut-ref="myPointCut" returning="returnVal" />
      <!-- 3.2.3 环绕通知 -->
      <aop:around method="myAround" pointcut-ref="myPointCut" />
      <!-- 3.2.4 抛出通知：用于处理程序发生异常-->
      <!-- * 注意：如果程序没有异常，将不会执行增强 -->
      <!-- * throwing属性：用于设置通知第二个参数的名称，类型Throwable -->
      <aop:after-throwing method="myAfterThrowing"
        pointcut-ref="myPointCut" throwing="e" />
      <!-- 3.2.5 最终通知：无论程序发生任何事情，都将执行 -->
      <aop:after method="myAfter" pointcut-ref="myPointCut" />
    </aop:aspect>
  </aop:config>
</beans>

4) 测试类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.lydms.jdk.UserDao;
// 测试类
public class TestXmlAspectj {
  public static void main(String args[]) {
    String xmlPath = 
                         "com/lydms/aspectj/xml/applicationContext.xml";
    ApplicationContext applicationContext = 
                          new ClassPathXmlApplicationContext(xmlPath);
    // 1 从spring容器获得内容
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    // 2 执行方法
    userDao.addUser();
  }
}

2、基于注解的声明式AspectJ

1）注解及其描述：

注解名称	描述
@Aspect	用于定义一个切面。
@Pointcut	用于定义切入点表达式。在使用时，还需要定义方法签名(包含名字和任意参数)，来表示切入点名称。
@Before	用于定义前置通知。相当于BeforeAdvice。通常指定一个value值，用来指定切入点表达式。
@AfterReturning	用于定义后置通知。相当于AfterReturningAdvice。
@Around	用于定义环绕通知。相当于MethodInterceptor。
@AfterThrowing	用于定义异常通知来处理程序中未处理的异常。相当于ThrowAdvice。
@After	用于定义最终final通知。无论是否异常，都会执行。
@DeclareParents	用于定义引介通知，相当于IntroductionInterceptor。

2）切面类：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
/**
 * 切面类，在此类中编写通知
 */
@Aspect
@Component
public class MyAspect {
  // 定义切入点表达式
  @Pointcut("execution(* com.lydms.jdk.*.*(..))")
  // 使用一个返回值为void、方法体为空的方法来命名切入点
  private void myPointCut(){}
  // 前置通知
  @Before("myPointCut()")
  public void myBefore(JoinPoint joinPoint) {
    System.out.print("前置通知 ：模拟执行权限检查...,");
    System.out.print("目标类是："+joinPoint.getTarget() );
    System.out.println(",被织入增强处理的目标方法为："
                   +joinPoint.getSignature().getName());
  }
  // 后置通知
  @AfterReturning(value="myPointCut()")
  public void myAfterReturning(JoinPoint joinPoint) {
    System.out.print("后置通知：模拟记录日志...," );
    System.out.println("被织入增强处理的目标方法为："
                  + joinPoint.getSignature().getName());
  }
  // 环绕通知 
  @Around("myPointCut()")
  public Object myAround(ProceedingJoinPoint proceedingJoinPoint) 
            throws Throwable {
    // 开始
    System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
    // 执行当前目标方法
    Object obj = proceedingJoinPoint.proceed();
    // 结束
    System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
    return obj;
  }
  // 异常通知
  @AfterThrowing(value="myPointCut()",throwing="e")
  public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
    System.out.println("异常通知：" + "出错了" + e.getMessage());
  }
  // 最终通知
  @After("myPointCut()")
  public void myAfter() {
    System.out.println("最终通知：模拟方法结束后的释放资源...");
  }
}

3）注解配置要扫描的包：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:aop="http://www.springframework.org/schema/aop"
  http://www.springframework.org/schema/context/spring-context-4.3.xsd">
      <!-- 指定需要扫描的包，使注解生效 -->
      <context:component-scan base-package="com.lydms" />
      <!-- 启动基于注解的声明式AspectJ支持 -->
      <aop:aspectj-autoproxy />
</beans>

4）测试类：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.lydms.jdk.UserDao;
// 测试类
public class TestAnnotationAspectj {
  public static void main(String args[]) {
    String xmlPath = 
                  "com/lydms/aspectj/annotation/applicationContext.xml";
    ApplicationContext applicationContext = 
                 new ClassPathXmlApplicationContext(xmlPath);
    // 1 从spring容器获得内容
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    // 2 执行方法
    userDao.addUser();
  }
}

五、Spring boot集成AspectJ开发

1、Pom.xml

<!--不指定版本的原因,如不指定版本,会默认下载springboot对应版本的jar -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2、Controller.java

import com.lydms.common.Result;
import com.lydms.pojo.English;
import com.lydms.service.WordAddService;
import org.apache.commons.lang.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
@RestController
@RequestMapping("/add")
public class WordAddController {
    private static final Logger logger = LogManager.getLogger(WordAddController.class);
    @Autowired
    private WordAddService wordAddService;
    /**
     * 添加英语
     * @throws Exception
     */
    @RequestMapping(value = "/english", method = {RequestMethod.POST})
    public ApiResult addEnglish(@RequestBody English en) {
//        1、将单词存入数据库
        English result = wordAddService.addEnglish(en);
        return ApiResult.succ(result);
    }
}

3、切面类(Aspect.java)

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
@Aspect
@Order(5)
@Component
public class ControllerAspect {
    private static final Logger logger = LogManager.getLogger(ControllerAspect.class);
    private ThreadLocal<Long> startTime = new ThreadLocal<Long>();
    @Autowired
    private ObjectMapper mapper;
    public ControllerAspect() {
    }
    @Pointcut("execution(public * com.ldyms.controller.*.*(..))")
    public void webLog() {
    }
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        startTime.set(System.currentTimeMillis());
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        Enumeration<String> enums = request.getParameterNames();
        ArrayList params = new ArrayList();
        while (enums.hasMoreElements()) {
            String paraName = enums.nextElement();
            String param = paraName + ":" + request.getParameter(paraName);
            params.add(param);
        }
        logger.info("request Url:{},Params:{}",(request.getRequestURL().toString()),params);
        logger.info("request Methods:{}", Arrays.toString(joinPoint.getArgs()));
    }
    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        logger.info("RESPONSE: {} ", this.mapper.writeValueAsString(ret));
        logger.info("SPEND TIME: {} ms", System.currentTimeMillis() - startTime.get());
    }
}

Spring AOP使用

一、简介

二、重点解析

1、代理分类

2、切入点位置配置(expression)

3、配置通知

二、动态代理

1、JDK动态代理

2、CGLIB代理

四、AspectJ开发

1、基于XML的声明式AspectJ

2、基于注解的声明式AspectJ

五、Spring boot集成AspectJ开发

1、Pom.xml

2、Controller.java

3、切面类(Aspect.java)

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Spring AOP使用

一、简介

二、重点解析

1、代理分类

2、切入点位置配置(expression)

3、配置通知

二、动态代理

1、JDK动态代理

2、CGLIB代理

四、AspectJ开发

1、基于XML的声明式AspectJ

2、基于注解的声明式AspectJ

五、Spring boot集成AspectJ开发

1、Pom.xml

2、Controller.java

3、切面类(Aspect.java)

热门文章

最新文章

相关课程

相关电子书