objectcache.java

cwbbs 云网论坛源码

package cn.js.fan.base;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;

import cn.js.fan.cache.jcs.ICacheMgr;
import cn.js.fan.cache.jcs.RMCache;
import cn.js.fan.db.*;
import cn.js.fan.resource.Constant;
import cn.js.fan.security.SecurityUtil;
import cn.js.fan.web.Global;
import org.apache.log4j.Logger;


public class ObjectCache implements ICacheMgr, java.io.Serializable {
    public String group;
    public String COUNT_GROUP_NAME;

    public transient Logger logger;
    public transient RMCache rmCache;
    public String connname = "";

    public ObjectDb objectDb;

    public ObjectCache() {
        init();
        regist();
    }

    public ObjectCache(ObjectDb obj) {
        this.objectDb = obj;
        init();
        regist();
    }

    public void renew() {
        if (logger==null)
            logger = Logger.getLogger(this.getClass().getName());
        if (rmCache==null)
            rmCache = RMCache.getInstance();
    }

    public void init() {
        logger = Logger.getLogger(this.getClass().getName());
        connname = Global.defaultDB;
        if (connname.equals(""))
            logger.info(Constant.DB_NAME_NOT_FOUND);
        rmCache = RMCache.getInstance();
        setGroup();
        setGroupCount();
    }

    public void setGroup() {
        group = this.getClass().getName();
    }

    public void setGroupCount() {
        this.COUNT_GROUP_NAME = group + ".Count";
    }

    
    public void timer() {

    }

    
    public void regist() {

    }

    public void setObjectDb(ObjectDb objectDb) {
        this.objectDb = objectDb;
    }

    public void setListCachable(boolean listCachable) {
        this.listCachable = listCachable;
    }

    public void setObjCachable(boolean objCachable) {
        this.objCachable = objCachable;
    }

    public void refreshCreate() {
        if (!listCachable)
            return;
        refreshList();
    }

    public void refreshList() {
        if (!listCachable)
            return;
        try {
            
            
            rmCache.invalidateGroup(COUNT_GROUP_NAME);
            rmCache.invalidateGroup(group);
        }
        catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    public void refreshSave(PrimaryKey pk) {
        if (objCachable)
            removeFromCache(pk);
    }

    public void refreshDel(PrimaryKey pk) {
        try {
            if (objCachable)
                removeFromCache(pk);
            if (listCachable)
                refreshList();
        }
        catch (Exception e) {
            logger.error("refreshDel:" + e.getMessage());
        }
    }

    
    public void removeFromCache(PrimaryKey pk) {
        if (objCachable) {
            try {
                rmCache.remove(pk.getValue(), group);
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
        }
    }

    public ObjectDb getObjectDb(PrimaryKey pk) {
        ObjectDb obj = null;
        if (objCachable) {
            try {
                obj = (ObjectDb) rmCache.getFromGroup(pk.getValue(), group);
            } catch (Exception e) {
                logger.error("getObjectDb:" + e.getMessage());
            }
            
            if (obj == null) {
                obj = objectDb.getObjectRaw(pk);
                
                
                
                if (obj != null && obj.isLoaded()) {
                    try {
                        rmCache.putInGroup(pk.getValue(), group, obj);
                    } catch (Exception e) {
                        logger.error("getObjectDb1:" + e.getMessage());
                    }
                }
            } else {
                
                obj.renew();
                
            }
        }
        else
            obj = objectDb.getObjectRaw(pk);
        return obj;
    }

    
    public int getObjectCount(String sql) {
        
        String query = SQLFilter.getCountSql(sql);
        if (!SecurityUtil.isValidSql(query))
            return -1;
        Integer count = null;
        if (listCachable) {
            try {
                count = (Integer) rmCache.getFromGroup(query, COUNT_GROUP_NAME);
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
            
            if (count != null) {
                return count.intValue();
            }
        }
        
        int docCount = 0;
        Conn conn = new Conn(connname);
        ResultSet rs = null;
        try {
            rs = conn.executeQuery(query);
            if (rs.next())
                docCount = rs.getInt(1);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                conn.close();
                conn = null;
            }
        }
        
        if (listCachable) {
            try {
                rmCache.putInGroup(query, COUNT_GROUP_NAME,
                                   new Integer(docCount));
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
        }
        return docCount;
    }

    public Object[] getObjectBlock(String sql, int startIndex) {
        
        int blockSize = objectDb.getBlockSize();
        int blockID = startIndex / blockSize;
        int blockStart = blockID * blockSize;

        PrimaryKey primaryKey = objectDb.getPrimaryKey();
        
        String pk = primaryKey.getName();
        
        
        String query = sql;

        
        String key = query + blockID;

        Object[] objArray = null;
        if (listCachable) {
            try {
                objArray = (Object[]) rmCache.getFromGroup(key,
                        group);
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
            
            if (objArray != null) {
                
                Object[] objkeys = objArray;
                
                if (startIndex >= blockStart + objkeys.length) {
                    
                    return ObjectDb.EMPTY_BLOCK;
                } else {
                    return objkeys;
                }
            }
        }
        

        Vector block = new Vector();
        Conn conn = new Conn(connname);
        ResultSet rs = null;
        try {
            
            conn.setMaxRows(blockSize * (blockID + 1));
            rs = conn.executeQuery(query);
            
            
            conn.setFetchSize(blockSize);
            
            
            
            for (int i = 0; i < blockStart; i++) {
                rs.next();
            }
            
            
            int count = 0;
            while (rs.next() && count < blockSize) {
                
                if (primaryKey.getKeyCount() == 1) {
                    if (primaryKey.getType() == primaryKey.TYPE_LONG)
                        block.addElement(new Long(rs.getLong(1)));
                    else if (primaryKey.getType() == primaryKey.TYPE_INT)
                        block.addElement(new Integer(rs.getInt(1)));
                    else if (primaryKey.getType() == primaryKey.TYPE_STRING)
                        block.addElement(rs.getString(1));
                } else if (primaryKey.getType() == primaryKey.TYPE_COMPOUND) { 
                    HashMap keys = ((PrimaryKey) primaryKey.clone()).getKeys();
                    Iterator ir = keys.keySet().iterator();
                    while (ir.hasNext()) {
                        String keyName = (String) ir.next();
                        KeyUnit ku = (KeyUnit) keys.get(keyName);
                        if (ku.getType() == primaryKey.TYPE_INT) {
                            ku.setValue(new Integer(rs.getInt(ku.getOrders() + 1)));
                        } else if (ku.getType() == primaryKey.TYPE_LONG) {
                            ku.setValue(new Long(rs.getLong(ku.getOrders() + 1)));
                        } else {
                            ku.setValue(rs.getString(ku.getOrders() + 1));
                        }
                    }
                    
                    block.addElement(keys);
                }
                count++;
            }
        } catch (SQLException sqle) {
            logger.error("getObjectBlock:" + sqle.getMessage());
        } finally {
            if (conn != null) {
                conn.close();
                conn = null;
            }
        }
        int len = block.size();
        Object[] objkeys = new Object[len];
        for (int i = 0; i < len; i++) {
            objkeys[i] = block.elementAt(i);
        }
        
        if (listCachable) {
            try {
                rmCache.putInGroup(key, group, objkeys);
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
        }
        
        if (startIndex >= blockStart + objkeys.length) {
            
            return ObjectDb.EMPTY_BLOCK;
        } else {
            return objkeys;
        }

    }

    public boolean isListCachable() {
        return listCachable;
    }

    public boolean isObjCachable() {
        return objCachable;
    }

    public boolean listCachable = true;
    public boolean objCachable = true;

}