网关与auth微服务缓存打通

文章目录

🌞 Sun Frame:SpringBoot 的轻量级开发框架(个人开源项目推荐)

轻松高效的现代化开发体验

Sun Frame 是我个人开源的一款基于 SpringBoot 的轻量级框架,专为中小型企业设计。它提供了一种快速、简单且易于扩展的开发方式。
我们的开发文档记录了整个项目从0到1的任何细节,实属不易,请给我们一个Star!🌟
您的支持是我们持续改进的动力。

🌟 亮点功能

  • 组件化开发:灵活选择,简化流程。
  • 高性能:通过异步日志和 Redis 缓存提升性能。
  • 易扩展:支持多种数据库和消息队列。

📦 spring cloud模块概览

  • Nacos 服务:高效的服务注册与发现。
  • Feign 远程调用:简化服务间通信。
  • 强大网关:路由与限流。

常用工具

  • 日志管理:异步处理与链路追踪。
  • Redis 集成:支持分布式锁与缓存。
  • Swagger 文档:便捷的 API 入口。
  • 测试支持:SpringBoot-Test 集成。
  • EasyCode:自定义EasyCode模板引擎,一键生成CRUD。

🔗 更多信息


1.缓存一致性问题

1、更新了数据库,再更新缓存

假设数据库更新成功,缓存更新失败,在缓存失效和过期的时候,读取到的都是老数据缓存。

2、更新缓存,更新数据库

缓存更新成功了,数据库更新失败,是不是读取的缓存的都是错误的。

以上两种,全都不推荐。

3、先删除缓存,再更新数据库

有一定的使用量。即使数据库更新失败。缓存也可以会刷。

存在的问题是什么?

高并发情况下!!

比如说有两个线程,一个是 A 线程,一个是 B 线程。

A 线程把数据删了,正在更新数据库,这个时候 B 线程来了,发现缓存没了,又查数据,又放入缓存。缓存里面存的就一直是老数据了。

延迟双删。更新完数据库之后,再删一次。

扩展思路
1、消息队列补偿

删除失败的缓存,作为消息打入 mq,mq 消费者进行监听,再次进行重试刷缓存。

2、canal

监听数据库的变化,做一个公共服务,专门来对接缓存刷新。优点业务解耦,业务太多冗余代码复杂度。

2.auth微服务在用户注册时,将当前用户的角色和权限都放到redis里

1.sun-club-auth-domain
1.pom.xml 引入依赖
xml 复制代码
        <!-- 序列化 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.12.7</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.7</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.6</version>
        </dependency>
2.RedisConfig.java
java 复制代码
package com.sunxiansheng.auth.domain.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Description: 原生 redis 的 template 的序列化器会产生乱码问题,重写改为 jackson
 * @Author sun
 * @Create 2024/6/5 14:16
 * @Version 1.0
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer());
        return redisTemplate;
    }

    private Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer() {
        Jackson2JsonRedisSerializer<Object> jsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jsonRedisSerializer.setObjectMapper(objectMapper);
        return jsonRedisSerializer;
    }

}
3.RedisUtil.java
java 复制代码
package com.sunxiansheng.auth.domain.redis;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Description: RedisUtil工具类
 * @Author sun
 * @Create 2024/6/5 14:17
 * @Version 1.0
 */
@Component
@Slf4j
public class RedisUtil {

    @Resource
    private RedisTemplate redisTemplate;

    private static final String CACHE_KEY_SEPARATOR = ".";

    /**
     * 构建缓存key
     */
    public String buildKey(String... strObjs) {
        return Stream.of(strObjs).collect(Collectors.joining(CACHE_KEY_SEPARATOR));
    }

    /**
     * 是否存在key
     */
    public boolean exist(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 删除key
     */
    public boolean del(String key) {
        return redisTemplate.delete(key);
    }

    public void set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public boolean setNx(String key, String value, Long time, TimeUnit timeUnit) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, time, timeUnit);
    }

    public String get(String key) {
        return (String) redisTemplate.opsForValue().get(key);
    }

    public Boolean zAdd(String key, String value, Long score) {
        return redisTemplate.opsForZSet().add(key, value, Double.valueOf(String.valueOf(score)));
    }

    public Long countZset(String key) {
        return redisTemplate.opsForZSet().size(key);
    }

    public Set<String> rangeZset(String key, long start, long end) {
        return redisTemplate.opsForZSet().range(key, start, end);
    }

    public Long removeZset(String key, Object value) {
        return redisTemplate.opsForZSet().remove(key, value);
    }

    public void removeZsetList(String key, Set<String> value) {
        value.stream().forEach((val) -> redisTemplate.opsForZSet().remove(key, val));
    }

    public Double score(String key, Object value) {
        return redisTemplate.opsForZSet().score(key, value);
    }

    public Set<String> rangeByScore(String key, long start, long end) {
        return redisTemplate.opsForZSet().rangeByScore(key, Double.valueOf(String.valueOf(start)), Double.valueOf(String.valueOf(end)));
    }

    public Object addScore(String key, Object obj, double score) {
        return redisTemplate.opsForZSet().incrementScore(key, obj, score);
    }

    public Object rank(String key, Object obj) {
        return redisTemplate.opsForZSet().rank(key, obj);
    }


}
4.AuthUserDomainServiceImpl.java register方法新增逻辑
java 复制代码
// 要把当前用户的角色和权限都放到redis里

// 1、存储角色
// 构建一个角色的key
String roleKey = redisUtil.buildKey(authRolePrefix, authUser.getUserName());
// 构建一个角色列表作为value
List<AuthRole> roleList = new ArrayList<>();
// 向角色列表中添加角色
roleList.add(authRole);
// 将角色列表序列化并放到redis中
redisUtil.set(roleKey, new Gson().toJson(roleList));

// 2、存储权限
// 查询当前用户拥有的权限
// 1.注册的时候,用户只有一个角色,先根据这个角色id去角色权限关联表中查询多条关联的记录
AuthRolePermission authRolePermission = new AuthRolePermission();
// 设置逻辑删除
authRolePermission.setIsDeleted(IsDeleteFlagEnum.UN_DELETED.getCode());
// 设置角色id
authRolePermission.setRoleId(roleId);
// 查询出一个角色权限关联的列表
List<AuthRolePermission> authRolePermissionList = authRolePermissionService.queryByCondition(authRolePermission);
// 2.根据查询出来的列表,得到所有的权限id
List<Long> permissionIdList = authRolePermissionList.stream().map(AuthRolePermission::getPermissionId).collect(Collectors.toList());
// 根据权限id,查询所有的权限,就是根据ids批量查询
List<AuthPermission> permissionList = authPermissionService.queryByIds(permissionIdList);
// 将权限列表序列化并放到redis中
String permissionKey = redisUtil.buildKey(authPermissionPrefix, authUser.getUserName());
redisUtil.set(permissionKey, new Gson().toJson(permissionList));
2.sun-club-auth-infra
1.AuthRolePermissionService.java
java 复制代码
/**
 * 根据角色id查询角色权限关联表
 * @param authRolePermission
 * @return
 */
List<AuthRolePermission> queryByCondition(AuthRolePermission authRolePermission);
2.AuthRolePermissionServiceImpl.java
java 复制代码
/**
 * 根据角色id查询角色权限关联表
 * @param authRolePermission
 * @return
 */
@Override
public List<AuthRolePermission> queryByCondition(AuthRolePermission authRolePermission) {
    return this.authRolePermissionDao.queryAllByLimit(authRolePermission);
}
3.AuthPermissionService.java
java 复制代码
/**
 * 通过ids查询数据
 * @param ids
 * @return
 */
public List<AuthPermission> queryByIds(List<Long> ids);
4.AuthPermissionServiceImpl.java
java 复制代码
/**
 * 通过ids查询数据
 * @param ids
 * @return
 */
public List<AuthPermission> queryByIds(List<Long> ids) {
    return authPermissionDao.queryByIds(ids);
}
5.AuthPermissionDao.java
java 复制代码
/**
 * 通过ID批量查询
 *
 * @param ids
 * @return
 */
List<AuthPermission> queryByIds(@Param("ids") List<Long> ids);
6.AuthPermissionDao.xml
xml 复制代码
<select id="queryByIds" resultMap="AuthPermissionMap">
    select id, name, parent_id, type, menu_url, status, `show`, icon, permission_key, created_by, created_time,
    update_by, update_time, is_deleted
    from auth_permission
    where id in
    <foreach collection="ids" item="id" open="(" close=")" separator=",">
        #{id}
    </foreach>
</select>
3.测试

3.gateway鉴权时可以获取权限/角色列表

1.sun-club-
1.复制两个entity到这个模块
1.AuthPermission.java
java 复制代码
package com.sunxiansheng.club.gateway.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * (AuthPermission)实体类
 *
 * @author makejava
 * @since 2024-06-06 17:16:58
 */
@Data
public class AuthPermission implements Serializable {

    private Long id;
    /**
     * 权限名称
     */
    private String name;
    /**
     * 父id
     */
    private Long parentId;
    /**
     * 权限类型 0菜单 1操作
     */
    private Integer type;
    /**
     * 菜单路由
     */
    private String menuUrl;
    /**
     * 状态 0启用 1禁用
     */
    private Integer status;
    /**
     * 展示状态 0展示 1隐藏
     */
    private Integer show;
    /**
     * 图标
     */
    private String icon;
    /**
     * 权限唯一标识
     */
    private String permissionKey;
    /**
     * 创建人
     */
    private String createdBy;
    /**
     * 创建时间
     */
    private Date createdTime;
    /**
     * 更新人
     */
    private String updateBy;
    /**
     * 更新时间
     */
    private Date updateTime;
    /**
     * 是否被删除 0为删除 1已删除
     */
    private Integer isDeleted;

}
2.AuthRole.java
java 复制代码
package com.sunxiansheng.club.gateway.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * (AuthRole)实体类
 *
 * @author makejava
 * @since 2024-06-06 14:30:38
 */
@Data
public class AuthRole implements Serializable {

    private Long id;
    /**
     * 角色名称
     */
    private String roleName;
    /**
     * 角色唯一标识
     */
    private String roleKey;
    /**
     * 创建人
     */
    private String createdBy;
    /**
     * 创建时间
     */
    private Date createdTime;
    /**
     * 更新人
     */
    private String updateBy;
    /**
     * 更新时间
     */
    private Date updateTime;
    /**
     * 是否被删除 0未删除 1已删除
     */
    private Integer isDeleted;


}
2.StpInterfaceImpl.java 根据loginId和前缀获取权限/角色列表
java 复制代码
/**
 * 根据loginId和前缀获取权限/角色列表
 * @param loginId
 * @param prefix
 * @return
 */
private List<String> getAuth(String loginId, String prefix) {
    // 得到该用户在redis中存储的key
    String authKey = redisUtil.buildKey(prefix, loginId.toString());
    // 从redis中获取列表
    String authValue = redisUtil.get(authKey);
    // 判空
    if (StringUtils.isBlank(authValue)) {
        return Collections.emptyList();
    }
    List<String> authList = new LinkedList<>();
    // 根据前缀来决定将内容反序列化为什么形式
    if (authRolePrefix.equals(prefix)) {
        // 如果是角色列表的前缀,就反序列化为角色类型的
        List<AuthRole> authRoleList = new Gson().fromJson(authValue, new TypeToken<List<AuthRole>>() {
        }.getType());
        // 得到roleKey的列表,放到authList中
        authList = authRoleList.stream().map(AuthRole::getRoleKey).collect(Collectors.toList());
    } else if (authPermissionPrefix.equals(prefix)) {
        // 如果是权限列表,就反序列化为权限类型的
        List<AuthPermission> authPermissionList = new Gson().fromJson(authValue, new TypeToken<List<AuthPermission>>() {
        }.getType());
        // 得到permissionKey,放到authList中
        authList = authPermissionList.stream().map(AuthPermission::getPermissionKey).collect(Collectors.toList());
    }
    return authList;
}
3.sun-club-auth-application-controller
在UserController.java可以设置用户登录时的token对应的loginId,这里设置成鸡翅
3.测试
1.首先登录,生成token和loginId(这里写死为鸡翅)
2.然后携带token进行登录,后端就可以找到对应的loginId,在验证登录成功之后会进行鉴权
1.在gateway的SaTokenConfigure.java可以配置鉴权的类型
2.下面是分别两种方式,从redis中取出的角色列表和权限列表
相关推荐
奶糖趣多多2 小时前
Redis知识点
数据库·redis·缓存
CoderIsArt3 小时前
Redis的三种模式:主从模式,哨兵与集群模式
数据库·redis·缓存
ketil277 小时前
Redis - String 字符串
数据库·redis·缓存
Dann Hiroaki8 小时前
GPU架构概述
架构
茶馆大橘8 小时前
微服务系列五:避免雪崩问题的限流、隔离、熔断措施
java·jmeter·spring cloud·微服务·云原生·架构·sentinel
coding侠客9 小时前
揭秘!微服务架构下,Apollo 配置中心凭啥扮演关键角色?
微服务·云原生·架构
生命几十年3万天9 小时前
redis时间优化
数据库·redis·缓存
lipviolet10 小时前
架构系列---高并发
架构
Phodal10 小时前
架构赋能 AI:知识工程推动下的软件架构数字化
人工智能·架构
lexusv8ls600h10 小时前
微服务设计模式 - 网关路由模式(Gateway Routing Pattern)
spring boot·微服务·设计模式