Redis简介&&Java使用 redis

Redis是什么

入门地址:
https://www.redis.net.cn/tutorial/3508.htmlRedis官网文档
Redis是一种支持Key-Value等多种数据结构的存储系统。可用于缓存，事件发布或订阅，高速队列等场景。该数据库使用ANSI C语言编写，支持网络，提供支持五种数据类型：==string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)==结构直接存取，基于内存，可持久化。

Redis的应用场景有哪些

1，会话缓存（最常用）
2，消息队列，比如支付
3，活动排行榜或计数
4，发布，订阅消息（消息通知）
5，商品列表，评论列表等 [F5] 网站前台

Redis 可以存储键与5种不同数据结构类型之间的映射，这5种数据结构类型分别为String（字符串）、List（列表）、Set（集合）、Hash（散列）和 Zset（有序集合）。
11.1Redis安装：

如果闪退，请使用如下的命令启动服务端:

redis-server.exe redis.windows.conf

命令行使用[客户端]:

11.2数据类型:
下面来对这5种数据结构类型作简单的介绍：
结构类型 结构存储的值 结构的读写能力
String 可以是字符串、整数或者浮点数 对整个字符串或者字符串的其中一部分执行操作；对象和浮点数执行自增(increment)或者自减(decrement)
List 一个链表，链表上的每个节点都包含了一个字符串 从链表的两端推入或者弹出元素；根据偏移量对链表进行修剪(trim)；读取单个或者多个元素；根据值来查找或者移除元素
Set 包含字符串的无序收集器(unorderedcollection)，并且被包含的每个字符串都是独一无二的、各不相同 添加、获取、移除单个元素；检查一个元素是否存在于某个集合中；计算交集、并集、差集；从集合里卖弄随机获取元素
Hash 包含键值对的无序散列表 添加、获取、移除单个键值对；获取所有键值对
Zset 字符串成员(member)与浮点数分值(score)之间的有序映射，元素的排列顺序由分值的大小决定 添加、获取、删除单个元素；根据分值范围(range)或者成员来获取元素

11.3string字符串
string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 ,string类型是Redis最基本的数据类型，一个键最大能存储512MB。
set key value 如果有键，则自动覆盖
通过help set 查看格式
SET key value [EX seconds] [PX milliseconds] [NX|XX]
set 键 值 过期秒数 过期毫秒数 键不存在|键存在

get key
keys * 查看所有的键 keys aa* keys aa?? ?是占位符
getset key value 修改新的值，返回旧的值
其他命令：append、strlen、setrange、getrange
注意：字符串的存储方式正序从0开始
倒序最后一位为-1，依次累减
11.4list列表
Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
格式: lpush name value
在 key 对应 list 的头部添加字符串元素

格式: rpush name value
在 key 对应 list 的尾部添加字符串元素

格式: lrem name index
key 对应 list 中删除 count 个和 value 相同的元素

格式: llen name
返回 key 对应 list 的长度

11.5Hash格式:
redis hash是一个键值对的集合，是一个string类型的field和value的映射表，适合用于存储对象。

格式: hmset name key1 value1 key2 value2

Redis hash 是一个键值(key=>value)对集合。

Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。

11.6Set（集合）

格式: sadd name value
Redis的Set是string类型的无序集合。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。

11.7zset(sorted set：有序集合)
是string类型的有序集合，也不可重复
有序集合中的每个元素都需要指定一个分数，根据分数对元素进行升序排序，如果多个元素有相同的分数，则以字典序进行升序排序，sorted set因此非常适合实现排名。

格式: zadd name score value

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

11.8Redis常用命令

Keys pattern
*表示区配所有

以bit开头的

查看Exists key是否存在

Set
设置 key 对应的值为 string 类型的 value。

setnx
设置 key 对应的值为 string 类型的 value。如果 key 已经存在，返回 0，nx 是 not exist 的意思。

删除某个key

第一次返回1 删除了 第二次返回0

Expire 设置过期时间（单位秒）

TTL查看剩下多少时间

返回负数则key失效，key不存在了

Setex

设置 key 对应的值为 string 类型的 value，并指定此键值对应的有效期。

Mset

一次设置多个 key 的值，成功返回 ok 表示所有的值都设置了，失败返回 0 表示没有任何值被设置。

Getset

设置 key 的值，并返回 key 的旧值。

Mget

一次获取多个 key 的值，如果对应 key 不存在，则对应返回 nil。

Incr

对 key 的值做加加操作,并返回新的值。注意 incr 一个不是 int 的 value 会返回错误，incr 一个不存在的 key，则设置 key 为 1

incrby

同 incr 类似，加指定值 ，key 不存在时候会设置 key，并认为原来的 value 是 0

Decr

对 key 的值做的是减减操作，decr 一个不存在 key，则设置 key 为-1

Decrby

同 decr，减指定值。

Append

给指定 key 的字符串值追加 value,返回新字符串值的长度。

Strlen

取指定 key 的 value 值的长度。

persist xxx(取消过期时间)

选择数据库（0-15库）
Select 0 //选择数据库

move age 1//把age 移动到1库

Randomkey随机返回一个key

Rename重命名

Type 返回数据类型

在Spring中，我们对Redis存储的数据进行操作时，通常使用的是RedisTemplate这个类。

我们知道，在对Redis数据进行访问时，一般情况下都是使用Redis命令进行访问，但是在Spring中，为了简化对Redis数据的访问，就产生了RedisTemplate。

Spring配置：
配置redis本地安装后的信息,放在.properties中；

11.9客户端可视化界面:

安装完成:

Java使用 redis:

http://www.redis.net.cn/tutorial/3525.html

安装

开始在 Java 中使用 Redis 前， 我们需要确保已经安装了 redis 服务及 Java redis 驱动，且你的机器上能正常使用 Java。 Java的安装配置可以参考我们的 Java开发环境配置 接下来让我们安装 Java redis 驱动：
首先你需要下载驱动包，下载 jedis.jar，确保下载最新驱动包。
在你的classpath中包含该驱动包。

在pom.xml中加入坐标依赖，下载 jedis.jar

		<dependency>
			<groupId>redis.clientsgroupId>
			<artifactId>jedisartifactId>
			<version>2.8.1version>
		dependency>

写个测试类玩玩

package com.movie.test;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
public class TestRedis {
	@Test
	public void test1() {
		//创建Jedis并连接
		Jedis jedis = new Jedis("localhost");
		//存储一个字符串
		jedis.set("hello", "redis");
		//取出来
		System.out.println(jedis.get("hello"));
	}
}

za
也可以在可视化界面查看
首先我们开启服务，在打开客户端

在可视化界面Redis Manager上可以查看结果

可能需要重新加载

结果：

连接到 redis 服务

1.import redis.clients.jedis.Jedis;
2.public class RedisJava {
3. public static void main(String[] args) {
4. //连接本地的 Redis 服务
5. Jedis jedis = new Jedis(“localhost”);
6. System.out.println(“Connection to server sucessfully”);
7. //查看服务是否运行
8. System.out.println("Server is running: "+jedis.ping());
9. }
10.}
编译以上 Java 程序，确保驱动包的路径是正确的。
1.$javacRedisJava.java2.$java RedisJava
3.Connection to server sucessfully
4.Server is running: PONG
5.
6.Redis Java String Example

Redis Java String(字符串) 实例

1.import redis.clients.jedis.Jedis;
2.public class RedisStringJava {
3. public static void main(String[] args) {
4. //连接本地的 Redis 服务
5. Jedis jedis = new Jedis(“localhost”);
6. System.out.println(“Connection to server sucessfully”);
7. //设置 redis 字符串数据
8. jedis.set(“w3ckey”, “Redis tutorial”);
9. // 获取存储的数据并输出
10. System.out.println("Stored string in redis:: "+ jedis.get(“w3ckey”));
11. }
12.}
编译以上程序。
1.$javacRedisStringJava.java2.$java RedisStringJava
3.Connection to server sucessfully
4.Stored string in redis:: Redis tutorial

11.10.4Redis Java List(列表) 实例
1.import redis.clients.jedis.Jedis;
2.public class RedisListJava {
3. public static void main(String[] args) {
4. //连接本地的 Redis 服务
5. Jedis jedis = new Jedis(“localhost”);
6. System.out.println(“Connection to server sucessfully”);
7. //存储数据到列表中
8. jedis.lpush(“tutorial-list”, “Redis”);
9. jedis.lpush(“tutorial-list”, “Mongodb”);
10. jedis.lpush(“tutorial-list”, “Mysql”);
11. // 获取存储的数据并输出
12. List list = jedis.lrange(“tutorial-list”, 0 ,5);
13. for(int i=0; i 14. System.out.println("Stored string in redis:: "+list.get(i));
15. }
16. }
17.}
编译以上程序。
1.$javacRedisListJava.java2.$java RedisListJava
3.Connection to server sucessfully
4.Stored string in redis:: Redis
5.Stored string in redis:: Mongodb
6.Stored string in redis:: Mysql

11.10.5Redis Java Keys 实例
1.import redis.clients.jedis.Jedis;
2.public class RedisKeyJava {
3. public static void main(String[] args) {
4. //连接本地的 Redis 服务
5. Jedis jedis = new Jedis(“localhost”);
6. System.out.println(“Connection to server sucessfully”);
7.
8. // 获取数据并输出
9. List list = jedis.keys(“*”);
10. for(int i=0; i 11. System.out.println("List of stored keys:: "+list.get(i));
12. }
13. }
14.}
编译以上程序。
1.$javacRedisKeyJava.java2.$java RedisKeyJava
3.Connection to server sucessfully
4.List of stored keys:: tutorial-name
5.List of stored keys:: tutorial-list

Spring整合Redis:[ SSM+Redis:]

关于缓存:
在高并发下，为了提高访问的性能，需要将数据库中 一些经常展现和不会频繁变更的数据，存放在存取速率更快的内存中。这样可以降低数据的获取时间，带来更好的体验减轻数据库的压力缓存适用于读多写少的场合，查询时缓存命中率很低、写操作很频繁等场景不适宜用缓存。

MySQL有自己的查询缓存，为什么还要使用 Redis 等缓存应用？
当只有一台 MySQL服务器时，可以将缓存放置在本地。这样当有相同的 SQL 查询到达时，可以直接从缓存中取到查询结果，不需要进行 SQL 的解析和执行。MySQL 提供了服务器层面的缓存支持。
如果有多台 MySQL 服务器，请求会随机分发给多台中的一台，我们无法保证相同的请求会到达同一台服务器，本地缓存命中率较低。所以基于本机的缓存就没有什么意义，此时采用的策略应该是将查询结果缓存在 Redis 或者 Memcache 中。
而Redis是一个高性能的 key-value 内存数据库，可以作为缓存使用。

简单方式

1. 将需要jar的坐标引入pom.xml文件:

		<dependency>
			<groupId>redis.clientsgroupId>
			<artifactId>jedisartifactId>
			<version>3.1.0version>
		dependency>
		<dependency>
			<groupId>org.springframework.datagroupId>
			<artifactId>spring-data-redisartifactId>
			<version>2.3.3.RELEASEversion>
		dependency>

2. 在src/main/resources文件夹下，新建spring-redis.xml的Spring配置文件，内容如下

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxTotal" value="100" />
		<property name="maxIdle" value="20" />
		<property name="minIdle" value="3" />
		<property name="maxWaitMillis" value="2000" />
	bean>

	
	<bean id="jedisConnectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
		p:poolConfig-ref="poolConfig" p:port="6379" p:password=""
		p:hostName="127.0.0.1" />

	
	<bean id="genericJackson2JsonRedisSerializer"
		class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />
	
	<bean id="stringRedisSerializer"
		class="org.springframework.data.redis.serializer.StringRedisSerializer" />

	<bean id="redisTemplate"
		class="org.springframework.data.redis.core.RedisTemplate">
		
		<property name="connectionFactory"
			ref="jedisConnectionFactory" />
		
		<property name="keySerializer" ref="stringRedisSerializer" />
		
		<property name="valueSerializer"
			ref="genericJackson2JsonRedisSerializer" />
	bean>
beans>

3. 在applicationContext.xml文件中加入Spring文件的配置信息spring-redis.xml

<import resource="spring-redis.xml"/>

4. 写个测试类TestRedisTemplate.java试试

@SpringJUnitConfig(locations = "classpath:applicationContext.xml")
@WebAppConfiguration
public class TestRedisTemplate {
	
	@Autowired
	RedisTemplate  redisTemplate;
	
	@Test
	public void test1() {
		//ops Operations Value =>String 
		//存储
		redisTemplate.opsForValue().set("spring", "spring-redis");
		
		//取出来
		System.out.println(redisTemplate.opsForValue().get("spring"));
	}
}

拦截器方式

Redis的配置文件:

在spring的配置文件中，加入redis.properties

加入redis通用类和拦截器类:
Redis通用类：
RedisTemplate，spring中封装了数据库redis的一些通用访问操作，在这个redis通用类加入了一些简单的逻辑.

拦截器类

拦截器类，决定了我们要拦截哪些请求的规则，也就是要缓存哪些内容，不缓存哪些内容.
当然，调用了redisUitl完成的.

Redis的缓存是基于序列化和反序列化的操作，所以我们要缓存的对象要实现序列化接口.

完成spring全局配置配置文件的配置:

applicationContext.xml：

其中使用的类 省略: 具体请见代码

大家的项目中是否能加入redis缓存? [并发大 访问频率高 ,一定时间内数据不变.]
好友列表，车位展示？，前台的展示:[商品 文章 评论 等]

项目中加入redis

经典案例：手机验证码登录

频繁读取，不会经常发生变化的数据
-> 网站公告，新闻
-> 系统通知

SpringBoot(SSM、JPA) 引入Redis

1. 依赖引入
   新建加入SpringData
   或者pom.xml加入依赖坐标，reload

2. 修改application.properties文件——redis连接
   spring.redis.host=localhost
   spring.redis.password=
   spring.redis.port

3. 在service实现类前加入
   @Cacheable(cacheNames=“showGoods”)
   在启动路口加入
   @EnableCaching

4. 数据缓存冲突情况
   加入@SpringBootTest
   @AutoWired
   右键方法名@Test

5. 做修改前，把数据缓存删除
   在service实现类
   @CacheEvict(key=“#user.userid”,cacheNames=“getusersbyid”) 根据一定条件对缓存清空
   @Cacheable(key=“#userid”,cacheNames=“getusersbyid”)
   @CachePut
   需要和@Cacheable的方法的返回值是一致的

@Test
    void testString() {
        //向redis中添加数据
        redisTemplate.opsForValue().set("name", "tom");
        //从redis中获取数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name ：" + name);
    }

    @Test
    void testObj() {
        //向redis中存储存对象
        Person p1 = new Person(1, "tom");

        //向redis中新增数据
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<Person>(Person.class));
        redisTemplate.opsForValue().set("p1", p1);

        //从redis中获取数据
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<Person>(Person.class));

        Person p = (Person) redisTemplate.opsForValue().get("p1");
        System.out.println("p：" + p);
    }

    @Test
    void testGetObj() {

        //从redis中获取数据
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<Person>(Person.class));

        Person p = (Person) redisTemplate.opsForValue().get("p1");
        System.out.println("p：" + p);
    }