【面试必问】Spring核心之面向切面编程(AOP)

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: AOP(面向切面编程)是一种编程范式,用于将横切关注点(如日志记录、性能统计等)从主要业务逻辑中分离出来。通过将这些横切关注点与业务逻辑分离开来,可以提高代码的可重用性、可维护性和可扩展性。在AOP中,切面是一个模块化的单元,它封装了与横切关注点相关的行为,并可以在多个不同的应用程序中重用。切面可以通过一种称为“织入”的过程将其与主要业务逻辑相结合,从而创建一个完整的应用程序。

博主介绍: ✌博主从事应用安全和大数据领域,有8年研发经验,5年面试官经验,Java技术专家✌

Java知识图谱点击链接:体系化学习Java(Java面试专题)

💕💕 感兴趣的同学可以收藏关注下不然下次找不到哟💕💕

1686547256994.jpg

1、什么是 AOP

1.1、概述

AOP(面向切面编程)是一种编程范式,用于将横切关注点(如日志记录、性能统计等)从主要业务逻辑中分离出来。通过将这些横切关注点与业务逻辑分离开来,可以提高代码的可重用性、可维护性和可扩展性。在AOP中,切面是一个模块化的单元,它封装了与横切关注点相关的行为,并可以在多个不同的应用程序中重用。切面可以通过一种称为“织入”的过程将其与主要业务逻辑相结合,从而创建一个完整的应用程序。

1.2、AOP 的作用

AOP 的作用主要有以下几个方面:

1. 代码复用:AOP 可以将一些通用的功能,如日志记录、安全控制等,抽象出来形成切面,这些切面可以被多个模块或应用程序共享,从而避免了代码重复。

2. 降低耦合度:AOP 可以将一些横跨多个模块的关注点从业务逻辑中解耦出来,使得应用程序更加模块化,降低了各个模块之间的耦合度。

3. 提高代码可维护性:AOP 可以将一些非核心的功能从主要业务逻辑中分离出来,使得代码更加清晰、易于维护。

4. 提高代码可扩展性:AOP 可以在不修改主要业务逻辑的情况下,通过增加新的切面来扩展应用程序的功能。

5. 提高代码的灵活性:AOP 可以在运行时动态地将切面织入到主要业务逻辑中,从而可以根据不同的需求对应用程序进行配置和定制。

1.3、AOP 的应用场景

AOP 的应用场景比较广泛,以下是一些常见的应用场景:

  1. 日志记录:通过 AOP 可以在方法执行前后记录日志,方便开发人员对系统进行调试和问题排查。

  2. 安全控制:通过 AOP 可以在方法执行前进行权限校验,从而保证系统的安全性。

  3. 缓存管理:通过 AOP 可以在方法执行前后对数据进行缓存,从而提高系统的性能。

  4. 事务管理:通过 AOP 可以在方法执行前后进行事务管理,从而保证系统的数据一致性。

  5. 性能统计:通过 AOP 可以在方法执行前后进行性能统计,从而方便开发人员对系统进行性能优化。

  6. 异常处理:通过 AOP 可以在方法执行过程中捕获异常,并进行统一的处理,从而提高系统的健壮性和稳定性。

  7. 分布式追踪:通过 AOP 可以在方法执行前后进行分布式追踪,从而方便开发人员对系统进行分布式调试和问题排查。

2、AOP 的配置方式

AOP 的配置方式主要有两种:基于 XML 的配置和基于注解的配置。

2.1、基于 XML 的配置方式

基于 XML 的配置方式需要在 Spring 的配置文件中定义切面、切点、通知等元素,并使用 元素将它们组合起来。以下是一个基于 XML 的 AOP 配置的示例:

<!-- 定义切面 -->
<bean id="loggingAspect" class="com.example.LoggingAspect"/>
 <!-- 定义切点 -->
<aop:pointcut id="serviceMethod" expression="execution(* com.example.Service.*(..))"/>
 <!-- 定义通知 -->
<aop:advisor advice-ref="loggingAdvice" pointcut-ref="serviceMethod"/>
 <!-- 定义通知实现类 -->
<bean id="loggingAdvice" class="org.springframework.aop.interceptor.CustomizableTraceInterceptor">
    <property name="enterMessage" value="Entering $[methodName]($[arguments])"/>
    <property name="exitMessage" value="Leaving $[methodName](): $[returnValue]"/>
</bean>
 <!-- 启用 AOP -->
<aop:config/>

上述配置文件定义了一个名为 loggingAspect 的切面,一个名为 serviceMethod 的切点,一个名为 loggingAdvice 的通知实现类,并将通知绑定到切点上。这个示例的作用是在 com.example.Service 包下的所有方法执行前后打印日志。

2.2、基于注解的配置方式

基于注解的配置方式需要在 Java 类中使用注解来标记切面、切点、通知等元素。以下是一个基于注解的 AOP 配置的示例:

@Aspect
@Component
public class LoggingAspect {
   

    @Pointcut("execution(* com.example.Service.*(..))")
    public void serviceMethod() {
   }

    @Before("serviceMethod()")
    public void beforeAdvice() {
   
        System.out.println("Entering method...");
    }

    @AfterReturning("serviceMethod()")
    public void afterAdvice() {
   
        System.out.println("Leaving method...");
    }
}

上述代码定义了一个名为 LoggingAspect 的切面,使用 @Pointcut 注解定义了一个名为 serviceMethod 的切点,并使用 @Before 和 @AfterReturning 注解定义了两个通知方法。这个示例的作用与前面的示例相同,都是在 com.example.Service 包下的所有方法执行前后打印日志。

3、AOP 实现原理

AOP 的实现原理主要是基于动态代理和字节码操作。Spring AOP 使用了 JDK 动态代理和 CGLIB 字节码操作两种方式来实现 AOP。

JDK 动态代理是通过反射机制在运行时动态地创建代理对象,代理对象与目标对象实现了相同的接口,并在代理对象中增加了切面逻辑。以下是一个使用 JDK 动态代理实现 AOP 的示例代码:

public interface UserService {
   
    void addUser(String name);
}

public class UserServiceImpl implements UserService {
   
    public void addUser(String name) {
   
        System.out.println("addUser: " + name);
    }
}

public class UserServiceProxy implements InvocationHandler {
   

    private Object target;

    public UserServiceProxy(Object target) {
   
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        System.out.println("before addUser");
        Object result = method.invoke(target, args);
        System.out.println("after addUser");
        return result;
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        UserService userService = new UserServiceImpl();
        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                new UserServiceProxy(userService));
        proxy.addUser("John");
    }
}

上述代码中, UserService 接口定义了一个 addUser 方法, UserServiceImpl 类是 UserService 接口的实现类。 UserServiceProxy 类是代理类,实现了 InvocationHandler 接口,用于在代理对象的方法执行前后增加切面逻辑。 Main 类中使用 Proxy.newProxyInstance 方法创建代理对象,并调用 addUser 方法。

CGLIB 字节码操作是通过继承目标对象并重写目标方法的方式来实现 AOP,因此目标对象不需要实现接口。以下是一个使用 CGLIB 实现 AOP 的示例代码:

public class UserService {
   
    public void addUser(String name) {
   
        System.out.println("addUser: " + name);
    }
}

public class UserServiceInterceptor implements MethodInterceptor {
   
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
   
        System.out.println("before addUser");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("after addUser");
        return result;
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new UserServiceInterceptor());
        UserService userService = (UserService) enhancer.create();
        userService.addUser("John");
    }
}

上述代码中, UserService 类是目标对象, UserServiceInterceptor 类是拦截器类,实现了 MethodInterceptor 接口,用于在目标方法执行前后增加切面逻辑。 Main 类中使用 Enhancer 类创建代理对象,并调用 addUser 方法。

无论是使用 JDK 动态代理还是 CGLIB 字节码操作,AOP 的实现原理都是基于代理模式和字节码操作。通过在代理对象中增加切面逻辑,实现了对目标对象的增强。

4、什么是动态代理

动态代理是一种在运行时动态生成代理类的技术,可以在不修改原始代码的情况下,为类或对象添加一些额外的功能。动态代理通常用于实现 AOP(面向切面编程)和远程方法调用等场景。

动态代理的实现原理是通过 Java 反射机制,在运行时动态生成代理类。代理类实现了与目标类相同的接口,并在代理类中增加了额外的逻辑,例如记录日志、性能监控等。当调用代理对象的方法时,实际上是调用了代理类中的方法,代理类再调用目标对象的方法,并在方法执行前后执行额外的逻辑。

Java 中有两种动态代理方式:JDK 动态代理和 CGLIB 动态代理。JDK 动态代理是基于接口的代理,只能代理实现了接口的类。而 CGLIB 动态代理是基于继承的代理,可以代理任何类,但代理的类不能声明为 final 类型。

4.1、JDK 动态代理

JDK 动态代理是 Java 标准库中提供的一种动态代理实现方式,它可以在运行时动态生成代理类,并实现被代理接口的所有方法。JDK 动态代理主要依赖于 Java 的反射机制和 InvocationHandler 接口。

下面是一个简单的 JDK 动态代理的示例代码:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义一个接口
interface Hello {
   
    void sayHello();
}

// 实现接口的类
class HelloImpl implements Hello {
   
    public void sayHello() {
   
        System.out.println("Hello, world!");
    }
}

// 实现 InvocationHandler 接口的代理类
class HelloProxy implements InvocationHandler {
   
    private Object target;
     public HelloProxy(Object target) {
   
        this.target = target;
    }
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        System.out.println("Before method " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method " + method.getName());
        return result;
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        // 创建被代理对象
        Hello hello = new HelloImpl();
         // 创建代理对象
        Hello proxy = (Hello) Proxy.newProxyInstance(
            hello.getClass().getClassLoader(),
            hello.getClass().getInterfaces(),
            new HelloProxy(hello)
        );
         // 调用代理对象的方法
        proxy.sayHello();
    }
}

在上面的代码中,我们定义了一个接口 Hello 和一个实现该接口的类 HelloImpl 。接着我们定义了一个实现 InvocationHandler 接口的代理类 HelloProxy ,它的作用是在调用被代理对象的方法前后输出日志。最后我们在 main 函数中创建了被代理对象 HelloImpl 和代理对象 HelloProxy ,并通过 Proxy.newProxyInstance 方法生成了代理对象实例。当我们调用代理对象的 sayHello 方法时,实际上是调用了 HelloProxy 中的 invoke 方法,该方法会在调用被代理对象的 sayHello 方法前后输出日志。

JDK 动态代理的原理是通过反射机制在运行时动态生成代理类,并实现被代理接口的所有方法。当调用代理对象的方法时,实际上是调用了代理类中的方法,代理类再调用目标对象的方法,并在方法执行前后执行额外的逻辑。

4.2、CGLIB 动态代理

CGLIB 动态代理是一种基于继承的代理实现方式,它可以在运行时动态生成代理类,并继承被代理类。CGLIB 动态代理主要依赖于 ASM(一个 Java 字节码操作库)。

下面是一个简单的 CGLIB 动态代理的示例代码:

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

// 被代理类
class Hello {
   
    public void sayHello() {
   
        System.out.println("Hello, world!");
    }
}

// 实现 MethodInterceptor 接口的代理类
class HelloProxy implements MethodInterceptor {
   
     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
   
        System.out.println("Before method " + method.getName());
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After method " + method.getName());
        return result;
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        // 创建 Enhancer 对象
        Enhancer enhancer = new Enhancer();
        // 设置被代理类为父类
        enhancer.setSuperclass(Hello.class);
        // 设置回调函数
        enhancer.setCallback(new HelloProxy());
        // 创建代理对象
        Hello proxy = (Hello) enhancer.create();
        // 调用代理对象的方法
        proxy.sayHello();
    }
}

6、AOP 在项目中的应用

AOP(面向切面编程)是一种编程思想,它可以通过将横切关注点(如日志记录、性能统计、事务管理等)与业务逻辑分离,使得代码更加模块化、易于维护和扩展。在项目中,AOP 可以应用于很多场景,下面举例说明几个常见的应用场景。

  1. 日志记录
    在项目中,我们通常需要记录一些关键操作的日志,以便于后续排查问题。使用 AOP 可以很方便地实现日志记录,例如使用 Spring AOP,我们可以定义一个切面,通过在切面中定义一个方法,在方法中记录日志,并将该切面织入到需要记录日志的方法中。
  2. 安全控制
    在项目中,我们通常需要对一些敏感操作进行安全控制,例如需要登录才能访问某些页面或执行某些操作。使用 AOP 可以很方便地实现安全控制,例如使用 Spring Security,我们可以定义一个切面,在切面中判断用户是否已经登录,并根据需要进行权限控制。
  3. 性能统计
    在项目中,我们通常需要对一些关键操作进行性能统计,以便于优化系统性能。使用 AOP 可以很方便地实现性能统计,例如使用 Spring AOP,我们可以定义一个切面,在切面中记录方法的执行时间,并将该切面织入到需要进行性能统计的方法中。
  4. 事务管理
    在项目中,我们通常需要对一些关键操作进行事务管理,以保证数据的一致性和完整性。使用 AOP 可以很方便地实现事务管理,例如使用 Spring AOP,我们可以定义一个切面,在切面中开启事务、提交事务或回滚事务,并将该切面织入到需要进行事务管理的方法中。
    总之,AOP 在项目中的应用非常广泛,可以帮助我们更好地实现代码的分离和模块化,提高代码的可维护性和可扩展性。

    5、实践-手写一个 AOP 的案例

以下是一个基于Spring AOP实现日志记录的示例代码:

  1. 创建一个切面类:
@Aspect
@Component
public class LogAspect {
   
     private static final Logger LOGGER = LoggerFactory.getLogger(LogAspect.class);
     @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
   
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        LOGGER.info("Method {} execution time: {}ms", joinPoint.getSignature().getName(), endTime - startTime);
        return result;
    }
     @Before("execution(* com.example.demo.controller.*.*(..)) && args(request,..)")
    public void logBefore(JoinPoint joinPoint, HttpServletRequest request) {
   
        LOGGER.info("Request URL: {} {}", request.getMethod(), request.getRequestURL());
        LOGGER.info("Request parameters: {}", request.getParameterMap());
    }
}

这里定义了两个切点,一个是 @Around ,用于记录方法的执行时间,另一个是 @Before ,用于记录请求的参数。

  1. 在Spring Boot主类中添加 @EnableAspectJAutoProxy 注解:
@SpringBootApplication
@EnableAspectJAutoProxy
public class DemoApplication {
   
     public static void main(String[] args) {
   
        SpringApplication.run(DemoApplication.class, args);
    }
 }
  1. 测试

编写一个简单的Controller:

@RestController
public class HelloController {
   
     @GetMapping("/hello")
    public String hello(@RequestParam("name") String name) {
   
        return "Hello, " + name;
    }
}

启动应用,访问 http://localhost:8080/hello?name=world,可以在控制台看到类似如下的日志:

2021-09-23 16:53:11.453  INFO 12345 --- [nio-8080-exec-1] c.e.d.aop.LogAspect                     : Request URL: GET http://localhost:8080/hello
2021-09-23 16:53:11.454  INFO 12345 --- [nio-8080-exec-1] c.e.d.aop.LogAspect                     : Request parameters: {
   name=[world]}
2021-09-23 16:53:11.454  INFO 12345 --- [nio-8080-exec-1] c.e.d.aop.LogAspect                     : Method hello execution time: 4ms

可以看到,请求的参数和方法的执行时间都被记录下来了。

1686494501743.jpg

💕💕 本文由激流创作,原创不易,感谢支持!!!
💕💕喜欢的话记得点赞收藏啊!!!

相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
目录
相关文章
|
2月前
Micronaut AOP与代理机制:实现应用功能增强,无需侵入式编程的秘诀
AOP(面向切面编程)能够帮助我们在不修改现有代码的前提下,为应用程序添加新的功能或行为。Micronaut框架中的AOP模块通过动态代理机制实现了这一目标。AOP将横切关注点(如日志记录、事务管理等)从业务逻辑中分离出来,提高模块化程度。在Micronaut中,带有特定注解的类会在启动时生成代理对象,在运行时拦截方法调用并执行额外逻辑。例如,可以通过创建切面类并在目标类上添加注解来记录方法调用信息,从而在不侵入原有代码的情况下增强应用功能,提高代码的可维护性和可扩展性。
59 1
|
3天前
|
安全 Java 编译器
什么是AOP面向切面编程?怎么简单理解?
本文介绍了面向切面编程(AOP)的基本概念和原理,解释了如何通过分离横切关注点(如日志、事务管理等)来增强代码的模块化和可维护性。AOP的核心概念包括切面、连接点、切入点、通知和织入。文章还提供了一个使用Spring AOP的简单示例,展示了如何定义和应用切面。
30 1
什么是AOP面向切面编程?怎么简单理解?
|
8天前
|
XML Java 开发者
论面向方面的编程技术及其应用(AOP)
【11月更文挑战第2天】随着软件系统的规模和复杂度不断增加,传统的面向过程编程和面向对象编程(OOP)在应对横切关注点(如日志记录、事务管理、安全性检查等)时显得力不从心。面向方面的编程(Aspect-Oriented Programming,简称AOP)作为一种新的编程范式,通过将横切关注点与业务逻辑分离,提高了代码的可维护性、可重用性和可读性。本文首先概述了AOP的基本概念和技术原理,然后结合一个实际项目,详细阐述了在项目实践中使用AOP技术开发的具体步骤,最后分析了使用AOP的原因、开发过程中存在的问题及所使用的技术带来的实际应用效果。
29 5
|
25天前
|
设计模式 缓存 Java
面试题:谈谈Spring用到了哪些设计模式?
面试题:谈谈Spring用到了哪些设计模式?
|
28天前
|
Java 数据库连接 Spring
【2021Spring编程实战笔记】Spring开发分享~(下)
【2021Spring编程实战笔记】Spring开发分享~(下)
25 1
|
2月前
|
缓存 前端开发 Java
【Java面试题汇总】Spring,SpringBoot,SpringMVC,Mybatis,JavaWeb篇(2023版)
Soring Boot的起步依赖、启动流程、自动装配、常用的注解、Spring MVC的执行流程、对MVC的理解、RestFull风格、为什么service层要写接口、MyBatis的缓存机制、$和#有什么区别、resultType和resultMap区别、cookie和session的区别是什么?session的工作原理
【Java面试题汇总】Spring,SpringBoot,SpringMVC,Mybatis,JavaWeb篇(2023版)
|
30天前
|
Java 程序员 Spring
Spring事务的1道面试题
每次聊起Spring事务,好像很熟悉,又好像很陌生。本篇通过一道面试题和一些实践,来拆解几个Spring事务的常见坑点。
Spring事务的1道面试题
|
2月前
|
缓存 Java 数据库
【Java面试题汇总】Spring篇(2023版)
IoC、DI、aop、事务、为什么不建议@Transactional、事务传播级别、@Autowired和@Resource注解的区别、BeanFactory和FactoryBean的区别、Bean的作用域,以及默认的作用域、Bean的生命周期、循环依赖、三级缓存、
【Java面试题汇总】Spring篇(2023版)
|
1月前
|
XML 前端开发 Java
Spring,SpringBoot和SpringMVC的关系以及区别 —— 超准确,可当面试题!!!也可供零基础学习
本文阐述了Spring、Spring Boot和Spring MVC的关系与区别,指出Spring是一个轻量级、一站式、模块化的应用程序开发框架,Spring MVC是Spring的一个子框架,专注于Web应用和网络接口开发,而Spring Boot则是对Spring的封装,用于简化Spring应用的开发。
86 0
Spring,SpringBoot和SpringMVC的关系以及区别 —— 超准确,可当面试题!!!也可供零基础学习
|
2月前
|
XML Java 开发者
经典面试---spring IOC容器的核心实现原理
作为一名拥有十年研发经验的工程师,对Spring框架尤其是其IOC(Inversion of Control,控制反转)容器的核心实现原理有着深入的理解。
99 3