doccontentcachemgr.java

来自「一个用java编写的功能强大的OA系统」· Java 代码 · 共 292 行

package com.redmoon.oa.flow;

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

public class DocContentCacheMgr implements ICacheMgr {

    public static final int DOCCONTENT_BLOCK_SIZE = 100;
    private static final long[] EMPTY_BLOCK = new long[0];

    String DOCCONTENTBLOCKCACHEPRIX = "FLOW_DOCCONTENTBLOCK";
    String cachePrix = "flow_doc_content_";
    String COUNT_GROUP_NAME = "flow_CONTENT_COUNT_";

    static boolean isRegisted = false;

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

    String connname = "";

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

        regist();
    }

    
    public void timer() {
    }

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

    public void refreshCreate(int doc_id ) {
            
            try {
                rmCache.invalidateGroup(DOCCONTENTBLOCKCACHEPRIX + doc_id);
                rmCache.invalidateGroup(COUNT_GROUP_NAME);
            } catch (Exception e) {
                logger.error(e.getMessage());
        }
    }

    public void refreshUpdate(int doc_id, int page_num) {
        removeFromCache(doc_id, page_num);
    }

    public void refreshDel(int doc_id, int page_num) {
        
        removeFromCache(doc_id, page_num);
        
        try {
            rmCache.invalidateGroup(DOCCONTENTBLOCKCACHEPRIX + doc_id);
            rmCache.invalidateGroup(COUNT_GROUP_NAME);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    public void removeFromCache(int doc_id, int page_num) {
        try {
            rmCache.remove(cachePrix+ doc_id + ":" + page_num);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

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

        long[] longArray = null;
        try {
            longArray = (long[]) rmCache.getFromGroup(key,
                    DOCCONTENTBLOCKCACHEPRIX + 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(DOCCONTENT_BLOCK_SIZE * (blockID + 1));
                rs = conn.executeQuery(query);
                
                
                conn.setFetchSize(DOCCONTENT_BLOCK_SIZE);
                
                
                
                for (int i = 0; i < blockStart; i++) {
                    rs.next();
                }
                
                
                int count = 0;
                while (rs.next() && count < DOCCONTENT_BLOCK_SIZE) {
                    DocBlock.addElement(new Long(rs.getLong(1)));
                    count++;
                }
            } catch (SQLException sqle) {
                sqle.printStackTrace();
            } 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, DOCCONTENTBLOCKCACHEPRIX + groupKey, docs);
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
            
            if (startIndex >= blockStart + docs.length) {
                
                return EMPTY_BLOCK;
            } else {
                return docs;
            }
        }
    }

    
    public int getDocContentCount(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 DocContent getDocContent(int doc_id, int page_num) {
        DocContent dc = (DocContent) rmCache.get(cachePrix + doc_id);
        if (dc == null) {
            dc = new DocContent(doc_id, page_num);
            try {
                rmCache.put(cachePrix + doc_id + ":" + page_num, dc);
            } catch (Exception e) {
                logger.error("getDocContent:" + e.getMessage());
            }
            return dc;
        } else {
            dc.renew();
            return dc;
        }
    }

    
    public int getContentCount(int docId) {
        
        String query = "select count(*) from flow_doc_content where doc_id=" + docId;

        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;
        }
    }
}