spring security oauth2 动态切换角色或者岗位，更新redis缓存

2023-11-20

1、切换角色或者岗位后更新缓存token，获取token，并更新token，特别要注意token中的内容

accessToken.getAdditionalInformation().put(SecurityConstants.DETAILS_POST_ID,postId);

 String key = authenticationKeyGenerator.extractKey(originalOAuth2Authentication);
                    byte[] serializedKey =  serializationStrategy.serialize(CacheConstants.PROJECT_OAUTH_ACCESS+"auth_to_access:" + key);
                    byte[] bytes = null;
                    RedisConnection conn = redisConnectionFactory.getConnection();
                    try {
                        bytes = conn.get(serializedKey);
                    } finally {
                        conn.close();
                    }
                    OAuth2AccessToken accessToken =serializationStrategy.deserialize(bytes,OAuth2AccessToken.class);
                    accessToken.getAdditionalInformation().put(SecurityConstants.DETAILS_POST_ID,postId);
                        tokenStore.storeAccessToken(accessToken,oauth2Authentication);

切换用户后，进行数据的更新。

 SysUser user = userService.selectUserByUserName(SecurityUtils.getUser().getUsername());
        Authentication authentication=SecurityContextHolder.getContext().getAuthentication();
        List<SysPost> postList= postService.selectPostsByUserName(user.getUserName());
        user.setPosts(postList);
        user.setPostId(postId);
        //角色集合
        //先查询对应岗位的角色ID
        Set<Integer> roles=postService.selectRoleIdsByPostId(postId);
        if(roles.size()<1){
            return R.failed("该岗位无权访问系统");
        }
        user.setRoleIds(roles.toArray(new Integer[roles.size()]));
        // 角色集合
        //Set<Integer> roles = permissionService.getRolePermission(sysUser.getUserId());
        // 权限集合
        //Set<String> permissions = permissionService.getMenuPermission(sysUser.getUserId());
        Set<String> permissions = permissionService.getMenuPermissionByRoles(user.getUserId(),roles);
        Set<String> dbAuthsSet = new HashSet<>();
        if (ArrayUtil.isNotEmpty(roles)) {
            // 获取角色
            roles.forEach(role -> dbAuthsSet.add(SecurityConstants.ROLE + role));
            // 获取资源
            dbAuthsSet.addAll(permissions);

        }
        Collection<? extends GrantedAuthority> authorities = AuthorityUtils
                .createAuthorityList(dbAuthsSet.toArray(new String[0]));

//        // 构造security用户
        UserDetails userDetails =new ItduUser(user.getUserId(),postId, user.getDeptId(), user.getRoles(), user.getUserName(),
                SecurityConstants.BCRYPT + user.getPassword(),
                StrUtil.equals("0", CommonConstants.STATUS_NORMAL), true, true, true, authorities);
        Cache cache = cacheManager.getCache(CacheConstants.USER_DETAILS);
        if (cache != null) {
            cache.put(user.getUserName(), userDetails);
        }
        ItduUser itduUser = new ItduUser(user.getUserId(),postId, user.getDeptId(), user.getRoles(), user.getUserName(), N_A, true, true, true, true, authorities);

        //替换oauth认证的信息里的details，这里就不展示了
       if (authentication instanceof OAuth2Authentication) {
            OAuth2Authentication originalOAuth2Authentication = (OAuth2Authentication) authentication;
            if (!originalOAuth2Authentication.isClientOnly()) {
                Authentication userAuthentication = originalOAuth2Authentication.getUserAuthentication();
                if (userAuthentication instanceof UsernamePasswordAuthenticationToken) {
                        //替换用户信息,权限信息根据自己的需求替换，这里直接取原来的
                        UsernamePasswordAuthenticationToken usernamePasswordAuthentication = new UsernamePasswordAuthenticationToken(itduUser, N_A, authorities);
                        usernamePasswordAuthentication.setDetails(itduUser);
                        OAuth2Authentication oauth2Authentication = new OAuth2Authentication(originalOAuth2Authentication.getOAuth2Request(), usernamePasswordAuthentication);
                        oauth2Authentication.setDetails(itduUser);
                    String key = authenticationKeyGenerator.extractKey(originalOAuth2Authentication);
                    byte[] serializedKey =  serializationStrategy.serialize(CacheConstants.PROJECT_OAUTH_ACCESS+"auth_to_access:" + key);
                    byte[] bytes = null;
                    RedisConnection conn = redisConnectionFactory.getConnection();
                    try {
                        bytes = conn.get(serializedKey);
                    } finally {
                        conn.close();
                    }
                    OAuth2AccessToken accessToken =serializationStrategy.deserialize(bytes,OAuth2AccessToken.class);
                    accessToken.getAdditionalInformation().put(SecurityConstants.DETAILS_POST_ID,postId);
                        tokenStore.storeAccessToken(accessToken,oauth2Authentication);
                }
            }
        }

后期使用

SecurityContextHolder.getContext().getAuthentication()   即可获取到当前登陆用户的相关信息

完整代码：

package com.intasect.upms.sys.controller;

import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.intasect.common.core.constant.CacheConstants;
import com.intasect.common.core.constant.CommonConstants;
import com.intasect.common.core.constant.SecurityConstants;
import com.intasect.common.core.constant.UserConstants;
import com.intasect.common.core.util.R;
import com.intasect.common.core.util.StringUtils;
import com.intasect.common.security.annotation.Inner;
import com.intasect.common.security.service.ItduUser;
import com.intasect.common.security.util.RedisTokenStore;
import com.intasect.common.security.util.SecurityUtils;
import com.intasect.upms.api.domain.SysPost;
import com.intasect.upms.api.domain.SysUser;
import com.intasect.upms.api.model.LoginUser;
import com.intasect.upms.sys.service.ISysPermissionService;
import com.intasect.upms.sys.service.ISysPostService;
import com.intasect.upms.sys.service.ISysUserService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.oauth2.common.OAuth2AccessToken;
import org.springframework.security.oauth2.provider.OAuth2Authentication;
import org.springframework.security.oauth2.provider.token.AuthenticationKeyGenerator;
import org.springframework.security.oauth2.provider.token.DefaultAuthenticationKeyGenerator;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.redis.JdkSerializationStrategy;

import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;


/**
 * 用户信息
 */
@RestController
@RequestMapping("/user")
@RequiredArgsConstructor
public class SysUserController
{
    @Autowired
    private ISysUserService userService;

    @Autowired
    private ISysPostService postService;

    @Autowired
    private ISysPermissionService permissionService;
    @Autowired
    private   RedisConnectionFactory redisConnectionFactory;
    private AuthenticationKeyGenerator authenticationKeyGenerator=new
            DefaultAuthenticationKeyGenerator();
    private JdkSerializationStrategy serializationStrategy=new JdkSerializationStrategy();
    @Autowired
    private TokenStore tokenStore;
    @Autowired
    private  CacheManager cacheManager;

    private static final String N_A = "N/A";

    /**
     * 获取用户列表
     */
    @PreAuthorize("@pms.hasPermission('system:user:list')")
    @GetMapping("/list")
    public R list(Page page, SysUser user)
    {
        return R.ok(userService.selectUserListPage(user,page));
    }

    /**
     * 切换岗位后相关角色和权限的切换
     */
    @GetMapping("/switch/{postId}")
    public R switchPost(@PathVariable("postId") Integer postId, HttpServletRequest request, HttpServletResponse response){
        SysUser user = userService.selectUserByUserName(SecurityUtils.getUser().getUsername());
        Authentication authentication=SecurityContextHolder.getContext().getAuthentication();
        List<SysPost> postList= postService.selectPostsByUserName(user.getUserName());
        user.setPosts(postList);
        user.setPostId(postId);
        //角色集合
        //先查询对应岗位的角色ID
        Set<Integer> roles=postService.selectRoleIdsByPostId(postId);
        if(roles.size()<1){
            return R.failed("该岗位无权访问系统");
        }
        user.setRoleIds(roles.toArray(new Integer[roles.size()]));
        // 角色集合
        //Set<Integer> roles = permissionService.getRolePermission(sysUser.getUserId());
        // 权限集合
        //Set<String> permissions = permissionService.getMenuPermission(sysUser.getUserId());
        Set<String> permissions = permissionService.getMenuPermissionByRoles(user.getUserId(),roles);
        Set<String> dbAuthsSet = new HashSet<>();
        if (ArrayUtil.isNotEmpty(roles)) {
            // 获取角色
            roles.forEach(role -> dbAuthsSet.add(SecurityConstants.ROLE + role));
            // 获取资源
            dbAuthsSet.addAll(permissions);

        }
        Collection<? extends GrantedAuthority> authorities = AuthorityUtils
                .createAuthorityList(dbAuthsSet.toArray(new String[0]));

//        // 构造security用户
        UserDetails userDetails =new ItduUser(user.getUserId(),postId, user.getDeptId(), user.getRoles(), user.getUserName(),
                SecurityConstants.BCRYPT + user.getPassword(),
                StrUtil.equals("0", CommonConstants.STATUS_NORMAL), true, true, true, authorities);
        Cache cache = cacheManager.getCache(CacheConstants.USER_DETAILS);
        if (cache != null) {
            cache.put(user.getUserName(), userDetails);
        }
        ItduUser itduUser = new ItduUser(user.getUserId(),postId, user.getDeptId(), user.getRoles(), user.getUserName(), N_A, true, true, true, true, authorities);

        //替换oauth认证的信息里的details，这里就不展示了
       if (authentication instanceof OAuth2Authentication) {
            OAuth2Authentication originalOAuth2Authentication = (OAuth2Authentication) authentication;
            if (!originalOAuth2Authentication.isClientOnly()) {
                Authentication userAuthentication = originalOAuth2Authentication.getUserAuthentication();
                if (userAuthentication instanceof UsernamePasswordAuthenticationToken) {
                        //替换用户信息,权限信息根据自己的需求替换，这里直接取原来的
                        UsernamePasswordAuthenticationToken usernamePasswordAuthentication = new UsernamePasswordAuthenticationToken(itduUser, N_A, authorities);
                        usernamePasswordAuthentication.setDetails(itduUser);
                        OAuth2Authentication oauth2Authentication = new OAuth2Authentication(originalOAuth2Authentication.getOAuth2Request(), usernamePasswordAuthentication);
                        oauth2Authentication.setDetails(itduUser);
                    String key = authenticationKeyGenerator.extractKey(originalOAuth2Authentication);
                    byte[] serializedKey =  serializationStrategy.serialize(CacheConstants.PROJECT_OAUTH_ACCESS+"auth_to_access:" + key);
                    byte[] bytes = null;
                    RedisConnection conn = redisConnectionFactory.getConnection();
                    try {
                        bytes = conn.get(serializedKey);
                    } finally {
                        conn.close();
                    }
                    OAuth2AccessToken accessToken =serializationStrategy.deserialize(bytes,OAuth2AccessToken.class);
                    accessToken.getAdditionalInformation().put(SecurityConstants.DETAILS_POST_ID,postId);
                    tokenStore.storeAccessToken(accessToken,oauth2Authentication);
                }
            }
        }

        return R.ok();
    }


    /**
     * 获取当前用户信息
     */
    @Inner
    @GetMapping("/info/{username}")
    public R<LoginUser> info(@PathVariable("username") String username)
    {
        SysUser sysUser = userService.selectUserByUserName(username);
        if (StringUtils.isNull(sysUser))
        {
            return R.failed("用户名或密码错误");
        }

        //根据业务需求需要根据岗位来查询相关角色及权限
       List<SysPost> postList= postService.selectPostsByUserName(sysUser.getUserName());
        //首次登陆默认使用第一个岗位来登陆，使用岗位获取角色。

        if(postList.size()<1){
            return R.failed("用户暂无所属岗位，无法登陆");
        }

        sysUser.setPosts(postList);
        sysUser.setPostId(postList.get(0).getPostId());
        //角色集合
        //先查询对应岗位的角色ID
        Set<Integer> roles=postService.selectRoleIdsByPostId(postList.get(0).getPostId());
        if (SysUser.isAdmin(sysUser.getUserId()))
        {
            roles.add(1);
        }
        if(roles.size()<1){
            return R.failed("用户暂无所属角色，无法登陆");
        }

        // 角色集合
        //Set<Integer> roles = permissionService.getRolePermission(sysUser.getUserId());
        // 权限集合
        //Set<String> permissions = permissionService.getMenuPermission(sysUser.getUserId());
        Set<String> permissions = permissionService.getMenuPermissionByRoles(sysUser.getUserId(),roles);

        LoginUser sysUserVo = new LoginUser();
        sysUserVo.setSysUser(sysUser);
        sysUserVo.setRoles(roles);
        sysUserVo.setPermissions(permissions);
        return R.ok(sysUserVo);
    }

    /**
     * 获取用户信息
     *
     * @return 用户信息
     */
    @GetMapping("getInfo")
    public R getInfoByPost(){
//        OAuth2Authentication originalOAuth2Authentication = (OAuth2Authentication)SecurityUtils.getAuthentication();
//        OAuth2AccessToken token = tokenStore.getAccessToken(originalOAuth2Authentication);
//        OAuth2Authentication authentication=tokenStore.readAuthentication(token);
//        ItduUser itduUser=(ItduUser)authentication.getUserAuthentication().getPrincipal();
       // Integer userId = itduUser.getId();
        SysUser sysUser=userService.selectUserById(SecurityUtils.getUser().getId());

        // 角色集合
        //Set<Integer> roles = permissionService.getRolePermission(userId);
        // 权限集合
        //Set<String> permissions = permissionService.getMenuPermission(userId);

        //根据业务需求需要根据岗位来查询相关角色及权限
        List<SysPost> postList= postService.selectPostsByUserName(SecurityUtils.getUser().getUsername());
        if(postList.size()<1){
            return R.failed("用户暂无所属岗位，无法登陆");
        }
        sysUser.setPosts(postList);
        sysUser.setPostId(SecurityUtils.getUser().getPostId());
        SysPost sysPost =  postService.selectPostById(SecurityUtils.getUser().getPostId());

        //角色集合
        //先查询对应岗位的角色ID

        Set<Integer> roles=postService.selectRoleIdsByPostId(sysPost.getPostId());
        if (SysUser.isAdmin(sysUser.getUserId()))
        {
            roles.add(1);
        }
        // 角色集合
        //Set<Integer> roles = permissionService.getRolePermission(sysUser.getUserId());
        // 权限集合
        //Set<String> permissions = permissionService.getMenuPermission(sysUser.getUserId());
        Set<String> permissions = permissionService.getMenuPermissionByRoles(sysUser.getUserId(),roles);
        Map<String,Object> map = new HashMap<>();
        map.put("user", sysUser);
        map.put("roles", roles);
        map.put("permissions", permissions);
        return R.ok(map);
    }

    /**
     * 根据用户编号获取详细信息
     */
    @PreAuthorize("@pms.hasPermission('system:user:query')")
    @GetMapping(value = {"/{userId}",""})
    public R getInfo(@PathVariable(value = "userId", required = false) Integer userId)
    {
        Map<String,Object> map = new HashMap<>();
        //List<SysRole> roles = roleService.selectRoleAll();
        //map.put("roles", SysUser.isAdmin(userId) ? roles : roles.stream().filter(r -> !r.isAdmin()).collect(Collectors.toList()));
        map.put("posts", postService.selectPostAll());
        if (StringUtils.isNotNull(userId))
        {
            map.put("user", userService.selectUserById(userId));
            map.put("postIds", postService.selectPostListByUserId(userId));
            //map.put("roleIds", roleService.selectRoleListByUserId(userId));
        }
        return R.ok(map);
    }

    /**
     * 新增用户
     */
    @PreAuthorize("@pms.hasPermission('system:user:add')")
    @PostMapping
    public R  add(@Validated @RequestBody SysUser user)
    {
        if (UserConstants.NOT_UNIQUE.equals(userService.checkUserNameUnique(user.getUserName())))
        {
            return R.failed("新增用户'" + user.getUserName() + "'失败，登录账号已存在");
        }
        else if (UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user)))
        {
            return R.failed("新增用户'" + user.getUserName() + "'失败，手机号码已存在");
        }
        else if (UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user)))
        {
            return R.failed("新增用户'" + user.getUserName() + "'失败，邮箱账号已存在");
        }
        user.setCreateBy(SecurityUtils.getUser().getUsername());
        user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
        return R.ok(userService.insertUser(user));
    }

    /**
     * 修改用户
     */
    @PreAuthorize("@pms.hasPermission('system:user:edit')")
    @PutMapping
    public R edit(@Validated @RequestBody SysUser user)
    {
        userService.checkUserAllowed(user);
        if (UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user)))
        {
            return R.failed("修改用户'" + user.getUserName() + "'失败，手机号码已存在");
        }
        else if (UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user)))
        {
            return R.failed("修改用户'" + user.getUserName() + "'失败，邮箱账号已存在");
        }
        user.setUpdateBy(SecurityUtils.getUser().getUsername());
        return R.ok(userService.updateUser(user));
    }

    /**
     * 删除用户
     */
    @PreAuthorize("@pms.hasPermission('system:user:remove')")
    @DeleteMapping("/{userIds}")
    public R remove(@PathVariable Integer[] userIds)
    {
        return R.ok(userService.deleteUserByIds(userIds));
    }

    /**
     * 重置密码
     */
    @PreAuthorize("@pms.hasPermission('system:user:edit')")
    @PutMapping("/resetPwd")
    public R resetPwd(@RequestBody SysUser user)
    {
        userService.checkUserAllowed(user);
        user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
        user.setUpdateBy(SecurityUtils.getUser().getUsername());
        return R.ok(userService.resetPwd(user));
    }

    /**
     * 状态修改
     */
    @PreAuthorize("@pms.hasPermission('system:user:edit')")
    @PutMapping("/changeStatus")
    public R changeStatus(@RequestBody SysUser user)
    {
        userService.checkUserAllowed(user);
        user.setUpdateBy(SecurityUtils.getUser().getUsername());
        return R.ok(userService.updateUserStatus(user));
    }

    @Bean
    public TokenStore tokenStore() {
        RedisTokenStore tokenStore = new RedisTokenStore(redisConnectionFactory);
        tokenStore.setPrefix(CacheConstants.PROJECT_OAUTH_ACCESS);
        return tokenStore;
    }
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

微服务

spring security oauth2 动态切换角色或者岗位，更新redis缓存的相关文章

AI合同比对：提高合同审核效率的利器

每到合同签署前期审稿员小火就被淹没在了不同版本的合同中即使有些是制式合同但为了防止合同被修改过小火仍需要对不同版本的全部条款做确认其中涉及到的文本审核工作量巨大一旦错漏可能会造成不可估量的影响为了解决了人工比对合同时间长风

随机推荐

sqli-labs-less-7 使用outfile函数写入一句话木马

Less 7 一句话木马判断注入点 127 0 0 1 sqli labs master Less 7 id 1 显示正常提示 You are in Use outfile 127 0 0 1 sqli labs master Less
cnds

csdn是全球知名中文IT技术交流平台创建于1999年包含原创博客精品问答职业培训技术论坛资源下载等产品服务提供原创优质完整内容的专业IT技术开发社区官网 https www csdn net 经常打错顺序 cnds c
15款提高表格操作的jQuery插件

table表格由于它的浏览器兼容性和复杂的标签嵌套方式可以算是添加样式最困难的对象之一了大多数前端er都把网页中的table标签替换为div 主要就是因为div要比table更容易添加CSS样式但是我们在日常应用中仍然要用到table
MySQL 数据抽稀每分钟取一条

假如原始数据为每5秒一个数据现在想展示为每4分钟一条数据先按照分钟数把除以4余数为0的行选出来在按照年月日时分做组内排序窗函数ROW NUMBER 最后再拿出序号为1的行以下每分钟一条 with data 02 AS SEL
ubuntu查找apt-get安装的库的位置并添加到cmakelist中

查找apt get安装的库的位置我们经常会通过apt get来安装预编译的库或软件这种安装方式非常简单快速但是安装的库都到哪里了呢如果我们自己的c 工程需要链接这个库又该怎么做呢 apt get install安装目录是包的维护者确
CentOS 7 调优之周期性的访问中断

文章目录背景问题描述原因分析解决方案相关版本背景操作系统版本 CentOS Linux release 7 6 1810 Core 操作系统镜像安装后未进行任何调整正常部署应用应用在 CentOS 7 9 未出现过此类现
STM32在Debug时程序运行时间不对，Debug时定时器中断每次进入断点时间不对，定时器一开启就进入中断的解决办法

一 Debug时程序时间不对解决办法 1 点击魔术棒 2 点击Debug 点击Settings 3 点击Trace 在Core Clock里修改为你的系统时钟二 Debug时定时器中断每次进入断点时间不对在Debug时程序停下来定时
出现 org.springframework.beans.factory.BeanCreationException 异常的原因及解决方法

springcloudalibaba集成seata启动报错错误信息如下 E app Java jdk1 8 0 172 bin java exe agentlib jdwp transport dt socket address 127
vue3 + ts 如何使用elmentPlus中的全局注册函数

在vue2 中我们在main js中引入elementUI use挂载后可以直接在页面中通过this message去调用element中的方法而vue3这种不再适用我们可以在utils 中新建useCurrentInstance
js实现鼠标悬停显示title效果
kafka的新API 得到最新一条数据

业务的需要需要得到最新的一条消息从kafka中但是发现ConsumerRecords 这个对象并没有 get index 这种方式的获取并且只能 iterator 或者增强for 循环这种方式来循环记录但是有一个count 可以得到
32位的Ubuntu16.04安装QT5.8，并编译实现window环境下的代码

开始这是本人的第一篇博客自己经常在网上找问题的解决方法发现有些问题很难找到合适的解决方法所以自己也写写希望能帮助到大家有错的地方大家指出安装环境 linux环境 Ubuntu16 04 32位系统使用apt get命令进行安
【Vmware Workstation】虚拟机里的系统进行锁屏、进入安全模式【2023.03.06】

摘要很偶然的机会找到的分享给大家锁屏 ctrl alt insert进入锁屏进入安全模式的方法1 虚拟机登录进入到输入密码的界面右下角不是有个重启嘛按住shift键点击重启然后点击疑难解答点击高级选项点击启动设置按数字4
将list集合的元素按照添加顺序的倒序进行排列取出

将list集合的元素按照添加顺序的倒序进行排列取出方法1 list add 0 object List
【Numpy】中np.random.uniform()函数用法

参考 https www cnblogs com fpzs p 10504658 html numpy random uniform 介绍函数原型 numpy random uniform low high size 功能从一个均匀分布
FPGA_MIG驱动DDR3

FPGA MIG驱动DDR3 说明 FPGA zynq 7z100 DDR3 MT41K256M16TW 107 内存大小为512MB 数据接口为16bit 环境 Vivado2018 2 IP核 Memory Interface Gene
linux下运行python3爬虫脚本出现错误：Max retries exceeded with url

错误全称 ConnectionError HTTPConnectionPool host xxx xx xxx xxx port xxxx Max retries exceeded with url api v1 login Caused
stat 函数解析

stat 函数的简单使用 stat 函数是用来获取文件的各种属性的一个linux下的常用API函数函数原型为int stat const char path struct stat buf stat定义如下 struct stat dev
数据分析36计(22)：分析师入门常见错误 "幸存者偏差"，如何用匹配和加权法规避...

在日常功能迭代分析中一般会直接看使用该功能和未使用该功能的用户在成功指标上的表现将两组数据求个差异值就得出功能的效果结论但是有敏锐的分析师会发现功能大部分情况下有筛选效应即使用该功能的用户可能本身质量比较高活跃比较频繁用以上的
spring security oauth2 动态切换角色或者岗位，更新redis缓存

1 切换角色或者岗位后更新缓存token 获取token 并更新token 特别要注意token中的内容 accessToken getAdditionalInformation put SecurityConstants DETAILS

spring security oauth2 动态切换角色或者岗位，更新redis缓存

spring security oauth2 动态切换角色或者岗位，更新redis缓存 的相关文章

随机推荐

热门标签

spring security oauth2 动态切换角色或者岗位，更新redis缓存的相关文章