资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/设计模式系列之装饰者模式

设计模式系列之装饰者模式

ytwman / 1059人阅读

摘要：测试类设计模式装饰者模式工厂模式只能读啦会报错只读异常可以正确运行第二部分定义抽象组件是具体组件和抽象装饰类的共同父类，声明了在具体组件中实现的方法。

前言

本篇文章分为四个部分：第一部分会举一个例子引出装饰者模式，让读者对装饰者模式有个感官上的认识；第二部分会给出装饰者模式的定义（当然我们主要不是来背定义，就当做积累专业名词来记吧，我个人是很不喜欢下定义的）；第三部分，我会拿jdk中两个使用装饰者模式的例子进行分析，让读者在学习模式的同时熟悉一下jdk源码。第四部分，我会结合装饰者模式理清楚java I/O各种流之间的关系（说实话，工作中用得最多，但是记了又忘，因为I/O类实在太多）后面学习到其他框架的时候再补充。

第一部分

假如有这样的需求：要求实现只能够读的List,要是你来完成这个任务你会如何做？
看下面代码实现：

</>复制代码 
  1. package decorate;
  2. import java.util.*;
  3. public class ReadOnlyList implements List{
  4.     private List target;
  5.     public ReadOnlyList(List target) {
  6.         super();
  7.         this.target = target;
  8.     }
  9.     @Override
  10.     public int size() {
  11.         return target.size();
  12.     }
  13.     @Override
  14.     public boolean isEmpty() {
  15.         return target.isEmpty();
  16.     }
  17.     @Override
  18.     public boolean contains(Object o) {
  19.         return target.contains(o);
  20.     }
  21.     @Override
  22.     public Iterator iterator() {
  23.         return target.iterator();
  24.     }
  25.     @Override
  26.     public Object[] toArray() {
  27.         return target.toArray();
  28.     }
  29.     @Override
  30.     public  T[] toArray(T[] a) {
  31.         return target.toArray(a);
  32.     }
  33.     @Override
  34.     public boolean add(E e) {
  35.         throw new RuntimeException("only read");
  36.     }
  37.     @Override
  38.     public boolean remove(Object o) {
  39.         throw new RuntimeException("only read");
  40.     }
  41.     @Override
  42.     public boolean containsAll(Collection c) {
  43.         return target.containsAll(c);
  44.     }
  45.     @Override
  46.     public boolean addAll(Collection c) {
  47.         throw new RuntimeException("only read");
  48.     }
  49.     @Override
  50.     public boolean removeAll(Collection c) {
  51.         throw new RuntimeException("only read");
  52.     }
  53.     @Override
  54.     public boolean retainAll(Collection c) {
  55.         throw new RuntimeException("only read");
  56.     }
  57.     @Override
  58.     public void clear() {
  59.         throw new RuntimeException("only read");
  60.     }
  61.     @Override
  62.     public boolean addAll(int index, Collection c) {
  63.         throw new RuntimeException("only read");
  64.     }
  65.     @Override
  66.     public E get(int index) {
  67.         return target.get(index);
  68.     }
  69.     @Override
  70.     public E set(int index, E element) {
  71.         throw new RuntimeException("only read");
  72.     }
  73.     @Override
  74.     public void add(int index, E element) {
  75.         throw new RuntimeException("only read");
  76.     }
  77.     @Override
  78.     public E remove(int index) {
  79.         throw new RuntimeException("only read");
  80.     }
  81.     @Override
  82.     public int indexOf(Object o) {
  83.         return target.indexOf(o);
  84.     }
  85.     @Override
  86.     public int lastIndexOf(Object o) {
  87.         return target.lastIndexOf(o);
  88.     }
  89.     @Override
  90.     public ListIterator listIterator() {
  91.         return target.listIterator();
  92.     }
  93.     @Override
  94.     public ListIterator listIterator(int index) {
  95.         return target.listIterator(index);
  96.     }
  97.     @Override
  98.     public List subList(int fromIndex, int toIndex) {
  99.         return target.subList(fromIndex, toIndex);
  100.     }
  101. }

这里的set,add,remove和addAll等操作都被限制了，只能够读。
测试类

</>复制代码 
  1. package decorate;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. public class ReadOnlyListMain {
  5.     public static void main(String[] args) {
  6.         List list = new ArrayList<>();
  7.         list.add("设计模式");
  8.         list.add("装饰者模式");
  9.         list.add("工厂模式");
  10.         ReadOnlyList onlyList = new ReadOnlyList<>(list);
  11. //        onlyList.add("只能读啦"); // 会报错只读异常
  12.         System.out.println(onlyList.size()); // 可以正确运行
  13.     }
  14. }
第二部分 定义

Component(抽象组件): 是具体组件和抽象装饰类的共同父类，声明了在具体组件中实现的方法。比如第一部分的List
ConcreteComponent（具体组件）: 抽象组件的子类，实现抽象组件的方法，装饰器可以给他加新的功能。比如ReadOnlyList
Decorator（抽象装饰者）: 抽象组件的子类，用来装饰具体组件或者装饰其他装饰组件
ConcreteDecorator（具体装饰者):抽象装饰类的子类
具体的可以看下面的结构图：

第三部分 jdk 例子分析

第一部分我们引出装饰者模式，ReadOnlyList 只读List将List给包装起来，提供了只读的功能，jdk Collection中也有个类似的实现:
public static List unmodifiableList(List list)

让我来看看它的源码：

</>复制代码 
  1. public static  List unmodifiableList(List list) {
  2.         return (list instanceof RandomAccess ?
  3.                 new UnmodifiableRandomAccessList<>(list) :
  4.                 new UnmodifiableList<>(list));
  5.     }

我们进入 UnmodifiableList

</>复制代码 
  1.  /**
  2.      * @serial include
  3.      */
  4.     static class UnmodifiableList extends UnmodifiableCollection
  5.                                   implements List {
  6.         private static final long serialVersionUID = -283967356065247728L;
  7.         final List list;
  8.         UnmodifiableList(List list) {
  9.             super(list);
  10.             this.list = list;
  11.         }
  12.         public boolean equals(Object o) {return o == this || list.equals(o);}
  13.         public int hashCode()           {return list.hashCode();}
  14.         public E get(int index) {return list.get(index);}
  15.         public E set(int index, E element) {
  16.             throw new UnsupportedOperationException();
  17.         }
  18.         public void add(int index, E element) {
  19.             throw new UnsupportedOperationException();
  20.         }
  21.         public E remove(int index) {
  22.             throw new UnsupportedOperationException();
  23.         }
  24.         public int indexOf(Object o)            {return list.indexOf(o);}
  25.         public int lastIndexOf(Object o)        {return list.lastIndexOf(o);}
  26.         public boolean addAll(int index, Collection c) {
  27.             throw new UnsupportedOperationException();
  28.         }
  29.         @Override
  30.         public void replaceAll(UnaryOperator operator) {
  31.             throw new UnsupportedOperationException();
  32.         }
  33.         @Override
  34.         public void sort(Comparator c) {
  35.             throw new UnsupportedOperationException();
  36.         }
  37.         public ListIterator listIterator()   {return listIterator(0);}
  38.         public ListIterator listIterator(final int index) {
  39.             return new ListIterator() {
  40.                 private final ListIterator i
  41.                     = list.listIterator(index);
  42.                 public boolean hasNext()     {return i.hasNext();}
  43.                 public E next()              {return i.next();}
  44.                 public boolean hasPrevious() {return i.hasPrevious();}
  45.                 public E previous()          {return i.previous();}
  46.                 public int nextIndex()       {return i.nextIndex();}
  47.                 public int previousIndex()   {return i.previousIndex();}
  48.                 public void remove() {
  49.                     throw new UnsupportedOperationException();
  50.                 }
  51.                 public void set(E e) {
  52.                     throw new UnsupportedOperationException();
  53.                 }
  54.                 public void add(E e) {
  55.                     throw new UnsupportedOperationException();
  56.                 }
  57.                 @Override
  58.                 public void forEachRemaining(Consumer action) {
  59.                     i.forEachRemaining(action);
  60.                 }
  61.             };
  62.         }
  63.         public List subList(int fromIndex, int toIndex) {
  64.             return new UnmodifiableList<>(list.subList(fromIndex, toIndex));
  65.         }
  66.         
  67.         private Object readResolve() {
  68.             return (list instanceof RandomAccess
  69.                     ? new UnmodifiableRandomAccessList<>(list)
  70.                     : this);
  71.         }
  72.     }

你们发现了啥，没错，就是它：addAll、replaceAll和sort等都抛出 UnsupportedOperationException异常，说明只支持读。

还没结束，再举个例子，Collections中还有将线程不安全的集合转换成线程安全的集合synchronizedList，也就是使用装饰者模式，本质上就是在方法加上synchronized 同步锁

让我们看源码：

</>复制代码 
  1. public static  List synchronizedList(List list) {
  2.         return (list instanceof RandomAccess ?
  3.                 new SynchronizedRandomAccessList<>(list) :
  4.                 new SynchronizedList<>(list));
  5.     }

老规矩，进入SynchronizedList

</>复制代码 
  1. /**
  2.      * @serial include
  3.      */
  4.     static class SynchronizedList
  5.         extends SynchronizedCollection
  6.         implements List {
  7.         private static final long serialVersionUID = -7754090372962971524L;
  8.         final List list;
  9.         SynchronizedList(List list) {
  10.             super(list);
  11.             this.list = list;
  12.         }
  13.         SynchronizedList(List list, Object mutex) {
  14.             super(list, mutex);
  15.             this.list = list;
  16.         }
  17.         public boolean equals(Object o) {
  18.             if (this == o)
  19.                 return true;
  20.             synchronized (mutex) {return list.equals(o);}
  21.         }
  22.         public int hashCode() {
  23.             synchronized (mutex) {return list.hashCode();}
  24.         }
  25.         public E get(int index) {
  26.             synchronized (mutex) {return list.get(index);}
  27.         }
  28.         public E set(int index, E element) {
  29.             synchronized (mutex) {return list.set(index, element);}
  30.         }
  31.         public void add(int index, E element) {
  32.             synchronized (mutex) {list.add(index, element);}
  33.         }
  34.         public E remove(int index) {
  35.             synchronized (mutex) {return list.remove(index);}
  36.         }
  37.         public int indexOf(Object o) {
  38.             synchronized (mutex) {return list.indexOf(o);}
  39.         }
  40.         public int lastIndexOf(Object o) {
  41.             synchronized (mutex) {return list.lastIndexOf(o);}
  42.         }
  43.         public boolean addAll(int index, Collection c) {
  44.             synchronized (mutex) {return list.addAll(index, c);}
  45.         }
  46.         public ListIterator listIterator() {
  47.             return list.listIterator(); // Must be manually synched by user
  48.         }
  49.         public ListIterator listIterator(int index) {
  50.             return list.listIterator(index); // Must be manually synched by user
  51.         }
  52.         public List subList(int fromIndex, int toIndex) {
  53.             synchronized (mutex) {
  54.                 return new SynchronizedList<>(list.subList(fromIndex, toIndex),
  55.                                             mutex);
  56.             }
  57.         }
  58.         @Override
  59.         public void replaceAll(UnaryOperator operator) {
  60.             synchronized (mutex) {list.replaceAll(operator);}
  61.         }
  62.         @Override
  63.         public void sort(Comparator c) {
  64.             synchronized (mutex) {list.sort(c);}
  65.         }
  66. private Object readResolve() {
  67.             return (list instanceof RandomAccess
  68.                     ? new SynchronizedRandomAccessList<>(list)
  69.                     : this);
  70.         }

嘿嘿，我们现在已经学会从设计模式的角度看jdk源码啦，开心。

第四部分 Java I/O流中的装饰者模式

我们来看看Java I/O中的流图

我们以输入流来分析，首先InputStream 相当于我们的抽象组件，FileInputStream、StringBufferInputStream、ByteArrayInputStream都是可以被装饰者包装起来的组件，FilterInputStream相当于抽象装饰者,PushbackInputStream、BufferedInputStream、DataInputStream和LineNumberInputStream都是具体的装
饰者

他们可以这样用: 一层装饰一层

</>复制代码 
  1.     InputStream ip = new DataInputStream(new BufferedInputStream(new FileInputStream(new File("/file_path"))));

如下图所示：

有了这样的思路，我们以后想编写自己的I/O，给流增加新的特性，我们就可以继承FilterInputStream，

</>复制代码 
  1. package decorate;
  2. import java.io.FilterInputStream;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. /**
  6.  * 将输入的流内所有的大写字符转成小写字符
  7.  */
  8. public class LowerCaseInputStream extends FilterInputStream{
  9.     public LowerCaseInputStream(InputStream in) {
  10.         super(in);
  11.     }
  12.     @Override
  13.     public int read() throws IOException {
  14.         int c = super.read();
  15.         if (c == -1) {
  16.             return c;
  17.         } else {
  18.             return Character.toLowerCase((char)c);
  19.         }
  20.     }
  21.     @Override
  22.     public int read(byte[] b, int off, int len) throws IOException {
  23.         int result = super.read(b, off, len);
  24.         for (int i = off; i < off + result; i++) {
  25.             b[i] = (byte) Character.toLowerCase((char)b[i]);
  26.         }
  27.         return result;
  28.     }
  29. }

测试类：把文件路径替换成你自己的路径

</>复制代码 
  1. package decorate;
  2. import java.io.*;
  3. /**
  4.  * 测试类
  5.  */
  6. public class MyInputStreamTest {
  7.     public static void main(String[] args) {
  8.         int c;
  9.         try {
  10.             InputStream in = new LowerCaseInputStream(new BufferedInputStream(new FileInputStream("file_path")));
  11.             while((c = in.read()) >= 0) {
  12.                 System.out.println((char)c);
  13.             }
  14.         } catch (IOException e) {
  15.             e.printStackTrace();
  16.         }
  17.     }
  18. }
GPU云服务器 云服务器 装饰者模式 装饰模式 建造者设计模式 策略者模式

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/75010.html

相关文章

  • 前端也要学系列：设计模式之装饰者模式

    摘要：什么是装饰者模式今天我们来讲另外一个非常实用的设计模式装饰者模式。就增加功能来说，装饰者模式相比生成子类更为灵活。下面，装饰者模式就要正式登场了。下一步，我们可以愉快的去使用装饰者模式啦 什么是装饰者模式 今天我们来讲另外一个非常实用的设计模式：装饰者模式。这个名字听上去有些莫名其妙，不着急，我们先来记住它的一个别名：包装器模式。 我们记着这两个名字来开始今天的文章。 首先还是上《设计...

    高胜山 评论0 收藏0

  • 设计模式之装饰者模式

    摘要：相关设计模式装饰者模式和代理模式装饰者模式关注再一个对象上动态添加方法代理模式关注再对代理对象的控制访问，可以对客户隐藏被代理类的信息装饰着模式和适配器模式都叫包装模式关于新职责适配器也可以在转换时增加新的职责，但主要目的不在此。 0x01.定义与类型 定义：装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的...

    chuyao 评论0 收藏0

  • Java 设计模式之装饰者模式

    摘要：装饰者模式组成结构抽象构件给出抽象接口或抽象类，以规范准备接收附加功能的对象。装饰者模式图解装饰者模式应用场景需要扩展一个类的功能，或给一个类添加附加职责。装饰者对象接受所有来自客户端的请求。参考资料设计模式 一、了解装饰者模式 1.1 什么是装饰者模式 装饰者模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰者来包裹真实的对...

    kumfo 评论0 收藏0

  • 美颜相机中的设计模式 —— 装饰者模式

    摘要：这是设计模式系列的第二篇，系列文章目录如下用一句话总结那些殊途同归的设计模式工厂策略模版方法美颜相机中的设计模式装饰者模式几乎所有的设计模式都是通过增加一层抽象来解决问题。 这是设计模式系列的第二篇，系列文章目录如下： 用一句话总结那些殊途同归的设计模式：工厂=？策略=？模版方法 美颜相机中的设计模式——装饰者模式 几乎所有的设计模式都是通过增加一层抽象来解决问题。 上一篇中提...

    anonymoussf 评论0 收藏0

  • 每天一个设计模式之装饰者模式

    摘要：作者按每天一个设计模式旨在初步领会设计模式的精髓，目前采用和两种语言实现。诚然，每种设计模式都有多种实现方式，但此小册只记录最直截了当的实现方式原文地址是每天一个设计模式之装饰者模式欢迎关注个人技术博客。 作者按：《每天一个设计模式》旨在初步领会设计模式的精髓，目前采用javascript和python两种语言实现。诚然，每种设计模式都有多种实现方式，但此小册只记录最直截了当的实现方式...

    brianway 评论0 收藏0

发表评论

登陆后可评论

0条评论

ytwman

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<