springBoot项目搭建包含RBAC模块 -- 引入redis和rabbitMq（三）

原创 已于 2022-07-25 14:32:07 修改 · 466 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #java-rabbitmq #redis

于 2022-06-22 14:20:24 首次发布
本文介绍了如何在Spring Boot项目中整合Redis和RabbitMQ。首先，通过添加相关依赖并配置Redis，创建了RedisTemplate及Redis工具类，用于实现数据的增删查改操作。接着，引入RabbitMq依赖，并配置了RabbitMq的Bean。文章最后提到这两个组件在实际项目中的应用场景，如Redis用于管理token，RabbitMq则用于消息传递。

上一章我们整合好了mybatis-Plus 这一章我们引入一些项目要用到的一些组件redis、rabbitMq

1. common工程引入redis

首先，需要引入redis的依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

如果使用lettuce 还需要引入


<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

引入完依赖以后我们还需要定义一个redis配置类，添加到common工程下的config目录，

package com.swh.common.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @ClassName: RedisConfig
 * @Description:
 * @Author: songWenHao
 * @Date: 2022/5/30 13:36
 */
@Configuration
@AutoConfigureBefore(RedisAutoConfiguration.class)
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);

        // 用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer); // key
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        // 指定要序列化的域(field,get,set)，访问修饰符(public,private,protected)
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); //value

        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}

我自己封装了一个redis的工具类，添加到conmon工程下的utils目录

package com.swh.common.utils;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.support.atomic.RedisAtomicLong;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @ClassName: RedisCacheUtil
 * @Description:
 * @Author: songWenHao
 * @Date: 2022/5/30 13:38
 */
@Slf4j
@Component
public class RedisCacheUtil {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public String stringGet(String key) {
        try {
            return redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis string get 异常：{}", e.getMessage());
            return null;
        }
    }

    public List<String> stringGet(String... key) {
        try {
            return redisTemplate.opsForValue().multiGet(Arrays.asList(key));
        } catch (Exception e) {
            for (String s : key) {
                if (ObjectUtil.isNull(s) || StrUtil.equalsAnyIgnoreCase(s, "null") || StrUtil.isBlank(s)) {
                    LOGGER.error("存在为空值的key");
                    e.printStackTrace();
                }
            }
            LOGGER.error("redis string get 异常：{}", e.getMessage());
            return null;
        }
    }

    public void stringDel(String key) {
        try {
            redisTemplate.delete(key);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis string get 异常：{}", e.getMessage());
        }
    }

    public void stringPut(String key, String value) {
        try {
            redisTemplate.opsForValue().set(key, value);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis string set 异常：{}", e.getMessage());
        }
    }

    public void stringPut(String key, String value, int i, TimeUnit timeUnit) {
        try {
            redisTemplate.opsForValue().set(key, value, i, timeUnit);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis string set 异常：{}", e.getMessage());
        }
    }

    public String hashGet(String key, String mapKey) {
        try {
            return (String) redisTemplate.opsForHash().get(key, mapKey);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis hash get 异常：{}", e.getMessage());
            return null;
        }
    }

    public List<String> hashGet(String key, String... mapKeys) {
        try {
            return Arrays.stream(mapKeys).map(k -> {
                Object o = redisTemplate.opsForHash().get(key, k);
                if (ObjectUtil.isNotNull(o)) {
                    return (String) o;
                } else {
                    LOGGER.error("redis Hash 取出值为空：一级key{},二级key{}", key, k);
                    return null;
                }
            }).filter(Objects::nonNull).collect(Collectors.toList());
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis hash get 异常：{}", e.getMessage());
            return new ArrayList<>();
        }
    }

    public List<String> hashGet(String key, List<String> hashKeys) {
        try {
            return hashKeys.parallelStream().map(k -> {
                Object o = redisTemplate.opsForHash().get(key, k);
                if (ObjectUtil.isNotNull(o)) {
                    return (String) o;
                } else {
                    LOGGER.debug("redis Hash 取出值为空：一级key{},二级key{}", key, k);
                    return null;
                }
            }).filter(Objects::nonNull).collect(Collectors.toList());
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis hash entries 异常：{}", e.getMessage());
            return new ArrayList<>();
        }
    }

    public Map<String, String> hashEntries(String key) {
        try {
            HashOperations<String, String, String> hashOperations = redisTemplate.opsForHash();
            return hashOperations.entries(key);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis hash entries 异常：{}", e.getMessage());
            return new HashMap<>();
        }
    }

    public void hashPut(String key, String mapKey, String value) {
        try {
            redisTemplate.opsForHash().put(key, mapKey, value);
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.error("redis hash put 异常：{}", e.getMessage());
        }
    }

    public void hashPut(String key, Map<String, String> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.error("redis hash putAll 异常：{}", e.getMessage());
        }
    }

    public void hashPut(String key, Map<String, String> map, int i, TimeUnit timeUnit) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (i > 0) {
                redisTemplate.expire(key, i, timeUnit);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.error("redis hash putAll 异常：{}", e.getMessage());
        }
    }

    public void hashPut(String key, String mapKey, String value, int i, TimeUnit timeUnit) {
        try {
            redisTemplate.opsForHash().put(key, mapKey, value);
            if (i > 0) {
                redisTemplate.expire(key, i, timeUnit);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.error("redis hash put 异常：{}", e.getMessage());
        }
    }

    public void hashDel(String key, Object... mapKeys) {
        try {
            redisTemplate.opsForHash().delete(key, mapKeys);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis hash delete 异常：{}", e.getMessage());
        }
    }

    public long getExpire(String key) {
        try {
            return redisTemplate.getExpire(key);
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.error("redis getExpire 异常：{}", e.getMessage());
            return -1;
        }
    }

    public void setExpire(String key, long time, TimeUnit timeUnit) {
        try {
            if (time > 0){
                redisTemplate.expire(key, time, timeUnit);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.error("redis setExpire 异常：{}", e.getMessage());
        }
    }

    public void setToAdd(String key, String value) {
        try {
            redisTemplate.opsForSet().add(key, value);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis set add  异常：{}", e.getMessage());
        }
    }

    public void setToRemove(String key, String value) {
        try {
            redisTemplate.opsForSet().remove(key, value);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis set remove  异常：{}", e.getMessage());
        }
    }

    public Set<String> setForMembers(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            if (ObjectUtil.isNull(key) || StrUtil.equalsAnyIgnoreCase(key, "null") || StrUtil.isBlank(key)) {
                LOGGER.error("存在为空值的key");
                e.printStackTrace();
            }
            LOGGER.error("redis set members  异常：{}", e.getMessage());
            return new HashSet<>();
        }
    }

    public Long getIncr(String key) {
        return new RedisAtomicLong(key, Objects.requireNonNull(redisTemplate.getConnectionFactory())).getAndIncrement();
    }

    public void setIncr(String key, int value) {
        redisTemplate.opsForValue().set(key, value + 1 + "");
    }


}

在application.yml添加你的redis链接配置就可以使用了

spring:
  redis:   
    database: 0
    host: 127.0.0.1
    port: 6379
    password:

项目中redis我是来管理token的，当然你也可以用来缓存其他的数据，毕竟redis的效率还是很高的。

2. 引入rabbitMq

首先，引入rabbitMq依赖 

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

需要创建一个配置类用来声明rabbitMq相应的bean

package com.swh.common.config;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import static com.swh.common.constant.AdminUserConst.Mqkey.MQ_SCAN_MENU_RESOURCE;
import static com.swh.common.constant.AdminUserConst.Mqkey.QUEUE_MQ_ADD_EER_LOG;


/**
 * @ClassName: RabbitMqBeanConfig
 * @Description: 用于声明rabbitmq相关的bean
 * @Author: songWenHao
 * @Date: 2022/6/1 16:23
 */
@Configuration
public class RabbitMqBeanConfig {

    @Bean
    public Queue scanMenuResource() {
        return new Queue(MQ_TEST);
    }


}

这个类需要加载到自动装备中，在resources目录下创建一个META-INF目录然后创建一个spring.factories 文件把对应的配置类路径加进去

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.swh.common.config.RabbitMqBeanConfig

rabbitMq具体的使用我们在后面具体写使用代码的时候在讲解包括redis也是。

springboot整合shiro完成RBAC功能
m0_73414822的博客
03-05 459
springboot整合shiro实现加密，权限管理.......
基于 SpringBoot+Mybatis+Redis+RabbitMQ 秒杀系统
hfbin的博客
08-14 2万+
开发工具 idea 2017.2.3 开发环境 JDK Maven Mysql SpringBoot redis RabbitMQ 1.8 3.2.2 5.7 1.5.10.RELEASE 3.2 项目启动说明 1、启动前，请配置 application.properties 中相关redis、mysql、ra...
Spring+Redis+RabbitMQ限流和秒杀项目的开发
hello world
02-02 4761
本文将围绕高并发场景中的限流和秒杀需求综合演示Spring Boot整合JPA、Redis缓存和RabbitMQ消息队列的做法。 本项目将通过整合Springboot和Redis以及Lua脚本来实现限流和秒杀的效果，将通过RabbitMQ消息队列来实现异步保存秒杀结果的效果。 一、项目概述 本项目将要实现的秒杀是指商家在某个时间段以非常低的价格销售商品的一种营销活动。 由于商品价格非常低，因此单位时间内发起购买商品的请求会非常多，从而会对系统造巨大的压力。对此，在一些秒杀系统中往往会整合限流的功能，同时会通
Openresty最佳案例 | 第8篇：RBAC介绍、sql和redis模块工具类
热门推荐
方志朋的专栏
11-23 3万+
RBAC介绍RBAC（Role-Based Access Control，基于角色的访问控制），用户基于角色的访问权限控制。简单地说，一个用户拥有若干角色，每一个角色拥有若干权限。这样，就构造成“用户-角色-权限”的授权模型。在这种模型中，用户与角色之间，角色与权限之间，一般都是多对多的关系。如图所示：sql_tool在本案例中，采用的就是这种权限设计的方式。具体的sql语句脚本如下：CREATE
搭建springboot+springcloud+mybatis+redis+rabbitmq项目框架
qq_37664264的博客
08-12 3308
1.1创建父工程 创建统一的父工程：cloud，用来管理依赖及其版本，注意是创建project，而不是moudle 填写项目信息： 注意： 父工程不需要代码，只是管理依赖，因此我们不选择任何SpringCloud的依赖 跳过依赖选择。 填写保存的位置信息： 然后将pom文件修改成我这个样子： <?xml version="1.0" encoding="...
springboot+redis整合rabbitmq
qq_40548741的博客
07-14 4821
MQ（IBM MQ）代表消息队列，是一种应用程序对应用程序的通信方法； 通过消息传递队列发送和接收消息数据，支持应用程序，系统，服务和文件之间的信息交换。 这简化了业务应用程序的创建和维护。 RabbitMQ是目前非常热门的一款消息中间件，不管是互联网大厂还是中小企业都在大量使用。 RabbitMQ中的交换机有Direct Exchange（直连交换机）、Topic Exchange（主题交换器）、Fanout Exchange（广播式交换机）、Headers Exchange（Headers交换机）四种
基于SpringBoot+Mybatis+Redis+RabbitMQ秒杀系统.zip
12-03
基于SpringBoot+Mybatis+Redis+RabbitMQ秒杀系统基于SpringBoot+Mybatis+Redis+RabbitMQ秒杀系统友情项目 Libra-Platform微服务平台。基于SpringCloud & SpringCloudAlibaba & SpringBoot & Vue3开发，基于多机场...
spring-boot-demo-RabbitMQ消息队列实战项目
最新发布
10-29
plus(Mybatis)BeetlSQL(ORM)upload()redis()ehcache()email()task()quartz()xxl-job()swagger(API)security(RBAC)SpringSession(Session)Zookeeper(AOP)RabbitMQ()Kafka()websocket()socket.io()ureport2()war ...
Java基于 SpringBoot+Mybatis+Redis+RabbitMQ 秒杀系统源码.zip
07-20
基于SpringCloud & SpringCloudAlibaba & SpringBoot & Vue3开发，基于多租户SaaS模式的设计，拥有强大的用户中心（一个账号对应多业务身份），权限基于RBAC设计，支持蓝绿灰度发布、网关动态路由、服务治理（流量...
基于SpringBoot与Vue的RBAC权限及秒杀系统集成实现
本项目标题为“基于SpringBoot+Vue+JWT+RabbitMQ的RBAC权限模型的后台管理系统集成演唱会门票秒杀”，描述中明确指出该项目是一个完整的课程设计系统，采用前后端分离架构，后端以Spring Boot为核心框架，前端使用...
Springboot+Shiro+Redis实现RBAC用户权限管理
07-22
Springboot+Shiro+Redis实现RBAC用户权限管理，其中采用org.creazycake的插件将Redis整合到Shiro中管理
SpringBoot集成RabbitMQ和Redis
青莳的博客
12-23 508
application.properties配置文件。在service中使用rabbitmq。rabbitmq的Listen监听消息。在service中使用redis。redis配置类（序列化）rabbirmq配置类。
springBoot项目搭建包含RBAC模块 -- 整合Swagger3和全局异常处理（四）
weixin_43470322的博客
06-24 428
上一章我们在项目中整合了redis和RabbitMq，这一章我们整合Swagger3和自定义异常。在common工程pom.xml引入swagger依赖，我这边引用的是swagger3.0依赖 在common工程config目录添加swagger需要的配置类 如果你想给swagger添加全局通用参数可以修改刚刚的配置类，我这边就加上了全局参数token和开发调试的auth.........
springBoot项目搭建包含RBAC模块 -- 基础框架搭建（一）
weixin_43470322的博客
06-21 1212
这是一个springboot单体的项目使用的是聚合工程，包含基础RBAC模块，主要使用的是：springboot 、mybatis-plus、webflux、mysql、redis、rabbitmq等技术。
RBAC用户权限管理数据库设计的图文详解
dianshanpang3778的博客
08-16 791
RBAC（Role-Based Access Control，基于角色的访问控制），就是用户通过角色与权限进行关联。简单地说，一个用户拥有若干角色，每一个角色拥有若干权限。这样，就构造成“用户-角色-权限”的授权模型。在这种模型中，用户与角色之间，角色与权限之间，一般者是多对多的关系。（如下图） 角色是什么？可以理解为一定数量的权限的集合，权限的载体。例如：一个论坛系统，“超...
分享一个不错的springboot+vue框架，ELadmin，适合初学者
何时林听@
11-10 1420
项目介绍 一个基于 Spring Boot 2.1.0 、 Spring Boot Jpa、 JWT、Spring Security、Redis、Vue的前后端分离的后台管理系统 项目源码 后端源码 前端源码 github https://github.com/elunez/eladmin https://github.com/elunez/eladmin-web 码云 https://gitee.com/elunez/eladmin https:...
基于SpringBoot学习RBAC（角色-权限-控制）
sdnyqfyqf的博客
04-15 1万+
文章目录前言1.RBACSpring相关注解 前言 本博客旨在记录个人的一个RBAC学习过程，因为刚学SpringBoot，RBAC也涉及到数据库的知识，本文亦可作为SpringBoot及数据库的一个入门参考。 1.RBAC 用过linux系统的应该都知道在linux系统中每个文件都有着r可读w可写x可执行三种权限，不同的用户对同一个文件也有着不同的权限，这和RBAC是类似的，RBAC全称Role...
微服务技术系列教程（39）- SpringBoot -RBAC权限模型
阿甘兄
12-17 1087
1. 引言 代码和相关的sql脚本已提交至Github，有兴趣的同学可以下载看看：https://github.com/ylw-github/SpringBoot-Security-Demo 2. RBAC权限模型 RBAC权限模型 : 基于角色的权限访问控制（Role-Based Access Control）作为传统访问控制（自主访问，强制访问）的有前景的代替受到广泛的关注。 在RBAC中...
使用 Redis 实现 RBAC 权限管理
nbsaas-boot基于Request-Response的企业级快速开发框架
02-18 843
RBAC（Role-Based Access Control，基于角色的访问控制）是一种常见的权限管理模型，它通过。及其映射关系来控制访问权限。在传统的 RBAC 设计中，权限数据通常存储在。作为 Web 框架，并结合。：无状态，适用于 API 认证。：高效、适用于分布式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值