SpringBoot | 1.3 约定编程Spring AOP

简介: 前面聊过Spring的一个很重要的概念,IoC控制反转,接下来就是AOP了;注:在说明注解时,第一点加粗为注解中文含义,第二点为一般加在哪身上,缩进或代码块为示例,如:**@注解** - **中文含义** - 加在哪 - 其他…… - `语句示例` ```java //代码示例 ```

1. AOP切面编程

面向切面编程,是利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

可以理解成“增强方法”,即:不通过修改源代码方式,在主干功能里面添加新功能。

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


20210614001813921.png

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

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

@Transactional

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


20210614163838914.png


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() {
     }

@Before、@AfterReturning、@After、@AfterThrowing、@Around

通知类型:均作用在方法上
注解 说明
@Before 前置通知
@AfterReturning 后置通知
@After 最终通知
@AfterThrowing 异常通知
@Around 环绕通知,需要大幅修改原有目标对象时使用

对于非环绕通知,可以使用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的指示器:


2021061419402844.png


*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;
          
            ......
      }
相关文章
|
9天前
|
人工智能 Java 机器人
基于Spring AI Alibaba + Spring Boot + Ollama搭建本地AI对话机器人API
Spring AI Alibaba集成Ollama,基于Java构建本地大模型应用,支持流式对话、knife4j接口可视化,实现高隐私、免API密钥的离线AI服务。
195 1
基于Spring AI Alibaba + Spring Boot + Ollama搭建本地AI对话机器人API
存储 JSON Java
164 0
|
16天前
|
人工智能 Java 开发者
【Spring】原理解析:Spring Boot 自动配置
Spring Boot通过“约定优于配置”的设计理念,自动检测项目依赖并根据这些依赖自动装配相应的Bean,从而解放开发者从繁琐的配置工作中解脱出来,专注于业务逻辑实现。
|
17天前
|
XML 安全 Java
使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
面向方面编程(AOP)通过分离横切关注点,如日志、安全和事务,提升代码模块化与可维护性。Spring 提供了对 AOP 的强大支持,核心注解 `@Aspect` 和 `@Pointcut` 使得定义切面与切入点变得简洁直观。`@Aspect` 标记切面类,集中处理通用逻辑;`@Pointcut` 则通过表达式定义通知的应用位置,提高代码可读性与复用性。二者结合,使开发者能清晰划分业务逻辑与辅助功能,简化维护并提升系统灵活性。Spring AOP 借助代理机制实现运行时织入,与 Spring 容器无缝集成,支持依赖注入与声明式配置,是构建清晰、高内聚应用的理想选择。
231 0
|
28天前
|
Java API 开发者
Spring 控制反转与依赖注入:从玄学编程到科学管理
在传统开发中,手动`new`对象导致紧耦合、难以维护和测试。控制反转(IoC)将对象创建交给框架,实现解耦。Spring通过IOC容器自动管理对象生命周期,开发者只需声明依赖,无需关心创建细节。依赖注入(DI)是IoC的具体实现方式,支持构造器、Setter和字段注入。构造器注入推荐使用,保证依赖不可变且易于测试。对于多个同类型Bean,可用`@Qualifier`或`@Primary`解决冲突。此外,Spring还支持依赖查找(DL),开发者主动从容器获取Bean,适用于动态场景,但侵入性强。掌握IoC与DI,有助于构建灵活、可维护的Spring应用。
|
29天前
|
人工智能 监控 安全
Spring AOP切面编程颠覆传统!3大核心注解+5种通知类型,让业务代码纯净如初
本文介绍了AOP(面向切面编程)的基本概念、优势及其在Spring Boot中的使用。AOP作为OOP的补充,通过将横切关注点(如日志、安全、事务等)与业务逻辑分离,实现代码解耦,提升模块化程度、可维护性和灵活性。文章详细讲解了Spring AOP的核心概念,包括切面、切点、通知等,并提供了在Spring Boot中实现AOP的具体步骤和代码示例。此外,还列举了AOP在日志记录、性能监控、事务管理和安全控制等场景中的实际应用。通过本文,开发者可以快速掌握AOP编程思想及其实践技巧。
|
1月前
|
设计模式 Java 开发者
如何快速上手【Spring AOP】?从动态代理到源码剖析(下篇)
Spring AOP的实现本质上依赖于代理模式这一经典设计模式。代理模式通过引入代理对象作为目标对象的中间层,实现了对目标对象访问的控制与增强,其核心价值在于解耦核心业务逻辑与横切关注点。在框架设计中,这种模式广泛用于实现功能扩展(如远程调用、延迟加载)、行为拦截(如权限校验、异常处理)等场景,为系统提供了更高的灵活性和可维护性。
|
1月前
|
人工智能 监控 安全
如何快速上手【Spring AOP】?核心应用实战(上篇)
哈喽大家好吖~欢迎来到Spring AOP系列教程的上篇 - 应用篇。在本篇,我们将专注于Spring AOP的实际应用,通过具体的代码示例和场景分析,帮助大家掌握AOP的使用方法和技巧。而在后续的下篇中,我们将深入探讨Spring AOP的实现原理和底层机制。 AOP(Aspect-Oriented Programming,面向切面编程)是Spring框架中的核心特性之一,它能够帮助我们解决横切关注点(如日志记录、性能统计、安全控制、事务管理等)的问题,提高代码的模块化程度和复用性。
|
10月前
|
Java 开发者 Spring
Spring AOP 底层原理技术分享
Spring AOP(面向切面编程)是Spring框架中一个强大的功能,它允许开发者在不修改业务逻辑代码的情况下,增加额外的功能,如日志记录、事务管理等。本文将深入探讨Spring AOP的底层原理,包括其核心概念、实现方式以及如何与Spring框架协同工作。
|
11月前
|
Java Spring 容器
Spring IOC、AOP与事务管理底层原理及源码解析
【10月更文挑战第1天】Spring框架以其强大的控制反转(IOC)和面向切面编程(AOP)功能,成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理,并通过源码解析来揭示其实现机制。同时,我们还将探讨Spring事务管理的核心原理,并给出相应的源码示例。
337 9