罗罗编程学习记录
本页内容 展开查看

01.3.2.4 代理模式

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解

覆盖范围

  • 代理模式的角色、意图与四种典型变体
  • Java 静态代理、JDK 动态代理(InvocationHandler 与 Proxy)
  • CGLIB 字节码增强与 JDK 动态代理的对比与取舍
  • Spring AOP 的两种代理落地与自调用陷阱
  • Go 没有动态代理时的接口包装、代码生成与手动转发
  • Python __getattr__ 与描述符实现代理
  • C# DispatchProxy、TypeScript Proxy 与 get/set trap
  • Rust Deref 与 newtype 包装
  • 远程代理、虚拟代理、保护代理的真实形态
  • 代理与装饰器、适配器的边界,以及代理带来的性能与调试成本

面试题索引

编号 题目 难度 状态 备注
01.3.2.4-001 静态代理怎么写?优缺点是什么? 基础 已完成 手写代理类
01.3.2.4-002 JDK 动态代理的 InvocationHandler 与 Proxy 怎么协作? 进阶 已完成 接口代理原理
01.3.2.4-003 CGLIB 字节码增强和 JDK 动态代理有什么区别? 进阶 已完成 子类代理与限制
01.3.2.4-004 Spring AOP 的两种代理怎么选?自调用为什么失效? 高级 已完成 事务失效经典题
01.3.2.4-005 Go 没有动态代理时怎么做? 进阶 已完成 接口包装与代码生成
01.3.2.4-006 Python 怎么用 __getattr__ 与描述符实现代理? 进阶 已完成 动态语言拦截
01.3.2.4-007 C# 的 DispatchProxy 和 Castle DynamicProxy 怎么用? 进阶 已完成 运行时代理
01.3.2.4-008 TypeScript 的 Proxy 与 get/set trap 能做什么? 进阶 已完成 元编程拦截
01.3.2.4-009 Rust 怎么用 Deref 与 newtype 做包装? 高级 已完成 所有权约束下的代理
01.3.2.4-010 远程代理、虚拟代理、保护代理分别长什么样? 进阶 已完成 四种变体
01.3.2.4-011 代理、装饰器、适配器三者怎么区分? 基础 已完成 意图分类
01.3.2.4-012 代理带来的性能与调试成本有哪些? 高级 已完成 反射开销与栈深
01.3.2.4-013 自调用陷阱的本质是什么?怎么绕过? 高级 已完成 this 调用不走代理

01.3.2.4-001 静态代理怎么写?优缺点是什么?

一句话结论

静态代理就是手写一个与目标实现同一接口的类,内部持有目标对象引用,在每个方法里做前置/后置处理后再委托调用;它最直观,但接口方法一多就要写大量样板转发代码。

概念解释

  • 三个角色:抽象主题(接口)、真实主题(业务实现)、代理主题(包装类)。
  • 代理必须与真实主题实现同一接口,调用方拿到的是接口类型,无法区分。
  • 静态代理的代理类在编译期就写好,没有反射,调用链最短。

原理流程

  1. 定义业务接口。
  2. 真实类实现接口,只写业务逻辑。
  3. 代理类实现同一接口,构造时接收真实对象。
  4. 代理方法内做横切逻辑(日志、权限、计时),然后调用真实对象同名方法。

代码或图示

public interface UserService {
    User getById(Long id);
}

public class UserServiceImpl implements UserService {
    public User getById(Long id) { return new User(id); }
}

public class UserServiceLogProxy implements UserService {
    private final UserService target;
    public UserServiceLogProxy(UserService target) { this.target = target; }

    public User getById(Long id) {
        long t = System.nanoTime();
        User u = target.getById(id);
        System.out.println("getById cost " + (System.nanoTime() - t));
        return u;
    }
}

常见误区

  • 代理类里写业务规则:代理只承载横切逻辑,业务仍在真实主题。
  • 代理类不实现接口而是继承真实类:继承会绑定具体实现,无法替换目标,也不符合面向接口。
  • 一个代理类做多种增强:按职责拆分,日志、事务、权限分别写代理,再组合。

追问

  • 静态代理和直接修改真实类有什么区别?答:真实类保持纯净,横切逻辑可独立复用、独立测试,且可在运行期决定是否包代理。
  • 接口有 20 个方法还要每个都手写转发吗?答:这就是静态代理的痛点,应改用动态代理或默认方法基类。

01.3.2.4-002 JDK 动态代理的 InvocationHandler 与 Proxy 怎么协作?

一句话结论

JDK 动态代理在运行期为目标实现的接口生成一个代理类,所有方法调用都被转发到 InvocationHandler.invoke,由你在 invoke 里统一决定前置、后置与目标反射调用;它只能代理接口,不能代理普通类。

概念解释

  • Proxy.newProxyInstance:生成代理类实例,参数为类加载器、接口数组、调用处理器。
  • InvocationHandler.invoke:代理对象每个方法调用都进入这里,参数为代理实例、Method 对象、参数数组。
  • 生成的代理类默认继承 Proxy,因此只能实现接口,不能继承类。

原理流程

  1. 目标类实现一个或多个接口。
  2. 实现 InvocationHandler,在 invoke 中写横切逻辑并 method.invoke(target, args)。
  3. 调用 Proxy.newProxyInstance 传入接口与处理器。
  4. 调用方持有接口引用,调用方法时进入处理器。

代码或图示

public class LogHandler implements InvocationHandler {
    private final Object target;
    public LogHandler(Object target) { this.target = target; }

    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
        long t = System.nanoTime();
        try {
            return m.invoke(target, args);
        } finally {
            System.out.println(m.getName() + " cost " + (System.nanoTime() - t));
        }
    }
}

// 使用
UserService real = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    real.getClass().getClassLoader(),
    real.getClass().getInterfaces(),
    new LogHandler(real));
proxy.getById(1L);

常见误区

  • 在 invoke 里直接调用 proxy.xxx():会再次进入 invoke,造成无限递归。
  • 认为代理对象 equals/hashCode/toString 也会走业务逻辑:这三个方法默认会被转发到目标,若目标未实现,需自己处理。
  • 目标没有实现接口:JDK 动态代理直接失败,这是它和 CGLIB 的分水岭。

追问

  • 生成的代理类长什么样?答:它实现目标接口,每个方法都调用 handler.invoke(this, method, args),method 是接口方法的 Method 对象。
  • 为什么 equals 之类的方法要特殊处理?答:代理类继承自 Proxy,equals 等方法被调用时也会进入 invoke,若不区分可能导致两个代理对象比较时逻辑错乱。

01.3.2.4-003 CGLIB 字节码增强和 JDK 动态代理有什么区别?

一句话结论

CGLIB 通过 ASM 在运行期生成目标类的子类,重写其非 final 方法并织入拦截器,因此不需要目标实现接口;代价是不能代理 final 类与 final 方法,且对无参构造有要求(具体约束以所用版本为准,待确认)。

概念解释

  • CGLIB:字节码子类代理,底层是 ASM 操作字节码。
  • MethodInterceptor.intercept:所有非 final 方法调用进入这里。
  • 限制:final 方法无法被重写,拦截器织不进去;目标类若没有无参构造,代理类实例化会失败。

原理流程

  1. 判断目标是否实现接口。
  2. 有接口:JDK 动态代理更轻量。
  3. 无接口或配置强制 CGLIB:生成子类,非 final 方法被重写。
  4. 方法调用进入 intercept,由拦截器决定是否回调原方法。

代码或图示

// 无接口的类
public class OrderService {
    public void place(String orderId) { /* 下单 */ }
}

// CGLIB 子类代理
public class LogInterceptor implements MethodInterceptor {
    public Object intercept(Object obj, Method m, Object[] args, MethodProxy p)
            throws Throwable {
        long t = System.nanoTime();
        Object r = p.invokeSuper(obj, args);   // 调用父类(原类)方法
        System.out.println(m.getName() + " cost " + (System.nanoTime() - t));
        return r;
    }
}

// 使用(伪代码,具体 API 随 CGLIB 版本变化)
// Enhancer e = new Enhancer();
// e.setSuperclass(OrderService.class);
// e.setCallback(new LogInterceptor());
// OrderService proxy = (OrderService) e.create();

常见误区

  • 认为 CGLIB 一定比 JDK 快:早期版本 CGLIB 因反射调用少而占优,现代 JDK 对 JDK 代理做了内联优化,实际差异受场景与版本影响,不能脱离实测下结论。
  • final 类也能被代理:final 类无法被继承,CGLIB 直接失败。
  • 认为 CGLIB 代理对象和原对象是同一个类:代理类是子类,getClass() 返回的是 OrderService$$EnhancerByCGLIB$$xxx。

追问

  • Spring 为什么默认优先用 JDK 代理?答:JDK 代理只依赖接口,避免目标类构造器与 final 限制;当目标无接口或显式配置 proxyTargetClass=true 时才用 CGLIB。
  • CGLIB 对无参构造的要求是什么?答:生成子类需要实例化,若目标类只提供带参构造,子类无法通过默认构造链实例化,具体行为以所用 CGLIB/Spring 版本为准,建议实测验证。

01.3.2.4-004 Spring AOP 的两种代理怎么选?自调用为什么失效?

一句话结论

Spring AOP 根据目标 Bean 是否实现接口选择代理方式:有接口默认用 JDK 动态代理,无接口或配置 proxy-target-class=true 时用 CGLIB;同类内部 this.method() 不经过代理对象,因此 @Transactional、@Async 等注解会失效。

概念解释

  • Spring 容器中每个被切面修饰的 Bean 实际注入的是代理对象。
  • 代理对象持有目标实例,调用先经过拦截链(事务、日志、缓存)。
  • this 指向目标实例本身,不是代理对象,内部调用绕过了拦截链。

原理流程

  1. 容器启动时为目标 Bean 生成代理。
  2. 外部注入的是代理对象。
  3. 外部调用 proxy.method() → 拦截链 → 目标方法。
  4. 目标方法内部 this.method() → 直接调用目标方法,不经过代理。

代码或图示

@Service
public class OrderService {
    @Transactional
    public void createOrder() { /* ... */ }

    public void batchCreate() {
        this.createOrder();   // 失效:this 是目标对象,不是代理
    }
}

// 绕过方式 1:注入自己(通过上下文或 ObjectProvider)
@Autowired private OrderService self;
public void batchCreate() {
    self.createOrder();       // 走代理,事务生效
}

// 绕过方式 2:AopContext.currentProxy()
public void batchCreate() {
    ((OrderService) AopContext.currentProxy()).createOrder();
}

常见误区

  • 认为只要方法上加了 @Transactional 就一定有事务:同类内部调用不生效,这是 Spring 面试最高频陷阱之一。
  • 把代理对象强转回实现类:JDK 代理只实现接口,强转 OrderServiceImpl 会抛 ClassCastException。
  • 认为 private 方法也能被代理:受代理机制限制,private 方法无法被重写或拦截,注解不会生效。

追问

  • 为什么 Spring 不直接改字节码织入?答:Spring AOP 是运行期代理,不是编译期织入;需要编译期织入的场景应使用 AspectJ。
  • @Async 自调用为什么也失效?答:@Async 同样靠代理拦截并提交到线程池,自调用绕过代理后就是普通同步方法调用。

01.3.2.4-005 Go 没有动态代理时怎么做?

一句话结论

Go 没有反射生成类的能力,标准做法是定义接口、写一个持有接口字段的包装结构体,在每个方法里手动转发;横切逻辑多时可用代码生成工具(如 mockgen、自定义 go generate)批量生成包装代码。

概念解释

  • 接口是 Go 的解耦核心,包装结构体实现同一接口。
  • 手动转发:每个方法一行 return w.inner.Method(args)。
  • 代码生成:用 go generate 模板批量生成,避免手写样板。

原理流程

  1. 定义业务接口。
  2. 写包装结构体,持有接口字段。
  3. 为接口每个方法写转发方法,在里面插横切逻辑。
  4. 调用方依赖接口类型,注入包装后的实例。

代码或图示

package service

type UserService interface {
    GetByID(id int64) (*User, error)
}

// LoggingProxy 是静态代理
type LoggingProxy struct {
    inner UserService
}

func NewLoggingProxy(u UserService) *LoggingProxy {
    return &LoggingProxy{inner: u}
}

func (p *LoggingProxy) GetByID(id int64) (*User, error) {
    defer func(start time.Time) {
        log.Printf("GetByID id=%d cost=%v", id, time.Since(start))
    }(time.Now())
    return p.inner.GetByID(id)
}
// 代码生成思路:go:generate 模板
//go:generate mockgen -source=service.go -destination=mock_service.go

常见误区

  • 想在 Go 里搞「运行期生成代理类」:Go 的反射能力只能读写值与调用方法,不能生成新类型,这是语言限制。
  • 包装结构体不实现接口:调用方拿到的是具体类型,无法替换。
  • 在转发方法里复制业务逻辑:代理只做横切,业务必须 inner.XXX()。

追问

  • Go 里怎么做统一的错误处理/重试?答:写函数式中间件,把接口方法签名抽象成 func(context.Context) error 类,再用装饰器函数层层包裹,这比静态代理更灵活。
  • Go 接口隐式实现有什么好处?答:包装结构体不需要声明 implements,只要方法集匹配就自动满足接口, mock 与代理可以独立演进。

01.3.2.4-006 Python 怎么用 __getattr__ 与描述符实现代理?

一句话结论

Python 用 __getattr__ 拦截对不存在属性的访问,把访问转发到内部持有的真实对象;描述符(__get__/__set__)则在属性访问时插入逻辑,适合做懒加载、类型校验这类代理。

概念解释

  • __getattr__:只在常规属性查找失败时被调用,是「兜底转发」。
  • __getattribute__:每次属性访问都调用,更强大但容易递归。
  • 描述符:实现了 __get__ 的类,作为另一个类的类属性时,访问该属性会触发描述符协议。

原理流程

  1. 包装类持有真实对象。
  2. 实现 __getattr__,把找不到的属性 getattr(self._inner, name)。
  3. 需要懒加载时,用描述符在 __get__ 里首次访问才创建真实对象。

代码或图示

class LoggingProxy:
    def __init__(self, target):
        self._inner = target

    def __getattr__(self, name):
        attr = getattr(self._inner, name)
        if callable(attr):
            def wrapper(*args, **kwargs):
                print(f"call {name} args={args}")
                return attr(*args, **kwargs)
            return wrapper
        return attr


class LazyProxy:
    """描述符式懒加载代理"""
    def __init__(self, factory):
        self.factory = factory
        self._value = None

    def __get__(self, obj, objtype=None):
        if self._value is None:
            self._value = self.factory()
        return self._value

常见误区

  • 在 __getattr__ 里访问 self._inner 而没有判空:_inner 还没赋值时会递归触发 __getattr__,应直接用 object.__getattribute__。
  • 用 __getattribute__ 做转发却不调 super():会拦截所有属性访问,包括 _inner 自身,造成无限递归。
  • 认为 __getattr__ 能拦截魔术方法:魔术方法(__len__、__str__)通常在类上查找,__getattr__ 不一定被触发。

追问

  • __getattr__ 和 __getattribute__ 的区别?答:前者只在找不到属性时调用,后者每次都调用,后者更危险但更强大。
  • Python 标准库里有代理吗?答:functools.cached_property 本质是描述符式代理,weakref.proxy 是弱引用代理。

01.3.2.4-007 C# 的 DispatchProxy 和 Castle DynamicProxy 怎么用?

一句话结论

.NET 自带 DispatchProxy 通过 ProxyGenerator.CreateProxy 为接口生成运行时代理,所有方法进入 Invoke;功能更全的 Castle DynamicProxy 还能代理类与虚方法,是 ORM、AOP 框架常用的底层库。

概念解释

  • DispatchProxy:官方内置,只能代理接口,轻量。
  • Castle DynamicProxy:第三方库,可代理类与虚方法,支持拦截器链。
  • 两者都属于运行期 IL 生成,原理类似 CGLIB。

原理流程

  1. 继承 DispatchProxy,实现 Invoke。
  2. 调用 CreateProxy<TInterface, TProxy> 创建代理实例。
  3. 方法调用进入 Invoke,参数为 MethodInfo 与参数数组。

代码或图示

public class LoggingProxy : DispatchProxy
{
    public object? Target { get; set; }

    protected override object? Invoke(MethodInfo method, object?[] args)
    {
        var sw = Stopwatch.StartNew();
        try
        {
            return method.Invoke(Target, args);
        }
        finally
        {
            Console.WriteLine($"{method.Name} cost {sw.ElapsedMilliseconds}ms");
        }
    }

    public static T Create<T>(object target) where T : class
    {
        var proxy = (LoggingProxy)CreateProxy(typeof(T), typeof(LoggingProxy));
        proxy.Target = target;
        return (T)(object)proxy;
    }
}

// 使用
var real = new UserService();
var svc = LoggingProxy.Create<IUserService>(real);
svc.GetById(1);

常见误区

  • 认为 DispatchProxy 能代理类:它只能代理接口,要代理类用 Castle DynamicProxy。
  • 在 Invoke 里直接调用 proxy 上的方法:会再次进入 Invoke,无限递归。
  • 忘记把 Target 赋值:method.Invoke(null, args) 会抛空引用。

追问

  • ASP.NET Core 里有代理吗?答:Middleware 管道是函数式装饰链,不是对象代理;如要 AOP,常用 Scrutor 或 Castle DynamicProxy。
  • DispatchProxy 和 Emit 有什么关系?答:DispatchProxy 内部用 Emit 动态生成代理类 IL,原理与 CGLIB 类似但由 .NET 运行时提供。

01.3.2.4-008 TypeScript 的 Proxy 与 get/set trap 能做什么?

一句话结论

ES2015 的 Proxy 可以包装任意对象,拦截 get/set/apply/has 等十几种操作,用少量代码实现懒加载、校验、响应式、远程对象代理;Vue 3 的响应式系统就是基于 Proxy。

概念解释

  • Proxy(target, handler):返回新代理对象,目标对象不变。
  • trap:handler 上的方法,如 get、set、apply、has、ownKeys。
  • 与 Object.defineProperty 相比,Proxy 能拦截数组下标、新增属性、in 操作等。

原理流程

  1. 定义真实对象或函数。
  2. 写 handler,在需要的 trap 里插逻辑。
  3. 用 new Proxy(target, handler) 创建代理。
  4. 外部只操作代理对象,所有访问被拦截。

代码或图示

const user = { name: "Ann", age: 30 };

const guarded = new Proxy(user, {
  get(target, prop, receiver) {
    console.log(`read ${String(prop)}`);
    return Reflect.get(target, prop, receiver);
  },
  set(target, prop, value, receiver) {
    if (prop === "age" && (typeof value !== "number" || value < 0)) {
      throw new Error("age must be a non-negative number");
    }
    return Reflect.set(target, prop, value, receiver);
  },
});

guarded.age = 25;   // 正常
guarded.age = -1;  // 抛错
// 函数代理:拦截调用
const fn = (a: number, b: number) => a + b;
const traced = new Proxy(fn, {
  apply(target, thisArg, args) {
    console.log(`call`, args);
    return Reflect.apply(target, thisArg, args);
  },
});

常见误区

  • 认为 Proxy 改变了原对象:原对象不变,代理是新对象,target === proxy 为 false。
  • 忘记 Reflect 转发:trap 不调 Reflect 就等于丢弃了默认行为,会出各种诡异 bug。
  • 在 SSR 环境滥用 Proxy:某些环境(旧版 Node、序列化、Vue 2)对 Proxy 支持有限,要确认运行时。

追问

  • Vue 3 为什么用 Proxy 替代 defineProperty?答:defineProperty 无法拦截新增属性与数组下标,需要手动 $set;Proxy 能原生拦截这些操作。
  • Proxy 能递归吗?答:默认只代理一层,嵌套对象需要在 get 里递归返回新的 Proxy,Vue 3 的 reactive 就是这样做的。

01.3.2.4-009 Rust 怎么用 Deref 与 newtype 做包装?

一句话结论

Rust 没有运行期代理,惯用做法是用 newtype(struct W(T))包装内部类型,再实现 Deref/DerefMut 把方法访问转发到内部类型;需要在转发时插逻辑时,就显式写方法而不是依赖 Deref。

概念解释

  • newtype:把已有类型包在零开销结构体里,编译后与内部类型等价。
  • Deref:自动解引用,让 wrapper.method() 转发到 inner.method()。
  • 所有权约束:代理不能随意持有可变引用,需要 Rc/RefCell/Mutex 等内部可变性。

原理流程

  1. 定义 newtype 包装内部类型。
  2. 实现 Deref/DerefMut 指向内部类型。
  3. 需要插逻辑时,在 newtype 上显式定义同名方法,先做横切再 self.0.method()。
  4. 共享可变状态用 RefCell 或 Mutex。

代码或图示

use std::ops::{Deref, DerefMut};

struct UserService(InnerUserService);

impl Deref for UserService {
    type Target = InnerUserService;
    fn deref(&self) -> &Self::Target { &self.0 }
}

impl DerefMut for UserService {
    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }
}

// 需要插日志时,显式写方法覆盖 Deref
impl UserService {
    fn get_by_id(&self, id: u64) -> User {
        println!("get_by_id id={}", id);
        self.0.get_by_id(id)
    }
}

常见误区

  • 在 Deref 里插逻辑:Deref 是零开销抽象,频繁隐式转发会让代码难以追踪,横切逻辑应显式写方法。
  • newtype 想做运行期拦截:Rust 没有运行期方法拦截,所有包装在编译期定型。
  • 用 Rc<RefCell<T>> 做代理却不处理借用错误:运行时 panic 会传染,应谨慎使用。

追问

  • Rust 怎么做 AOP?答:没有运行期代理,惯用做法是用宏(macro_rules!)在编译期生成包装代码,或用函数式中间件把逻辑抽成高阶函数。
  • Deref 转发有什么风险?答:自动解引用可能让调用方误以为在操作包装类型,实际上操作的是内部类型,调试时栈帧会少一层。

01.3.2.4-010 远程代理、虚拟代理、保护代理分别长什么样?

一句话结论

远程代理把网络调用伪装成本地方法调用(RPC stub);虚拟代理在首次访问时才创建昂贵对象(懒加载);保护代理在调用前做权限校验,不通过就拒绝;三者都实现与真实对象相同的接口,对调用方透明。

概念解释

  • 远程代理:封装序列化、网络传输、反序列化,调用方像调本地方法。
  • 虚拟代理:占位对象,首次访问时才加载真实对象。
  • 保护代理:前置鉴权,拒绝未授权访问。
  • 缓存代理:结果缓存,避免重复计算。

原理流程

  1. 定义统一接口。
  2. 远程代理:方法内序列化参数 → 网络调用 → 反序列化返回。
  3. 虚拟代理:首次调用时 if real == null { real = load() },再转发。
  4. 保护代理:if !hasPermission(user, method) { throw },再转发。

代码或图示

// 远程代理:RPC stub
public class UserServiceRemoteProxy implements UserService {
    private final RpcChannel channel;
    public UserServiceRemoteProxy(String host) { this.channel = new RpcChannel(host); }

    public User getById(Long id) {
        byte[] req = Serializer.encode("getById", id);
        byte[] resp = channel.call("UserService", req);
        return Serializer.decode(resp, User.class);
    }
}
// 虚拟代理:懒加载
public class HeavyImageProxy implements Image {
    private HeavyImage real;
    private final String path;
    public HeavyImageProxy(String path) { this.path = path; }

    public void draw() {
        if (real == null) real = new HeavyImage(path);
        real.draw();
    }
}
// 保护代理:权限校验
public class SecuredUserService implements UserService {
    private final UserService target;
    private final SecurityContext ctx;
    public User getById(Long id) {
        if (!ctx.hasPermission("user:read")) {
            throw new SecurityException("no permission");
        }
        return target.getById(id);
    }
}

常见误区

  • 远程代理把网络异常吞掉:应把网络错误翻译成业务异常,否则调用方无法区分「用户不存在」和「服务不可用」。
  • 虚拟代理不处理并发:多线程首次加载会创建多个真实对象,需要加锁或用 Once。
  • 保护代理里写业务规则:权限校验是横切逻辑,业务规则仍在真实主题。

追问

  • Feign、gRPC stub 是代理吗?答:是远程代理,调用方写本地接口调用,框架生成 HTTP/RPC 请求。
  • MyBatis Mapper 接口是代理吗?答:是 JDK 动态代理,接口方法被翻译成 SQL 执行,属于「智能代理」的一种。

01.3.2.4-011 代理、装饰器、适配器三者怎么区分?

一句话结论

适配器转换接口以对齐期望;代理不改接口只控制访问;装饰器不改接口只叠加能力;三者结构相似(都持有被包装对象),区分看「改什么、为什么包装」。

概念解释

  • 适配器:接口不一致 → 转换签名与参数。
  • 代理:接口一致 → 控制是否放行、何时放行。
  • 装饰器:接口一致 → 在调用前后叠加功能。

原理流程

  1. 先看接口是否一致:不一致归适配器。
  2. 接口一致时,看包装目的:控制访问归代理,叠加功能归装饰。
  3. 多层叠加增强是装饰器典型形态,单一受控访问是代理典型形态。

代码或图示

接口不一致 ──> 适配器(转换签名/参数)
接口一致 ──> 代理(放行/懒加载/权限/远程)
接口一致 ──> 装饰(日志/缓存/压缩,可多层嵌套)

常见误区

  • 凭代码结构归类:结构相似不代表角色相同,必须看意图。
  • 把参数转换写进代理/装饰器:签名转换属于适配器职责。
  • 认为 Spring AOP 是纯装饰器:它是动态代理,承载横切增强,兼具装饰器式叠加与代理式拦截特征。

追问

  • 装饰器也能做权限校验,和保护代理有什么区别?答:装饰器的核心是增强,权限校验只是其中一种增强;保护代理的核心是控制访问,权限是其存在的理由。
  • 什么时候三者会组合出现?答:接入第三方 SDK 时先用适配器对齐接口,再用装饰器叠日志,再用保护代理做鉴权,三层各司其职。

01.3.2.4-012 代理带来的性能与调试成本有哪些?

一句话结论

动态代理引入反射调用、方法查找、栈帧加深,高频调用下有可观开销;调试时代理对象的类名与调用栈不直观,需要额外配置才能看到目标方法的真实参数与返回值。

概念解释

  • 反射开销:Method.invoke 比直接调用慢,尤其在 JIT 未内联时。
  • 栈帧加深:一次业务调用可能经过「代理 → 拦截器 → 目标」三四层栈。
  • 可读性:代理类名是 $Proxy0 或 $$EnhancerByCGLIB$$xxx,日志里难以辨认。

原理流程

  1. 高频路径评估代理开销:用 JMH 或等价基准测试。
  2. 对性能敏感路径:手写静态代理或用编译期织入(AspectJ)。
  3. 调试时配置 IDE 显示代理类源码,日志里打印方法名与参数。

代码或图示

一次普通调用:
  OrderService.createOrder()

经过 Spring AOP:
  JdkDynamicAopProxy.invoke()
    -> ReflectiveMethodInvocation.proceed()
      -> TransactionInterceptor.invoke()
        -> OrderService.createOrder()
栈帧多 3 层,反射调用 1 次

常见误区

  • 认为代理零成本:每次调用都有反射与拦截链开销,在热点循环里要算清楚。
  • 生产环境关闭所有日志切面:调试时没有日志,出问题时难以定位。
  • 用代理包装所有方法:按需代理,只在需要横切的方法上启用。

追问

  • AspectJ 编译期织入为什么更快?答:它在编译期直接把增强代码织入目标字节码,运行时没有反射与代理对象,调用就是普通方法调用。
  • 怎么在日志里看清代理调用?答:在拦截器里打印 method.getName()、参数数组与返回值,而不是只打印代理对象的 toString()。

01.3.2.4-013 自调用陷阱的本质是什么?怎么绕过?

一句话结论

自调用陷阱的本质是:代理对象持有目标对象,但目标对象内部的 this 指向自己,不是代理对象,因此内部调用不会经过拦截链;绕过方式是让调用方拿到代理引用(自注入、AopContext.currentProxy()、拆分类)。

概念解释

  • 代理对象 ≠ 目标对象:容器注入的是代理,目标对象内部 this 是目标。
  • 拦截链只挂在代理对象上,目标对象的方法调用是裸调用。
  • 典型受影响注解:@Transactional、@Async、@Cacheable、@Retryable。

原理流程

  1. 外部注入代理对象。
  2. 外部调用 proxy.method() → 拦截链 → 目标方法。
  3. 目标方法内部 this.internal() → 直接调用,绕过代理。
  4. 解决:把 internal() 移到另一个 Bean,或通过代理引用调用。

代码或图示

@Service
public class OrderService {
    @Autowired private ApplicationContext ctx;

    @Transactional
    public void createOrder() { /* ... */ }

    public void batch() {
        OrderService self = ctx.getBean(OrderService.class);
        self.createOrder();   // 走代理
    }
}

常见误区

  • 把 this 换成 getClass().newInstance():这创建了新对象,不是代理对象,事务仍不生效。
  • 认为 private 方法加事务也能生效:private 方法根本不在代理接口里,代理无法拦截。
  • 在接口默认方法里自调用:默认方法的 this 同样指向目标对象,陷阱依旧。

追问

  • 为什么不直接改字节码织入?答:Spring AOP 选择运行期代理是为了简单与可配置;要彻底避免自调用陷阱,可使用 AspectJ 编译期织入。
  • 自注入 @Lazy 是为什么?答:直接注入自己会循环依赖,加 @Lazy 注入代理,延迟到首次使用时才解析。

跨语言差异对照

语言 惯用实现 差异要点
Java JDK 动态代理(接口)、CGLIB(子类)、静态代理 反射能力最强,Spring AOP 生态最成熟
Go 手写包装结构体 + go generate 代码生成 无运行期代理,靠接口与代码生成
Python __getattr__、描述符、weakref.proxy 动态语言拦截兜底属性,魔术方法需特殊处理
PHP __call、__get/__set 魔术方法、Laravel 代理类 FPM 下代理对象随请求重建,常驻模型需注意状态
C#/.NET DispatchProxy、Castle DynamicProxy 官方轻量代理只支持接口,第三方库支持类代理
TypeScript/JS Proxy + Reflect 元编程拦截十几种操作,响应式系统基础
Rust newtype + Deref,宏在编译期生成包装 无运行期拦截,所有权约束代理持有方式

跨语言差异

  • Java 是唯一把动态代理做成运行时标准能力的语言,JDK 动态代理与 CGLIB 的对比是面试经典。
  • Go、Rust 这类系统语言没有运行期生成类的能力,代理必须在编译期定型,代码生成是常见替代。
  • Python、JavaScript、PHP 这类动态语言用魔术方法或元编程拦截,写法更简洁但调试栈不直观。
  • C# 介于两者之间:官方提供 DispatchProxy,但只能代理接口,类代理要靠第三方库。
  • 所有语言的代理都共享同一个本质:在不改变接口的前提下,于调用路径上插入横切逻辑。
  • 远程代理是跨语言通用模式,RPC 框架(gRPC、Feign、grpc-go)都是远程代理的工业化实现。

待整理清单

  • [ ] 补充 Kotlin 代理(by 关键字)与 Scala 动态代理的写法
  • [ ] 补充 AspectJ 编译期织入与 Spring AOP 运行期织入的基准对比
  • [ ] 补充 gRPC、Dubbo、Feign 的远程代理生成原理
  • [ ] 补充 Rust 用宏实现编译期 AOP 的最小示例