Jedis 和 Redis Template 应用

准备工作

创建工程

创建maven父工程，例如03-sca-redis,并在此工程下创建两个子工程，一个为sca-jedis,一个为sca-tempate,例如：

添加项目依赖

sca-jedis 工程依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.5.2</version>
</dependency>

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

添加sca-template工程依赖

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.2.RELEASE</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

Jedis的应用

简介

Jedis是Java中操作redis的一个客户端，类似通过jdbc访问mysql数据库。

准备工作

第一步:从redis.io官方下载对应版本的redis.conf文件,地址如下:

https://redis.io/topics/config/

第二步:停止redis并删除挂载目录下(/usr/local/docker/redis01/conf)的redis.conf配置文件.
第三步:将下载的redis.conf文件拷贝到redis挂载目录(/usr/local/docker/redis01/conf)
第四步:基于vim打开redis.conf文件,然后注释 bind 127.0.0.1这一行,并修改protected-mode的值修改为no.
第五步:重启redis服务,并检查启动日志(docker logs 容器id)

快速入门实现

在Jedis工程中定义单元测试类，在类中定义单元测试方法：

基础类型操作

在项目的src/test/java目录创建单元测类,例如:

package jedis;

import com.google.gson.Gson;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

public class JedisTests {

    // 点赞成员, 特点: 无序, 不可重复
    @Test
    public void testSetOperation(){
        Jedis jedis=new Jedis("192.168.126.128",6379);
        jedis.sadd("set1", "A", "B", "B", "C");
        jedis.srem("set1", "A");
        Set<String> set1 = jedis.smembers("set1");
        System.out.println(set1);
        jedis.close();
    }

    //list类型练习:实现一个阻塞队列
    @Test
    public void testListOperation2(){
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.128",6379);
        // create
        jedis.lpush("list02", "A","B","C","D");
        // 取
        jedis.brpop(5,"list02");
        jedis.brpop(5,"list02");
        jedis.brpop(5,"list02");
        jedis.brpop(5,"list02"); // 当队列中没有数据时, 回阻塞当前线程
        // 阻塞式队列放入四循环中, 防止cup空转, 消耗系统资源,
        // retrieve
        String rpop = jedis.rpop("list02");
        System.out.println(rpop);

    }

    //list类型练习:实现一个秒杀队列
    @Test
    public void testListOperation1(){
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.128",6379);
        // create
        jedis.lpush("list01", "A","B","C","C");
        // update
//        String e = jedis.lindex("list01", 0);
//        System.out.println(e);
        jedis.lset("list01", jedis.lpos("list01", "A"), "D");
        // retrieve
        String rpop = jedis.rpop("list01");
        System.out.println(rpop);

    }

    //hash类型练习（直接存储map对象）
    @Test
    public void testHashOperation2(){
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.129",6379);
        //2.存储
        Map<String,String> map=new HashMap<>();
        map.put("x","100");
        map.put("y","200");
        jedis.hset("point",map);
        //3.获取博客内容并输出
        map=jedis.hgetAll("point");
        System.out.println(map);
        //4.释放资源
        jedis.close();
    }

    //hash类型练习
    @Test
    public void testHashOperation1(){
        //1.建立连接
        Jedis jedis = new Jedis("192.168.126.128", 6379);
        //2.存储一篇博客信息
        jedis.hset("article","id","1");
        jedis.hset("article","title","mybatis");
        jedis.hset("article","content","framework");
        //3.获取博客内容并输出
        String id=jedis.hget("article","id");
        String title=jedis.hget("article","title");
        String content= jedis.hget("article","content");
        System.out.println(id+"/"+title+"/"+content);
        //4.释放资源
        jedis.close();
    }

    // json数据练习
    @Test
    public void testStringOperation2(){
        Jedis jedis = new Jedis("192.168.126.128", 6379);

        Map<String, Object> map = new HashMap<>();
        map.put("id", 1);
        map.put("name", "jack");
        map.put("password", "123456");

        Gson gson = new Gson();
        String json = gson.toJson(map);
        System.out.println(json);

        jedis.set("user", json);
        String user = jedis.get("user");
        System.out.println(user);
        Map<String, Object> obj = gson.fromJson(user, Map.class);
        System.out.println(obj);
        jedis.close();

    }

    // 字符串类型练习
    @Test
    public void testStringOperation1() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.128", 6379);
        jedis.set("id", "1000");
        jedis.set("count", "500");
        jedis.set("content", "redis");

        jedis.incr("id");
        jedis.expire("count", 1);

        String id = jedis.get("id");// 1001
//        Thread.sleep(1000);
        TimeUnit.SECONDS.sleep(1);
        String count = jedis.get("count");
        String format = String.format("id=%s,count=%s", id, count);
        System.out.println(format);

    }

    // redis连接测试
    @Test
    public void testConnect(){
        Jedis jedis = new Jedis("192.168.126.128", 6379);
//        jedis.connect();
        String ping = jedis.ping();
        System.out.println(ping);
    }
}

连接池JedisPool应用

我们直接基于Jedis访问redis时，每次获取连接，释放连接会带来很大的性能开销，可以借助Jedis连接池，重用创建好的连接，来提高其性能，简易应用方式如下：

package com.jt;

import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisPoolTests {
    @Test
   public void testJedisPool(){
        //定义连接池的配置
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(1000);//最大连接数
        config.setMaxIdle(60);//最大空闲时间(连接不用了要释放)
        //创建连接池
        JedisPool jedisPool=
        new JedisPool(config,"192.168.126.130",6379);
        //从池中获取一个连接
        Jedis resource = jedisPool.getResource();
        resource.auth("123456");
        //通过jedis连接存取数据
        resource.set("class","cgb2004");
        String clazz=resource.get("class");
        System.out.println(clazz);
        //将链接返回池中
        resource.close();
        //关闭连接池
        jedisPool.close();
    }
}

RedisTemplate应用

简介

RedisTemplate为SpringBoot工程中操作redis数据库的一个Java对象，此对象封装了对redis的一些基本操作。

准备工作

第一步：创建工程配置文件application.yml,其内容如下：

spring:
  redis:
    host: 192.168.64.128  #远程redis服务器ip地址
    port: 6379

第二步：创建工程启动类，例如：

package com.jt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RedisApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisApplication.class,args);
    }
}

快速入门实现

StringRedisTemplate 应用

StringRedisTemplate 是一个专门用于操作redis字符串类型数据的一个对象，其应用方式如下：

package com.jt.redis;
@SpringBootTest
public class StringRedisTemplateTests {
    /**此对象为spring提供的一个用于操作redis数据库中的字符串的一个对象*/
  @Autowired
  private StringRedisTemplate stringRedisTemplate;
  
  @Test
  void testConnection(){
        RedisConnection connection =
                stringRedisTemplate.getConnectionFactory()
                        .getConnection();
        String ping = connection.ping();
        System.out.println(ping);
    }

  @Test
  void testRedisStringOper()throws Exception{
  	
    //获取用于操作字符串的值对象
   	ValueOperations<String, String> valueOperations
            = stringRedisTemplate.opsForValue();
   	//向redis中存储数据
   	valueOperations.set("ip", "192.168.174.128");
   	valueOperations.set("state","1",1, TimeUnit.SECONDS);
   	valueOperations.decrement("state");
   	// Thread.sleep(2000);
   	//从redis中取数据
   	String ip=valueOperations.get("ip");
   	System.out.println("ip="+ip);
   	String state=valueOperations.get("state");
   	System.out.println("state="+state);
  	}
}

RedisTemplate 应用

RedisTemplate是一个专门用于实现对远端redis中复杂数据的操作的对应，应用案例如下：

package com.jt.redis;
@SpringBootTest
public class RedisTemplateTests {
    /**
     * 通过此对象操作redis中复杂数据类型的数据，例如hash结构
     */
    @Autowired
    private RedisTemplate redisTemplate;

  @Test
    void testConnection(){
        String result=
        redisTemplate.getConnectionFactory().getConnection().ping();
        System.out.println(result);
    }

    @Test
    void testSetData(){
        SetOperations setOperations=redisTemplate.opsForSet();
        setOperations.add("setKey1", "A","B","C","C");
        Object members=setOperations.members("setKey1");
        System.out.println("setKeys="+members);
        //........
    }

    @Test
    void testListData(){
      //向list集合放数据
        ListOperations listOperations = redisTemplate.opsForList();
        listOperations.leftPush("lstKey1", "100"); //lpush
        listOperations.leftPushAll("lstKey1", "200","300");
        listOperations.leftPush("lstKey1", "100", "105");
        listOperations.rightPush("lstKey1", "700");
        Object value= listOperations.range("lstKey1", 0, -1);
        System.out.println(value);
      //从list集合取数据
        Object v1=listOperations.leftPop("lstKey1");//lpop
        System.out.println("left.pop.0="+v1);
        value= listOperations.range("lstKey1", 0, -1);
        System.out.println(value);
    }

    /**通过此方法操作redis中的hash数据*/
    @Test
    void testHashData(){
        HashOperations hashOperations = redisTemplate.opsForHash();//hash
        Map<String,String> blog=new HashMap<>();
        blog.put("id", "1");
        blog.put("title", "hello redis");
        hashOperations.putAll("blog", blog);
        hashOperations.put("blog", "content", "redis is very good");
        Object hv=hashOperations.get("blog","id");
        System.out.println(hv);
        Object entries=hashOperations.entries("blog");
        System.out.println("entries="+entries);
    }

   @Test
    void testFlushdb(){
        redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
               //redisConnection.flushDb();
                redisConnection.flushAll();
                return "flush ok";
            }
        });
    }
}