SpringBoot之AOP

面向切面编程(Aspect Oriented Programming, AOP)。它能够建立一种横向关系,对业务类使用横切技术,将多个类的公共方法抽取出来,留下业务核心方法,这样将业务类的关注点变成了核心关注点和横切关注点。

Springboot之AOP的Demo

  1. 新建spring项目。
    pom.xml

    <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-aopartifactId>
    dependency>
    
  2. Service层

package com.boot.bootaop.service;

import com.boot.bootaop.pojo.User;

import java.util.List;

/**
 * @description 操作User 的接口
 */
public interface UserService {
    //查询功能
    List<User> getUsers();
}
package com.boot.bootaop.service.impl;

import com.boot.bootaop.pojo.User;
import com.boot.bootaop.service.UserService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public List<User> getUsers() {
        System.out.println("getUsers");
        List<User> list = new ArrayList<>();
        list.add(new User("ww",22));
        return list;
    }
}
  1. Aspect类
package com.boot.bootaop.aspect;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * Aspect 注解让Spring知道这是一个切面程序
 * @description 切面类
 */
@Aspect
@Component
public class UserAspect {

    /**
     * 前置通知
     */
    @Before("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void before(){
        System.out.println("before...");
    }

    /**
     * 后置通知
     */
    @After("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void after(){
        System.out.println("after...");
    }

    /**
     * 返回通知
     */
    @AfterReturning("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }

    /**
     * 异常通知
     */
    @AfterThrowing("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }
}

  1. 测试类Controller
package com.boot.bootaop.controller;

import com.boot.bootaop.pojo.User;
import com.boot.bootaop.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @description 测试
 */
@RestController
public class MyController {

    @Autowired
    private UserService userService;

    @GetMapping("/get")
    public List<User> get(){
        return userService.getUsers();
    }
}

  1. 查看运行结果
    SpringBoot之AOP_第1张图片SpringBoot之AOP_第2张图片

“execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(…) )” 是一个切入点,是一个正则表达式,标明什么情况下启用AOP。

AOP术语

  • 连接点(joinPoint): 就是拦截的方法。
  • 切点(pointCut): 一系列连接点的集合,对于一个切面而言,执行的不仅仅是一个类的某个方法 ,也可以是多个类的多个方法,根据正则表达式找到连接点。
  • 通知(Advice): 在连接点处,AOP执行的动作。主要有5种通知,前置通知(BeforeAdvice)、后置通知(AfterAdvice)、返回通知(AfterReturningAdvice)、异常通知(AfterThroeingAdvice)、环绕通知(AroundAdvice)。
  • 引入(introduction): 在被通知的类中引入字段和方法。
  • 目标对象(target): 被代理的对象,即包含连接点的对象。
  • 切面(aspect): 可以定义各类通知、切点和引入的内容。
  • 织入(weave): 把切面连接到应用程序生,并生成一个被通知的对象。

AOP详解

连接点与两种代理

PointCut源码

先查看PointCut的源码

public interface Pointcut {

	//在程序中一个类会被多个代理进行代理,Spring会进入责任链模式,这里返回一个类过滤器。
	ClassFilter getClassFilter();

	//返回一个方法匹配器
	MethodMatcher getMethodMatcher();

	// 默认Pointcut实例
	Pointcut TRUE = TruePointcut.INSTANCE;
}

再看MethodMatcher 的源码

public interface MethodMatcher {

	boolean matches(Method method, Class<?> targetClass);

	//返回值决定使用静态匹配器还是动态匹配器,true则使用动态匹配器。
	boolean isRuntime();

	boolean matches(Method method, Class<?> targetClass, Object... args);

	MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
}

两个matches方法,区别多了args参数,定义了两种匹配器,一种为静态匹配器,对方法的名称和入参类型进行一次匹配判断;另一种动态匹配器,因为参数的不同,每次增强方法都会进行判断。

JDK代理与cglib代理

SpringBoot有两种代理,JDK与cglib。引入spring-boot-starter-aop,默认启动AOP,也可以在配置文件中配置,spring.aop.auto = true。

使用配置文件进行配置,

spring:
  aop:
    proxy-target-class: true

默认为true,即使用cglib代理,false则使用jdk代理。
具体使用哪种代理,根据代理类是否实现了接口决定,如果实现接口则使用jdk代理;如果没有实现接口,就算设置 spring.aop.proxy-target-class=false,也会使用cglib代理。

也可以使用@EnableAspectJAutoProxy注解,表示启动AOP,优先级会高于application.xml。
第一个参数表示使用什么代理,true为cglib代理,默认为false。第二个参数表示在横切关注点中可以使用AopContext这个类。

@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true,exposeProxy = true)
@PropertySource(value = "classpath:application.xml",ignoreResourceNotFound = true)
public class JdkProxyTest {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        UserService userService = (UserService) context.getBean("userService");
        System.out.println(userService.getClass().getName());
    }
}
//代理类
public List<User> getUsers() {
		//System.out.println("getUsers ");
        System.out.println("getUsers "+ AopContext.currentProxy());
        List<User> list = new ArrayList<>();
        list.add(new User("ww",22));
        return list;
    }

切面

就是我们前面用@Aspect注解的类,有了连接点后,我们就需要切面来增强功能。

  • 定义切面。需要@Aspect说明注解的类是一个切面,在使用@Component注解将切面交给Spring的IOC容器进行管理。

  • 增强功能。对切点做一些增强操作:前置增强,后置增强等。

切点

切点就是一些连接点二点集合。
之前在每个注解上都写了匹配的正则表达式,比较复杂,可以使用@PointCut注解进行简化。
对之前的切点进行简化

@Aspect
@Component
public class UserAspect {

    @Pointcut("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void pointCut(){}

    /**
     * 前置通知
     */
    @Before("pointCut()")
    public void before(){
        System.out.println("before...");
    }

    /**
     * 后置通知
     */
    @After("pointCut()")
    public void after(){
        System.out.println("after...");
    }

    /**
     * 返回通知
     */
    @AfterReturning("pointCut()")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }

    /**
     * 异常通知
     */
    @AfterThrowing("pointCut()")
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }
}

切点表达式

切点表达式的语法:
execution ( [可见性] 返回类型 [声明类型].方法名(参数)[异常] )

常见通配符和运算符如下:

  • * :匹配所有字符。
  • .. :匹配多个参数。
  • + :匹配类及其子类。
  • &&、||、!:运算符。

指示符:

  • execution:匹配执行连接点指示符。
  • within: 匹配连接点的类或者包。
  • this: 向通知方法传入代理对象。
  • target: 向通知方法传入目标对象。
  • args: 根据目标方法的参数进行匹配。
  • @within: 在类上的匹配注解类型。
  • annotation(): 限定带有指定注解的连接点。

多个切面与@Order

多个切面的顺序如何确定,使用Order注解。

@Aspect
@Order(1)
@Component
public class UserAspect {

    @Pointcut("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void pointCut(){}

    /**
     * 前置通知
     */
    @Before("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void before(){
        System.out.println("before...");
    }
	...
}    

你可能感兴趣的:(SpringBoot,spring,spring,boot,java,aop)