tip:作为程序员一定学习编程之道,一定要对代码的编写有追求,不能实现就完事了。我们应该让自己写的代码更加优雅,即使这会费时费力。
💕💕 推荐:体系化学习Java(Java面试专题)
1、什么是 AOP
1.1、概述
AOP(面向切面编程)是一种编程范式,用于将横切关注点(如日志记录、性能统计等)从主要业务逻辑中分离出来。通过将这些横切关注点与业务逻辑分离开来,可以提高代码的可重用性、可维护性和可扩展性。在AOP中,切面是一个模块化的单元,它封装了与横切关注点相关的行为,并可以在多个不同的应用程序中重用。切面可以通过一种称为“织入”的过程将其与主要业务逻辑相结合,从而创建一个完整的应用程序。
1.2、AOP 的作用
AOP 的作用主要有以下几个方面:
1. 代码复用:AOP 可以将一些通用的功能,如日志记录、安全控制等,抽象出来形成切面,这些切面可以被多个模块或应用程序共享,从而避免了代码重复。
2. 降低耦合度:AOP 可以将一些横跨多个模块的关注点从业务逻辑中解耦出来,使得应用程序更加模块化,降低了各个模块之间的耦合度。
3. 提高代码可维护性:AOP 可以将一些非核心的功能从主要业务逻辑中分离出来,使得代码更加清晰、易于维护。
4. 提高代码可扩展性:AOP 可以在不修改主要业务逻辑的情况下,通过增加新的切面来扩展应用程序的功能。
5. 提高代码的灵活性:AOP 可以在运行时动态地将切面织入到主要业务逻辑中,从而可以根据不同的需求对应用程序进行配置和定制。
1.3、AOP 的应用场景
AOP 的应用场景比较广泛,以下是一些常见的应用场景:
-
日志记录:通过 AOP 可以在方法执行前后记录日志,方便开发人员对系统进行调试和问题排查。
-
安全控制:通过 AOP 可以在方法执行前进行权限校验,从而保证系统的安全性。
-
缓存管理:通过 AOP 可以在方法执行前后对数据进行缓存,从而提高系统的性能。
-
事务管理:通过 AOP 可以在方法执行前后进行事务管理,从而保证系统的数据一致性。
-
性能统计:通过 AOP 可以在方法执行前后进行性能统计,从而方便开发人员对系统进行性能优化。
-
异常处理:通过 AOP 可以在方法执行过程中捕获异常,并进行统一的处理,从而提高系统的健壮性和稳定性。
-
分布式追踪:通过 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 可以应用于很多场景,下面举例说明几个常见的应用场景。
- 日志记录
在项目中,我们通常需要记录一些关键操作的日志,以便于后续排查问题。使用 AOP 可以很方便地实现日志记录,例如使用 Spring AOP,我们可以定义一个切面,通过在切面中定义一个方法,在方法中记录日志,并将该切面织入到需要记录日志的方法中。 - 安全控制
在项目中,我们通常需要对一些敏感操作进行安全控制,例如需要登录才能访问某些页面或执行某些操作。使用 AOP 可以很方便地实现安全控制,例如使用 Spring Security,我们可以定义一个切面,在切面中判断用户是否已经登录,并根据需要进行权限控制。 - 性能统计
在项目中,我们通常需要对一些关键操作进行性能统计,以便于优化系统性能。使用 AOP 可以很方便地实现性能统计,例如使用 Spring AOP,我们可以定义一个切面,在切面中记录方法的执行时间,并将该切面织入到需要进行性能统计的方法中。 - 事务管理
在项目中,我们通常需要对一些关键操作进行事务管理,以保证数据的一致性和完整性。使用 AOP 可以很方便地实现事务管理,例如使用 Spring AOP,我们可以定义一个切面,在切面中开启事务、提交事务或回滚事务,并将该切面织入到需要进行事务管理的方法中。
总之,AOP 在项目中的应用非常广泛,可以帮助我们更好地实现代码的分离和模块化,提高代码的可维护性和可扩展性。
6、实践-手写一个 AOP 的案例
以下是一个基于Spring AOP实现日志记录的示例代码:
- 创建一个切面类:
@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 ,用于记录请求的参数。
- 在Spring Boot主类中添加 @EnableAspectJAutoProxy 注解:
@SpringBootApplication
@EnableAspectJAutoProxy
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
- 测试
编写一个简单的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
可以看到,请求的参数和方法的执行时间都被记录下来了。
文章来源:https://www.toymoban.com/news/detail-757847.html
💕💕 本文由激流原创,首发于CSDN博客,博客主页 https://blog.csdn.net/qq_37967783?spm=1010.2135.3001.5421
💕💕喜欢的话记得点赞收藏啊文章来源地址https://www.toymoban.com/news/detail-757847.html
到了这里,关于【Java 初级】Spring核心之面向切面编程(AOP)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!