装饰者模式及实例

简述

装饰者模式是23中设计模式之一，装饰者模式的定义是在不改变原有的类，不使用继承的基础上，动态扩展对象的一种思想模式。

实现步骤

1.装饰者和被装饰者的类都要实现同一个接口

2.在装饰者类中必须有被装饰者的引用或者组合

3.在装饰者类中对需要扩展的方法进行扩展

4.在装饰者类中对不需要扩展的方法调用被装饰者类的同名方法即可

装饰者模式相比于继承

装饰者类内部可以通过多态技术对多个需要增强的类进行增强而不用像继承那样对每个需要增强的类都创建具体的子类，也因为如此装饰者类的代码逻辑也会更复杂可读性和可维护性难度增加。

装饰者模式相比较于代理模式

装饰者模式是对被装饰者本身方法的增强，而代理模式是将控制权交给代理，被代理的类并没有得到增强。

装饰者模式实例

实例代码

实体类

public class CellPhone implements Serializable {

    //序列化之后class字节码文件被修改，例如增删属性，此时在反序列化就会出现异常说
    //序列化版本不一致，加上如下属性就能是序列化和反序列化版本一致从而正常运行
    //其中的数值可以随便写
    static final long serialVersionUID = 42L;

    private String name;
    private Integer price;

    //被transient修饰的标识瞬态，不会被序列化
    private transient String color;

    public CellPhone(String name, Integer price, String color) {
        this.name = name;
        this.price = price;
        this.color = color;
    }

    public CellPhone() {

    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "CellPhone{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", color='" + color + '\'' +
                '}';
    }
}

接口

public interface BaseDao<T> {

    int add(T element);
    int delete(T element);
    int update(T element);
    T get(T element);
}

被装饰者

public class BaseDaoimpl<T> implements BaseDao<T>{
    @Override
    public int add(T element) {
        System.out.println("add method is success");
        return 0;
    }

    @Override
    public int delete(T element) {
        System.out.println("delete method is success");
        return 0;
    }

    @Override
    public int update(T element) {
        System.out.println("update method is success");
        return 0;
    }

    @Override
    public T get(T element) {
        System.out.println("get method is success");
        return element;
    }
}

装饰者

public class CacheBaseDaoimpl<T> implements BaseDao<T>{

    BaseDao<T> baseDao;

    public CacheBaseDaoimpl(BaseDao<T> baseDao) {
        this.baseDao = baseDao;
    }

    @Override
    public int add(T element) {
        return baseDao.add(element);
    }

    @Override
    public int delete(T element) {
        return baseDao.delete(element);
    }

    @Override
    public int update(T element) {
        return baseDao.update(element);
    }

    /**
     * 加强get方法
     * 从缓存中取
     * 如果没有则调用被装饰者去取
     * @return
     */
    @Override
    public T get(T element) {
        if(element != null){
            T formCache = getFormCache(element);
            if(formCache != null){
                System.out.println("Cache is Ok");
            }else {
                System.out.println("Database is Ok");
                return baseDao.get(element);
            }
        }
        return null;
    }

    private T getFormCache(T element) {
        if(element != null){
            System.out.println("Cache getFormCache method is success");
            return element;
        }else{
            return null;
        }
    }
}

测试类

public class BaseDaoTest {

    public static void main(String[] args) {

        CellPhone cellPhone = new CellPhone("apple",12999,"white");
        BaseDao<CellPhone> cellPhoneBaseDao = new BaseDaoimpl<>();
        cellPhoneBaseDao.get(cellPhone);
        cellPhoneBaseDao.update(cellPhone);
        cellPhoneBaseDao.get(cellPhone);

        System.out.println("**************************");
        System.out.println("**************************");

        //加强get
        BaseDao<CellPhone> cacheBaseDao = new CacheBaseDaoimpl<>(cellPhoneBaseDao);
        cacheBaseDao.get(cellPhone);

    }
}

实例代码说明

整体结构

 

装饰者只增强get方法，其余方法还是调用被装饰者的原方法；

测试类中利用装饰者类的构造方法将被装饰者传入其中；

JDK中的装饰者模式实现

 InputStream        OutputStream        Reader        Writer 都是典型的被装饰者

BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter 都是装饰者