Java操作Memcached

本文复制其他播客,有好的技术文章希望各位大神能告知... 谢谢。

如何使用Java操作Memcached实例:

代码一:

package com.ghj.packageoftool;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.management.ManagementFactory;
import java.text.SimpleDateFormat;
import java.util.Date;

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

/**
 * Memcached工具类
 *
 * @author GaoHuanjie
 */
public class MemcachedUtils {

  private static MemCachedClient memCachedClient;
  static {
         /************************************配置Memcached**************************************/
         SockIOPool sockIOPool = SockIOPool.getInstance();

         sockIOPool.setServers(new String[]{"127.0.0.1:11211"});//设置memcached服务器地址
         sockIOPool.setWeights(new Integer[]{3}); 				//设置每个MemCached服务器权重
         sockIOPool.setFailover(true);  						//当一个memcached服务器失效的时候是否去连接另一个memcached服务器.
         sockIOPool.setInitConn(10);    						//初始化时对每个服务器建立的连接数目
         sockIOPool.setMinConn(10);     						//每个服务器建立最小的连接数
         sockIOPool.setMaxConn(100);    						//每个服务器建立最大的连接数
         sockIOPool.setMaintSleep(30);  						//自查线程周期进行工作,其每次休眠时间
         sockIOPool.setNagle(false);    						//Socket的参数,如果是true在写数据时不缓冲,立即发送出去。Tcp的规则是在发送一个包之前,包的发送方会等待远程接收方确认已收到上一次发送过来的包;这个方法就可以关闭套接字的缓存——包准备立即发出。
         sockIOPool.setSocketTO(3000);  						//Socket阻塞读取数据的超时时间
         sockIOPool.setAliveCheck(true);						//设置是否检查memcached服务器是否失效
         sockIOPool.setMaxIdle(1000*30*30); 					// 设置最大处理时间
         sockIOPool.setSocketConnectTO(0);  					//连接建立时对超时的控制

         sockIOPool.initialize();  								// 初始化连接池
         if (memCachedClient == null){
        	 memCachedClient = new MemCachedClient();
        	 memCachedClient.setPrimitiveAsString(true);		//是否将基本类型转换为String方法
         }
  }

  private MemcachedUtils() {
  }

  /**
   * 向缓存添加键值对。注意:如果键已经存在,则之前的键对应的值将被替换。
   *
   * @author GaoHuanjie
   */
  public static boolean set(String key, Object value) {
    try {
      return memCachedClient.set(key, value);
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached set方法报错,key值:" + key + "\r\n" + exceptionWrite(e));
      return false;
    }
  }

  /**
   * 向缓存添加键值对并为该键值对设定逾期时间(即多长时间后该键值对从Memcached内存缓存中删除,比如: new Date(1000*10),则表示十秒之后从Memcached内存缓存中删除)。注意:如果键已经存在,则之前的键对应的值将被替换。
   *
   * @author GaoHuanjie
   */
  public static boolean set(String key, Object value, Date expire) {
    try {
      return memCachedClient.set(key, value, expire);
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached set方法报错,key值:" + key + "\r\n" + exceptionWrite(e));
      return false;
    }
  }

  /**
   * 向缓存添加键值对。注意:仅当缓存中不存在键时,才会添加成功。
   *
   * @author GaoHuanjie
   */
  public static boolean add(String key, Object value) {
    try {
      if (get(key) != null) {
        MemcachedLogUtils.writeLog("Memcached add方法报错,key值:" + key + "\r\n" + exceptionWrite(new Exception("Memcached内存缓存中已经存在该键值对")));
        return false;
      }else{
        return memCachedClient.add(key, value);
      }
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached add方法报错,key值:" + key + "\r\n" + exceptionWrite(e));
      return false;
    }
  }

  /**
   * 向缓存添加键值对并为该键值对设定逾期时间(即多长时间后该键值对从Memcached内存缓存中删除,比如: new Date(1000*10),则表示十秒之后从Memcached内存缓存中删除)。注意:仅当缓存中不存在键时,才会添加成功。
   *
   * @author GaoHuanjie
   */
  public static boolean add(String key, Object value, Date expire) {
    try {
      if (get(key) != null) {
        MemcachedLogUtils.writeLog("Memcached add方法报错,key值:" + key + "\r\n" + exceptionWrite(new Exception("Memcached内存缓存中已经存在该键值对")));
        return false;
      }else{
        return memCachedClient.add(key, value, expire);
      }
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached add方法报错,key值:" + key + "\r\n" + exceptionWrite(e));
      return false;
    }
  }

  /**
   * 根据键来替换Memcached内存缓存中已有的对应的值。注意:只有该键存在时,才会替换键相应的值。
   *
   * @author GaoHuanjie
   */
  public static boolean replace(String key, Object newValue) {
    try {
      return memCachedClient.replace(key, newValue);
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached replace方法报错,key值:" + key + "\r\n" + exceptionWrite(e));
      return false;
    }
  }

  /**
   * 根据键来替换Memcached内存缓存中已有的对应的值并设置逾期时间(即多长时间后该键值对从Memcached内存缓存中删除,比如: new Date(1000*10),则表示十秒之后从Memcached内存缓存中删除)。注意:只有该键存在时,才会替换键相应的值。
   *
   * @author GaoHuanjie
   */
  public static boolean replace(String key, Object newValue, Date expireDate) {
    try {
      return memCachedClient.replace(key, newValue, expireDate);
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached replace方法报错,key值:" + key + "\r\n" + exceptionWrite(e));
      return false;
    }
  }

  /**
   * 根据键获取Memcached内存缓存管理系统中相应的值
   *
   * @author GaoHuanjie
   */
  public static Object get(String key) {
    try {
      return memCachedClient.get(key);
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached get方法报错,key值:" + key + "\r\n" + exceptionWrite(e));
      return null;
    }
  }

  /**
   * 根据键删除memcached中的键/值对
   *
   * @author GaoHuanjie
   */
  public static boolean delete(String key) {
    try {
      return memCachedClient.delete(key);
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached delete方法报错,key值:" + key + "\r\n" + exceptionWrite(e));
      return false;
    }
  }

  /**
   * 根据键和逾期时间(例如:new Date(1000*10):十秒后过期)删除 memcached中的键/值对
   *
   * @author GaoHuanjie
   */
  public static boolean delete(String key, Date expireDate) {
    try {
      return memCachedClient.delete(key, expireDate);
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached delete方法报错,key值:" + key + "\r\n" + exceptionWrite(e));
      return false;
    }
  }

  /**
   * 清理缓存中的所有键/值对
   *
   * @author GaoHuanjie
   */
  public static boolean flashAll() {
    try {
      return memCachedClient.flushAll();
    } catch (Exception e) {
      MemcachedLogUtils.writeLog("Memcached flashAll方法报错\r\n" + exceptionWrite(e));
      return false;
    }
  }

  /**
   * 返回String类型的异常栈信息
   *
   * @author GaoHuanjie
   */
  private static String exceptionWrite(Exception exception) {
    StringWriter stringWriter = new StringWriter();
    PrintWriter printWriter = new PrintWriter(stringWriter);
    exception.printStackTrace(printWriter);
    printWriter.flush();
    return stringWriter.toString();
  }

  /**
   * Memcached日志记录工具
   *
   * @author GaoHuanjie
   */
  private static class MemcachedLogUtils {

    private static FileWriter fileWriter;
    private static BufferedWriter logWrite;
    private final static String PID = ManagementFactory.getRuntimeMXBean().getName();// 通过找到对应的JVM进程获取PID

    /**
     * 初始化Memcached日志写入流
     *
   * @author GaoHuanjie
   */
static {
try {
  String osName = System.getProperty("os.name");
if (osName.contains("Windows")) {
  fileWriter = new FileWriter("D:\\memcached.log", true);
  } else {
  fileWriter = new FileWriter("/usr/local/logs/memcached.log", true);
  }
  logWrite = new BufferedWriter(fileWriter);
  } catch (IOException iOException) {
  iOException.printStackTrace();
try {
if (fileWriter != null) {
  fileWriter.close();
  }
if (logWrite != null) {
  logWrite.close();
  }
  } catch (Exception exception) {
  exception.printStackTrace();
  }
  }
  }
/**
   * 写入日志信息
   *
   * @author GaoHuanjie
   */
public static void writeLog(String logContent) {
try {
  logWrite.write("[" + PID + "] " + "- [" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "]\r\n" + logContent);
  logWrite.newLine();
  logWrite.flush();
  } catch (IOException e) {
  e.printStackTrace();
  }
  }
  }
}

代码二:

package com.ghj.packageofclient;

import java.util.Date;

import junit.framework.TestCase;

import com.ghj.packageoftool.MemcachedUtils;

public class Client extends TestCase{

  /**
   * 测试MemcachedUtils类的set方法。
   *
   * @author GaoHuanjie
   */
  public static void testSet1() {
    MemcachedUtils.set("set1Description", "调用MemcachedUtils类的set方法,没有设置键值对的存在时长");
    System.out.println(MemcachedUtils.get("set1Description").toString());
  }

  /**
   * 测试MemcachedUtils类的set方法。
   *
   * @author GaoHuanjie
   */
  public static void testSet2() {
    MemcachedUtils.set("set2Description", "调用MemcachedUtils类的set方法,设置了键值对的存在时长——存在60秒", new Date(1000*60));
    System.out.println(MemcachedUtils.get("set2Description").toString());
  }

  /**
   * 测试MemcachedUtils类的add方法。
   *
   * @author GaoHuanjie
   */
  public static void testAdd1() {
    MemcachedUtils.add("add1Description", "调用MemcachedUtils类的add方法,没有设置键值对的存在时长");
    System.out.println(MemcachedUtils.get("add1Description").toString());
  }

  /**
   * 测试MemcachedUtils类的add方法。
   *
   * @author GaoHuanjie
   */
  public static void testAdd2() {
    MemcachedUtils.add("add2Description", "调用MemcachedUtils类的add方法,设置了键值对的存在时长——存在60秒", new Date(1000*60));
    System.out.println(MemcachedUtils.get("add2Description").toString());
  }

  /**
   * 测试MemcachedUtils类的replace方法。
   *
   * @author GaoHuanjie
   */
  public static void testReplace1() {
    MemcachedUtils.add("replace1Description", "调用MemcachedUtils类的replace方法,没有设置键值对的存在时长");
    MemcachedUtils.replace("replace1Description", "值改变了!!!");
    System.out.println(MemcachedUtils.get("replace1Description").toString());
  }

  /**
   * 测试MemcachedUtils类的replace方法。
   *
   * @author GaoHuanjie
   */
  public static void testReplace2() {
    MemcachedUtils.add("replace2Description", "调用MemcachedUtils类的replace方法,设置了键值对的存在时长——存在60秒", new Date(1000*60));
    MemcachedUtils.replace("replace2Description", "值改变了!!!", new Date(1000*60));
    System.out.println(MemcachedUtils.get("replace2Description").toString());
  }

  /**
   * 测试MemcachedUtils类的get方法。
   *
   * @author GaoHuanjie
   */
  public static void testGet() {
    MemcachedUtils.add("getDescription", "调用MemcachedUtils类的get方法,没有设置键值对的存在时长");
    System.out.println(MemcachedUtils.get("getDescription").toString());
  }

  /**
   * 测试MemcachedUtils类的delete方法。
   *
   * @author GaoHuanjie
   */
  public static void testDelete1() {
    MemcachedUtils.add("delete1Description", "调用MemcachedUtils类的delete方法,没有设置键值对的逾期时长");
    MemcachedUtils.delete("delete1Description");
    assertEquals(null, MemcachedUtils.get("delete1Description"));
  }

  /**
   * 测试MemcachedUtils类的delete方法。
   *
   * @author GaoHuanjie
   */
  public static void testDelete2() {
    MemcachedUtils.set("delete2Description1", "调用MemcachedUtils类的delete方法,设置键值对的逾期时长", new Date(600*1000));
    MemcachedUtils.delete("delete2Description1", new Date(1000*600));
    assertEquals(null, MemcachedUtils.get("delete2Description1"));
  }

  /**
   * 测试MemcachedUtils类的flashAll方法。
   *
   * @author GaoHuanjie
   */
  public static void testFlashAll() {
    MemcachedUtils.add("flashAllDescription", "调用MemcachedUtils类的delete方法,没有设置键值对的预期时长");
    MemcachedUtils.flashAll();
    assertEquals(null, MemcachedUtils.get("flashAllDescription"));
  }
}
时间: 2024-10-11 16:58:55

Java操作Memcached的相关文章

memcached—Java操作Memcached实例

前面博客介绍了如何在Windows操作系统中安装Memcached,总结一下如何使用Java操作Memcached实例: 代码一: package com.ghj.packageoftool; import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; import java.io.StringWriter; import jav

java操作memcached入门教程demo代码

原文:java操作memcached入门教程demo代码 源代码下载地址:http://www.zuidaima.com/share/1550463754996736.htm 参考地址: http://www.open-open.com/lib/view/open1357831114183.html http://tech.idv2.com/2008/07/10/memcached-001/ 感谢 京-java牛-ID号1  感谢 锡-SuperPrivate-195 在网上搜索了部分代码,一个

Java操作memcached(一)

Memcached事实上,两次Hash算法 第一次hash算法被用于定位Memcached示例 第二次hash算法是底部HashMap中间hash算法 Hash算法 1.依据余数来进行计算(事实上java中的HashMap的hash算法也是用的这样的方式) 2.一致性hash算法 C的client  --->libMemcached已经实现了该功能,C的开发者直接使用它. 新浪----->Memcachedb  实现了持久化功能 java的client a官方的 memcached clien

Java操作memcache

准备工作 Java操作memcache需要spymemcache类库的支持,在Eclipse中修改maven项目的pom.xml文件—— 添加仓库: <repositories> <repository> <id>spy</id> <name>Spy Repository</name> <layout>default</layout> <url>http://files.couchbase.com/

java操作elasticsearch

Elasticsearch是一个搜索引擎,建立在Lucene之上 集群 (cluster) 代表一个集群,集群中有多个节点,其中有一个为主节点,这个主节点是可以通过选举产生的,主从节点是对于集群内部来说的. es的一个概念就是去中心化,字面上理解就是无中心节点,这是对于集群外部来说的,因为从外部来看es集群,在逻辑上是个整体, 你与任何一个节点的通信和与整个es集群通信是等价的. 节点(node) 每一个运行实例称为一个节点,每一个运行实例既可以在同一机器上,也可以在不同的机器上.所谓运行实例,

java 操作 Excel,java导出excel

WritableWorkbook out = null; try { response.getServletResponse().reset(); ((HttpServletResponse) response.getServletResponse()).setHeader("Content-Disposition", "attachment;filename=export.xls"); response.getServletResponse().setConten

java操作hbase例子

hbase安装方法请参考:hbase-0.94安装方法详解 hbase常用的shell命令请参考:hbase常用的shell命令例子 java操作hbase,在eclipse中创建一个java项目,将hbase安装文件根目录的jar包和lib目录下jar包导入项目,然后就可以编写java代码操作hbase了.下面代码给出来一个简单的示例 /** * @date 2015-07-23 21:28:10 * @author sgl */ package com.songguoliang.hbase;

通过memcache动态运行库操作memcached服务,进行CURD

具体学习参考php参考手册: 操作memcached的几种方式: bool Memcache::add ( string $key , mixed $var [, int $flag [, int $expire ]] ) 如果报 expire 设为0 表示,永不过期.(只要memcache不重新启动,就永远在mem中) exprie 直接给的是秒数,则最大 30*3600*24 如果你希望保持时间超过30  time()+天数*3600*24 即可 mem1.php <?php //创建一个m

PHP源码来操作memcached服务

如何使用PHP源码来操作memcached服务 如果管理员不让我们去加载 memcache.dll 文件,我们可以直接通过源码操作 看高手的源代码也很有意思! 特点: 1.不需要开启memcache扩展 2.使用fsockopen()套接字连接memcached 3.同样执行执行CRUD 引用别人写的一个类: memcached-client.php <?php // // +------------------------------------------------------------