Java代理设计模式(Proxy)的具体实现：静态代理和动态代理

r囧r小猫 2023-09-30 12:41 8阅读 0赞

## Java代理设计模式(Proxy)的具体实现：静态代理和动态代理 ##

*  实现方式一：静态代理
 *  静态代理方式的优点
 *  静态代理方式的缺点
 *  Java动态代理实现方式一：InvocationHandler
 *  Java动态代理实现方式二：CGLIB
 *  用CGLIB实现Java动态代理的局限性

面试问题：Java里的代理设计模式（Proxy Design Pattern）一共有几种实现方式？这个题目很像孔乙己问“茴香豆的茴字有哪几种写法？

所谓代理模式，是指客户端(Client)并不直接调用实际的对象(下图右下角的RealSubject)，而是通过调用代理(Proxy)，来间接的调用实际的对象。

代理模式的使用场合，一般是由于客户端不想直接访问实际对象，或者访问实际的对象存在技术上的障碍，因而通过代理对象作为桥梁，来完成间接访问。

![img][]

## 实现方式一：静态代理 ##

开发一个接口IDeveloper，该接口包含一个方法writeCode，写代码。

public interface IDeveloper {
        
    
         public void writeCode();
    
    }

创建一个Developer类，实现该接口。

public class Developer implements IDeveloper{
        
    	private String name;
    	public Developer(String name){
        
    		this.name = name;
    	}
    	@Override
    	public void writeCode() {
        
    		System.out.println("Developer " + name + " writes code");
    	}
    }

测试代码：创建一个Developer实例，名叫Jerry，去写代码！

public class DeveloperTest {
        
    	public static void main(String[] args) {
        
    		IDeveloper jerry = new Developer("Jerry");
    		jerry.writeCode();
    	}
    }

现在问题来了。Jerry的项目经理对Jerry光写代码，而不维护任何的文档很不满。假设哪天Jerry休假去了，其他的程序员来接替Jerry的工作，对着陌生的代码一脸问号。经全组讨论决定，每个开发人员写代码时，必须同步更新文档。

为了强迫每个程序员在开发时记着写文档，而又不影响大家写代码这个动作本身, 我们不修改原来的Developer类，而是创建了一个新的类，同样实现IDeveloper接口。这个新类DeveloperProxy内部维护了一个成员变量，指向原始的IDeveloper实例：

public class DeveloperProxy implements IDeveloper{
        
    	private IDeveloper developer;
    	public DeveloperProxy(IDeveloper developer){
        
    		this.developer = developer;
    	}
    	@Override
    	public void writeCode() {
        
    		System.out.println("Write documentation...");
    		this.developer.writeCode();
    	}
    }

这个代理类实现的writeCode方法里，在调用实际程序员writeCode方法之前，加上一个写文档的调用，这样就确保了程序员写代码时都伴随着文档更新。

测试代码：

![img][img 1]

### 静态代理方式的优点 ###

1.  易于理解和实现
2.  代理类和真实类的关系是编译期静态决定的，和下文马上要介绍的动态代理比较起来，执行时没有任何额外开销。

### 静态代理方式的缺点 ###

每一个真实类都需要一个创建新的代理类。还是以上述文档更新为例，假设老板对测试工程师也提出了新的要求，让测试工程师每次测出bug时，也要及时更新对应的测试文档。那么采用静态代理的方式，测试工程师的实现类ITester也得创建一个对应的ITesterProxy类。

public interface ITester {
        
    	public void doTesting();
    }
    Original tester implementation class:
    public class Tester implements ITester {
        
    	private String name;
    	public Tester(String name){
        
    		this.name = name;
    	}
    	@Override
    	public void doTesting() {
        
    		System.out.println("Tester " + name + " is testing code");
    	}
    }
    public class TesterProxy implements ITester{
        
    	private ITester tester;
    	public TesterProxy(ITester tester){
        
    		this.tester = tester;
    	}
    	@Override
    	public void doTesting() {
        
    		System.out.println("Tester is preparing test documentation...");
    		tester.doTesting();
    	}
    }

正是因为有了静态代码方式的这个缺点，才诞生了Java的动态代理实现方式。

## Java动态代理实现方式一：InvocationHandler ##

通过InvocationHandler, 我可以用一个EnginnerProxy代理类来同时代理Developer和Tester的行为。

public class EnginnerProxy implements InvocationHandler {
        
    	Object obj;
    	public Object bind(Object obj)
    	{
        
    		this.obj = obj;
    		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
    		.getClass().getInterfaces(), this);
    	}
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    	throws Throwable
    	{
        
    		System.out.println("Enginner writes document");
    		Object res = method.invoke(obj, args);
    		return res;
    	}
    }

真实类的writeCode和doTesting方法在动态代理类里通过反射的方式进行执行。

测试输出：

![img][img 2]

通过InvocationHandler实现动态代理的局限性

假设有个产品经理类(ProductOwner) 没有实现任何接口。

public class ProductOwner {
        
    	private String name;
    	public ProductOwner(String name){
        
    		this.name = name;
    	}
    	public void defineBackLog(){
        
    		System.out.println("PO: " + name + " defines Backlog.");
    	}
    }

我们仍然采取EnginnerProxy代理类去代理它，编译时不会出错。运行时会发生什么事？

ProductOwner po = new ProductOwner("Ross");
    
    ProductOwner poProxy = (ProductOwner) new EnginnerProxy().bind(po);
    
    poProxy.defineBackLog();

运行时报错。所以局限性就是：如果被代理的类未实现任何接口，那么不能采用通过InvocationHandler动态代理的方式去代理它的行为。

![img][img 3]

## Java动态代理实现方式二：CGLIB ##

CGLIB是一个Java字节码生成库，提供了易用的API对Java字节码进行创建和修改。关于这个开源库的更多细节，请移步至CGLIB在github上的仓库：https://github.com/cglib/cglib

我们现在尝试用CGLIB来代理之前采用InvocationHandler没有成功代理的ProductOwner类(该类未实现任何接口)。

现在我改为使用CGLIB API来创建代理类：

public class EnginnerCGLibProxy {
        
    	Object obj;
    	public Object bind(final Object target)
    	{
        
    		this.obj = target;
    		Enhancer enhancer = new Enhancer();
    		enhancer.setSuperclass(obj.getClass());
    		enhancer.setCallback(new MethodInterceptor() {
        
    			@Override
    			public Object intercept(Object obj, Method method, Object[] args,
    			MethodProxy proxy) throws Throwable
    			{
        
    				System.out.println("Enginner 2 writes document");
    				Object res = method.invoke(target, args);
    				return res;
    			}
    		}
    		);
    		return enhancer.create();
    	}
    }

测试代码：

ProductOwner ross = new ProductOwner("Ross");
    
    ProductOwner rossProxy = (ProductOwner) new EnginnerCGLibProxy().bind(ross);
    
    rossProxy.defineBackLog();

尽管ProductOwner未实现任何代码，但它也成功被代理了：

![img][img 4]

## 用CGLIB实现Java动态代理的局限性 ##

如果我们了解了CGLIB创建代理类的原理，那么其局限性也就一目了然。我们现在做个实验，将ProductOwner类加上final修饰符，使其不可被继承：

![img][img 5]

再次执行测试代码，这次就报错了： Cannot subclass final class XXXX。

所以通过CGLIB成功创建的动态代理，实际是被代理类的一个子类。那么如果被代理类被标记成final，也就无法通过CGLIB去创建动态代理。

Java动态代理实现方式三：通过编译期提供的API动态创建代理类

假设我们确实需要给一个既是final，又未实现任何接口的ProductOwner类创建动态代码。除了InvocationHandler和CGLIB外，我们还有最后一招：

我直接把一个代理类的源代码用字符串拼出来，然后基于这个字符串调用JDK的Compiler（编译期）API，动态的创建一个新的.java文件，然后动态编译这个.java文件，这样也能得到一个新的代理类。

![img][img 6]

测试成功：

![img][img 7]

我拼好了代码类的源代码，动态创建了代理类的.java文件，能够在Eclipse里打开这个用代码创建的.java文件，

![img][img 8]

![img][img 9]

下图是如何动态创建ProductPwnerSCProxy.java文件:

![img][img 10]

下图是如何用JavaCompiler API动态编译前一步动态创建出的.java文件，生成.class文件：

![img][img 11]

下图是如何用类加载器加载编译好的.class文件到内存：

![img][img 12]

[img]: https://img-blog.csdnimg.cn/img_convert/ada83a22b151c3f556fbee1ac2f3045f.png
[img 1]: https://img-blog.csdnimg.cn/img_convert/562a45359a2a6632c32d72c7f5cfedb9.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/f3c979babeb31bf04831e07ac56a6f6b.png
[img 3]: https://img-blog.csdnimg.cn/img_convert/be090a1932bd1397d82caa45115669e3.png
[img 4]: https://img-blog.csdnimg.cn/img_convert/9465ee6cdd3eed8c11f9851b583b8668.png
[img 5]: https://img-blog.csdnimg.cn/img_convert/84b043b0fdb3fb0b3e76ccbedf39a071.png
[img 6]: https://img-blog.csdnimg.cn/img_convert/8fe3c193c3d06e3c33deb340352f4c62.png
[img 7]: https://img-blog.csdnimg.cn/img_convert/238883fcbe69fc8abbc45fa3e36b46ab.png
[img 8]: https://img-blog.csdnimg.cn/img_convert/f9cb8dbea7c9f86afcf2637b52bcbd74.png
[img 9]: https://img-blog.csdnimg.cn/img_convert/7620cbd651bb18eb2bce77475f0e56af.png
[img 10]: https://img-blog.csdnimg.cn/img_convert/326c547239a2eaf4e8b747c47536c19d.png
[img 11]: https://img-blog.csdnimg.cn/img_convert/6bd25bdffb4c2f9b8ac1beb6475db962.png
[img 12]: https://img-blog.csdnimg.cn/img_convert/89233f053de1de059c4b7669f8819fd5.png