Java连接Redis

Jedis连接Redis

需要依赖：

 <!--    1、 Jedis-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>

测试连接：

public class Test01 {
    @Test
    public void test01() {
        Jedis jedis = new Jedis("192.168.200.129", 6379);//作为java版的redis客户端去连接redis服务器

        jedis.set("name", "zs");//为啥选择jedis而不用其他的?因为redis的命令是啥,jedis的方法名就是啥
        String value = jedis.get("name");
        System.out.println(value);//zs

        jedis.close();//释放资源
    }
}

Jedis存储一个对象到Redis以byte[]的形式(对象序列化转字节数组存储)

导入spring-context依赖,是为了使用spring里面的一个序列号和反序列化工具类SerializationUtils

<!-- 4.这里导入spring-context,是为了使用spring里面的一个序列号和反序列化工具类SerializationUtils -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.18.RELEASE</version>
</dependency>

创建测试类,存储键和值的字节数组到redis中,然后取出字节数组,还原为原来的东西

    @Test
    public void test01() {
        Jedis jedis = new Jedis("192.168.200.129", 6379);

        //通过序列化工具类方法把键和值变成字节数组,然后通过jedis把字节数组存到到redis中,缺啥补啥
        jedis.set(SerializationUtils.serialize("user"),
                SerializationUtils.serialize(new User(1, "fbb", new Date())));

        //通过序列化工具类方法得到键的字节数组,然后通过jedis根据键的字节数组查询值的字节数组,把值的字节数组通过序列化工具类方法反序列化还原为之前的对象,缺啥补啥
        byte[] valueBytes = jedis.get(SerializationUtils.serialize("user"));
        User user = (User) SerializationUtils.deserialize(valueBytes);
        System.out.println(user);//可以还原对象
        jedis.close();
    }

Jedis存储一个对象到Redis以String的形式(对象转json字符串存储)

导入依赖

<!-- 5.先导入fastJSON,做对象序列化为json字符串等操作 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

     @Test
    public void test01() {
        Jedis jedis = new Jedis("192.168.200.129", 6379);

        //存储字符串键和json字符串值到redis,对象和json字符串之间的转换这里先用阿里的fastjson
        jedis.set("user2", JSON.toJSONString(new User(2, "lbb", new Date())));


        //根据字符串键得到json字符串值,对象和json字符串之间的转换这里先用阿里的fastjson
        String json = jedis.get("user2");
        System.out.println(json);//{"birthday":1625823989727,"id":2,"name":"lbb"}
        User user = JSON.parseObject(json, User.class);
        System.out.println(user);//
        jedis.close();
    }

Jedis连接池的操作

使用连接池操作Redis,避免频繁创建和销毁连接对象,减少资源的消耗

 @Test
    public void test01() {
        GenericObjectPoolConfig config = new GenericObjectPoolConfig();
        config.setMaxTotal(100);//连接池中最大的活跃数
        config.setMaxIdle(10);//最大空闲数
        config.setMinIdle(5);//最小空闲数
        config.setMaxWaitMillis(3000);//当连接池空了之后,多久没获取到Jedis对象,就超时

        //从连接池里面得到的连接,用完之后不会关闭,而是可以回到连接池反复使用,提高效率
        JedisPool jedisPool = new JedisPool(config, "192.168.200.129", 6379);//关键代码,缺啥补啥
        
        Jedis jedis = jedisPool.getResource();
        String value = jedis.get("name");
        System.out.println(value);//zs

        jedis.close();//用完之后不会关闭,而是可以回到连接池反复使用
    }

Redis的管道操作,管道相当于一辆小卡车的效果

因为在操作Redis的时候，执行一个命令需要先发送请求到Redis服务器，这个过程需要经历网络的延迟，Redis还需要给客户端一个响应。

如果我需要一次性执行很多个命令，上述的方式效率很低，可以通过Redis的管道，先将命令放到客户端的一个Pipeline中，之后一次性的将全部命令都发送到Redis服务，Redis服务一次性的将全部的返回结果响应给客户端。

下面有两个情况一个是带管道的自增，一个是没带管道的自增，通过用时可以看出其效率：

         @Test
    public void testNoPipeLine() {
        long start = System.currentTimeMillis();

        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(100);
        poolConfig.setMaxIdle(10);
        poolConfig.setMinIdle(5);
        poolConfig.setMaxWaitMillis(3000);//3秒拿不到连接就超时

        JedisPool jedisPool = new JedisPool(poolConfig,"192.168.200.129",6379);

        Jedis jedis = jedisPool.getResource();//.var

        //无管道,键自增十万次
        for (int i = 0; i < 100000; i++) {
            jedis.incr("key1");
        }

        jedis.close();//back to pool

        long end = System.currentTimeMillis();
        System.out.println(end-start);//45997
    }

    @Test
    public void testPipeLine() {
        long start = System.currentTimeMillis();

        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(100);
        poolConfig.setMaxIdle(10);
        poolConfig.setMinIdle(5);
        poolConfig.setMaxWaitMillis(3000);//3秒拿不到连接就超时

        JedisPool jedisPool = new JedisPool(poolConfig,"192.168.200.129",6379);

        Jedis jedis = jedisPool.getResource();//.var

        //有管道,命令交给管道来管理,键自增十万次
        Pipeline pipelined = jedis.pipelined();

        for (int i = 0; i < 100000; i++) {
            pipelined.incr("key2");
        }

        List<Object> objectList = pipelined.syncAndReturnAll();//拿到返回值,巧记ps
        System.out.println(objectList);//[1, 2, 3, 4, ..., 100000]

        jedis.close();//back to pool

        long end = System.currentTimeMillis();
        System.out.println(end-start);//569
    }