从回调与代理认识AOP

1509 字

4 分钟

从回调与代理认识AOP

2026-01-29

SSM 企业级开发框架

反射

/

回调方法

/

代理模式

/

AOP

/

编程范式

/

设计模式

介绍#

了解AOP(目前只了解Java AOP)，你需要了解：回调函数、反射、代理模式(jdk动态代理,cglib不做考虑)之前写的不好，所以重写了一下(全由Java实现)，作为个人的复习^3^

回调方法#

Callback、控制反转

方法内部执行步骤已经规定，缺省的逻辑由回调函数根据实际需求补全，将核心代码交给使用者编写

[!details] 详细解释 A想使用B设计的代码，其中的大部分功能符合A需求，但是A仍不满足，如果代码是写死的话，A还要重构一下并自己封装，冗余而不方便。假设B的代码将A想重写的部分抽离出去，其余部分做一个框架，A就只需要写核心的代码即可，非常方便。所以被抽离的部分就是回调函数！想要实现这个思想，各个语言各有不同的方法(noob的猜测)；Java要实现回调函数，就要利用其重要的面向接口(Interface)思想

Java的实现回调步骤:实现类继承回调接口，写具体代码。Caller调用继承回调接口实例的方法。

1.回调接口

1
public interface CallBack {
2
  public void callBackMethod();
3
}

2.调用类

1
public class Caller {
2
    public void call(CallBack callBack) {
3
        System.out.println("写死的代码");
4
        callBack.callBackMethod();
5
        System.out.println("写死的代码");
6
    }
7
}

3.重写回调方法,为了方便使用匿名内部类

1
public static void main(){
2
  Caller caller = new Caller();
3
    caller.call(new CallBack(){
4
        @Override
5
        public void callBackMethod(){
6
            System.out.println("Hello I'm Oddpalmer");
7
        }
8
    });
9
}
10
/*
11
写死的代码
12
回调方法: Hello I'm Oddpalmer
13
写死的代码
14
*/

代理模式#

Proxy Pattern、设计模式

以明星和经纪人为例：对接、签约…，这些工作经纪人做就行，明星只需要唱歌、演戏…即可，这里经纪人就作了代理的工作，并且经纪人可以去为多个明星服务。

代理就是将非核心代码剥离出去，只关注对象本身的核心。非核心代码在AOP中称为通知(Advice)

静态代理#

Java实现代理的步骤

代理和被代理对象类继承同一个接口
代理的方法调用对象的同名方法依旧是面向接口编程

1.接口

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

2.实现类

1
public class UserServiceImpl implements UserService{
2
    @Override
3
    public void addUser(String name) {
4
        System.out.println("添加用户 " + name + " 成功");
5
    }
6
}

3.实现类代理

1
public class UserServiceProxy implements UserService{
2
    private UserService target;
3
    public UserServiceProxy(UserService target) {
4
        this.target = target;
5
    }
6
    @Override
7
    public void addUser(String name) {
8
        System.out.println("代理：[权限检查]");// 前置额外逻辑
9
        target.addUser(name); //UserService真实对象的核心业务逻辑
10
        System.out.println("代理：[日志上传]");// 后置额外逻辑
11
    }
12
}

4.Main

1
// 调用
2
public class ProxyTest {
3
    public static void main(String[] args) {
4
        UserService proxy = new UserServiceProxy(new UserServiceImpl());
5
        proxy.addUser("张三");
6
    }
7
}
8
/*  结果
9
  代理：[权限检查]
10
  添加用户 张三 成功
11
  代理：[日志上传]
12
*/

虽然静态代理能在一定程度上帮我们减少代码冗余，但是不难发现只有继承了UserService接口的类才可以被代理。如果我还有OrderService、ProductService也需要权限检查或者日志上传，就需要多个静态代理才可以实现，冗余而不优雅，这就引出了我们的动态代理。

动态代理#

coder手动创建的静态代理(麻烦) -> JVM用反射动态生成的静态代理(方便)；不了解反射的可以看博主的这篇文档待重构todo

因为静态代理要获取实现类接口，所以JVM也要知道你用的什么接口；因为是动态生成的，所以里面的步骤控制权要转让给编写代码的人，就要用回调接口的方法(invoke())。

以上是我对动态代理的核心理解，其本质就是由jvm创造的静态代理

jvm生成的一个动态代理类大致长这样，发现没有，和静态代理一样的，区别只是动态生成的(里面涉及了一个回调，我们稍后再讲)，DeepSeek给出的代码：

1
public final class $Proxy0 extends Proxy implements UserService {
2
    private static Method m_addUser;
3
    static {
4
        try {
5
            m_addUser = UserService.class
6
                    .getMethod("addUser", String.class);
7
        } catch (NoSuchMethodException e) {
8
            throw new RuntimeException(e);
9
        }
10
    }
11
    // 父类 Proxy 已经持有 InvocationHandler h
12
    public $Proxy0(InvocationHandler h) {
13
        super(h);
14
    }
15

16
    @Override
17
    public void addUser(String name) {
18
        try {
19
            // invoactionHandler.invoke(), 所有接口方法 → 回调调用者
20
            h.invoke(this, m_addUser, new Object[]{name});
21
        } catch (RuntimeException | Error e) {
22
            throw e;
23
        } catch (Throwable t) {
24
            throw new UndeclaredThrowableException(t);
25
        }
26
    }
27
}

如何生成一个动态代理类？Java给我们设计了 java.lang.reflect.Proxy 动态代理类。核心方法newProxyInstance()

1
public static Object newProxyInstance(
2
        ClassLoader loader,     // 用target类加载器
3
        Class<?>[] interfaces,  // 用target的接口：硬性规定只能代理接口
4
        InvocationHandler h    // 传入回调实现类: 要求重写回调方法
5
)

InvotationHandler 动态代理的回调接口

1
Interface InvotationHandler{
2
    public Object invoke(
3
      Object proxy,
4
      Method method,
5
      Object[] args) throws Throwable;
6
}

创造代理对象的步骤：

调用newProxyInstance()
将被代理对象的反射对象类加载器、接口参数传入
重写invocationHandler回调接口的invoke()

实际开发中，动态代理可以再封装成一个工具类，不用每次代理都去写一遍newProxyInstance()，简化代码

1
  public class ProxyUtil {
2
    @SuppressWarnings("unchecked")
3
    public static <T> T createProxy(T target) {
4
        return (T) Proxy.newProxyInstance(
5
                target.getClass().getClassLoader(),
6
                target.getClass().getInterfaces(),
7
                new InvocationHandler() {
8
                    @Override
9
                    // InvokeHandler接口定义的回调方法,控制权在程序员手里
10
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
11
                       System.out.println("[权限检测]");// 前置 额外逻辑
12
                       Object o = method.invoke(target, args);// 反射包下invoke 调用真实对象方法
13
                       System.out.println("[日志记录]");// 后置 额外逻辑
14
                       return o;
15
                    }
16
                }
17
        );
18
    }
19
}

调用了ProxyUtil

1
  UserService userServiceProxy = new ProxyUtil().createProxy(new UserServiceImple());
2
  userServiceProxy.addUser("oddpalmer");
3
  /*
4
    [权限检测]
5
    添加 oddpalmer 成功
6
    [日志记录]
7
  */