-享元模式

享元模式

定义

运用共享技术有效地支持大量细粒度的对象。
系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式，它是一种对象结构型模式。

解决

在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。
面向对象技术可以很好地解决一些灵活性或可扩展性问题，但在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时，将导致运行代价过高，带来性能下降等问题。

优点

• 享元模式的优点在于它可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份。
• 享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享。

缺点

• 享元模式使得系统更加复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。
• 为了使对象可以共享，享元模式需要将享元对象的状态外部化，而读取外部状态使得运行时间变长。而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

结构

享元模式包含如下角色：

• Flyweight: 抽象享元类
• ConcreteFlyweight: 具体享元类
• UnsharedConcreteFlyweight: 非共享具体享元类
• FlyweightFactory: 享元工厂类
  

实现

package flyweightpattern;
/**
 * 所有具体享元类的超类，通过此接口，Flyweight可以接受并作用于外部状态
 */
public abstract class Flyweight {
    public abstract void operation(int extrinsicState);
}

/**
 * 继承Flyweight或实现Flyweight接口，并为内部状态增加存储空间
 */
class ConcreteFlyweight extends Flyweight {

    @Override
    public void operation(int extrinsicState) {
        System.out.println("具体Flyweight：" + extrinsicState);
    }

}

/**
 * 指那些不需要共享的Flyweight子类，因为接口共享成为可能，但它并不强制共享。
 */
class UnsharedConcreteFlyweight extends Flyweight {

    @Override
    public void operation(int extrinsicState) {
        System.out.println("不共享的具体Flyweight：" + extrinsicState);
    }
}

package flyweightpattern;

import java.util.HashMap;

/**
 * 享元工厂，用来创建并管理Flyweight对象。
 * 它主要时用来确保合理地共享Flyweight，当用户请求一个Flyweight时，FlyweightFactory
 * 对象提供一个已创建的实例或者创建一个（如果不存在）。
 */
public class FlyweightFactory {
    //初始化工厂，生成若干实例
    private HashMap<String, Flyweight> flyweights = new HashMap<String, Flyweight>();

    public Flyweight getFlyweight(String key) {
        if (!flyweights.containsKey(key)) {
            flyweights.put(key, new ConcreteFlyweight());
        }

        return flyweights.get(key);
    }
}

package flyweightpattern;
public class FlyweightClient {
    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);

        Flyweight fa = f.getFlyweight("A");
        fz.operation(--extrinsicState);

        Flyweight uf = new UnsharedConcreteFlyweight();
        uf.operation(--extrinsicState);
    }
}

实例

模拟做网站，在控制台中显示“网页”，相同类型网站共享元对象，那该类型就是内部状态，而不同网站所有者的账号密码网页信息等则是外部状态。

这里是外部状态

package flyweightpattern.demo;
/**
 * 网站外部状态 用户
 */
public class User {
    private String name;
    private String news;

    public String getName() {
        return name;
    }

    public String getNews() {
        return news;
    }

    public User(String name, String news) {
        this.name = name;
        this.news = news;
    }
}

package flyweightpattern.demo;
/**
 * 网站抽象类
 */
public abstract class WebSite {
    public abstract void use(User user);
}

class ConcreteWebSite extends WebSite{
    private String type =null;

    public ConcreteWebSite(String type) {
        this.type = type;
    }


    @Override
    public void use(User user) {
        System.out.println("网站分类："+type+"\t用户："+user.getName()+"\t网站内容："+user.getNews());
    }
}

class UnshareConcreteWebSite extends WebSite{
    @Override
    public void use(User user) {
        System.out.print("不共享元的网站，我很特殊\t");
        System.out.println("用户："+user.getName()+"\t网站内容："+user.getNews());
    }
}

package flyweightpattern.demo;
import java.util.HashMap;

public class WebSiteFactory {
    //初始化工厂，生成若干实例
    private HashMap<String, WebSite> webSites = new HashMap<String, WebSite>();

    public WebSite getWebSiteType(String key) {
        if (!webSites.containsKey(key)) {
            webSites.put(key, new ConcreteWebSite(key));
        }

        return webSites.get(key);
    }
}

package flyweightpattern.demo;

public class FlyweightClient {

    public static void main(String[] args) {
        WebSiteFactory f = new WebSiteFactory();

        WebSite w1=f.getWebSiteType("电子商务");
        w1.use(new User("张三","卖鞋"));

        WebSite w2=f.getWebSiteType("电子商务");
        w2.use(new User("李四","卖酒"));

        WebSite w3=f.getWebSiteType("博客");
        w3.use(new User("王五","写技术"));

        WebSite w4=f.getWebSiteType("博客");
        w4.use(new User("赵六","放写真"));

        UnshareConcreteWebSite w5 =new UnshareConcreteWebSite();
        w5.use(new User("刘七","不可告人"));
    }
}

总结

• 享元模式运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用，它是一种对象结构型模式。
• 享元模式包含四个角色：抽象享元类声明一个接口，通过它可以接受并作用于外部状态；具体享元类实现了抽象享元接口，其实例称为享元对象；非共享具体享元是不能被共享的抽象享元类的子类；享元工厂类用于创建并管理享元对象，它针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中。
• 享元模式以共享的方式高效地支持大量的细粒度对象，享元对象能做到共享的关键是区分内部状态和外部状态。其中内部状态是存储在享元对象内部并且不会随环境改变而改变的状态，因此内部状态可以共享；外部状态是随环境改变而改变的、不可以共享的状态。
• 享元模式主要优点在于它可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份；其缺点是使得系统更加复杂，并且需要将享元对象的状态外部化，而读取外部状态使得运行时间变长。
• 享元模式适用情况包括：一个系统有大量相同或者相似的对象，由于这类对象的大量使用，造成内存的大量耗费；对象的大部分状态都可以外部化，可以将这些外部状态传入对象中；多次重复使用享元对象。