腳本之家服務器常用軟件

快捷導航

Java結構型設計模式之享元模式示例詳解

更新時間：2022年09月22日 17:09:36 作者：丨Jack_Chen丨

享元模式（FlyWeight?Pattern），也叫蠅量模式，運用共享技術，有效的支持大量細粒度的對象，享元模式就是池技術的重要實現(xiàn)方式。本文將通過示例詳細講解享元模式，感興趣的可以了解一下

享元模式

概述

享元模式(Flyweight Pattern)又稱為輕量級模式，是對象池的一種實現(xiàn)。屬于結構型模式。

類似于線程池，線程池可以避免不停的創(chuàng)建和銷毀多個對象，消耗性能。享元模式提供了減少對象數(shù)量從而改善應用所需的對象結構的方式。

享元模式嘗試重用現(xiàn)有的同類對象，如果未找到匹配的對象，則創(chuàng)建新對象。主要用于減少創(chuàng)建對象的數(shù)量，以減少內存占用和提高性能。其本質是緩存共享對象，降低內存消耗。

目的

運用共享技術有效地支持大量細粒度的對象，將多個對同一對象的訪問集中起來，不必為每個訪問者創(chuàng)建一個單獨的對象，以此來降低內存的消耗。

在系統(tǒng)中增加類和對象的個數(shù)，當對象數(shù)量太多時，將導致運行代價過高，帶來性能下降等問題。

當有大量對象時，有可能會造成內存溢出，把其中共同的部分抽象出來，如果有相同的業(yè)務請求，直接返回在內存中已有的對象，避免重新創(chuàng)建。

應用場景

當系統(tǒng)中多處需要同一組信息時，可以把這些信息封裝到一個對象中，然后對該對象進行緩存，這樣，一個對象就可以提供給多處需要使用的地方，避免大量同一對象的多次創(chuàng)建，消耗大量內存空間。

享元模式其實就是工廠模式的一個改進機制，享元模式同樣要求創(chuàng)建一個或一組對象，并且就是通過工廠方法生成對象的，只不過享元模式中為工廠方法增加了緩存這一功能。

1、系統(tǒng)有大量相似對象。

2、需要緩沖池的場景。

例如

1、JAVA中的String，如果有則返回，如果沒有則創(chuàng)建一個字符串保存在字符串緩存池里面。

2、數(shù)據(jù)庫的數(shù)據(jù)池。

優(yōu)缺點

優(yōu)點：

1.減少對象的創(chuàng)建，降低內存中對象的數(shù)量，降低系統(tǒng)的內存，提高效率。

2.減少內存之外的其他資源占用。

缺點：

1.關注內、外部狀態(tài)、關注線程安全問題。

2.提高了系統(tǒng)的復雜度，需要分離出外部狀態(tài)和內部狀態(tài)，而且外部狀態(tài)具有固有化的性質，不應該隨著內部狀態(tài)的變化而變化，否則會造成系統(tǒng)的混亂。

主要角色

1.抽象享元角色(Flyweight)

享元對象抽象基類或者接口，同時定義出對象的外部狀態(tài)和內部狀態(tài)的接口或實現(xiàn)。

2.具體享元角色(ConcreteFlyweight)

實現(xiàn)抽象角色定義的業(yè)務。該角色的內部狀態(tài)處理應該與環(huán)境無關，不能出現(xiàn)會有一個操作改變內部狀態(tài)，同時修改了外部狀態(tài)。

3.享元工廠(FlyweightFactory)

負責管理享元對象池和創(chuàng)建享元對象。

享元模式結構

內部狀態(tài)和外部狀態(tài)

享元模式把一個對象的狀態(tài)分成內部狀態(tài)和外部狀態(tài)，內部狀態(tài)是不變的，外部狀態(tài)是變化的。然后通過共享不變的部分，達到減少對象數(shù)量并節(jié)約內存的目的。

享元模式的定義有2個要求：細粒度和共享對象。因為要求細粒度對象，所以不可避免地會使對象數(shù)量多且性質相近，此時就將這些對象的信息分為兩個部分：內部狀態(tài)和外部狀態(tài)。

內部狀態(tài)指與外部狀態(tài)

內部狀態(tài)指對象共享出來的信息，存儲在享元對象內部并且不會隨環(huán)境的改變而改變；

外部狀態(tài)指對象得以依賴的一個標記，是隨環(huán)境改變而改變的、不可共享的狀態(tài)。

例如

連接池中的連接對象，保存在連接對象中的用戶名、密碼、連接等信息，在創(chuàng)建對象的時候就設置好了，不會隨環(huán)境的改變而改變，這些為內部狀態(tài)。而每個連接要回收利用時，需要給它標記為可用狀態(tài)，這些為外部狀態(tài)。

享元模式的基本使用

創(chuàng)建抽象享元角色

public interface ITicket {
    /**
     * 查詢票信息
     */
    void query();
}

創(chuàng)建具體享元角色

public class TrainTicket implements ITicket {
    /**
     * 出發(fā)地
     */
    private String from;
    /**
     * 目的地
     */
    private String to;
    /**
     * 票種類
     */
    private String type;
    /**
     * 票價
     */
    private int price;
    public TrainTicket(String from, String to, String type) {
        this.from = from;
        this.to = to;
        this.type = type;
    }
    public void query() {
        this.price = new Random().nextInt(100);
        int num = new Random().nextInt(10);
        System.out.println(String.format("從%s到%s,%s,票價：%s元,剩余車票：%s", this.from, this.to, this.type, this.price, num));
    }
}

創(chuàng)建享元工廠

將相同查詢票的信息對象進行緩存，復用該對象進行查詢，減少對象的創(chuàng)建，降低內存的壓力。

public class TicketFactory {
    private static Map<String, ITicket> ticketPool = new ConcurrentHashMap<String, ITicket>();
    public static ITicket queryTicket(String from, String to, String type) {
        String key = "出發(fā)站："+from + " 目的站：" + to + " 坐席類型：" + type;
        if (TicketFactory.ticketPool.containsKey(key)) {
            System.out.println("使用緩存查詢：" + key);
            return TicketFactory.ticketPool.get(key);
        }
        System.out.println("第一次查詢，創(chuàng)建對象: " + key);
        ITicket ticket = new TrainTicket(from, to, type);
        TicketFactory.ticketPool.put(key, ticket);
        return ticket;
    }
}

客戶端調用

    public static void main(String[] args) {
        ITicket ticket = TicketFactory.queryTicket("A", "B", "特等座");
        ticket.query();
        ticket = TicketFactory.queryTicket("A", "B","一等座");
        ticket.query();
        ticket = TicketFactory.queryTicket("A", "B","特等座");
        ticket.query();
    }

第一次查詢，創(chuàng)建對象: 出發(fā)站：A 目的站：B 坐席類型：特等座
從A--->B,特等座,票價：38元,剩余車票：8

第一次查詢，創(chuàng)建對象: 出發(fā)站：A 目的站：B 坐席類型：一等座
從A--->B,一等座,票價：0元,剩余車票：4

使用緩存查詢：出發(fā)站：A 目的站：B 坐席類型：特等座
從A--->B,特等座,票價：62元,剩余車票：6

總結

容器式單例模式適用于需要大量創(chuàng)建單例對象的場景。享元模式的實現(xiàn)恰好類似于容器式單例模式。但是有一點區(qū)別是享元模式的重點在于結構上。

享元模式實現(xiàn)數(shù)據(jù)庫連接池

經常使用的數(shù)據(jù)庫連接池也使用了享元模式，有效提高了其運行的性能。

在使用數(shù)據(jù)庫連接池時，由于經常使用Connection對象，其主要性能消耗在建立連接和關閉連接的時候，為了提高Connection在調用時的性能，可以將Connection對象在調用前創(chuàng)建好緩存起來，用的時候從緩存中取值，用完再放回去，達到資源重復利用的目的。

創(chuàng)建數(shù)據(jù)庫連接池

@Data
public class ConnectionPool {
    private Vector<Connection> pool;
    private String url = "jdbc:mysql://localhost:3306/demo";
    private String username = "root";
    private String password = "123456";
    private String driverClassName = "com.mysql.jdbc.Driver";
    private int poolSize = 100;
    /**
     * 初始化一定數(shù)量的連接
     */
    public ConnectionPool() {
        pool = new Vector<Connection>(poolSize);
        try {
            Class.forName(driverClassName);
            for (int i = 0; i < poolSize; i++) {
                Connection conn = DriverManager.getConnection(url, username, password);
                pool.add(conn);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 獲取連接
     * @return
     */
    public synchronized Connection getConnection() {
        if (pool.size() > 0) {
            Connection conn = pool.get(0);
            pool.remove(conn);
            return conn;
        }
        return null;
    }
    /**
     * 釋放歸還連接
     * @param conn
     */
    public synchronized void release(Connection conn) {
        pool.add(conn);
    }
}

使用數(shù)據(jù)庫連接池

    public static void main(String[] args) {
        ConnectionPool connectionPool = new ConnectionPool();
        Connection conn = connectionPool.getConnection();
        System.out.println("獲取一個連接：" + conn + "連接池中剩余：" + connectionPool.getPool().size());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            connectionPool.release(conn);
            System.out.println("歸還連接池，連接池總數(shù)： " + connectionPool.getPool().size());
        }
    }