一、享元模式（Flyweight）

概念

** 一个系统中若存在大量相同或相似的对象，则只共享一份就可以了，不必为每份相同的东西还都单独实例化出一个对象，浪费性能。（有点缓存的意思） **

解释：比如26个英文字母，一个文本中有1MB的26个英文字母，那你解析出来的时候需要为每一个字母都创建一个对象的话，内存肯定扛不住。所以可以用享元模式，只创建26个对象进行共享就行了。

什么时候使用此模式？

• 一个应用程序使用了大量的对象。
• 完全由于使用大量的对象，造成很大的存储开销
• 对象的大多数状态都可变为外部状态
• 如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组成对象
• 应用程序不依赖对象标识

优点

大幅度地降低内存中对象的数量

缺点

1）享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。
2）享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

总的来说，享元模式一般是解决系统性能问题的，所以经常用于底层开发，在项目开发中并不常用。

各大角色的关系与说明

Paste_Image.png

1）抽象享元角色（Flyweight）：此角色是所有的具体享元类的超类，为这些类规定出需要实现的公共接口或抽象类。那些需要外部状态(External State)的操作可以通过方法的参数传入。抽象享元的接口使得享元变得可能，但是并不强制子类实行共享，因此并非所有的享元对象都是可以共享的。

2）具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定的接口。如果有内部状态的话，必须负责为内部状态提供存储空间。享元对象的内部状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享。有时候具体享元角色又叫做单纯具体享元角色，因为复合享元角色是由单纯具体享元角色通过复合而成的。

3） 复合享元(UnsharableFlyweight)角色：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。这个角色一般很少使用。

4）享元工厂(FlyweightFactoiy)角色：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象请求一个享元对象的时候，享元工厂角色需要检查系统中是否已经有一个符合要求的享元对象，如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个新的合适的享元对象。

5）客户端(Client)角色：本角色还需要自行存储所有享元对象的外部状态。

内部状态与外部状态：在享元对象内部并且不会随着环境改变而改变的共享部分，可以称之为享元对象的内部状态，反之随着环境改变而改变的，不可共享的状态称之为外部状态。

Demo

package com.designmodel.flyweight;

/**
 * User
 * @author [email protected]
 * @date 2017年3月6日
 */
public class User {
    
    private String userName;
    private String pwd;
    
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

package com.designmodel.flyweight;

/**
 * 抽象享元角色
 * @author [email protected]
 * @date 2017年3月6日
 */
public abstract class FlyWeight {
    
    protected String type;

    public FlyWeight(String type) {
        super();
        this.type = type;
    }

    public String getType() {
        return type;
    }
    
    public abstract void use(User user);
    
}

package com.designmodel.flyweight;

/**
 * 具体享元(ConcreteFlyweight)角色
 * @author [email protected]
 * @date 2017年3月6日
 */
public class ConcreteFlyweight extends FlyWeight {

    public ConcreteFlyweight(String type) {
        super(type);
    }

    @Override
    public void use(User user) {
        System.out.println("The web site's type is: " + type);
        System.out.println("User: " + user.getUserName());
        System.out.println("Passwd: " + user.getPwd());
        System.out.println();
    }

}

package com.designmodel.flyweight;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 享元工厂(FlyweightFactoiy)角色
 * @author [email protected]
 * @date 2017年3月6日
 */
public class FlyWeightFactory {
    
    private static final Map FACTORY = new ConcurrentHashMap();
    
    private FlyWeightFactory() {
        
    }
    
    public static FlyWeight createFlyWeight(String type) {
        FlyWeight flyWeight = FACTORY.get(type);
        if(null == flyWeight) {
            flyWeight = new ConcreteFlyweight(type);
            FACTORY.put(type, flyWeight);
        }
        return flyWeight;
    }
    
    public static int webSitesCounts() {
        return FACTORY.size();
    }
}

package com.designmodel.flyweight;

import org.junit.Test;

/**
 * 测试类
 * @author [email protected]
 * @date 2017年3月6日
 */
public class FlyWeightTest {

    @Test
    public void test() {
        
        FlyWeight flyWeight = FlyWeightFactory.createFlyWeight("test1");
        User user = new User();
        user.setUserName("user1");
        user.setPwd("pwd1");
        flyWeight.use(user);
        
        FlyWeight flyWeight2 = FlyWeightFactory.createFlyWeight("test1");
        User user2 = new User();
        user2.setUserName("user2");
        user2.setPwd("pwd2");
        flyWeight2.use(user2);
        
        FlyWeight flyWeight3 = FlyWeightFactory.createFlyWeight("test2");
        User user3 = new User();
        user3.setUserName("user3");
        user3.setPwd("pwd3");
        flyWeight3.use(user3);
        
        FlyWeight flyWeight4 = FlyWeightFactory.createFlyWeight("test2");
        User user4 = new User();
        user4.setUserName("user4");
        user4.setPwd("pwd4");
        flyWeight4.use(user4);
        
        System.out.println(FlyWeightFactory.webSitesCounts()); //2
    }
}

可以发现，本来需要四个对象，运用享元模式后，只用了两个对象。减少了一半。建议在大量对象的时候使用。

JDK中的享元模式

Integer、Lang、Byte、String等都用到了享元模式

前三者中的valueOf()方法用到了享元模式，String常量池就是享元模式。

测试代码如下：

/*（1）*/
String str1 = "str";
String str2 = "str";
System.out.println(str1 == str2); //true

/*（2）*/
Integer num = 127;
Integer num2 = 127;
System.out.println(num == num2); //true
    
/*（3）*/ 
Integer num3 = 128;
Integer num4 = 128;
System.out.println(num3 == num4);  //false
    
/*（4）*/ 
Integer num5 = Integer.valueOf(127);
Integer num6 = Integer.valueOf(127);
System.out.println(num5 == num6);  //true
    
/*（5）*/ 
Integer num7 = Integer.valueOf(128);
Integer num8 = Integer.valueOf(128);
System.out.println(num7 == num8);  //false

/*（6）*/     
Integer num9 = Integer.valueOf(127);
Integer num10 = 127;
System.out.println(num9 == num10);  //true
    
/*（7）*/ 
Integer num11 = Integer.valueOf(128);
Integer num12 = 128;
System.out.println(num11 == num12);  //false

解释：
（1）String的常量池即用到了享元模式，所以为true。他首先检查常量池中是否有str这个值，若有则直接指向，不会重新创建String对象。（共享）
（2）（3）（4）（5）（6）（7）是因为Integer（Long、Byte等）内部维护着一个Cache，用于共享。拿Integer举例如下：

static final int low = -128;
static final int high = 127;
 public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

可发现，若值在-128~127之间，是可以直接从Cache中获取的，好比String常量池，直接从池中获取，无需new。若不再这范围内，才会去new返回新对象。否则共享。

若有兴趣，欢迎来加入群，【Java初学者学习交流群】：458430385，此群有Java开发人员、UI设计人员和前端工程师。有问必答，共同探讨学习，一起进步！
欢迎关注我的微信公众号【Java码农社区】，会定时推送各种干货：

qrcode_for_gh_577b64e73701_258.jpg