01.3.2.4 代理模式
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解
覆盖范围
- 代理模式的角色、意图与四种典型变体
- Java 静态代理、JDK 动态代理(
InvocationHandler与Proxy) - CGLIB 字节码增强与 JDK 动态代理的对比与取舍
- Spring AOP 的两种代理落地与自调用陷阱
- Go 没有动态代理时的接口包装、代码生成与手动转发
- Python
__getattr__与描述符实现代理 - C#
DispatchProxy、TypeScriptProxy与 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 静态代理怎么写?优缺点是什么?
一句话结论
静态代理就是手写一个与目标实现同一接口的类,内部持有目标对象引用,在每个方法里做前置/后置处理后再委托调用;它最直观,但接口方法一多就要写大量样板转发代码。
概念解释
- 三个角色:抽象主题(接口)、真实主题(业务实现)、代理主题(包装类)。
- 代理必须与真实主题实现同一接口,调用方拿到的是接口类型,无法区分。
- 静态代理的代理类在编译期就写好,没有反射,调用链最短。
原理流程
- 定义业务接口。
- 真实类实现接口,只写业务逻辑。
- 代理类实现同一接口,构造时接收真实对象。
- 代理方法内做横切逻辑(日志、权限、计时),然后调用真实对象同名方法。
代码或图示
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,因此只能实现接口,不能继承类。
原理流程
- 目标类实现一个或多个接口。
- 实现
InvocationHandler,在invoke中写横切逻辑并method.invoke(target, args)。 - 调用
Proxy.newProxyInstance传入接口与处理器。 - 调用方持有接口引用,调用方法时进入处理器。
代码或图示
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 方法无法被重写,拦截器织不进去;目标类若没有无参构造,代理类实例化会失败。
原理流程
- 判断目标是否实现接口。
- 有接口:JDK 动态代理更轻量。
- 无接口或配置强制 CGLIB:生成子类,非 final 方法被重写。
- 方法调用进入
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指向目标实例本身,不是代理对象,内部调用绕过了拦截链。
原理流程
- 容器启动时为目标 Bean 生成代理。
- 外部注入的是代理对象。
- 外部调用
proxy.method()→ 拦截链 → 目标方法。 - 目标方法内部
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模板批量生成,避免手写样板。
原理流程
- 定义业务接口。
- 写包装结构体,持有接口字段。
- 为接口每个方法写转发方法,在里面插横切逻辑。
- 调用方依赖接口类型,注入包装后的实例。
代码或图示
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__的类,作为另一个类的类属性时,访问该属性会触发描述符协议。
原理流程
- 包装类持有真实对象。
- 实现
__getattr__,把找不到的属性getattr(self._inner, name)。 - 需要懒加载时,用描述符在
__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。
原理流程
- 继承
DispatchProxy,实现Invoke。 - 调用
CreateProxy<TInterface, TProxy>创建代理实例。 - 方法调用进入
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操作等。
原理流程
- 定义真实对象或函数。
- 写 handler,在需要的 trap 里插逻辑。
- 用
new Proxy(target, handler)创建代理。 - 外部只操作代理对象,所有访问被拦截。
代码或图示
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等内部可变性。
原理流程
- 定义 newtype 包装内部类型。
- 实现
Deref/DerefMut指向内部类型。 - 需要插逻辑时,在 newtype 上显式定义同名方法,先做横切再
self.0.method()。 - 共享可变状态用
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);虚拟代理在首次访问时才创建昂贵对象(懒加载);保护代理在调用前做权限校验,不通过就拒绝;三者都实现与真实对象相同的接口,对调用方透明。
概念解释
- 远程代理:封装序列化、网络传输、反序列化,调用方像调本地方法。
- 虚拟代理:占位对象,首次访问时才加载真实对象。
- 保护代理:前置鉴权,拒绝未授权访问。
- 缓存代理:结果缓存,避免重复计算。
原理流程
- 定义统一接口。
- 远程代理:方法内序列化参数 → 网络调用 → 反序列化返回。
- 虚拟代理:首次调用时
if real == null { real = load() },再转发。 - 保护代理:
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 代理、装饰器、适配器三者怎么区分?
一句话结论
适配器转换接口以对齐期望;代理不改接口只控制访问;装饰器不改接口只叠加能力;三者结构相似(都持有被包装对象),区分看「改什么、为什么包装」。
概念解释
- 适配器:接口不一致 → 转换签名与参数。
- 代理:接口一致 → 控制是否放行、何时放行。
- 装饰器:接口一致 → 在调用前后叠加功能。
原理流程
- 先看接口是否一致:不一致归适配器。
- 接口一致时,看包装目的:控制访问归代理,叠加功能归装饰。
- 多层叠加增强是装饰器典型形态,单一受控访问是代理典型形态。
代码或图示
接口不一致 ──> 适配器(转换签名/参数)
接口一致 ──> 代理(放行/懒加载/权限/远程)
接口一致 ──> 装饰(日志/缓存/压缩,可多层嵌套)
常见误区
- 凭代码结构归类:结构相似不代表角色相同,必须看意图。
- 把参数转换写进代理/装饰器:签名转换属于适配器职责。
- 认为 Spring AOP 是纯装饰器:它是动态代理,承载横切增强,兼具装饰器式叠加与代理式拦截特征。
追问
- 装饰器也能做权限校验,和保护代理有什么区别?答:装饰器的核心是增强,权限校验只是其中一种增强;保护代理的核心是控制访问,权限是其存在的理由。
- 什么时候三者会组合出现?答:接入第三方 SDK 时先用适配器对齐接口,再用装饰器叠日志,再用保护代理做鉴权,三层各司其职。
01.3.2.4-012 代理带来的性能与调试成本有哪些?
一句话结论
动态代理引入反射调用、方法查找、栈帧加深,高频调用下有可观开销;调试时代理对象的类名与调用栈不直观,需要额外配置才能看到目标方法的真实参数与返回值。
概念解释
- 反射开销:
Method.invoke比直接调用慢,尤其在 JIT 未内联时。 - 栈帧加深:一次业务调用可能经过「代理 → 拦截器 → 目标」三四层栈。
- 可读性:代理类名是
$Proxy0或$$EnhancerByCGLIB$$xxx,日志里难以辨认。
原理流程
- 高频路径评估代理开销:用 JMH 或等价基准测试。
- 对性能敏感路径:手写静态代理或用编译期织入(AspectJ)。
- 调试时配置 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。
原理流程
- 外部注入代理对象。
- 外部调用
proxy.method()→ 拦截链 → 目标方法。 - 目标方法内部
this.internal()→ 直接调用,绕过代理。 - 解决:把
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 的最小示例