MemcachedClient

/**

 * 

 */

package com.xcj.common.memcached;

 

import java.io.IOException;

 

import net.spy.memcached.AddrUtil;

import net.spy.memcached.ConnectionFactoryBuilder;

import net.spy.memcached.MemcachedClient;

import net.spy.memcached.ConnectionFactoryBuilder.Protocol;

 

import com.xcj.common.util.properties.ReadPropertiesUtil;

 

/**

 * <b>function:</b> MemberCache缓存单例实例只打开一个实例

 * 

 * @project xcjframe

 * @package com.xcj.common.memcached

 * @fileName com.xcj.*

 * @createDate Apr 15, 2014 12:26:24 PM

 * @author nyy

 */

public class MemcachedClientFactory {

private volatile static MemcachedClient instance;

 

private MemcachedClientFactory() {

};

/**

  * <b>function:</b> 防止Mc创建更多的实例，故采用单例模式<br>

  * 放到正式环境阿里云服务区则把注释的放开

  * @project xcjframe

  * @package com.xcj.common.memcached  

  * @fileName com.xcj.common.memcached.MemcachedClientFactory 

  * @createDate Apr 15, 2014 2:49:34 PM

  * @return MemcachedClient

  * @author su_jian

*/

public static MemcachedClient getInstance() throws IOException {

if (instance == null) {

synchronized (MemcachedClient.class) {

if (instance == null) {

//TODO 放到正式正式服务器放开 username passowrd 

// AuthDescriptor ad = new AuthDescriptor(new String[]{"PLAIN"}, new PlainCallbackHandler("2a1e34a8d37011e3", "Xcj1qaz2wsx")); // 用户名，密码 

instance = new MemcachedClient(

new ConnectionFactoryBuilder().setProtocol(

Protocol.BINARY) // 指定使用Binary协议

.setOpTimeout(800222312)// 设置超时时间为100ms

//TODO 放到正式正式服务器放开

// .setAuthDescriptor(ad)

.build(), AddrUtil

.getAddresses(ReadPropertiesUtil.getProperties("memcached.ip")+":"+ReadPropertiesUtil.getProperties("memcached.port")));

}

}

}

return instance;

}

 

}

//---------------------------------------------------------

package com.xcj.common.memcached;

 

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.ExecutionException;

 

import net.spy.memcached.MemcachedClient;

import net.spy.memcached.internal.OperationFuture;

 

import com.xcj.common.util.properties.ReadPropertiesUtil;

 

/**

 * <b>function:</b> Membercache缓存工具类

 * 

 * @project xcjframe

 * @package com.xcj.common.memcached

 * @fileName com.xcj.common.memcached.MemcachedUtil

 * @createDate Apr 15, 2014 2:45:52 PM

 * @author su_jian

 */

public class MemcachedUtil {

 

  /**

   * <b>function:</b> Membercache 将对象放到缓存工具类

   * @project xcjframe

   * @package com.xcj.common.memcached  

   * @fileName com.xcj.*** 

   * @createDate Apr 15, 2014 3:58:13 PM

   * @return MemcachedClient

   * @author su_jian

   */

@SuppressWarnings("unchecked")

public static MemcachedClient putMemcacheIntance(HashMap<String, String> map) {

MemcachedClient mc = null;

try {

// 指定验证机制，推荐PLAIN，

// 部分客户端存在协议BUG，只能使用PLAIN协议(PlainCallbackHandler)

mc = MemcachedClientFactory.getInstance();

OperationFuture future = null;

for (Map.Entry entry : map.entrySet()) {

future = mc.set("" + entry.getKey() + "",Integer.valueOf(ReadPropertiesUtil.getProperties("memcached.exptime")), entry

.getValue()); // 异步接口，注意！返回的是Future

}

future.get(); // future.get() 确保之前(mc.set())操作已经结束

} catch (IOException e) {

e.printStackTrace();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} finally {

if (mc != null) {

}

// mc.shutdown(); // 关闭，释放资源

}

return mc;

}

 

/**

  * <b>function:</b> Membercache 将对象放到缓存工具类 设置缓存时间

  * @project xcjframe

  * @package com.xcj.common.memcached  

  * @fileName com.xcj.*** 

  * @createDate Apr 15, 2014 3:58:13 PM

  * @return MemcachedClient

  * @author nyy

  */

@SuppressWarnings("unchecked")

public static MemcachedClient putMemcacheIntance(HashMap<String, String> map,Integer time) {

MemcachedClient mc = null;

try {

// 指定验证机制，推荐PLAIN，

// 部分客户端存在协议BUG，只能使用PLAIN协议(PlainCallbackHandler)

mc = MemcachedClientFactory.getInstance();

OperationFuture future = null;

 

for (Map.Entry entry : map.entrySet()) {

future = mc.set("" + entry.getKey() + "",time, entry.getValue()); // 异步接口，注意！返回的是Future

}

future.get(); // future.get() 确保之前(mc.set())操作已经结束

} catch (IOException e) {

e.printStackTrace();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} finally {

if (mc != null) {

}

// mc.shutdown(); // 关闭，释放资源

}

return mc;

}

 

/*

* 根据key来删除缓存

*/

public static boolean deteleKey(String key){

try{

MemcachedClient mc = null;

mc.delete(key);

return true;

}catch(Exception ex){

ex.printStackTrace();

return false;

}

}

 

 

/**

  * <b>function:</b> Membercache 将对象放到缓存工具类

  * @project xcjframe

  * @package com.xcj.common.memcached  

  * @fileName com.xcj.*** 

  * @createDate Apr 15, 2014 3:58:13 PM

  * @return MemcachedClient

  * @author su_jian

  */

@SuppressWarnings("unchecked")

public static void putMemcacheIntance(Object obj) {

MemcachedClient mc = null;

try {

// 指定验证机制，推荐PLAIN，

// 部分客户端存在协议BUG，只能使用PLAIN协议(PlainCallbackHandler)

mc = MemcachedClientFactory.getInstance();

OperationFuture future = null;

future = mc.add(obj+"_xcj",Integer.valueOf(ReadPropertiesUtil.getProperties("memcached.exptime")), obj); // 异步接口，注意！返回的是Future

future.get(); // future.get() 确保之前(mc.set())操作已经结束

} catch (IOException e) {

e.printStackTrace();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} finally {

if (mc != null) {

}

// mc.shutdown(); // 关闭，释放资源

}

}

 

 

/**

* <b>function:</b>刷新缓存没有时间

* @project xcjframe

* @package com.xcj.common.memcached

* @fileName com.xcj.***

* @createDate May 12, 2014 2:38:14 PM

* @return void

* @author su_jian

*/

public static void flushMemcache() {

MemcachedClient mc = null;

try {

mc = MemcachedClientFactory.getInstance();

mc.flush();

} catch (IOException e) {

e.printStackTrace();

}

}

/**

* <b>function:</b>刷新缓存延迟时间

* @project xcjframe

* @param  int 延迟时间

* @package com.xcj.common.memcached

* @fileName com.xcj.***

* @createDate May 12, 2014 2:38:14 PM

* @return void

* @author su_jian

*/

public static void flushMemcache(int delay) {

MemcachedClient mc = null;

try {

mc = MemcachedClientFactory.getInstance();

mc.flush(delay);

} catch (IOException e) {

e.printStackTrace();

}

}

 

}

 

 

//-------------------------------------

@SuppressWarnings("unchecked")

public List<Dict> getDictList(String typeCode) {

MemcachedClient mc;

List<Dict> list = null;

try {

mc = MemcachedClientFactory.getInstance();

list = (List) mc.get(typeCode);

if (list == null) {

HashMap map = dictService.getDictMap();

MemcachedUtil.putMemcacheIntance(map);

list = (List) mc.get(typeCode);

}else{

System.out.print("111111111111111111");

}

} catch (IOException e) {

e.printStackTrace();

}

return list;

}

 

//------------------------------------------

public void setSession(String sessionId, String token, Integer userId){

HashMap map = new HashMap();

map.put("sessionId", sessionId);

map.put("token", token);

map.put("date",DateUtil.getCurrentTimeByDate());

map.put("userId", userId);

MemcachedUtil.putMemcacheIntance(map,10000);

 

 

}