从代理模式到注解开发（一）

代理模式

package org.example.proxy;public class ProxyClient {public static void main(String[] args) {ProxyBuilder proxyBuilder = new ProxyBuilder();proxyBuilder.build();}
}interface BuildDream {void build();
}class CustomBuilder implements BuildDream {@Overridepublic void build() {System.out.println("自定义执行方法");}
}class ProxyBuilder implements BuildDream {private CustomBuilder customBuilder;@Overridepublic void build() {if (this.customBuilder == null) {this.customBuilder = new CustomBuilder();}System.out.println("代理执行前");customBuilder.build();System.out.println("代理执行后");}
}

执行结果：

代理执行前
自定义执行方法
代理执行后

动态代理

Java 动态代理是一种设计模式，允许在运行时创建代理对象，以拦截对目标对象的方法调用。动态代理通常用于横切关注点（如日志记录、事务管理、权限控制等）的实现。Java 提供了两种主要的动态代理机制：

JDK 动态代理：基于接口的代理。
CGLIB 动态代理：基于类的代理。

JDK 动态代理

JDK 动态代理使用 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来实现。它只能代理实现了接口的类。

示例代码

package org.example.proxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** JDK动态代理实现*/
public class DynamicProxy {public static void main(String[] args) {MyService myService = (MyService) MyServiceProxy.newProxyInstance(new MyServiceImpl());myService.saveInfo();}
}// 定义接口
interface MyService {void saveInfo();
}// 实现接口的类
class MyServiceImpl implements MyService {@Overridepublic void saveInfo() {System.out.println("保存信息成功");}
}class MyServiceProxy implements InvocationHandler {private Object target;MyServiceProxy(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("代理方法执行前");Object result = method.invoke(target, args);System.out.println("代理方法执行后");return result;}public static Object newProxyInstance(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new MyServiceProxy(target));}
}

执行结果：

代理方法执行前
保存信息成功
代理方法执行后

CGLIB 动态代理

CGLIB 动态代理使用字节码生成库来生成代理类，它可以代理没有实现接口的类。

示例代码

package org.example.proxy;import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/*** CGLIB实现动态代理*/
public class CGLibProxy {public static void main(String[] args) {HerService herService = (HerService) ProxyServiceInterceptor.newProxyInstance(new HerService());herService.saveInfo();herService.sayHello();}
}class HerService {public void saveInfo() {System.out.println("保存信息成功");}public void sayHello() {System.out.println("Hi");}
}class ProxyServiceInterceptor implements MethodInterceptor {private Object target;ProxyServiceInterceptor(Object target) {this.target = target;}@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("代理方法执行前");Object result = methodProxy.invokeSuper(o, objects);System.out.println("代理方法执行后");return result;}public static Object newProxyInstance(Object target) {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(target.getClass());enhancer.setCallback(new ProxyServiceInterceptor(target));return enhancer.create();}
}

运行结果：

代理方法执行前
保存信息成功
代理方法执行后
代理方法执行前
Hi
代理方法执行后

总结

JDK 动态代理：适用于代理实现了接口的类。
CGLIB 动态代理：适用于代理没有实现接口的类。

这两种动态代理机制都可以用于实现 AOP（面向切面编程），以便在不修改目标对象代码的情况下添加额外的功能。

AOP

AOP（面向切面编程）是一种编程范式，它允许你在不修改业务逻辑代码的情况下，添加横切关注点（如日志记录、事务管理、权限控制等）。Spring Framework 提供了强大的 AOP 支持，主要通过以下几种方式实现：

基于代理的 AOP：使用 JDK 动态代理或 CGLIB 动态代理。
基于注解的 AOP：使用注解来定义切面和切点。
基于 XML 配置的 AOP：使用 XML 配置文件来定义切面和切点。

基于注解的 AOP 示例

下面是一个使用 Spring AOP 和注解的示例，展示了如何在 Spring 应用程序中使用 AOP。

1. 添加依赖

首先，确保你的项目中包含 Spring AOP 相关的依赖。如果你使用的是 Maven，可以在 pom.xml 中添加以下依赖：

<dependencies><!-- Spring AOP --><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.3.10</version></dependency><!-- AspectJ --><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.3.10</version></dependency>
</dependencies>

2. 定义业务逻辑类

定义一个简单的业务逻辑类：

package com.example.service;import org.springframework.stereotype.Service;@Service
public class HelloService {public void sayHello() {System.out.println("Hello, World!");}
}

3. 定义切面类

定义一个切面类，使用注解来指定切点和通知：

package com.example.aspect;import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {@Before("execution(* com.example.service.HelloService.sayHello(..))")public void logBefore() {System.out.println("Before method call");}@After("execution(* com.example.service.HelloService.sayHello(..))")public void logAfter() {System.out.println("After method call");}
}

4. 配置 Spring 应用程序

创建一个 Spring 配置类，启用 AOP 支持：

package com.example.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;@Configuration
@ComponentScan(basePackages = "com.example")
@EnableAspectJAutoProxy
public class AppConfig {
}

5. 测试代码

编写一个测试类来验证 AOP 的效果：

package com.example;import com.example.config.AppConfig;
import com.example.service.HelloService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Main {public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);HelloService helloService = context.getBean(HelloService.class);helloService.sayHello();}
}

运行结果

当你运行测试代码时，输出将会是：

Before method call
Hello, World!
After method call

解释

业务逻辑类：HelloService 是一个简单的业务逻辑类，包含一个 sayHello 方法。
切面类：LoggingAspect 是一个切面类，包含两个通知方法 logBefore 和 logAfter，分别在 sayHello 方法调用之前和之后执行。
Spring 配置类：AppConfig 是一个 Spring 配置类，启用了 AOP 支持并扫描指定包中的组件。
测试代码：在测试代码中，通过 Spring 容器获取 HelloService 的代理对象，并调用 sayHello 方法。

总结

通过使用 Spring AOP 和注解，你可以在不修改业务逻辑代码的情况下，轻松地添加横切关注点。Spring AOP 提供了强大的功能和灵活性，使得代码更加模块化和可维护。

`@Before`中的参数

在 Spring AOP 中，@Before 注解用于定义一个前置通知（Advice），它会在目标方法执行之前执行。@Before 注解的参数是一个切点表达式，用于指定哪些方法应该被拦截。切点表达式可以使用多种方式来匹配目标方法，包括方法签名、注解、包名等。

常见的切点表达式

匹配方法签名：
- execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)
- 例如：execution(* com.example.service.HelloService.sayHello(..))
匹配类上的注解：
- @within(annotationType)
- 例如：@within(org.springframework.stereotype.Service)
匹配方法上的注解：
- @annotation(annotationType)
- 例如：@annotation(org.springframework.transaction.annotation.Transactional)
匹配包名：
- within(package-name)
- 例如：within(com.example.service..*)
匹配参数：
- args(argument-types)
- 例如：args(String, ..)

示例代码

以下是一些常见的 @Before 注解的使用示例：

1. 匹配特定方法

匹配 com.example.service.HelloService 类中的 sayHello 方法：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {@Before("execution(* com.example.service.HelloService.sayHello(..))")public void logBefore() {System.out.println("Before method call");}
}

2. 匹配特定包中的所有方法

匹配 com.example.service 包及其子包中的所有方法：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {@Before("within(com.example.service..*)")public void logBefore() {System.out.println("Before method call");}
}

3. 匹配带有特定注解的方法

匹配带有 @Transactional 注解的方法：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {@Before("@annotation(org.springframework.transaction.annotation.Transactional)")public void logBefore() {System.out.println("Before transactional method call");}
}

4. 匹配带有特定参数的方法

匹配第一个参数为 String 类型的方法：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {@Before("args(java.lang.String, ..)")public void logBefore() {System.out.println("Before method call with String argument");}
}

组合切点表达式

你可以使用 &&、|| 和 ! 运算符来组合多个切点表达式。例如，匹配 com.example.service 包中的所有方法，并且这些方法带有 @Transactional 注解：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {@Before("within(com.example.service..*) && @annotation(org.springframework.transaction.annotation.Transactional)")public void logBefore() {System.out.println("Before transactional method call in service package");}
}