实现缓存功能

水深无声 2022-08-03 11:38 190阅读 0赞

1、缓存 
 CacheBean.getIntance(); 
 package com.comName.epg.cache.aop; 
 
import java.util.HashMap; 
import java.util.Map; 
import java.util.Set; 
import java.util.Map.Entry; 
 
import org.apache.log4j.Logger; 
 
import com.comName.epg.cache.manager.IEpgCacheManager; 
 
/\*\* 
 \* 内容摘要：将缓存操作类注册 
 \* 编码作者： 
 \* 完成日期： 
 \*/ 
public class CacheBean 
\{ 
    private  static Map<String, IEpgCacheManager> map = new HashMap<String, IEpgCacheManager>(); 
     
    private static final Logger logger = Logger.getLogger(CacheBean.class); 
     
    private static CacheBean instance = new CacheBean(); 
 
    // 注册需要处理的拦截处理类 
 
    /\*\* 
     \* resourceDao拦截类常量 
     \*/ 
    public static final String CHANNEL\_DAO = "com.comName.epg.dao.tv.IChannelDao"; 
 
    /\*\* 
     \* programDao拦截类常量 
     \*/ 
    public static final String PROGRAM\_DAO = "com.comName.epg.dao.tv.IProgramDao"; 
 
    /\*\* 
     \* catalogDao拦截类常量 
     \*/ 
    public static final String CATALOG\_DAO = "com.comName.epg.dao.mod.ICatalogDao"; 
 
    /\*\* 
     \* productOfferingDao拦截类常量 
     \*/ 
    public static final String PRODUCT\_OFFERING\_DAO = "com.comName.epg.dao.mod.IProductOfferingDao"; 
 
    /\*\* 
     \* resourceDao拦截类常量 
     \*/ 
    public static final String RESOURCE\_DAO = "com.comName.epg.dao.mod.IResourceDaoNew"; 
 
    /\*\* 
     \* parameterDao拦截类常量 
     \*/ 
    public static final String PARAMETER\_DAO = "com.comName.epg.dao.parameter.IParameterDao"; 
 
    /\*\* 
     \* com.comName.aaa.dao.impl.jdbc2.ChannelDao拦截常量 
     \*/ 
    public static final String WSCHANNEL\_DAO = "com.comName.aaa.dao.IChannelDao"; 
 
    /\*\* 
     \* com.comName.aaa.dao.impl.jdbc2.ChannelDao拦截常量 
     \*/ 
    // public static final String WSAUTHORITY\_DAO = 
    // "com.comName.aaa.dao.IAuthorityDao"; 
    /\*\* 
     \* com.comName.aaa.dao.impl.jdbc2.ChannelDao拦截常量 
     \*/ 
    public static final String WSCOMMON\_DAO = "com.comName.aaa.dao.ICommonDao"; 
 
    /\*\* 
     \* com.comName.aaa.dao.impl.jdbc2.ProductDao拦截常量 
     \*/ 
    public static final String WSPRODUCT\_DAO = "com.comName.aaa.dao.IProductDao"; 
 
    public static final String USER\_DAO = "com.comName.aaa.dao.IUserDao"; 
     
    public static final String PROGRAMEXTRAINFO\_DAO = "com.comName.epg.dao.tv.IProgramExtraInfoDao"; 
     
    public static IEpgCacheManager monitorCache; 
     
    private static IEpgCacheManager sessionsCache; 
     
     
    /\*\* 
     \* 私有构造 
     \*/ 
    private CacheBean() 
    \{ 
        init(); 
    \} 
 
    /\*\* 
     \* 初始化 
     \*/ 
    public synchronized static void init() 
    \{ 
        // 将dao拦截处理类在此处注册 
        map.put(CHANNEL\_DAO, new ChannelCache()); 
        map.put(PROGRAM\_DAO, new ProgramCache()); 
        map.put(PARAMETER\_DAO, new ParameterCache()); 
        map.put(CATALOG\_DAO, new CatalogCache()); 
        map.put(PRODUCT\_OFFERING\_DAO, new ProductOfferingCache()); 
        map.put(PROGRAMEXTRAINFO\_DAO, new ProgramExtraInfoCache()); 
        // 此处使用同一个缓存 
        ResourceCache resourceCache = new ResourceCache(); 
        map.put(RESOURCE\_DAO, resourceCache); 
        map.put(WSPRODUCT\_DAO, resourceCache);//addVodPopularForCache 
         
        monitorCache=new MonitorCache(); 
        sessionsCache=new SessionsCache(); 
         
//        map.put(WSCHANNEL\_DAO, new WsChannelCache()); 
//        map.put(WSCOMMON\_DAO, new WsCommonCache()); 
         
         
        // map.put(WSAUTHORITY\_DAO, new WsAuthorityCache()); 
//        map.put(USER\_DAO, new UserCache()); 
    \} 
    public static IEpgCacheManager getMonitorCache() 
    \{ 
        return monitorCache; 
    \} 
     
    public static IEpgCacheManager getSessionsCache() 
    \{ 
        return sessionsCache; 
    \} 
     
 
    /\*\* 
     \* 获取实例 
     \* @return 
     \*/ 
    public static CacheBean getIntance() 
    \{ 
        return instance; 
    \} 
 
    /\*\* 
     \* 获取缓存处理类实例 
     \* @param name 
     \* @return 
     \*/ 
    public IInvoke getInvokeBean(String name) 
    \{ 
        return (IInvoke) map.get(name); 
    \} 
 
    /\*\* 
     \* 获取缓存处理类实例 
     \* @param name 
     \* @return 
     \*/ 
    public IEpgCacheManager getManageBean(String name) 
    \{ 
        return (IEpgCacheManager) map.get(name); 
    \} 
 
    public static Map<String, IEpgCacheManager> getMap() 
    \{ 
        return map; 
    \} 
     
    public static void celarAllCache() 
    \{ 
        logger.info("--------开始清除所有缓存----------"); 
        Set<Entry<String, IEpgCacheManager>> entrySet = map.entrySet(); 
        for (Entry<String, IEpgCacheManager> entry : entrySet) 
        \{ 
            entry.getValue().removeAll(); 
        \} 
        logger.info("--------清除缓存完毕----------"); 
    \} 
\} 
 
package com.comName.epg.cache.manager; 
 
import java.util.List; 
 
/\*\* 
 \* 内容摘要：缓存管理接口 
 \* 编码作者： 
 \* 完成日期： 
 \*/ 
public interface IEpgCacheManager 
\{ 
    public void put(String key, Object value); 
    /\*\* 
     \* 实现功能：清空所有缓存 
     \*/ 
    public void removeAll(); 
 
    /\*\* 
     \* 实现功能：按key值清空缓存 
     \*/ 
    public boolean removeByKey(String key); 
 
    /\*\* 
     \* 实现功能：按模糊key值清空缓存 
     \* 如：removeByFuzzyKey("Channel\_",IEpgCacheManager.START\_WITH)将删除缓存中所有以"Channel\_"开头的key对应的缓存数据 
     \* @param key 查询参数 
     \* @param pattern 可选参数为：START\_WITH，ENDS\_WITH，INCLUDE 
     \* @return 缓存数据删除个数 
     \*/ 
    public int removeByFuzzyKey(String key, int pattern); 
 
    /\*\* 
     \* 实现功能：按表达式key值清空缓存 
     \* 如：removeByPatternKey("Channel\_\\\\w\*")将删除缓存中所有以"Channel\_"开头的key对应的缓存数据 
     \* @param patternKey 表达式字符串 
     \* @return 缓存数据删除个数 
     \*/ 
    public int removeByPatternKey(String patternKey); 
 
    /\*\* 
     \* 实现功能：获得所有的缓存对象的key 
     \*/ 
    public List getAllKeys(); 
 
    /\*\* 
     \* 实现功能：根据缓存对象的key获取缓存对象 
     \*/ 
    public Object getObjectByKey(String key); 
 
    public void flush(); 
     
    /\*\* 
     \* 缓存中的key值以参数字符串开头 
     \*/ 
    public static final int START\_WITH = 1; 
 
    /\*\* 
     \* 缓存中的key值以参数字符串结尾 
     \*/ 
    public static final int ENDS\_WITH = 2; 
 
    /\*\* 
     \* 缓存中的key值包含参数字符串中的字符 
     \*/ 
    public static final int INCLUDE = 3; 
     
    public int getSize(); 
\} 
 
 
package com.comName.epg.cache.aop; 
 
import org.aopalliance.intercept.MethodInvocation; 
 
import com.comName.epg.model.Catalog; 
 
/\*\* 
 \* 内容摘要：商品查询dao拦截实现 
 \* 编码作者： 
 \* 完成日期： 
 \*/ 
public class CatalogCache extends AbstractCache 
\{ 
 
    private static final String service\_code = "ServiceCode\_"; 
 
    /\*\* 
     \* 通过catalog对象的id保存数据的前缀 
     \*/ 
    public static final String CATALOG\_PRE = "CATALOG\_"; 
 
    /\*\* 
     \* 通过catalog对象的serviceCode保存数据的前缀 
     \*/ 
    public static final String CATALOG\_SERVICE\_CODE\_PRE = CATALOG\_PRE + service\_code; 
 
    /\*\* 
     \* 保存子栏目List的前缀 
     \*/ 
    public static final String SUB\_CATALOG\_PRE = CATALOG\_PRE + symbol\_objs; 
 
    /\*\* 
     \* 根据上架ID查询栏目信息，保存至缓存 
     \*/ 
    public static final String CATALOG\_RESOURCE = "catalog\_resource\_"; 
 
    protected CatalogCache() 
    \{ 
        super("CatalogCache"); 
    \} 
 
    protected MethodProcess parseMethodProcess(MethodInvocation invocation) 
    \{ 
        MethodProcess process = new MethodProcess(); 
        String methodName = invocation.getMethod().getName(); 
        Object\[\] argument = invocation.getArguments(); 
 
        if (querySubCatalogs.equals(methodName)) 
        \{ 
            process.setMethodType(MethodProcessType.getObjectListByParamType); 
            process.setCacheKey(SUB\_CATALOG\_PRE + String.valueOf(argument\[0\])); 
            process.setSaveEmptyList(true); 
            //TODO 增加子栏目时刷新 
        \} 
        else if (getCatalog.equals(methodName)) 
        \{ 
            process.setMethodType(MethodProcessType.getObjectByIdType); 
            process.setCacheKey(CATALOG\_PRE + String.valueOf(argument\[0\])); 
        \} 
        else if (queryCatalogByServiceCode.equals(methodName)) 
        \{ 
            process.setMethodType(MethodProcessType.getObjectByIdType); 
            process.setCacheKey(CATALOG\_SERVICE\_CODE\_PRE + String.valueOf(argument\[0\])); 
            // serviceCode对应的key，保存的是栏目的缓存key 
            process.setCacheObjectReference(true); 
        \} 
//        else if (queryCatalogByCatalogResourceId.equals(methodName)) 
//        \{ 
//            process.setMethodType(MethodProcessType.getObjectByIdType); 
//            process.setCacheKey(CATALOG\_PRE + CATALOG\_RESOURCE + String.valueOf(argument\[0\])); 
//        \} 
        //add by sunwen 
        else if(queryCatalogIdForRes.equals(methodName))\{ 
            //根据资源找上架栏目id  栏目上架时/下架时 刷新 
            process.setMethodType(MethodProcessType.getObjectListByParamType); 
            process.setCacheKey(queryCatalogIdForRes+"\_"+argument\[0\]); 
            process.setCacheSingleResult(false); 
            process.setSaveEmptyList(true); 
        \} 
        return process; 
    \} 
 
    protected String getModelKey(Object obj, MethodInvocation invocation) 
    \{ 
        return CATALOG\_PRE + String.valueOf(((Catalog) obj).getId()); 
    \} 
 
    private static final String querySubCatalogs = "querySubCatalogs"; 
 
    private static final String getCatalog = "getCatalog"; 
 
    private static final String queryCatalogByServiceCode = "queryCatalogByServiceCode"; 
 
//    private static final String queryCatalogByCatalogResourceId = "queryCatalogByCatalogResourceId"; 
     
    public static final String queryCatalogIdForRes="queryCatalogIdForRes"; 
\} 
 
package com.comName.epg.cache.aop; 
 
import org.aopalliance.intercept.MethodInvocation; 
 
/\*\* 
 \* 内容摘要：dao拦截器接口 
 \* 编码作者： 
 \* 完成日期： 
 \*/ 
public interface IInvoke 
\{ 
    /\*\* 
     \* 实现功能：处理拦截器动作 
     \* 
     \* @param invocation 
     \* @return 
     \* @throws Throwable 
     \*/ 
    public Object invoke(MethodInvocation invocation) throws Throwable; 
\} 
 
package com.comName.epg.cache.aop; 
 
public final class MethodProcess 
\{ 
    /\*\* 
     \* 缓存key，或单个缓存对象的key前缀，默认值为null，此时不会拦截 
     \*/ 
    private String cacheKey = null; 
 
    /\*\* 
     \* 方法类型 
     \*/ 
    private int methodType = MethodProcessType.typeUndefined; 
 
    /\*\* 
     \* 判断getObjectListById方法，获取的对象集合后，是否缓存单个集合对象 
     \*/ 
    private boolean isCacheSingleResult = true; 
     
    /\*\* 
     \* getObjectById方法，不是通过ID缓存的数据，此时是否缓存对象的key值 
     \* 默认为不缓存，直接保存原数据。为true时，缓存对象和对象的缓存key 
     \*/ 
    private boolean isCacheObjectReference = false; 
     
    /\*\* 
     \* getObjectListByParamType 
     \* 是否保存空的集合 
     \*/ 
    private boolean isSaveEmptyList=false; 
     
    public int getMethodType() 
    \{ 
        return methodType; 
    \} 
 
    public void setMethodType(int methodType) 
    \{ 
        this.methodType = methodType; 
    \} 
 
    public String getCacheKey() 
    \{ 
        return cacheKey; 
    \} 
 
    public void setCacheKey(String cacheKey) 
    \{ 
        this.cacheKey = cacheKey; 
    \} 
 
    public boolean isCacheSingleResult() 
    \{ 
        return isCacheSingleResult; 
    \} 
 
    public void setCacheSingleResult(boolean isCacheSingleResult) 
    \{ 
        this.isCacheSingleResult = isCacheSingleResult; 
    \} 
 
    public boolean isCacheObjectReference() 
    \{ 
        return isCacheObjectReference; 
    \} 
 
    public void setCacheObjectReference(boolean isCacheObjectReference) 
    \{ 
        this.isCacheObjectReference = isCacheObjectReference; 
    \} 
 
    public boolean isSaveEmptyList() 
    \{ 
        return isSaveEmptyList; 
    \} 
 
    public void setSaveEmptyList(boolean isSaveEmptyList) 
    \{ 
        this.isSaveEmptyList = isSaveEmptyList; 
    \} 
 
\} 
 
package com.comName.epg.model; 
 
import java.io.Serializable; 
import java.util.List; 
 
public class Catalog implements Serializable 
\{ 
 
    private Integer id; 
 
    private String name; 
 
    private String serviceCode; 
 
    private String description; 
 
    private Integer ordinal; 
 
    private Integer parentCatalogId; 
 
    private List<Poster> posters; // 海报路径 
 
    private int recommendCount; 
 
    private int resourceCount;// 栏目下的资源总数 
 
    private Integer saleType; 
 
    private String resourceId; 
 
    private String goodsId; 
     
    private List<Catalog> subCatalogList; 
     
    private List<ProductResource> resourceList; 
     
    private Integer isMonthColOnePay=1; 
     
    public Integer getIsMonthColOnePay() 
    \{ 
        return isMonthColOnePay; 
    \} 
 
    public void setIsMonthColOnePay(Integer isMonthColOnePay) 
    \{ 
        this.isMonthColOnePay = isMonthColOnePay; 
    \} 
 
    public List<ProductResource> getResourceList() 
    \{ 
        return resourceList; 
    \} 
 
    public void setResourceList(List<ProductResource> resourceList) 
    \{ 
        this.resourceList = resourceList; 
    \} 
 
    public List<Catalog> getSubCatalogList() 
    \{ 
        return subCatalogList; 
    \} 
 
    public void setSubCatalogList(List<Catalog> subCatalogList) 
    \{ 
        this.subCatalogList = subCatalogList; 
    \} 
 
    public String getGoodsId() 
    \{ 
        return goodsId; 
    \} 
 
    public void setGoodsId(String goodsId) 
    \{ 
        this.goodsId = goodsId; 
    \} 
 
    public String getResourceId() 
    \{ 
        return resourceId; 
    \} 
 
    public void setResourceId(String resourceId) 
    \{ 
        this.resourceId = resourceId; 
    \} 
 
    public Integer getSaleType() 
    \{ 
        return saleType; 
    \} 
 
    public void setSaleType(Integer saleType) 
    \{ 
        this.saleType = saleType; 
    \} 
 
    public Integer getId() 
    \{ 
        return id; 
    \} 
 
    public void setId(Integer id) 
    \{ 
        this.id = id; 
    \} 
 
    public String getName() 
    \{ 
        return GBKfilter.filter(name); 
    \} 
 
    public void setName(String name) 
    \{ 
        this.name = name; 
    \} 
 
    public String getServiceCode() 
    \{ 
        return serviceCode; 
    \} 
 
    public void setServiceCode(String serviceCode) 
    \{ 
        this.serviceCode = serviceCode; 
    \} 
 
    public String getDescription() 
    \{ 
        return GBKfilter.filter(description); 
    \} 
 
    public void setDescription(String description) 
    \{ 
        this.description = description; 
    \} 
 
    public Integer getOrdinal() 
    \{ 
        return ordinal; 
    \} 
 
    public void setOrdinal(Integer ordinal) 
    \{ 
        this.ordinal = ordinal; 
    \} 
 
    public Integer getParentCatalogId() 
    \{ 
        return parentCatalogId; 
    \} 
 
    public void setParentCatalogId(Integer parentCatalogId) 
    \{ 
        this.parentCatalogId = parentCatalogId; 
    \} 
 
    public List<Poster> getPosters() 
    \{ 
        return posters; 
    \} 
 
    public void setPosters(List<Poster> posters) 
    \{ 
        this.posters = posters; 
    \} 
 
    public int getRecommendCount() 
    \{ 
        return recommendCount; 
    \} 
 
    public void setRecommendCount(int recommendCount) 
    \{ 
        this.recommendCount = recommendCount; 
    \} 
 
    public int getResourceCount() 
    \{ 
        return resourceCount; 
    \} 
 
    public void setResourceCount(int resourceCount) 
    \{ 
        this.resourceCount = resourceCount; 
    \} 
 
\} 
 
/\* 
 \* To change this template, choose Tools | Templates 
 \* and open the template in the editor. 
 \*/ 
 
package com.comName.common; 
 
/\*\* 
 \* 
 \* @author 903274 
 \*/ 
public class AppRuntimeException extends RuntimeException \{ 
 
    private EnumPower errorInfo = null; 
     
    private String errorCode; 
     
    private String errorMessage; 
     
    public String getErrorMessage() 
    \{ 
        return errorMessage; 
    \} 
 
 
 
    public String getErrorCode() \{ 
        return this.errorCode; 
    \} 
     
    private void setErrorMessage(String errorCode, String errorMessage) 
    \{ 
        this.errorCode=errorCode; 
        this.errorMessage=errorMessage; 
    \} 
     
    public AppRuntimeException(String errorCode, String message) \{ 
        super(message); 
        setErrorMessage(errorCode, message); 
    \} 
     
     
    public AppRuntimeException(EnumPower errorInfo) \{ 
        super(errorInfo.toString()); 
        this.errorInfo = errorInfo; 
        setErrorMessage(errorInfo.getCode(), errorInfo.getTitle()); 
    \} 
 
    public AppRuntimeException(EnumPower errorInfo, Throwable cause) \{ 
        super(errorInfo.toString(), cause); 
        this.errorInfo = errorInfo; 
        setErrorMessage(errorInfo.getCode(), errorInfo.getTitle()); 
    \} 
 
    public AppRuntimeException(AppRuntimeException appException) \{ 
        this(appException.getErrorInfo(), appException.getCause()); 
    \} 
    public AppRuntimeException(String appException)\{        
        super(appException); 
    \} 
 
    public EnumPower getErrorInfo() \{ 
        return this.errorInfo; 
    \} 
 
\} 
 
 
package com.comName.common; 
 
 
import java.util.\*; 
 
import com.comName.common.EnumPower; 
 
/\*\* 
 \* Title: tvboss 
 \* 
 \* Description: 业务运营支撑系统 
 \* 
 \* Copyright: Copyright (c) 
 \* 
 \* Company: clong 
 \* 
 \* @author 
 \* @version 3.0 
 \*/ 
public enum CommInfo implements EnumPower \{ 
    SUCCESS("0000", "成功"), 
    FAILURE("0001", "失败"),     
    VERSION\_INVALID("0002", "版本信息无效"), 
    PARA\_VALUE\_IS\_NULL("0003", "参数值为空"), 
    PARA\_PATTERN\_INVALID("0004", "参数格式不正确"),      
    UNKONWN\_HOST("0005", "未找到目标主机，请检查网络配置"), 
    UNKONWN\_PROT("0006", "服务未启动，或端口有改动，请检查网络配置"), 
    SOCKET\_TIME\_OUT("0007", "网络连接超时，请检查网络"), 
    IO\_EXCEPTION("0008", "网络通讯异常，请检查网络"),    
    BOSS\_SERVER\_RUN\_WRONG("0009","系统忙，请稍后再试！BOSS服务运行异常"),   
    NO\_DATA("0010","数据不存在"), 
    DATABASE\_EXCEPTION("0011","数据库异常"), 
    JAXB\_EXCEPTION("0012","文档解析异常"), 
    WRONG\_DTO("0013", "传输对象有误"),    
    CLONE\_ERROR("0014", "克隆对象出错"), 
    SYSTEM\_PARAMETER("0015", "查找系统参数失败"), 
    START\_TIME\_IS\_NULL("0016", "起始播放时间不能为空"), 
    UNKNOWN("0099","未知异常"),     
    INVALID\_CACHE("0018", "缓存异常"), 
    INVALID\_PROGRAM("0019", "节目单无效"), 
    INVALID\_CHANNEL("0020", "频道无效"), 
    DEFAULT\_ERROR("-1", "网络繁忙，请稍后再试"), 
    SUCCESS\_ZERO("0", "成功") 
    ; 
       ; 
 
    private String code = null; 
    private String title = null; 
    private static Hashtable<String, CommInfo> aliasEnums; 
 
    CommInfo(String code, String title) \{ 
        this.init(code, title); 
    \} 
 
    @SuppressWarnings("unchecked") 
    private void init(String code, String title) \{ 
        this.code = code; 
        this.title = title; 
        synchronized (this.getClass()) \{ 
            if (aliasEnums == null) \{ 
                aliasEnums = new Hashtable(); 
            \} 
        \} 
        aliasEnums.put(code, this); 
        aliasEnums.put(title, this); 
    \} 
 
    public static CommInfo valueOfAlias(String alias) \{ 
        return aliasEnums.get(alias); 
    \} 
 
    public static CommInfo valueOfAlias(char alias) \{ 
        return aliasEnums.get(String.valueOf(alias)); 
    \} 
 
    public String getCode() \{ 
        return this.code; 
    \} 
 
    public char getChar() \{ 
        return this.code.charAt(0); 
    \} 
 
    public String getTitle() \{ 
        return this.title; 
    \} 
 
    /\*\* 
     \* 信息描述 
     \* @return String 
     \*/ 
    @Override 
    public String toString() \{ 
        return this.getTitle() + "〔信息代码：" + this.getCode() + "〕"; 
    \} 
\} 
 
 
/\* 
 \* EnumObject.java 
 \* 
 \* Created on 2007-8-26, 20:40:49 
 \* 
 \* To change this template, choose Tools | Templates 
 \* and open the template in the editor. 
 \*/ 
 
package com.comName.common; 
 
/\*\* 
 \* 
 \* @author Administrator 
 \*/ 
public interface EnumPower \{ 
    public String getCode(); 
     
    public char getChar(); 
 
    public String getTitle(); 
 
    public String name(); 
 
    public int ordinal(); 
 
    public String toString(); 
\} 
 
package com.comName.epg.cache.manager; 
 
import java.util.List; 
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 
 
import net.sf.ehcache.Cache; 
import net.sf.ehcache.CacheManager; 
import net.sf.ehcache.Element; 
import net.sf.ehcache.Statistics; 
import net.sf.ehcache.cluster.CacheCluster; 
import net.sf.ehcache.cluster.ClusterNode; 
import net.sf.ehcache.cluster.ClusterScheme; 
import net.sf.ehcache.cluster.ClusterTopologyListener; 
 
import org.apache.log4j.Logger; 
 
/\*\* 
 \* 内容摘要：ehcach缓存封装 
 \* 编码作者： 
 \* 完成日期： 
 \*/ 
public class EpgCache implements IEpgCache 
\{ 
    private static final Logger log = Logger.getLogger(EpgCache.class); 
    // ehcache缓存实例 
    private static CacheManager manager; 
 
    // ehcache缓存的一个具体的缓存块 
    private Cache cache; 
     
    private static  boolean cacheStatus=true; 
     
    static \{ 
        init(); 
    \} 
     
    private static synchronized void init() 
    \{ 
            manager=CacheManager.getInstance(); 
         
    \} 
     
    public static synchronized void restart()throws Exception 
    \{ 
        if(manager!=null) 
        \{ 
            manager.shutdown(); 
        \} 
        init(); 
    \} 
  
     
    public static boolean getCacheStatus() 
    \{ 
        return cacheStatus; 
    \} 
 
    public static void setCacheStatus(boolean cacheStatus) 
    \{ 
            EpgCache.cacheStatus = cacheStatus; 
    \} 
 
    /\*\* 
     \* 构造函数 
     \* @param name 
     \*/ 
    public EpgCache(String name) 
    \{ 
        cache = manager.getCache(name); 
    \} 
 
    /\*\* 
     \* 实现功能：将对象从缓存中取出 
     \* @param key 
     \* @return 
     \*/ 
    public Object get(String key) 
    \{ 
        Element e = cache.getQuiet(key); 
        if (e != null) 
        \{ 
            return e.getObjectValue(); 
        \} 
        return null; 
    \} 
 
    /\*\* 
     \* 实现功能：获得所有的缓存对象的key 
     \*/ 
    public List getAllKeys() 
    \{ 
        return cache.getKeys(); 
    \} 
 
    /\*\* 
     \* 实现功能：将对象加入缓存 
     \* @param key 
     \* @param value 
     \*/ 
    public void put(String key, Object value) 
    \{ 
        //cache.remove(key); 
//        cache.putQuiet(new Element(key, value)); 
        cache.put(new Element(key, value)); 
    \} 
 
    /\*\* 
     \* 实现功能：清空缓存中所有数据 
     \*/ 
    public void removeAll() 
    \{ 
        cache.removeAll(); 
    \} 
 
    /\*\* 
     \* 按对应的key值清空对应缓存 
     \*/ 
    public boolean removeByKey(String key) 
    \{ 
        return cache.removeQuiet(key); 
    \} 
 
    /\*\* 
     \* 实现功能：按模糊key值清空缓存 
     \* 如：removeByFuzzyKey("Channel\_",IEpgCacheManager.START\_WITH)将删除缓存中所有以"Channel\_"开头的key对应的缓存数据 
     \* @param key 查询参数 
     \* @param pattern 可选参数为：START\_WITH，ENDS\_WITH，INCLUDE 
     \* @return 缓存数据删除个数 
     \*/ 
    public int removeByFuzzyKey(String key, int pattern) 
    \{ 
        // 记录删除缓存的个数 
        int count = 0; 
        // 得到所有的key 
        List keyList = cache.getKeys(); 
        switch (pattern) 
        \{ 
            // 以匹配字符串开头 
            case IEpgCacheManager.START\_WITH: 
                count = removeStartsWith(keyList, key); 
                break; 
            // 以匹配字符串结尾 
            case IEpgCacheManager.ENDS\_WITH: 
                count = removeEndsWith(keyList, key); 
                break; 
            // 包含匹配字符串 
            case IEpgCacheManager.INCLUDE: 
                count = removeInclude(keyList, key); 
                break; 
            // 都不是 
            default: 
                break; 
        \} 
        return count; 
    \} 
 
    /\*\* 
     \* 删除以指定字符开头的key在缓存中的数据 
     \* @param keyList 
     \* @param key 
     \* @return 
     \*/ 
    private int removeStartsWith(List keyList, String key) 
    \{ 
        int count = 0; 
        for (Object keyTemp:keyList) 
        \{ 
//            String keyTemp = (String) keyList.get(i); 
            if (keyTemp != null && ((String)keyTemp).startsWith(key)) 
            \{ 
                cache.removeQuiet(keyTemp); 
                count++; 
            \} 
        \} 
        return count; 
    \} 
 
    /\*\* 
     \* 删除以指定字符结尾的key在缓存中的数据 
     \* @param keyList 
     \* @param key 
     \* @return 
     \*/ 
    private int removeEndsWith(List keyList, String key) 
    \{ 
        int count = 0; 
        for (int i = 0; i < keyList.size(); i++) 
        \{ 
            String keyTemp = (String) keyList.get(i); 
            if (keyTemp != null && keyTemp.endsWith(key)) 
            \{ 
                cache.removeQuiet(keyTemp); 
                count++; 
            \} 
        \} 
        return count; 
    \} 
 
    /\*\* 
     \* 删除以指定字符包含在key中在缓存的数据 
     \* @param keyList 
     \* @param key 
     \* @return 
     \*/ 
    private int removeInclude(List keyList, String key) 
    \{ 
        int count = 0; 
        for (int i = 0; i < keyList.size(); i++) 
        \{ 
            String keyTemp = (String) keyList.get(i); 
            if (keyTemp != null && keyTemp.indexOf(key) != -1) 
            \{ 
                cache.removeQuiet(keyTemp); 
                count++; 
            \} 
        \} 
        return count; 
    \} 
 
    /\*\* 
     \* 实现功能：按表达式key值清空缓存 
     \* 如：removeByPatternKey("Channel\_\\\\w\*")将删除缓存中所有以"Channel\_"开头的key对应的缓存数据 
     \* @param patternKey 表达式字符串 
     \* @return 缓存数据删除个数 
     \*/ 
    public int removeByPatternKey(String patternKey) 
    \{ 
        // 记录删除缓存的个数 
        int count = 0; 
        // 得到所有的key 
        List keyList = cache.getKeys(); 
        Pattern pattern = Pattern.compile(patternKey); 
        Matcher matcher = null; 
        for (int i = 0; i < keyList.size(); i++) 
        \{ 
            String keyTemp = (String) keyList.get(i); 
            // 判断key值是否匹配正则表达式 
            matcher = pattern.matcher(keyTemp); 
            if (matcher.matches()) 
            \{ 
                cache.removeQuiet(keyTemp); 
                count++; 
            \} 
        \} 
        return count; 
    \} 
     
    public Statistics getStatistics() 
    \{ 
        return cache.getStatistics(); 
    \} 
     
    @Override 
    public void flush() 
    \{ 
        cache.flush(); 
    \} 
     
    @Override 
    public int getSize() 
    \{ 
       return cache.getSize(); 
    \} 
     
    @Deprecated 
    private static void addTopologyListener() 
    \{ 
        CacheCluster cluster =manager.getCluster(ClusterScheme.TERRACOTTA); 
        cluster.addTopologyListener(new ClusterTopologyListener() 
        \{ 
            public void nodeJoined(ClusterNode node) 
            \{ 
                setCacheStatus(true); 
                log.info(node + " joined"); 
            \} 
            public void clusterRejoined(ClusterNode node, ClusterNode newNode) 
            \{ 
                setCacheStatus(true); 
                log.info(node + " rejoined the cluster as " + newNode); 
            \} 
            public void clusterOnline(ClusterNode node) 
            \{ 
                setCacheStatus(true); 
                log.info(node + " enabled"); 
            \} 
            public void nodeLeft(ClusterNode node) 
            \{ 
                setCacheStatus(false); 
                log.error(node + " left"); 
            \} 
 
            public void clusterOffline(ClusterNode node) 
            \{ 
                setCacheStatus(false); 
                log.error(node + " disabled"); 
            \} 
 
        \}); 
    \} 
 
    public Cache getCache() 
    \{ 
        return cache; 
    \} 
     
\} 
 
package com.comName.epg.cache.manager; 
 
import java.util.List; 
 
/\*\* 
 \* 内容摘要：缓存数据接口 
 \* 编码作者： 
 \* 完成日期： 
 \*/ 
public interface IEpgCache 
\{ 
    /\*\* 
     \* 实现功能：将对象加入缓存 
     \* @param key 
     \* @param value 
     \*/ 
    public void put(String key, Object value); 
 
    /\*\* 
     \* 实现功能：将对象从缓存中取出 
     \* @param key 
     \* @return 
     \*/ 
    public Object get(String key); 
 
    /\*\* 
     \* 实现功能：获得所有的缓存对象的key 
     \*/ 
    public List getAllKeys(); 
 
    /\*\* 
     \* 实现功能：清空缓存中所有数据 
     \*/ 
    public void removeAll(); 
 
    /\*\* 
     \* 实现功能：按对应的key值清空对应缓存 
     \*/ 
    public boolean removeByKey(String key); 
 
    /\*\* 
     \* 实现功能：按模糊key值清空缓存 
     \* 如：removeByFuzzyKey("Channel\_",IEpgCacheManager.START\_WITH)将删除缓存中所有以"Channel\_"开头的key对应的缓存数据 
     \* @param key 查询参数 
     \* @param pattern 可选参数为：START\_WITH，ENDS\_WITH，INCLUDE 
     \* @return 缓存数据删除个数 
     \*/ 
    public int removeByFuzzyKey(String key, int pattern); 
 
    /\*\* 
     \* 实现功能：按表达式key值清空缓存 
     \* 如：removeByPatternKey("Channel\_\\\\w\*")将删除缓存中所有以"Channel\_"开头的key对应的缓存数据 
     \* @param patternKey 表达式字符串 
     \* @return 缓存数据删除个数 
     \*/ 
    public int removeByPatternKey(String patternKey); 
     
    public void flush(); 
     
     
    int getSize(); 
     
\} 
 
package com.comName.epg.cache.manager; 
 
import java.util.List; 
 
import org.apache.log4j.Logger; 
 
import com.comName.common.cache.Cache; 
import com.comName.common.cache.CacheManager; 
 
public class Xmemcache implements IEpgCache 
\{ 
    private static Cache cache = CacheManager.getInstance().getCache(); 
     
    private static final Logger log = Logger.getLogger(Xmemcache.class); 
     
    public Object get(String key) 
    \{ 
        return cache.get(key); 
    \} 
 
    public List getAllKeys() 
    \{ 
        return null; 
    \} 
 
    public void flush() 
    \{ 
      cache.flushAll();         
    \} 
     
    public void put(String key, Object value) 
    \{ 
        boolean flag = cache.set(key, value); 
        if(!flag) 
        \{ 
         log.warn("put cache fail:"+key+" value="+value);    
        \}else\{ 
            log.debug("put cache success:"+key+" value="+value);    
        \} 
    \} 
 
    public void removeAll() 
    \{ 
        cache.flushAll(); 
    \} 
 
    public int removeByFuzzyKey(String key, int pattern) 
    \{ 
        return 0; 
    \} 
 
    public boolean removeByKey(String key) 
    \{ 
        try 
        \{ 
            return cache.delete(key); 
        \} 
        catch (Exception e) 
        \{ 
            e.printStackTrace(); 
        \} 
        return false; 
    \} 
 
    public int removeByPatternKey(String patternKey) 
    \{ 
        //TODO 
        return 0; 
    \} 
 
    public boolean getCacheStatus() 
    \{ 
        //TODO 
        return true; 
    \} 
 
    @Override 
    public int getSize() 
    \{ 
        //TODO 
        return 0; 
    \} 
 
\} 
 
// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov. 
// Jad home page: http://www.kpdus.com/jad.html 
// Decompiler options: packimports(3) radix(10) lradix(10) 
// Source File Name:   Cache.java 
 
package com.comName.common.cache; 
 
import java.io.IOException; 
import java.net.InetSocketAddress; 
import java.util.Map; 
 
public interface Cache 
\{ 
 
    public abstract boolean add(String s, Object obj); 
 
    public abstract void addServer(String s, int i, int j); 
 
    public abstract boolean append(String s, Object obj); 
 
    public abstract boolean delete(String s); 
 
    public abstract void flushAll(); 
 
    public abstract void flushAll(InetSocketAddress inetsocketaddress); 
 
    public abstract boolean isShutdown(); 
 
    public abstract void shutdown() 
        throws IOException; 
 
    public abstract Map stats(InetSocketAddress inetsocketaddress); 
 
    public abstract void removeServer(String s); 
 
    public abstract boolean replace(String s, Object obj); 
 
    public abstract boolean set(String s, Object obj); 
 
    public abstract Object get(String s); 
 
    public abstract Map getStats(); 
\} 
 
// Messages from Jad: 
// The class file version is 50.0 (only 45.3, 46.0 and 47.0 are supported) 
// 
 
// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov. 
// Jad home page: http://www.kpdus.com/jad.html 
// Decompiler options: packimports(3) radix(10) lradix(10) 
// Source File Name:   CacheManager.java 
 
package com.comName.common.cache; 
 
import com.comName.common.cache.config.ConfigFileTool; 
import com.comName.common.cache.xmemcache.CacheImp; 
import java.io.IOException; 
import java.io.PrintStream; 
import net.rubyeye.xmemcached.\*; 
import net.rubyeye.xmemcached.impl.KetamaMemcachedSessionLocator; 
import net.rubyeye.xmemcached.utils.AddrUtil; 
import org.apache.log4j.Logger; 
 
// Referenced classes of package com.comName.common.cache: 
//            Cache 
 
public class CacheManager 
\{ 
 
    private CacheManager() 
    \{ 
        cache = null; 
        try 
        \{ 
            init(); 
        \} 
        catch(Exception ex) 
        \{ 
            log.error((new StringBuilder("\\u521D\\u59CB\\u5316\\u7F13\\u5B58\\u5931\\u8D25\\uFF01")).append(ex).toString()); 
            ex.printStackTrace(); 
        \} 
    \} 
 
    public static CacheManager getInstance() 
    \{ 
        return instance; 
    \} 
 
    private synchronized void init() 
        throws IOException 
    \{ 
        try 
        \{ 
            ConfigFileTool config = new ConfigFileTool(); 
            String servers = config.getProperty(ConfigFileTool.SYSCONFIG, "memcacheServers"); 
            String connPoolSize = config.getProperty(ConfigFileTool.SYSCONFIG, "memcacheConnPoolSize"); 
            String weight = config.getProperty(ConfigFileTool.SYSCONFIG, "memcacheWeight"); 
            String getExp = config.getProperty(ConfigFileTool.SYSCONFIG, "memcacheExp"); 
            String cacheOpTimeout = config.getProperty(ConfigFileTool.SYSCONFIG, "memcacheOpTimeout"); 
            String failureModeFlag = config.getProperty(ConfigFileTool.SYSCONFIG, "memcacheFailureMode"); 
            String setTimeOutFile = config.getProperty(ConfigFileTool.SYSCONFIG, "memcacheSetTimeOut"); 
            String getTimeOutFile = config.getProperty(ConfigFileTool.SYSCONFIG, "memcacheGetTimeOut"); 
            System.out.println((new StringBuilder("\\u7F13\\u5B58\\u914D\\u7F6E\\u5982\\u4E0B\\uFF1Aservers=")).append(servers).toString()); 
            log.info((new StringBuilder("\\u7F13\\u5B58\\u914D\\u7F6E\\u5982\\u4E0B\\uFF1Aservers=")).append(servers).toString()); 
            log.info((new StringBuilder("\\u7F13\\u5B58\\u914D\\u7F6E\\u5982\\u4E0B\\uFF1AconnPoolSize=")).append(connPoolSize).toString()); 
            log.info((new StringBuilder("\\u7F13\\u5B58\\u914D\\u7F6E\\u5982\\u4E0B\\uFF1AcacheOpTimeout=")).append(cacheOpTimeout).toString()); 
            setTimeOut = Long.valueOf(Long.parseLong(setTimeOutFile)); 
            getTimeOut = Long.valueOf(Long.parseLong(getTimeOutFile)); 
            exp = Integer.valueOf(getExp); 
            String ininal\[\] = weight.split(" "); 
            int serverWeight\[\] = new int\[ininal.length\]; 
            for(int i = 0; i < ininal.length; i++) 
                serverWeight\[i\] = Integer.parseInt(ininal\[i\]); 
 
            MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddressMap(servers), serverWeight); 
            builder.setSessionLocator(new KetamaMemcachedSessionLocator()); 
            if(failureModeFlag.equals("Y")) 
                builder.setFailureMode(true); 
            else 
                builder.setFailureMode(false); 
            builder.setConnectionPoolSize((new Integer(connPoolSize)).intValue()); 
            MemcachedClient memcachedClient = builder.build(); 
            memcachedClient.setOpTimeout((new Long(cacheOpTimeout)).longValue()); 
            memcachedClient.setMergeFactor(50); 
            memcachedClient.setOptimizeMergeBuffer(false); 
            memcachedClient.setConnectTimeout(2000L); 
            cache = new CacheImp(memcachedClient); 
        \} 
        catch(Exception e) 
        \{ 
            e.printStackTrace(); 
        \} 
    \} 
 
    public Cache getCache() 
    \{ 
        return cache; 
    \} 
 
    public void setCache(Cache cache) 
    \{ 
        this.cache = cache; 
    \} 
 
    public static Long getSetTimeOut() 
    \{ 
        return setTimeOut; 
    \} 
 
    public static void setSetTimeOut(Long setTimeOut) 
    \{ 
        setTimeOut = setTimeOut; 
    \} 
 
    public static Long getGetTimeOut() 
    \{ 
        return getTimeOut; 
    \} 
 
    public static void setGetTimeOut(Long getTimeOut) 
    \{ 
        getTimeOut = getTimeOut; 
    \} 
 
    public static Integer getExp() 
    \{ 
        return exp; 
    \} 
 
    public static void setExp(Integer exp) 
    \{ 
        exp = exp; 
    \} 
 
    private static Logger log = Logger.getLogger(com/comName/common/cache/CacheManager); 
    private static CacheManager instance = new CacheManager(); 
    private Cache cache; 
    private static Long setTimeOut; 
    private static Long getTimeOut; 
    private static Integer exp; 
 
\} 
 
// Messages from Jad: 
// The class file version is 50.0 (only 45.3, 46.0 and 47.0 are supported) 
// 
 
// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov. 
// Jad home page: http://www.kpdus.com/jad.html 
// Decompiler options: packimports(3) radix(10) lradix(10) 
// Source File Name:   ConfigFileTool.java 
 
package com.comName.common.cache.config; 
 
import java.util.\*; 
import org.apache.commons.configuration.ConfigurationException; 
import org.apache.commons.configuration.PropertiesConfiguration; 
import org.apache.log4j.Logger; 
 
public class ConfigFileTool 
\{ 
 
    public ConfigFileTool() 
    \{ 
    \} 
 
    protected synchronized void setProperty(String configName, String key, String value) 
    \{ 
        PropertiesConfiguration targetconfig = (PropertiesConfiguration)configMap.get(configName); 
        targetconfig.setProperty(key, value); 
        try 
        \{ 
            targetconfig.save(); 
        \} 
        catch(ConfigurationException e) 
        \{ 
            e.printStackTrace(); 
        \} 
    \} 
 
    public String getProperty(String configName, String key) 
    \{ 
        PropertiesConfiguration targetConfig = (PropertiesConfiguration)configMap.get(configName); 
        String value = null; 
        if(targetConfig.containsKey(key)) 
        \{ 
            Object property = targetConfig.getProperty(key); 
            if(property instanceof List) 
            \{ 
                List propertylist = (List)property; 
                return (String)propertylist.get(0); 
            \} 
            value = (String)targetConfig.getProperty(key); 
        \} 
        return value; 
    \} 
 
    protected List getKeys(String configName, String prefix) 
    \{ 
        PropertiesConfiguration targetConfig = (PropertiesConfiguration)configMap.get(configName); 
        List prefixlist = new ArrayList(); 
        for(Iterator it = targetConfig.getKeys(); it.hasNext();) 
        \{ 
            String configKey = (String)it.next(); 
            if(configKey.startsWith(prefix)) 
                prefixlist.add(configKey); 
        \} 
 
        return prefixlist; 
    \} 
 
    protected Map getProperties(String configName) 
    \{ 
        PropertiesConfiguration targetConfig = (PropertiesConfiguration)configMap.get(configName); 
        Map propertymap = new HashMap(); 
        String key; 
        for(Iterator it = targetConfig.getKeys(); it.hasNext(); propertymap.put(key, targetConfig.getProperty(key))) 
            key = (String)it.next(); 
 
        return propertymap; 
    \} 
 
    public static String SYSCONFIG; 
    public static String lOG4J; 
    private static Logger log; 
    private static Map configMap; 
 
    static 
    \{ 
        SYSCONFIG = "sysconfig.properties"; 
        lOG4J = "log4j.properties"; 
        log = Logger.getLogger(com/comName/common/cache/config/ConfigFileTool); 
        configMap = new HashMap(); 
        try 
        \{ 
            PropertiesConfiguration sysconfig = new PropertiesConfiguration(SYSCONFIG); 
            configMap.put(SYSCONFIG, sysconfig); 
            log.info((new StringBuilder("\\u52A0\\u8F7D\\u7F13\\u5B58\\u914D\\u7F6E\\u6587\\u4EF6=")).append(sysconfig).toString()); 
            PropertiesConfiguration log4jconfig = new PropertiesConfiguration(lOG4J); 
        \} 
        catch(ConfigurationException ee) 
        \{ 
            log.info("\\u52A0\\u8F7D\\u914D\\u7F6E\\u6587\\u4EF6\\u9519\\u8BEF", ee); 
            ee.printStackTrace(); 
        \} 
    \} 
\} 
 
// Messages from Jad: 
// The class file version is 50.0 (only 45.3, 46.0 and 47.0 are supported) 
// 
 
 
// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov. 
// Jad home page: http://www.kpdus.com/jad.html 
// Decompiler options: packimports(3) radix(10) lradix(10) 
// Source File Name:   CacheImp.java 
 
package com.comName.common.cache.xmemcache; 
 
import com.comName.common.cache.Cache; 
import com.comName.common.cache.CacheManager; 
import java.io.IOException; 
import java.net.InetSocketAddress; 
import java.util.Map; 
import net.rubyeye.xmemcached.MemcachedClient; 
import org.apache.log4j.Logger; 
 
public class CacheImp 
    implements Cache 
\{ 
 
    public CacheImp(MemcachedClient memcachedClient) 
    \{ 
        this.memcachedClient = null; 
        this.memcachedClient = memcachedClient; 
    \} 
 
    public boolean add(String key, Object value) 
    \{ 
        boolean addResult = memcachedClient.add(key, CacheManager.getExp().intValue(), value, CacheManager.getSetTimeOut().longValue()); 
        return addResult; 
        Exception ex; 
        ex; 
        log.info((new StringBuilder("\\u65B0\\u589E\\u7F13\\u5B58\\u5931\\u8D25\\uFF01ex=")).append(ex).toString()); 
        return false; 
    \} 
 
    public void addServer(String server, int port, int weight) 
    \{ 
        try 
        \{ 
            memcachedClient.addServer(server, port, weight); 
        \} 
        catch(IOException e) 
        \{ 
            log.info((new StringBuilder("\\u589E\\u52A0\\u7F13\\u5B58\\u670D\\u52A1\\u5668\\u5931\\u8D25\\uFF01ex=")).append(e).toString()); 
            e.printStackTrace(); 
        \} 
    \} 
 
    public boolean append(String key, Object value) 
    \{ 
        boolean appendResult = memcachedClient.append(key, value, CacheManager.getSetTimeOut().longValue()); 
        return appendResult; 
        Exception ex; 
        ex; 
        log.info((new StringBuilder("\\u8FFD\\u52A0\\u7F13\\u5B58\\u5931\\u8D25\\uFF01ex=")).append(ex).toString()); 
        return false; 
    \} 
 
    public boolean delete(String key) 
    \{ 
        boolean deleteResult = memcachedClient.delete(key, CacheManager.getSetTimeOut().longValue()); 
        return deleteResult; 
        Exception ex; 
        ex; 
        log.info((new StringBuilder("\\u5220\\u9664\\u7F13\\u5B58\\u5931\\u8D25\\uFF01ex=")).append(ex).toString()); 
        return false; 
    \} 
 
    public void flushAll() 
    \{ 
        try 
        \{ 
            memcachedClient.flushAll(); 
        \} 
        catch(Exception e) 
        \{ 
            log.info((new StringBuilder("\\u589E\\u52A0\\u7F13\\u5B58\\u670D\\u52A1\\u5668\\u5931\\u8D25\\uFF01ex=")).append(e).toString()); 
            e.printStackTrace(); 
        \} 
    \} 
 
    public void flushAll(InetSocketAddress address) 
    \{ 
        try 
        \{ 
            memcachedClient.flushAll(address); 
        \} 
        catch(Exception e) 
        \{ 
            log.info((new StringBuilder("\\u5237\\u65B0\\u6307\\u5B9A\\u7F13\\u5B58\\u670D\\u52A1\\u5668\\u5931\\u8D25\\uFF01ex=")).append(e).toString()); 
            e.printStackTrace(); 
        \} 
    \} 
 
    public void shutdown() 
        throws IOException 
    \{ 
        try 
        \{ 
            memcachedClient.shutdown(); 
        \} 
        catch(Exception e) 
        \{ 
            log.info((new StringBuilder("\\u5173\\u95ED\\u7F13\\u5B58\\u670D\\u52A1\\u5668\\u5931\\u8D25\\uFF01ex=")).append(e).toString()); 
            e.printStackTrace(); 
        \} 
    \} 
 
    public boolean isShutdown() 
    \{ 
        boolean ifShudownResult = memcachedClient.isShutdown(); 
        return ifShudownResult; 
        Exception ex; 
        ex; 
        log.info((new StringBuilder("\\u65AD\\u7F13\\u5B58\\u670D\\u52A1\\u5668\\u662F\\u5426\\u5173\\u95ED\\u5931\\u8D25\\uFF01ex=")).append(ex).toString()); 
        return false; 
    \} 
 
    public Map stats(InetSocketAddress address) 
    \{ 
        Map getResult = memcachedClient.stats(address); 
        return getResult; 
        Exception ex; 
        ex; 
        log.info((new StringBuilder("\\u7EDF\\u8BA1\\u7F13\\u5B58\\u670D\\u52A1\\u5668\\u72B6\\u6001\\uFF01ex=")).append(ex).toString()); 
        ex.printStackTrace(); 
        return null; 
    \} 
 
    public void removeServer(String hostList) 
    \{ 
        try 
        \{ 
            memcachedClient.removeServer(hostList); 
        \} 
        catch(Exception ex) 
        \{ 
            log.info((new StringBuilder("\\u5220\\u9664\\u7F13\\u5B58\\u5931\\u8D25\\uFF01ex=")).append(ex).toString()); 
        \} 
    \} 
 
    public boolean replace(String key, Object value) 
    \{ 
        boolean replaceResult = memcachedClient.replace(key, CacheManager.getExp().intValue(), CacheManager.getSetTimeOut()); 
        return replaceResult; 
        Exception ex; 
        ex; 
        log.info((new StringBuilder("\\u66FF\\u6362\\u7F13\\u5B58\\u5931\\u8D25\\uFF01ex=")).append(ex).toString()); 
        return false; 
    \} 
 
    public boolean set(String key, Object value) 
    \{ 
        boolean result = memcachedClient.set(key, CacheManager.getExp().intValue(), value, CacheManager.getSetTimeOut().longValue()); 
        return result; 
        Exception ex; 
        ex; 
        log.info((new StringBuilder("\\u653E\\u5165\\u7F13\\u5B58\\u5931\\u8D25xxx-key:")).append(key).append(",value=").append(value.toString()).append(" ex=").append(ex).toString()); 
        ex.printStackTrace(); 
        return false; 
    \} 
 
    public Object get(String key) 
    \{ 
        Object getResult = memcachedClient.get(key, CacheManager.getGetTimeOut().longValue()); 
        return getResult; 
        Exception ex; 
        ex; 
        log.info((new StringBuilder("xxx\\u8BFB\\u53D6\\u7F13\\u5B58\\u5931\\u8D25-key:")).append(key).append(" ex=").append(ex).toString()); 
        ex.printStackTrace(); 
        return null; 
    \} 
 
    public Map getStats() 
    \{ 
        Map getResult = memcachedClient.getStats(); 
        return getResult; 
        Exception ex; 
        ex; 
        log.info((new StringBuilder("\\u83B7\\u53D6\\u670D\\u52A1\\u5668\\u72B6\\u6001\\u5931\\u8D25\\uFF01ex=")).append(ex).toString()); 
        ex.printStackTrace(); 
        return null; 
    \} 
 
    private MemcachedClient memcachedClient; 
    private static Logger log = Logger.getLogger(com/comName/common/cache/CacheManager); 
 
\} 
 
// Messages from Jad: 
// The class file version is 50.0 (only 45.3, 46.0 and 47.0 are supported) 
// Couldn't fully decompile method add 
// Couldn't resolve all exception handlers in method add 
// Couldn't fully decompile method append 
// Couldn't resolve all exception handlers in method append 
// Couldn't fully decompile method delete 
// Couldn't resolve all exception handlers in method delete 
// Couldn't fully decompile method isShutdown 
// Couldn't resolve all exception handlers in method isShutdown 
// Couldn't fully decompile method stats 
// Couldn't resolve all exception handlers in method stats 
// Couldn't fully decompile method replace 
// Couldn't resolve all exception handlers in method replace 
// Couldn't fully decompile method set 
// Couldn't resolve all exception handlers in method set 
// Couldn't fully decompile method get 
// Couldn't resolve all exception handlers in method get 
// Couldn't fully decompile method getStats 
// Couldn't resolve all exception handlers in method getStats 
// 
 
 
log4j.properties 
log4j.rootLogger=INFO,stdout,logfile 
 
log4j.logger.com.comName=INFO 
\#log4j.logger.org.springframework.jdbc=DEBUG 
\#log4j.logger.com.ibatis=DEBUG 
log4j.logger.org.apache.activemq.transport=FATAL 
log4j.logger.org.apache.commons=ERROR 
log4j.logger.com.comName.backupmode=ERROR 
log4j.logger.org.apache.velocity=ERROR 
\#stdout 
log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
log4j.appender.stdout.layout.ConversionPattern=%d\{yyyy-MM-dd HH\\:mm\\:ss,SSS\} \[%p-%t\]-\[%C %M %L\]-%m%n 
 
\#ibatis 
\#log4j.logger.com.ibatis=DEBUG 
\#log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=DEBUG 
\#log4j.logger.com.ibatis.common.jdbc.ScriptRunner=DEBUG 
\#log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG 
\#log4j.logger.java.sql.Connection=DEBUG 
\#log4j.logger.java.sql.Statement=DEBUG 
\#log4j.logger.java.sql.PreparedStatement=DEBUG 
\#log4j.logger.java.sql.ResultSet=DEBUG 
 
\#logfile 
log4j.appender.logfile=org.apache.log4j.RollingFileAppender 
log4j.appender.logfile.File=$\{jboss.server.log.dir\}/memcached.log 
log4j.appender.logfile.MaxFileSize=51200KB 
log4j.appender.logfile.MaxBackupIndex=10 
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout 
log4j.appender.logfile.layout.ConversionPattern=%t-%d\{yyyy-MM-dd HH\\:mm\\:ss,SSS\} \[%p\]-\[%C %M %L\]-%m%n 
 
 
sysconfig.properties 
\#\#\#\#\#\#\#memcached\#\#\#\#\#\#\#\#\#\#\# 
 
memcacheServers=172.21.13.57:11211\\,172.21.13.58:11213 
\#cacheServers=172.21.13.57:11211\\,172.21.13.58:11211 172.21.13.57:11212\\,172.21.13.58:11212 
memcacheWeight=1 
memcacheConnPoolSize=30 
memcacheExp=0 
memcacheOpTimeout=3000 
memcacheSetTimeOut=2000 
memcacheGetTimeOut=2000 
memcacheFailureMode=Y