Spring源码学习之动态代理

最新推荐文章于 2025-06-29 10:47:33 发布

原创最新推荐文章于 2025-06-29 10:47:33 发布 · 1k 阅读

2 ·

CC 4.0 BY-SA版权

Spring源码分析专栏收录该内容

11 篇文章

订阅专栏

本文深入探讨了Java代理模式，包括静态代理和动态代理。重点介绍了JDK动态代理和CGLIB动态代理的工作原理，强调了JDK动态代理需要委托类实现接口的限制，而CGLIB通过字节码技术可以代理未实现接口的类。文中通过代码示例展示了两种动态代理的实现方式，并分析了它们的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

谈到代理模式，是java的一种常见的设计模式，代理模式显著的特点是代理类和委托类有相同的接口，代理类的主要功能是为委托类预处理消息，过滤消息，把消息转发给委托类，以及事后处理消息等等。代理类和委托类之间通常会存在关联，一个代理类对象和委托类对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类对象的方法来实现特定的服务。

代理通常分为：

静态代理：由程序员手动创建或者特定工具自动生成源码，再对其进行编译。在程序运行前，代理类的.class文件就已经存在了；

动态代理：动态代理主要分为JDK动态代理和CGLIB两种，主要是在程序运行时，利用反射机制动态生成代理类；

JDK中的动态代理：

JDK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的，但是，JDK中所要进行动态代理的类必须要实现一个接口，也就是说只能对该类所实现接口中定义的方法进行代理，这在实际编程中具有一定的局限性，而且使用反射的效率也并不是很高。

CGLib实现动态代理：

使用CGLib实现动态代理，完全不受代理类必须实现接口的限制，而且CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。

下面结合具体的例子分析静态代理和动态代理。

静态代理：

/** 
 * 定义一个账户接口 
 */  
public interface Count {  
    // 查看账户方法  
    public void queryCount();  
    // 修改账户方法  
    public void updateCount();  
}

/** 
 * 委托类(包含业务逻辑) 
 *  
 */  
public class CountImpl implements Count {  
  
    @Override  
    public void queryCount() {  
        System.out.println("查看账户方法...");  
    }  
  
    @Override  
    public void updateCount() {  
        System.out.println("修改账户方法...");  
    }  
  
}  
  
/** 
 * 代理类（增强CountImpl实现类） 
 */  
public class CountProxy implements Count {  
    private CountImpl countImpl;  
    /** 
     * 覆盖默认构造器 
     */  
    public CountProxy(CountImpl countImpl) {  
        this.countImpl = countImpl;  
    }  
  
    @Override  
    public void queryCount() {  
        System.out.println("事务处理之前");  
        // 调用委托类的方法;  
        countImpl.queryCount();  
        System.out.println("事务处理之后");  
    }  
  
    @Override  
    public void updateCount() {  
        System.out.println("事务处理之前");  
        // 调用委托类的方法;  
        countImpl.updateCount();  
        System.out.println("事务处理之后");  
    }  
  
}

然后新建一个测试类：

/** 
 *测试Count类 
 */  
public class TestCount {  
    public static void main(String[] args) {  
        CountImpl countImpl = new CountImpl();  
        CountProxy countProxy = new CountProxy(countImpl);  
        countProxy.updateCount();  
        countProxy.queryCount();  
    }  
}

以上就是静态代理的一个简单实现，通过代码，可以看出每一个代理类只能为一个接口服务，这样在开发中会出现很多代理，这些代理中除了调用的方法不一样之外，大部分代码都是重复的，因此需要由动态代理来实现。

在JDK1.3开始实现了动态代理的技术，jdk中的动态代理主要涉及到java.lang.reflect包中的两个类：Proxy和InvocationHandler两个类，其中InvocationHandler是一个接口，可以通过实现该接口定义横切逻辑，在并通过反射机制调用目标类的代码，动态将横切逻辑和业务逻辑编织在一起。

InvocationHandler接口：

public interface InvocationHandler { 
	public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
}

Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数
Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException

参数说明：ClassLoader：类加载器；Class<?>[] interfaces:得到的所有接口实例；InvocationHandler：得到InvocationHandler接口的子类实例；

JDK动态代理实例：

/** 
 * 定义一个账户接口 
 */  
public interface Count {  
    // 查看账户方法  
    public void queryCount();  
    // 修改账户方法  
    public void updateCount();  
  
}

/** 
 * 实现接口的类  
 */  
public class CountImpl implements Count {  
  
    @Override  
    public void queryCount() {  
        System.out.println("查看账户方法...");  
  
    }  
    @Override  
    public void updateCount() {  
        System.out.println("修改账户方法...");  
  
    }  
  
}

/** 
 * JDK动态代理代理类 
 */  
public class CountProxy implements InvocationHandler {  
    private Object target;  
    /** 
     * 绑定委托对象并返回一个代理类 
     * @param target 
     * @return 
     */  
    public Object bind(Object target) {  
        this.target = target;  
        //取得代理对象  
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
                target.getClass().getInterfaces(), this);               //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)  
    }  
  
    @Override  
    /** 
     * 调用方法 
     */  
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable {  
        Object result=null;  
        System.out.println("事务开始");  
        //执行方法  
        result=method.invoke(target, args);  
        System.out.println("事务结束");  
        return result;  
    }  
  
}

/*
 *代理测试类
 */
public class TestProxy {  
    public static void main(String[] args) {  
        CountProxy proxy = new CountProxy();  
        Count countProxy = (Count) proxy.bind(new CountImpl());  
        countProxy.updateCount();  
    }  
  
}

查看执行结果，实现了动态代理，但是JDK的动态代理是依靠接口实现的，如果有些类没有实现接口，则不能使用JDK的动态代理，CGLIB则突破了这一局限。

CGLIB是针对类来实现代理的，原理是对一个目标类生成一个子类，并覆盖其中的方法实现增强，但是因为是采用的继承技术，所以不能对final关键词修饰的类进行代理，实例如下：

/** 
 * 定义一个账户接口 
 */  
public interface Count {  
    // 查看账户方法  
    public void queryCount();  
    // 修改账户方法  
    public void updateCount();  
  
}

/** 
 * 这是一个没有实现接口的类
 *  
 */  
public class CountImpl{  
    public void queryCount() {  
        System.out.println("查看账户方法...");  
  
    }  
    public void updateCount() {  
        System.out.println("修改账户方法...");  
  
    }  
  
}

/** 
 * 使用cglib动态代理 
 */  
public class CountCglib implements MethodInterceptor {  
    private Object target;  
  
    /** 
     * 创建代理对象 
     * @param target 
     * @return 
     */  
    public Object getInstance(Object target) {  
        this.target = target;  //传入用户类
        Enhancer enhancer = new Enhancer();  //Enhancer是cglib的核心类
        enhancer.setSuperclass(this.target.getClass());  // 将用户类设为 Enhancer对象的superclass属性,,即设为 Enhancer对象的父类
        // 回调方法  
        enhancer.setCallback(this);  // 设 Enhancer对象的Callbacks属性,要求必须是Callback接口类型
        // 创建代理对象  
        return enhancer.create();  //生成代理对象
    }  
  
    @Override  
    // 回调方法  
    public Object intercept(Object obj, Method method, Object[] args,  
            MethodProxy proxy) throws Throwable {  
        System.out.println("事务开始");  
        proxy.invokeSuper(obj, args);  
        System.out.println("事务结束");  
        return null;  
  
  
    }  
  
}

/*
 *cglib测试类
 */
public class TestCglib {  
    public static void main(String[] args) {  
        CountCglib cglib=new CountCglib();  
        CountImpl countCglib=(CountImpl)cglib.getInstance(new CountImpl());  
        countCglib.queryCount();  
    }  
}

JDK的动态代理和CGLIB动态代理的区别：

JDK的动态代理只能针对实现了接口的类生成代理对象；CGLIB针对类，主要是针对指定类生成一个子类对象，并覆盖其中的方法，实现增强；