doccachemgr.java

oa 源码

package com.redmoon.oa.netdisk;

import org.apache.log4j.Logger;
import cn.js.fan.cache.jcs.*;
import cn.js.fan.db.Conn;
import java.util.Vector;
import java.sql.ResultSet;
import java.sql.SQLException;
import cn.js.fan.web.Global;
import cn.js.fan.db.SQLFilter;
import cn.js.fan.security.SecurityUtil;


public class DocCacheMgr implements ICacheMgr {
    public static final int DOC_BLOCK_SIZE = 100;
    private static final long[] EMPTY_BLOCK = new long[0];

    public final static String FULLTEXT = "NETDISK_FULLTEXT"; 
    public final static String ALL = "NETDISK_ALL";   
    String COUNT_GROUP_NAME = "NETDISK_SQL_COUNT_";
    String DOCBLOCKCACHEPRIX = "NETDISK_DOCBLOCK_";
    String cachePrix = "netdisk_doc";

    public final static String CHILDREN_OF_PARENT = "NETDISK_CHILDREN_"; 

    private final long FULLTEXTMAXLIFE = 3600;
    private long curFulltextLife = FULLTEXTMAXLIFE;
    static boolean isRegisted = false;

    Logger logger = Logger.getLogger(DocCacheMgr.class.getName());
    RMCache rmCache = RMCache.getInstance();

    String connname = "";

    public DocCacheMgr() {
        connname = Global.defaultDB;
        if (connname.equals(""))
            logger.info("DocCacheMgr:默认数据库名为空！");

        regist();
    }

    
    public void refreshFulltext() {
        try {
            rmCache.invalidateGroup(DOCBLOCKCACHEPRIX + FULLTEXT);
        }
        catch (Exception e){
            logger.error("refreshFulltext:" + e.getMessage());
        }
    }

    
    public void timer() {
        
        curFulltextLife--;
        if (curFulltextLife<=0) {
            refreshFulltext();
            curFulltextLife = FULLTEXTMAXLIFE;
        }
    }

    
    public void regist() {
        if (!isRegisted) {
            rmCache.regist(this);
            isRegisted = true;
        }
    }

    public void refreshCreate(String dir_code, String parent_code) {
        
        try {
            rmCache.invalidateGroup(DOCBLOCKCACHEPRIX + dir_code);
            rmCache.invalidateGroup(COUNT_GROUP_NAME);
            rmCache.invalidateGroup(ALL);

            
            
            rmCache.invalidateGroup(DOCBLOCKCACHEPRIX + CHILDREN_OF_PARENT + parent_code);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    public void refreshUpdate(int id) {
        removeFromCache(id);
    }

    
    public void refreshUpdate(int id, String dir_code, String parent_code) {
        
        removeFromCache(id);
        
        try {
            rmCache.invalidateGroup(DOCBLOCKCACHEPRIX + dir_code);
            rmCache.invalidateGroup(COUNT_GROUP_NAME);
            rmCache.invalidateGroup(ALL);

            
            rmCache.invalidateGroup(DOCBLOCKCACHEPRIX + CHILDREN_OF_PARENT +
                                    parent_code);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    public void refreshChangeDirCode(String dirCodeFrom, String dirCodeTo) {
        try {
            rmCache.invalidateGroup(DOCBLOCKCACHEPRIX + dirCodeFrom);
            rmCache.invalidateGroup(DOCBLOCKCACHEPRIX + dirCodeTo);
            rmCache.invalidateGroup(COUNT_GROUP_NAME);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    public void refreshDel(int id, String dir_code, String parent_code) {
        
        removeFromCache(id);
        
        try {
            rmCache.invalidateGroup(DOCBLOCKCACHEPRIX + dir_code);
            rmCache.invalidateGroup(COUNT_GROUP_NAME);
            rmCache.invalidateGroup(ALL);

            
            rmCache.invalidateGroup(DOCBLOCKCACHEPRIX + CHILDREN_OF_PARENT +
                                    parent_code);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    public void removeFromCache(int id) {
        try {
            rmCache.remove(cachePrix + id);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    protected long[] getDocBlock(String query, String groupKey, int startIndex) {
        
        int blockID = startIndex / DOC_BLOCK_SIZE;
        int blockStart = blockID * DOC_BLOCK_SIZE;
        
        
        String key = query + blockID;

        long[] longArray = null;
        try {
            
            longArray = (long[]) rmCache.getFromGroup(key,
                    DOCBLOCKCACHEPRIX + groupKey);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
        
        if (longArray != null) {
            
            long[] docs = longArray;
            
            if (startIndex >= blockStart + docs.length) {
                
                return EMPTY_BLOCK;
            } else {
                return docs;
            }
        }
        
        else {
            Vector DocBlock = new Vector();
            Conn conn = new Conn(connname);
            ResultSet rs = null;
            try {
                
                conn.setMaxRows(DOC_BLOCK_SIZE * (blockID + 1));
                rs = conn.executeQuery(query);
                
                
                conn.setFetchSize(DOC_BLOCK_SIZE);
                
                
                
                for (int i = 0; i < blockStart; i++) {
                    rs.next();
                }
                
                
                int count = 0;
                while (rs.next() && count < DOC_BLOCK_SIZE) {
                    DocBlock.addElement(new Long(rs.getLong(1)));
                    count++;
                }
            } catch (SQLException sqle) {
                logger.error("getDocBlock: " + sqle.getMessage());
                
            } finally {
                if (rs != null) {
                    try {
                        rs.close();
                    } catch (Exception e) {}
                    rs = null;
                }
                if (conn != null) {
                    conn.close();
                    conn = null;
                }
            }
            int len = DocBlock.size();
            long[] docs = new long[len];
            for (int i = 0; i < len; i++) {
                docs[i] = ((Long) DocBlock.elementAt(i)).longValue();
            }
            
            try {
                rmCache.putInGroup(key, DOCBLOCKCACHEPRIX + groupKey, docs);
            } catch (Exception e) {
                logger.error("getDocBlock1:" + e.getMessage());
            }
            
            if (startIndex >= blockStart + docs.length) {
                
                return EMPTY_BLOCK;
            } else {
                return docs;
            }
        }
    }

    
    public int getDocCount(String sql) {
        
        String query = SQLFilter.getCountSql(sql);
        if (!SecurityUtil.isValidSql(query))
            return -1;
        Integer count = null;
        try {
            count = (Integer) rmCache.getFromGroup(query, COUNT_GROUP_NAME);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }

        
        if (count != null) {
            return count.intValue();
        }
        
        else {
            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 sqle) {
                sqle.printStackTrace();
            } finally {
                if (rs != null) {
                    try {
                        rs.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    rs = null;
                }
                if (conn != null) {
                    conn.close();
                    conn = null;
                }
            }
            
            try {
                rmCache.putInGroup(query, COUNT_GROUP_NAME,
                                   new Integer(docCount));
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
            return docCount;
        }
    }

    public Document getDocument(int id) {
        Document doc = (Document) rmCache.get(cachePrix + id);
        if (doc == null) {
            doc = new Document(id);
            if (doc.isLoaded()) {
                try {
                    rmCache.put(cachePrix + id, doc);
                } catch (Exception e) {
                    logger.error("getDocument:" + e.getMessage());
                }
                return doc;
            }
            else
                return null;
        } else {
            doc.renew();
            return doc;
        }
    }
}