XMLCacheStrategyManager.java example

Explorer
jinhe-tss-master
/* ==================================================================   
 * Created [2009-4-27 下午11:32:55] by Jon.King 
 * ==================================================================  
 * TSS 
 * ================================================================== 
 * mailTo:jinpujun@hotmail.com
 * Copyright (c) Jon.King, 2009-2012 
 * ================================================================== 
 */

package com.jinhe.tss.component.cache;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Map.Entry;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

import com.jinhe.tss.core.cachepool.CacheManager;
import com.jinhe.tss.core.cachepool.Cacheable;
import com.jinhe.tss.core.cachepool.IPool;
import com.jinhe.tss.core.cachepool.strategy.CacheConstants;
import com.jinhe.tss.core.cachepool.strategy.CacheStrategy;
import com.jinhe.tss.core.exception.BusinessException;
import com.jinhe.tss.core.sso.Environment;
import com.jinhe.tss.core.util.BeanUtil;
import com.jinhe.tss.core.util.DateUtil;
import com.jinhe.tss.core.util.URLUtil;
import com.jinhe.tss.core.util.XMLDocUtil;

/** 
 * <p> XMLCacheStrategyService.java </p> 
 * 
 * 以XML存放的缓存配置操作类
 */
public class XMLCacheStrategyManager {

    private XMLCacheStrategyManager(){
    }
    
    public static XMLCacheStrategyManager service = null;
    
    public static XMLCacheStrategyManager getInstance(){
        if(service == null)
            service = new XMLCacheStrategyManager();
        return service;
    }
 
    private static CacheManager poolManager = CacheManager.getInstance();

    /**
     * 保存修改后的缓存策略。
     * @param cacheStrategy
     */
    @SuppressWarnings("unchecked")
    public void saveCacheStrategy(CacheStrategy cacheStrategy) {
        if(cacheStrategy == null) return;
        
        String code = cacheStrategy.getCode();
        
        // 保存的时候将操作人的信息记录到remark字段中
        cacheStrategy.setRemark(cacheStrategy.getRemark() + "\n上次修改时间" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                + ", 修改人" + Environment.getOperatorName() + "。");
        poolManager.getCachePool(code).setCacheStrategy(cacheStrategy);
        
        //覆盖策略文件 
        Document doc = XMLDocUtil.createDoc(CacheConstants.STRATEGY_PATH);      
        List<Element> nodes = XMLDocUtil.selectNodes(doc, CacheConstants.STRATEGY_NODE_NAME);
        for(Iterator<Element> it = nodes.iterator(); it.hasNext();){
            Element strategyNode = it.next();  
            if(!strategyNode.attributeValue("code").equals(code))
                continue;
            
            for(Iterator iter = strategyNode.elementIterator(); iter.hasNext();){
                Element attrNode = (Element)iter.next();
                attrNode.setText(BeanUtil.getPropertyValue(cacheStrategy, attrNode.getName()).toString());
            }
        }
        //同时将更改后的缓存策略保存回缓存策略文件和缓存策略备份文件，以防止保存过程中出现服务器死机等意味情况时，可确保其中一个文件正常。 
        String classpath = URLUtil.getClassesPath().getPath(); 
       
        String backupFile = classpath + CacheConstants.STRATEGY_BACKUP_PATH;
        String sourceFile = classpath + CacheConstants.STRATEGY_PATH;
        try {
            File cacheFile = new File(classpath + "META-INF");
            if( !cacheFile.exists() ) { 
                cacheFile.mkdir();
            }
            
            //pass: FileWriter和FileOutputStream区别：前者会改变文件编码格式，后者不会。
            //另外可通过format.setEncoding("UTF-8")方式来设置XMLWriter的输出编码方式。
            OutputFormat format = OutputFormat.createPrettyPrint();
            XMLWriter writer = new XMLWriter(new FileOutputStream(backupFile), format);
            writer.write( doc );
            writer.close();
            
            writer = new XMLWriter(new FileOutputStream(sourceFile), format);
            writer.write( doc );
            writer.close();
        } catch (IOException e) {
            throw new BusinessException("写入缓存策略文件时出错：", e);
        }
    }

    /**
     * 获取所有的缓存策略
     * @return
     */
    public List<CacheStrategy> getAllCacheStrategy() {
        Set<Entry<String, IPool>> pools = poolManager.listCachePools(); 
        List<CacheStrategy> list = new ArrayList<CacheStrategy>();
        for(Iterator<Entry<String, IPool>> it = pools.iterator(); it.hasNext();){
            IPool pool = it.next().getValue(); 
            CacheStrategy cacheStrategy = pool.getCacheStrategy();
            if("1".equals(cacheStrategy.getVisible()))
                list.add(cacheStrategy);
        }
        return list;
    }

    /**
     * 获取单个缓存策略
     * @param code
     * @return
     */
    public CacheStrategy getCacheStrategy(String code) {
        return poolManager.getCachePool(code).getCacheStrategy();
    }

    /**
     * 获取某个缓存策略的缓存池中的所有缓存项。
     * 缓存项需要按点击数来排序。
     * @param code
     * @return
     */
    public List<Cacheable> listItemsByStrategy(String code) {
        return poolManager.getCachePool(code).listItems();
    }

    /**
     * 刷新缓存项。
     * 如果不能重新加载更新的缓存项，则返回null。
     * @param code
     *             缓存项所在池的缓存策略code
     * @param key  
     *             缓存项的key值
     * @return
     */
    public Cacheable refresh(String code, String key) {
        IPool pool = poolManager.getCachePool(code);
        Cacheable object = pool.getObject(key);
        if(object == null){
            throw new BusinessException("缓存项不在缓存池中，可能已被清除！");
        }
        return pool.reload(object);
    }

    /**
     * 清空缓存池
     * @param code
     */
    public void releaseCache(String code) {
        poolManager.getCachePool(code).flush();
    }

    /**
     * 初始化缓存池
     * @param code
     */
    public void initPool(String code) {
        poolManager.getCachePool(code).init();
    }

    /**获取一个缓存项值
     * @param code
     * @param key
     * @return
     */
    public Cacheable getCachedItem(String code, String key) {
        return poolManager.getCachePool(code).getObject(key);
    }
}