代理模式(Proxy Pattern)是GoF 23种Java常用设计模式之一。

代理模式的定义：Provide a surrogate or placeholder for another object to control access to it(为其他对象提供一种代理以控制对这个对象的访问)。

使用代理模式创建代理对象，让代理对象控制目标对象的访问(目标对象可以是远程的对象、创建开销大的对象或需要安全控制的对象)，并且可以在不改变目标对象的情况下添加一些额外的功能。

代理模式一般涉及到的角色有：
    1、抽象角色：可以是抽象类，也可以是接口，真实对象和代理对象的共同接口；
    2、真实角色：代理角色所代表的真实对象，是我们最终要引用的目标对象。
    3、代理角色：也叫委托类、代理类，内部含有对真实对象（目标对象）的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作（如记录日志、进行完全检查等），相当于对真实对象进行封装。

示例：

抽象角色：

		
								package com.invicme.apps.aop.proxy;
							
								/**
							
								 * 
							
								 * @author lucl
							
								 * 
							
								 * 抽象角色
							
								 *
							
								 */
							
								public interface IDoSomeThing {
							
								    public void doSomeThing ();
							
								}

真实角色：

		
								package com.invicme.apps.aop.proxy;
							
								/**
							
								 * 
							
								 * @author lucl
							
								 * 
							
								 * 真实角色
							
								 *
							
								 */
							
								public class DoSomeThing implements IDoSomeThing {
							
								    @Override
							
								    public void doSomeThing() {
							
								        System.out.println("I'm doing some thing...");
							
								    }
							
								}

代理角色：

		
								package com.invicme.apps.aop.proxy;
							
								/**
							
								 * 
							
								 * @author lucl
							
								 * 
							
								 * 代理类
							
								 *
							
								 */
							
								public class DoSomeThingProxy implements IDoSomeThing {
							
								    private IDoSomeThing iDoSomeThing;
							
								    private String userName;
							
								    public DoSomeThingProxy (IDoSomeThing iDoSomeThing, String userName) {
							
								        this.iDoSomeThing = iDoSomeThing;
							
								        this.userName = userName;
							
								    }
							
								    @Override
							
								    public void doSomeThing() {
							
								        // 调用目标对象之前可以做相关操作(如记录日志、根据用户判断是否能够进行doSomeThing的操作)
							
								        System.out.println("Current user " + userName + " want to do some thing.");
							
								        this.iDoSomeThing.doSomeThing();
							
								        // 调用目标对象之后可以做相关操作
							
								        System.out.println("Current user " + userName + " do some thing end.");
							
								    }
							
								}

测试驱动类

		
								package com.invicme.apps.aop.proxy;
							
								/**
							
								 * 
							
								 * @author lucl
							
								 * 
							
								 * 驱动类，希望执行某些业务逻辑
							
								 *
							
								 */
							
								public class MainDriver {
							
								    public static void main(String[] args) {
							
								        IDoSomeThing iDoSomeThing = new DoSomeThing();
							
								        IDoSomeThing doSomeThingProxy = new DoSomeThingProxy(iDoSomeThing, "张三");
							
								        doSomeThingProxy.doSomeThing();
							
								        doSomeThingProxy = new DoSomeThingProxy(iDoSomeThing, "李四");
							
								        doSomeThingProxy.doSomeThing();
							
								    }
							
								}

总结：

代理模式主要使用了java的多态（这里为了简化使用的Sring userName，实际上可以为Person对象），干活的是被代理类，代理类主要是接活，你让我干活，好，我交给幕后的类去干，你满意就成，那怎么知道被代理类能不能干呢？同根就成，大家知根知底，你能做啥，我能做啥都清楚得很，同样一个接口，大家也可以多去看看java视频来学习。

《大话设计模式》中描述的为“当追求者想要送礼物时，没有直接将礼物送出去，而是通过代理”。

追求者和代理类均实现该接口，并且唉代理类中实现对追求者的封装，礼物都是通过代理之手出去的。

Proxy提供用于创建动态代理类和代理对象的静态方法，它是所有动态代理类的父类；
Proxy提供了两个方法来创建动态代理类和动态代理实例。

创建某一接口 Foo 的代理：

     InvocationHandler handler = new MyInvocationHandler(...);
     Class proxyClass = Proxy.getProxyClass(
         Foo.class.getClassLoader(), new Class[] { Foo.class });
     Foo f = (Foo) proxyClass.
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });

或使用以下更简单的方法：

     Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class[] { Foo.class },
                                          handler);

ITPub博客

java学习之代理模式

最新文章