享元模式实现java对象池          返回主页

名词定义

享元模式: 是池技术的重要实现方式，使用共享对象有效的支持大量细粒度对象，实现对象的共享。

对象key:在对象池中，一旦产生对象，必然有一个唯一的可供访问的状态标识该对象，而且池中的对象声明周期是由池容器决定的而不是由使用者决定。

本文将通过享元模式实现java对象池(以学生报考考试为例)

SignInfo.java报考信息类，POJO，记录人员ID,考试地点，科目及地址

package sharinModule;

public class SignInfo {

    private String id;
    private String location;
    private String subject;
    private String postAddress;

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getLocation() {
        return location;
    }
    public void setLocation(String location) {
        this.location = location;
    }
    public String getSubject() {
        return subject;
    }
    public void setSubject(String subject) {
        this.subject = subject;
    }
    public String getPostAddress() {
        return postAddress;
    }
    public void setPostAddress(String postAddress) {
        this.postAddress = postAddress;
    }
}

SignInfo4Pool.java继承SignInfo类，带一个对象池报考信息key

public class SignInfo4Pool extends SignInfo{
    //key
    private String key;

    public SignInfo4Pool(String _key) {
        this.key = _key;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }
}

SignInfoFactory.java工厂类，建立对象池，如果池中没有对象池，则建立放入池中，否则直接从池中获得所需对象

import java.util.HashMap;

public class SignInfoFactory {
    //池容器
    private static HashMap<String, SignInfo> pool = new HashMap<>();
    @Deprecated
    public static SignInfo SignInfo() {
        return new SignInfo();
    }
    //从池中获取对象
    public static SignInfo getSignInfo(String key) {
        SignInfo result = null;
        //池中没该对象则建立
        if (!pool.containsKey(key)) {
            System.out.println(key + " 建立对象，并放在池子中");
            result = new SignInfo4Pool(key);
            pool.put(key, result);
        } else {
            result = pool.get(key);
            System.out.println(key + "直接从池中获得");
        }
        return result;
    }
}

client.java类，测试方法类，建立9999个对象并用“学科”+“地点”作为唯一标示标记；并从中取第9999个对象

package sharinModule;

public class client {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            String subject = "学科" + i;
            for (int j = 0; j < 100; j++) {
                String key = subject + "考试地点" + j;
                SignInfoFactory.getSignInfo(key);
            }
        }

        SignInfo signInfo = SignInfoFactory.getSignInfo("学科99考试地点99");
    }
}

运行结果

......
学科99考试地点64 建立对象，并放在池子中
学科99考试地点65 建立对象，并放在池子中
学科99考试地点66 建立对象，并放在池子中
学科99考试地点67 建立对象，并放在池子中
......
学科99考试地点73 建立对象，并放在池子中
学科99考试地点74 建立对象，并放在池子中
学科99考试地点75 建立对象，并放在池子中
学科99考试地点76 建立对象，并放在池子中
学科99考试地点77 建立对象，并放在池子中
学科99考试地点78 建立对象，并放在池子中
......
学科99考试地点95 建立对象，并放在池子中
学科99考试地点96 建立对象，并放在池子中
学科99考试地点97 建立对象，并放在池子中
学科99考试地点98 建立对象，并放在池子中
学科99考试地点99 建立对象，并放在池子中
学科99考试地点99直接从池中获得

小结

可以看到，建立的对象以一个key作为唯一标示放入HashMap中，保证了对象的最小粒度，不会出现重复的对象大量堆积。达到了建立多个可贡献的对象的目的。