大话设计模式读书笔记(享元模式)
人物：大鸟，小菜
事件：小菜最近接了点私活，是一个做网站的外包，刚开始是为一个客户做，后来另一个客户也需要做一个类似的网站，后面客户多了这样代码虽然结构类似但是多多少少都有些不一样了，而且很费租用空间，后期更是难以维护，在小菜给大鸟倾诉完之后，大鸟为小菜提供了一种新的设计模式：享元模式
享元模式：
1.用代码设计小菜实例
2.了解共享模式
3.通过共享模式改进小菜实例并小结
每个网站一个实例的设计实现
WebSite类，网站：
@Slf4j public class WebSite { private String name = ""; public WebSite(String name) { this.name = name; } public void use() { log.info("网站分类：" + name); } }
客户端代码：
public class WebSiteClient { public static void main(String[] args) { WebSite fx = new WebSite("产品展示"); fx.use(); WebSite fy = new WebSite("产品展示"); fy.use(); WebSite fz = new WebSite("产品展示"); fz.use(); WebSite fl = new WebSite("博客"); fl.use(); WebSite fm = new WebSite("博客"); fm.use(); WebSite fn = new WebSite("博客"); fn.use(); } }
小菜：这样就做出3个产品展示，3个博客的网站
享元模式
1.概念：运用共享技术有效地支持大量细粒度的对象
2.结构图：
3.代码示例：
Flyweight类，是所有具体享元类的超类或接口
public abstract class Flyweight { public abstract void Operation(int extrinsicstate); }
ConcreteFlyweight类，为内部状态增加存储空间：
@Slf4j public class ConcreteFlyweight extends Flyweight { @Override public void Operation(int extrinsicstate) { log.info("具体Flyweight: " + extrinsicstate); } }
UnsharedConcreteFlyweight类，指那些不需要共享的Flyweight子类：
@Slf4j public class UnsharedConcreteFlyweight extends Flyweight { @Override public void Operation(int extrinsicstate) { log.info("不共享的具体Flyweight: " + extrinsicstate); } }
FlyweightFactory类，是一个享元工厂，用来创建和管理FlyweightFactory，主要是确保合理共享Flyweight：
public class FlyweightFactory { private Hashtable flyweights = new Hashtable<>(); public FlyweightFactory() { flyweights.put("X", new ConcreteFlyweight()); flyweights.put("Y", new ConcreteFlyweight()); flyweights.put("Z", new ConcreteFlyweight()); } public Flyweight getFlyweight(String key) { return (Flyweight)flyweights.get(key); } }
客户端代码：
public class WebSiteClient { public static void main(String[] args) { int extrinsicstate = 22; FlyweightFactory f = new FlyweightFactory(); Flyweight fx = f.getFlyweight("X"); fx.Operation(--extrinsicstate); Flyweight fy = f.getFlyweight("Y"); fy.Operation(--extrinsicstate); Flyweight fz = f.getFlyweight("Z"); fz.Operation(--extrinsicstate); UnsharedConcreteFlyweight uf = new UnsharedConcreteFlyweight(); uf.Operation(--extrinsicstate); } }
享元模式结合小菜实例
网站抽象类：
@Slf4j public abstract class WebSite { public abstract void use(); }
具体网站类：
@Slf4j public class ConcreteWebSite extends WebSite { private String name = ""; public ConcreteWebSite(String name) { this.name = name; } @Override public void use() { log.info("网站分类：" + name); } }
网站工厂类：
public class WebSiteFactory { private Hashtable flyweights = new Hashtable(); public WebSite getWebSiteCategory(String key) { if (!flyweights.containsKey(key)) { flyweights.put(key, new ConcreteWebSite(key)); } return (WebSite) flyweights.get(key); } public int getWebSiteCount() { return flyweights.size(); } }
客户端代码：
public class WebSiteClient { public static void main(String[] args) { WebSiteFactory f = new WebSiteFactory(); WebSite fx = f.getWebSiteCategory("产品展示"); fx.use(); WebSite fy = f.getWebSiteCategory("产品展示"); fy.use(); WebSite fz = f.getWebSiteCategory("产品展示"); fz.use(); WebSite fl = f.getWebSiteCategory("博客"); fl.use(); WebSite fm = f.getWebSiteCategory("博客"); fm.use(); WebSite fn = f.getWebSiteCategory("博客"); fn.use(); } }
最后输出的结果：
网站分类：产品展示
网站分类：产品展示
网站分类：产品展示
网站分类：博客
网站分类：博客
网站分类：博客
网站分类总数为2
大鸟：这样算是基本实现了享元模式共享对象的目的，不管建几个网站，只要key相同，那么就一样，这里只体现了相同的部分，但实际中不同企业可能需要的网站功能同，但是不同公司的账号，数据都是不同的，那你有考虑过怎么处理么，我再给你讲讲享元模式的内部状态和外部状态。
享元模式的内部状态和外部状态
享元模式可以避免大量相似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据，如果能发现这些实例除了几个参数外，基本都是相同的，如果能把参数移到类实例的外面，在方法调用时将它们传进来，就可以通过共享大幅度减少单个实例的数目。
也就是说客户的状态就是外部状态，应该由专门的对象来处理。
于是小菜出了第三版：
1.代码结构图：
2.代码示例：
User类，用户类，用户网站的客户账号：
@Data @Accessors(chain = true) public class User { private String name; }
网站抽象类：
@Slf4j public abstract class WebSite {
//使用的方法需要传递用户对象 public abstract void use(User user); }
网站工厂类：
public class WebSiteFactory { private Hashtable flyweights = new Hashtable(); public WebSite getWebSiteCategory(String key) { if (!flyweights.containsKey(key)) { flyweights.put(key, new ConcreteWebSite(key)); } return (WebSite) flyweights.get(key); } public int getWebSiteCount() { return flyweights.size(); } }
客户端代码：
@Slf4j public class WebSiteClient { public static void main(String[] args) { WebSiteFactory f = new WebSiteFactory(); WebSite fx = f.getWebSiteCategory("产品展示"); User user1 = new User().setName("小菜"); fx.use(user1); WebSite fy = f.getWebSiteCategory("产品展示"); User user2 = new User().setName("大鸟"); fx.use(user2); WebSite fz = f.getWebSiteCategory("产品展示"); User user3 = new User().setName("娇娇"); fz.use(user3); WebSite fl = f.getWebSiteCategory("博客"); User user4 = new User().setName("老顽童"); fl.use(user4); WebSite fm = f.getWebSiteCategory("博客"); User user5 = new User().setName("桃谷六仙"); fm.use(user5); WebSite fn = f.getWebSiteCategory("博客"); User user6 = new User().setName("南海鳄神"); fn.use(user6); log.info("网站分类总数为{}", f.getWebSiteCount()); } }
结果输出：
网站分类：产品展示用户：小菜
网站分类：产品展示用户：大鸟
网站分类：产品展示用户：娇娇
网站分类：博客用户：老顽童
网站分类：博客用户：桃谷六仙
网站分类：博客用户：南海鳄神
网站分类总数为2
3.享元模式的应用场景
(1)理解：当一个应用程序使用了大量重复的对象，而这些大量的存储对象造成了很大开销时，享元模式就可以通过共享对象来避免创建过多对象。
(2)举例：String常量池、数据库连接池、缓冲池等等，或者你要开发一款五子棋游戏，理论上一盘棋有361个空格要创建361个对象，但用了共享模式后，只用创建两个即可。
(3)优点：减少了大量重复的代码，简化了代码的复杂的，而且减小了开销，节省了内存，提高了性能。
