享元模式

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

享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。

假设一个场景：有一盘围棋，有黑白二色旗子，对于任意一方来说，每一个棋子长得都是一样的，但是我们需要用位置来区分每个棋子。如果我们为每一个棋子创建一个对象，显然会创建大量的对象，这增加了大量的小对象，造成了对象管理的困难。所以我们引入了享元模式，把棋子共有的颜色等属性抽象出来，把棋子不共有的，如位置等，另外构成一个类。

FlyWeight接口

package top.bigking.flyWeight;

/**
 * @Author ABKing
 * @since 2020/2/25 下午10:12
 **/
public interface FlyWeight {
    void getColor();
    void getPosition(UnsharedConcreteFlyWeight position);
}

FlyWeight的实现类，ConcreteFlyWeight类，增加了内部状态（共有的）

package top.bigking.flyWeight;

/**
 * @Author ABKing
 * @since 2020/2/25 下午10:13
 * 内部状态 ConcreteFlyWeight
 **/
public class ConcreteFlyWeight implements FlyWeight {
    private String color;

    public ConcreteFlyWeight(String color) {
        this.color = color;
    }

    @Override
    public void getColor() {
        System.out.println("颜色是: " + color);
    }

    @Override
    public void getPosition(UnsharedConcreteFlyWeight position) {
        System.out.println("位置是: " + position);
    }


}

外部状态，UnsharedConcreteFlyWeight类

package top.bigking.flyWeight;

/**
 * @Author ABKing
 * @since 2020/2/25 下午10:14
 * 外部状态 UnsharedConcreteFlyWeight
 **/
public class UnsharedConcreteFlyWeight {
    private String x, y;

    public UnsharedConcreteFlyWeight(String x, String y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "x是" + x + ", y是" + y;
    }

    public String getX() {
        return x;
    }

    public void setX(String x) {
        this.x = x;
    }

    public String getY() {
        return y;
    }

    public void setY(String y) {
        this.y = y;
    }
}

享元模式通常与工厂模式结合起来使用，写一个FlyWeightFactory类

package top.bigking.flyWeight;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author ABKing
 * @since 2020/2/25 下午10:34
 **/
public class FlyWeightFactory {
    //享元池
    private static Map<String, FlyWeight> map = new HashMap<>();

    public static FlyWeight getFlyWeight(String color){
        FlyWeight flyWeight = map.get(color);
        if(flyWeight != null){//池中有对象
            return flyWeight;
        }else {//池中无对象
            FlyWeight fw = new ConcreteFlyWeight(color);
            map.put(color, fw);
            return fw;
        }
    }
}

JUnit单元测试：

package top.bigking.flyWeight;

import org.junit.Test;

/**
 * @Author ABKing
 * @since 2020/2/25 下午10:40
 **/
public class TestFlyWeight {
    @Test
    public void testFlyWeight(){
        FlyWeight flyWeight = FlyWeightFactory.getFlyWeight("黑色");
        FlyWeight flyWeight2 = FlyWeightFactory.getFlyWeight("黑色");
        System.out.println(flyWeight == flyWeight2);
        flyWeight.getColor();
        flyWeight2.getColor();
        flyWeight.getPosition(new UnsharedConcreteFlyWeight("10", "15"));
        flyWeight2.getPosition(new UnsharedConcreteFlyWeight("20", "20"));
    }
}

优点：

• 极大减少内存中对象的数量
• 相同或相似对象内存中只存一份，极大地节约资源，提高系统性能。
• 外部状态相对独立，不影响内部状态。

缺点：

• 模式较复杂，使程序逻辑复杂化
• 为了节省内存，共享了内部状态，分理出外部状态，而读取外部状态使运行时间边长。用时间换取了空间。
• 由于是共享同一个对象，所以后一个改变外部状态会影响前一个的外部状态。

享元模式开发应用中的场景：

享元模式由于其共享的特性，可以在任何池中操作，比如：线程池，数据库连接池

String类的设计也是享元模式