1、代理模式
所谓代理,就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下,一个客户不想或者不能够直接引用一个对象,而代理对象可以在客户端和目标对象之前起到中介的作用。
代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。
生活中的例子:过年加班比较忙,没空去买火车票,这时可以打个电话到附近的票务中心,叫他们帮你买张回家的火车票,当然这会附加额外的劳务费。但要清楚票务中心自己并不卖票,只有火车站才真正卖票,票务中心卖给你的票其实是通过火车站实现的。这点很重要!
上面这个例子,你就是“客户”,票务中心就是“代理角色”,火车站是“真实角色”,卖票称为“抽象角色”!
代理模式JAVA代码示例:
1
//抽象角色:抽象类或接口
2
interface Business
3

{
4
void doAction();
5
}
6
//真实角色:真正实现了业务逻辑接口
7
class BusinessImpl implements Business
8

{
9
public void doAction()
10
{
11
System.out.println("真实角色中的方法被执行!");
12
}
13
}
14
//代理角色:自己并未实现业务逻辑接口,而是调用真实角色来实现
15
class BusinessImplProxy implements Business
16

{
17
private BusinessImpl bi;
18
public void doAction()
19
{
20
if (bi==null)
21
{
22
bi = new BusinessImpl();
23
}
24
doBefore();
25
bi.doAction();
26
doAfter();
27
}
28
public void doBefore()
29
{
30
System.out.println("前置处理!");
31
}
32
public void doAfter()
33
{
34
System.out.println("后置处理!");
35
}
36
}
37
//测试类
38
class Test
39

{
40
public static void main(String[] args)
41
{
42
//引用变量定义为抽象角色类型
43
Business bi = new BusinessImplProxy();
44
bi.doAction();
45
}
46
}
47
代理模式允许使用抽象类或接口作为“抽象角色”,每个“代理角色”代理了一个“真实角色”,如果要代理的“真实角色”比较多,这势必造成大量的“代理角色”造成代码的急剧膨胀,其实其内部结构都是类似的,要是在运行时能动态生成“代理角色”就好了。
2、JAVA中的动态代理模式
从JDK1.3开始,java中引入了动态代理机制。相关的接口或类有如下两个:InvocationHandler和Proxy,都位于java.lang.reflect包下
InvocationHandler接口只定义了一个抽象方法:
Object
invoke(Object proxy, Method method, Object[] args)
Proxy类中主要的2个静态方法:
Class<?>
getProxyClass(ClassLoader loader, Class<?>... interfaces)
Object
newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
getProxyClass返回一个动态创建的代理类(Class),newProxyInstance则返回改代理类的实例(Object)。
所以,借助于JVM的支持,可以在运行时动态生成代理类(“代理角色”),我们就可以解决上述代理模式中代码膨胀的问题,使用了动态代理后,“代理角色”将不用手动生成,而由JVM在运行时,通过指定类加载器、接口数组、调用处理程序这3个参数来动态生成。
动态代理模式JAVA代码示例:
1
import java.lang.reflect.InvocationHandler;
2
import java.lang.reflect.Proxy;
3
import java.lang.reflect.Method;
4
//抽象角色:java动态代理的实现目前只支持接口,不支持抽象类
5
interface BusinessFoo
6

{
7
void foo();
8
}
9
interface BusinessBar
10

{
11
String bar(String message);
12
}
13
//真实角色:真正实现业务逻辑方法
14
class BusinessFooImpl implements BusinessFoo
15

{
16
public void foo()
17
{
18
System.out.println("BusinessFooImpl.foo()");
19
}
20
}
21
class BusinessBarImpl implements BusinessBar
22

{
23
public String bar(String message)
24
{
25
System.out.println("BusinessBarImpl.bar()");
26
return message;
27
}
28
}
29
//动态角色:动态生成代理类
30
class BusinessImplProxy implements InvocationHandler
31

{
32
private Object obj;
33
BusinessImplProxy()
{
34
}
35
BusinessImplProxy(Object obj)
{
36
this.obj = obj;
37
}
38
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable
39
{
40
Object result = null;
41
doBefore();
42
result = method.invoke(obj,args);
43
doAfter();
44
return result;
45
}
46
public void doBefore()
{
47
System.out.println("do something before Business Logic");
48
}
49
public void doAfter()
{
50
System.out.println("do something after Business Logic");
51
}
52
public static Object factory(Object obj)
53
{
54
Class cls = obj.getClass();
55
return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new BusinessImplProxy(obj));
56
}
57
}
58
//测试类
59
public class DynamicProxy
60

{
61
public static void main(String[] args) throws Throwable
62
{
63
BusinessFooImpl bfoo = new BusinessFooImpl();
64
BusinessFoo bf = (BusinessFoo)BusinessImplProxy.factory(bfoo);
65
bf.foo();
66
System.out.println();
67
68
BusinessBarImpl bbar = new BusinessBarImpl();
69
BusinessBar bb = (BusinessBar)BusinessImplProxy.factory(bbar);
70
String message = bb.bar("Hello,World");
71
System.out.println(message);
72
}
73
}
程序流程说明:
new BusinessFooImpl();创建一个“真实角色”,传递给工厂方法BusinessImplProxy.factory(),进而初始化“调用处理器”——即实现InvocationHandler的类。并返回一个动态创建的代理类实例,由于“代理角色”也必然实现了“抽象角色”提供的业务逻辑方法,故可向下转型为BusinessBar,并赋值给指向BusinessBar类型的引用bb。
newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)方法由程序员来指定参数动态返回需要的代理类,而invoke(Object proxy, Method method, Object[] args) 方法则是由JVM在运行时动态调用的。当执行“bb.bar("Hello,World");”方法时,JVM动态指派“调用处理器”,向外层invoke传递参数,并调用method.invoke(obj,args)真正执行!
BusinessImplProxy.Factory静态方法用来动态生成代理类(“代理角色”),在运行时根据不同的业务逻辑接口BusinessFoo和BusinessBar,在运行时分别动态生成了代理角色。“抽象角色”、“代理角色”以及调用处理器(实现InvocationHandler接口的类)这三者都可以改变,所以说JAVA的动态代理十分强大。
posted on 2008-01-04 21:02
菜园小鸟 阅读(8009)
评论(1) 编辑 收藏