MemcachedService

package com.yulong.memcached.service;

import java.io.InputStream;
import java.net.URL;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;

import org.apache.log4j.Logger;

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;

public class MemcachedService
{
   
    static Logger logger = Logger.getLogger(MemcachedService.class);
    static
    {
        init();
    }
    private static MemCachedClient mcc = new MemCachedClient();
   
    public static void init()
    {
        String[] servers = {};
       
        long maxBusyTime = 1000 * 60 * 2;
        int initConn = 10;
        int minConn = 5;
        int maxConn = 250;
        long maintSleep = 30;
        int hashingAlg = 3;
       
        try
        {
            URL url = MemcachedService.class.getResource("/memcached/servers.properties");
            InputStream is = null;
            if (url != null)
            {
                is = url.openStream();
            }
            if (is == null)
                is = MemcachedService.class.getResourceAsStream("/memcached/servers.properties");
            Properties prop = new Properties();
            prop.load(is);
           
            servers = prop.getProperty("servers").split(",");
           
            maxBusyTime = Long.valueOf(prop.getProperty("maxBusyTime") == null ? "" : prop.getProperty("maxBusyTime"));
            initConn = Integer.parseInt(prop.getProperty("initConn") == null ? "" : prop.getProperty("initConn"));
            minConn = Integer.parseInt(prop.getProperty("minConn") == null ? "" : prop.getProperty("minConn"));
            maxConn = Integer.parseInt(prop.getProperty("maxConn") == null ? "" : prop.getProperty("maxConn"));
            maintSleep = Long.parseLong(prop.getProperty("maintSleep") == null ? "" : prop.getProperty("maintSleep"));
            hashingAlg = Integer.parseInt(prop.getProperty("hashingAlg") == null ? "" : prop.getProperty("hashingAlg"));
           
            logger.info("memcached servers:" + prop.getProperty("servers"));
           
            SockIOPool pool = SockIOPool.getInstance();
            pool.setServers(servers);
            pool.setMaxBusyTime(maxBusyTime);
            pool.setInitConn(initConn);
            pool.setMinConn(minConn);
            pool.setMaxConn(maxConn);
            pool.setMaintSleep(maintSleep);
            pool.setHashingAlg(hashingAlg);
           
            pool.setFailover(true);
            pool.setNagle(false);
            pool.setSocketTO(3000);
            pool.setAliveCheck(false);
           
            pool.initialize();
        }
        catch (Exception e)
        {
            logger.error(e.getMessage());
            for (StackTraceElement element : e.getStackTrace())
            {
                logger.error(element);
            }
        }
       
    }
    /**
     * 系统专用
     * @param key
     * @param value
     * @return
     */
    public static Object setParam(Object key, Object value)
    {
        return set("P" + (String) key, value);
    }
   
    /**
     * 获得memcached服务器的状态
     */
//    public static String getServerStatus()
//    {
//        mch = new MccErrorHandler();
//        mch.handleErrorOnStats(mcc, null);
////        mcc.setErrorHandler(mch);
//        mcc.set("test", "test");
//        mcc.replace("test", "test");
//        if (mch.getStatus().equals("ok"))
//        {
//            return "ok";
//        }
//        else
//        {
//            return "outOfService";
//        }
//    }
   
    /**
     * 系统专用
     * @param key
     * @param value
     * @return
     */
    public static Object setParam(String key, Object value)
    {
       
        return set("P" + key, value);
    }
   
    public static Object set(Object key, Object value)
    {
       
        return set((String) key, value);
    }
   
    public static Object set(String key, Object value)
    {
//        mch = new MccErrorHandler();
//        mcc.setErrorHandler(mch);
        mcc.set(key, value);
        mcc.replace(key, value);
//        if (mch.getStatus().equals("ok"))
//        {
            return value;
//        }
//        else
//        {
//            return "error";
//        }
    }
   
    public static void putAll(Map<? extends String, ? extends Object> m)
    {
        for (String key : m.keySet())
        {
            set(key, m.get(key));
        }
    }
   
    public static Object removeGroup(Object key)
    {
        return remove("G" + (String) key);
    }
   
    public static Object removeParam(Object key)
    {
        return null;// 系统不可移除
    }
   
    public static Object remove(Object key)
    {
        return remove((String) key);
    }
   
    public static Object remove(String key)
    {
//        mch = new MccErrorHandler();
//        mcc.setErrorHandler(mch);
        Object value = mcc.get(key);
        mcc.delete(key);
//        if (mch.getStatus().equals("ok"))
//        {
            return value;
//        }
//        else
//        {
//            return "error";
//        }
    }
   
    public static boolean replace(String key, Object value)
    {
        boolean result = false;
//        mch = new MccErrorHandler();
//        mcc.setErrorHandler(mch);
        result = mcc.replace(key, value);
//        if (mch.getStatus().equals("ok"))
//        {
            return result;
//        }
//        else
//        {
//            return false;
//        }
       
    }
   
    public static Object get(Object key)
    {
        return get((String) key);
    }
   
    public static Object get(String key)
    {
//        mch = new MccErrorHandler();
//        mcc.setErrorHandler(mch);
        Object t = mcc.get(key);
//        if (mch.getStatus().equals("ok"))
//        {
            return t;
//        }
//        else
//        {
//            return "error";
//        }
    }
   
    /**
     * 系统专用
     * @param key
     * @return
     */
    public static Object getParam(Object key)
    {
        Object t = get("P" + (String) key);
        if (t != null && t.toString().equals("error"))
        {
            // TODO 获得对应的值
            return "error";
        }
        else
        {
            return t;
        }
    }
   
    /**
     * 系统专用
     * @param key
     * @return
     */
    public static Object getParam(String key)
    {
        return get("P" + key);
    }
   
    /**
     * 系统专用
     * @param groupName
     * @return
     */
    public static LinkedHashMap<String, Object> getGroup(String groupName)
    {
        Object group = get("G" + groupName);
        if (group != null && group.toString().equals("error"))
        {
            // 数据库存取
            return null;
        }
        else if (group == null)
        {
            return null;
        }
        else
        {
            return (LinkedHashMap<String, Object>) group;
        }
    }
   
    /**
     * 系统专用
     * @param groupName
     * @param group
     * @return
     */
    public static LinkedHashMap<String, Object> setGroup(String groupName, LinkedHashMap<String, Object> group)
    {
        String t = set("G" + groupName, group).toString();
        if (t.equals("error"))
        {
            return null;
        }
        replace("G" + groupName, group);
        return group;
    }
   
    public static boolean set(String key, Object value, Date expiry)
    {
        boolean result = false;
//        mch = new MccErrorHandler();
//        mcc.setErrorHandler(mch);
        result = mcc.set(key, value, expiry);
        result = mcc.replace(key, value, expiry);
        return result;
    }
   
    /**
     *
    * @Title: getAll
    * @Description: 批量获取数据
    * @param  key
    * @return boolean
    * @throws
     */
    public static Map<String,Object> getAll(String[] key){
        return mcc.getMulti(key);

    }
   
    /**
     *
    * @Title: getAllParam
    * @Description: TODO批量获取系统参数数据
    * @param keys
    * @return Map<String,Object>
    * @throws
     */
    public static Map<String,Object> getAllParam(String[] keys){
    for (int i=0;i<keys.length;i++){
    keys[i]="P"+keys[i];
        }
        return mcc.getMulti(keys);

    }
   
    /**
     *
    * @Title: getAllGroup
    * @Description: TODO批量获取系统代码数据
    * @param keys
    * @return Map<String,Object>
    * @throws
     */
    public static Map<String,Object> getAllGroup(String[] keys){
    for (int i=0;i<keys.length;i++){
    keys[i]="G"+keys[i];
        }
        return mcc.getMulti(keys);

    }
   
    public static boolean keyExists(String key)
    {
        boolean result = false;
//        mch = new MccErrorHandler();
//        mcc.setErrorHandler(mch);
        result = mcc.keyExists(key);
        return result;
    }
}