java 享元模式以及代码实现

转自：https://www.cnblogs.com/adamjwh/p/9070107.html

作者：JAdam 

这也是一种重要的设计模式~

本文重点内容标红。附带了一些别的理解。

本文转载参考文章在文底部，其实本人写的东西都是for meet以及增长自己的知识。

前言：

今天的歌词分享：

一定要计较输赢

啦爱玩才会赢

啦谁人倘跟我拼

啦你问我叫啥米名

啦叫我第一名

                                                                                                                                                    —— Mayday《叫我第一名》

                                                                                                                                                                       love jh

1. 享元模式是什么？

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。

说到享元模式，第一个想到的应该就是池技术了，String常量池、数据库连接池、缓冲池等等都是享元模式的应用，所以说享元模式是池技术的重要实现方式。

　　比如我们每次创建字符串对象时，都需要创建一个新的字符串对象的话，内存开销会很大，所以如果第一次创建了字符串对象“adam“，下次再创建相同的字符串”adam“时，只是把它的引用指向”adam“，这样就实现了”adam“字符串再内存中的共享。

　　举个最简单的例子，网络联机下棋的时候，一台服务器连接了多个客户端（玩家），如果我们每个棋子都要创建对象，那一盘棋可能就有上百个对象产生，玩家多点的话，因为内存空间有限，一台服务器就难以支持了，所以这里要使用享元模式，将棋子对象减少到几个实例。下面给出享元模式的定义。

　　享元模式（Flyweight），运用共享技术有效地支持大量细粒度的对象。UML结构图如下：

 　　其中，Flyweight是抽象享元角色。它是产品的抽象类，同时定义出对象的外部状态和内部状态（外部状态及内部状态相关内容见后方）的接口或实现；ConcreteFlyweight是具体享元角色，是具体的产品类，实现抽象角色定义的业务；UnsharedConcreteFlyweight是不可共享的享元角色，一般不会出现在享元工厂中；FlyweightFactory是享元工厂，它用于构造一个池容器，同时提供从池中获得对象的方法。

其实总结而言，就是有一个抽象的享元角色，然后有一个对外的具体的享元角色。然后还有它内部私有的行为。

然后享元工厂就相当于池容器，通过享元工厂来获取对象，最终达到的思想就是能够节省共享的对象的创建。

1.1 字符串在内存中是共享的么？

有两种。

String a = "a"；

String b= "a"；

那么，这个第一段代码执行的时候就在常量池中创建了一个a,后面这个第二句执行的时候，因为常量池里面有了a，所以不再创建String对象了。

此时字符串的引用存在虚拟机栈立面.

2. 具体代码实现

2.1 Flyweight抽象类

public abstract class Flyweight {

    //内部状态
    public String intrinsic;
    //外部状态
    protected final String extrinsic;
    
    //要求享元角色必须接受外部状态
    public Flyweight(String extrinsic) {
        this.extrinsic = extrinsic;
    }
    
    //定义业务操作
    public abstract void operate(int extrinsic);

    public String getIntrinsic() {
        return intrinsic;
    }

    public void setIntrinsic(String intrinsic) {
        this.intrinsic = intrinsic;
    }

}

注意这边有对象的外部状态和内部状态。享元角色必须接受外部状态。

2.1.1 抽象类与接口的区别？

温习一下知识。毕竟面试经常问。注意这是java8的内容，相同与不同。

相同点：

1）都是抽象类型；

2）都可以有实现方法（以前接口不行）；

3）都可以不需要实现类或者继承者去实现所有方法，（这边提到的是JAVA8的default的方法）

不同点：

1）抽象类不可以多重继承，接口可以（无论是多重类型继承还是多重行为继承）；

2）抽象类和接口所反映出的设计理念不同。其实抽象类表示的是"is-a"关系，接口表示的是"like-a"关系；

3）接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值；抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

2.2   ConcreteFlyweight类（继承接口或者抽象类的类）

　继承Flyweight超类或实现Flyweight接口，并为其内部状态增加存储空间。

public class ConcreteFlyweight extends Flyweight {

    //接受外部状态
    public ConcreteFlyweight(String extrinsic) {
        super(extrinsic);
    }

    //根据外部状态进行逻辑处理
    @Override
    public void operate(int extrinsic) {
        System.out.println("具体Flyweight:" + extrinsic);
    }

}

2.3 UnsharedConcreteFlyweight类（不需要共享的子类）

　指那些不需要共享的Flyweight子类。

public class UnsharedConcreteFlyweight extends Flyweight {

    public UnsharedConcreteFlyweight(String extrinsic) {
        super(extrinsic);
    }

    @Override
    public void operate(int extrinsic) {
        System.out.println("不共享的具体Flyweight:" + extrinsic);
    }

}

2.4 FlyweightFactory类

一个享元工厂，用来创建并管理Flyweight对象，主要是用来确保合理地共享Flyweight，当用户请求一个Flyweight时，FlyweightFactory对象提供一个已创建的实例或创建一个实例。

public class FlyweightFactory {

    //定义一个池容器
    private static HashMap pool = new HashMap<>();
    
    //享元工厂
    public static Flyweight getFlyweight(String extrinsic) {
        Flyweight flyweight = null;
        
        if(pool.containsKey(extrinsic)) {    //池中有该对象
            flyweight = pool.get(extrinsic);
            System.out.print("已有 " + extrinsic + " 直接从池中取---->");
        } else {
            //根据外部状态创建享元对象
            flyweight = new ConcreteFlyweight(extrinsic);
            //放入池中
            pool.put(extrinsic, flyweight);
            System.out.print("创建 " + extrinsic + " 并从池中取出---->");
        }
        
        return flyweight;
    }
}

所以，享元模式的思想就是，如果已有，那么我这个管理池就不要再创建了，提供一个已创建的实例。

如果没有，那么创建一个实例。

这边池容器用的是HashMap。

如果包含了外部状态的KEY，那么就取出来。如果没有创建。

2.5 Client客户端

public class Client {

    public static void main(String[] args) {
        int extrinsic = 22;
        
        Flyweight flyweightX = FlyweightFactory.getFlyweight("X");
        flyweightX.operate(++ extrinsic);
        
        Flyweight flyweightY = FlyweightFactory.getFlyweight("Y");
        flyweightY.operate(++ extrinsic);
        
        Flyweight flyweightZ = FlyweightFactory.getFlyweight("Z");
        flyweightZ.operate(++ extrinsic);
        
        Flyweight flyweightReX = FlyweightFactory.getFlyweight("X");
        flyweightReX.operate(++ extrinsic);
        
        Flyweight unsharedFlyweight = new UnsharedConcreteFlyweight("X");
        unsharedFlyweight.operate(++ extrinsic);
    }
    
}

个人感觉，原博主这部分写的并不是很好。（emm指的这部分模板）

但是思想在这边，所以还是说看具体需求。

3. 内部状态和外部状态

上面享元模式的定义为我们提出了两个要求：细粒度和共享对象。我们知道分配太多的对象到应用程序中将有损程序的性能，同时还容易造成内存溢出，要避免这种情况，用到的就是共享技术，这里就需要提到内部状态和外部状态了。

　　因为要求细粒度对象，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。

　　内部状态指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变；外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。（那么也就是外部状态是因环境变化而变化的）

　　我们举一个最简单的例子，棋牌类游戏大家都有玩过吧，比如说说围棋和跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋颜色略多一点，但也是不太变化的，所以棋子颜色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同，我们落子嘛，落子颜色是定的，但位置是变化的，所以方位坐标就是棋子的外部状态。

　　那么为什么这里要用享元模式呢？可以想象一下，上面提到的棋类游戏的例子，比如围棋，理论上有361个空位可以放棋子，常规情况下每盘棋都有可能有两三百个棋子对象产生，因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏，如果用享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解决了对象的开销问题。

 

4. 享元模式的应用

　4.1 何时使用

• 系统中有大量对象时
• 这些对象消耗大量内存时
• 这些对象的状态大部分可以外部化时（就是不用内部的状态，比如下棋都用内部的状态就是会不停的创建对象然后占用资源，外部化的话就可以把一些固定的不太变得内部状态作为内部的享元模式实现）

   4.2 方法

• 用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象，用HashMap/HashTable存储

   4.3. 优点

• 大大减少了对象的创建，降低了程序内存的占用，提高效率

   4.4 缺点

• 提高了系统的复杂度。需要分离出内部状态和外部状态，而外部状态具有固化特性，不应该随着内部状态的改变而改变

   4.5 使用场景

• 系统中存在大量相似对象
• 需要缓冲池的场景

   4.6 应用实例

• String常量池
• 数据库连接池
• 当我们项目中创建很多对象，而且这些对象存在许多相同模块，这时，我们可以将这些相同的模块提取出来采用享元模式生成单一对象，再使用这个对象与之前的诸多对象进行配合使用，这样无疑会节省很多空间。但是这么一看享元模式就有点点像别的设计模式，但是也不太一样，享元的抽离也很需要在意内部状态和外部状态，还需要看线程的问题。

   4.7 注意事项

• 注意划分内部状态和外部状态，否则可能会引起线程安全问题
• 这些类必须有一个工厂类加以控制

5.  享元模式的实现

为了更好的理解享元模式，这里再举一个实例，比如接了我一个小型的外包项目，是做一个产品展示网站，后来他的朋友们也希望做这样的网站，但要求都有些不同，我们当然不能直接复制粘贴再来一份，希望是新闻发布形式的，有人希望是博客形式的等等，而且因为经费原因不能每个网站租用一个空间。

　　其实这里他们需要的网站结构相似度很高，而且都不是高访问量网站，如果分成多个虚拟空间来处理，相当于一个相同网站的实例对象很多，这是造成服务器的大量资源浪费。如果整合到一个网站中，共享其相关的代码和数据，那么对于硬盘、内存、CPU、数据库空间等服务器资源都可以达成共享，减少服务器资源；而对于代码，由于是一份实例，维护和扩展都更加容易。

（为了更大化的利用资源）

　　那么此时就可以用到享元模式了。UML图如下：

　　5.1 网站抽象类

public abstract class WebSite {

   public abstract void use();
     
}

　　5.2 具体网站类

public class ConcreteWebSite extends WebSite {

    private String name = "";
    
    public ConcreteWebSite(String name) {
        this.name = name;
    }
    
    @Override
    public void use() {
        System.out.println("网站分类：" + name);
    }
    
}

 

 　　5.3 网络工厂类

　　这里使用HashMap来作为池，通过put和get方法实现加入池与从池中取的操作。

public class WebSiteFactory {

    private HashMap pool = new HashMap<>();
    
    //获得网站分类
    public WebSite getWebSiteCategory(String key) {
        if(!pool.containsKey(key)) {
            pool.put(key, new ConcreteWebSite(key));
        }
        
        return (WebSite)pool.get(key);
    }
    
    //获得网站分类总数
    public int getWebSiteCount() {
        return pool.size();
    }
    
}

 

　     5.4 Client客户端

　　这里测试用例给了两种网站，原先我们需要做三个产品展示和三个博客的网站，也即需要六个网站类的实例，但其实它们本质上都是一样的代码，可以利用用户ID号的不同，来区分不同的用户，具体数据和模板可以不同，但代码核心和数据库却是共享的。

public class Client {

    public static void main(String[] args) {
        WebSiteFactory factory = new WebSiteFactory();
        
        WebSite fx = factory.getWebSiteCategory("产品展示");
        fx.use();
        
        WebSite fy = factory.getWebSiteCategory("产品展示");
        fy.use();
        
        WebSite fz = factory.getWebSiteCategory("产品展示");
        fz.use();
        
        WebSite fa = factory.getWebSiteCategory("博客");
        fa.use();
        
        WebSite fb = factory.getWebSiteCategory("博客");
        fb.use();
        
        WebSite fc = factory.getWebSiteCategory("博客");
        fc.use();
        
        System.out.println("网站分类总数为：" + factory.getWebSiteCount());
    }
    
}

 　　运行结果如下：

　　

　　可以看出，虽然我们做了6个网站，但网站分类只有2个。这样基本算是实现了享元模式的共享对象的目的，但想想上面提到的内部状态和外部状态，这里实际上没有体现对象间的不同，只体现了它们的共享部分。

　　5. 用户类

　　所以我们再加一个用户类，作为网站类的外部状态，并在use()方法中传递用户对象，UML如下：

　　下面添加一个User类。

public class User {

    private String name;

    public User(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
}

 

　　然后再对use()方法进行修改，添加参数，以抽象类为例： public abstract void use(User user); 

　　而客户端中只需对每一个网站添加一个用户即可，如： fx.use(new User("adam")); 

　　（具体内容可参考源码，源码地址见最下方）

　　运行结果如下：

　　

　　这样就可以协调内部与外部状态，哪怕接手了上千个网站的需求，只要要求相同或类似，实际开发代码也就是分类的哪几种。

　　源码地址：https://gitee.com/adamjiangwh/GoF