【设计模式】享元模式

享元模式属于结构型设计模式

核心思想是通过共享技术，实现相似对象的高效复用。用 1%的资源支撑100%的需求------通过对象状态的分离与共享，用最小内存支持海量对象

内部状态：对象中不变的部分共享

外部状态：对象中变化的部分非共享

适用场景

系统中存在大量相似或相同的对象
对象创建/销毁成本较高
对象状态可以外部变化，即对象状态独立于对象本身存在。

核心组件

享元接口：定义外部状态的方法，规定可以共享的状态
实现类：实现类，存储内部状态，实现具体业务逻辑
享元工厂：用于对象池的管理，控制对象的创建和复用

类图

java 复制代码

//抽象 享元类
public abstract class AbstractBikeFlyWeight {

    private String color;

    private int price;

    public AbstractBikeFlyWeight(String color, int price) {
        this.color = color;
        this.price = price;
    }
    
    
    public abstract String show();

}
//实现类
public class OneBike extends AbstractBikeFlyWeight {
    

    public OneBike(String color, int price) {
        super(color, price);
    }

    @Override
    public String show() {
        return "one bike color: " + color + " price: " + price;
    }
}

public class TwoBike extends AbstractBikeFlyWeight {

    public TwoBike(String color, int price) {
        super(color, price);
    }

    @Override
    public String show() {
        return "two bike color: " + color + " price: " + price;
    }
}

//工厂
public class Factory {

    private static Map<String,AbstractBikeFlyWeight> bikeMapping = new HashMap<>();

    public static AbstractBikeFlyWeight getBike(String color, String type) {
        String key = color + type;

        if (bikeMapping.containsKey(key)) {
            return bikeMapping.get(key);
        }else  {
            AbstractBikeFlyWeight bike;
            switch (color) {
                case "one":
                    bike = new OneBike();
                    break;
                case "two":
                    bike = new TwoBike();
                    break;
                default:
                    throw new IllegalArgumentException("Invalid color: " + color);
            }
            bike.setColor(color);
            bike.setType(type);
            return bike;
        }

    }

}

模式的优点缺点

优点

内存优化：可以减少对象的存储
性能提升：降低GC压力，提高缓存命中率
资源复用：避免重复资源的浪费

缺点

增加系统的复杂性：需要区分可共享和不可共享的逻辑
需要考虑线程安全的场景

总结

当系统面临对象数量爆炸性增长，占用内存过大的情况，可以考虑是否使用享元模式。同时还要确认对象是否存在可复用的逻辑以及多少状态可以在外部传递进行处理。