設計模式系列之裝飾者模式

ytwman 發布于2019-08-16 18:24 / 990人閱讀

摘要：測試類設計模式裝飾者模式工廠模式只能讀啦會報錯只讀異常可以正確運行第二部分定義抽象組件是具體組件和抽象裝飾類的共同父類，聲明了在具體組件中實現的方法。

前言

本篇文章分為四個部分：第一部分會舉一個例子引出裝飾者模式，讓讀者對裝飾者模式有個感官上的認識；第二部分會給出裝飾者模式的定義（當然我們主要不是來背定義，就當做積累專業名詞來記吧，我個人是很不喜歡下定義的）；第三部分，我會拿jdk中兩個使用裝飾者模式的例子進行分析，讓讀者在學習模式的同時熟悉一下jdk源碼。第四部分，我會結合裝飾者模式理清楚java I/O各種流之間的關系（說實話，工作中用得最多，但是記了又忘，因為I/O類實在太多）后面學習到其他框架的時候再補充。

第一部分

假如有這樣的需求：要求實現只能夠讀的List,要是你來完成這個任務你會如何做？
看下面代碼實現：

package decorate;
import java.util.*;

public class ReadOnlyList implements List{

    private List target;

    public ReadOnlyList(List target) {
        super();
        this.target = target;
    }

    @Override
    public int size() {
        return target.size();
    }

    @Override
    public boolean isEmpty() {
        return target.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return target.contains(o);
    }

    @Override
    public Iterator iterator() {
        return target.iterator();
    }

    @Override
    public Object[] toArray() {
        return target.toArray();
    }

    @Override
    public  T[] toArray(T[] a) {
        return target.toArray(a);
    }

    @Override
    public boolean add(E e) {
        throw new RuntimeException("only read");
    }

    @Override
    public boolean remove(Object o) {
        throw new RuntimeException("only read");
    }

    @Override
    public boolean containsAll(Collection c) {
        return target.containsAll(c);
    }

    @Override
    public boolean addAll(Collection c) {
        throw new RuntimeException("only read");
    }

    @Override
    public boolean removeAll(Collection c) {
        throw new RuntimeException("only read");
    }

    @Override
    public boolean retainAll(Collection c) {
        throw new RuntimeException("only read");
    }

    @Override
    public void clear() {
        throw new RuntimeException("only read");
    }

    @Override
    public boolean addAll(int index, Collection c) {
        throw new RuntimeException("only read");
    }

    @Override
    public E get(int index) {
        return target.get(index);
    }

    @Override
    public E set(int index, E element) {
        throw new RuntimeException("only read");
    }

    @Override
    public void add(int index, E element) {
        throw new RuntimeException("only read");
    }

    @Override
    public E remove(int index) {
        throw new RuntimeException("only read");
    }

    @Override
    public int indexOf(Object o) {
        return target.indexOf(o);
    }

    @Override
    public int lastIndexOf(Object o) {
        return target.lastIndexOf(o);
    }

    @Override
    public ListIterator listIterator() {
        return target.listIterator();
    }

    @Override
    public ListIterator listIterator(int index) {
        return target.listIterator(index);
    }

    @Override
    public List subList(int fromIndex, int toIndex) {
        return target.subList(fromIndex, toIndex);
    }

}

這里的set,add,remove和addAll等操作都被限制了，只能夠讀。
測試類

package decorate;

import java.util.ArrayList;
import java.util.List;

public class ReadOnlyListMain {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("設計模式");
        list.add("裝飾者模式");
        list.add("工廠模式");
        ReadOnlyList onlyList = new ReadOnlyList<>(list);
//        onlyList.add("只能讀啦"); // 會報錯只讀異常
        System.out.println(onlyList.size()); // 可以正確運行
    }
}

第二部分定義

Component(抽象組件): 是具體組件和抽象裝飾類的共同父類，聲明了在具體組件中實現的方法。比如第一部分的List
ConcreteComponent（具體組件）: 抽象組件的子類，實現抽象組件的方法，裝飾器可以給他加新的功能。比如ReadOnlyList
Decorator（抽象裝飾者）: 抽象組件的子類，用來裝飾具體組件或者裝飾其他裝飾組件
ConcreteDecorator（具體裝飾者):抽象裝飾類的子類
具體的可以看下面的結構圖：

第三部分 jdk 例子分析

第一部分我們引出裝飾者模式，ReadOnlyList 只讀List將List給包裝起來，提供了只讀的功能，jdk Collection中也有個類似的實現:
public static List unmodifiableList(List list)

讓我來看看它的源碼：

public static  List unmodifiableList(List list) {
        return (list instanceof RandomAccess ?
                new UnmodifiableRandomAccessList<>(list) :
                new UnmodifiableList<>(list));
    }

我們進入 UnmodifiableList

 /**
     * @serial include
     */
    static class UnmodifiableList extends UnmodifiableCollection
                                  implements List {
        private static final long serialVersionUID = -283967356065247728L;

        final List list;

        UnmodifiableList(List list) {
            super(list);
            this.list = list;
        }

        public boolean equals(Object o) {return o == this || list.equals(o);}
        public int hashCode()           {return list.hashCode();}

        public E get(int index) {return list.get(index);}
        public E set(int index, E element) {
            throw new UnsupportedOperationException();
        }
        public void add(int index, E element) {
            throw new UnsupportedOperationException();
        }
        public E remove(int index) {
            throw new UnsupportedOperationException();
        }
        public int indexOf(Object o)            {return list.indexOf(o);}
        public int lastIndexOf(Object o)        {return list.lastIndexOf(o);}
        public boolean addAll(int index, Collection c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void replaceAll(UnaryOperator operator) {
            throw new UnsupportedOperationException();
        }
        @Override
        public void sort(Comparator c) {
            throw new UnsupportedOperationException();
        }

        public ListIterator listIterator()   {return listIterator(0);}

        public ListIterator listIterator(final int index) {
            return new ListIterator() {
                private final ListIterator i
                    = list.listIterator(index);

                public boolean hasNext()     {return i.hasNext();}
                public E next()              {return i.next();}
                public boolean hasPrevious() {return i.hasPrevious();}
                public E previous()          {return i.previous();}
                public int nextIndex()       {return i.nextIndex();}
                public int previousIndex()   {return i.previousIndex();}

                public void remove() {
                    throw new UnsupportedOperationException();
                }
                public void set(E e) {
                    throw new UnsupportedOperationException();
                }
                public void add(E e) {
                    throw new UnsupportedOperationException();
                }

                @Override
                public void forEachRemaining(Consumer action) {
                    i.forEachRemaining(action);
                }
            };
        }

        public List subList(int fromIndex, int toIndex) {
            return new UnmodifiableList<>(list.subList(fromIndex, toIndex));
        }

        
        private Object readResolve() {
            return (list instanceof RandomAccess
                    ? new UnmodifiableRandomAccessList<>(list)
                    : this);
        }
    }

你們發現了啥，沒錯，就是它：addAll、replaceAll和sort等都拋出 UnsupportedOperationException異常，說明只支持讀。

還沒結束，再舉個例子，Collections中還有將線程不安全的集合轉換成線程安全的集合synchronizedList，也就是使用裝飾者模式，本質上就是在方法加上synchronized 同步鎖

讓我們看源碼：

public static  List synchronizedList(List list) {
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<>(list) :
                new SynchronizedList<>(list));
    }

老規矩，進入SynchronizedList

/**
     * @serial include
     */
    static class SynchronizedList
        extends SynchronizedCollection
        implements List {
        private static final long serialVersionUID = -7754090372962971524L;

        final List list;

        SynchronizedList(List list) {
            super(list);
            this.list = list;
        }
        SynchronizedList(List list, Object mutex) {
            super(list, mutex);
            this.list = list;
        }

        public boolean equals(Object o) {
            if (this == o)
                return true;
            synchronized (mutex) {return list.equals(o);}
        }
        public int hashCode() {
            synchronized (mutex) {return list.hashCode();}
        }

        public E get(int index) {
            synchronized (mutex) {return list.get(index);}
        }
        public E set(int index, E element) {
            synchronized (mutex) {return list.set(index, element);}
        }
        public void add(int index, E element) {
            synchronized (mutex) {list.add(index, element);}
        }
        public E remove(int index) {
            synchronized (mutex) {return list.remove(index);}
        }

        public int indexOf(Object o) {
            synchronized (mutex) {return list.indexOf(o);}
        }
        public int lastIndexOf(Object o) {
            synchronized (mutex) {return list.lastIndexOf(o);}
        }

        public boolean addAll(int index, Collection c) {
            synchronized (mutex) {return list.addAll(index, c);}
        }

        public ListIterator listIterator() {
            return list.listIterator(); // Must be manually synched by user
        }

        public ListIterator listIterator(int index) {
            return list.listIterator(index); // Must be manually synched by user
        }

        public List subList(int fromIndex, int toIndex) {
            synchronized (mutex) {
                return new SynchronizedList<>(list.subList(fromIndex, toIndex),
                                            mutex);
            }
        }

        @Override
        public void replaceAll(UnaryOperator operator) {
            synchronized (mutex) {list.replaceAll(operator);}
        }
        @Override
        public void sort(Comparator c) {
            synchronized (mutex) {list.sort(c);}
        }
private Object readResolve() {
            return (list instanceof RandomAccess
                    ? new SynchronizedRandomAccessList<>(list)
                    : this);
        }

嘿嘿，我們現在已經學會從設計模式的角度看jdk源碼啦，開心。

第四部分 Java I/O流中的裝飾者模式

我們來看看Java I/O中的流圖

我們以輸入流來分析，首先InputStream 相當于我們的抽象組件，FileInputStream、StringBufferInputStream、ByteArrayInputStream都是可以被裝飾者包裝起來的組件，FilterInputStream相當于抽象裝飾者,PushbackInputStream、BufferedInputStream、DataInputStream和LineNumberInputStream都是具體的裝
飾者

他們可以這樣用: 一層裝飾一層

    InputStream ip = new DataInputStream(new BufferedInputStream(new FileInputStream(new File("/file_path"))));

如下圖所示：

有了這樣的思路，我們以后想編寫自己的I/O，給流增加新的特性，我們就可以繼承FilterInputStream，

package decorate;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 將輸入的流內所有的大寫字符轉成小寫字符
 */
public class LowerCaseInputStream extends FilterInputStream{

    public LowerCaseInputStream(InputStream in) {
        super(in);
    }

    @Override
    public int read() throws IOException {
        int c = super.read();
        if (c == -1) {
            return c;
        } else {
            return Character.toLowerCase((char)c);
        }
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        int result = super.read(b, off, len);
        for (int i = off; i < off + result; i++) {
            b[i] = (byte) Character.toLowerCase((char)b[i]);
        }
        return result;
    }
}

測試類：把文件路徑替換成你自己的路徑

package decorate;

import java.io.*;

/**
 * 測試類
 */
public class MyInputStreamTest {

    public static void main(String[] args) {
        int c;
        try {
            InputStream in = new LowerCaseInputStream(new BufferedInputStream(new FileInputStream("file_path")));
            while((c = in.read()) >= 0) {
                System.out.println((char)c);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

GPU云服務器云服務器裝飾者模式裝飾模式建造者設計模式策略者模式

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/75010.html

前端也要學系列：設計模式之裝飾者模式

摘要：什么是裝飾者模式今天我們來講另外一個非常實用的設計模式裝飾者模式。就增加功能來說，裝飾者模式相比生成子類更為靈活。下面，裝飾者模式就要正式登場了。下一步，我們可以愉快的去使用裝飾者模式啦什么是裝飾者模式今天我們來講另外一個非常實用的設計模式：裝飾者模式。這個名字聽上去有些莫名其妙，不著急，我們先來記住它的一個別名：包裝器模式。我們記著這兩個名字來開始今天的文章。首先還是上《設計...

高勝山 2019-08-26 11:54 評論0 收藏0
設計模式之裝飾者模式

摘要：相關設計模式裝飾者模式和代理模式裝飾者模式關注再一個對象上動態添加方法代理模式關注再對代理對象的控制訪問，可以對客戶隱藏被代理類的信息裝飾著模式和適配器模式都叫包裝模式關于新職責適配器也可以在轉換時增加新的職責，但主要目的不在此。 0x01.定義與類型定義：裝飾模式指的是在不必改變原類文件和使用繼承的情況下，動態地擴展一個對象的功能。它是通過創建一個包裝對象，也就是裝飾來包裹真實的...

chuyao 2019-08-16 18:34 評論0 收藏0
Java 設計模式之裝飾者模式

摘要：裝飾者模式組成結構抽象構件給出抽象接口或抽象類，以規范準備接收附加功能的對象。裝飾者模式圖解裝飾者模式應用場景需要擴展一個類的功能，或給一個類添加附加職責。裝飾者對象接受所有來自客戶端的請求。參考資料設計模式一、了解裝飾者模式 1.1 什么是裝飾者模式裝飾者模式指的是在不必改變原類文件和使用繼承的情況下，動態地擴展一個對象的功能。它是通過創建一個包裝對象，也就是裝飾者來包裹真實的對...

kumfo 2019-08-19 11:14 評論0 收藏0
美顏相機中的設計模式 —— 裝飾者模式

摘要：這是設計模式系列的第二篇，系列文章目錄如下用一句話總結那些殊途同歸的設計模式工廠策略模版方法美顏相機中的設計模式裝飾者模式幾乎所有的設計模式都是通過增加一層抽象來解決問題。這是設計模式系列的第二篇，系列文章目錄如下：用一句話總結那些殊途同歸的設計模式：工廠=？策略=？模版方法美顏相機中的設計模式——裝飾者模式幾乎所有的設計模式都是通過增加一層抽象來解決問題。上一篇中提...

anonymoussf 2019-05-27 17:41 評論0 收藏0
每天一個設計模式之裝飾者模式

摘要：作者按每天一個設計模式旨在初步領會設計模式的精髓，目前采用和兩種語言實現。誠然，每種設計模式都有多種實現方式，但此小冊只記錄最直截了當的實現方式原文地址是每天一個設計模式之裝飾者模式歡迎關注個人技術博客。作者按：《每天一個設計模式》旨在初步領會設計模式的精髓，目前采用javascript和python兩種語言實現。誠然，每種設計模式都有多種實現方式，但此小冊只記錄最直截了當的實現方式...

brianway 2019-08-23 14:56 評論0 收藏0