Dynamic Proxy、 Proxy Pattern and Decorator Pattern

动态代理：

在目前的Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现，

如下，IHelloWorld接口定义的业务方法，HelloWorld是IHelloWorld接口的实现，HelloWorldProxy是 InvocationHandler接口实现。

package aop.dynamicProxy;public interface IHelloWorld { public void sayHello();}package aop.dynamicProxy;public class HelloWorld implements IHelloWorld { public void sayHello() { System.out.println("say hello!"); }}package aop.dynamicProxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class HelloWorldProxy implements InvocationHandler { private Object origanalObj; public HelloWorldProxy(Object orignalObject){ this.origanalObj = orignalObject; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null; beforeAction(); result = method.invoke(origanalObj, args); afterAction(); return result; } private void beforeAction(){ System.out.println("invoke before method!"); } private void afterAction(){ System.out.println("invoke after method!"); }}package aop;import java.lang.reflect.Proxy;import aop.dynamicProxy.HelloWorld;import aop.dynamicProxy.HelloWorldProxy;import aop.dynamicProxy.IHelloWorld;public class Main { /** * @param args */ public static void main(String[] args) { IHelloWorld hello = new HelloWorld(); HelloWorldProxy handler = new HelloWorldProxy(hello); IHelloWorld proxy = (IHelloWorld) Proxy.newProxyInstance(hello.getClass().getClassLoader() , hello.getClass().getInterfaces(), handler); proxy.sayHello(); }}

运行结果：

 

invoke before method!

say hello!

invoke after method!

 

1. 首先获取一个业务接口的实现对象；
2. 获取一个InvocationHandler实现，此处是HelloWorldProxy对象；
3. 创建动态代理对象；(只支持对接口的的实现)
4. 通过动态代理对象调用sayHello()方法，此时会在原始对象HelloWorld. sayHello()方法前后输出两句字符串。

 

Proxy模式：

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及消息被委托类执行后的后续处理。

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

代理模式常用的两个目的：

1. 授权机制 不同级别的用户对同一对象拥有不同的访问权利,代理来控制这两种用户对资源的访问权限.
2. 某个客户端不能直接操作到某个对象,但又必须和那个对象有所互动（如果那个对象是一个是很大的图片,需要花费很长时间才能显示出来,那么当这个图片包含在文档中时,使用编辑器或浏览器打开这个文档,打开文档必须很迅速,不能等待大图片处理完成,这时需要做个图片Proxy来代替真正的图片）.

package aop.proxyPattern;public interface IUserService { public void deleteUser();}package aop.proxyPattern;public class UserServiceImpl implements IUserService { public void deleteUser() { System.out.println("delete user."); }}package aop.proxyPattern;public class UserServiceProxy implements IUserService { private IUserService userService; public UserServiceProxy(IUserService userService){ this.userService = userService; } public void deleteUser() { if (checkPermission()) { userService.deleteUser(); } } private boolean checkPermission(){ System.out.println("check permission before delete user!"); return true; } public IUserService getUserService() { return userService; } public void setUserService(IUserService userService) { this.userService = userService; }}package aop;import aop.proxyPattern.IUserService;import aop.proxyPattern.UserServiceImpl;import aop.proxyPattern.UserServiceProxy;public class Main { /** * @param args */ public static void main(String[] args) { IUserService service = new UserServiceImpl(); IUserService proxy = new UserServiceProxy(service); proxy.deleteUser(); }}运行结果：invoke before delete user!delete user.invoke after delete user!package aop.proxyPattern;public interface IRenderImg { public void renderMiddleImg();}package aop.proxyPattern;public class RenderImgImpl implements IRenderImg { public void renderMiddleImg() { System.out.println("render middle img."); }}package aop.proxyPattern;public class RenderImgProxy implements IRenderImg { private IRenderImg render; public RenderImgProxy(IRenderImg render){ this.render = render; } public void renderMiddleImg() { new Thread(new RenderImg(render)).start(); } class RenderImg implements Runnable { IRenderImg img; RenderImg(IRenderImg img){ this.img = img; } public void run() { System.out.println("start a new thread to down load and render middle img."); img.renderMiddleImg(); } }}package aop.proxyPattern;public class ImgProxyTest { public static void main(String[] args) { ImgProxyTest main = new ImgProxyTest(); main.renderContent(); } public void renderContent() { renderTopContent(); renderMiddleImg(); renderBottomContent(); } public void renderTopContent() { System.out.println("render top content."); } public void renderMiddleImg() { IRenderImg img = new RenderImgImpl(); IRenderImg imgProxy = new RenderImgProxy(img); imgProxy.renderMiddleImg(); } public void renderBottomContent() { System.out.println("render bottom content."); }}运行结果：render top content.render bottom content.start a new thread to down load and render middle img.render middle img. 

 

Decorator Pattern：

 

动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活.我们通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性。

使用Decorator的理由是:这些功能需要由用户动态决定加入的方式和时机.Decorator提供了"即插即用"的方法,在运行期间决定何时增加何种功能.

 

 

 

 

 

package aop.decoratorPattern;public interface IFly { public void fly();}package aop.decoratorPattern;public class FlyImpl implements IFly { public void fly() { System.out.println("begin to fly"); }}package aop.decoratorPattern;public class FlyDecorator implements IFly { private IFly fly; public FlyDecorator(IFly fly) { this.fly = fly; } public void fly() { beforeFly(); fly.fly(); afterFly(); } private void beforeFly(){ System.out.println("before fly, prepare for flying"); } private void afterFly(){ System.out.println("after fly, do something after flying"); }}运行结果：before fly, prepare for flyingbegin to flyafter fly, do something after flying 

总结：

Proxy模式和Decorator模式本质上没什么大的区别，只是他们的使用目的不一样而已：proxy只是对现在功能作了代理，而decorator不是对现在功能代理，是添加新的功能。而Java自己的动态代理则是更灵活一点的代理模式的实现，代理类被动态生成。 他们都是java编程思想中对“继承”“多态”“面向接口编程”原则的较好实践而已。