[[433206]]

創(chuàng)建型

單例模式

單例對(duì)象能節(jié)約系統(tǒng)資源，一個(gè)對(duì)象的創(chuàng)建和消亡的開(kāi)銷可能很小。但是日常的服務(wù)接口，就算是一般小公司也有十幾萬(wàn)的QPS吧。每一次的功能運(yùn)轉(zhuǎn)都創(chuàng)建新的對(duì)象來(lái)響應(yīng)請(qǐng)求，十幾萬(wàn)對(duì)象的創(chuàng)建和銷毀，想想就是一筆大開(kāi)銷，所以 spring 管理構(gòu)造的 bean 對(duì)象一般都是單例。而且單例模式可以更好的解決并發(fā)的問(wèn)題，方便實(shí)現(xiàn)數(shù)據(jù)的同步性

優(yōu)點(diǎn)

• 在內(nèi)存中只有一個(gè)對(duì)象，節(jié)省內(nèi)存空間
• 避免頻繁的創(chuàng)建銷毀對(duì)象，可以提高性能
• 避免對(duì)共享資源的多重占用，簡(jiǎn)化訪問(wèn)
• 為整個(gè)系統(tǒng)提供一個(gè)全局訪問(wèn)點(diǎn)

缺點(diǎn)

• 不適用于變化頻繁的對(duì)象

//餓漢式 
private static Singleton singleton = new Singleton(); 

//懶漢式 
private static Singleton singleton; 
public static Singleton getSingleton(){ 
    if (singleton == null) { 
        singleton = new Singleton(); //被動(dòng)創(chuàng)建，在真正需要使用時(shí)才去創(chuàng)建 
    } 
    return singleton; 
} 

//雙重判斷加鎖機(jī)制 
private volatile static Singleton instance; 
//程序運(yùn)行時(shí)創(chuàng)建一個(gè)靜態(tài)只讀的進(jìn)程輔助對(duì)象 
public static Singleton GetInstance() { 
    //先判斷是否存在，不存在再加鎖處理 
    if (instance == null){ 
        synchronized (Singleton.class){ 
            if(instance == null){ 
                instance = new Singleton(); 
            } 
        } 
    } 
    return instance; 
} 

//靜態(tài)初始化 
private static readonly Singleton instance= new Singleton(); 
public static Singleton GetInstance(){ 
    return instance; 
} 

工廠模式

使用者不關(guān)心對(duì)象的實(shí)例化過(guò)程，只關(guān)心對(duì)象的獲取。工廠模式使得產(chǎn)品的實(shí)例化過(guò)程和消費(fèi)者解耦

優(yōu)點(diǎn)

• 一個(gè)調(diào)用者想創(chuàng)建一個(gè)對(duì)象，只需通過(guò)其名稱或其他唯一鍵值在工廠獲取
• 擴(kuò)展性高，如果想增加生產(chǎn)一種類型對(duì)象，只要擴(kuò)展工廠類就可以

缺點(diǎn)

• 工廠類不太理想，因?yàn)槊吭黾右划a(chǎn)品，都要在工廠類中增加相應(yīng)的生產(chǎn)判斷邏輯，這是違背開(kāi)閉原則的

public interface Sender{  public void send();  }   
public class MailSender implements Sender {   
    @Override   
    public void send() {   
        System.out.println("this is mailsender!");   
    }   
} 
public class SmsSender implements Sender {   
    @Override   
    public void send() {   
        System.out.println("this is sms sender!");   
    }   
} 
public class SendFactory {   
    public Sender produce(String type) {   
        if ("mail".equals(type)) {   
            return new MailSender();   
        } else if ("sms".equals(type)) {   
            return new SmsSender();   
        } else {   
            return null;   
        }   
    }  
    //若還有其他產(chǎn)品 則在工廠里加對(duì)應(yīng)的 produce 方法 
}   

建造者模式

主要解決在軟件系統(tǒng)中一個(gè)復(fù)雜對(duì)象的創(chuàng)建工作，其通常由各個(gè)部分的子對(duì)象用一定的算法構(gòu)成;由于需求的變化，這個(gè)復(fù)雜對(duì)象的各個(gè)部分經(jīng)常面臨著劇烈的變化，但是將它們組合在一起的算法卻相對(duì)穩(wěn)定

優(yōu)點(diǎn)

• 擴(kuò)展性好，對(duì)象每一個(gè)屬性的構(gòu)建相互獨(dú)立，有利于解耦。
• 建造者可以對(duì)創(chuàng)建過(guò)程逐步細(xì)化，而不對(duì)其它模塊產(chǎn)生任何影響，便于控制細(xì)節(jié)風(fēng)險(xiǎn)

缺點(diǎn)

• 如果對(duì)象建造者發(fā)生變化，則建造者也要同步修改，后期維護(hù)成本較大
• 一種建造者對(duì)應(yīng)一種類型建造，一個(gè)建造者基本很難建造多種類型對(duì)象

@Data 
class Product { 
    private String name; 
    private String price; 
    // Product 的建造者  Builder 
    public static class Builder{ 
        public static Builder builder(){ 
            Builder builder = Builder(); 
        } 
        private Product product = new Product(); 
        public Builder name(String name){ product.name = name; return this;} 
        public Builder price(String price){ product.price = price; return this; } 
        //返回產(chǎn)品對(duì)象 
        public Product build() { return product; } 
    } 
} 

結(jié)構(gòu)型

適配器模式

連通上下游功能。一般是現(xiàn)有的功能和產(chǎn)品要求的接口不兼容，需要做轉(zhuǎn)換適配。平時(shí)見(jiàn)到的 PO，BO，VO，DTO 模型對(duì)象之間的相互轉(zhuǎn)換也是一種適配的過(guò)程

• 優(yōu)點(diǎn)：提高了類的復(fù)用，靈活性好
• 缺點(diǎn)：過(guò)多地使用適配器，會(huì)讓系統(tǒng)非常零亂，不易整體進(jìn)行把握。比如，明明看到調(diào)用的是 A 接口，其實(shí)內(nèi)部被適配成了 B 接口的實(shí)現(xiàn)

//類的適配器模式 
public class Source {   
    public void sayHello() {   
        System.out.println("lwl:hello!");   
    }   
}   
public interface Targetable {   
    /* Source方法相同 */   
    public void sayHello();   
    /* 新增的方法 */   
    public void hi();   
} 
// Source 用 Adapter 適配成 Targetable 
public class Adapter extends Source implements Targetable {   
    @Override   
    public void hi() {   
        System.out.println("csc:hi!");   
    }   
} 

//對(duì)象的適配器模式 
public class Source {   
    public void sayHello() {   
        System.out.println("lwl:hello!");   
    }   
}   
public interface Targetable {   
    /* Source方法相同 */   
    public void sayHello();   
    /* 新增的方法 */   
    public void hi();   
} 
//  Source的對(duì)象適配成 Targetable 
public class Adapter implements Targetable { 
    private Source source;   
    public Adapter(Source source){ this.source = source; } 
    public void sayHello(){ source.sayHello(); } 
    @Override   
    public void hi() {   
        System.out.println("csc:hi!");   
    }   
} 

裝飾器模式

增強(qiáng)對(duì)象功能，動(dòng)態(tài)的為一個(gè)對(duì)象增加功能，而且還能動(dòng)態(tài)撤銷。(繼承不能做到這一點(diǎn)，繼承的功能是靜態(tài)的，不能動(dòng)態(tài)增刪)

public interface Show(){ public void acting(); } 
public class Artist implements Show {   
    public void acting(){ 
        System.out.println("lwl 在唱歌!");   
    } 
}   
public class DecoratorArtist implements Show{ 
    Artist artist; 
    DecoratorArt(Artist artist){ 
        this.artist = artist; 
    } 
    public void acting(){ 
        System.out.println("lwl 在彈鋼琴!"); //增強(qiáng)的功能 
        this.artist.acting();  
        System.out.println("表演完畢!"); //增強(qiáng)的功能 
    } 
} 

代理模式

代理類是客戶類和委托類的中介，可以通過(guò)給代理類增加額外的功能來(lái)擴(kuò)展委托類的功能，這樣只需要修改代理類而不需要再修改委托類，符合代碼設(shè)計(jì)的開(kāi)閉原則

• 和裝飾器模式的區(qū)別：代理模式著重于增強(qiáng)類功能，且對(duì)面屏蔽原對(duì)象的創(chuàng)建過(guò)程;裝飾器模式增強(qiáng)的是對(duì)象，且裝飾器模式有一個(gè)動(dòng)態(tài)傳遞原對(duì)象的步驟
• 和對(duì)象的適配器模式優(yōu)點(diǎn)像：不過(guò)代理模式著重的是對(duì)原功能增強(qiáng)，適配器模式著重的是對(duì)新功能的兼容
• 優(yōu)點(diǎn)-1、職責(zé)清晰。2、高擴(kuò)展性

public class Artist implements Show {   
    public void acting(){ 
        System.out.println("lwl 在唱歌!");   
    } 
} 
public class ProxyArtist implements Show{ 
    Artist artist; 
    ProxyArtist(){  
        this.artist = new Artist();//屏蔽了 artist 對(duì)象的創(chuàng)建 
    } 
    public void acting(){ 
        System.out.println("lwl 在彈鋼琴!"); //增強(qiáng)的功能 
        this.artist.acting();  
        System.out.println("表演完畢!"); //增強(qiáng)的功能 
    } 
} 
public class Demo { 
    public static void main(String[] arg){ 
        Show show = new ProxyArtist(); 
        show.acting(); 
    } 
} 

橋接模式

橋接模式側(cè)重于功能的抽象，從而基于這些抽象接口構(gòu)建上層功能。一般的java 項(xiàng)目都會(huì)將接口和實(shí)現(xiàn)分離原因，就是基于橋接模式。提高了系統(tǒng)的擴(kuò)展能力，當(dāng)引用的底層邏輯有不同的設(shè)計(jì)實(shí)現(xiàn)時(shí)，繼承抽象接口重新實(shí)現(xiàn)一套即可，舊的不變，符合代碼設(shè)計(jì)的開(kāi)閉原則

• jdbc 的驅(qū)動(dòng)：常用的JDBC 和 DriverManager，JDBC進(jìn)行連接數(shù)據(jù)庫(kù)的時(shí)候，在各個(gè)數(shù)據(jù)庫(kù)之間進(jìn)行切換，基本不需要?jiǎng)犹嗟拇a，原因就是JDBC提供統(tǒng)一接口，每個(gè)數(shù)據(jù)庫(kù)提供各自的實(shí)現(xiàn)，用一個(gè)叫做數(shù)據(jù)庫(kù)驅(qū)動(dòng)的程序來(lái)橋接
• Unix 的文件系統(tǒng)：VFS(virtual File System)使得 Unix 系統(tǒng)可以在不同物理介質(zhì)上的不同文件系統(tǒng)進(jìn)行讀寫

public interface FileSystem(){  
  public void open(int file);  
  public String loading(int file);  
  public void store(int file, String data);  
} 
//網(wǎng)絡(luò)上的文件系統(tǒng) 
public class NetFileSystem implements FileSystem {   
  public void open(int file){ System.out.println(" netfile opening...."); } 
  public String loading(int file) {System.out.println(" net loading ...."); }   
  public void store(int file, String data) {System.out.println(" send to network ...."); }   
} 
//磁盤文件系統(tǒng) 
public class DiskFileSystem implements FileSystem{ 
  public void open(int file){ System.out.println(" disk opening...."); } 
  public String loading(int file) {System.out.println(" disk loading ...."); }  
  public void store(int file, String data) {System.out.println(" write back disk ...."); }    
} 
public class Linux { 
    FileSystem fileSystem;  
    //底層功能提供接口，橋接模式：功能和具體實(shí)現(xiàn)分離 
    //可以橋接 NetFileSystem 或者 DiskFileSystem 作為文件系統(tǒng) 
    public void set(FileSystem fileSystem){ this.fileSystem = fileSystem; } 
    //上層功能讀數(shù)據(jù) 
    public String read(int file){ 
        fileSystem.open(file); 
        ... // Linux 自己的系統(tǒng)功能 
        fileSystem.loading(file); 
        ...  
    } 
    //上層功能寫數(shù)據(jù) 
    public String write(int file, String data){ 
        fileSystem.open(file); 
        .... 
        fileSystem.store(file,data); 
    } 
} 

可配合適配器模式使用

享元模式

多個(gè)對(duì)象共享某些屬性。在創(chuàng)建有大量對(duì)象時(shí)，可能會(huì)造成內(nèi)存溢出，把其中共同的部分抽象出來(lái)，如果有相同的請(qǐng)求，直接返回在內(nèi)存中同一份屬性，避免重新創(chuàng)建

• 如 jdbc 連接池的連接對(duì)象，它們會(huì)共享池對(duì)象的 url、driverClassName、username、password 等屬性

public class ConnectionPool {   
    private Vector<Connection> pool;   
    /*公有屬性*/   
    private String url = "jdbc:mysql://localhost:3306/test";   
    private String username = "root";   
    private String password = "root";   
    private String driverClassName = "com.mysql.jdbc.Driver";   
    public ConnectionPool() {   
        pool = new Vector<Connection>(poolSize);   
        for (int i = 0; i < poolSize; i++) {   
            Class.forName(driverClassName);   
                // 每一個(gè) conn 共享了 driverClassName ，url, username, password 等屬性 
                Connection conn = DriverManager.getConnection(url, username, password);   
                pool.add(conn); 
            } 
    } 
    .... 
} 

外觀模式

• 用多個(gè)不同的對(duì)象實(shí)現(xiàn)一組更復(fù)雜的功能。使得類與類之間的關(guān)系解耦。如 spring 將使用各個(gè)簡(jiǎn)單的 component、dao 實(shí)現(xiàn)復(fù)雜的service，就是一種外觀模式
• 功能的組合，組合優(yōu)于繼承

public class DAO {  
    public void queryData(){ 
        System.out.print(" query data ") 
    } 
} 
public class Deal {   
    public void dealData(){ 
        System.out.print(" dealing data ") 
    } 
} 
public class Sender {   
    public void send(){ 
        System.out.print(" send data ") 
    } 
} 
public class Service(){ 
    private DAO dao;   
    private Deal deal;   
    private Sender sender; 
    //封裝 DAO，Deal，Sender 的功能，統(tǒng)一對(duì)外提供服務(wù) 
    public void reponse(){ 
        dao.queryData(); 
        deal.dealData(); 
        sender.send(); 
    } 
} 

行為型

策略模式

策略模式側(cè)重于不同的場(chǎng)景使用不同的策略。在有多種算法相似的情況下，解決 if...else 所帶來(lái)的復(fù)雜和難以維護(hù)

和橋接模式的區(qū)別：而橋接模式是結(jié)構(gòu)型模式，側(cè)重于分離底層功能的抽象和實(shí)現(xiàn)，底層只有一種實(shí)現(xiàn)也可以

// 上學(xué)的策略 
abstract class Strategy{ 
    private static final Map<Integer,Strategy> strategyMap = new ConcurrentHashMap<>(); 
    public Strategy(){ 
        strategyMap.put(getType(), this); 
    } 
    public static Strategy routing(int type){ 
        return strategyMap.get(type); 
    } 
    abstract int getType(); 
    abstract void method(); //留待子類實(shí)現(xiàn)差異 
} 
//跑路去學(xué)校 
class RunningStrategy extends Strategy{ 
    int getType() { return 0; } 
    void method() { System.out.println(" Run to school "); } 
} 
//公交去學(xué)校 
class BusStrategy extends Strategy{ 
    int getType() { return 1; } 
    void method() { System.out.println(" Go to school by bus "); } 
} 
//飛去學(xué)校 
class FlyStrategy extends Strategy{ 
    int getType() { return 2; } 
    void method() { System.out.println(" Fly to school "); } 
} 
class Context{ 
    //使用不同的策略 
    void method(int strategy){ 
        Strategy.routing(strategy).method(); 
    } 
} 

模板方法

和享元模式有一定的相似處，享元模式側(cè)重于屬性的共享，而且是結(jié)構(gòu)上的引用，不一定需要繼承;而模板方法是共享相同行為，一定有繼承行為

區(qū)別于策略模式是它有能抽象出來(lái)的共同行為，每一個(gè)子類再實(shí)現(xiàn)有差異細(xì)節(jié)

abstract class AbstractHandler{ 
    // handle是抽象出來(lái)的共同邏輯 
    void handle(String data){ 
        System.out.println("通用邏輯1..."); 
        stepOne(data); 
        System.out.println("通用邏輯2..."); 
        stepTwo(data); 
        System.out.println("通用邏輯3..."); 
    } 
    abstract void stepOne(String data); //留待子類實(shí)現(xiàn)差異 
    abstract void stepTwo(String data); //留待子類實(shí)現(xiàn)差異 
} 
class HelloHandler extends AbstractHandler{ 
    @Override 
    void stepOne(String data) { 
        System.out.println("hello: "+data); 
    } 
    @Override 
    void stepTwo(String data) { 
        System.out.println("hi: "+data); 
    } 
} 

迭代子模式

循環(huán)處理多個(gè)相同對(duì)象，用來(lái)遍歷集合或者數(shù)組

//迭代的抽象接口 
public interface Iterator {   
    //前移   
    public Object previous();   
    //后移   
    public Object next();   
    public boolean hasNext();    
}  
// 數(shù)組的迭代類 
public class ArrayIterator implements Iterator {   
    private Object[] datas;  
    private int cur = 0;   
    public ArrayIterator(Object[] datas){   
        this.datas = datas;   
    }   
    public String previous() {   
        if(cur > 0){ cur--;}   
        return datas[cur];   
    }   
    public Object next() {   
        if(cur < datas.length-1){ cur++;}   
        return datas[cur];   
    }   
    public boolean hasNext() {   
        return pos < datas.length-1 ? true ：false; 
    }   
}   

責(zé)任鏈模式

負(fù)責(zé)處理上游的傳遞下來(lái)的對(duì)象，并傳遞給下一個(gè)處理者

和迭代子模式的區(qū)別，責(zé)任鏈模式是多個(gè)hander處理同一個(gè)data，且 hander 處理具有順序性，不用全部 hander 處理，可在某一 hander 中斷，也可繼續(xù)傳遞。 

abstract class Handler<T,R> { 
    private Handler<R,?> next; 
    abstract R handle(T data); 
    public void setNext(Handler<R, ?> next){ this.next = next; } 
    public void loopHandle(T data){ 
        R result = this.handle(data); 
        if(next!=null && result!=null ) { next.loopHandle(result); } 
    } 
} 
//負(fù)責(zé)問(wèn)候 
class HelloHandler extends Handler<String, Integer> { 
    Integer handle(String data) { 
        System.out.println(data + " hello! "); 
        return 10; 
    } 
} 
//負(fù)責(zé)計(jì)數(shù) 
class CountHandler extends Handler<Integer, Double> { 
    Double handle(Integer data) { 
        System.out.println(" it is " + data); 
        return 2.0; 
    } 
} 
public class demo{ 
    public static void main(String[] args){ 
        HelloHandler hello = new HelloHandler(); 
        CountHandler count = new CountHandler(); 
        hello.setNext(count); 
        hello.loopHandle("lwl"); 
    } 
} 

觀察者模式

事件通知: 定義對(duì)象間的一種一對(duì)多的依賴關(guān)系，當(dāng)一個(gè)對(duì)象的狀態(tài)發(fā)生改變時(shí)，所有依賴于它的對(duì)象都得到通知。

優(yōu)點(diǎn)：觀察者和被觀察者是抽象耦合的

缺點(diǎn)

• 如果一個(gè)被觀察者對(duì)象有很多的直接和間接的觀察者的話，將所有的觀察者都通知到會(huì)花費(fèi)很多時(shí)間
• 如果在觀察者和觀察目標(biāo)之間有循環(huán)依賴的話，觀察目標(biāo)會(huì)觸發(fā)它們之間進(jìn)行循環(huán)調(diào)用，可能導(dǎo)致系統(tǒng)崩潰

//觀察者 
public abstract class Observer<T> { 
    public abstract void update(T data); 
} 
// 被觀察對(duì)象 
public class Subject<T> { 
    private List<Observer<T>> observers = new ArrayList<>(); 
    private T state; 
    public void deal() {  
        ....// 邏輯處理 
        //如果修改了 state，通知觀察者 
        if(...) notifyAllObservers(); 
    } 
    //增加一個(gè)觀察觀察 
    public void observe(Observer<T> observer) { 
        observers.add(observer); 
    } 
    public void notifyAllObservers() { 
        for (Observer<T> observer : observers) { 
            observer.update(state); 
        } 
    } 
} 

狀態(tài)機(jī)模式

不同的狀態(tài)不同的響應(yīng)，實(shí)現(xiàn)狀態(tài)之間的轉(zhuǎn)移

和策略模式的區(qū)別

• 狀態(tài)機(jī)模式是策略模式的孿生兄弟。策略模式可以讓用戶指定更換的策略算法，而狀態(tài)機(jī)模式是狀態(tài)在滿足一定條件下的自動(dòng)更換，用戶無(wú)法指定狀態(tài)，最多只能設(shè)置初始狀態(tài)
• 狀態(tài)機(jī)模式重點(diǎn)在各狀態(tài)之間的切換，從而做不同的事情;而策略模式更側(cè)重于根據(jù)具體情況選擇策略，并不涉及切換

interface State<T> { 
    //當(dāng)前狀態(tài)進(jìn)行處理數(shù)據(jù)，并返回下一個(gè)狀態(tài) 
    abstract State<T> action(T data); 
} 
@Data 
class Context<T>{ 
    private State<T> state; 
    public void invoke(T data){ 
        state != null ? state = state.action(data) : System.out.println(" nothing " + data); 
    } 
} 
// HelloState -> HiState 
class HelloState implements State<String>{ 
    public State<String> action(String data) { 
        System.out.println("hello!" + data); 
        return new HiState(); 
    } 
} 
// HiState -> FineState 
class HiState implements State<String>{ 
    public State<String> action(String data) { 
        System.out.println("how are you ?" + data); 
        return new FineState(); 
    } 
} 
//最后的狀態(tài) 
class FineState implements State<String>{ 
    public State<String> action(String data) { 
        System.out.println("I am  fine!"); 
        return null; 
    } 
} 
public class demo{ 
    public static void main(String[] args){ 
        Context<String> context = new Context<>(); 
        context.setState(new HelloState()); 
        context.invoke("lwl"); 
        context.invoke("lwl"); 
        context.invoke("lwl"); 
        context.invoke("lwl"); 
    } 
} 

備忘錄

記錄上一次的狀態(tài)，方便回滾。很多時(shí)候我們是需要記錄當(dāng)前的狀態(tài)，這樣做的目的就是為了允許用戶取消不確定或者錯(cuò)誤的操作，恢復(fù)到原先的狀態(tài)

缺點(diǎn)：消耗資源。如果類的成員變量過(guò)多，勢(shì)必會(huì)占用比較大的資源，而且每一次保存都會(huì)消耗一定的內(nèi)存

@Data 
public class Memento {  
    private String state; 
    public Memento(String state){ this.state = state; } 
} 
@Data 
public class Storage {  
    private String value;   
    public void storeMemento(){ 
        return new Memento(value);   
    } 
    public void restoreMemento(Memento memento){   
        this.value = memento.getValue();   
    } 
    public void action(){ System.out.println(" Storage類邏輯運(yùn)行 ")；} 
       
} 
public class MementoPatternDemo {  
    public static void main(String[] args) { 
        Storage storage = new Storage(); 
        storage.setValue(1); 
        storage.storeMemento();//備忘，一下 
        storage.action();//....邏輯運(yùn)行 
        restoreMemento(Memento memento);//使用備忘錄的恢復(fù)狀態(tài) 
    } 
}