RedisTemplate

Spring Boot中Jedis几个api返回值的确认

 

    @RequestMapping("/del/{key}")
    public String del(@PathVariable("key") String key) {
        try {
            //键不存在时，也不会抛异常
            redisTemplate.delete(key);
            return "Success";
        } catch (Exception e) {
            return e.getMessage();
        }
    }

 

RedisTemplate如果是按以下设置的话，直接对String类型使用get方法获取值时，会报以下的错。原因是存放的数据是经过Serialize的。deserialize就是会报错。网上给一个解决办法是使用get(0,-1).

但是，这种场景下，不能使用increment方法，因为存放的值是经过Serialize的，不是数字了，不能increment

这种场景可以使用StringRedisTemplate ，如上例所示

org.springframework.data.redis.serializer.SerializationException : Cannot deserialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException: Failed to deserialize payload. Is the byte array a result of corresponding serialization for DefaultDeserializer?; nested exception is java.io.EOFException

        RedisTemplate<StringRedisSerializer, Serializable> rt = new RedisTemplate<>();
        rt.setConnectionFactory(jedisConnectionFactory());
        JdkSerializationRedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();
        rt.setKeySerializer(new StringRedisSerializer());
        rt.setValueSerializer(jdkSerializationRedisSerializer);

 

package com.rest;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;


@RestController
public class TestRedisTemplateOperation {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/add")
    public String set() {
        String key = "mykey";
        stringRedisTemplate.boundValueOps(key).increment(1);
        return key;
    }

    @RequestMapping("/get")
    public String get() {
        String key = "mykey";
        //如果key不存在时，Jedis会返回空字符串（key中无值时，redis会删除这个key）
        return stringRedisTemplate.boundValueOps(key).get();
    }

    @RequestMapping("/getList")
    public String getList() {
        String key = "myList";
        //如果key不存在时，Jedis会返回空集合（key中无值时，redis会删除这个key）。这种场景的返回值为"[]"
        return redisTemplate.boundListOps(key).range(0, -1).toString();
    }

    @RequestMapping("/setList/{element}")
    public void setList(@PathVariable("element") String element) {
        String key = "myList";
        redisTemplate.boundListOps(key).leftPush(element);
    }

    /**
     * [null, null, null, null, null]true;true;true;true;true;
     * hash不存在时的Operation是否为null:false
     * hash不存在，或hash存在但Key不存在时，删除时也不会抛异常
     *
     * @return
     */
    @RequestMapping("/getHash")
    public String getHash() {
        String key = "myHash";
        Collection collection = Arrays.asList(1, 2, 3, 4, 5);
        //如果Hash不存在时，Jedis会给每个field返回一个null;存在的field会返回相关的值
        //下例中会返回  [null, null, null, null, null]true;true;true;true;true;
        List list = redisTemplate.boundHashOps(key).multiGet(collection);
        String result = list.toString();
        for (Object value : list) {
            result = result + (value == null) + ";";
        }
        redisTemplate.delete(key);
        result = result + " \n hash不存在时的Operation是否为null:" + (redisTemplate.boundHashOps(key) == null);

        //删除hash中不存在的key时，是否会抛异常
        String tmpKey = "myHash2";
        redisTemplate.boundHashOps(tmpKey).delete("notExistKey");
        redisTemplate.boundHashOps(tmpKey).put("key2-hash", "value2-hash");
        redisTemplate.boundHashOps(tmpKey).delete("notExistKey");
        result = result + " \n hash不存在，或hash存在但Key不存在时，删除时也不会抛异常";
        return result;
    }

    @RequestMapping("/setHash/{field}/{value}")
    public void setHash(@PathVariable("field") String field, @PathVariable("value") String value) {
        String key = "myHash";
        //执行hmset myHash 1 value1后
        //mget的返回值为[value1, null, null, null, null]false;true;true;true;true;
        redisTemplate.boundHashOps(key).put(field, value);
    }

    /**
     * 存放在Redis中的返回值：
     * {"keyWithNullValue":null,"keyEmptyArrayList":[],"key2":"key2"}
     */
    @RequestMapping("/set/hash/null")
    public void setHasWithNullValue() {
        String key = "myhashWithNull";
        redisTemplate.boundHashOps(key).put("keyWithNullValue", null);
        redisTemplate.boundHashOps(key).put("keyEmptyArrayList", new ArrayList<>());
        redisTemplate.boundHashOps(key).put("key2", "key2");
    }


    @RequestMapping("/redis/{key}")
    public String getRedisDataForkey(@PathVariable("key") String key) throws JsonProcessingException {

        if (!StringUtils.isEmpty(key) && redisTemplate.hasKey(key)) {
            ObjectMapper objectMapper = new ObjectMapper();

            DataType dataType = redisTemplate.type(key);
            String type = dataType.code();
            if ("string".equals(type)) {
                Object _obj = redisTemplate.opsForValue().get(key);
                return "string：" + objectMapper.writeValueAsString(_obj);
            }
            if ("list".equals(type)) {
                Object _obj = redisTemplate.boundListOps(key).range(0, -1);
                return "list：" + objectMapper.writeValueAsString(_obj);
            }
            if ("set".equals(type)) {
                Object _obj = redisTemplate.boundSetOps(key).members();
                return "set：" + objectMapper.writeValueAsString(_obj);
            }
            if ("zset".equals(type)) {
                Object _obj = redisTemplate.boundZSetOps(key).range(0, -1);
                return "zset：" + objectMapper.writeValueAsString(_obj);
            }
            if ("hash".equals(type)) {
                Object _obj = redisTemplate.boundHashOps(key).entries();
                return "Hash：" + objectMapper.writeValueAsString(_obj);
            }
            if ("none".equals(type)) {
                return "none：";
            }
        }
        return "no key";
    }

}

 

 

 

 

org.springframework.data.redis.core.RedisConnectionUtils

    private static void potentiallyRegisterTransactionSynchronisation(RedisConnectionHolder connHolder,
            final RedisConnectionFactory factory) {

        if (isActualNonReadonlyTransactionActive()) {

            if (!connHolder.isTransactionSyncronisationActive()) {
                connHolder.setTransactionSyncronisationActive(true);

                RedisConnection conn = connHolder.getConnection();
                conn.multi();//此处设置mutl

                TransactionSynchronizationManager.registerSynchronization(new RedisTransactionSynchronizer(connHolder, conn,
                        factory));
            }
        }
    }

org.springframework.data.redis.connection.jedis.JedisConnection

    public void multi() {
        if (isQueueing()) {
            return;
        }
        try {
            if (isPipelined()) {
                pipeline.multi();
                return;
            }
            this.transaction = jedis.multi();
        } catch (Exception ex) {
            throw convertJedisAccessException(ex);
        }
    }

 

redis.clients.jedis.BinaryJedis

  public Transaction multi() {
    client.multi();
    transaction = new Transaction(client);
    return transaction;
  }