安装 redis

安装redis windows版。

安装redis-desktop-manager-0.8.8.384.exe

redis 服务端

1. 解压 安装包，选择指定目录（最好全英文目录）

选择 Redis-x64-3.2.100.zip，进行解压

1. 部署 Redis在windows下的服务

1. 管理员身份打开 命令提示符

1. 切换路径为 解压安装的目录

1. 命令行使：redis-server --service-install redis.windows.conf

部署完成：设置自启动（内存占用很小）

redis使用命令

也可以进入 计算机管理，选择服务，鼠标右键启动或停止服务。

redis 客户端

1. 选择 redis-desktop-manager-2020.1.0.0.exe1 2020版本的 redis客户端（中文的），双击运行

1. 下一步，下一步，选择安装目录（最好全英文目录）

1. 下载完成，询问是否 安装完成自动打开，勾选 Finish

主界面

1. 配置 文件，开启远程访问

1. 查看 所需的文件，Redis服务右键属性查看

1. 在 安装目录找到对应的文件

1. 修改 连接密码

搜索 requirepass 关键字，取消注释并 确定密码（顶格写！）

1. 注释 本地连接对应的 bind 127.0.0.1

搜索 bind 关键字

1. 将redis默认的守护关闭

搜索 protected 关键字

修改 protected-mode yes 为 protected-mode no

1. 保存文件，重启 redis 服务生效

修改配置，重新启动服务才会有效

新建 redis连接

• 新建 redis 连接，确定就可以建立了

• 默认有 十六个数据库 0-15，不需要自己创

（如果需要可以手动添加）

redis 小知识

相关知识

• redis 也是一个框架

• 可以 抗住 高并发的压力，MySQL不行。

• Redis 缓存数据具有时效性，过期会自动删除（3600s 为 一小时）

• redis 集群：

• 集群是 redis不仅只有一个节点，而是 有很多节点

• 为什么会有集群？？

• 如果 redis只有一个节点，为单节点，它挂了，与之所有相关连接的客户端全部报错

• 如果是集群，有多个节点，一个节点挂了，还有其他节点在工作，可以切换到其他节点进行连接

• redis 只能存储 key，value值

• 集合 或对象只能通过 Jackson转成 json对象（本质为 字符串），再把数据储存进 redis

• 多端模式（手机端，电脑端，网页端...）

• session 不合适，第三方存储 redis合适

• cookie 也不合适，手机端不支持，小程序也不支持，redis支持

五大常用类型

详情参考 https://zhuanlan.zhihu.com/p/161311820

spring+redis集成配置

pom.xml 导入依赖

定义版本

<properties>

<!--spring+ redis 集成配置-->

<!-- spring-data-redis 依赖：支持在spring管理项目对redis的操作-->

<spring-data-redis.version>1.7.1.RELEASE</spring-data-redis.version>

<!--mybatis-redis是 redis数据库的java语言的驱动jar包，用来操作redis数据库。类似与mysql-jdbc连接桥-->

<jedis.version>2.9.0</jedis.version>

<!--jackson：集合、数组及对象 转成字符串-->

<jackson.version>2.9.3</jackson.version>

</properties>

导入依赖

<!--spring+ redis 集成配置-->

<!-- spring-data-redis 依赖：支持在spring管理项目对redis的操作-->

<dependency>

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

<version>${jedis.version}</version>

<exclusions>

<exclusion>

<artifactId>commons-pool2</artifactId>

<groupId>org.apache.commons</groupId>

</exclusion>

</exclusions>

</dependency>

<!--mybatis-redis是 redis数据库的java语言的驱动jar包，用来操作redis数据库。类似与mysql-jdbc连接桥-->

<dependency>

<groupId>org.springframework.data</groupId>

<artifactId>spring-data-redis</artifactId>

<version>${spring-data-redis.version}</version>

</dependency>

<!--jackson：集合、数组及对象 转成字符串-->

<dependency>

<groupId>com.fasterxml.jackson.core</groupId>

<artifactId>jackson-databind</artifactId>

<version>${jackson.version}</version>

<exclusions>

<exclusion>

<artifactId>jackson-annotations</artifactId>

<groupId>com.fasterxml.jackson.core</groupId>

</exclusion>

</exclusions>

</dependency>

<dependency>

<groupId>com.fasterxml.jackson.core</groupId>

<artifactId>jackson-core</artifactId>

<version>${jackson.version}</version>

</dependency>

<dependency>

<groupId>com.fasterxml.jackson.core</groupId>

<artifactId>jackson-annotations</artifactId>

<version>${jackson.version}</version>

</dependency>

新建 spring-redis.xml

新建 spring 与 redis 的集成文件

记得 在 spirng.xml 文件中引入 spring-redis.xml！！！

步骤

1. 导入外部数据库连接 配置文件 redis.properties

1. 创建数据库连接池

1. 创建 Redis 连接工厂类 ConnectionFactory

1. 创建 RedisTemplate 模板类

导入外部 Redis配置文件

转换编码格式

文件是 编码格式：（记得 检查ip地址和密码，不正确则修改）

idea 可 转换为 中文（utf-8）可视化读，但是源文件还是 编码格式

打开设置：File 选择 Settings

导入 redis.properties

<!--1.导入外部的数据库链接配置文件redis.properties-->

<context:property-placeholderlocation="classpath:redis.properties"/>

多配置文件.properties文件引入方式：

<!--1. 引入外部多文件方式 -->

<beanid="propertyConfigurer"

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<propertyname="systemPropertiesModeName"value="SYSTEM_PROPERTIES_MODE_OVERRIDE"/>

<propertyname="ignoreResourceNotFound"value="true"/>

<propertyname="locations">

<list>

<value>classpath:jdbc.properties</value>

<value>classpath:redis.properties</value>

</list>

</property>

</bean>

将spring-mybatis.xml和spring-redis.xml中引入的properties配置文件注释，并统一到spring.xml文件中配置引入。

创建 Redis数据库连接池

<!--2.创建Redis数据库连接池-->

<beanid="poolConfig"class="redis.clients.jedis.JedisPoolConfig">

<!--最大空闲数-->

<propertyname="maxIdle"value="${redis.maxIdle}"/>

<!--连接池的最大数据库连接数 -->

<propertyname="maxTotal"value="${redis.maxTotal}"/>

<!--最大建立连接等待时间-->

<propertyname="maxWaitMillis"value="${redis.maxWaitMillis}"/>

<!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟)-->

<propertyname="minEvictableIdleTimeMillis"value="${redis.minEvictableIdleTimeMillis}"/>

<!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3-->

<propertyname="numTestsPerEvictionRun"value="${redis.numTestsPerEvictionRun}"/>

<!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1-->

<propertyname="timeBetweenEvictionRunsMillis"value="${redis.timeBetweenEvictionRunsMillis}"/>

<!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个-->

<propertyname="testOnBorrow"value="${redis.testOnBorrow}"/>

<!--在空闲时检查有效性, 默认false -->

<propertyname="testWhileIdle"value="${redis.testWhileIdle}"/>

</bean>

创建 Redis连接工厂类

<!--3. 创建 Redis 连接工厂类 ConnectionFactory-->

<!-- 怎么拿到连接？（配置与注解 结合使用）

@Autowired

private ConnectionFactory connectionFactory; //通过 Bean注入 上下文，在 SpringIOC容器中

-->

<!--配备 销毁方法，当连接关闭时触动销毁-->

<beanid="connectionFactory"class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"

destroy-method="destroy">

<!--依赖于 上面添加的 连接池-->

<propertyname="poolConfig"ref="poolConfig"/>

<!--IP地址 -->

<propertyname="hostName"value="${redis.hostName}"/>

<!--端口号 -->

<propertyname="port"value="${redis.port}"/>

<!--如果 Redis设置有密码 -->

<propertyname="password"value="${redis.password}"/>

<!--客户端超时时间单位是毫秒 -->

<propertyname="timeout"value="${redis.timeout}"/>

</bean>

创建 RedisTemplate模板类

这里针对两种类型

• String类型

• 添加序列化 （不进行序列化，redis缓存不了）

• Hash类型

复杂类型需要 转换后再添加到 redi内

<!--4. 创建 RedisTemplate 模板类（人为控制 变为自动控制）-->

<!-- @Autowired

private RedisTemplate<String,Object> redisTemplate;

-->

<!-- redis操作模板,使用该对象可以轻松操作 redis缓存的数据 -->

<beanid="redisTemplate"class="org.springframework.data.redis.core.RedisTemplate">

<!--redis是 key-value-->

<propertyname="connectionFactory"ref="connectionFactory"/>

<!--如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！！ -->

<!--String 类型-->

<!--需要添加序列号，将 key、value 先转换成 json对象，在存储进 redis数据库-->

<propertyname="keySerializer">

<beanclass="org.springframework.data.redis.serializer.StringRedisSerializer"/>

</property>

<propertyname="valueSerializer">

<beanclass="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>

</property>

<!--Hash 类型-->

<!--进行序列化转换，进行 json转换-->

<propertyname="hashKeySerializer">

<beanclass="org.springframework.data.redis.serializer.StringRedisSerializer"/>

</property>

<propertyname="hashValueSerializer">

<beanclass="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>

</property>

<!--开启事务 -->

<propertyname="enableTransactionSupport"value="false"/>

</bean>

启用spring注解式缓存

配置Redis缓存管理器

<!--5.配置 redis缓存管理器-->

<beanid="redisCacheManager"class="org.springframework.data.redis.cache.RedisCacheManager">

<!--通过构造函数引入 第四步的 模板-->

<constructor-argname="redisOperations"ref="redisTemplate"/>

<!--设置缓存时间：默认配置文件中的 3600s。redis缓存数据过期时间单位秒-->

<propertyname="defaultExpiration"value="${redis.expiration}"/>

​

<!--是否使用缓存前缀-->

<propertyname="usePrefix"value="true"/>

<!--设置缓存前缀（不开启缓存前缀，此步骤无意义）-->

<propertyname="cachePrefix">

<beanclass="org.springframework.data.redis.cache.DefaultRedisCachePrefix">

<constructor-argindex="0"value="-cache-"/>

</bean>

</property>

</bean>

配置redis缓存过期时间、是否使用缓存前缀及缓存前缀配置。

配置自定义Key生成器

bean注入

导入自定义Key生成器 CacheKeyGenerator

<!--6.配置自定义Key生成器CacheKeyGenerator-->

<beanid="cacheKeyGenerator"class="com.zking.ssm.util.CacheKeyGenerator"/>

引入 CacheKeyGenerator类

packagecom.zking.ssm.util;

​

@Slf4j

/**

* 自定义 Key生成

*/

publicclassCacheKeyGeneratorimplementsKeyGenerator {

// custom cache key

publicstaticfinalintNO_PARAM_KEY=0;

publicstaticfinalintNULL_PARAM_KEY=53;

​

/**

* 重写方法：生成 Key规则

* @param target 目标对象

* @param method 目标方法

* @param params 目标方法的执行参数

* @return

*/

@Override

publicObjectgenerate(Objecttarget, Methodmethod, Object... params) {

//动态的 可变字符串

StringBuilderkey=newStringBuilder();

/* target.getClass().getSimpleName() = BookServiceImpl

1）-cache-BookServiceImpl.queryBookPager:0 无参

2）-cache-BookServiceImpl.queryBookPager:zs,10 ？？啥情况

3）-cache-BookServiceImpl.queryBookPager:53 参数为 null值，赋值常量

4）-cache-BookServiceImpl.queryBookPager:89,90,91... 判断参数是否为集合或集合，循环遍历取出单个参数

5）-cache-BookServiceImpl.queryBookPager:zs String类型，直接拼接参数

6）-cache-BookServiceImpl.queryBookPager:109 HashCode值

*/

key.append(target.getClass().getSimpleName()).append(".").append(method.getName()).append(":");

if (params.length==0) {

key.append(NO_PARAM_KEY);

} else {

intcount=0;

for (Objectparam : params) {

if (0!=count) {//参数之间用,进行分隔

key.append(',');

}

if (param==null) {

key.append(NULL_PARAM_KEY);

} elseif (ClassUtils.isPrimitiveArray(param.getClass())) {

intlength=Array.getLength(param);

for (inti=0; i<length; i++) {

key.append(Array.get(param, i));

key.append(',');

}

} elseif (ClassUtils.isPrimitiveOrWrapper(param.getClass()) ||paraminstanceofString) {

key.append(param);

} else {//Java一定要重写hashCode和eqauls

key.append(param.hashCode());

}

count++;

}

}

​

//根据规则生成的 key，转成字符串，最终输出 字符串类型数据

StringfinalKey=key.toString();

log.debug("using cache key={}", finalKey);

returnfinalKey;

}

}

启用注解式缓存

<!--7.启用注解式缓存-->

<!--使用缓存管理器（第五步），自定义 key生成（第六步）-->

<cache:annotation-drivencache-manager="redisCacheManager"key-generator="cacheKeyGenerator"/>

缓存注解

@CacheConfig

@CacheConfig是一个类级别的注解，允许共享缓存的名称、KeyGenerator、CacheManager和CacheResolver。

@Cacheable

配置在方法或类上

作用：

本方法执行后，先去缓存看有没有数据，如果没有，从数据库中查找出来，给缓存中存一份，返回结果，次本方法执行，在缓存未过期情况下，先在缓存中查找，有的话直接返回，没有的话从数据库查找。

先在 redis缓存查，没有则先去数据库真实查询并备份在 redis中，有的则直接在 redis取出数据

属性

//'' 字符串，随意填，覆盖 默认策略
//#bookId SpEL表达式
@Cacheable(value="selectOne",key="'book-'+#bookId")
​
+ 只有一个 ` " "` ，默认是 value的属性值；如果有其他属性，则必须添加 `value=""`
​
+ value 补全在 缓存前缀的前面
​
+ 缓存的值就是 当前方法的返回值

在 接口实现类添加注解

示例：

@Cacheable(value="selectByPrimaryKey",key="'selectOne-'+#bookId",condition="#bookId>90")

@Override

publicBookselectByPrimaryKey(IntegerbookId) {

Bookbook=bookMapper.selectByPrimaryKey(bookId);

returnbook;

}

redis 缓存

@CachePut

作用

更新操作，即每次不管缓存中有没有结果，都从数据库查找结果，并将结果更新到缓存，并返回结果。

每次从数据库获取结果，一般用于 update方法
key 属性要与之前 保持一致

属性

示例：

@CachePut(value="selectByPrimaryKey",key="'selectOne-'+#bookId",condition="#bookId>90")

@Override

publicBookselectByPrimaryKey(IntegerbookId) {

Bookbook=bookMapper.selectByPrimaryKey(bookId);

returnbook;

}

@CacheEvict

用来清除用在本方法或者类上的缓存数据（用在哪里清除哪里）。

属性

示例

示例一：清空指定缓存

@CacheEvict(value="selectByPrimaryKey")

@Override

publicvoiddelete(IntegerbookId) {

System.out.println("被删除了...");

}

示例二：清空所有缓存

@CacheEvict(value="selectByPrimaryKey",allEntries=true)

@Override

publicvoiddelete(IntegerbookId) {

System.out.println("被删除了...");

}

多框架->配置文件覆盖问题

引入多框架导致配置文件覆盖

后者覆盖前者

比如，在 spirng.xml 文件引入过个相关文件

<!--多框架引入，会导致 redis的配置文件覆盖 mybatis的 jdbc配置（后者覆盖前者）-->

<!--引入 spring和 mybatis的集成文件-->

<importresource="spring-mybatis.xml"/>

<!--引入 spring和 redis的集成文件-->

<importresource="spring-redis.xml"/>

spring-mybatis 文件会引入 jdbc.properties 配置

spring-redis 文件会引入 redis.properties 配置

从而导致， redis 会覆盖 jdbc的连接

解决问题

将spring-mybatis.xml和spring-redis.xml中引入的properties配置文件注释，并统一到spring.xml文件中配置引入。

PS: spring-mybatis 的引入语句需要注释，否则 重复引用了
spring-redis 的引入语句也要同步注释。

<!--引入外部多文件方式 -->

<beanid="propertyConfigurer"

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<propertyname="systemPropertiesModeName"value="SYSTEM_PROPERTIES_MODE_OVERRIDE"/>

<propertyname="ignoreResourceNotFound"value="true"/>

<propertyname="locations">

<list>

<value>classpath:jdbc.properties</value>

<value>classpath:redis.properties</value>

</list>

</property>

</bean>

本节回顾

Spring 与 redis 集成配置

1. 导入依赖

spring-data-redis
jedis
jackson

1. spring-redis.xml

1. 导入外部的配置文件 redis.properties

1. properties 多文件引入方式的改变

1. 创建数据库连接池

1. 创建 ConnectionFactory 连接工厂类

1. 创建 RedisTemplate

1. 实践操作

@Autowire

privateRedisTemplate<String,Object>redisTemplate;

redisTemplate.opsForValue().set(key,value);

开启注解式缓存

1. 配置 缓存管理器 RedisCacheManager

1. 通过 ref 引用 RedisTemplate ref="RedisTemplate"

1. 设置统一过期时间：3600s

1. 开启缓存前缀 -cache-

1. 配置自定义的 KeyCacheGenerator 的生成器

-cache- 类名.方法名:参数：不同方法（相同方法）的不同参数所缓存的效果不一样

1. 开启注解式缓存

案例

关键点

• @Cacheable：第一次先到缓存查，缓存有返回，如果缓存没有触发真实查询，将数据存储到缓存里面再返回。（第二次查询只要数据有缓存，且没过期就从缓存返回）

• @CachePut：每一次都触发数据库真实查询，并将查询结果存储到缓存中。实现数据更新和同步

• @CacheEvict：

• 根据指定 Key，删除某个缓存

• 批量的删除，删除所有

相关知识

key的生成策略

keyGenerator

1）-cache-BookServiceImpl.queryBookPager:0 无参2）-cache-BookServiceImpl.queryBookPager:zs,10 ？？啥情况3）-cache-BookServiceImpl.queryBookPager:53 参数为 null值，赋值常量4）-cache-BookServiceImpl.queryBookPager:89,90,91... 判断参数是否为集合或集合，循环遍历取出单个参数5）-cache-BookServiceImpl.queryBookPager:zs String类型，直接拼接参数6）-cache-BookServiceImpl.queryBookPager:109 HashCode值

雪崩、击穿和穿透

缓存雪崩和缓存击穿主要是数据不在缓存上，而缓存穿透是数据既不在缓存上，也不在数据上。

详情参考：https://blog.csdn.net/weixin_39559282/article/details/114167769

手动配置缓存

//进行 redis缓存 RedisTemplate<String,Object>:既可以操控 String，也可操控 Hash

@Autowired

privateRedisTemplate<String,Object>redisTemplate;//Bean 定义的 id=redisTemplate

@Autowired

// private StringRedisTemplate stringRedisTemplate;//只能操控 String

​

​

@Test

publicvoidredisTest(){

Bookbook=newBook();

book.setBookId(10);

book.setBookName("三字经");

book.setBookNamePinyin("szj");

book.setBookPrice(120.0F);

book.setBookType("经书");

//这里存储的 书本对象：redis 内不允许直接存储对象，根据 String将 书本对象转成 json后再存进 redis

redisTemplate.opsForValue().set("book",book,15L, TimeUnit.SECONDS);//手动设置 时间：15秒后过期

// redisTemplate.opsForValue().set("book",book);//String 类型

// redisTemplate.opsForHash();//Hash类型

}