Redis 教程 - 悦读

1. Redis基本数据结构5种:

String: 字符串（set，get常用命令）
Hash: 散列(Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象,HMSET ,HGET, HGETALL)
List: 列表
Set: 集合
Sorted Set: 有序集合

String 类型可以存贮二进制或者未经序列化的字符串

string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如jpg图片或者序列化的对象

Hash存贮为:

redis> HMSET myhash field1 "Hello" field2 "World"
"OK"
redis> HGET myhash field1
"Hello"
redis> HGET myhash field2
"World"

redis> HGETALL myhash

List（列表） Redis 列表是简单的字符串列表，按照插入顺序排序

Set（集合）

Redis的Set是string类型的无序集合

redis 127.0.0.1:6379> sadd runoob redis
(integer) 1
redis 127.0.0.1:6379> sadd runoob mongodb
(integer) 1
redis 127.0.0.1:6379> sadd runoob rabitmq
(integer) 1
redis 127.0.0.1:6379> sadd runoob rabitmq
(integer) 0
redis 127.0.0.1:6379> smembers runoob

1) "redis"
2) "rabitmq"
3) "mongodb

zset(sorted set：有序集合)

Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。

不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

zset的成员是唯一的,但分数(score)却可以重复。

zadd 命令

添加元素到集合，元素在集合中存在则更新对应score

zadd key score member

实例

redis 127.0.0.1:6379> zadd runoob 0 redis
(integer) 1
redis 127.0.0.1:6379> zadd runoob 0 mongodb
(integer) 1
redis 127.0.0.1:6379> zadd runoob 0 rabitmq
(integer) 1
redis 127.0.0.1:6379> zadd runoob 0 rabitmq
(integer) 0
redis 127.0.0.1:6379> > ZRANGEBYSCORE runoob 0 1000
1) "mongodb"
2) "rabitmq"
3) "redis"

Java 使用JRedis对redis的基本操作

package cn.spring.test.utils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.alibaba.fastjson.JSON;
import com.google.common.annotations.VisibleForTesting;

import redis.clients.jedis.Jedis;
import springfox.documentation.spring.web.json.Json;

/**
 * 最简单的封装，为了便于测试，所以未封装方法
 * Redis: String 的value值可以按照序列化二进制存贮，也可以按照文本格式存贮，也可以按照Json格式进行存贮，key则可以按照二进制或者String存贮，但是最终实际key都是转化为字符串进行统一处理的
 */

public class RedisMainTest {

// Jredis依赖包
//       <dependency>
//            <groupId>org.springframework.session</groupId>
//            <artifactId>spring-session-data-redis</artifactId>
//            <version>1.2.2.RELEASE</version>
//            <type>pom</type>
//        </dependency>

//       <dependency>
//            <groupId>com.alibaba</groupId>
//            <artifactId>fastjson</artifactId>
//            <version>1.2.4</version>
//        </dependency>

    /**
     * 方法一:测试redis链接是否成功
     */
    public static void testMehtod1AboutRedisConnetTest() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //查看服务是否运行
        System.out.println("服务正在运行: " + jedis.ping());
    }

    /**
     * 方法二: redis设置String, 以序列化格式存贮,存贮结构为key--->value
     * 类似java  结构  String name = "zhangsan" ;  name为key, zhangsan为value
     */
    public static void testMehtod2AboutRedisString() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //设置 redis 字符串数据
        jedis.set("simpleReidsString", "最简单的String存贮");
        // 获取存储的数据并输出
        System.out.println("redis 存储的字符串为: " + jedis.get("simpleReidsString"));

    }

    /**
     * 方法二: redis设置String, 以序列化格式存贮 存贮结构为key--->value
     */
    public static void testMehtod3AboutRedisString() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //设置 redis 字符串数据
        jedis.set("stringSerize".getBytes(), SerializeUtil.serialize("这个是String序列化进行存贮的"));
        // 获取存储的数据并输出
        System.out.println("redis 存储的字符串为: " + SerializeUtil.unSerialize(jedis.get("stringSerize".getBytes())));

        //存贮结果为:\xAC\xED\x00\x05t\x00'\xE8\xBF\x99\xE4\xB8\xAA\xE6\x98\xAFString\xE5\xBA\x8F\xE5\x88\x97\xE5\x8C\x96\xE8\xBF\x9B\xE8\xA1\x8C\xE5\xAD\x98\xE8\xB4\xAE\xE7\x9A\x84
    }

    /***
     * 方法四，redis String存贮实体对象,存贮实体对象必须进行序列化 存贮结构为key--->value
     *
     */
    public static void testMehtod4AboutRedisString() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //设置 redis 字符串数据
        User user = new User();
        user.setAge(1);
        user.setPassWord("xserworuwr");
        user.setUserName("test2");
        jedis.set("userInfo".getBytes(), SerializeUtil.serialize(user));

        User userJedis = (User) SerializeUtil.unSerialize(jedis.get("userInfo".getBytes()));
        // 获取存储的数据并输出
        System.out.println("redis 存储的序列化的对象为: " + JSON.toJSONString(userJedis));

        //存贮结果为:\xAC\xED\x00\x05sr\x00\x19cn.spring.test.utils.User\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x03I\x00\x03ageL\x00\x08passWordt\x00\x12Ljava/lang/String;L\x00\x08userNameq\x00~\x00\x01xp\x00\x00\x00\x01t\x00\x0Axserworuwrt\x00\x05test2
        //输出值为: 连接成功    redis 存储的序列化的对象为: {"age":1,"passWord":"xserworuwr","userName":"test2"}
    }

    /**
     * 方法五, redis String存贮实体对象,以json的格式进行存贮  存贮结构为key--->value
     */

    public static void testMehtod5AboutRedisString() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //设置 redis 字符串数据
        User user = new User();
        user.setAge(1);
        user.setPassWord("xserworuwr");
        user.setUserName("test2");
        jedis.set("userInfoJson", JSON.toJSONString(user));

        String userJedis = jedis.get("userInfoJson");
        ;
        // 获取存储的数据并输出
        System.out.println("redis 存储的序列化的对象为: " + userJedis);

    }

    /**
     * 方法六  redis Set 类型测试, set类型的value值可以为String，序列化之后的对象值，以及Json值
     * 存贮结构为 key --->  typeSetAll ,  --->value(1,2,3) ,value为无序
     * 类似于java Set, Set<String> typeSetAll = new HashSet<String>(); set.add("apple");set.add("pear");
     * 其中typeSetAll 为key,value为apple,pear,且无序
     */
    public static void testMehtod6AboutRedisSet() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");

        jedis.sadd("typesSet", "value1", "value2", "value3");
        Set<String> myset = jedis.smembers("typesSet");
        System.out.println("typesSet = " + myset);


    }

    /**
     * 方法六  redis Set 类型测试, value值分别为String, json ,序列化之后的值等
     * 存贮结构为 key --->  typeSetAll ,  --->value(1,2,3) ,value为无序
     * result
     * {
     * "cn.spring.test.utils.User@33833882": {
     * "age": 12,
     * "passWord": "UserLis@PWD",
     * "userName": "userLisi"
     * },
     * "value1": "value1",
     * "{\"password\":\"lisi@12313\",\"username\":\"zhangsan\"}": "{\"password\":\"lisi@12313\",\"username\":\"zhangsan\"}"
     * }
     */
    public static void testMehtod7AboutRedisSet() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        String value1 = "简单的String值";
        Map<String, String> value2 = new HashMap<String, String>();
        value2.put("username", "zhangsan");
        value2.put("password", "lisi@12313");

        User user = new User();
        user.setUserName("userLisi");
        user.setPassWord("UserLis@PWD");
        user.setAge(12);

        jedis.sadd("typeSetAll", "value1");
        jedis.sadd("typeSetAll", JSON.toJSONString(value2));
        jedis.sadd("typeSetAll".getBytes(), SerializeUtil.serialize(user));

        //在获取的时候，则必须按照byte进行来获取了，否则会存在问题
        //  Set<String> myset = jedis.smembers("typeSetAll");

        Set<byte[]> bytes = jedis.smembers("typeSetAll".getBytes());

        Map<String, Object> mapResult = new HashMap<String, Object>();
        for (byte[] aByte : bytes) {

            Object obs = SerializeUtil.unSerialize(aByte);
            System.out.println(obs);
            if (obs == null) {
                mapResult.put(new String(aByte), new String(aByte));
                new String(aByte);
            } else {
                mapResult.put(obs.toString(), obs);
            }
        }

        System.out.println("result is " + JSON.toJSONString(mapResult));

        //   System.out.println("typesSet = " + bytes);


    }

    /**
     * about redis Hash, hmest,hgetAll
     * 存贮结构为 key ---> hashKey --->hashKey1--> value1  hashKey2--->value2
     * *类似于Map<String> type =  new HashMap<String>(); type.add("book","boooks");
     * type.add("desk","desks");其中Hash里面的key为type，对应里面的子的key为book和desk
     * 其中key可以为Json, byte, String, 二进制等值，value也同此, Redis Hmset 命令
     */

    public static void testMehtod8AboutRedisHash() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");

        User user = new User();
        user.setUserName("userLisi");
        user.setPassWord("UserLis@PWD");
        user.setAge(12);

        Map<String, String> json = new HashMap<String, String>();
        json.put("username", "zhangsan");
        json.put("password", "lisi@12313");

        Map<byte[], byte[]> bytes = new HashMap<byte[], byte[]>();
        bytes.put("user".getBytes(), SerializeUtil.serialize(user));
        bytes.put("userName".getBytes(), "zhangsan".getBytes());
        bytes.put("userJson".getBytes(), JSON.toJSONString(json).getBytes());

        jedis.hmset("user".getBytes(), bytes);
        // hgetAll(byte[] key)

        Map<byte[], byte[]> resultMap = jedis.hgetAll("user".getBytes());


        Map<String, Object> mapResult = new HashMap<String, Object>();

        for (byte[] aByte : resultMap.keySet()) {
            Object obs = SerializeUtil.unSerialize(resultMap.get(aByte));
            System.out.println(obs);
            if (obs == null) {

                mapResult.put(new String(aByte), new String(resultMap.get(aByte)));
            } else {
                mapResult.put(new String(aByte), obs);
            }
        }

        System.out.println(JSON.toJSONString(mapResult));

    }


    /**
     * redis List   lpush  lrange
     *
     * @param args
     */
    public static void testMehtod9AboutRedisList() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");

        Map<String, String> json = new HashMap<String, String>();
        json.put("username", "zhangsan");
        json.put("password", "lisi@12313");

        User user = new User();
        user.setUserName("userLisi");
        user.setPassWord("UserLis@PWD");
        user.setAge(12);

        jedis.lpush("list".getBytes(), JSON.toJSONString(json).getBytes(), SerializeUtil.serialize(user));


        List<byte[]> lists = jedis.lrange("list".getBytes(), 0, 3);

        List<Object> list = new ArrayList<Object>();

        for (byte[] aByte : lists) {
            Object obs = SerializeUtil.unSerialize(aByte);

            if (obs == null) {
                list.add(new String(aByte));

            } else {

                list.add(obs);
            }
        }
        System.out.println(JSON.toJSONString(list));

    }


    public static void testMehtod10AboutRedisListTimeOut() {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");

        Map<String, String> json = new HashMap<String, String>();
        json.put("username", "zhangsan");
        json.put("password", "lisi@12313");

        User user = new User();
        user.setUserName("userLisi");
        user.setPassWord("UserLis@PWD");
        user.setAge(12);

        jedis.lpush("list1".getBytes(), JSON.toJSONString(json).getBytes(), SerializeUtil.serialize(user));


        jedis.expire("list1", 10);//设置过期时间为10秒

        List<byte[]> lists = jedis.lrange("list1".getBytes(), 0, 3);

        List<Object> list = new ArrayList<Object>();

        for (byte[] aByte : lists) {
            Object obs = SerializeUtil.unSerialize(aByte);

            if (obs == null) {
                list.add(new String(aByte));

            } else {

                list.add(obs);
            }
        }
        System.out.println(JSON.toJSONString(list));

    }


    /**
     * redis List   redis keyTime out
     *
     * @param args
     */
    public static void testMehtod10AboutRedisKeyTimeOut() {
        // NX是不存在时才set， XX是存在时才set， EX是秒，PX是毫秒
        Long expireSecond = 10l;

        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");

        String key = "simpleReidsString";
        boolean keyExists = jedis.exists(key);
        if (keyExists) {
            System.out.println("不做任何处理" + jedis.get(key));
        } else {
            jedis.set(key, System.currentTimeMillis() + "", "NX", "EX", expireSecond);
        }

        // jedis.set();
        // 获取存储的数据并输出
        System.out.println("redis 存储的字符串为: " + jedis.get(key));
    }


    public static void main(String args[]) {
        testMehtod9AboutRedisList();
        testMehtod10AboutRedisListTimeOut();
    }


}

class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String userName;
    private String passWord;
    private int age;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String password) {
        this.passWord = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


class SerializeUtil {
    /**
     * 序列化
     */
    public static byte[] serialize(Object obj) {

        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;

        try {
            // 序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);

            oos.writeObject(obj);


            byte[] byteArray = baos.toByteArray();
            return byteArray;

        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 反序列化
     *
     * @param bytes
     * @return
     */
    public static Object unSerialize(byte[] bytes) {

        ByteArrayInputStream bais = null;

        try {
            // 反序列化为对象
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();

        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return null;
    }
}

JCache、EhCache、Hazelcast、Redis、Guava ，Spring自身不提供缓存的存储实现，需要借助第三方，比如JCache、EhCache、Hazelcast、Redis、Guava等。Spring Boot可以自动化配置合适的缓存管理器（CacheManager），默认采用的是ConcurrentMapCacheManager