一、什么是享元模式
說到享元模式，第一個想到的應該就是池技術了，String常量池、資料庫連接池、緩沖池等等都是享元模式的應用，所以說享元模式是池技術的重要實作方式，
比如我們每次創建字串物件時，都需要創建一個新的字串物件的話，記憶體開銷會很大，所以如果第一次創建了字串物件“adam“，下次再創建相同的字串”adam“時，只是把它的參考指向”adam“，這樣就實作了”adam“字串再記憶體中的共享，
舉個最簡單的例子，網路聯機下棋的時候，一臺服務器連接了多個客戶端（玩家），如果我們每個棋子都要創建物件，那一盤棋可能就有上百個物件產生，玩家多點的話，因為記憶體空間有限，一臺服務器就難以支持了，所以這里要使用享元模式，將棋子物件減少到幾個實體，下面給出享元模式的定義，
享元模式（Flyweight），運用共享技術有效地支持大量細粒度的物件，UML結構圖如下：
其中，Flyweight是抽象享元角色，它是產品的抽象類，同時定義出物件的外部狀態和內部狀態（外部狀態及內部狀態相關內容見后方）的介面或實作；ConcreteFlyweight是具體享元角色，是具體的產品類，實作抽象角色定義的業務；UnsharedConcreteFlyweight是不可共享的享元角色，一般不會出現在享元工廠中；FlyweightFactory是享元工廠，它用于構造一個池容器，同時提供從池中獲得物件的方法，
1. Flyweight抽象類
所有具體享元類的超類或介面，通過這個介面，Flyweight可以接受并作用于外部狀態，
1 public abstract class Flyweight {
2
3 //內部狀態
4 public String intrinsic;
5 //外部狀態
6 protected final String extrinsic;
7
8 //要求享元角色必須接受外部狀態
9 public Flyweight(String extrinsic) {
10 this.extrinsic = extrinsic;
11 }
12
13 //定義業務操作
14 public abstract void operate(int extrinsic);
15
16 public String getIntrinsic() {
17 return intrinsic;
18 }
19
20 public void setIntrinsic(String intrinsic) {
21 this.intrinsic = intrinsic;
22 }
23
24 }
2. ConcreteFlyweight類
繼承Flyweight超類或實作Flyweight介面，并為其內部狀態增加存盤空間，
1 public class ConcreteFlyweight extends Flyweight {
2
3 //接受外部狀態
4 public ConcreteFlyweight(String extrinsic) {
5 super(extrinsic);
6 }
7
8 //根據外部狀態進行邏輯處理
9 @Override
10 public void operate(int extrinsic) {
11 System.out.println("具體Flyweight:" + extrinsic);
12 }
13
14 }
3. UnsharedConcreteFlyweight類
指那些不需要共享的Flyweight子類，
1 public class UnsharedConcreteFlyweight extends Flyweight {
2
3 public UnsharedConcreteFlyweight(String extrinsic) {
4 super(extrinsic);
5 }
6
7 @Override
8 public void operate(int extrinsic) {
9 System.out.println("不共享的具體Flyweight:" + extrinsic);
10 }
11
12 }
4. FlyweightFactory類
一個享元工廠，用來創建并管理Flyweight物件，主要是用來確保合理地共享Flyweight，當用戶請求一個Flyweight時，FlyweightFactory物件提供一個已創建的實體或創建一個實體，
1 public class FlyweightFactory {
2
3 //定義一個池容器
4 private static HashMap<String, Flyweight> pool = new HashMap<>();
5
6 //享元工廠
7 public static Flyweight getFlyweight(String extrinsic) {
8 Flyweight flyweight = null;
9
10 if(pool.containsKey(extrinsic)) { //池中有該物件
11 flyweight = pool.get(extrinsic);
12 System.out.print("已有 " + extrinsic + " 直接從池中取---->");
13 } else {
14 //根據外部狀態創建享元物件
15 flyweight = new ConcreteFlyweight(extrinsic);
16 //放入池中
17 pool.put(extrinsic, flyweight);
18 System.out.print("創建 " + extrinsic + " 并從池中取出---->");
19 }
20
21 return flyweight;
22 }
23 }
5. Client客戶端
1 public class Client {
2
3 public static void main(String[] args) {
4 int extrinsic = 22;
5
6 Flyweight flyweightX = FlyweightFactory.getFlyweight("X");
7 flyweightX.operate(++ extrinsic);
8
9 Flyweight flyweightY = FlyweightFactory.getFlyweight("Y");
10 flyweightY.operate(++ extrinsic);
11
12 Flyweight flyweightZ = FlyweightFactory.getFlyweight("Z");
13 flyweightZ.operate(++ extrinsic);
14
15 Flyweight flyweightReX = FlyweightFactory.getFlyweight("X");
16 flyweightReX.operate(++ extrinsic);
17
18 Flyweight unsharedFlyweight = new UnsharedConcreteFlyweight("X");
19 unsharedFlyweight.operate(++ extrinsic);
20 }
21
22 }
運行結果如下：
從這個結果我們可以看出來，第一次創建X、Y、Z時，都是先創建再從池中取出，而第二次創建X時，因為池中已經存在了，所以直接從池中取出，這就是享元模式，
二、內部狀態和外部狀態
上面享元模式的定義為我們提出了兩個要求：細粒度和共享物件，我們知道分配太多的物件到應用程式中將有損程式的性能，同時還容易造成記憶體溢位，要避免這種情況，用到的就是共享技術，這里就需要提到內部狀態和外部狀態了，
因為要求細粒度物件，所以不可避免地會使物件數量多且性質相近，此時我們就將這些物件的資訊分為兩個部分：內部狀態和外部狀態，
內部狀態指物件共享出來的資訊，存盤在享元物件內部并且不會隨環境的改變而改變；外部狀態指物件得以依賴的一個標記，是隨環境改變而改變的、不可共享的狀態，
我們舉一個最簡單的例子，棋牌類游戲大家都有玩過吧，比如說說圍棋和跳棋，它們都有大量的棋子物件，圍棋和五子棋只有黑白兩色，跳棋顏色略多一點，但也是不太變化的，所以棋子顏色就是棋子的內部狀態；而各個棋子之間的差別就是位置的不同，我們落子嘛，落子顏色是定的，但位置是變化的，所以方位坐標就是棋子的外部狀態，
那么為什么這里要用享元模式呢？可以想象一下，上面提到的棋類游戲的例子，比如圍棋，理論上有361個空位可以放棋子，常規情況下每盤棋都有可能有兩三百個棋子物件產生，因為記憶體空間有限，一臺服務器很難支持更多的玩家玩圍棋游戲，如果用享元模式來處理棋子，那么棋子物件就可以減少到只有兩個實體，這樣就很好的解決了物件的開銷問題，
三、享元模式的應用
1. 何時使用
- 系統中有大量物件時
- 這些物件消耗大量記憶體時
- 這些物件的狀態大部分可以外部化時
2. 方法
- 用唯一標識碼判斷，如果在記憶體中有，則回傳這個唯一標識碼所標識的物件，用HashMap/HashTable存盤
3. 優點
- 大大減少了物件的創建，降低了程式記憶體的占用，提高效率
4. 缺點
- 提高了系統的復雜度，需要分離出內部狀態和外部狀態，而外部狀態具有固化特性，不應該隨著內部狀態的改變而改變
5. 使用場景
- 系統中存在大量相似物件
- 需要緩沖池的場景
6. 應用實體
- String常量池
- 資料庫連接池
7. 注意事項
- 注意劃分內部狀態和外部狀態，否則可能會引起執行緒安全問題
- 這些類必須有一個工廠類加以控制
四、享元模式的實作
應用實體的話，其實上面的模板就已經是一個很好的例子了，類似于String常量池，沒有的物件創建后存在池中，若池中存在該物件則直接從池中取出，
為了更好的理解享元模式，這里再舉一個實體，比如接了我一個小型的外包專案，是做一個產品展示網站，后來他的朋友們也希望做這樣的網站，但要求都有些不同，我們當然不能直接復制粘貼再來一份，有任希望是新聞發布形式的，有人希望是博客形式的等等，而且因為經費原因不能每個網站租用一個空間，
其實這里他們需要的網站結構相似度很高，而且都不是高訪問量網站，如果分成多個虛擬空間來處理，相當于一個相同網站的實體物件很多，這是造成服務器的大量資源浪費，如果整合到一個網站中，共享其相關的代碼和資料，那么對于硬碟、記憶體、CPU、資料庫空間等服務器資源都可以達成共享，減少服務器資源；而對于代碼，由于是一份實體，維護和擴展都更加容易，
那么此時就可以用到享元模式了，UML圖如下：
1. 網站抽象類
1 public abstract class WebSite {
2
3 public abstract void use();
4
5 }
2. 具體網站類
1 public class ConcreteWebSite extends WebSite {
2
3 private String name = "";
4
5 public ConcreteWebSite(String name) {
6 this.name = name;
7 }
8
9 @Override
10 public void use() {
11 System.out.println("網站分類：" + name);
12 }
13
14 }
3. 網路工廠類
這里使用HashMap來作為池，通過put和get方法實作加入池與從池中取的操作，
1 public class WebSiteFactory {
2
3 private HashMap<String, ConcreteWebSite> pool = new HashMap<>();
4
5 //獲得網站分類
6 public WebSite getWebSiteCategory(String key) {
7 if(!pool.containsKey(key)) {
8 pool.put(key, new ConcreteWebSite(key));
9 }
10
11 return (WebSite)pool.get(key);
12 }
13
14 //獲得網站分類總數
15 public int getWebSiteCount() {
16 return pool.size();
17 }
18
19 }
4. Client客戶端
這里測驗用例給了兩種網站，原先我們需要做三個產品展示和三個博客的網站，也即需要六個網站類的實體，但其實它們本質上都是一樣的代碼，可以利用用戶ID號的不同，來區分不同的用戶，具體資料和模板可以不同，但代碼核心和資料庫卻是共享的，
1 public class Client {
2
3 public static void main(String[] args) {
4 WebSiteFactory factory = new WebSiteFactory();
5
6 WebSite fx = factory.getWebSiteCategory("產品展示");
7 fx.use();
8
9 WebSite fy = factory.getWebSiteCategory("產品展示");
10 fy.use();
11
12 WebSite fz = factory.getWebSiteCategory("產品展示");
13 fz.use();
14
15 WebSite fa = factory.getWebSiteCategory("博客");
16 fa.use();
17
18 WebSite fb = factory.getWebSiteCategory("博客");
19 fb.use();
20
21 WebSite fc = factory.getWebSiteCategory("博客");
22 fc.use();
23
24 System.out.println("網站分類總數為：" + factory.getWebSiteCount());
25 }
26
27 }
運行結果如下：
可以看出，雖然我們做了6個網站，但網站分類只有2個，這樣基本算是實作了享元模式的共享物件的目的，但想想上面提到的內部狀態和外部狀態，這里實際上沒有體現物件間的不同，只體現了它們的共享部分，
5. 用戶類
所以我們再加一個用戶類，作為網站類的外部狀態，并在use()方法中傳遞用戶物件，UML如下：
下面添加一個User類，
1 public class User {
2
3 private String name;
4
5 public User(String name) {
6 this.name = name;
7 }
8
9 public String getName() {
10 return name;
11 }
12
13 }
然后再對use()方法進行修改，添加引數，以抽象類為例： public abstract void use(User user);
而客戶端中只需對每一個網站添加一個用戶即可，如： fx.use(new User("adam"));
（具體內容可參考原始碼，原始碼地址見最下方）
運行結果如下：
這樣就可以協調內部與外部狀態，哪怕接手了上千個網站的需求，只要要求相同或類似，實際開發代碼也就是分類的哪幾種，
關注公眾號:java寶典
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/254301.html
標籤：Java
上一篇：JavaFx ObservableList的使用詳解
下一篇：JVM-虛擬機堆疊