redis安装

参考:https://www.cnblogs.com/LQBlog/p/9214517.html

单机版

1.添加pom依赖

<!-- Spring Boot Reids 依赖 -->

        <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>1.5.7.RELEASE</version>
</dependency> <!--spring2.0集成redis所需common-pool2-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.4.2</version>
</dependency>

2.application.properties配置redis连接信息

spring
redis:
host: 192.168.65.128
port: 6379
timeout: 0
password: # 密码 没有则不填

3.添加测试代码

@Service
public class AddressServiceImpl extends BaseServiceImpl<Address> implements AddressService {
@Resource
AddressMapper addressMapper; @Autowired
private RedisTemplate<Object,Object> redisTemplate;
@Override
public Address selectByPrimaryKey(Object key) {
String redisKey=key.toString();
Address address=(Address) redisTemplate.opsForValue().get(redisKey);
if(address==null){
//防止缓存穿透
synchronized (this) {
address = (Address) redisTemplate.opsForValue().get(redisKey);
if (address == null) {
address = super.selectByPrimaryKey(key);
redisTemplate.opsForValue().set(redisKey, address);
}
}
}else {
System.out.println("使用缓存了");
}
return address; }
}

红色代码是为了防止内存穿透,比如你这个业务方法有10000个人同时访问,如果不加锁。当第一次访问都判断address为空 然后全部去查数据库,正常应该是一个连接查询数据库并设置缓存 后面9999都使用缓存

通过redis Desktop Manager查看结果

因默认key 和value都是用jdk自带的序列化方式JdkSerializationRedisSerializer 可以发现可读性很差

自定义序列化方式

新增一个redisConfig 配置序列化方式

@Configuration
public class RedisConfig { /**
* redisTemplate 序列化使用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
* @param redisConnectionFactory
* @return
*/
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
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.afterPropertiesSet();
return redisTemplate;
}
}

再次测试结果

集群版

1.application.properties配置

  redis:
cluster:
master: myMaster
nodes: 192.168.65.128:6379,192.168.65.128:6380,192.168.65.128:6381,192.168.65.128:6382,192.168.65.128:6383,192.168.65.128:6384
timeout: 0

2.配置jedisCluster

@Configuration
public class RedisConfig { @Value("${spring.redis.cluster.nodes}")
private String clusterNodes;
@Value("${spring.redis.timeout}")
private int timeout; @Bean
public JedisCluster getJedisCluster() {
String[] cNodes = clusterNodes.split(",");
Set<HostAndPort> nodes = new HashSet<HostAndPort>();
// 分割出集群节点
for (String node : cNodes) {
String[] hp = node.split(":");
nodes.add(new HostAndPort(hp[0],Integer.parseInt(hp[1])));
} // 创建集群对象
// JedisCluster jedisCluster = new JedisCluster(nodes,commandTimeout);
JedisCluster jedisCluster = new JedisCluster(nodes);
return jedisCluster;
}
}

3.缓存操作 都通过jedisCluster来操作

package com.liqiang.utils;

import com.fasterxml.jackson.databind.JsonSerializable;
import org.apache.tomcat.util.buf.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.SerializationUtils;
import redis.clients.jedis.JedisCluster;
import tk.mybatis.mapper.util.StringUtil; import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.LinkedHashMap;
import java.util.Map; @Component
public class RedisUtil { protected int DEFAULT_EXPIRED_TIME_SECONDS_OBJECT = 1296000; @Autowired
private JedisCluster jedisCluster; public boolean putString(String sKey, String sValue, int expiredInSeconds) {
boolean result = false; if (StringUtil.isEmpty(sKey)) {
return result;
} if (this.jedisCluster != null) {
this.jedisCluster.set(sKey, sValue);
if (expiredInSeconds > 0) {
this.jedisCluster.expire(sKey, expiredInSeconds);
} result = true;
} return result;
} public boolean putString(String sKey, String sValue) {
return putString(sKey, sValue, this.DEFAULT_EXPIRED_TIME_SECONDS_OBJECT);
} public String getString(String sKey) {
String result = null;
if (StringUtil.isEmpty(sKey)) {
return result;
} if (this.jedisCluster != null) {
result = this.jedisCluster.get(sKey);
} return result;
} public boolean putObject(String sKey, Serializable object, int expiredInSeconds) {
boolean result = false; if (StringUtil.isEmpty(sKey)) {
return result;
} if (this.jedisCluster != null) {
byte[] datas = SerializationUtils.serialize(object);
byte[] arrKey = sKey.getBytes(); this.jedisCluster.set(arrKey, datas);
if (expiredInSeconds > 0) {
this.jedisCluster.expire(arrKey, expiredInSeconds);
} result = true;
} return result;
} public boolean putObject(String sKey, Serializable object) {
return putObject(sKey, object, this.DEFAULT_EXPIRED_TIME_SECONDS_OBJECT);
} public <T> T getObject(String sKey, Class<T> oclass) {
Object result = null;
if (StringUtil.isEmpty(sKey)) {
return null;
} System.out.println(sKey);
if (this.jedisCluster != null) {
byte[] arrKey = sKey.getBytes(); byte[] datas = this.jedisCluster.get(arrKey); if ((datas != null) && (datas.length > 0)) {
result = SerializationUtils.deserialize(datas);
}
}
System.out.println("dddd");
System.out.println(result);
return (T) result;
} public boolean putMap(String sKey, Map<String, String> oMap, int expiredInSeconds) {
boolean result = false; if ((StringUtil.isEmpty(sKey)) || (oMap == null) || (oMap.size() <= 0)) {
return result;
} if (this.jedisCluster != null) {
this.jedisCluster.hmset(sKey, oMap);
if (expiredInSeconds > 0) {
this.jedisCluster.expire(sKey, expiredInSeconds);
} result = true;
} return result;
} public boolean putMap(String sKey, Map<String, String> oMap) {
return putMap(sKey, oMap, this.DEFAULT_EXPIRED_TIME_SECONDS_OBJECT);
} public boolean putMap(String sKey, String sField, String sValue, int expiredInSeconds) {
boolean result = false; if ((StringUtil.isEmpty(sKey)) || (StringUtil.isEmpty(sField))) {
return result;
} if (this.jedisCluster != null) {
this.jedisCluster.hset(sKey, sField, sValue);
if (expiredInSeconds > 0) {
this.jedisCluster.expire(sKey, expiredInSeconds);
} result = true;
} return result;
} public boolean putMap(String sKey, String sField, String sValue) {
return putMap(sKey, sField, sValue, this.DEFAULT_EXPIRED_TIME_SECONDS_OBJECT);
} public Map<String, String> getMap(String sKey) {
Map result = null;
if (StringUtil.isEmpty(sKey)) {
return result;
} if (this.jedisCluster != null) {
result = this.jedisCluster.hgetAll(sKey);
} return result;
} public Map<String, String> getMap(String sKey, String[] fields) {
Map result = null; Map mapAll = getMap(sKey);
if ((mapAll != null) && (mapAll.size() > 0) && (fields != null) && (fields.length > 0)) {
result = new LinkedHashMap();
for (String field : fields) {
result.put(field, mapAll.get(field));
} } return result;
} public boolean existsMapItem(String sKey, String sField) {
if ((StringUtil.isEmpty(sKey)) || (StringUtil.isEmpty(sField))) {
return false;
} if (this.jedisCluster != null) {
return this.jedisCluster.hexists(sKey, sField).booleanValue();
} return false;
} public boolean putMapValueAsObject(String sKey, String sField, Serializable oValue, int expiredInSeconds) {
boolean result = false; if ((StringUtil.isEmpty(sKey)) || (StringUtil.isEmpty(sField))) {
return result;
} if (this.jedisCluster != null) {
byte[] arrKey = sKey.getBytes(); this.jedisCluster.hset(arrKey, sField.getBytes(), SerializationUtils.serialize(oValue));
if (expiredInSeconds > 0) {
this.jedisCluster.expire(arrKey, expiredInSeconds);
} result = true;
} return result;
} public boolean putMapValueAsObject(String sKey, String sField, Serializable oValue) {
return putMapValueAsObject(sKey, sField, oValue, this.DEFAULT_EXPIRED_TIME_SECONDS_OBJECT);
} public <T> T getMapValueAsObject(String sKey, String sField, Class<T> oClass) {
Object result = null; if ((StringUtil.isEmpty(sKey)) || (StringUtil.isEmpty(sField))) {
return null;
} if (this.jedisCluster != null) {
byte[] datas = this.jedisCluster.hget(sKey.getBytes(), sField.getBytes());
if ((datas != null) && (datas.length > 0)) {
Object tmpObject = SerializationUtils.deserialize(datas);
result = tmpObject;
}
} return (T) result;
} public void remove(String sKey) {
if (StringUtil.isEmpty(sKey)) {
return;
} if (this.jedisCluster != null)
this.jedisCluster.del(sKey);
} }

Spring Boot-整合redis(六)的更多相关文章

  1. SpringBoot入门系列(七)Spring Boot整合Redis缓存

    前面介绍了Spring Boot 中的整合Mybatis并实现增删改查,.不清楚的朋友可以看看之前的文章:https://www.cnblogs.com/zhangweizhong/category/ ...

  2. Spring Boot 整合 Redis 和 JavaMailSender 实现邮箱注册功能

    Spring Boot 整合 Redis 和 JavaMailSender 实现邮箱注册功能 开篇 现在的网站基本都有邮件注册功能,毕竟可以通过邮件定期的给用户发送一些 垃圾邮件 精选推荐

  3. Spring Boot2 系列教程(二十六)Spring Boot 整合 Redis

    在 Redis 出现之前,我们的缓存框架各种各样,有了 Redis ,缓存方案基本上都统一了,关于 Redis,松哥之前有一个系列教程,尚不了解 Redis 的小伙伴可以参考这个教程: Redis 教 ...

  4. (转)spring boot整合redis

    一篇写的更清晰的文章,包括redis序列化:http://makaidong.com/ncjava/330749_5285125.html 1.项目目录结构 2.引入所需jar包 <!-- Sp ...

  5. Spring Boot 整合 Redis 实现缓存操作

    摘要: 原创出处 www.bysocket.com 「泥瓦匠BYSocket 」欢迎转载,保留摘要,谢谢!   『 产品没有价值,开发团队再优秀也无济于事 – <启示录> 』   本文提纲 ...

  6. spring boot整合redis,以及设置缓存过期时间

    spring-boot 整合 redis 注:redis服务器要先开启 pom文件: <dependency> <groupId>org.springframework.boo ...

  7. spring boot 2.x 系列 —— spring boot 整合 redis

    文章目录 一.说明 1.1 项目结构 1.2 项目主要依赖 二.整合 Redis 2.1 在application.yml 中配置redis数据源 2.2 封装redis基本操作 2.3 redisT ...

  8. Spring Boot2 系列教程(二十九)Spring Boot 整合 Redis

    经过 Spring Boot 的整合封装与自动化配置,在 Spring Boot 中整合Redis 已经变得非常容易了,开发者只需要引入 Spring Data Redis 依赖,然后简单配下 red ...

  9. Spring Boot 整合Redis 实现缓存

      本文提纲 一.缓存的应用场景 二.更新缓存的策略 三.运行 springboot-mybatis-redis 工程案例 四.springboot-mybatis-redis 工程代码配置详解   ...

  10. spring boot 整合 redis

    自己开发环境需要安装 redis 服务,百度一下很多,下面主要说明Springboot 集成 redis 讲解 我的版本 java8 + redis3.0 + springboot 1.5.9. Sp ...

随机推荐

  1. Ubuntu Linux 安装 .7z 解压和压缩文件

    安装方法: sudo apt-get install p7zip 解压文件: 7z x manager.7z -r -o /home/xx解释如下:x 代表解压缩文件,并且是按原始目录解压(还有个参数 ...

  2. B1051 受欢迎的牛 tarjan缩点

    就是一道tarjan缩点的板子,之前在洛谷做过.但是我发现一个事,就是函数里面有一句话: void tarjan(int x) { dfn[x] = low[x] = ++tot; str[++top ...

  3. thinkphp session db配置

    这篇文章主要介绍了ThinkPHP实现将SESSION存入MYSQL的方法,需要的朋友可以参考下   本文以实例讲解了ThinkPHP实现将SESSION存入MYSQL的方法,所采用的运行环境是Thi ...

  4. Git 和 Redis 的基本认识

    一: Git 二: Redis

  5. 线性预测与Levinson-Durbin算法实现

    在学习信号处理的时候,线性预测是一个比较难理解的知识点,为了加快很多朋友的理解,这里给出Levinson-Durbin算法的线性预测实现和一个测试Demo,Demo中很明确的把输入信号.预测信号.预测 ...

  6. 题解报告:hdu 1847 Good Luck in CET-4 Everybody!(入门SG值)

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1847 Problem Description 大学英语四级考试就要来临了,你是不是在紧张的复习?也许紧 ...

  7. 努比亚 Z17 mini s (Nubia NX589J) 解锁BootLoader 并刷入recovery ROOT

    首先下载好工具链接:链接:https://pan.baidu.com/s/1gher4T9 密码:rypn 备用下载链接:https://pan.baidu.com/s/1nxdzt9Z 本篇教程教你 ...

  8. (List)写一个函数reverseList,该函数能够接受一个List,然后把该List 倒序排列。 例如:  List list = new ArrayList();  list.add(“Hello”);  list.add(“World”);  list.add(“Learn”); //此时list 为Hello World Learn  rever

    import java.util.ArrayList; import java.util.List; public class AA { public static void main(String[ ...

  9. java反射_01

    为什么要用反射? 举个栗子: package com.imooc.reflect; public class Work { // 定义一个word方法 public void word() { Sys ...

  10. QT设计UI:QT模式对话框打开文件

    使用QT模式对话框,并使显示框 为背景色: 方法使用了QCheckBox *native;   #include <QCheckBox> 初始化函数代码: //设置默认打开图像位置 nat ...