模式说明

某些对象相似度很高，只有少量字段或方法不同，当需要大量这类对象时，若为每一次需求都创建实例，内存开销会很大。此时可以提炼出这些对象的相同部分，作为所谓的享元，创建一个享元工厂类，持有享元实例。需要使用上述对象时，从享元工厂中获取该实例。若这些对象有不同部分，提取这些不同部分单独成类，使用时作为享元中的方法参数传入享元(使相同和不同部分结合)。这样无论使用多少次，对于享元而言，只有一个实例的开销。

本示例以网站为抽象享元，博客网站和电子商务网站为具体享元，用户为外部非享元。展示如何通过享元工厂类添加和获取享元，如何将非享元作为享元方法的参数传入到享元内。

结构

抽象享元类
被使用对象中提炼出的相同内容的集合，定义享元的抽象方法。
具体享元类
继承抽象享元类，实现抽象方法。
非享元类
需要使用但不能被提炼为享元内容的部分，单独成类，需要时传入享元。
享元工厂类
持有具体享元实例，有添加享元和获取享元的方法。

代码演示

  1. package com.yukiyama.pattern.structure;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. /**
  7.  * 享元模式
  8.  */
  9. public class FlyweightDemo {
  11.     public static void main(String[] args) {
  12.         // 声明享元工厂
  13.         WebsiteFactory fa = new WebsiteFactory();
  14.         // 声明具体享元博客网站和电子商务网站
  15.         Website blog = new BlogWebsite("Blog");
  16.         Website ec = new BlogWebsite("EC");
  17.         // 向享元工厂中添加如上两种享元
  18.         fa.addFlyweight(blog);
  19.         fa.addFlyweight(ec);
  20.         // 通过享元工厂，创建两个博客网站和两个电子商务网站
  21.         Website blog1 = fa.getFlyweight("Blog");
  22.         Website blog2 = fa.getFlyweight("Blog");
  23.         Website ec1 = fa.getFlyweight("EC");
  24.         Website ec2 = fa.getFlyweight("EC");
  25.         // 将两个博客网站和两个电子商务网站分给不同的使用者
  26.         blog1.use(new User("莫小言"));
  27.         blog2.use(new User("金大庸"));
  28.         ec1.use(new User("马风"));
  29.         ec2.use(new User("刘强西"));
  30.         // 如下均输出“true”，即通过享元工厂获取的多个享元以及
  31.         // 工厂内持有的享元均为同一个。
  32.         System.out.println(blog == blog1 && blog1 == blog2);
  33.         System.out.println(ec == ec1 && ec1 == ec2);
  34.     }
  36. }
  38. /**
  39.  * 享元工厂类
  40.  * 以Map数据结构持有享元，key为网站类型，value为Website实例。
  41.  * 实现添加享元，获取享元的方法。
  42.  * 客户端声明享元工厂后，需要继续创建享元并将其添加进享元工厂中。
  43.  */
  44. class WebsiteFactory{
  45.     private Map<String, Website> flyweights = new HashMap<>();
  47.     public void addFlyweight(Website web) {
  48.         if(!flyweights.containsKey(web.getCatagory())) {
  49.             flyweights.put(web.getCatagory(), web);
  50.         } else {
  51.             System.out.println("已存在该享元。");
  52.         }
  53.     }
  55.     public Website getFlyweight(String key) {
  56.         if(!flyweights.containsKey(key)) {
  57.             System.out.println("无此享元。");
  58.             return null;
  59.         } else {
  60.             return flyweights.get(key);
  61.         }
  62.     }
  64. }
  66. /**
  67.  * 享元抽象类
  68.  * 声明享元的字段和相关方法。
  69.  */
  70. abstract class Website{
  71.     private String catagory;
  73.     public Website(String catagory) {
  74.         this.catagory = catagory;
  75.     }
  76.     public String getCatagory() {
  77.         return catagory;
  78.     }
  79.     public abstract void use(User user);
  80. }
  82. /**
  83.  * 具体享元类
  84.  * 继承享元抽象类，实现抽象方法。
  85.  * 如下是博客网站类。
  86.  */
  87. class BlogWebsite extends Website{
  88.     public BlogWebsite(String catagory) {
  89.         super(catagory);
  90.     }
  91.     @Override
  92.     public void use(User user) {
  93.         System.out.printf("这是一个%s网站，提供文章发布服务。\n", getCatagory());
  94.         System.out.printf("网站用户为%s。\n", user.getUser());
  95.     }
  96. }
  98. /**
  99.  * 具体享元类
  100.  * 如下是电子商务网站类。
  101.  */
  102. class ECWebsite extends Website{
  103.     public ECWebsite(String catagory) {
  104.         super(catagory);
  105.     }
  106.     @Override
  107.     public void use(User user) {
  108.         System.out.printf("这是一个%s网站，提供商品发布服务。\n", getCatagory());
  109.         System.out.printf("网站用户为%s。\n", user.getUser());
  110.     }
  111. }
  113. /**
  114.  * 非享元类
  115.  * 享元Website需要结合非享元User使用，例如对博客网站来说，他们可能共用
  116.  * 相同的文章编辑器控件(作为享元的一部分)，但各自使用的用户不同(非享元)。
  117.  */
  118. class User{
  119.     private String user;
  121.     public User(String user) {
  122.         this.user = user;
  123.     }
  124.     public String getUser() {
  125.         return user;
  126.     }
  127. }