一、说明
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
动态代理使用场合：
- 调试
- 远程方法调用
代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
二、静态代理
静态代理：要求被代理类和代理类实现相应的一套接口，通过代理类的对象调用重写接口的方法时，实际上执行的是被代理类的同样的方法的调用。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38//接口
interface ClothFactory{
void productCloth();
}
//被代理类
class NikeClothFactory implements ClothFactory{
@Override
public void productCloth(){
System.out.println("Nike");
}
}
//代理类
class ProxyFactory implements ClothFactory{
ClothFactory cf;
//代理类创建对象时，实际传入一个被代理类的对象
public ProxyFactory(ClothFactory cf){
this.cf=cf;
}
@Override
public void productCloth(){
System.out.println("代理开始");
cf.productCloth();
}
}
public class TestClothProduct{
public static void main(String[] args){
NikeClothFactory nike=new NikeClothFactory();//创建被代理类的对象
ProxyFactory proxy=new ProxyFactory(nike);//创建代理类的对象
proxy.productCloth();
}
}
三、动态代理
动态代理：在程序运行时，根据被代理类及其实现的接口，动态的创建一个代理类。当调用代理类的实现的抽象方法时，就发起对被代理类的同样的方法的调用。
一个代理类动态的调用不同的被代理类，代理类代理接口的实现方法即被代理类。通俗理解就是一个代理可以调用多个不同的被代理类，实现相应的动作。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50interface Subject{
void action();
}
//被代理类
class RealSubject implements Subject{
public void action(){
System.out.println("被代理类");
}
}
//中间类
class MyInvocationHandler implements InvocationHandler{
Object obj;//实现了接口的被代理类的对象的声明
//给被代理的对象实例化
//返回一个代理类的对象
public Object blind(Object obj){
this.obj=obj;
//第一个参数，是被代理类的(类加载器)反射的对象，第二个参数是被代理类实现的接口，第三个参数就是实现代理类的类的对象，根据参数的不同返回不同的代理类
return Proxy.newProxyInstance(obj.getClass().getClassLoader,obj.getClass().getInterface(),this);
}
//当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的invoke方法的调用
@Override
public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
//method方法的返回值是returnVal
Object returnVal=method.invoke(obj,args);
return returnVal;
}
}
public class TestProxy{
public static void main(String[] args){
//1.被代理类的对象创建
RealSubject real=new RealSubject();
//2.创建一个实现了InvacationHandler接口的类的对象
MyInvocationHandler handler=new MyInvocationHandler();
//3.调用blind()方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象
Object obj=handler.blind(real);
Subject sub=(Subject)obj;//sub就是代理类的对象
sub.action();//转到对InvacationHandler接口的实现类的invoke();方法的调用
//再用上面的静态代理做个例子
NikeClothFactory nike=new NikeClothFactory();//创建被代理类的对象
ClothFactory proxyCloth=(ClothFactory)handler.blind(nike);//proxyCloth即为代理类的对象
proxyCloth.productCloth();
}
}
