`

redis存储对象和集合

 
阅读更多
使用redis存储对象或集合时，不能直接存储。需要将对象或集
合通过序列化转换为可存储的json，这里使用了fastjson来转型
redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、

       zset(sorted set --有序集合)和hash（哈希类型）

所用到的依赖,可以在maven仓库中查找

<!-- redis客户端:Jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.7.3</version>
</dependency>
<!-- https://mvnrepository.com/artifact/net.sf.json-lib/json-lib -->
<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
</dependency>
1.redis工具类，里面写了部分redis常用命令
package com.bcc.util;

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

import org.apache.commons.lang.StringUtils;

import com.fasterxml.jackson.databind.ObjectMapper;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.util.SafeEncoder;

public class jedisUtil {

   
   
        private static String HOST = "localhost";
        private static int PORT = 6379;
    
        private static JedisPool pool = null;
    
        static {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(128);
            config.setMaxIdle(80);
            config.setMaxWaitMillis(2001);
    
                pool = new JedisPool(config, HOST, PORT, 2000);
        }
    
        /**
         * 把key存入redis中
         *
         * @param key     k
         * @param value   v
         * @param seconds 过期时间（秒）
         * @return boolean
         */
        public static boolean set(byte[] key, byte[] value, int seconds) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                String result = jedis.set(key, value);
                if (seconds > 0) {
                    Long r = jedis.expire(key, seconds);
                }
            } catch (Exception e) {
                return false;
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return true;
        }
    
        public static byte[] get(byte[] key) {
            byte[] value = null;
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                value = jedis.get(key);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return value;
        }
    
    
        /**
         * 向缓存中设置对象
         *
         * @param key key
         * @param obj value
         * @return boolean
         */
        public static boolean set(String key, Object obj, Integer seconds) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                ObjectMapper mapper = new ObjectMapper();
                String value = mapper.writeValueAsString(obj);
                jedis.set(SafeEncoder.encode(key), SafeEncoder.encode(value));
                if (seconds != null) {
                    jedis.expire(key, seconds);
                }
                return true;
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return false;
        }
    
    
        /**
         * 向缓存中设置对象
         *
         * @param key   key
         * @param value value
         * @return boolean
         */
        public static boolean set(String key, String value, Integer seconds) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                jedis.set(SafeEncoder.encode(key), SafeEncoder.encode(value));
                if (seconds != null) {
                    jedis.expire(key, seconds);
                }
                return true;
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return false;
        }
    
        /**
         * 移除缓存中设置对象
         *
         * @param keys 被删除的KEYS
         * @return Long 被删除个数
         */
        public static Long del(String... keys) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.del(keys);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        /**
         * 根据key 获取对象
         *
         * @param key key
         * @return T
         */
        public static <T> T get(String key, Class<T> clazz) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                String v = jedis.get(key);
                if (StringUtils.isNotEmpty(v)) {
                    ObjectMapper mapper = new ObjectMapper();
                    return mapper.readValue(v, clazz);
                }
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        /**
         * 根据key值得到String类型的返回值
         *
         * @param key key
         * @return String
         */
        public static String get(String key) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                String v = jedis.get(key);
                if (StringUtils.isNotEmpty(v)) {
                    return v;
                }
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        public static Boolean exists(String key) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.exists(key);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        /**
         * redis的list操作：
         * 把元素插入到列表的尾部
         *
         * @param key     KEY
         * @param strings 要插入的值，变参
         * @return 返回插入后list的大小
         */
        public static Long rpush(String key, String... strings) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.rpush(key, strings);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        /**
         * redis的list操作：
         * 根据开始与结束下标取list中的值
         *
         * @param key   KEY
         * @param start 开始下标
         * @param end   结束下标
         * @return List<String>
         */
        public static List<String> lrange(String key, int start, int end) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.lrange(key, start, end);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        /**
         * redis的list操作：
         * 取列表的长度
         *
         * @param key key
         * @return Long
         */
        public static Long llen(String key) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.llen(key);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        /**
         * redis的list操作：
         * 根据值移除list中的元素
         *
         * @param key   KEY
         * @param count ：
         *              count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
         *              count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
         *              count = 0 : 移除表中所有与 value 相等的值。
         * @param value 要删除的值
         * @return 返回被移除的个数
         */
        public static Long lrem(String key, long count, String value) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.lrem(key, count, value);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        public static boolean setLong(String key, Long value) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return "OK".equals(jedis.set(key, String.valueOf(value)));
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return false;
        }
    
        public static Long getLong(String key) {
            String result = get(key);
            return result == null ? null : Long.valueOf(result);
        }
    
    
        public static Long incrBy(String key, Long increment) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.incrBy(key, increment);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        public static Long hashSet(String key, String field, String value) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.hset(key, field, value);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return -1L;
        }
    
        public static Long hashSetLong(String key, String field, Long value) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.hset(key, field, String.valueOf(value));
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return -1L;
        }
    
        public static Long hashIncrBy(String key, String field, Long increment) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.hincrBy(key, field, increment);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return -1L;
        }
    
        public static Map<String, String> hashGetAll(String key) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.hgetAll(key);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
    
        public static Set<String> hashKeys(String key) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.hkeys(key);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }
    
        public static Long hashDelAll(String key, String... fields) {
            Jedis jedis = null;
            try {
                jedis = pool.getResource();
                return jedis.hdel(key, fields);
            } catch (Exception e) {
            } finally {
                if (null != jedis) {
                    jedis.close();
                }
            }
            return null;
        }   
}

2.实现类中调用
package com.bcc.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.bcc.dao.usermapper;
import com.bcc.pojo.City;
import com.bcc.util.jedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class userserviceimpl implements userservice{
    @Autowired
    private usermapper um;

            //这里展示一个简单的查询方法，返回的是list集合，把list集合存入redis

@Override
    public List<City> listCity(String sname) {
        //首先先判断redis中是否存在该key值
        String aa1 = jedisUtil.get("aoo");

        if (aa1==null){ 

        //若不存在首先走一下方法，从数据库中查询数据

            List<City> cities  = um.listCity(sname);

          //然后调用JSON.toJSONString()方法转为json

            String ss = JSON.toJSONString(cities);

          //存入redis

            jedisUtil.set("aoo", ss, 10000*100000);
            return cities;
        }
        else {

           //若存在，将key值查询出来，此时的key值还是json形式

            String aoo = jedisUtil.get("aoo");

           //调用JSON.parseArray()方法转为list集合

            List<City> cities = JSON.parseArray(aoo,City.class);

            //JSON.parseObject方法是转为对象

            /*City city = JSON.parseObject(aoo, City.class);*/
            return cities;
        }

    }
}
分享到：
| c3p0代码动态切换数据源
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    redis存储List集合

    标题中的“redis存储List集合”指的是使用Redis数据库来存储列表数据结构。Redis是一个开源的、高性能的键值存储系统，支持多种数据结构，包括字符串、哈希、列表、集合、有序集合等。在这个示例中，重点是利用Redis...

    Redis如何存储对象与集合示例详解

    在本文中，我们将探讨Redis如何存储对象与集合，包括字符串(Strings)、列表(Lists)、集合(Sets)、有序集合(ZSets)以及哈希(Hashes)。 1. 字符串(Strings) 字符串是最基础的数据类型，它可以存储任何简单的文本或...

    使用.Net 技术操作Redis缓存技术，对Redis缓存进行存储增删改查等相关操作

    1. **存储数据**：Redis支持多种数据结构，如字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。例如，存储一个字符串键值对： ```csharp var db = redis.GetDatabase(); db...

    Redis启动，数据结构存储系统

    其数据结构丰富，支持字符串、哈希、列表、集合和有序集合等多种类型，使得Redis在处理各种复杂数据操作时表现出色。 1. **Redis的启动过程** Redis的启动主要包括以下步骤： - 首先，检查配置文件（默认为`redis...

    使用redis管理对象缓存，可代替session

    3. **数据结构丰富**: Redis支持多种数据结构，如字符串、哈希、列表、集合、有序集合等，方便处理各种复杂的数据场景。 4. **主从复制与集群**: 支持主从复制，可以构建高可用的分布式系统。Redis Cluster则提供了...

    JOhm 是一个 Java 的对象哈希映射库，用于在 Redis 中存储对象.zip

    JOhm 是一个 Java 的对象哈希映射库，用于在 Redis 中存储对象约翰JOhm 是一个速度超快的 Java 对象哈希映射库，其灵感来自超棒的Ohm。JOhm OHM 是 Hibernate 等旧 ORM 的现代化身，不同之处在于我们这里处理的不是 ...

    用Redis存储Tomcat集群的Session

    它的数据结构丰富，支持字符串、哈希、列表、集合和有序集合等，使得Redis成为存储Session的理想选择。 2. **Tomcat集群** Tomcat是一个流行的Java Servlet容器，用于部署和运行Java Web应用。当需要扩展服务或...

    redis字节码存压缩对象

    这些工具可能包括序列化/反序列化方法，用于将Java对象转换为适合Redis存储的字节码格式，以及压缩和解压缩方法。 - 这样的工具类能够帮助开发者更高效地与 Redis 交互，提高代码的可读性和可维护性，同时降低出错...

    redis存储数据.rar

    这两个模板提供了丰富的操作方法，如`opsForValue()`用于操作字符串，`opsForHash()`用于操作哈希，`opsForSet()`和`opsForZSet()`分别用于集合和有序集合。 例如，我们可以创建一个工具类，包含以下方法来存取键值...

    Redis安装包和Redis jar包

    1. **数据类型**：Redis的五大数据类型为字符串、哈希、列表、集合和有序集合，每种类型都有其特定的用途，如字符串适合存储简单的值，哈希用于存储对象，列表可以作为队列或栈，集合用于成员关系，有序集合则带有...

    Redis和RedisDesktop

    哈希则适用于存储对象，如用户信息；列表可以实现消息队列；集合用于存储无序的唯一元素；而有序集合则允许根据分数排序元素。 Redis还支持多种操作命令，如原子操作（如INCR、DECR）、订阅/发布（Pub/Sub）系统、...

    redis常用命令集合.pdf

    它支持多种类型的数据结构，如字符串、哈希表、链表、集合和有序集合等，广泛应用于缓存、会话管理、排行榜、实时分析等场景。以下是针对所给文档内容的知识点整理： 1. Redis数据类型及其使用场景 - String（字符...

    Redis的数据结构和对象系统介绍.docx

    Redis 是一个高性能的键值存储系统，其强大的功能和高效性能在很大程度上得益于它丰富的数据结构和对象系统。本文将详细介绍 Redis 中的数据结构和对象系统，帮助你更好地理解和利用 Redis。 1. 数据结构 1.1. ...

    redis-proto.cr：带有Protobuf对象的便捷Redis存储，用于Crystal

    **redis-proto.cr：带有Protobuf对象的便捷Redis存储，用于Crystal** `redis-proto.cr` 是一个专门为 Crystal 语言设计的库，它允许开发者方便地将基于 Protocol Buffers（Protobuf）的对象存储到 Redis 数据库中。...

    java实现用Redis来存储关注关系借鉴.pdf

    这样，我们可以快速地获取当前用户的关注对象集合和被关注的用户集合。 六、结论 本文介绍了如何使用 Java 语言和 Redis 存储关注关系。我们定义了 UserService 接口和 UserServiceImpl 实现类，并使用 Jedis ...

    redis的实战教学.pdf

    散列（Hash）：键值对集合，适合存储对象。每个散列可以存储多个字段和值之间的映射。 集合（Set）：无序集合，用于存储多个不重复的字符串元素，支持集合间的交集、并集和差集等操作。 有序集合（Sorted Set）：与...

    RedisRepository 分享和纠错

    在Redis中存储数据时，经常需要将对象序列化成可存储的格式，如二进制或JSON，然后再进行存储。读取时，再将这些数据反序列化成原始的对象。因此，这个类也是实现RedisRepository中不可或缺的一部分。 综上所述，...

    Redis in action，Redis入门指南和Redis实战三本书

    - 哈希：存储键值对的集合，适合表示对象或结构化数据。 - 列表：双向链表结构，支持在两端添加和删除元素，常用作消息队列。 - 集合：无序的唯一元素集合，支持并集、交集和差集操作。 - 有序集合：类似集合，...

Magicbox
Global site tag (gtag.js) - Google Analytics