Java 操作 Redis 五种数据类型

项目添加依赖

　　　　　<!-- Redis 依赖 -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

Java 怎么连接 Redis

//连接 Redis
    @Test
    public void initConn01(){
        System.out.println("==========================");
        System.out.println("==========================");
        System.out.println("==========================");
        // 创建 jedis 对象，连接 redis 服务
        Jedis jedis=new Jedis("192.168.75.163",6379);
        // 设置认证密码
        //jedis.auth("root");
        // 指定数据库 默认是 0
        jedis.select(1);
        // 使用 ping 命令，测试连接是否成功
        String result=jedis.ping();
        System.out.println(result);// 返回 PONG
        // 添加一条数据
        jedis.set("username","zhangsan");
        // 获取一条数据
        String username=jedis.get("username");
        System.out.println(username);
        // 释放资源
        if(jedis!=null){
            jedis.close();
        }
    }

看下输出结果

通过 Redis 连接池获取连接对象并操作服务器

private String host ="192.168.75.163";
private Integer port=6379;
@Test
    public void initConn02() {
        // 初始化 redis 客户端连接池
        JedisPool jedisPool = new JedisPool(new JedisPoolConfig(), host, port, 10000);
        // 从连接池获取连接
        Jedis jedis = jedisPool.getResource();
        // 指定数据库 默认是 0
        jedis.select(2);
        // 使用 ping 命令，测试连接是否成功
        String result = jedis.ping();
        System.out.println(result);// 返回 PONG
        // 添加一条数据
        jedis.set("username", "zhangsan");
        // 获取一条数据
        String username = jedis.get("username");
        System.out.println(username);
        // 释放资源
        if (jedis != null)
            jedis.close();
    }

封装 JedisUtil 对外提供连接对象获取方法

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
 * 实例化 Jedis 对象工具类
 */
public final class JedisUtil {
    //Redis 服务器 IP
    private static String ADDR = "192.168.75.163";
    //Redis 的端口号
    private static int PORT = 6379;
    //访问密码
    private static String AUTH = "root";
    //可用连接实例的最大数目，默认值为 8；
    //如果赋值为-1，则表示不限制；如果 pool 已经分配了 maxActive 个 jedis 实例，则此时 pool 的状态为 exhausted(耗尽)。
    private static int MAX_ACTIVE = 1024;
    //控制一个 pool 最多有多少个状态为 idle(空闲的)的 jedis 实例，默认值也是 8。
    private static int MAX_IDLE = 200;
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出 JedisConnectionException；
    private static int MAX_WAIT = 10000;
    private static int TIMEOUT = 10000;
    //在 borrow 一个 jedis 实例时，是否提前进行 validate 操作；如果为 true，则得到的 jedis 实例均是可用的；
    private static boolean TEST_ON_BORROW = true;
    private static JedisPool jedisPool = null;
    /**
     * 初始化 Redis 连接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            //jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取 Jedis 实例
     *
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null)
                return jedisPool.getResource();
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 释放 jedis 资源
     *
     * @param jedis
     */
    public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.close();
        }
    }
}

Java 操作 Redis 五种数据类型

连接与释放

Jedis jedis = null;
    /**
     * 连接 Redis
     */
    @Before
    public void initConn() {
        jedis = JedisUtil.getJedis();
    }
    /**
     * 释放资源
     */
    @After
    public void close() {
        JedisUtil.returnResource(jedis);
    }

1、操作 String

　　@Test
    public void testString() {
        // 添加一条数据
        jedis.set("username", "zhangsan");
        jedis.set("age", "18");
        // 添加多条数据 参数奇数为 key 参数偶数为 value
        jedis.mset("address", "bj", "sex", "1");
        // 获取一条数据
        String username = jedis.get("username");
        System.out.println(username);
        // 获取多条数据
        List<String> list = jedis.mget("username", "age", "address", "sex");
        for (String str : list) {
            System.out.println(str);
        }
        // 删除
        //jedis.del("username");
    }

看下结果

2、操作 hash

@Test
    public void testHash() {
        /*
         * 添加一条数据
         * 参数一：redis 的 key
         * 参数二：hash 的 key
         * 参数三：hash 的 value
         */
        jedis.hset("userInfo", "name", "lisi");
        // 添加多条数据
        Map<String, String> map = new HashMap<>();
        map.put("age", "20");
        map.put("sex", "1");
        jedis.hmset("userInfo", map);
        // 获取一条数据
        String name = jedis.hget("userInfo", "name");
        System.out.println(name);
        // 获取多条数据
        List<String> list = jedis.hmget("userInfo", "age", "sex");
        for (String str : list) {
            System.out.println(str);
        }
        // 获取 Hash 类型所有的数据
        Map<String, String> userMap = jedis.hgetAll("userInfo");
        for (Map.Entry<String, String> userInfo : userMap.entrySet()) {
            System.out.println(userInfo.getKey() + "--" + userInfo.getValue());
        }
        // 删除 用于删除 hash 类型数据
        //jedis.hdel("userInfo", "name");
    }

看下结果

3、操作 list

@Test
    public void testList() {
        // 左添加(上)
        jedis.lpush("students", "Wang Wu", "Li Si");
        // 右添加(下)
        jedis.rpush("students", "Zhao Liu");
        // 获取 start 起始下标 end 结束下标 包含关系
        List<String> students = jedis.lrange("students", 0, 2);
        for (String stu : students) {
            System.out.println(stu);
        }
        // 获取总条数
        Long total = jedis.llen("students");
        System.out.println("总条数：" + total);
        // 删除单条 删除列表中第一次出现的 Li Si
        // jedis.lrem("students", 1, "Li Si");
        // 删除多条
        // jedis.del("students");
    }

看下结果

4、操作 set

@Test
    public void testSet() {
        // 添加数据
        jedis.sadd("letters", "aaa", "bbb", "ccc", "ddd", "eee");
        // 获取数据
        Set<String> letters = jedis.smembers("letters");
        for (String letter: letters) {
            System.out.println(letter);
        }
        // 删除
        //jedis.srem("letters", "aaa", "bbb");
    }

看下结果

5、操作 sorted set -有序

@Test
    public void testSortedSet() {
        Map<String, Double> scoreMembers = new HashMap<>();
        scoreMembers.put("zhangsan", 99D);
        scoreMembers.put("lisi", 96D);
        scoreMembers.put("wangwu", 92D);
        scoreMembers.put("zhaoliu", 100D);
        scoreMembers.put("tianqi", 95D);
        // 添加数据
        jedis.zadd("score", scoreMembers);
        // 获取数据
        Set<String> scores = jedis.zrange("score", 0, 4);
        for (String score: scores) {
            System.out.println(score);
        }
        // 获取总条数
        Long total = jedis.zcard("score");
        System.out.println("总条数：" + total);
        // 删除
        //jedis.zrem("score", "zhangsan", "lisi");
    }

看下结果

6、Redis 中以层级关系、目录形式存储数据

@Test
    public void test() {
        // Redis 中以层级关系、目录形式存储数据
        jedis.set("user:01", "user_zhangsan");
        jedis.set("user:02", "user_lisi");
        System.out.println(jedis.get("user:01"));
    }

看下结果

7、获取所有 key&事务&删除

// 获取所有 key
    @Test
    public void testAllKeys() {
        // 当前库 key 的数量
        System.out.println(jedis.dbSize());
        // 当前库 key 的名称
        Set<String> keys = jedis.keys("*");
        for (String key: keys) {
            System.out.println(key);
        }
    }
    // 操作事务
    @Test
    public void testMulti() {
        Transaction tx = jedis.multi();
        // 开启事务
        tx.set("tel", "10010");
        // 提交事务
        // tx.exec();
        // 回滚事务
        tx.discard();
    }
    // 删除
    @Test
    public void testDelete() {
        // 删除 通用 适用于所有数据类型
        jedis.del("score");
    }

8、操作 byte

实体类user

import java.io.Serializable;
public class User implements Serializable {
    private static final long serialVersionUID = 9148937431079191022L;
    private Integer id;
    private String username;
    private String password;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    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;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username=‘" + username + ‘\‘‘ +
                ", password=‘" + password + ‘\‘‘ +
                ‘}‘;
    }
}

序列化工具类

/**
 * 序列化工具类
 */
public class SerializeUtil {

    /**
     * 将 java 对象转换为 byte 数组 序列化过程
     */
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            // 序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 将 byte 数组转换为 java 对象 反序列化
     */
    public static Object unserialize(byte[] bytes) {
        if(bytes == null)return null;
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
操作 byte
@Test
    public void testByte() {
        User user = new User();
        user.setId(2);
        user.setUsername("zhangsan");
        user.setPassword("123");
        // 序列化
        byte[] userKey = SerializeUtil.serialize("user:" + user.getId());
        byte[] userValue = SerializeUtil.serialize(user);
        jedis.set(userKey, userValue);
        // 获取数据
        byte[] userResult = jedis.get(userKey);
        // 反序列化
        User u = (User) SerializeUtil.unserialize(userResult);
        System.out.println(u);
    }

看下结果

原文地址：https://www.cnblogs.com/lusaisai/p/12546957.html

时间： 2024-08-07 04:11:06

Java 操作 Redis 五种数据类型的相关文章

redis五种数据类型的使用场景

string 1.String 常用命令: 除了get.set.incr.decr mget等操作外,Redis还提供了下面一些操作: 获取字符串长度 往字符串append内容 设置和获取字符串的某一段内容 设置及获取字符串的某一位(bit) 批量设置一系列字符串的内容 应用场景: String是最常用的一种数据类型,普通的key/value存储都可以归为此类,value其实不仅是String, 也可以是数字:比如想知道什么时候封锁一个IP地址(访问超过几次).INCRBY命令让这些变得很容易,

Redis——五种数据类型

Redis共有strings.hashs.lists.sets.sorted sets五种数据类型,可以说已经比较丰富了.下面只对这几种数据类型的数据结构与用途做简要介绍.至于每种数据类型的操作API,这里只简单一提,不再一一详细介绍,有需要的用户可以Google即可. 一.    strings string是最简单的类型,一个Key对应一个Value.string类型是类型安全的,Redis的string可以包含任何数据,比如jpg图片或者序列化的对象.存储结构如下: 常用的API函数有:

转 redis 五种数据类型的使用场景

http://www.cnblogs.com/lori/archive/2012/05/15/2501862.html Redis学习笔记~Redis提供的五种数据结构 回到目录 分布式缓存,消息队列,替代Session呵呵(Session太不稳定了,呵呵)＝Redis Redis的崛起绝非偶然,它确实有自己的新东西在里面,它不像Memcached,只能将数据存储在内存中,它提供了持久化机制,避免了場机后的雪崩的问题,即服务器出现问题后,内存中保留的原始数据全部丢失,需要重新组织数据到内存,这时

redis 五种数据类型

前言 前面学会了单机, 学会了集群, 但是redis咋用啊? 或者说, redis支持哪些数据类型呢? 常用的有五种: String , Hash, List, Set, zset(SortedSet) 一.String String 类型, 在前面也是使用过的. 直接来看一下 可以使用del name来删除缓存 二.List push指令: push分两个, 一个从左边push, 一个从右边push. 但是这个左右, 是对准备push的值而言的. 而不是针对将要push的数组来说的. pop指

《闲扯Redis三》Redis五种数据类型之List型

一.前言 Redis 提供了5种数据类型:String(字符串).Hash(哈希).List(列表).Set(集合).Zset(有序集合),理解每种数据类型的特点对于redis的开发和运维非常重要. Redis 中的 list 是我们经常使用到的一种数据类型,根据使用方式的不同,可以应用到很多场景中. 二.操作命令 ?List数据类型在 Redis 中的相关命令:: 命令 描述 用法 LPUSH 1.将一个或多个值value插入到列表key的表头2.如果有多个value值,那么各个value值按

redis五种数据类型应用场景

String 1.String   常用命令:   除了get.set.incr.decr mget等操作外,Redis还提供了下面一些操作:   获取字符串长度   往字符串append内容   设置和获取字符串的某一段内容   设置及获取字符串的某一位(bit)   批量设置一系列字符串的内容      2.应用场景:   String是最常用的一种数据类型,普通的key/value存储都可以归为此类,value其实不仅是String,   也可以是数字:比如想知道什么时候封锁一个IP地址(

[redis]redis五种数据类型命令汇总整理

redis所有命令参考中文版 键key 命令 时间复杂度 命令描述 返回值 del key O(N) 在key存在时删除key 被移除key的数量 dump key O(N) 序列话给定key,并返回被序列化的值 exists key O(1) 检查给定key是否存在 若key存在,返回1,否则返回0. expire key seconds O(1) 为给定key设置过期时间 设置成功返回1. 当key不存在或者不能为key设置生存时间时(比如在低于2.1.3中你尝试更新key的生存时间),返回

redis 五种数据类型的使用场景

String [html] view plain copy 1.String 常用命令: 除了get.set.incr.decr mget等操作外,Redis还提供了下面一些操作: 获取字符串长度 往字符串append内容 设置和获取字符串的某一段内容 设置及获取字符串的某一位(bit) 批量设置一系列字符串的内容 应用场景: String是最常用的一种数据类型,普通的key/value存储都可以归为此类,value其实不仅是String, 也可以是数字:比如想知道什么时候封锁一个IP地址(访问

Redis五种数据类型及应用场景

MySql+Memcached架构的问题 实际MySQL是适合进行海量数据存储的,通过Memcached将热点数据加载到cache,加速访问,很多公司都曾经使用过这样的架构,但随着业务数据量的不断增加,和访问量的持续增长,我们遇到了很多问题: 1.MySQL需要不断进行拆库拆表,Memcached也需不断跟着扩容,扩容和维护工作占据大量开发时间. 2.Memcached与MySQL数据库数据一致性问题. 3.Memcached数据命中率低或down机,大量访问直接穿透到DB,MySQL无法支撑.