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

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

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

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

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

image.png

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 的配置文件中定义切面、切点、通知等元素,并使用 aop:config 元素将它们组合起来。以下是一个基于 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();
    }
}

5、AOP 在项目中的应用

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

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

6、实践-手写一个 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

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

image.png

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

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。