update comment

Author: jarry

programming-paradigm/aop/go/aop.go

@@ -2,15 +2,14 @@ package main
 
 import (
   "fmt"
+  "reflect"
 )
 
 /*
 AOP（面向切面编程）是一种编程范式，通过分离横切关注点来提高模块性。
 横切关注点是跨越应用程序多个部分的功能，比如日志记录、事务管理等。
-Go语言没有直接的动态代理机制，但可以通过接口和函数包装实现AOP。
-Go这种机构相比动态代理更加巧妙和高性能，但代码会比较啰嗦，每个类都要单独写
+Go语言没有直接的动态代理机制，但可以反射来达成动态代理。
 */
-
 // 1. 定义业务接口
 type UserService interface {
   AddUser(username string)
@@ -39,32 +38,48 @@ func (l *LoggingAspect) After() {
   fmt.Println("后置通知: 操作执行完成")
 }
 
-// 4. 创建动态代理类
-type UserServiceProxy struct {
-  target UserService
-  aspect *LoggingAspect
+// 通用代理函数
+func createProxy(target interface{}, aspect *LoggingAspect, methodName string, args ...interface{}) {
+  // 前置通知
+  aspect.Before()
+
+  // 获取目标对象的反射值
+  targetValue := reflect.ValueOf(target)
+
+  // 获取目标方法
+  method := targetValue.MethodByName(methodName)
+
+  if method.IsValid() {
+    // 准备参数
+    in := make([]reflect.Value, len(args))
+    for i, arg := range args {
+      in[i] = reflect.ValueOf(arg)
+    }
+
+    // 调用目标方法
+    method.Call(in)
+  }
+
+  // 后置通知
+  aspect.After()
 }
 
-// 代理类构造函数，传入目标对象和切面对象
-func NewUserServiceProxy(target UserService, aspect *LoggingAspect) UserService {
-  return &UserServiceProxy{target: target, aspect: aspect}
+// 4. 创建动态代理结构体
+type DynamicServiceProxy struct {
+  target interface{}
+  aspect *LoggingAspect
 }
 
-// 每个函数都实现相一遍，增加前后调用
-func (p *UserServiceProxy) AddUser(username string) {
-  p.aspect.Before()
-  p.target.AddUser(username)
-  p.aspect.After()
+// 代理结构体构造函数
+func NewDynamicServiceProxy(target interface{}, aspect *LoggingAspect) *DynamicServiceProxy {
+  return &DynamicServiceProxy{target: target, aspect: aspect}
 }
 
-// 每个函数都实现相一遍，增加前后调用
-func (p *UserServiceProxy) DeleteUser(userId int) {
-  p.aspect.Before()
-  p.target.DeleteUser(userId)
-  p.aspect.After()
+// 通用方法调用代理
+func (p *DynamicServiceProxy) Call(methodName string, args ...interface{}) {
+  createProxy(p.target, p.aspect, methodName, args...)
 }
 
-// 5. 测试AOP
 func main() {
   // 创建目标对象
   userService := &UserServiceImpl{}
@@ -73,11 +88,11 @@ func main() {
   aspect := &LoggingAspect{}
 
   // 创建代理对象
-  proxy := NewUserServiceProxy(userService, aspect)
+  proxyService := NewDynamicServiceProxy(userService, aspect)
 
   // 通过代理对象调用方法
-  proxy.AddUser("张三")
-  proxy.DeleteUser(101)
+  proxyService.Call("AddUser", "张三")
+  proxyService.Call("DeleteUser", 101)
 }
 
 /*

programming-paradigm/aop/java/AOP.java

@@ -1,98 +1,111 @@
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
-
+import java.util.ArrayList;
+import java.util.List;
 /*
 AOP（面向切面编程）是一种编程范式，通过分离横切关注点来提高模块性。
 横切关注点是跨越应用程序多个部分的功能，比如日志记录、事务管理等。
 在 Java 中，主要是通过 Java 的反射机制和动态代理来实现 AOP 。
 态代理允许在运行时创建一个实现了特定接口的代理对象，我们可以在代理对象的方法调用前后插入额外的逻辑，从而实现 AOP 的功能。
 */
 
-// 1. 定义业务接口
-interface UserService {
-    void addUser(String username);
+// 1. 定义通用的切面接口（可扩展）
+interface Aspect {
+    void before(Method method, Object[] args);
 
-    void deleteUser(int userId);
+    void after(Method method, Object result);
 }
 
-// 2. 实现业务接口
-class UserServiceImpl implements UserService {
+// 2. 日志切面实现
+class LoggingAspect implements Aspect {
     @Override
-    public void addUser(String username) {
-        System.out.println("添加用户: " + username);
+    public void before(Method method, Object[] args) {
+        System.out.println("前置通知: 调用 " + method.getName() + "，参数: " + java.util.Arrays.toString(args));
     }
 
     @Override
-    public void deleteUser(int userId) {
-        System.out.println("删除用户: " + userId);
+    public void after(Method method, Object result) {
+        System.out.println("后置通知: " + method.getName() + " 执行完成，返回值: " + result);
     }
 }
 
-// 3. 定义切面类
-class LoggingAspect {
-    public void before() {
-        System.out.println("前置通知: 准备执行操作");
+// 3. 通用动态代理类
+class DynamicProxy implements InvocationHandler {
+    private final Object target; // 目标对象
+    private final List<Aspect> aspects; // 切面列表
+
+    public DynamicProxy(Object target, List<Aspect> aspects) {
+        this.target = target;
+        this.aspects = aspects;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        for (Aspect aspect : aspects) {
+            aspect.before(method, args);
+        }
+        Object result = method.invoke(target, args); // 调用目标方法
+        for (Aspect aspect : aspects) {
+            aspect.after(method, result);
+        }
+        return result;
     }
 
-    public void after() {
-        System.out.println("后置通知: 操作执行完成");
+    // 创建代理对象的通用方法
+    @SuppressWarnings("unchecked")
+    public static <T> T createProxy(T target, List<Aspect> aspects) {
+        return (T) Proxy.newProxyInstance(
+                target.getClass().getClassLoader(),
+                target.getClass().getInterfaces(),
+                new DynamicProxy(target, aspects));
     }
 }
 
-// 4. 创建动态代理类
-class UserServiceProxy implements InvocationHandler {
-    private Object target; // 目标对象（被代理的对象）
-    private LoggingAspect aspect; // 切面对象（包含横切逻辑）
+// 4. 业务接口
+interface UserService {
+    void addUser(String username);
 
-    // 构造函数，传入目标对象和切面对象
-    public UserServiceProxy(Object target, LoggingAspect aspect) {
-        this.target = target;
-        this.aspect = aspect;
+    void deleteUser(int userId);
+}
+
+// 5. 业务实现类
+class UserServiceImpl implements UserService {
+    @Override
+    public void addUser(String username) {
+        System.out.println("添加用户: " + username);
     }
 
-    // 实现 InvocationHandler 接口的 invoke 方法
     @Override
-    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-        aspect.before(); // 前置通知：在目标方法执行前调用
-        Object result = method.invoke(target, args); // 调用目标方法
-        aspect.after(); // 后置通知：在目标方法执行后调用
-        return result; // 返回目标方法的执行结果
+    public void deleteUser(int userId) {
+        System.out.println("删除用户: " + userId);
     }
 }
 
-// 5. 测试AOP
+// 6. 测试 AOP 代理
 public class AOP {
     public static void main(String[] args) {
         // 创建目标对象
         UserService userService = new UserServiceImpl();
 
-        // 创建切面对象
-        LoggingAspect aspect = new LoggingAspect();
+        // 创建切面列表
+        List<Aspect> aspects = new ArrayList<>();
+        aspects.add(new LoggingAspect()); // 可以添加多个切面
 
-        // 通过动态代理创建代理对象
-        UserService proxy = (UserService) Proxy.newProxyInstance(
-                userService.getClass().getClassLoader(), // 目标类的类加载器
-                userService.getClass().getInterfaces(), // 目标类实现的接口
-                new UserServiceProxy(userService, aspect) // InvocationHandler 实现类
-        );
+        // 通过动态代理创建 UserService 代理对象
+        UserService proxy = DynamicProxy.createProxy(userService, aspects);
 
-        // 通过代理对象调用 UserService 的方法
-        // 调用 addUser 方法时，会先执行前置通知，再执行目标方法，最后执行后置通知
+        // 调用代理方法，自动执行 AOP 逻辑
         proxy.addUser("张三");
-
-        // 调用 deleteUser 方法时，同样会先执行前置通知，再执行目标方法，最后执行后置通知
         proxy.deleteUser(101);
     }
 }
-
 /*
- * jarry@Mac java % javac AOP.java
- * jarry@Mac java % java AOP
- * 前置通知: 准备执行操作
- * 添加用户: 张三
- * 后置通知: 操作执行完成
- * 前置通知: 准备执行操作
- * 删除用户: 101
- * 后置通知: 操作执行完成
+jarry@MacBook-Pro java % java AOP.java
+前置通知: 调用 addUser，参数: [张三]
+添加用户: 张三
+后置通知: addUser 执行完成，返回值: null
+前置通知: 调用 deleteUser，参数: [101]
+删除用户: 101
+后置通知: deleteUser 执行完成，返回值: null
  */