今天面试聊到了模式。
 
面试官问：装饰者模式了解吗，讲一下？
 
我：blabla...
 
面试官：那代理模式呢？
 
我：blabla.....（说完感觉怎么都一样呢）
 
果然，面试官又问了：那两者有什么区别呢？
 
我： ....懵.........懵.........懵.........懵.........
 
 
 
 
首先呢来看一下定义。
 
一、代理模式
 
代理模式：为其他对象提供一种代理以控制对这个对象的访问。代理模式是一项基本的设计技巧，许多其他的模式，如状态模式、策略模式、访问者模式本质上也采用了代理模式。
 
 
在代理模式中主要包含三个角色：
 
抽象主题角色Subject：是真实主题和代理主题的共同接口，以便在任何可以使用真实主题的地方都可以使用代理主题。
代理主题角色Proxy Subject：也叫做委托类、代理类，该角色负责控制对真实主题的引用，负责在需要的时候创建或删除真实主题对象，并且在真实主题角色处理完毕前后做预处理和善后处理工作。
真实主题角色Real Subject：也叫做被委托角色、被代理角色，是业务逻辑的具体执行者。
二、装饰者模式
 
装饰者模式：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式比生成子类更为灵活。
 
 
装饰模式有以下4个角色。
 
抽象构件（Component）角色：该角色用于规范需要装饰的对象（原始对象）。
具体构件（Concrete Component）角色：该角色实现抽象构件接口，定义一个需要装饰的原始类。
装饰（Decorator）角色：该角色持有一个构件对象的实例，并定义一个与抽象构件接口一致的接口。
具体装饰（Concrete Decorator）角色：该角色负责对构件对象进行装饰。
 
三、区别
 
从定义上看似乎能够回答面试官的问题，一个是用于实现访问控制，一个是增加功能。可是。。访问控制是什么，增加功能又是怎么样的？到底啥是佩琪，还是要搞清楚些，看一些具体的例子来了解下。
 
3.1 访问控制 -- 代理模式
 
// 抽象主题
interface AbstractSubject{
    void doAction();
}

// 真实主题
class RealSubject implements AbstractSubject{
    @Override
    public void doAction() {
        System.out.println(" Real Action ");
    }
}

// 代理主题
class ProxySubject implements AbstractSubject{
    private AbstractSubject subject;

    public ProxySubject(){
        this.subject = new RealSubject();
    }

    @Override
    public void doAction() {
        System.out.println(" Before Proxy do Action");
        subject.doAction();
        System.out.println(" Before Proxy do Action");
    }
}

// 客户端
public class Client{

    public static void main(String[] args) {
        AbstractSubject subject = new ProxySubject();
        subject.doAction();
    }
}
 
3.2 功能扩展 -- 装饰者模式
 
// 抽象构件
interface Human{
    void eat();
}

// 具体构件
class Baby implements Human{

    @Override
    public void eat() {
        System.out.println("Baby eating");
    }
}

// 装饰角色
class Guardian implements Human{
    private Human human;

    public Guardian(Human h){
        human = h;
    }

    @Override
    public void eat() {
        human.eat();
    }
}

// 具体装饰角色
class Parent extends Guardian{

    public Parent(Human h) {
        super(h);
    }

    @Override
    public void eat() {
        System.out.println("Wash hands for baby");
        super.eat();
    }
}



// 客户端
Baby baby = new Baby();
Human human = new Parent(baby);
human.eat();
 
四、总结
 
等待，看完例子怎么感觉又似懂非懂了呢。不是说一个控制访问，一个增强功能吗，为什么都是中间类和目标类实现了相同的接口，在调用目标类时增加了自己的方法呢？好像确实又懵了。
 
 
其实，代理模式的访问控制主要在于对目标类的透明访问，也就是说我们不需要知道目标类的具体情况，只需要知道代理类可以帮助我们完成想要的功能就对了；而对于装饰者模式，我们是有一个目标类的对象的，比如例子中的baby，这个对象可以完成特定的功能（eat），但是不能满足我们的要求，所以需要对其进行增强（饭前洗手）。
 
也就是说，在代理模式中，目标类对于客户端是透明的，由代理类隐藏其具体信息并响应客户端请求；而装饰者中客户端对特定的目标类对象进行增强。所以，代理类与真实对象的关系常在编译时就确定，而装饰者在运行时递归构造。
 
 
 
 
----------
 
终于搞明白了这两个相似的设计模式的关系，好像智商又占领了高地，就是脚有点麻   ------
 

设计模式中有很多种，这里介绍下面试中可能会被问到的一个问题：代理模式和装饰者模式的区别。
先看一下代理模式的设计图：

再看一下代理模式的代码：
第一步：定义一个接口：
package com.interview.designModel.agentModel;
/**
 * 第一步：定义一个接口
 * @author EdwardShen
 *
 * 2018年4月13日
 */
public interface Girl {
    void behavior();
}



第二步：定义接口的实现，即为被代理的类
package com.interview.designModel.agentModel;
/**
 * 第二步：定义真实的被代理的类
 * @author EdwardShen
 *
 * 2018年4月13日
 */
public class NiceGirl implements Girl{
	private String name;
	public NiceGirl(String name)
	{
		this.name = name;
	}

	@Override
	public void behavior() {
		System.out.println(name+"说话很nice");
		System.out.println(name+"长的很nice");
	}
	
}

第三步：定义代理类
package com.interview.designModel.agentModel;

import java.util.Random;

/**
 * 第三步：定义代理类
 * 代理类，代理的对象是Girl
 * @author EdwardShen
 *
 * 2018年4月13日
 */
public class GirlAgent implements Girl{
	private Girl girl;
	
	public GirlAgent(Girl girl)
	{
		this.girl = girl;
	}
	
	public void behavior()
	{
		Random random = new Random();
		if(random.nextBoolean())
		{
			System.out.println("我安排你们上自习");
			girl.behavior();
		}
		else
		{
			System.out.println("上完自习再说");
		}
	}
}

第四步：定义测试类
package com.interview.designModel.agentModel;

import org.junit.Test;

/**
 * 第四步：定义测试类
 * 装饰者模式：可以对被代理的对象有控制权，决定被代理的对象执行还是不执行
 * @author EdwardShen
 *
 * 2018年4月13日
 */
public class Client {
	@Test
	public void showInfo()
	{
		Girl girl = new NiceGirl("小美");
		Girl friend = new GirlAgent(girl);
		friend.behavior();
	}
}

最后，正确的代码展示结果：
我安排你们上自习
小美说话很nice
小美长的很nice
或者
上完自习再说

装饰者模式的设计原理：


对，你没有看错，是一毛一样的。
接下来，看一下代码的实现。不同的地方，只有装饰类，其余不在展示
package com.interview.designModel.decoratorModel;

import com.interview.designModel.agentModel.Girl;
/**
 * 装饰者需要与装饰的对象相关联
 * @author EdwardShen
 *
 * 2018年4月13日
 */
public class GirlDecorator implements Girl{
	private Girl girl;
	public GirlDecorator(Girl girl)
	{
		this.girl = girl;
	}

	@Override
	public void behavior() {
		System.out.println("我的闺蜜不但知书达理，还会洗衣做饭");
		girl.behavior();
	}

}

正确的代码展示的结果
我的闺蜜不但知书达理，还会洗衣做饭
小美说话很nice
小美长的很nice



所以最终两者的区别是：
代理模式：对于被代理的对象有控制权，可以执行或者不执行。
装饰着模式：没有控制权，肯定会执行，但是增加了一层装饰的功能。

定义：
 
代理模式：为其他对象提供一种代理，以控制该对象的访问
装饰模式：动态的给对象添加额外职责，就增加功能来说，装饰模式比生成子类更灵活
桥接模式：将抽象部分和实现部分分离，使得他们可以都可以独立的变化
 
区别
 
从实现目的来看：
 
代理模式主要是为了控制对象的访问（比如权限校验）或者为了更方便的访问对象（比如Binder中的代理使得跨进程调用方法就像调用本地方法一样）
装饰模式是为了增加新的功能，而不改变原有对象，它可以用来代替继承，使得增加功能更灵活
而桥接模式是为了解决多个维度发生变化时带来的类爆炸问题
 
UML图
 
代理模式：
 
装饰模式：
 
 
桥接模式：
 
 
从类结构上来看：
 
代理模式和装饰模式中的代理角色和装饰者角色，都需要实现或者重写被代理者/被装饰者的方法，使得对用户来说是透明的，而桥接模式则不需要
相对于代理模式来说，装饰者模式多了个装饰者的抽象类，也就是它可以往装饰者和被装饰者这两个维度来扩展，而代理模式中的代理者则是具体的实现类
而桥接模式，则是将抽象类作为桥梁，将各个实现连接起来，它不像装饰模式那样只能往2个维度扩展，而是可以扩展到多个维度，比如手机的抽象类，它可以桥接屏幕、相机、cpu等各个硬件的实现类
 
所以装饰模式可以看做是桥接模式的特例，而代理模式则可以看做是装饰模式的特列，在实际开发中往往很少有标准化的设计模式，往往都是根据实际情况多种设计模式结合在一起使用，所以一些设计模式看起来会比较相似，但其实他们核心的目的还是不一样的

学习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());
            …
        }
}
 
对已有的业务逻辑进一步的封装，使其增加额外的功能，如java中的IO流就使用了装饰者模式，用户在使用的时候，可以任意组装，达到自己想要的效果。 
 举个栗子，我想吃三明治，首先我需要一根大大的香肠，我喜欢吃奶油，在香肠上面加一点奶油，再放一点蔬菜，最后再用两片面包加一下，很丰盛的一顿午饭，营养又健康，那我们应该怎么来写代码呢？ 
 首先，我们需要写一个Food类，让其他所有食物都来继承这个类，看代码：
 
public class Food {
 
    private String food_name;
 
    public Food() {
    }
 
    public Food(String food_name) {
        this.food_name = food_name;
    }
 
    public String make() {
        return food_name;
    };
}
 
代码很简单，我就不解释了，然后我们写几个子类继承它：
 
//面包类
public class Bread extends Food {
 
    private Food basic_food;
 
    public Bread(Food basic_food) {
        this.basic_food = basic_food;
    }
 
    public String make() {
        return basic_food.make()+"+面包";
    }
}
 
//奶油类
public class Cream extends Food {
 
    private Food basic_food;
 
    public Cream(Food basic_food) {
        this.basic_food = basic_food;
    }
 
    public String make() {
        return basic_food.make()+"+奶油";
    }
}
 
//蔬菜类
public class Vegetable extends Food {
 
    private Food basic_food;
 
    public Vegetable(Food basic_food) {
        this.basic_food = basic_food;
    }
 
    public String make() {
        return basic_food.make()+"+蔬菜";
    }
 
}
 
这几个类都是差不多的，构造方法传入一个Food类型的参数，然后在make方法中加入一些自己的逻辑，如果你还是看不懂为什么这么写，不急，你看看我的Test类是怎么写的，一看你就明白了
public class Test {
    public static void main(String[] args) {
        Food food = new Bread(new Vegetable(new Cream(new Food("香肠"))));
        System.out.println(food.make());
    }
}
 
看到没有，一层一层封装，我没从里往外看：最里面我new了一个香肠，在香肠的外面我包裹了一层奶油，在奶油的外面我又加了一层蔬菜，最外面我放的是面包，是不是很形象，哈哈 ~ 这个设计模式简直跟现实生活中一摸一样，看懂了吗？ 
 我们看看运行结果吧