使用Jedis 在java程序中操作redis

一、使用Jedis 在java程序中操作redis

Jedis是Java程序连接Redis和操作Redis的工具。

1.初体验

引入依赖

<dependencies>
        <!--    1、 Jedis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <!--    2、 Junit测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--    3、 Lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
        </dependency>
    </dependencies>

写Test来连接和操作Redis

使用jedis就好像在用redis-cli，非常方便

	@Test
    public void testJedisSet(){

        //1.new Jedis对象,指定redis服务器的ip和端口号
        Jedis jedis = new Jedis("172.16.253.2",6379);
        //2.直接使用jedis充当成redis-cli来操作redis即可
        jedis.set("zhangsan","hello jedis");
        //3.释放连接
        jedis.close();
    }

    @Test
    public void testJedisGet(){
        //1.使用Jedis连接redis
        Jedis jedis = new Jedis("172.16.253.2",6379);
        //2.操作redis
        String zhangsan = jedis.get("zhangsan");
        System.out.println(zhangsan);
        //3.释放连接
        jedis.close();
    }

2.如何使用jedis来存和取对象——byte[]

在存取对象时，对象需要被转换成二进制进行传输，因此使用SerializationUtils来进行对象的序列化和反序列化。该工具引入依赖

<!-- 4. 导入spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>

具体的操作：

User:

package com.qf.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {

    private Long id;
    private String name;
    private int age;

}

@Test

    /**
     * 存储对象
     */
    @Test
    public void testJedisEntity(){

        //1.new Jedis对象,指定redis服务器的ip和端口号
        Jedis jedis = new Jedis("172.16.253.2",6379);
        //2.直接使用jedis充当成redis-cli来操作redis即可
        User user = new User(1001L,"小明",20);
        //没有办法直接存的，可以转换成二进制
        //把key序列化成byte数组
        byte[] userKey = SerializationUtils.serialize(user.getId());
        //把value序列化成byte数组
        byte[] userValue = SerializationUtils.serialize(user);
        //通过jedis存入
        jedis.set(userKey,userValue);

        //3.释放连接
        jedis.close();

    }


    /**
     * 获取对象
     */
    @Test
    public void testGetJedisEntity(){
        //1.new Jedis对象,指定redis服务器的ip和端口号
        Jedis jedis = new Jedis("172.16.253.2",6379);
        //2.1使用序列化工具序列化key
        byte[] key = SerializationUtils.serialize(1001L);
        byte[] value = jedis.get(key);
        //2.2 反序列化
        User user = (User) SerializationUtils.deserialize(value);
        System.out.println(user.getId());
        System.out.println(user.getName());
        System.out.println(user.getAge());

        //3.释放连接	 	
        jedis.close();

    }

3.使用json来存取对象

导入json依赖

		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.74</version>
        </dependency>

使用byte[]来存取对象，多少有一些麻烦，因此可以使用json来存取，更加简单

    /**
     * json来作为对象存储的介质：
     *   java对象 转换成  json字符串  =》 json的工具类： fastjson、gson、jackson
     *   json字符串 转换成 java对象
     */

	//存储对象
    @Test
    public void testJsonToRedis(){
        //1.new Jedis对象,指定redis服务器的ip和端口号
        Jedis jedis = new Jedis("172.16.253.2",6379);

        //2.使用fastjson把java对象转换成json字符串
        User user = new User(1002L,"lisi",20);
        String json = JSON.toJSONString(user);
        jedis.set("lisi",json);

        //3.释放连接
        jedis.close();
    }



	//获取对象
	@Test
    public void testJsonFromRedis(){

        //1.new Jedis对象,指定redis服务器的ip和端口号
        Jedis jedis = new Jedis("172.16.253.2",6379);

        //2.使用jedis获取json字符串
        String json = jedis.get("lisi");
        //json->java
        User user = JSON.parseObject(json, User.class);
        System.out.println(user.getId());
        System.out.println(user.getName());
        System.out.println(user.getAge());
        //3.释放连接
        jedis.close();


    }

4.使用Jedis连接池工具类

使用连接池工具类提供连接效率。

package com.qf;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class JedisUtil {

    private static GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();

    private static JedisPool pool;

    private static final int port = 6379;

    private static final String host = "172.16.253.2";

    static{
        poolConfig.setMaxTotal(100);
        poolConfig.setMaxIdle(10);
        poolConfig.setMinIdle(5);
        poolConfig.setMaxWaitMillis(3000);
        pool = new JedisPool(poolConfig,host,port);

    }

    /**
     * 获取连接池
     */
    public static JedisPool getPool(){
        return pool;
    }

    /**
     * 从连接池中获取连接
     * @return
     */
    public static Jedis getJedis(){
        return pool.getResource();
    }


}

5.使用流水线提高批量操作的效率

• 没有使用流水线： 每个操作都发一次给redis，redis在收到后再执行。

  @Test
    public void testP(){
        Jedis jedis = JedisUtil.getJedis();

        long start = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {
            jedis.incr("pp");
        }

        long end = System.currentTimeMillis();

        System.out.println("执行时间："+(end-start));


    }

• 使用流水线：把多个操作捆绑在一起发给redis，让redis一起执行。这样提升了性能。

@Test
    public void testP1(){
        Jedis jedis = JedisUtil.getJedis();

        long start = System.currentTimeMillis();
		//使用流水线
        Pipeline pipelined = jedis.pipelined();
        
        for (int i = 0; i < 10000; i++) {
            pipelined.incr("qq");
        }
        pipelined.syncAndReturnAll();

        long end = System.currentTimeMillis();

        System.out.println("执行时间："+(end-start));


    }

redis的性能瓶颈不是在他的单线程，而是在他的网络io次数