Java使用Memcached和Redis简单示例

package xmq.study.memcached;

import java.io.IOException;
import java.net.InetSocketAddress;

import net.spy.memcached.MemcachedClient;

/**
 * memcached test
 * @author 943567518@qq.com
 *
 */
public class Memcached {

    public static void main(String[] args) {
        //导入spymemcached-3.17.jar
        //dos下启动memcached：
        //1、进入解压目录 ；2、启动命令memcached.exe -d start（安装：memcached.exe -d install）；3、关闭命令memcached.exe -d stop
        MemcachedClient mcc=null;
        try {
            //本地连接
            mcc=new MemcachedClient(new InetSocketAddress("127.0.0.1",11211));
            //添加
            add(mcc, "xmq", 0, "添加");
            System.out.println("添加:	"+get(mcc,"xmq"));
            //追加
            append(mcc, "xmq","追加");
            System.out.println("追加:	"+get(mcc,"xmq"));
            //前置追加
            prepend(mcc, "xmq","前置追加");
            System.out.println("前置追加:	"+get(mcc,"xmq"));
            //替换
            replace(mcc, "xmq",0,"替换");
            System.out.println("替换:	"+get(mcc,"xmq"));
            //删除
            delete(mcc, "xmq");
            System.out.println("删除:	"+get(mcc,"xmq"));
            //自减
            add(mcc, "num", 0, "2");
            replace(mcc, "num",0,"2");
            decr(mcc,"num",1);
            System.out.println("自减:	"+get(mcc,"num"));
            //自增
            replace(mcc, "num",0,"2");
            incr(mcc,"num",1);
            System.out.println("自增:	"+get(mcc,"num"));
            //存储java对象
            String[] strArr=new String[]{"我","是","字","符","数","组"};
            add(mcc,"strArr",0,strArr);
            System.out.println("字符数组:	"+get(mcc,"strArr"));
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //关闭连接
            mcc.shutdown();
        }
    }
    
    /**
     * Memcached incr 与 decr 命令用于对已存在的 key(键) 的数字值进行自增或自减操作。
     * incr 与 decr 命令操作的数据必须是十进制的32位无符号整数。
     * 如果 key 不存在返回 NOT_FOUND，如果键的值不为数字，则返回 CLIENT_ERROR，其他错误返回 ERROR。
     * @param mcc
     * @param key
     * @return
     */
    public static void decr(MemcachedClient mcc,String key,int value){
        mcc.decr(key,value);
    }
    
    /**
     * Memcached incr 与 decr 命令用于对已存在的 key(键) 的数字值进行自增或自减操作。
     * incr 与 decr 命令操作的数据必须是十进制的32位无符号整数。
     * 如果 key 不存在返回 NOT_FOUND，如果键的值不为数字，则返回 CLIENT_ERROR，其他错误返回 ERROR。
     * @param mcc
     * @param key
     * @return
     */
    public static void incr(MemcachedClient mcc,String key,int value){
        mcc.incr(key,value);
    }
    
    /**
     * 获取 CAS 令牌存 的 value(数据值) ，如果 key 不存在，则返回空
     * @param mcc
     * @param key
     * @return
     */
    public static void delete(MemcachedClient mcc,String key){
        mcc.delete(key);
    }
    
    /**
     * 获取 CAS 令牌存 的 value(数据值) ，如果 key 不存在，则返回空
     * @param mcc
     * @param key
     * @return
     */
    public static Object gets(MemcachedClient mcc,String key){
        return mcc.gets(key);
    }
    
    /**
     * 获取存储在 key(键) 中的 value(数据值) ，如果 key 不存在，则返回空
     * @param mcc
     * @param key
     * @return
     */
    public static Object get(MemcachedClient mcc,String key){
        return mcc.get(key);
    }
    /**
     * cas key flags exptime bytes unique_cas_token [noreply]
     * value
     * 参数说明如下：
     * key：键值 key-value 结构中的 key，用于查找缓存值。
     * flags：可以包括键值对的整型参数，客户机使用它存储关于键值对的额外信息 。
     * exptime：在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
     * bytes：在缓存中存储的字节数
     * unique_cas_token通过 gets 命令获取的一个唯一的64位值。
     * noreply（可选）： 该参数告知服务器不需要返回数据
     * value：存储的值（始终位于第二行）（可直接理解为key-value结构中的value）
     * 
     * @param mcc
     * @param key
     * @param value
     */
    public static void cas(MemcachedClient mcc,String key,Object value){
        mcc.cas(key, mcc.gets(key).getCas(), value);
    }
    /**
     * prepend 命令的基本语法格式如下：
     * prepend key flags exptime bytes [noreply] 
     * value 
     * 参数说明如下：
     * key：键值 key-value 结构中的 key，用于查找缓存值。
     * flags：可以包括键值对的整型参数，客户机使用它存储关于键值对的额外信息 。
     * exptime：在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
     * bytes：在缓存中存储的字节数
     * noreply（可选）： 该参数告知服务器不需要返回数据
     * value：存储的值（始终位于第二行）（可直接理解为key-value结构中的value）
     * @param mcc
     * @param key
     * @param value
     */
    public static void prepend(MemcachedClient mcc,String key,Object value){
        mcc.prepend(key, value);
    }
    
    /**
     * append 命令的基本语法格式如下：
     * append key flags exptime bytes [noreply] 
     * value 
     * 参数说明如下：
     * key：键值 key-value 结构中的 key，用于查找缓存值。
     * flags：可以包括键值对的整型参数，客户机使用它存储关于键值对的额外信息 。
     * exptime：在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
     * bytes：在缓存中存储的字节数
     * noreply（可选）： 该参数告知服务器不需要返回数据
     * value：存储的值（始终位于第二行）（可直接理解为key-value结构中的value）
     * @param mcc
     * @param key
     * @param value
     */
    public static void append(MemcachedClient mcc,String key,Object value){
        mcc.append(key, value);
    }
    
    /**
     * replace 命令的基本语法格式如下：
     * replace key flags exptime bytes [noreply] 
     * value 
     * 参数说明如下：
     * key：键值 key-value 结构中的 key，用于查找缓存值。
     * flags：可以包括键值对的整型参数，客户机使用它存储关于键值对的额外信息 。
     * exptime：在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
     * bytes：在缓存中存储的字节数
     * noreply（可选）： 该参数告知服务器不需要返回数据
     * value：存储的值（始终位于第二行）（可直接理解为key-value结构中的value）
     * @param mcc
     * @param key
     * @param exptime
     * @param value
     */
    public static void replace(MemcachedClient mcc,String key,int exptime,Object value){
        mcc.replace(key, exptime, value);
    }
    
    /**
     * add 命令的基本语法格式如下：
     * add key flags exptime bytes [noreply] 
     * value 
     * 参数说明如下：
     * key：键值 key-value 结构中的 key，用于查找缓存值。
     * flags：可以包括键值对的整型参数，客户机使用它存储关于键值对的额外信息 。
     * exptime：在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
     * bytes：在缓存中存储的字节数
     * noreply（可选）： 该参数告知服务器不需要返回数据
     * value：存储的值（始终位于第二行）（可直接理解为key-value结构中的value）
     * @param mcc
     * @param key
     * @param exptime
     * @param value
     */
    public static void add(MemcachedClient mcc,String key,int exptime,Object value){
        mcc.add(key, exptime, value);
    }
    
    /**
     * set 命令的基本语法格式如下：
     * set key flags exptime bytes [noreply] 
     * value 
     * 参数说明如下：
     * key：键值 key-value 结构中的 key，用于查找缓存值。
     * flags：可以包括键值对的整型参数，客户机使用它存储关于键值对的额外信息 。
     * exptime：在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
     * bytes：在缓存中存储的字节数
     * noreply（可选）： 该参数告知服务器不需要返回数据
     * value：存储的值（始终位于第二行）（可直接理解为key-value结构中的value）
     * @param mcc
     * @param key
     * @param exptime
     * @param value
     */
    public static void set(MemcachedClient mcc,String key,int exptime,Object value){
        mcc.set(key, exptime, value);
    }
}

package xmq.study.redis;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.Jedis;

/**
 * redis test
 * @author 943567518@qq.com
 *
 */
public class Redis {
    public static void main(String[] args) {
        //导入jedis-2.9-0.jar
        //dos下启动redis：
        //1、进入解压目录 ；2、启动命令redis-server.exe redis.windows.conf
        Jedis jedis=new Jedis("127.0.0.1",6379);
        //set&get&del
        jedis.set("xmq-set-get-del","set数据1");
        System.out.println("获取xmq-set-get-del："+jedis.get("xmq-set-get-del"));
        jedis.del("xmq-set-get-del");
        System.out.println("获取xmq-set-get-del："+jedis.get("xmq-set-get-del"));
        //添加string
        jedis.set("xmq", "添加");
        System.out.println(jedis.get("xmq"));
        //存储数据到列表中
        jedis.lpush("xmq-list", "列表数据1");
        jedis.lpush("xmq-list", "列表数据2");
        jedis.lpush("xmq-list", "列表数据3");
        List<String> list = jedis.lrange("xmq-list", 0 ,2);
        for(int i=0; i<list.size(); i++) {
            System.out.println("列表项为: "+list.get(i));
        }
        //map测试
        Map<String,String> map=new HashMap<String,String>();
        map.put("xmq-map-key1", "map数据1");
        map.put("xmq-map-key2", "map数据2");
        map.put("xmq-map-key3", "map数据3");
        jedis.hmset("xmq-map",map);
        Set<String> xmqMapKeys =jedis.hkeys("xmq-map");
        System.out.println("获取xmq-map："+jedis.hgetAll("xmq-map")); 
        Iterator<String> xmqMapIt=xmqMapKeys.iterator() ;   
        while(xmqMapIt.hasNext()){   
            String key = xmqMapIt.next(); 
            System.out.println("获取xmq-map-key项："+key); 
        }
        // 获取key数据并输出
        Set<String> keys = jedis.keys("*"); 
        Iterator<String> it=keys.iterator() ;   
        while(it.hasNext()){   
            String key = it.next();   
            System.out.println("获取key项："+key);   
            jedis.del(key);
            System.out.println("删除key项："+key);
        }
        //保存数据，将在 redis 安装目录中创建dump.rdb文件。
        //jedis.save();
    }
}