Spring Boot-整合redis(六)

最新推荐文章于 2023-06-26 16:07:24 发布
最新推荐文章于 2023-06-26 16:07:24 发布
阅读量72 收藏
点赞数
文章标签： 数据库 java
原文链接：http://www.cnblogs.com/LQBlog/p/9242750.html
版权

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);
    }


}

 

转载于:https://www.cnblogs.com/LQBlog/p/9242750.html

denggouya9281
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
GB28181国标28181的JAVA注册实现代码
10-23
最近用JAVA的SIP协议写了一个GB28181平台的对接，并成功完成了海康、大华、中威等设备，更重要的是海康平台、公安一所平台的对接。因为行业内很少有JAVA方面的设备接入实现，希望本篇能够让JAVA在安防接入生态中发挥越来越大的作用。 详细了解，请查看https://www.jianshu.com/p/4438711f6f3e
6.Redis6 与 Spring Boot 整合
dingxiao123的博客
04-25 297
Spring Boot整合Redis非常简单，只需要按如下步骤整合即可。
SpringBoot简单整合redis
weixin_45317589的博客
10-15 381
这是一个使用redis内带的RedisTemplate使用redis 的简单整合 (1)导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> （2）编写配置信息（就是写入redis的配置信息） 这个是根据
SpringBoot整合Redis6及简单增删改查
weixin_52258854的博客
08-12 689
本文将从零开始以SpringBoot为基础整合Redis6，并配合mybatis-plus的代码生成器实现基础的mysql+redis双数据源的增删改查。
SpringBoot(六)：SpringBoot整合Redis
qq_35071164的博客
05-31 102
https://blog.csdn.net/plei_yue/article/details/79362372
spring-boot-整合redis
最新发布
03-08
pdf详细步骤介绍spring-boot-整合redis如何实现 添加依赖：在项目的构建文件（如pom.xml）中加入spring-boot-starter-data-redis依赖，这是整合Redis的基础。 配置Redis连接：在application.properties或application...
Spring-Boot-Redis-Session：Spring Boot整合Redis与Session共享
02-13
Spring-Boot-Redis-Session Spring Boot整合Redis，详情请查看依赖Spring Boot依赖（创建项目时选择） Sprint Boot2.1.5.RELEASE由于spring-boot-starter-parent 2.1.5.RELEASE中的会话需要安全性支持，故此需要约会...
spring-boot-shiro-redis整合源码
08-03
spring-boot-shiro-redis 整合源码
spring-boot-redis.zip
07-20
spring-boot整合MySQL，mybatis，redis
springboot整合spring-data-redis遇到的坑
08-30
使用springboot整合redis,使用默认的序列化配置,然后使用redis-client去查询时查询不到相应的key.问题出在哪，怎么解决呢？下面小编给大家带来了springboot整合spring-data-redis遇到的坑，需要的的朋友参考下吧
springboot整合redis6
m0_67820396的博客
08-31 605
springboot整合redis6
【六】springboot整合redis
热门推荐
weixin_56995925的博客
09-06 2万+
springboot整合redis
springboot整合redis
Mr_yu_shao的博客
08-30 4804
超详解springboot整合redis！！！
Redis6学习笔记【part5】SpringBoot整合Redis
Parker_cpp的博客
01-19 107
首先先自动注入 RedisTemplate ，利用 RedisTemplate 对 redis 进行操作。进行测试，成功返回 redis 中的值。
springboot整合redis详细教程
weixin_47976194的博客
01-09 1334
注意：本次实验环境 是将 redis 安装在 CentOS7.x-86_x64 中 教程中用到的软件（VMware Workstation Pro、postman、idea、Another Redis Desktop Manager、FinalShell（xshell也可）、DBeaver（数据库客户端就行））
6.springboot整合redis
qq_53597372的博客
06-20 85
1.创建一个名为springboot-redis的springboot工程。
SpringBoot2.x整合Redis6客户端
菜鸟联盟
08-05 681
一java语言客户端 Jedis 是直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的,需要使用连接池 其API提供了比较全面的Redis命令的支持，相比于其他Redis 封装框架更加原生 Jedis中的方法调用是比较底层的暴露的Redis的API，Java方法基本和Redis的API保持着一致 使用阻塞的I/O，方法调用同步，程序流需要等到socket处理完I/O才能执行，不支持异步操作 lettuce 高级Redis客户端，用于线程安全同步，异步响应 基于Net.
Spring Boot 整合 Redis 全面教程：从配置到使用
weixin_43749805的博客
06-26 2万+
Redis 是一种高性能的键值存储数据库，而 Spring Boot 是一个简化了开发过程的 Java 框架。将两者结合，可以轻松地在 Spring Boot 项目中使用 Redis 来实现数据缓存、会话管理和分布式锁等功能。
为什么引入的spring-data-redis和spring-boot-starter-data-redis不一致
06-03
因为Spring Boot会对`spring-data-redis`进行封装和整合，所以在使用`spring-boot-starter-data-redis`时，可以不必关心`spring-data-redis`的具体版本，只需要关注`spring-boot-starter-data-redis`的版本即可。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值