装饰者模式和代理模式的区别（转）

转自：https://www.cnblogs.com/jaredlam/archive/2011/11/08/2241089.html  

学习AOP时，教材上面都说使用的是动态代理，可是在印象中代理模式一直都是控制访问什么的，怎么又动态增加行为了，动态增加行为不是装饰器模式吗？于是 找了很多资料，想弄清楚这两者之间到底有什么区别。结果发现这一篇英文文章讲的很清晰，就翻译一下，供参考。       

        首先，让我们先看一下下面的这两个UML类图，他们分别描述了装饰器模式和代理模式的基本实现。

                    

                     

        这两个图可能使我们产生困惑。这两个设计模式看起来很像。对装饰器模式来说，装饰者（decorator）和被装饰者（decoratee）都实现同一个 接口。对代理模式来说，代理类（proxy class）和真实处理的类（real class）都实现同一个接口。此外，不论我们使用哪一个模式，都可以很容易地在真实对象的方法前面或者后面加上自定义的方法。

        然而，实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话 说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模 式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

        我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。    

代理模式：

//代理模式
public class Proxy implements Subject{

private Subject subject;
public Proxy(){
//关系在编译时确定
            subject = new RealSubject();
       }
public void doAction(){
             ….
             subject.doAction();
             ….
       }
}

//代理的客户
public class Client{
public static void main(String[] args){
//客户不知道代理委托了另一个对象
             Subject subject = new Proxy();
             …
        }
}

装饰模式：

//装饰器模式
public class Decorator implements Component{
private Component component;
public Decorator(Component component){
this.component = component
        }
public void operation(){
            ….
            component.operation();
            ….
       }
}

//装饰器的客户
public class Client{
public static void main(String[] args){
//客户指定了装饰者需要装饰的是哪一个类
            Component component = new Decorator(new ConcreteComponent());
            …
        }
}

个人理解：

代理分为：静态代理--自己手动编写代理类，通过new得到代理对象，调用方法。

                动态代理--不用手动编写代理类，通过jdk提供的API的proxy类newProxyInstance方法来获取代理对象，调用方法。

代理模式实例：

package com.itheima.proxy;
//抽象角色  
public interface ITarget {

	public void show();
}

package com.herbert.proxy;
//真实角色     目标
public class Target implements ITarget {

	@Override
	public void show() {
		System.out.println("show.....");
	}

}

package com.herbert.proxy;
//代理角色
public class TargetProxy implements ITarget {//条件1：实现同一接口
	private ITarget target; // 目标--条件2：获得被代理对象的引用

	public TargetProxy(ITarget target) {
		this.target = target;
	}

	@Override
	public void show() {
		// 在代理中通过目标来调用真实行为
		// 1.例如判断是否有权限调用目标行为
		// 2.进行日志操作
		// 3.性能临近
		target.show();
	}

}

package com.herbert.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.junit.Test;

public class TagertTest {

	// 直接访问目标
	@Test
	public void test1() {
		ITarget target = new Target();
		target.show();
	}

	// 通过代理来访问
	@Test
	public void test2() {

		// 1.创建目标
		ITarget target = new Target();

		// 2.创建代理
		ITarget targetProxy = new TargetProxy(target);

		// 3.通过代理来调用目标
		targetProxy.show();
	}

	// 使用jdk提供的Proxy类来完成动态代理
	@Test
	public void test3() {
		// 1.创建目标-条件2：获得被代理对象的引用
		final ITarget target = new Target();
		
		//2.使用Proxy的newProxyInstance方法来完成代理对象创建
		ITarget targetProxy=(ITarget) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {
			//上面的target.getClass().getInterfaces()可以理解为条件1：实现同一接口
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				return method.invoke(target, args);
			}
		});
		
		targetProxy.show();
		
	}
}

装饰者模式实例：

可以从上面的实例代码中看出，代理模式（静态/动态代理）和装饰者模式满足条件可以理解为是一致的。另外，静态代理和装饰者在代码编写上也很像。

满足条件：实现同一接口，代理类（装饰者类）获得被代理类（被装饰者类）的引用。