前言
为什么要将Decorator(装饰)，Delegation(委托) ，Proxy(代理)这三个模式放在一起呢？
因为它们的代码是如此地相似。如果不结合场景，会很容易分不清楚。
所以请在本文中尝试体会它们当中的细微差别。
我们应该记住，设计模式并非无中生有，其原型往往来源于生活。
在面对对象编程(OOP)时，我们的代码可以看作现实世界某些场景的缩影，我们的对象则可以看作是场景中的一个个人。
因此看似相似的代码所还原出的应用场景并不一定相同，它也就被抽象成不同的模式。
意图
Decorator(装饰)
侧重于为一个基础对象动态地增强它的职责或能力。
这是面对排列组合所造成的子类数爆炸问题的一种灵活的解决方案。Delegation(委托)
侧重于对用户提供统一的接口，却可以切换多种底层实现。
当使用委托对象的某个方法时，它不并自己实现，而是往后退，委托给其内部的被委托对象让其代劳。Proxy(代理)
侧重于控制访问。
不改变被代理对象的职责或能力。提供与被代理对象相同的接口，但会添加一些特有的逻辑来控制对被代理对象的访问。
生动的栗子
有一个王国要打仗了！王国的武器库里有很多武器。
比如说，有剑有斧子！
public interface Weapon {
int makeDamage();
}
public class Sword implements Weapon {
private int att = 10;
public int makeDamage() {
return this.att;
}
}
public class Axe implements Weapon {
private int att = 15;
public int makeDamage() {
return this.att;
}
}
斧子的初始攻击比剑稍微高点。但是没关系，我们可以给它们加很多其他属性。比如说，可以给武器加点毒属性，也可以了来点钢属性。总有一款适合你。
public abstract class WeaponDecorator implements Weapon {
protected Weapon weaponDecorated;
public WeaponDecorator(Weapon weaponDecorated) {
this.weaponDecorated = weaponDecorated;
}
public abstract int makeDamage();
}
public class PoisonWeapon extends WeaponDecorator{
private int powerOfPoison = 10;
public PoisonWeapon(Weapon weaponDecorated) {
super(weaponDecorated);
}
@Override
public int makeDamage() {
return weaponDecorated.makeDamage() + powerOfPoison;
}
}
public class SteelWeapon extends WeaponDecorator{
private int powerOfSteel = 12;
public SteelWeapon(Weapon weaponDecorated) {
super(weaponDecorated);
}
@Override
public int makeDamage() {
return weaponDecorated.makeDamage() + powerOfSteel;
}
}
我们就可以拿这些属性来装饰实际的武器。
理论上我们一共可能得到这么多种武器。
Weapon normalSword = new Sword(); // 普通剑
Weapon steelSword = new SteelWeapon(new Sword()); //钢剑
Weapon poisonSword = new PoisonWeapon(new Sword()); //毒剑
Weapon poisonSteelSword = new PoisonWeapon(new SteelWeapon(new Sword())); //毒钢剑
Weapon normalAxe = new Axe(); // 普通斧
Weapon steelAxe = new SteelWeapon(new Axe()); //钢斧
Weapon poisonAxe = new PoisonWeapon(new Axe()); //毒斧
Weapon poisonSteelAxe = new PoisonWeapon(new SteelWeapon(new Axe())); //毒钢斧
我们忽略了属性之间的顺序，但有些时候顺序是有意义的，那么种类就会更多。
这就是Decorator(装饰)模式了。
用2个基类加上2个装饰器，我们得到了8种结果。如果又多了1个基类，又多了2个装饰器呢？在不考虑顺序的情况下，有48种结果。
排列组合的威力太过强大，如果不用装饰模式，我们得写48个子类出来。
但有了装饰器，我们只需要7个类而已。而且可以非常灵活得组装。
接着说故事～
我们的主角兽人大兄弟登场了。
他想要为王国效力。出战前他可以去武器库选把武器。
public interface Warrior {
void attack();
int damageValue();
}
public class OrcWarrior implements Warrior {
private WeaponArsenal weaponArsenal = new WeaponArsenal();
public void attack() {
System.out.println(String.format("洛克打猴哥！造成%d点伤害!", damageValue()));
}
public int damageValue() {
return weaponArsenal.makeDamage();
}
public void selectWeapon(WeaponType weaponType) {
weaponArsenal.setWeaponType(weaponType);
}
}
public enum WeaponType {
SWORD, AXE
}
public class WeaponArsenal implements Weapon {
private WeaponType weaponType;
public int makeDamage() {
Weapon weapon = getWeapon();
if (weapon != null) {
return weapon.makeDamage();
}
return 0;
}
public void setWeaponType(WeaponType weaponType) {
this.weaponType = weaponType;
}
private Weapon getWeapon() {
switch (weaponType) {
case SWORD : return new SteelWeapon(new PoisonWeapon(new Sword()));
case AXE : return new SteelWeapon(new Axe());
default : return null;
}
}
}
这里就用到了Delegation(委托)模式。
当从武器库选择了武器的兽人战士想要造成伤害时，他委托了武器库去造成伤害——weaponArsenal.makeDamage()。
但武器库怎么可能去造成伤害呢？武器库其实又是委托了具体被选择的那把武器来造成伤害——weapon.makeDamage()。
兽人大兄弟十分英勇，但还是有时候赢有时候输。直到有一天他遇到了一个小法师。
小法师完全不会打架，但智商很高。他发现我们这位兽人大兄弟看到什么都忍不住想上去砍一刀，于是提议，由他来判断形势，可以打的时候就让兽人兄弟上，打不了咱们就跑。
兽人兄弟没多想，一口答应。于是乎，小法师成为了兽人战士的代理(Proxy)。
public class LittleWizard implements Warrior {
private Warrior warrior;
public LittleWizard(Warrior warrior) {
this.warrior = warrior;
}
public void attack() {
if (warrior.damageValue() < 30) {
System.out.println("就这点攻击力咱还是跑吧。");
} else {
System.out.println("不要怂，就是干！");
warrior.attack();
}
}
public int damageValue() {
return 0; // Little wizard doesn't know how to fight
}
}
有了小法师以后，兽人的输出被控制了，有了选择性。
具体能不能打小法师说了算。
整个故事在战场上是这样的。
public class BattleField {
public static void main(String[] args) {
// 兽人大兄弟踏上了战场
Warrior orcWarrior = new OrcWarrior();
// 选了把趁手的斧子
((OrcWarrior) orcWarrior).selectWeapon(WeaponType.AXE);
// 遇到谁都上去砍
orcWarrior.attack();
// 遇到了小法师，小法师成了兽人战士的代理人
Warrior littleWizard = new LittleWizard(orcWarrior);
// 遇到敌人了，怂了
littleWizard.attack();
// 赶紧回去换把武器
((OrcWarrior) orcWarrior).selectWeapon(WeaponType.SWORD);
// 上！
littleWizard.attack();
}
}
结果是这样的。
洛克打猴哥！造成27点伤害!
就这点攻击力咱还是跑吧。
不要怂，就是干！
洛克打猴哥！造成32点伤害!
结论
上面虽然是一个魔幻现实主义场景，但我们会发现，没有一个模式是我们在生活中无法还原出来的，只是我们平时没有认出它们。
所以说设计模式源于生活，而反过来将其还原成现实场景，就可以帮助我们更好地理解。
现实应用
-
Decorator(装饰)模式- 女生们每天早上不同的衣服搭配
- Java中的
FileInputStream()那一系列类
-
Delegation(委托)模式- 实在太过常见，因为我们经常把自己的某些工作委托给在那方面更擅长的人去做。比如说外包业务。
-
Proxy(代理)模式- 限制访问型——比如经纪人和明星。钱不到位我们是不能上的！
- 帮助访问型——比如
VPN，我们虽然访问不了哔～哔，但是我们可以访问VPN，而VPN又可以访问哔～哔。 - 各司其职型——这种情况下的代理模式和委托模式很相似。还是比如经纪人和明星。经纪人负责找演出，明星负责唱歌跳舞。