前两天已经把 Redis 重新整理好了,一两天就可以发布出来啦~ 今天先继续看一下一个简单的设计模式
今天一起来看一个新的设计模式,那就是享元模式,关于此模式,常见的就是 “项目外包”、 以及 “五子棋” 这样两个例子,我们下面就选择使用 “项目外包” 这个例子引入去讲
程序员小B,帮助客户 A 做了一个展示一些产品内容的网站,通过 A 的 推荐,客户 B 、客户C 也想要做这样一个网站,但是就是形式有一些变化
而且他们都希望能够降低一些费用,但是每一个空间部署着一个网站,所以租借空间的费用是固定的,同时程序员小B 并不想从自己的劳动报酬中缩减费用
先说最简单能想到的方案,直接把网站代码复制几份,然后每一个都租借一个空间,然后对代码进行定制修改。注:这里还没考虑优化或者省钱
我们用一个 WebSite 类来模拟一个网站的模板,所有类型可以通过对 name 赋值然后调用 use 方法进行修改
public class WebSite {
private String name = "";
public WebSite(String name) {
this.name = name;
}
public void use(){
System.out.println("当前网站分类: " + name);
}
}
如果按照刚才的思路,是这样操作的
public class Test {
public static void main(String[] args) {
WebSite webSite1 = new WebSite("博客");
webSite1.use();
WebSite webSite2 = new WebSite("博客");
webSite2.use();
WebSite webSite3 = new WebSite("博客");
webSite3.use();
WebSite webSite4 = new WebSite("新闻发布");
webSite4.use();
WebSite webSite5 = new WebSite("公众号");
webSite5.use();
WebSite webSite6 = new WebSite("公众号");
webSite6.use();
}
}
运行结果:
当前网站分类: 博客 当前网站分类: 博客 当前网站分类: 博客 当前网站分类: 新闻发布 当前网站分类: 公众号 当前网站分类: 公众号
对于这种重复性很高的内容,首先我们要做到将其抽象出来,重复创建实例在设计模式中肯定是不太明智的,我们想要做到多个客户,共享同一个实例。这样不管是代码还是服务器资源利用,都会改善很多
一个不算特别恰当的例子:例如外卖平台中的一个一个商家店铺,是不是可以理解为平台中的一个小店铺,小网站,其中通过例如店铺 ID 等内容来区分不同店铺,但是其每一家店铺整体的模板和样子是差不多的。
我们下面要做的就是,将大量相似内容抽象成一个网站模板类,然后把一些特定的内容,通过参数移到实例的外面,调用的时候再指定,这样可以大幅度减少单个实例的数目。
创建一个抽象的 WebSite 类
public abstract class WebSite {
public abstract void use();
}
接下来是具体实现,创建其子类,和前面一样,所有类型可以通过对 type赋值然后调用 use 方法进行修改
public class ConcreteWebSite extends WebSite {
// 网站发布形式
private String type = "";
public ConcreteWebSite(String type) {
this.type = type;
}
@Override
public void use() {
System.out.println("当前网站分类: " + type);
}
}
创建一个工厂类,用于创建,返回一个指定的网站实例
这一个类,首先用一个 HashMap 模拟一种连接池的概念,因为我们既然想要达到不重复创建实例的效果,就需要通过一些逻辑判断,判断 Map 中是否存在这个实例,如果有就直接返回,如果没有就创建一个新的,同样类型 type 是在调用时,显式的指定的。
后面补充了一个获取网站分类总数的方法,用来测试的时候,看一下是不是没有重复创建实例
import java.util.HashMap;
/**
* 网站工厂类,根据需要返回
*/
public class WebSiteFactory {
// 模拟一个连接池
private HashMap<String, ConcreteWebSite> pool = new HashMap<>();
/**
* 获取网站:根据传入的类型,返回网站,无则创建,有则直接返回
*
* @param type
* @return
*/
public WebSite getWebSiteCategory(String type) {
if (!pool.containsKey(type)) {
// 创建一个网站,放到池种
pool.put(type, new ConcreteWebSite(type));
}
return (WebSite) pool.get(type);
}
/**
* 获取网站分类总数
*/
public int getWebSiteCount() {
return pool.size();
}
}
测试一下
public class Test {
public static void main(String[] args) {
// 创建一个工厂
WebSiteFactory factory = new WebSiteFactory();
// 给客户创建一个博客类型的网站
WebSite webSite1 = factory.getWebSiteCategory("博客");
webSite1.use();
// 给客户创建一个博客类型的网站
WebSite webSite2 = factory.getWebSiteCategory("博客");
webSite2.use();
// 给客户创建一个博客类型的网站
WebSite webSite3 = factory.getWebSiteCategory("博客");
webSite3.use();
// 给客户创建一个新闻发布类型的网站
WebSite webSite4 = factory.getWebSiteCategory("新闻发布");
webSite4.use();
// 给客户创建一个公众号类型的网站
WebSite webSite5 = factory.getWebSiteCategory("公众号");
webSite5.use();
// 给客户创建一个公众号类型的网站
WebSite webSite6 = factory.getWebSiteCategory("公众号");
webSite6.use();
// 查看一下连接池中的实例数
System.out.println("实例数:" + factory.getWebSiteCount());
}
}
运行结果:
当前网站分类: 博客 当前网站分类: 博客 当前网站分类: 博客 当前网站分类: 新闻发布 当前网站分类: 公众号 当前网站分类: 公众号 实例数:3
上面的代码,使用工厂代替了直接实例化的方式,工厂中,主要通过一个池的概念,实现了共享对象的目的,但是其实我们会发现,例如创建三个博客类型的网站,但是好像这三个网站就是一模一样的,但是不同的客户,其中博客网站中的数据肯定是不同的,这就是我们还没有区分内部外部的状态
内部状态:对象共享出来的信息,存储在享元对象内部并且不会随环境改变的共享部分
外部状态:对象用来标记的一个内容,随环境会改变,不可共享
打个比方,五子棋只有黑白两色,总不能下多少子,就创建多少个实例吧,所以我们把颜色看做内部状态,有黑白两种颜色。而各个棋子的位置并不相同,当我们落子后这个位置信息才会被传入,所以位置信息就是外部状态
那么对于“外包网站”的例子中,很显然,不同的客户网站数据就是一个外部状态,下面来修改一下
首先新增一个 User 类,后面会将其引入作为外部状态
public class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
修改抽象类和子类,通过参数的方式引入 User 这个外部状态
抽象类
public abstract class WebSite {
public abstract void use(User user);
}
子类
public class ConcreteWebSite extends WebSite {
// 网站发布形式
private String type = "";
public ConcreteWebSite(String type) {
this.type = type;
}
@Override
public void use(User user) {
System.out.println("【网站分类】: " + type + " 【客户】: " + user.getName());
}
}
工厂类不变,最后修改测试类
public class Test {
public static void main(String[] args) {
// 创建一个工厂
WebSiteFactory factory = new WebSiteFactory();
// 给客户创建一个博客类型的网站
WebSite webSite1 = factory.getWebSiteCategory("博客");
webSite1.use(new User("客户A"));
// 给客户创建一个博客类型的网站
WebSite webSite2 = factory.getWebSiteCategory("博客");
webSite2.use(new User("客户B"));
// 给客户创建一个博客类型的网站
WebSite webSite3 = factory.getWebSiteCategory("博客");
webSite3.use(new User("客户C"));
// 给客户创建一个新闻发布类型的网站
WebSite webSite4 = factory.getWebSiteCategory("新闻发布");
webSite4.use(new User("客户A"));
// 给客户创建一个公众号类型的网站
WebSite webSite5 = factory.getWebSiteCategory("公众号");
webSite5.use(new User("客户A"));
// 给客户创建一个公众号类型的网站
WebSite webSite6 = factory.getWebSiteCategory("公众号");
webSite6.use(new User("客户B"));
// 查看一下连接池中的实例数
System.out.println("实例数:" + factory.getWebSiteCount());
}
}
运行结果:
【网站分类】: 博客 【客户】: 客户A 【网站分类】: 博客 【客户】: 客户B 【网站分类】: 博客 【客户】: 客户C 【网站分类】: 新闻发布 【客户】: 客户A 【网站分类】: 公众号 【客户】: 客户A 【网站分类】: 公众号 【客户】: 客户B 实例数:3
可以看出来,虽然有 6 个客户,但是实际上只有三个实例,同样再增加几十个,也最多只会有三个实例
定义:享元(Flyweight)模式运用共享技术来有效地支持大量细粒度对象的复用。
它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销,从而提高系统资源的利用率。
享元模式又叫做蝇量模式,所以英文为 Flyweight
注:方法参数和返回值没细细弄,主要为了说明结构
优点:相同对象只需要保存一份,降低了系统中内存的数量,减少了系统内存的压力
缺点:程序复杂性增大,同时读取享元模式的外部状态会使得运行时间稍微变长
享元模式其中也需要一个工厂进行控制,所以就好像是在工厂方法模式的基础上,增加了一个缓存机制,也就是通过一个 “池” 的概念,避免了大量相同的对象创建,大大降低了内存空间的消耗。
那么应用场景如下: