Java动态代理实现方式一

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

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

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

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

实现方式一：静态代理

开发一个接口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方法之前，加上一个写文档的调用，这样就确保了程序员写代码时都伴随着文档更新。

测试代码：

静态代理方式的优点

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的原理我曾经专门写文章介绍过：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方法在动态代理类里通过反射的方式进行执行。

测试输出：

通过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动态代理的方式去代理它的行为。

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未实现任何代码，但它也成功被代理了：

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

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

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

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

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

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

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

测试成功：

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

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

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

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

如果您想试试这篇文章介绍的这四种代理模式(Proxy Design Pattern), 请参考我的github仓库，全部代码都在上面。感谢阅读。

原文地址：https://www.cnblogs.com/wangenxian/p/10885309.html

时间： 2024-11-07 23:16:28

Java动态代理实现方式一的相关文章

Java EE开发平台随手记5——Mybatis动态代理接口方式的原生用法

为了说明后续的Mybatis扩展,插播一篇广告,先来简要说明一下Mybatis的一种原生用法,不过先声明:下面说的只是Mybatis的其中一种用法,如需要更深入了解Mybatis,请参考官方文档,或者研读源码. 我们知道,使用Mybatis的方式有很多种,从是否集成上分,可以单独使用,也可以和Spring集成使用:从使用方式上分,可以编写静态工具类,在静态工具中调用SqlSession,也可以直接注入SqlSession/ SqlSessionTemplate,还可以编写Dao接口,让mybat

理解java动态代理

java动态代理是java语言的一项高级特性.在平时的项目开发中,可能很难遇到动态代理的案例.但是动态代理在很多框架中起着不可替代的作用,例如Spring的AOP.今天我们就聊一聊java动态代理的实现原理. jdk对于动态代理的支持主要依赖于两个类:Proxy和InvocationHandler.我们先看一下类图. Subject类是主题类,定义了我要做什么.我们需要代理的类即实现Subject接口的RealSubject. 1.InvocationHandler InvocationHand

java动态代理机制

首先了解代理设计模式,其思想是为其他对象提供一种代理以控制对这个对象的访问. java动态代理就是遵循这种思想,spring中的AOP实现原理就是java的动态代理. 在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface).另一个则是 Proxy(Class),这一个类和接口是实现我们动态代理所必须用到的. 每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通

java动态代理

要想了解Java动态代理,首先要了解什么叫做代理,熟悉设计模式的朋友一定知道在Gof总结的23种设计模式中,有一种叫做代理(Proxy)的对象结构型模式,动态代理中的代理,指的就是这种设计模式. 在我看来所谓的代理模式,和23种设计模式中的"装饰模式"是一个东西.23种设计模式中将它们作为两种模式,网上也有些文章讲这两种模式的异同,从细节来看,确实可以人为地区分这两种模式,但是抽象到一定高度后,我认为这两种模式是完全一样的.因此学会了代理模式,也就同时掌握了装饰模式. 代理模式 代理模

彻底理解JAVA动态代理

注:本文转自 http://www.cnblogs.com/flyoung2008/archive/2013/08/11/3251148.html 代理设计模式 定义:为其他对象提供一种代理以控制对这个对象的访问. 代理模式的结构如下图所示. 动态代理使用 java动态代理机制以巧妙的方式实现了代理模式的设计理念. 代理模式示例代码 public interface Subject { public void doSomething(); } public class RealSubject i

java动态代理框架

java动态代理是一个挺有意思的东西,他有时候可以被使用的很灵活.像rpc的调用,调用方只是定义的一个接口,动态代理让他匹配上对应的不同接口:mybatis内部的实现,编码时,只是实现了mapper层的接口和sql的xml的配置,动态代理把他们连起来.记得之前在一家公司,他们使用thrift做rpc的解决方案,每个项目都得管理thrift的连接和关闭,代码考来考去,在spring下还得不断new对象.后来参照mybatis的实现方式,使用动态代理,做成spring注入的方式,方便很多,程序员只需

Java 动态代理机制分析及扩展，第 1 部分

引言 Java 动态代理机制的出现,使得 Java 开发人员不用手工编写代理类,只要简单地指定一组接口及委托类对象,便能动态地获得代理类.代理类会负责将所有的方法调用分派到委托对象上反射执行,在分派执行的过程中,开发人员还可以按需调整委托类对象及其功能,这是一套非常灵活有弹性的代理框架.通过阅读本文,读者将会对 Java 动态代理机制有更加深入的理解.本文首先从 Java 动态代理的运行机制和特点出发,对其代码进行了分析,推演了动态生成类的内部实现. 回页首 代理:设计模式 代理是一种常用的设计

理解Java动态代理（1）—找我还钱？我出钱要你的命

代理模式是最常用的一个设计模式之一,理解起来也是很简单,一张图足以说明了,LZ就不废话了. 至于代理模式能干嘛也不是LZ今天想说的,今天主要想简单介绍下JAVA里面的动态代理."动"当然是相对"静"来说的,那么什么是静,怎么就又动了呢?LZ想举个生活中常见的例子来说明,俗话说"谈钱伤感情",但生活所迫LZ曾经可没少找人借个一百两百五的,话说借钱一时爽,还钱--(请自行造句),好点的心平气和的委婉的说,横点的就拳脚相加啊.我们来用接口表示下借钱者这

Java动态代理的理解

代理可分为两类: 静态代理和动态代理 1.静态代理: /*定义一个业务接口*/ public interface Count { // 查看账户方法 public void queryCount(); // 修改账户方法 public void updateCount(); } /*定义一个委托类,实现该业务接口*/ public class CountImpl implements Count { @Override public void queryCount() { System.out.