java 远程链接redis java项目连接redis

java连接redis

• 一、java连接redis

• 1.1、连接数据库
• 1.2、jedis以byte[] 存储一个对象到redis中
• 1.3、jedis以String 形式存储一个对象到redis中
• 1.4、Jedis连接池的操作
• 1.5 、管道操作

一、java连接redis

1.1、连接数据库

1、创建一个maven项目

2、引入依赖

运行

redis图形化界面出现数据

取出数据：

1.2、jedis以byte[] 存储一个对象到redis中

创建实体类 User：

package com.yms.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * @author 此间乐
 * @create 2020-12-22-21:03
 */
@Data
public class User implements Serializable {
    private Integer id;
    private String name;
    private Date birthday;

    public User() {
    }

    public User(Integer id, String name, Date birthday) {
        this.id = id;
        this.name = name;
        this.birthday = birthday;
    }
}

引入依赖：

<dependencies>

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

<!--        junit 依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

<!--        Lombok 简化操作-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
        </dependency>

<!--        使用spring它的 SerializationUtils-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
    </dependencies>

创建Demo类

public class Demo {

    //存储对象 -以byte[](字节数组)的形式存储在Redis
    @Test
    public void setByteArray(){
        //1.连接Redis
        Jedis jedis =new Jedis("192.168.156.128", 6379);

        //2.1 准备key(String)-value(User)
        String key = "user";
        User value = new User(1,"李四",new Date());

        //2.2 将key和value转换为byte[]
        byte[] byteKey = SerializationUtils.serialize(key);
        byte[] byteValue = SerializationUtils.serialize(value);

        //2.3 将key和value存储到redis中
        jedis.set(byteKey,byteValue);

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

    //获取对象 -以byte[](字节数组)的形式在redis获取
    @Test
    public void getByteArray(){
        //1.连接Redis
        Jedis jedis =new Jedis("192.168.156.128", 6379);

        //2.1 准备key
        String key = "user";

        //2.2 将key转换为byte[]
        byte[] byteKey = SerializationUtils.serialize(key);
        
        //2.3 jedis 去redis中获取value
        byte [] value = jedis.get(byteKey);
       
        //2.4 将value反序列化为User对象
        User user = (User) SerializationUtils.deserialize(value);
       
        //2.5 输出
        System.out.println("user:" + user);
        //3释放资源
        jedis.close();
    }
}

---

执行setByteArray()后 redis在图形化界面的结果

执行getByteArray() 后，控制台的输出结果

1.3、jedis以String 形式存储一个对象到redis中

实体类：

package com.yms.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * @author 此间乐
 * @create 2020-12-22-21:03
 */
@Data
public class User implements Serializable {
    private Integer id;
    private String name;
    private Date birthday;

    public User() {
    }

    public User(Integer id, String name, Date birthday) {
        this.id = id;
        this.name = name;
        this.birthday = birthday;
    }
}

引入fastJSON依赖：

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

创建Demo1类

package com.yms.test;

import com.alibaba.fastjson.JSON;
import com.yms.entity.User;
import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.util.Date;

/**
 * @author 此间乐
 * @create 2020-12-23-15:37
 */
public class Demo1 {
    //存储一个对象 - 以String形式存储
    @Test
    public void setString(){

        //1、连接Redis
        Jedis jedis = new Jedis("192.168.156.128", 6379);

        //2.1 准备key(String)-value(User)
        String stringKey = "stringUser";
        User value = new User(2,"旺财",new Date());

        //2.2 使用fastJSON将value转换为json字符串
        String stringValue = JSON.toJSONString(value);

        //2.3 存储到Redis中
        jedis.set(stringKey,stringValue);

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

    //获取一个对象 - 以String形式存储
    @Test
    public void getString(){

        //1、连接Redis
        Jedis jedis = new Jedis("192.168.156.128", 6379);

        //2.1 准备key
        String stringKey = "stringUser";

        //2.2 去Redis中查询value
        String stringValue = jedis.get(stringKey);

        //2.3 将value反序列化为User
        User user = JSON.parseObject(stringValue,User.class);

        //2.4 输出
        System.out.println("user:" + user);

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

执行setString 在redis图形化界面的结果

执行setString 控制台输出的结果

1.4、Jedis连接池的操作

简单方式：

//简单方式
    @Test
    public void pool1(){
        //1.创建连接池
        JedisPool jedisPool = new JedisPool("192.168.156.128", 6379);

        //2、通过连接池获取jedis对象
        Jedis jedis = jedisPool.getResource();
        //3、操作
        String value = jedis.get("stringUser");
        System.out.println("user:" + value);

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

详细配置：

@Test
    public void pool2(){
        //1.创建连接池配置信息
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(100); //连接池中最大的活跃数
        poolConfig.setMaxIdle(10); //最大空闲数
        poolConfig.setMinIdle(5); //最小空闲数
        poolConfig.setMaxWaitMillis(3000); //当连接池空了之后，多久没获取到Jedis对象，就超时

        //2.创建连接池
        JedisPool pool = new JedisPool(poolConfig,"192.168.156.128",6379);


        //3、通过连接池获取jedis对象
        Jedis jedis = pool.getResource();

        //4、操作
        String value = jedis.get("stringUser");
        System.out.println("user:" + value);

        //5、释放资源
        jedis.close();

    }

1.5 、管道操作

因为在操作Redis的时候，执行一个命令需要先发送请求到Redis服务器，这个过程需要经历网络的延迟，Redis还需要给客户端一个响应
如果我们需要一次性执行很多个命令，上述的方式效率很低，可以通过Redis的管道，先将命令放到客户端的一个Pipeline中，之后一次性的将命令都发送到Redis服务，Redis服务一次性的将全部的返回结果响应给客户端。

不进行管道操作：

//1、创建连接池
    JedisPool pool = new JedisPool("192.168.156.128",6379);
    long l = System.currentTimeMillis();//当前系统时间

    //2、获取一个连接对象
    Jedis jedis = pool.getResource();

    //3、执行incr - 10000次
    for (int i = 0; i < 10000; i++) {
        jedis.incr("pp");
    }

    //4、释放资源
    jedis.close();
    System.out.println(System.currentTimeMillis() - l);

输出结果，花费了4829毫秒

进行管道操作：

//2、获取一个连接对象

    Jedis jedis = pool.getResource();

    //3、创建管道
    Pipeline pipelined = jedis.pipelined();

    //4、执行incr - 10000次放到管道中
    for (int i = 0; i < 10000; i++) {
         pipelined.incr("qq");

    }

    //5、执行命令
    pipelined.syncAndReturnAll();

    //6、释放资源
    jedis.close();

    System.out.println(System.currentTimeMillis() - l);

输出结果，花费了67毫秒

完整代码：

public class Pipeline01 {

    //管道操作
    @Test
    public void pipeline(){
       //1、创建连接池
        JedisPool pool = new JedisPool("192.168.156.128",6379);
        long l = System.currentTimeMillis();//当前系统时间

  /*      //2、获取一个连接对象
        Jedis jedis = pool.getResource();

        //3、执行incr - 10000次
        for (int i = 0; i < 10000; i++) {
            jedis.incr("pp");
        }

        //4、释放资源
        jedis.close();

 */

        //==========================

        //2、获取一个连接对象

        Jedis jedis = pool.getResource();

        //3、创建管道
        Pipeline pipelined = jedis.pipelined();

        //4、执行incr - 10000次放到管道中
        for (int i = 0; i < 10000; i++) {
             pipelined.incr("qq");

        }

        //5、执行命令
        pipelined.syncAndReturnAll();

        //6、释放资源
        jedis.close();

        System.out.println(System.currentTimeMillis() - l);

    }
}