装饰者模式(Decorator Pattern)是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能,它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
装饰者是代替继承扩展功能另外一种方式，装饰者模式遵循了多用组合少用继承和对扩展开放对修改关闭的设计原则。

这一次用两个例子来说明，一个关于车的，一个是项目实际中经常用到的验证问题。
假如你有一天醒了，起来发现有人送了一辆法拉利488，那么有个性的你怎么会只满足车辆本身的性能和外观，这时候你会想着按照自己的意愿修改也就是改造。改了颜色、花纹、排气管等等要再改就比较麻烦了，既然是做梦，索性就做一点智能的东西，随意修改改装配件，还不用破坏车子本来的样子，接下来就用装饰者模式来做做梦～

类图

类图不是目的，只是方便理解

[图片上传失败...(image-bfea17-1527174192660)]

前面提到了装饰者模式是创建包装对象，所以装饰者模式里面的类不管是具体的组件还是装饰者组件都是实现同样的接口或者类。
Component是装饰的装饰接口，ConcreteComponent是具体的装饰组件，DecoratorComponent是装饰者组件，装饰者模式的核心就是用装饰者去装饰具体的组件，同样的一个装饰者组件也可以当成被装饰的具体组件。
在这个类图中，可以用DecorateComponentA或者DecorateComponentB去装饰ConcreteComponent、DecorateComponentA、DecorateComponentB，你要是非常丧心病狂也可以用DecorateComponentA装饰自己。

接下来实现自己的汽车智能改装

实例

现在我们用之前的知识梳理一下如何实现一个汽车的智能改装。
首先，需要一个Component也就是组件接口，因为我们是定义的改装所以定义成IUpdate,里面有一个叫refit()改装的行为：

/**
 * 改装，装饰者的装饰接口
 * Created by Carlton on 2016/11/2.
 */
interface IUpdate
{
    /**
     * 改装
     */
    fun refit() : String
}

有了装饰者接口，现在还需要一个被装饰的具体装饰组件，要不然妆化那么好，穿那么漂亮给谁看呢？女为悦己者容，所以得先要有一个服务的对象ConcreteComponent，这里定义成Car，这是别人送给你的4s店原装无改动的法拉利 488:

/**
 * 汽车, 被装饰的组件
 * Created by Carlton on 2016/11/2.
 */
class Car(var name: String) : IUpdate
{
    override fun refit(): String
    {
        return ""
    }

    override fun toString(): String
    {
        return "Car(name='$name')"
    }
}

现在有了具体的目标，接下来就需要很多额外的配件来改装，我们想改变汽车的颜色、速度、是否需要喷火，所以先定义4个类：RedColor、BlueColor、Speed、Fire:

/**
 * 红色改装
 * Created by Carlton on 2016/11/2.
 */
class RedColor(update: IUpdate) : DecoratorUpdate(update)
{
    override fun refit(): String
    {
        return "${update.refit()} - 红色的"
    }
}

/**
 * 蓝色改装
 * Created by Carlton on 2016/11/2.
 */
class BlueColor(update: IUpdate) : DecoratorUpdate(update)
{
    override fun refit(): String
    {
        return "${update.refit()} - 蓝色的"
    }
}

/**
 * 速度装饰者
 * Created by Carlton on 2016/11/2.
 */
class Speed(update: IUpdate) : DecoratorUpdate(update)
{
    override fun refit(): String
    {
        return "${update.refit()} - 速度提升一倍"
    }
}

/**
 * 能喷火的装饰者
 * Created by Carlton on 2016/11/2.
 */
class Fire(update: IUpdate) : DecoratorUpdate(update)
{
    override fun refit(): String
    {
        return "${update.refit()} - 能喷火"
    }

    fun fire(): String
    {
        return "${refit()}：氮气"
    }
}

注意这里的Fire类，里面多了一个方法叫fire()，功能是喷氮气。这是装饰者模式扩展的汽车原来的行为，可以给每一个装饰者组件添加多余的功能。

现在，汽车和原材料都准备好了，那么：

• 我想要一辆红色、能喷氮气、速度极快的车车
• 我想要一辆蓝色、速度极快的车车
• 我想要一辆蓝色、速度、速度的车车

//红色、氮气、速度提升一倍的Ferrari
val car:Car = Car("Ferrari 488")
val refit = Fire(Speed(RedColor(car))).fire()
println("$car $refit")
//  Car(name='Ferrari 488')  - 红色的 - 速度提升一倍 - 能喷火：氮气


// 蓝色、速度极快的
val car:Car = Car("Ferrari 488")
val refit = Speed(BlueColor(car)).refit()
println("$car $refit")
//  Car(name='Ferrari 488')  - 蓝色的 - 速度提升一倍

// 蓝色、速度、速度
val car:Car = Car("Ferrari 488")
val refit = Speed(Speed(BlueColor(car))).refit()
println("$car $refit")
//  Car(name='Ferrari 488')  - 蓝色的 - 速度提升一倍 - 速度提升一倍

既然如此，那我买一辆自行车也能改装嘛，所以我们现在新增一个具体的装饰者组件Bike自行车：

/**
 * 自行车, 具体的装饰者组件
 * Created by Carlton on 2016/11/2.
 */
class Bike(var name: String) : IUpdate
{
    override fun refit(): String
    {
        return ""
    }

    override fun toString(): String
    {
        return "Bike(name='$name')"
    }
}

一辆蓝色、能喷火、速度提升的自行车由此诞生：

val bike:Bike = Bike("凤凰牌自行车")
val refitBike = Speed(Fire(BlueColor(bike))).refit()
println("$bike $refitBike")
//  Bike(name='凤凰牌自行车')  - 蓝色的 - 能喷火 - 速度提升一倍

例子的类图：

类图不是目的，只是方便理解

[图片上传失败...(image-6c50e1-1527174192660)]

在这个例子中Car和Bike都是具体的装饰者组件，而继承自DecoratorUpdate的都是装饰者组件，可以自由扩展其他功能，比如Fire中的fire()，装饰者组件本身也可以被装饰。

项目应用

以下代码为Java实现

我们经常会遇到一个需求就是对前端的字段验证，比如字段是不是为空，手机号格式是否正确等等，如果对字段的判断需要新增规则用装饰者模式就能愉快的解决这个问题，接下来实现一个验证的装饰者，对字段的验证通过装饰者来实现。我们实现一个正则表达式的装饰者和一个函数方法的装饰者（验证字段可以自定义规则）。
首先，我们需要一个装饰者的接口：

/**
 * 参数验证接口
 * Created by Carlton on 2016/10/31.
 */
public interface IParamValidate<T>
{
    /**
     * 验证是否通过，先验证自身的条件再验证装饰者。先验证被装饰者，在验证自身的条件。
     *
     * @param value 被验证的字段
     *
     * @return 如果是true验证通过，如果是false验证失败。如果value==null，返回false
     */
    public boolean validate(T value);
}

然后，实现一个具体的装饰对象EmptyValidate：

/**
 * 字段为空的验证，也是装饰者中的被装饰的对象.
 * 如果数据类型是null 返回false，如果数据类型是CharSequence则使用{@link TextUtils#isEmpty(CharSequence)}判断字符是否为空。
 * 所有的true代表验证通过，false代表验证不通过。
 * Created by Carlton on 2016/11/1.
 */
public class EmptyValidate<T> implements IParamValidate<T>
{
    @Override
    public boolean validate(T value)
    {
        return value != null && (!(value instanceof CharSequence) || !TextUtils.isEmpty((CharSequence) value));
    }
}

有了具体的装饰对象，现在我们实现一个正则表达式的验证和一个函数验证的装饰者：

/**
 * 验证的接口，用于扩展自定义的验证方式。
 * 实现的返回必须遵循下面的规则：
 * <ul>
 * <li>
 * 1、如果value==null则返回false。
 * </li>
 * <li>
 * 2、如果返回true则代表验证通过，如果返回false则代表验证失败。
 * </li>
 * </ul>
 * Created by Carlton on 2016/11/1.
 */
public interface IValidator<T>
{
    /**
     * 自定义的验证接口方法
     *
     * @param value 被验证的值
     *
     * @return true是验证通过，false验证失败
     */
    public boolean validate(T value);
}

/**
 * 函数验证，通过一个自定义的函数来实现验证。如果Validator==null 返回自身验证返回true。
 * Created by Carlton on 2016/11/1.
 */
public class FunctionValidate<T> extends ValidateDecorator<T>
{
    private IValidator<T> mValidator;

    public FunctionValidate(IParamValidate<T> validate, IValidator<T> validator)
    {
        super(validate);
        mValidator = validator;
    }

    private boolean selfValidate(T value)
    {
        return mValidator == null || mValidator.validate(value);
    }

    @Override
    public boolean validate(T value)
    {
        return getValidate().validate(value) && selfValidate(value);
    }
}

/**
 * 正则表达式验证。使用一个正则表达是来匹配验证。
 * 如果value == null返回false。
 * 如果是true验证通过，如果是false验证不通过。
 * Created by Carlton on 2016/11/1.
 */
public class RexValidate extends ValidateDecorator<CharSequence>
{
    private String mPatternString = "\\.";
    public RexValidate(String patternString, IParamValidate<CharSequence> validate)
    {
        super(validate);
        mPatternString = patternString;
    }
    private boolean selfValidate(CharSequence value)
    {
        if(value == null)
        {
            return false;
        }
        Pattern pattern = Pattern.compile(mPatternString);
        Matcher matcher = pattern.matcher(value);
        return matcher.find();
    }

    @Override
    public boolean validate(CharSequence value)
    {
        return getValidate().validate(value) && selfValidate(value);
    }
}

IValidator是函数验证的接口，然后就是怎么使用。

• 验证一个字段是否是空、是否匹配正则“abc”、首字母是否是C

实现代码：

public static void main(String[] args)
{
    String validateValue = "这是被验证的字段";
    // 验证是否是空
    EmptyValidate<CharSequence> emptyValidate = new EmptyValidate<>();
    // 验证是否通过正则表达式'abc'
    RexValidate rxValidate = new RexValidate("abc", emptyValidate);
    // 验证自定义函数，首字母是否是C
    boolean result = new FunctionValidate<>(rxValidate, new IValidator<CharSequence>() {
        @Override
        public boolean validate(CharSequence value)
        {
            return !(value == null || value.length() > 0) && value.charAt(0) == 'C';
        }
    }).validate(validateValue);
    System.out.println(result);
}

同样的这些规则可以任意组合，自己也能实现其他的验证规则，比如可以把手机号验证直接实现成一个装饰者。

总结

装饰者模式解决的问题是动态的将责任附加到对象上，若要扩展功能，装饰者提供了比继承更有弹性的替代方案。万物都是平衡的，装饰者也有它自己的缺点，主要就是会产生很多类，在使用的时候不要无脑套用，需要自己权衡是否合适。另外java中的I/O Stream是用装饰者实现的，本来想扩展一个IO Stream对象，想来比较画蛇添足，有兴趣的可以去了解一下。

😊查看更多😊

不登高山，不知天之高也；不临深溪，不知地之厚也
感谢指点、交流、喜欢