Redis

Redis简介及理解

简介

Redis 是完全开源的，遵守 BSD 协议，是一个高性能的 key-value 数据库。

Redis 与其他 key - value 缓存产品有以下三个特点：

• Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
• Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
• Redis支持数据的备份，即master-slave模式的数据备份。

理解

Redis是一个把数据存储在内存上的工具，优势就是快，支持数据类型丰富等。Redis本身和数据库没有关系，他们的使用场景不一样。

Java与Redis

SpringBoot整合Redis有两种方式，分别是Jedis和RedisTemplate。

Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。目前官方推荐的是SpringDataRedis形式，相对于Jedis来说可以方便地更换Redis的Java客户端，其比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。

实战模拟

Jedis

必要依赖

<!--Redis（Jedis）-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.5.0</version>
</dependency>

工具类

package yuri.akira.demo.util;

import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Component
public class RedisUtil {

    private static JedisPool jedisPool = null;//连接池

    private static String IP = "127.0.0.1";//IP
    private static int PORT = 6379;//端口,Redis默认6379
    private static String password = "???";//密码，开始没有密码
    private static int MAX_ACTIVE = 1024;//实例最大连接数
    private static int MAX_IDLE = 200;//空闲的（idle）Jedis实例数，default：8
    private static int MAX_WAIT = 10000;//等待可用连接最大时间，ms，default：-1
    private static int TIMEOUT = 10000;//超时时间
    private static boolean TEST_ON_BORROW = true;//在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；

    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, IP, PORT, TIMEOUT); //Redis有密码参数放TIMEOUT后，没有就不用加参数。
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public synchronized Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public void returnResource (final Jedis jedis){
        if (jedis != null){
            jedisPool.returnResource(jedis);
        }
    }
}

对于工具类的参数设置，一般而言是放在配置文件里通过@ConfigurationProperties()，@Value等来进行值的注入，此处只是为了方便。

为了方便使用Spring的Bean注入等功能，此处使用一个类写Redis测试类函数实体，另一个作为Test启动类放在测试目录里。

测试方法类

package yuri.akira.demo.util;

import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import yuri.akira.demo.util.RedisUtil;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component
public class RedisJedis {

    private Jedis jedis;

    @Resource
    RedisUtil redisUtil;

    /*连接服务器*/
    public void connectRedis() {
        jedis = redisUtil.getJedis();
    }

    /*redis操作简单字符串测试*/
    public void testString() {
        System.out.println("Redis操作简单字符串测试：");
        /*添加数据*/
        jedis.set("name", "Yuri");
        System.out.println(jedis.get("name"));

        /*拼接字符串*/
        jedis.append("name", ".Ming");
        System.out.println(jedis.get("name"));

        /*删除数据*/
        jedis.del("name");
        System.out.println(jedis.get("name"));

        /*设置多个键值对*/
        jedis.mset("name", "yuri", "age", "22", "sexy", "boy");
        jedis.incr("age");/* +1操作 */
        System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("sexy"));
        System.out.println();
    }

    /*Redis操作map*/
    public void testMap() {
        System.out.println("Redis操作map的测试：");

        Map<String, String> map = new HashMap<>();
        map.put("name", "Yuri");
        map.put("age", "22");
        map.put("sexy", "boy");
        jedis.hmset("MAP", map);

        /*hmget()第一个参数是map的key，后面参数为存入此map对象的key，本身返回一个List<String>*/
        System.out.println(jedis.hmget("MAP", "name", "age", "sexy"));

        /*删除map中某个键值*/
        System.out.println(jedis.hkeys("MAP"));
        jedis.hdel("MAP", "sexy");
        System.out.println(jedis.hkeys("MAP"));
        System.out.println();
    }

    /*Redis操作List*/
    public void testList() {
        jedis.del("LIST");
        jedis.lpush("LIST", "Akira");
        jedis.lpush("LIST", "Yuri");
        jedis.lpush("LIST", "Ming");
/*        再取出所有数据jedis.lrange是按范围取出
        第一个是key,第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有*/
        System.out.println(jedis.lrange("LIST", 0, -1));
        jedis.del("LIST");
        jedis.rpush("LIST", "Akira");
        jedis.rpush("LIST", "Yuri");
        jedis.rpush("LIST", "Ming");
        System.out.println(jedis.lrange("LIST", 0, -1));
        System.out.println();
    }

    /*Redis操作Set*/
    public void testSet(){
        jedis.sadd("SET", "Yuri");
        jedis.sadd("SET", "Akira");
        jedis.sadd("SET", "Ming");
        jedis.sadd("SET", "Xs");
        System.out.println(jedis.smembers("SET"));//获取所有value
        jedis.srem("SET", "Xs");//删除
        System.out.println(jedis.sismember("SET", "Xs"));//查询是否存在
        System.out.println(jedis.srandmember("SET"));//返回随机元素
        System.out.println(jedis.scard("SET"));//返回集合元素个数
        System.out.println();
    }

    /*Redis排序*/
    public void testSort(){
        /*r,l是List操作，表明从左插入和从右插入*/
        jedis.rpush("SORT", "2");
        jedis.lpush("SORT", "4");
        jedis.lpush("SORT", "1");
        jedis.lpush("SORT", "3");
        System.out.println(jedis.lrange("SORT", 0, -1));
        System.out.println(jedis.sort("SORT"));
        System.out.println(jedis.lrange("SORT", 0, -1));
        System.out.println();
    }
}

启动器类

package yuri.akira.demo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import yuri.akira.demo.util.RedisTest;
import yuri.akira.demo.util.RedisUtil;

import javax.annotation.Resource;

@SpringBootTest
public class TestRedisRun {

    @Resource
    RedisTest redisTest;

    @Test
    public void test1(){
        redisTest.connectRedis();
        redisTest.testString();
        redisTest.testMap();
        redisTest.testList();
        redisTest.testSet();
        redisTest.testSort();
    }
}

RedisTemplate

必要依赖

<!--Redis（RedisTemplate）-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

yml配置文件

spring:
  redis:
    # 数据库索引，默认为0，避免数据库冲突
    database: 3
    #redis服务器地址
    host: 127.0.0.1
    #redis端口
    port: 6379
    #redis密码，默认空
    password:
    #连接超时时间
    timeout: 10000
    #连接池配置
    jedis:
      pool:
        #最大可用连接数（默认8，负数表示无限）
        max-active: 1024
        #最大空闲连接数（默认8，负数表示无限）
        max-idle: 200
        #最小空闲连接数（默认0）
        min-idle: 0
        #连接最大等待时间（默认-1，ms，负数表示无限）
        max-wait: 10000

测试类

package yuri.akira.demo.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundValueOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@Component
public class RedisTemplateTest {
    @Resource
    RedisTemplate redisTemplate;

    /*直接使用，无需连接*/
    public void testString(){
        /*通过redisTemplate设置值*/
        redisTemplate.boundValueOps("Key1").set("Value1");
        System.out.println(redisTemplate.hasKey("Key1"));
        System.out.println(redisTemplate.opsForValue().get("Key1"));

    /*通过BoundValueOperations设置值*/
        BoundValueOperations stringKey = redisTemplate.boundValueOps("Key2");
        stringKey.set("Vaule2");
        System.out.println(stringKey.getKey());

    /*通过ValueOperations设置值*/
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("Key3", "Vaule3");
        System.out.println(ops.get("Key3"));
    }
}

RedisTemplate只需引入依赖后在yml文件配置对应参数，然后使用时直接注入即可，非常简单方便。

此处只简单对RedisTemplate类方法进行模拟，其他详细方法并没有过多涉及。

以上就是简单的Redis操作。

注意

Redis每次使用都要启动服务器，WIndows下可以自行写个CMD脚本命令

::设置磁盘路径
F:
::进入redis目录
cd F:SoftWareRedis-x64-5.0.10
::启动服务
redis-server.exe

也可以直接注册服务：

进行Redis根路径

#注册安装服务
redis-server --service-install redis.windows.conf --loglevel verbose
#卸载服务
#redis-server --service-uninstall

然后在任务管理器可以把这个服务设为自动，以后则不需要手动启动Redis了。

项目代码

链接：https://pan.baidu.com/s/1U_tQTtM9cGXBvxrdZvgABA
提取码：Yuri

以上