本文主要是介绍SpringBoot | 1.3 约定编程Spring AOP，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

前言

前面聊过Spring的一个很重要的概念，IoC控制反转，接下来就是AOP了；

1. AOP切面编程

面向切面编程，是利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
可以理解成“增强方法”，即：不通过修改源代码方式，在主干功能里面添加新功能。

Spring AOP是一种约定流程的编程，我们将这种流程成为约定，如下流程所示：

为什么使用AOP?
AOP最典型的应用实际就是数据库的管控，用户信息与用户角色信息一般要求要么一起成功，要么一起失败。这是OOP（面向对象编程）不能实现的。

除此之外，AOP可以减少大量重复的工作。

@Transactional

• 事务的
• 常用于需要事务处理的方法上；
• 大致流程为：Spring将方法织入以下流程图中，默认实现数据库连接的打开与关闭以及事务，也就是说将大量重复的try-catch-finally流程通过约定的方式抽取，给予默认实现；
• 这样我们只需要专注SQL语句的编写即可。

2. JDK动态代理底层原理

AOP底层使用动态代理，实际上有两种情况动态代理；第一种是有接口情况，使用JDK动态代理，创建接口实现类代理对象，增强类的方法；第二种没有接口情况，使用CGLIB动态代理，创建子类的代理对象，增强类的方法。这里只讨论有接口的JDK动态代理方式。

在JDK动态代理场景中，主要使用java.lang.reflect.Proxy类里面的newProxyInstance方法创建代理对象

//Proxy类里newProxyInstance方法的源码
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {
    Objects.requireNonNull(h);
    Class<?> caller = System.getSecurityManager() == null ? null : Reflection.getCallerClass();
    Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);
    return newProxyInstance(caller, cons, h);
}

newProxyInstance方法的作用是：返回指定接口的代理类的实例，该接口方法调用分派给指定的调用处理程序。

查阅源码可知，在该方法中，有三个参数：

• 第一参数：类加载器；
• 第二参数：增强方法所在的类，这个类实现的接口，支持多个接口；
• 第三参数：实现接口InvocationHandler，创建代理对象，写增强的部分；

//InvocationHandler接口源码：
public interface InvocationHandler {
    Object invoke(Object var1, Method var2, Object[] var3) throws Throwable;
}

查阅源码可知，该接口定义了一个invoke方法，这个方法就是实现代理对象的逻辑，也是我们要实现的方法。

然后通过目标对象（target）、方法（method）和参数（args）反射方法运行。

3. 使用AOP开发

在本小节里比较重要的是第1)和2)点，第3)点不常用。

1) 确定连接点

因为Spring AOP只能对方法进行拦截，因此需要确定拦截什么方法，让其编入约定的流程中。

• 这里只专注@AspectJ的注解方式，对userService.printUser()方法进行增强。

用户服务接口

public interface UserService {
    public void printUser(User user);
}

用户服务接口实现类

@Service
public class UserServiceImpl implements UserService{
    @Override
    public void printUser(User user) { 
        if( user == null){
        	throw new RuntimeException("检查用户参数是否为空");
        }
        System.out.print("id = " + user.getId());
        System.out.print("\tusername = " + user.getUseranme());
        System.out.print("\tnote = " + user.getNote());
    }
}

2) 配置不同类型的通知（切点、切面、环绕等通知）

通过切面可以描述AOP其他信息，用以描述流程的织入。

• 可以理解成在这里在这里实现对Bean的功能增强。

@Aspect

• 切面
• 常用于增强类上；
• Spring以@Aspect注解声明切面；

@Order

• 增强次序
• 常用于增强类上；
• 当多个增强类对同一个方法进行增强，设置增强类优先级，数字越小优先级越高；
• 也可以使用Ordered接口实现（不推荐，推荐注解）

  @Aspect
  //@Order(1) //该注解相当于下面对接口的实现
  public class MyAspect implements Ordered {
  	//指定顺序
  	@Override
  	public int getOrdered() {
  		return 1;
  	}
  }
  

@Pointcut

• 切点
• 用于方法上；
• 描述哪些类的哪些方法需要启用AOP编程，在后面通知注解中可以使用方法名称pointCut()定义；
• 本例中前置、后置、最终和异常通知使用了切点描述，环绕通知类型也可转成切点描述；

   @Pointcut("execution(* com.dlhjw.springboot.service.impl.UserServiceImpl.printUser(..))")
   public void pointCut() {
   }
  

通知类型：均作用在方法上

对于非环绕通知，可以使用JoinPoint连接点获取需要增强方法的参数：

• 例子在下方前置通知上

对于环绕通知，可以使用ProceedingsJoinPoint类型的参数。

@Component
@Aspect
//@Order(1)
public class MyAspect{
   //相同切入点抽取，并命名为pointCut()
   @Pointcut("execution(* com.dlhjw.springboot.service.impl.UserServiceImpl.printUser(..))")
   public void pointCut() {
   }

   //前置通知
   @Before("pointCut()" && args(user))
   public void beforeParam(JoinPoint point, User user) {
   	//获取到args[0] = user
   	Object[] args = point.getArgs();
       System.out.println("before.........");
   }

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

   //最终通知
   @After("pointCut()")
   public void after() {
       System.out.println("after.........");
   }

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

   //环绕通知
   @Around("execution(* com.dlhjw.springboot.service.impl.UserServiceImpl.printUser(..))")
   public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
       System.out.println("环绕之前.........");
       //被增强的方法执行
       proceedingJoinPoint.proceed();
       System.out.println("环绕之后.........");
   }
}

其中execution(* com.dlhjw.springboot.service.impl.UserServiceImpl.printUser(..))表示正则式：

• execution 表示在执行时拦截正则匹配的方法；
• * 表示任意返回类型的方法；
• com.dlhjw.springboot.service.impl.UserServiceImpl 表示指定目标对象的全类名；
• printUser 表示指定目标对象的方法；
• (..) 表示任意参数进行匹配。

对于正则式而言，还可以使用AspectJ的指示器：

*3) 引入新的类增强服务

当我们需要利用外部类对方法进行增强时，即：对userService.printUser()方法进行非空校验时。

用户检测的接口UserValidator

public interface UserValidator {
	//检测用户对象是否为空
	public boolean validate(User user);
}

UserValidator的实现类

public class UserValidatorImpl implements UserValidator {
	@Override
	public boolean validate(User user) {
		System.out.println("引入新的接口：" + UserValidator.class.getSimpleName());
		return user != null;
	}
}

@DeclareParents

• 引入声明

• 用于属性上；

• 引入新的类来增强服务，其必须有两个配置属性value和defaultImpl；

  • value 指要增强功能的目标对象；
  • defaultImpl 引入增强功能的类，这里配置UserValidatorImpl，用来提供校验用户是否为空的功能。

  @Component
  @Aspect
  public class MyAspect{
  	@DeclareParents(value= "com.dlhjw.springboot.service.impl.UserServiceImpl+", defaultImpl=UserValidatorImpl.class)
  	public UserValidator userValidator;
  	
      ......
  }
  

最后

新人制作，如有错误，欢迎指出，感激不尽！ 欢迎关注公众号，会分享一些更日常的东西！ 如需转载，请标注出处！

这篇关于SpringBoot | 1.3 约定编程Spring AOP的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！