代理设计模式的核心含义在于一个业务操作除了真实实现之外，也需要有代理支持，代理负责所有与真实操作有关的辅助性功能实现，而真实主题只负责核心业务操作。

代理使用分析：

在传统编写DAO程序操作过程之中，一直是存在有一个问题的，业务层的真实功能是调用数据层，但是发现在我们之前写的代码之中，业务层除了要调用数据层组织数据之外，还要负责数据库的打开和关闭。

范例：定义业务层接口

 

 

1 2 3 4

package com.zmcheng.Demo; public interface Service {      public void print() throws Exception; }

范例：定义真实主题类

 

1 2 3 4 5 6 7 8 9

package com.zmcheng.Demo; public class ServiceImpl implements Service { @Override public void print() throws Exception { System.out.println("********操作前的准备：打开数据库连接*******"); System.out.println("********操作数据层的若干操作*******"); System.out.println("********操作后的收尾：关闭数据库连接*******"); } }

以上是最早的设计思路，但是如果说现在结合代理设计模式来看，实现就非常槽糕了，因为所有的核心业务操作业务与辅助业务都同时写在了一个方法里。必须解决这样的问题。

范例：设计一个静态代理类

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

package com.zmcheng.Demo; public class SeriverProxy implements Service { Service service; public SeriverProxy(Service service){ this.service = service; } public void pre()  throws Exception{ System.out.println("********操作前的准备：打开数据库连接*******"); } public void end() throws Exception{ System.out.println("********操作后的收尾：关闭数据库连接*******"); } public void print() throws Exception { this.pre(); this.service.print(); this.end(); } }

范例：真实主题实现类

 

1 2 3 4 5 6 7

package com.zmcheng.Demo; public class ServiceImpl implements Service { @Override public void print() throws Exception { System.out.println("********操作数据层的若干操作*******"); } }

而在使用的时候应该也通过工厂类取得接口实例化对象。

范例：定义serviceFactory

 

1 2 3 4 5 6

package com.zmcheng.Demo; public class serviceFactory {      public static Service getServiceInstance(){      return new SeriverProxy(new ServiceImpl());      } }

此时继续编写客户端，客户端依然是通过工厂取得接口实例化对象，客户端不会关心是代理主题还是真实主题，只是它知道，利用你这个工厂的方法就可以取得Seriver接口，就可以操作了。

范例：编写客户端

 

1 2 3 4 5 6 7

package com.zmcheng.Demo; public class Test { public static void main(String[] args) throws Exception{         Service service = serviceFactory.getServiceInstance();         service.print(); } }

这个时候的代理发生了作用，也就是说在实际的环境之中，代理设计模式应该和工厂设计模式联合起来，这样客户端在操作的时候就不会有任何的不适应感。

动态代理设计模式：

使用代理模式可以有效的抽取出核心业务与辅助业务，但是回顾整个项目的开发过程里面，可能会存在几百个业务层接口。可是这个时候所有的代理层的功能发现都一样，都只是负责真实主题业务调用，以及打开关闭数据库。如果每一个业务层接口都编写一个代理，基本上的表现：代理也是折磨人的。所以必须想办法让一个代理类可以负责所有真实主题的操作。

如果想要实现动态代理设计模式，必须有一个类来实现java.lang.reflect InvocationHandler接口。此接口有一个方法：

Object invoke(Object proxy, Method method,Object[] args) throws Throwable

实际上invoke()这个方法是属于反射调用的方法，证明动态代理也属于反射调用，而在invoke方法里面参数：

Object proxy:表示要代理的对象；

Method method:表示要操作的方法；

Object args[]:方法调用时传递的参数。

如果要想让代理设计真正可以使用，必须有一个代理类对象产生，而这个代理类对象的产生可以通过java.lang.reflect.Proxy类完成，而在Proxy类里面有一个取得代理对象的实例化方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)

                               throws IllegalArgumentException

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

package com.zmcheng.Demo; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class ServiceProxy implements InvocationHandler { private Object target=null; public Object getProxy(Object obj){ this.target = obj; return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this); } public void prepare(){ System.out.println("********操作前的准备：打开数据库连接*******"); } public void end() throws Exception{ System.out.println("********操作后的收尾：关闭数据库连接*******"); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object retValue = method.invoke(this.target, args); return retValue; } }

下篇博客将对剖析动态代理类的原理。