SpringBoot integriert JSON-Serialisierungsordneroperationen von Reids

Vorwort

Kürzlich wurde Redis im Entwicklungsprojekt als Cache verwendet, um die Systemzugriffsgeschwindigkeit zu verbessern und den Systemdruck zu verringern sowie die Benutzerreaktion und Zugriffsgeschwindigkeit zu verbessern. Hier sind einige Probleme, die zusammengefasst und gelöst werden müssen

schnelle Konfiguration

Für SpringBoot ist es sehr praktisch, Redis mit einem speziellen Szenenstarter zu integrieren.

   <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

Wenn Sie zur Einführung den Redis-Verbindungspool verwenden

        <!-- redis连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

Integrationsprofil

#------------------redis缓存配置------------
# Redis数据库索引（默认为 0）
spring.redis.database=1
# Redis服务器地址
spring.redis.host= 127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis 密码
spring.redis.password
# 连接超时时间（毫秒）
spring.redis.timeout= 5000
# redis连接池
# 连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=10
# 连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle= 500
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=2000
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.lettuce.pool.max-wait=10000

JSON-Serialisierung

Da die zwischengespeicherten Daten standardmäßig die mit jdk
gelieferte serialisierte Binärdatei verwenden , erbt die Entitätsklasse, die serialisiert werden muss, die Serializable- Schnittstelle. Und der serialisierte Inhalt sieht in Redis auch nicht sehr praktisch aus.

\xAC\xED\x00\x05sr\x00Lorg.springframework.security.oauth2.common.DefaultExpiringOAuth2RefreshToken/\xDFGc\x9D\xD0\xC9\xB7\x02\x00\x01L\x00\x0Aexpirationt\x00\x10Ljava/util/Date;xr\x00Dorg.springframework.security.oauth2.common.DefaultOAuth2RefreshTokens\xE1\x0E\x0AcT\xD4^\x02\x00\x01L\x00\x05valuet\x00\x12Ljava/lang/String;xpt\x00$805a75f7-2ee2-4a27-a598-591bfa1cf17dsr\x00\x0Ejava.util.Datehj\x81\x01KYt\x19\x03\x00\x00xpw\x08\x00\x00\x01}y\x81\xDB\x9Ax

So entstand die Idee, die Daten in JSON zu serialisieren.

Jackson-Serialisierung

Bei Verwendung von spring-data-redis wird standardmäßig die Klasse org.springframework.data.redis.serializer.JdkSerializationRedisSerializer für die Serialisierung verwendet. Die Jackson-Redis- Serialisierung wird mit Spring geliefert. Wir verwenden die Jackson-Methode

@Bean
    @ConditionalOnClass(RedisOperations.class)
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    
    
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        //序列化包括类型描述 否则反向序列化实体会报错，一律都为JsonObject
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(mapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用 String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的 key也采用 String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用 jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的 value序列化方式采用 jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

Der nach der Serialisierung in Redis gespeicherte Inhalt

[
  "com.qhong.test.dependBean.Person",
  {
    
    
    "age": 20,
    "name": "name0",
    "iss": true
  }
]

[
  "java.util.ArrayList",
  [
    [
      "com.qhong.test.dependBean.Person",
      {
    
    
        "age": 20,
        "name": "name0",
        "iss": true
      }
    ],
    [
      "com.qhong.test.dependBean.Person",
      {
    
    
        "age": 21,
        "name": "name1",
        "iss": true
      }
    ],
    [
      "com.qhong.test.dependBean.Person",
      {
    
    
        "age": 22,
        "name": "name2",
        "iss": true
      }
    ]
  ]
]

Das Obige entspricht nicht unbedingt der JSON- Formatspezifikation, ist jedoch besser als die Standardbinärdatei

Achten Sie hier darauf, den JSON-Generierungstyp zu serialisieren. "com.qhong.test.dependBean.Person"Wenn keine solche Deserialisierung vorhanden ist, wird ein Ausnahmefehler bei der Typkonvertierung gemeldet.

Das heißt, dieser Abschnitt des Codes muss festgelegt werden. Ich habe ihn zuvor nicht festgelegt. Die Deserialisierung ist JsonObject und der Typ muss selbst konvertiert werden, andernfalls wird ein Fehler gemeldet.

//序列化包括类型描述 否则反向序列化实体会报错，一律都为JsonObject
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(mapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);

Fastjson-Serialisierung

1. Fastjson muss in die Abhängigkeit importiert werden

<!-- JSON工具 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.76</version>
</dependency>

2. Implementieren Sie die RedisSerializer-Schnittstelle

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
    
    

    public static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;

    static {
    
    
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }

    private final Class<T> clazz;

    public FastJson2JsonRedisSerializer(Class<T> clazz) {
    
    
        super();
        this.clazz = clazz;
    }

    /**
     * 序列化
     */
    @Override
    public byte[] serialize(T t) throws SerializationException {
    
    
        if (null == t) {
    
    
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    /**
     * 反序列化
     */
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
    
    
        if (null == bytes || bytes.length <= 0) {
    
    
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return (T) JSON.parseObject(str, clazz);
    }
}

3. Konfigurieren Sie redisTemplate

import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisCacheAutoConfiguration {
    
    

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
    
    
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        FastJson2JsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJson2JsonRedisSerializer<>(Object.class);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);

        // value序列化方式采用fastJson
        template.setValueSerializer(fastJsonRedisSerializer);
        // hash的value序列化方式采用fastJson
        template.setHashValueSerializer(fastJsonRedisSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

Beachten Sie, dass dies eine Möglichkeit ist, die RedisSerializer-Serialisierungsschnittstelle selbst zu implementieren,
FastJson Version 1.2.36 erfordert jedoch keine Implementierung von RedisSerializer selbst

Um uns Serialisierungsunterstützung zu bieten, gibt es in com.alibaba.fastjson.support.spring zwei Implementierungsklassen :GenericFastJsonRedisSerializerFastJsonRedisSerializer

Der Unterschied besteht darin, dass GenericFastJsonRedisSerializerder Objekttyp automatisch konvertiert werden kann und FastJsonRedisSerializerder für die Konvertierung erforderliche Typ angepasst werden muss.

Normalerweise kann die Verwendung von GenericFastJsonRedisSerializer die meisten Szenarien erfüllen. Wenn Sie einen bestimmten Typ einer dedizierten RedisTemplate definieren möchten, können Sie FastJsonRedisSerializer anstelle von GenericFastJsonRedisSerializer verwenden.

FastJson Github hat eine entsprechende Problembeschreibung . Ich war in der Grube und habe am Anfang FastJsonRedisSerializer verwendet . ****Kann nicht automatisch deserialisiert werden

Der nach der Serialisierung in Redis gespeicherte Inhalt

{
    
    
  "@type": "com.qhong.test.dependBean.Person",
  "age": 20,
  "iss": true,
  "name": "name0"
}

[
  {
    
    
    "@type": "com.qhong.test.dependBean.Person",
    "age": 20,
    "iss": true,
    "name": "name0"
  },
  {
    
    
    "@type": "com.qhong.test.dependBean.Person",
    "age": 21,
    "iss": true,
    "name": "name1"
  },
  {
    
    
    "@type": "com.qhong.test.dependBean.Person",
    "age": 22,
    "iss": true,
    "name": "name2"
  }
]

Normalerweise ist das Format korrekt. Wenn Ihr gespeicherter Inhalt jedoch einen Set- oder Double-Typ hat, wird ein Set angezeigt, und der D-Typ wird wie folgt beschrieben

Es wird Probleme geben, die nicht analysiert werden können, aber im Programm deserialisiert werden können

Analyse-Referenzvergleich

1. jdkSerializationRedisSerializer:Nutzen Sie die vom JDK bereitgestellte Serialisierungsfunktion. Der Vorteil besteht darin, dass beim Deserialisieren keine Typinformationen (Klasse) bereitgestellt werden müssen. Der Nachteil besteht jedoch darin, dass die serialisierbare Schnittstelle implementiert werden muss und das Ergebnis nach der Serialisierung sehr groß ist, was etwa dem Fünffachen des JSON-Formats entspricht. Dies verbraucht viel Speicher auf dem Redis-Server.

2. Jackson2JsonRedisSerializer：Verwenden Sie die Jackson-Bibliothek, um das Objekt in einen JSON-String zu serialisieren. Der Vorteil besteht darin, dass die Geschwindigkeit hoch ist, die serialisierte Zeichenfolge kurz und kompakt ist und keine Notwendigkeit besteht, die serialisierbare Schnittstelle zu implementieren. Der Nachteil ist jedoch auch sehr schwerwiegend: Im Konstruktor dieser Klasse gibt es einen Typparameter, und die Typinformationen (.class-Objekt) des zu serialisierenden Objekts müssen bereitgestellt werden. Wenn man sich den Quellcode ansieht, stellt man fest, dass er beim Deserialisierungsprozess nur Typinformationen verwendet.

3. FastJsonRedisSerializerDie beste Leistung wird als schnellste JSON-Parsing-Bibliothek bezeichnet, aber nach der Deserialisierung stimmt die Reihenfolge der Klassenfelder nicht mit der ursprünglichen Entitätsklasse überein und ändert sich. Bei einigen Set- und Double-Feldern ist das JSON-Format falsch, aber es kann im Programm analysiert werden

Weitere Fragenreferenz

Interpretation der RedisTemplate-Serialisierungsmethode

Redis-Datenbankbetrieb

Nach der Integration spring-boot-starter-data-rediswerden redisTemplatefür uns automatisch Objekte eingefügt, die speziell für den Betrieb der Reids-Datenbank verwendet werden

Wenn Sie Schlüssel in Ordnern in Reids speichern möchten, sieht das so aus

Wir müssen :: nur verwenden, um Ordner im Speicher darzustellen

redisTemplate.opsForValue().set("userLoginCache::Kenx_6003783582be4c368af14daf3495559c", "user");

Wenn Sie einen Fuzzy-Abfrageschlüssel benötigen, verwenden Sie ihn, *um z. B. auszudrücken

1. Holen Sie sich alle Schlüssel

public static Set<String> getAllKey(String keys) {
    
    
        Set<String> key = redisTemplate.keys(keys + "*");
        return key;
    }

2. Fuzzy-Batch-Löschen

 /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public static void del(String... key) {
    
    
        if (key != null && key.length > 0) {
    
    
            if (key.length == 1) {
    
    
                redisTemplate.delete(key[0]);
            } else {
    
    
                redisTemplate.delete(Arrays.asList(key));
            }
        }
    }

public static void delByPrefix(String key) {
    
    
        if (key != null) {
    
    
            Set<String> keys = redisTemplate.keys(key + "*");
            redisTemplate.delete(keys);
        }
    }

    public static void delBySuffix(String key) {
    
    
        if (key != null) {
    
    
            Set<String> keys = redisTemplate.keys("*" + key);
            redisTemplate.delete(keys);
        }
    }

    public static  void clean(){
    
    
        Set<String> keys = redisTemplate.keys("*");
        redisTemplate.delete(keys);
    }

Da es häufig verwendet wird, habe ich es als Werkzeugbibliothek geschrieben RedisUtilund über eine statische Methode aufgerufen.

Enthält grundsätzlich alle in der Arbeit verwendeten Methoden, der Quellcode ist hier beigefügt

package cn.soboys.kmall.cache.utils;

import cn.hutool.extra.spring.SpringUtil;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * 定义常用的 Redis操作
 *
 * @author kenx
 */

public class RedisUtil {
    
    

    private static final RedisTemplate<String, Object> redisTemplate = SpringUtil.getBean("redisTemplate", RedisTemplate.class);


    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return Boolean
     */
    public static Boolean expire(String key, Long time) {
    
    
        try {
    
    
            if (time > 0) {
    
    
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key获取过期时间
     *
     * @param key 键 不能为 null
     * @return 时间(秒) 返回 0代表为永久有效
     */
    public static Long getExpire(String key) {
    
    
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public static Boolean hasKey(String key) {
    
    
        try {
    
    
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public static void del(String... key) {
    
    
        if (key != null && key.length > 0) {
    
    
            if (key.length == 1) {
    
    
                redisTemplate.delete(key[0]);
            } else {
    
    
                redisTemplate.delete(Arrays.asList(key));
            }
        }
    }

    public static void delByPrefix(String key) {
    
    
        if (key != null) {
    
    
            Set<String> keys = redisTemplate.keys(key + "*");
            redisTemplate.delete(keys);
        }
    }

    public static void delBySuffix(String key) {
    
    
        if (key != null) {
    
    
            Set<String> keys = redisTemplate.keys("*" + key);
            redisTemplate.delete(keys);
        }
    }

    public static  void clean(){
    
    
        Set<String> keys = redisTemplate.keys("*");
        redisTemplate.delete(keys);
    }

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public static Object get(String key) {
    
    
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public static Boolean set(String key, Object value) {
    
    
        try {
    
    
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public static Boolean set(String key, Object value, Long time) {
    
    
        try {
    
    
            if (time > 0) {
    
    
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
    
    
                set(key, value);
            }
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return Long
     */
    public static Long incr(String key, Long delta) {
    
    
        if (delta < 0) {
    
    
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几
     * @return Long
     */
    public static Long decr(String key, Long delta) {
    
    
        if (delta < 0) {
    
    
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * HashGet
     *
     * @param key  键 不能为 null
     * @param item 项 不能为 null
     * @return 值
     */
    public static Object hget(String key, String item) {
    
    
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取 hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public static Map<Object, Object> hmget(String key) {
    
    
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 获取 hashKey对应的所有键
     *
     * @param key 键
     * @return 对应的多个键
     */
    public static Set<String> hmgetKey(String key) {
    
    
        Map map = redisTemplate.opsForHash().entries(key);
        return map.keySet();
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public static Boolean hmset(String key, Map<String, Object> map) {
    
    
        try {
    
    
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public static Boolean hmset(String key, Map<String, Object> map, Long time) {
    
    
        try {
    
    
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
    
    
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public static Boolean hset(String key, String item, Object value) {
    
    
        try {
    
    
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public static Boolean hset(String key, String item, Object value, Long time) {
    
    
        try {
    
    
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
    
    
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为 null
     * @param item 项 可以使多个不能为 null
     */
    public static void hdel(String key, Object... item) {
    
    
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为 null
     * @param item 项 不能为 null
     * @return true 存在 false不存在
     */
    public static Boolean hHasKey(String key, String item) {
    
    
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return Double
     */
    public static Double hincr(String key, String item, Double by) {
    
    
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return Double
     */
    public static Double hdecr(String key, String item, Double by) {
    
    
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    /**
     * 根据 key获取 Set中的所有值
     *
     * @param key 键
     * @return Set
     */
    public static Set<Object> sGet(String key) {
    
    
        try {
    
    
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public static Boolean sHasKey(String key, Object value) {
    
    
        try {
    
    
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public static Long sSet(String key, Object... values) {
    
    
        try {
    
    
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public static Long sSetAndTime(String key, Long time, Object... values) {
    
    
        try {
    
    
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
    
    
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return Long
     */
    public static Long sGetSetSize(String key) {
    
    
        try {
    
    
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public static Long setRemove(String key, Object... values) {
    
    
        try {
    
    
            return redisTemplate.opsForSet().remove(key, values);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return List
     */
    public static List<Object> lGet(String key, Long start, Long end) {
    
    
        try {
    
    
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return Long
     */
    public static Long lGetListSize(String key) {
    
    
        try {
    
    
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；
     *              index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return Object
     */
    public static Object lGetIndex(String key, Long index) {
    
    
        try {
    
    
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return Boolean
     */
    public static Boolean lSet(String key, Object value) {
    
    
        try {
    
    
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return Boolean
     */
    public static Boolean lSet(String key, Object value, Long time) {
    
    
        try {
    
    
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
    
    
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return Boolean
     */
    public static Boolean lSet(String key, List<Object> value) {
    
    
        try {
    
    
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return Boolean
     */
    public static Boolean lSet(String key, List<Object> value, Long time) {
    
    
        try {
    
    
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
    
    
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return Boolean
     */
    public static Boolean lUpdateIndex(String key, Long index, Object value) {
    
    
        try {
    
    
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public static Long lRemove(String key, Long count, Object value) {
    
    
        try {
    
    
            return redisTemplate.opsForList().remove(key, count, value);
        } catch (Exception e) {
    
    
            e.printStackTrace();
            return 0L;
        }
    }

    public static Set<String> getAllKey(String keys) {
    
    
        Set<String> key = redisTemplate.keys(keys + "*");
        return key;
    }


}