结构型模式--代理模式（Proxy）_JAVA_编程开发_程序员俱乐部

其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。先来看看关系图：

?

根据上文的阐述，代理模式就比较容易的理解了，我们看下代码：

1. public?interface?Sourceable?{??
2. ????public?void?method();??
3. }??

1. public?class?Source?implements?Sourceable?{??
2. ??
3. ????@Override??
4. ????public?void?method()?{??
5. ????????System.out.println("the?original?method!");??
6. ????}??
7. }??

1. public?class?Proxy?implements?Sourceable?{??
2. ??
3. ????private?Source?source;??
4. ????public?Proxy(){??
5. ????????super();??
6. ????????this.source?=?new?Source();??
7. ????}??
8. ????@Override??
9. ????public?void?method()?{??
10. ????????before();??
11. ????????source.method();??
12. ????????atfer();??
13. ????}??
14. ????private?void?atfer()?{??
15. ????????System.out.println("after?proxy!");??
16. ????}??
17. ????private?void?before()?{??
18. ????????System.out.println("before?proxy!");??
19. ????}??
20. }??

测试类：

1. public?class?ProxyTest?{??
2. ??
3. ????public?static?void?main(String[]?args)?{??
4. ????????Sourceable?source?=?new?Proxy();??
5. ????????source.method();??
6. ????}??
7. ??
8. }??

输出：

before proxy!
the original method!
after proxy!

代理模式的应用场景：

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

===============================================================

?下面的例子说明代理模式在jdk中的使用：

public class Test {  
    public static void main(String[] args) throws Exception {  
          
        //创建目标对象，也就是被代理对象  
        RealSubject realSubject = new RealSubject();  
          
        //将目标对象交给代理  
        InvocationHandler handler = new DynamicProxy(realSubject);  
          
//      Class<?> proxyClass = Proxy.getProxyClass(Subject.class.getClassLoader()  
//              , new Class[]{Subject.class});  
//      Subject subject = (Subject)proxyClass.getConstructor(new Class[]{InvocationHandler.class})  
//              .newInstance(new Object[]{handler});  
          
        //返回代理对象，相当于上面两句  
        Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(),  
                realSubject.getClass().getInterfaces(),  
                handler);  
          
        //叫代理对象去doSomething()，其实在代理对象中的doSomething()中还是会  
        //用handler来调用invoke(proxy, method, args) 参数proxy为调用者subject(this)，  
        //method为doSomething()，参数为方法要传入的参数，这里没有  
        subject.doSomething();  
    }  
}  
/** 
 * 抽象角色：声明真实对象和代理对象的共同接口 
 * @author WalkingDog 
 * 
 */  
 interface Subject {  
    public void doSomething();  
}  
 class RealSubject implements Subject {  
   
    public void doSomething() {  
        System.out.println("RealSubject.doSomething");  
    }  
}  
class DynamicProxy implements InvocationHandler {  
	    private Object object;  
	    public DynamicProxy(Object object) {  
	        this.object = object;  
	    }  
	   
	    public Object invoke(Object proxy, Method method, Object[] args)  
	            throws Throwable {  
	        System.out.println("Before Invoke ! method : " + method);  
	          
	        //我们可以再代理方法调用前后添加功能  
	        Object result = method.invoke(object, args);  
	          
	        System.out.println("object : " + object + "\tresult : " + result + "\targs : " + args);  
	        System.out.println("After Invoke !");  
	        return result;  
	    }

		  
	} 

?