原文地址：点击打开链接
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
interface Business3
{4
void doAction();5
} 6
// 真实角色：真正实现了业务逻辑接口 7
class BusinessImpl implements Business8
{9
public void doAction()10
{11
System.out.println("真实角色中的方法被执行！");12
}13
} 14
// 代理角色：自己并未实现业务逻辑接口，而是调用真实角色来实现 15
class BusinessImplProxy implements Business16
{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 Test39
{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}
import java.lang.reflect.InvocationHandler;2
import java.lang.reflect.Proxy;3
import java.lang.reflect.Method;4
// 抽象角色：java动态代理的实现目前只支持接口，不支持抽象类 5
interface BusinessFoo6
{7
void foo();8
} 9
interface BusinessBar10
{11
String bar(String message);12
} 13
// 真实角色：真正实现业务逻辑方法 14
class BusinessFooImpl implements BusinessFoo15
{16
public void foo()17
{18
System.out.println("BusinessFooImpl.foo()");19
}20
} 21
class BusinessBarImpl implements BusinessBar22
{23
public String bar(String message)24
{25
System.out.println("BusinessBarImpl.bar()");26
return message;27
}28
} 29
// 动态角色：动态生成代理类 30
class BusinessImplProxy implements InvocationHandler31
{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 Throwable39
{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 DynamicProxy60
{ 61
public static void main(String[] args) throws Throwable62
{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的动态代理十分强大。
