设计模式 - 享元模式

介绍

享元模式是对对象池的一种实现，它的英文名称叫做Flyweight，代表轻量级的意思，享元模式用来尽可能减少内存使用量，它适合用于可能存在大量重复对象的场景，来缓存可共享的对象，达到对象共享、避免创建过多对象的效果，这样一来就可以提升性能、避免内存移除等。

享元对象中的部分状态是可以共享，可以共享的状态成为内部状态，内部状态不会随着环境变化；不可共享的状态称为外部状态，它们会随着环境的改变而改变。在享元模式中好建立一个对象的容器，在经典的享元模式中该容器为一个Map，它的键是享元对象的内部状态，它的值就是享元对象本身。客户端程序通过这个内部状态从享元工厂中获取享元单元，如果缓存则使用缓存对象，否则创建一个享元对象并且存入容器中，这样一来避免了创建过多对象的问题。

定义

使用共享对象可有效地支持大量的细粒度的对象

使用场景

• 系统中存在大量的相似对象
• 细粒度的对象都具有较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份
• 需要缓冲池场景

UML类图

角色介绍
Flyweight:享元对象抽象基类或接口

ConcreteFlyweight：具体的享元对象

FlyweightFactory:享元工厂，负责管理享元对象池和创建享元对象。

示例代码

Flyweight

public interface Credit {
    void showCredit();
}

ConcreteFlyweight

public class SubjectCredit implements Credit {
    private int credit;
    private String subject;

    public SubjectCredit(String subject) {
        this.credit = new Random().nextInt() % 3 + 1;
        this.subject = subject;
    }

    public int getCredit() {
        return credit;
    }

    public void setCredit(int credit) {
        this.credit = credit;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    @Override
    public void showCredit() {
        System.out.println(toString());
    }

    @Override
    public String toString() {
        return "SubjectCredit{" +
                "credit=" + credit +
                ", subject='" + subject + '\'' +
                '}';
    }
}

FlyweightFactory

public class CreditFactory {
    private static Map<String, Credit> creditMap = new HashMap<>();

    public static Credit getCredit(String subject) {
        if (creditMap.containsKey(subject)) {
            System.out.println("使用缓存 -> subject = [" + subject + "]");
            return creditMap.get(subject);
        } else {
            System.out.println("创建对象 -> subject = [" + subject + "]");
            Credit credit = new SubjectCredit(subject);
            creditMap.put(subject, credit);
            return credit;
        }
    }
}

Test

public class TestFlyweight {
    public static void main(String[] args) {
        Credit credit_0 = CreditFactory.getCredit("语文");
        Credit credit_1 = CreditFactory.getCredit("数学");
        Credit credit_2 = CreditFactory.getCredit("语文");
        Credit credit_3 = CreditFactory.getCredit("英语");
        Credit credit_4 = CreditFactory.getCredit("数学");

        credit_0.showCredit();
        System.out.println("------------------");
        credit_1.showCredit();
        System.out.println("------------------");
        credit_2.showCredit();
        System.out.println("------------------");
        credit_3.showCredit();
        System.out.println("------------------");
        credit_4.showCredit();
        System.out.println("------------------");

    }
}

Log打印

创建对象 -> subject = [语文]
创建对象 -> subject = [数学]
使用缓存 -> subject = [语文]
创建对象 -> subject = [英语]
使用缓存 -> subject = [数学]
SubjectCredit{credit=1, subject='语文'}
------------------
SubjectCredit{credit=3, subject='数学'}
------------------
SubjectCredit{credit=1, subject='语文'}
------------------
SubjectCredit{credit=1, subject='英语'}
------------------
SubjectCredit{credit=3, subject='数学'}
------------------

从输出结果可以看到，科目语文和数学在只有第一次查询的时，创建了一次对象，后续的查询都是用的缓存池中的对象，相当于一个对象的缓存，避免了对象的重复创建与回收，在一定程度上节省了内存的开支。在这个例子中，内部状态就是credit字段，内部状态是不发生改变的，而外部状态是subject，credit会随着subject的改变而改变。