Redis入门使用

1、Redis简介

简介
Redis 是完全开源的，遵守 BSD 协议，是一个高性能的 key-value 数据库。
Redis 与其他 key - value 缓存产品有以下三个特点：
- Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
- Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
- Redis支持数据的备份，即master-slave模式的数据备份。
优势

性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。

2、Redis安装

2.1、window安装

下载地址：https://github.com/tporadowski/redis/releases。
** 根据自己电脑是32位或者64位的下载相对应得版本，就可以进行安装使用 **
解压文件夹之后进入文件夹得目录下打开cmd
输入以下命令，就可以运行redis
redis-server.exe redis.windows.conf
重新打开一个cmd，输入以下命令就可以进行数据库操作
redis-cli.exe -h 127.0.0.1 -p 6379

2.2、Linux安装

下载地址：http://redis.io/download 下载最新稳定版本。
在linux中对压缩包进行解压之后
进入解压后的文件夹
进行make操作

# wget http://download.redis.io/releases/redis-6.0.8.tar.gz
# tar xzf redis-6.0.8.tar.gz
# cd redis-6.0.8
# make

make之后，src目录下面就会出现一个redis-server的文件，可以用来启动Redis，如下

1 2	# cd src # ./redis-server

除此之外，Redis还给我们提供了一个配置文件，可以修改Redis的配置文件，并运行，如下

1 2	# cd src # ./redis-server ../redis.conf

2.3、Ubuntu apt 命令安装

Ubuntu系统不像其他的linux系统，它可以通过命令来在线安装
在 Ubuntu 系统安装 Redis 可以使用以下命令:

1 2	# sudo apt update # sudo apt install redis-server

然后可以启动

1	# redis-server

3、Redis的数据类型

3.1、String类型

字符串类型，是一种我们平常最常见到的一种数据类型之一
我们使用set和get存取数据时，一般就是String的类型，如下

redis 127.0.0.1:6379> SET name "陈益财"
OK
redis 127.0.0.1:6379> GET name
"陈益财"

其中，name就是key，”陈益财”就是所对应的值

3.2、Hash类型

Redis hash 是一个键值(key=>value)对集合。
Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象
例子如下：

redis 127.0.0.1:6379> HMSET names name1 "chenyicai" name1 "George"
"OK"
redis 127.0.0.1:6379> HGET names name1
"Hello"
redis 127.0.0.1:6379> HGET names name1
"World"

3.3、List类型

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
例子如下：

redis 127.0.0.1:6379> lpush chen redis
(integer) 1
redis 127.0.0.1:6379> lpush chen mongodb
(integer) 2
redis 127.0.0.1:6379> lpush chen rabbitmq
(integer) 3
redis 127.0.0.1:6379> lrange chen 0 10
1) "rabbitmq"
2) "mongodb"
3) "redis"
redis 127.0.0.1:6379>

其中lpush表示存数据，而lrange表示取数据

3.4、set类型

Redis 的 Set 是 string 类型的无序集合。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。
例子如下：

redis 127.0.0.1:6379> sadd chen redis
(integer) 1
redis 127.0.0.1:6379> sadd chen mongodb
(integer) 1
redis 127.0.0.1:6379> sadd chen rabbitmq
(integer) 1
redis 127.0.0.1:6379> sadd chen rabbitmq
(integer) 0
redis 127.0.0.1:6379> smembers chen

1) "redis"
2) "rabbitmq"
3) "mongodb"

其中sadd表示添加数据，smembers表示取出数据
注意：以上实例中 rabbitmq 添加了两次，但根据集合内元素的唯一性，第二次插入的元素将被忽略

3.5、zset类型

Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
zset的成员是唯一的,但分数(score)却可以重复。
例子·如下：

redis 127.0.0.1:6379> zadd chen 0 redis
(integer) 1
redis 127.0.0.1:6379> zadd chen 0 mongodb
(integer) 1
redis 127.0.0.1:6379> zadd chen 0 rabbitmq
(integer) 1
redis 127.0.0.1:6379> zadd chen 0 rabbitmq
(integer) 0
redis 127.0.0.1:6379> ZRANGEBYSCORE chen 0 1000
1) "mongodb"
2) "rabbitmq"
3) "redis"

其中zadd表示存数据，ZRANGEBYSCORE表示取数据
且虽然存了两次相同的字符，但是也是只会保留一个

4、在java中使用Redis

使用Redis更多的情况是在java环境下面使用，所以需要掌握如何在java中对Redis进行操作
Redis官方给我们提供了很方便的工具来进行Redis的操作：Jedis

首先你需要下载驱动包下载 jedis.jar，确保下载最新驱动包。

4.1、连接到Redis

配置完成之后我们就可以连接到Redis了。
例子如下：

import redis.clients.jedis.Jedis;
 
public class RedisJava {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        // 如果 Redis 服务设置了密码，需要下面这行，没有就不需要
        // jedis.auth("123456"); 
        System.out.println("连接成功");
        //查看服务是否运行
        System.out.println("服务正在运行: "+jedis.ping());
    }
}

如果是可以连接成功的，就会返回一个PONG表示回应

4.2、String类型的存储

import redis.clients.jedis.Jedis;
 
public class RedisStringJava {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //设置 redis 字符串数据
        jedis.set("name", "chenyicai");
        // 获取存储的数据并输出
        System.out.println("redis 存储的字符串为: "+ jedis.get("name"));
    }
}

成功之后控制台就会显示name所对应的值：chenyicai

4.3、List类型的存储

import java.util.List;
import redis.clients.jedis.Jedis;
 
public class RedisListJava {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //存储数据到列表中
        jedis.lpush("site-list", "Baidu");
        jedis.lpush("site-list", "Google");
        jedis.lpush("site-list", "Taobao");
        // 获取存储的数据并输出
        List<String> list = jedis.lrange("site-list", 0 ,2);
        for(int i=0; i<list.size(); i++) {
            System.out.println("列表项为: "+list.get(i));
        }
    }
}

成功之后控制台就会返回信息

1
2
3

列表项为: Taobao
列表项为: Google
列表项为: Baidu

5、在SpringBoot中使用Redis

一般在SpringBoot中使用Redis时我们会用来做Mysql数据库的二级缓存，这样子在我们获取数据的时候就不需要每次都到数据库进行查询，如果缓存中有数据就可以直接从缓存中拿，大大提高了查询的效率。

首先我们需要在maven中引入我们所需要的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

然后在yml配置文件中，配置Redis的相关配置文件

spring:
  redis:
    database: 0
    host: localhost
    port: 6379
    password:
    timeout: 500
    pool:
      max-active: 8
      max-idle: 8
      min-idle: 0
      max-wait: -1

我们还需要一个Config类来处理数据的序列化，否则双方可能会出现乱码的情况

@Configuration
public class RedisConfig {

    private RedisConnectionFactory redisConnectionFactory;

    public RedisConfig(RedisConnectionFactory redisConnectionFactory) {
        this.redisConnectionFactory = redisConnectionFactory;
    }

    /**
     * redisTemplate 序列化使用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
     *
     * @return
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate() {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}

创建一个cache的实现类用于将查出来的数据添加到缓存中，并设置一些缓存的配置,里面包括了一些有关增删改的配置方法。

public class MybatisRedisCache implements Cache {
    private Object key;
    private String id;

    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    private RedisTemplate<Object, Object> redisTemplate;

    private final String COMMON_CACHE_KEY = "MYBATIS:";

    /**
     * 默认缓存对象的缓存时间为 1 分钟
     **/
    private static final long EXPRIRE_TIME_IN_MINUT = 30;

    public MybatisRedisCache(String id) {
        if (id == null) {
            throw new IllegalArgumentException("缓存对象id是不能为空的");
        }
        this.id = id;
    }

    private RedisTemplate<Object, Object> getRedisTemplate() {
        if (redisTemplate == null) {
            redisTemplate = ApplicationContextHolder.getBean("redisTemplate");
        }
        return redisTemplate;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public void putObject(Object key, Object value) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            //使用redisTemplate得到值操作对象
            ValueOperations operation = redisTemplate.opsForValue();
            //使用值操作对象operation设置缓存对象
            operation.set(getKey(key), value, EXPRIRE_TIME_IN_MINUT, TimeUnit.MINUTES);
//            System.out.println("缓存对象保存成功");
        } catch (Throwable t) {
            System.err.println("缓存对象保存失败" + t);
        }
    }

    public Object getKey() {
        return key;
    }

    public void setKey(Object key) {
        this.key = key;
    }

    @Override
    public Object getObject(Object key) {
        try {
            setKey(key);
            RedisTemplate redisTemplate = getRedisTemplate();
            ValueOperations operations = redisTemplate.opsForValue();
            Object result = operations.get(getKey(key));
//            System.out.println("获取缓存对象成功");
            return result;
        } catch (Throwable t) {
            System.err.println("缓存对象获取失败" + t);
            return null;
        }
    }

    @Override
    public Object removeObject(Object key) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            redisTemplate.delete(getKey(key));
//            System.out.println("删除缓存对象成功！"+key);
        } catch (Throwable t) {
            System.err.println("删除缓存对象失败！" + t);
        }
        return null;
    }

    @Override
    public void clear() {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            Set<String> keys = redisTemplate.keys(getKeys());
            redisTemplate.delete(keys);
            System.out.println("出现新增、修改、删除操作，清空对应Mapper缓存======>" + keys.size());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 按照一定规则标识key
     */
    private String getKey(Object key) {
        String k=COMMON_CACHE_KEY + this.id + ":" + DigestUtils.md5DigestAsHex(String.valueOf(key).getBytes());
        return k;
    }

    /**
     * 所有key
     */
    private String getKeys() {
        return COMMON_CACHE_KEY + this.id + ":*";
    }

    @Override
    public int getSize() {
        Long size = getRedisTemplate().boundHashOps(getId()).size();
        return size == null ? 0 : size.intValue();
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }
}

然后我们在数据库查询的mapper.xml上添加上以下的配置，表示开启了数据库的二级缓存
1
<cache type="com.chen.mysqlredisdemo.cache.MybatisRedisCache"></cache>

然后在Controller文件中注入刚才写好的方法

@Autowired
StringRedisTemplate stringRedisTemplate;
@Autowired
RedisTemplate redisTemplate;

最后在方法中判断Redis中是否有缓存，如果有就从Redis中取数据，否则就到数据库进行查找

@RequestMapping("/selectForOne/{sId}")
    public Student selectStudentForOne(@PathVariable int sId){
        String key = "MYBATIS:" + "com.chen.mysqlredisdemo.StudentMapper:"+sId;
        ValueOperations<String, Student> operations = redisTemplate.opsForValue();
        boolean hasKey = redisTemplate.hasKey(key);
        if (hasKey) {
            System.out.println("缓存输出");
            Student student = operations.get(key);
            return student;
        }else {
            Student student = studentService.selectStudentForOne(sId);
            operations.set(key, student);//把数据放入缓存
            return student;
        }
    }