javaweb框架构想-自己的对象存储池-遁地龙卷风

设计初衷:
　　网站在提供服务的过程中，会创建很多对象，bean,dao层的对象尤为频繁,然而这些对象是可以重复利用的.
设计思路:
　　对象连接池ObjectPool才用单态的设计模式,自带线程，每隔一段时间调用该类的
clearObject方法，
　　为了保证同步，涉及线程安全的方法全都使用了synchronized关键字
　　每个方法的流程控制根据存储值会出现的状态，以及会影响存储值状态的数据决定
　　要存储进ObjectPool的类需要实现AllowEnterObjectPool接口
主要属性介绍：
　　HashMap<String,ArrayList> hashMapForStorageObject，key是包名+类名,value存储改类的实例，每次取出放回都会从0的位置
　　HashMap<String,Integer> hashMapForObjectUsedTime key是包名+类名+@+对象hashcode Integer记录了对象被取出次数
主要方法介绍:
　　takeOut的方法利用泛型，只需传给类的Class,便可返回对应类型,利用反射批量添加对象
　　put 是对象恢复到初始状态(由程序员指定),放入到对应ArrayList的0位置
　　clearObject，由内部线程调用，遍历hashMapForStorageObject每个ArrayList,如果ArrayList总数大于最小存储数,再去

　　ashMapForObjectUsedTime查找使用记录，将符合条件的对象删除,最后清零使用记录
代码及使用方式:

package myFrame;

public interface AllowEnterObjectPool
{
	public ObjectPool objectPool = ObjectPool.getInstance();
	//将对象放入改类时，需调用改方法，将对象恢复带默认状态
	public void initialMember();
	//当调用takeOut方法，发现没有可用的对象使，会调用改方法批量加入
	public void batchAddSelf();
}

　

package myFrame;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;

import com.sun.security.auth.NTDomainPrincipal;

import Dao.TestDao;

public class ObjectPool implements Debug,Assistant
{

    //当只剩下30个对象的时候，就不进行删除行为了
    private int minNumber = 30;
    //每隔多少时间进行检查
    private int checkTime = 60*60*1000;
    //每个类对应一个ArrayList
    //    key值已包名+类名的方式
    //    value值是存储该对象的Arraylist
    // value影响程序流程的值  null(没有找到key)  0(size)
    // 影响value的状态的值    minNumber
    private HashMap<String,ArrayList> hashMapForStorageObject = new HashMap<String, ArrayList>();
    //每个对象对应一个Integer，记录一段时间内被调用得次数

    /*
     * key值已包名+类名+@+对象hashcode
        value 记录了该对象被取出的次数
        value影响程序流程的值 null(没有找到key) >0(被使用过)
     */
    private HashMap<String,Integer> hashMapForObjectUsedTime = new HashMap<String, Integer>();

    private static ObjectPool objectPool = new ObjectPool();
    private ObjectPool()
    {
        new clock().start();
    }
    //得到一个类的实例,每次都从0获取，并从ArrayList中删除
    public<T>  T takeOut(Class<T> object)
    {
        synchronized (this)
        {
            String className = object.getName();
            ArrayList<T> objectList = hashMapForStorageObject.get(className);
            if(objectList == null)
            {
                objectList = new ArrayList<T>();
                hashMapForStorageObject.put(className,objectList);
                T createObject = null;
                try
                {
                    createObject = object.newInstance();
                    Method batchAddSelf = object.getMethod("batchAddSelf");
                    batchAddSelf.invoke(createObject);
                    objectList.add(createObject);

                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            else if(objectList.size()==0)
            {
                T createObject = null;
                try
                {
                    createObject = object.newInstance();
                    Method batchAddSelf = object.getMethod("batchAddSelf");
                    batchAddSelf.invoke(createObject);
                    objectList.add(createObject);

                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            T returnObject = objectList.get(0);
            String flag  = className+"@"+Integer.toHexString(returnObject.hashCode());
            Integer i = hashMapForObjectUsedTime.get(flag);
            if(i == null)
            {
                i = 0;
            }
            hashMapForObjectUsedTime.put(flag,++i);
            objectList.remove(returnObject);
            return returnObject;
        }
    }
    /*
     * 将对象恢复到初始状态后,放入0位置
     */
    public synchronized void put(AllowEnterObjectPool allowEnterObjectPool)
    {
        allowEnterObjectPool.initialMember();
        String className = allowEnterObjectPool.getClass().getName();
        ArrayList objectList = hashMapForStorageObject.get(className);
        if(objectList == null)
        {
            objectList = new ArrayList();
            hashMapForStorageObject.put(className,objectList);
        }
        objectList.add(0,allowEnterObjectPool);
    }
    /*
     * 已hashMapForStorageObject为准,取出一个ArrayList A，遍历里面的对象，例如对a ，组成hashMapForObjectUsedTime的key值
     * 当A的容量大于minnumber时,则通过key查找hashMapForObjectUsedTime，得到value为null的话,则删除A里面的对应对象
     * 将hashMapForObjectUsedTime数据清除
     */
    public synchronized void clearObject()
    {
        Iterator<String> iterator = hashMapForStorageObject.keySet().iterator();
        String key,flag;
        ArrayList list;
        while (iterator.hasNext())
        {
            key = iterator.next();
            list = hashMapForStorageObject.get(key);
            Object object;
            Integer usedTime;
            if (list.size()<minNumber)
            {
                continue;
            }
            for(int i=0;i<list.size();i++)
            {
                object = list.get(i);
                flag = key+"@"+Integer.toHexString(object.hashCode());
                usedTime = hashMapForObjectUsedTime.get(flag);
                if(usedTime == null)
                {
                    list.remove(i);
                    hashMapForObjectUsedTime.remove(key);
                    i--;
                    if(list.size() ==  minNumber) break;
                }

            }

        }
        hashMapForObjectUsedTime.clear();
    }
    public static ObjectPool getInstance()
    {
        return objectPool;
    }
    private class clock extends Thread
    {

        @Override
        public void run()
        {
            System.out.println("时钟启动");
            while(true)
            {
                try
                {
                    Thread.sleep(checkTime);
                }
                catch (InterruptedException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                clearObject();
            }
        }

    }
    public static void main(String[] args)
    {
        Message message = objectPool.takeOut(Message.class);
        objectPool.put(message);
        System.out.println(message);
    }

}

package myFrame;

public class Message implements AllowEnterObjectPool
{
    private String name;
    private int age;
    public Message()
    {

    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public void initialMember() {
        // TODO Auto-generated method stub
        name = "";
        age = 0;
    }
    @Override
    public void batchAddSelf()
    {
        Message message;
        for(int i=0;i<10;i++)
        {
            message = new Message();
            objectPool.put(message);
        }
    }

}