Java设计模式之享元模式

本文介绍了Java设计模式之享元模式，供大家参考，具体内容如下

1、关于享元模式　　

享元模式有点类似于单例模式，都是只生成一个对象被共享使用。享元模式主要目的就是让多个对象实现共享，减少不会要额内存消耗，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗。

2、享元模式结构图

因为享元模式结构比较复杂，一般结合工厂模式一起使用，在它的结构图中包含了一个享元工厂类。

在享元模式结构图中包含如下几个角色：

　　Flyweight（抽象享元类）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。

　　ConcreteFlyweight（具体享元类）：它实现了抽象享元类，其实例称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。

　　UnsharedConcreteFlyweight（非共享具体享元类）：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。

　　FlyweightFactory（享元工厂类）：享元工厂类用于创建并管理享元对象，它针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中，享元池一般设计为一个存储“键值对”的集合（也可以是其他类型的集合），可以结合工厂模式进行设计；当用户请求一个具体享元对象时，享元工厂提供一个存储在享元池中已创建的实例或者创建一个新的实例（如果不存在的话），返回新创建的实例并将其存储在享元池中。

3、享元模式的实现　　　

　　在享元模式中引入了享元工厂类，享元工厂类的作用在于提供一个用于存储享元对象的享元池，当用户需要对象时，首先从享元池中获取，如果享元池中不存在，则创建一个新的享元对象返回给用户，并在享元池中保存该新增对象。

　　接下来，实现一个登陆的享元模式。

1、用户类

/**
 * 用户类
 * @author 董秀才
 *
 */
public class User {
 private String username; // 用户名
 private String password; // 密码

 public User(String username,String password) {
  this.username = username;
  this.password = password;
 }

 public String getUsername() {
  return username;
 }

 public void setUsername(String username) {
  this.username = username;
 }

 public String getPassword() {
  return password;
 }

 public void setPassword(String password) {
  this.password = password;
 }
}

2、抽象的登陆者（抽象享元类）

/**
 * 登陆者--抽象享元类
 * @author 董秀才
 *
 */
public abstract class Loginer {

 //登陆--享元类公共方法
 public abstract void login(User user);

}

3、具体的登陆者（具体享元类）

/**
 * 具体享元类
 * @author 董秀才
 *
 */
public class ConcreteLoginer extends Loginer{

 // 登陆者凭证
 private String loginerKey = "";
 public ConcreteLoginer(String loginerKey) {
  this.loginerKey = loginerKey;
 }

 @Override
 public void login(User user) {
  System.out.println("登陆者凭证：" + this.loginerKey+",用户名：" + user.getUsername() + ",密码：" + user.getPassword());
 }

}　

4、具体登陆者的工厂类（享元工厂类）

/**
 * 享元工厂类
 * @author 董秀才
 *
 */
public class ConcreteLoginerFactory {

 // map充当对象享元池
 private static Map<String,ConcreteLoginer> loginerMap = new HashMap<String, ConcreteLoginer>();

 public static ConcreteLoginer getConcreteLoginer(String key) {
  // 从享元池中拿 登陆者对象
  ConcreteLoginer concreteLoginer = loginerMap.get(key);
  // 如果享元池中没有此对象
  if(concreteLoginer == null) {
   // 创建对象
   concreteLoginer = new ConcreteLoginer(key);
   // 存到享元池中
   loginerMap.put(key, concreteLoginer);
  }
  // 返回对象
  return concreteLoginer;
 }

 // 返回享元池对象数量
 public static int getSize() {
  return loginerMap.size();
 }
}

5、测试类　

/**
* 博客测试类
* @author 董秀才
*
*/
public class MainTest {

public static void main(String[] args) {
// 去工厂拿对象
ConcreteLoginer concreteLoginer_1 = ConcreteLoginerFactory.getConcreteLoginer("csdn");
concreteLoginer_1.login(new User("董秀才","123456"));

ConcreteLoginer concreteLoginer_2 = ConcreteLoginerFactory.getConcreteLoginer("csdn");
concreteLoginer_2.login(new User("董秀才","123456"));

ConcreteLoginer concreteLoginer_3 = ConcreteLoginerFactory.getConcreteLoginer("csdn");
concreteLoginer_3.login(new User("董秀才","123456"));

// 测试是否是同一个对象
System.out.println("是否是同一个对象：" + ((concreteLoginer_1==concreteLoginer_2)&&(concreteLoginer_2 == concreteLoginer_3)));

// 第二登陆者
ConcreteLoginer concreteLoginer_4 = ConcreteLoginerFactory.getConcreteLoginer("博客园");
concreteLoginer_4.login(new User("董才才","654321"));

ConcreteLoginer concreteLoginer_5 = ConcreteLoginerFactory.getConcreteLoginer("博客园");
concreteLoginer_5.login(new User("董才才","654321"));

ConcreteLoginer concreteLoginer_6 = ConcreteLoginerFactory.getConcreteLoginer("博客园");
concreteLoginer_6.login(new User("董才才","654321"));

System.out.println("是否是同一个对象：" + ((concreteLoginer_4==concreteLoginer_5)&&(concreteLoginer_5 == concreteLoginer_6)));
// 工厂类中享元池中对象数量
System.out.println("享元池size：" + ConcreteLoginerFactory.getSize());
}

} 

6、运行结果

4、总结

从上面代码和运行结果这可以看到，同一个登陆者登陆时是  "享"  用同一个登陆者对象。在享元对象池中只有两个对象。

享元模式优点

　　享元模式的外部状态相对独立，使得对象可以在不同的环境中被复用（共享对象可以适应不同的外部环境）

　　享元模式可共享相同或相似的细粒度对象，从而减少了内存消耗，同时降低了对象创建与垃圾回收的开销

享元模式缺点

　　外部状态由客户端保存，共享对象读取外部状态的开销可能比较大

　　享元模式要求将内部状态与外部状态分离，这使得程序的逻辑复杂化，同时也增加了状态维护成本

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。