设计模式—享元模式

谁践踏了优雅 2022-08-08 09:16 195阅读 0赞

享元模式的英文原文是：Use share to support large number of fine-grained objects efficiently.意思是：使用共享对象可以有效的支持大量的细粒度的对象。这里的共享对象指的是对象常驻内存，都可以使用；细粒度对象指的是，对象的很多属性相似或相同，可以提取出公共属性。享元对象能够做到共享的关键就是区分内部状态和外部状态，上边提到的公共属性就是内部状态，不同的属性是外部状态。再看看内部状态和外部状态的的定义：

内部状态：存储在享元对象的内部，可以共享的信息，并且不会随环境的改变而改变。

外部状态：随外部环境改变而改变且不可共享的状态，外部状态由客户端保存，在必要的时候再将其传入到享元对象内部。

享元模式的四种角色：

抽象享元角色（Flyweight）：对享元类进行抽象规定了必须要实现的公共接口，需要外部状态(External State)的操作可以通过方法的参数传入。

具体享元角色（ConcreteFlyweight）：实现抽象享元角色定义的业务，具体享元对象的内部状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享。

复合享元角色(UnsharableFlyweight)：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个具体享元角色的组合。

享元工厂（FlyweightFactory）：该角色构造一个池容器，负责创建和管理享元角色，并提供从容器池中获取对象的方法，保证享元对象可以被系统适当的共享。

享元模式的类图：

![Center][]

各类对应的实现代码：

抽象享元角色：

package com.zz.flyweight;
    /**
     *  抽象享元角色（Flyweight）
     * Copyright 2015年5月13日
     * created by txxs
     * all right reserved
     */
    public abstract class Flyweight {
    	//内部状态
    	private String intrinsic;
    	//外部状态
    	private String Extrinsic;
    	//定义业务操作
    	public abstract void operate();
    	//要求享元角色必须接受外部状态
    	public Flyweight(String Extrinsic){
    		this.Extrinsic = Extrinsic;
    	}
    	public String getIntrinsic() {
    		return intrinsic;
    	}
    	public void setIntrinsic(String intrinsic) {
    		this.intrinsic = intrinsic;
    	}
    	
    }

具体享元角色：

package com.zz.flyweight;
    /**
     * 具体享元角色
     * Copyright 2015年5月13日
     * created by txxs
     * all right reserved
     */
    public class ConcreteFlyweight extends Flyweight {
    
    	//接受外部状态
    	public ConcreteFlyweight(String Extrinsic) {
    		super(Extrinsic);
    	}
    
    	@Override
    	public void operate() {
    		//业务处理
    	}
    
    }

复合享元角色：

package com.zz.flyweight;
    /**
     * 复合享元角色
     * Copyright 2015年5月13日
     * created by txxs
     * all right reserved
     */
    public class UnsharedConcreteFlyweight extends Flyweight {
    
    	//接受外部状态
    	public UnsharedConcreteFlyweight(String Extrinsic) {
    		super(Extrinsic);
    	}
    
    	@Override
    	public void operate() {
    		//业务逻辑
    	}
    
    }

享元工厂：

package com.zz.flyweight;
    
    import java.util.HashMap;
    /**
     * 享元工厂
     * Copyright 2015年5月13日
     * created by txxs
     * all right reserved
     */
    public class FlyweightFactory {
    	//定义一个池容器
    	private static HashMap<String, Flyweight> pool = new HashMap<String, Flyweight>();
    	//享元工厂
    	public static Flyweight getFlyweight(String extrinsic){
    		//需要返回的对象
    		Flyweight flyweight = null;
    		//获取返回的对象
    		if(pool.containsKey(extrinsic)){
    			flyweight = pool.get(extrinsic);
    		}else{
    			flyweight = new ConcreteFlyweight(extrinsic);
    			pool.put(extrinsic, flyweight);
    		}
    		return flyweight;
    	}
    }

享元模式的优缺点：

大幅降低内存中对象的数量，降低内存的占有，提高性能。但是增加了系统的复杂性，需要分离出外部状态和内部状态，内部状态具有固化的特性，不应该随外部状态的改变而改变，使得逻辑复杂化；并且享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

享元模式适合的场合：  
        1、系统中有大量的相似的对象，这些对象耗费大量的内存

2、需要缓冲池的场景

比如java的基础类库中就大量使用了享元模式，String、Integer等类都利用享元模式提供了内部的池化机制，看下面的代码：

package com.zz.decorator.impl;
    /**
     * 测试类
     * Copyright 2015年4月20日
     * created by txxs
     * all right reserved
     */
    public class ClientTest {
    	public static void main(String args[]){
            String a = "abc";
            String b = "abc";
            System.out.println(a==b);
            System.out.println("----------------------");
            String c=new String("Hello"); 
            String d=new String("Hello"); 
            System.out.println(c==d);
    	}
    
    }

第一个输出的就是true，第二个输出的fasle。

[Center]: /images/20220805/724c4064117c4272a06753697f6321d6.png