欢迎您访问 最编程 本站为您分享编程语言代码，编程技术文章！

热门搜索/Hot Search

您现在的位置是： 首页

理解Java设计模式：装饰器、委托和代理的运用

最编程 2024-08-05 21:35:58
...

前言

为什么要将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点伤害!

结论

上面虽然是一个魔幻现实主义场景，但我们会发现，没有一个模式是我们在生活中无法还原出来的，只是我们平时没有认出它们。
所以说设计模式源于生活，而反过来将其还原成现实场景，就可以帮助我们更好地理解。

现实应用

  1. Decorator(装饰)模式
    • 女生们每天早上不同的衣服搭配
    • Java中的FileInputStream()那一系列类
  2. Delegation(委托)模式
    • 实在太过常见，因为我们经常把自己的某些工作委托给在那方面更擅长的人去做。比如说外包业务。
  3. Proxy(代理)模式
    • 限制访问型——比如经纪人和明星。钱不到位我们是不能上的！
    • 帮助访问型——比如VPN，我们虽然访问不了哔～哔，但是我们可以访问VPN，而VPN又可以访问哔～哔。
    • 各司其职型——这种情况下的代理模式和委托模式很相似。还是比如经纪人和明星。经纪人负责找演出，明星负责唱歌跳舞。

上一篇： Face Detection | DSFD

下一篇： C++实现外观模式的设计技巧

推荐阅读