JAVA代理模式

liulanghan110

浏览: 1072750 次
性别:
来自: 武汉

最近访客更多访客>>

youyuezym

vicento4

quainter

a1002323289

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

JAVA

代理模式是我们比较常用的设计模式之一。其中新思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信，代理模式一般涉及到的角色有：

抽象角色：声明真实对象和代理对象的共同接口；

代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

图如下：

静态代理

所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

静态代理的例子如下：

接口

package proxy;
public interface Subject {
	public void operate();
}

实际实现类：

package proxy;
public class SubjectImpl implements Subject {
	@Override
	public void operate() {
		System.out.println("卖房");
	}
}

代理类：

package proxy;
public class ProxySubject implements Subject {
	private Subject	srcObject;	// 被代理对象

	public ProxySubject(Subject srcObject) {
		this.srcObject = srcObject;
	}
	public void operate() {
		System.out.println("评估房产价格！");
		srcObject.operate();
	}
}

测试类：

package proxy;
public class StaticProxyDemo {

	/**
	 * 静态代理使用示例
	 */
	public static void consumer(Subject subject) {
		subject.operate();
	}

	public static void main(String[] args) {
		Subject real = new SubjectImpl();
		System.out.println("===Without Proxy===");
		consumer(real);
		System.out.println("===Use Proxy===");
		consumer(new ProxySubject(real));
	}
}

买房的时候，可以房主直接卖房，也可以由代理评估房产价格后在让房主卖房，后面就是所谓的代理模式。

静态代理类优缺点
优点：业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。
缺点：
1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

动态代理

动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。

1.动态代理分类

1. JDK动态代理

官方，不能代理类，只能代理接口

2.CGLIB动态代理

非官方，基于ASM，能代理类和接口，不能代理final类

3. Javassist、bcel等

2.动态代理相关的API

1、先看看与动态代理紧密关联的Java API。
1）java.lang.reflect.Proxy
这是 Java 动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。
Proxy类的静态方法

Java代码 
// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器  
static InvocationHandler getInvocationHandler(Object proxy)   
  
// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象  
static Class getProxyClass(ClassLoader loader, Class[] interfaces)   
  
// 方法 3：该方法用于判断指定类对象是否是一个动态代理类  
static boolean isProxyClass(Class cl)   
  
// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例  
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)   

2）java.lang.reflect.InvocationHandler
这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。每次生成动态代理类对象时都要指定一个对应的调用处理器对象。
InvocationHandler的核心方法

Java代码 
// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象 
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行  
Object invoke(Object proxy, Method method, Object[] args)   

3）java.lang.ClassLoader
这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。
每次生成动态代理类对象时都需要指定一个类装载器对象

3、动态代理实现步骤
具体步骤是：
a. 实现InvocationHandler接口创建自己的调用处理器
b. 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类
c. 以调用处理器类型为参数，利用反射机制得到动态代理类的构造函数
d. 以调用处理器对象为参数，利用动态代理类的构造函数创建动态代理类对象
分步骤实现动态代理

Proxy类的静态方法newProxyInstance对上面具体步骤的后三步做了封装，简化了动态代理对象的获取过程。

简化后的动态代理实现

Java代码 

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
InvocationHandler handler = new InvocationHandlerImpl(..);
// 通过 Proxy 直接创建动态代理类实例
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,
new Class[] { Interface.class }, handler );

4.动态代理例子

创建自己的调用处理器

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 * 动态代理类对应的调用处理程序类
 */
public class SubjectInvocationHandler implements InvocationHandler {
 
	 //代理类持有一个委托类的对象引用
	 private Object delegate;
	 
	 public SubjectInvocationHandler(Object delegate) {
		 
		 this.delegate = delegate;
	 }
 
	 @Override
	 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		 
		  long stime = System.currentTimeMillis(); 
		  //利用反射机制将请求分派给委托类处理。Method的invoke返回Object对象作为方法执行结果。
		  //因为示例程序没有返回值，所以这里忽略了返回值处理
		  method.invoke(delegate, args);
		  
		  long ftime = System.currentTimeMillis(); 
		  
		  System.out.println("执行任务耗时"+(ftime - stime)+"毫秒");
		  
		  return null;
	 }
}

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
/**
 * 生成动态代理对象的工厂.
 */
public class DynProxyFactory {
	 //客户类调用此工厂方法获得代理对象。
	 //对客户类来说，其并不知道返回的是代理类对象还是委托类对象。
	 public static Subject getInstance(){ 
		 
		  Subject delegate = new SubjectImpl();
		  
		  InvocationHandler handler = new SubjectInvocationHandler(delegate);
		  Subject proxy = null;
		  
		  proxy = (Subject)Proxy.newProxyInstance(
		    delegate.getClass().getClassLoader(), 
		    delegate.getClass().getInterfaces(), 
		    handler);
		  
		  return proxy;
	 }
}

动态代理测试

package proxy;
public class DynamicProxyDemo {
	 public static void main(String[] args) {  
		  
		  Subject proxy = DynProxyFactory.getInstance();  
		  proxy.operate();  
		 }   
}

5、动态代理的优点和美中不足 
优点： 
动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。在本示例中看不出来，因为invoke方法体内嵌入了具体的外围业务（记录任务处理前后时间并计算时间差），实际中可以类似Spring AOP那样配置外围业务。 

美中不足： 
诚然，Proxy 已经设计得非常优美，但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持 interface 代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫 Proxy。Java 的继承机制注定了这些动态代理类们无法实现对 class 的动态代理，原因是多继承在 Java 中本质上就行不通。 

有很多条理由，人们可以否定对 class 代理的必要性，但是同样有一些理由，相信支持 class 动态代理会更美好。接口和类的划分，本就不是很明显，只是到了 Java 中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾(CGLIB可以)。

查看图片附件

分享到：

RMI | jQuery包装集和DOM对象

2013-01-22 18:15
浏览 1324
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论