九、享元设计模式

9.1 享元设计模式简介

9.1.1 享元设计模式概述

享元模式（Flyweight Pattern）：享元模式主要的任务就是减少对象创建的数量，其宗旨是共享细粒度的对象，将多个对同一对象的访问集中起来，不必为每一个访问者都创建一个单独的对象，以减少内存占用和提高性能。

Tips：享元的本质就是缓存共享对象，降低内存消耗；

享元模式在我们生活中非常常见，我们举几个例子：

• 1）如各大搜索引擎的资源共享，我们在CSDN、简书等社交平台发布的一篇文章在百度、360等网站都能搜索到；
• 2）各大中介机构的房源信息，房子只有一套，但是各大房源搜索平台都能搜索到；
• 3）公司的招聘信息，招聘岗位只有一个，但是很多公司会在很多招聘网上都发布；
• 4）各大旅游网站的卖票程序，在某一时间点的某张票只有一张，但是在很多旅游网站都能查询购买；

享元模式其实是工厂模式的一个改进机制，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法模板生成的对象，只不过享元模式对工厂模式进行了改进，将重点放在了如何共享多个对象的访问，而不是重点考虑如何创建对象；

如何共享多个对象的访问成为了享元设计模式的实现目标，我们之前学过的线程池、连接池等其实就是享元设计模式很好的实现方案；

9.1.2 享元设计模式中的角色

在响应模式中，包含有如下3个角色：

• 1）抽象享元角色（Flyweight）：享元角色的抽象基类或者接口
• 2）具体享元角色（ConcreteFlyweight）：实现抽象享元角色定义的业务
• 3）享元工厂（FlyweightFactory）：负责管理享元对象和创建享元对象

9.2 享元设计模式的实现

我们在买票过程中，首先要根据一些信息查询票，假设一张火车票包含出发站、目的站等信息，用户根据这些信息就可以查询到自己想要的票；

• ITicket接口（抽象享元角色）：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface ITicket {
    void show();
}
1
2
3
4
5
6
7
8
9
10

• ITicket的实现（具体享元角色）：

package com.pattern.demo01;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Ticket implements ITicket {
    private String from;
    private String to;

    @Override
    public void show() {
        System.out.println(String.format("这是一张【%s】开往【%s】的火车票", from, to));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• ITicketFactory（享元工厂）：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class TicketFactory {
    public static ITicket getTicket(String from, String to) {
        return new Ticket(from, to);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

• 测试代码：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        ITicket ticket = TicketFactory.getTicket("长沙", "南昌");
        ticket.show();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在上述案例中，当客户端进行查询时，系统通过享元工厂直接创建一个火车票对象将其返回。当某个瞬间如果有大量用户查询同一张票时，系统就会创建出大量该火车票对象，内存压力剧增；我们的做法应该是不管用户查询多少次，只返回一个对象，这样下来内存压力就会减少很多；我们使用享元模式就可以很好的解决这个问题，我们在享元工厂中添加缓存机制即可；

• 修改TicketFactory类：

package com.pattern.demo01;

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

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class TicketFactory {

    private static Map<String, ITicket> ticketPool = new HashMap<>();

    public static ITicket getTicket(String from, String to) {
        String key = from + "-" + to;

        if (ticketPool.containsKey(key)) {
            System.out.println("查询缓存中的: ");
            return ticketPool.get(key);
        }

        System.out.println("第一次查询: ");
        Ticket ticket = new Ticket(from, to);
        ticketPool.put(key, ticket);

        return ticket;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

• 测试代码：

package com.pattern.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        ITicket ticket = TicketFactory.getTicket("长沙", "南昌");
        ticket.show();
        ITicket ticket1 = TicketFactory.getTicket("长沙", "南昌");
        ticket1.show();
        ITicket ticket2 = TicketFactory.getTicket("长沙", "南昌");
        ticket2.show();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行效果：

9.3 享元模式中的状态

9.3.1 内部状态与外部状态

享元模式的核心就是对象的共享，所以不可避免的会使对象数量多且性质相近。因此享元模式将对象的信息（成员变量等）分为了两个状态：内部状态和外部状态；

• 内部状态：存储在享元对象内部且不会随着环境的改变而改变的共享信息部分，称为内部状态
• 外部状态：而随环境改变而改变的、不可以共享的那部分信息状态就是外部状态；

享元模式可以避免大量非常相似类的开销。在程序设计中有时需要大量细粒度的类实例来表示数据，如果能发现这些实例除了几个参数外基本上都是相同的，那么我们可以把那些参数移动到类实例的外面，在方法调用时将它们传递进来。这样下来就可以通过共享，来大幅度地减少单个实例的数目；

9.3.2 使用外部状态

享元模式Flyweight执行时所需的状态（数据）有可能是内部的，也有可能是外部的，内部状态存储于具体享元角色之中，而外部状态的数据则应该交给客户端对象存储或计算。当调用Flyweight对象时，将状态数据传递给它；

例如在上述【买票案例】中，用户查询票时需要显示是哪个用户查询的票；我们不可能将用户的信息定位为对象的内部状态，因为任何用户都可以查询任何的票，因此用户信息应该是由客户端传递进来，应该将其定位为外部数据（外部状态）；

• 定义User类：

package com.pattern.demo02_内部状态和外部状态;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
public class User {
    private String username;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 修改ITicket：

package com.pattern.demo02_内部状态和外部状态;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface ITicket {
    void show(User user);
}
1
2
3
4
5
6
7
8
9
10

• Ticket：

package com.pattern.demo02_内部状态和外部状态;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Ticket implements ITicket {
    private String from;
    private String to;

    @Override
    public void show(User user) {
        System.out.println(String.format("来自【%s】的查询", user.getUsername()));
        System.out.println(String.format("这是一张【%s】开往【%s】的火车票", from, to));
        System.out.println("-----------------");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

• 测试代码：

package com.pattern.demo02_内部状态和外部状态;


/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        ITicket ticket = TicketFactory.getTicket("长沙", "南昌");
        ticket.show(new User("张三"));
        ITicket ticket1 = TicketFactory.getTicket("长沙", "南昌");
        ticket1.show(new User("李四"));
        ITicket ticket2 = TicketFactory.getTicket("长沙", "南昌");
        ticket2.show(new User("张三"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行效果：

9.4 享元模式的优缺点

• 优点：
  • 1）减少对象的创建，降低内存中的对象数量，降低系统内存的消耗
• 缺点：
  • 1）享元模式中的数据状态分为内部和外部状态，当多线程时，需要关注线程安全问题