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. Window.open()打开一个窗体不被拦截

    Window.open()打开一个窗体不被拦截     在DataGrid中建一个模板列,在模板列中放一个客户端的Button,或者直接写你要的字句,然后用<a href>连接例:< ...

  2. hdu 1075(字典树)

    What Are You Talking About Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 102400/204800 K ...

  3. hdoj--1220--Cube(数学推导)

    Cube Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submi ...

  4. 利用递归分割(Split)字符串

    利用递归分割(Split)字符串 SqlServer 递归 工作需要将表里的某个字段分割之后再插入到另一个表中,其实数据量不大,直接用游标一行一行的取,再利用循环来分割之后再实现数据的插入应该可以直接 ...

  5. vs2010永久删除项目的相关操作

    1.选中要删除的项目,在解决方案资源管理器中,直接左键点击一下即可.. 2.点击键盘的删除键“DElect”. 3.然后找到工程的目录后,删除项目.即可永久性删除不在需要的程序或者是项目.

  6. PCB Genesis原点坐标转换关系

    一.Genesis原点坐标转换关系: 1.读取Genesis坐标转换:   UI界面坐标 = 文件坐标 - 偏移值 2.写入Genesis坐标转换:   文件坐标 = UI界面坐标 + 偏移值 3.为 ...

  7. Django day17 博客项目(一)

    一: 博客项目需求分析 首页(显示文章) 文章详情 点赞, 点踩 文章评论 字评论 评论的展示 登录功能(图片验证码) 注册功能(基于form验证,ajax) 个人站点(不同人不同样式,文章过滤) 后 ...

  8. 遍历WPF DataGrid单元格

    using System.Windows.Controls; using System.Windows.Controls.Primitives; using System.Windows.Media; ...

  9. WPF播放器

    最近由于工作需要,需要做一个播放软件,在网上参考了很多例子,园子里有很多代码.其中最多的就是wpf自带的MediaElement控件,或者VLC视频播放器. 先附我自己查询资料的链接: MediaEm ...

  10. 在.xls;*.xlsx类型文件的导入(可以导入多条数据)

    2018-11-28   17:36:35 需要jar包:poi-3.8-201203026.jar jsp页面: <LINK href="${basePath}plugins/upl ...