学习风`宇博客用户权限菜单模块

news/2024/4/24 21:07:51/

文章目录

    • 用户-角色-菜单-资源 各表关系图
    • 菜单 和 路由
      • 菜单表及分析
        • 分析
      • /api/admin/user/menus接口
        • MenuServiceImpl#listUserMenus
        • 接口返回示例及分析
      • 前端代码分析
        • menu.js
        • SideBar.vue
    • 接口权限控制
      • 资源表 及 分析
        • 分析
      • WebSecurityConfig
        • 权限控制整体流程
          • 先说登录
            • UserDetailsServiceImpl
          • 再看权限控制
            • 自定义FilterInvocationSecurityMetadataSourceImpl
            • 自定义AccessDecisionManagerImpl
          • 会话管理
            • 限制单个用户登录人数(挤掉登录 或 阻止登录)
            • 踢人下线
            • 注册会话
            • 会话监听

用户-角色-菜单-资源 各表关系图

在这里插入图片描述

菜单 和 路由

菜单表及分析

在这里插入图片描述

分析

要形成右边这种菜单,需要2部分来做支撑。

  • 第一部分:需要构建出菜单之间的父子级关系出来。
    • 在上表中,通过id与parent_id,就可以构建出来,但是应当注意到:它这种似乎没有做超过2级的菜单。它的这种,第一级要么是菜单,要么是目录,第二级只能是菜单,不能是目录。也就是说,目录下面不能是目录,只能是菜单(目前的前端vue项目里面没有对菜单做递归)。
  • 第二部分:需要嵌套路由支持。
    • 也就是要做到后台管理系统的这种布局,在切换菜单的时候,右侧主区域切换到不同的组件需要嵌套路由作支撑。
    • 在考虑动态路由的时候,就不要考虑父子级之间的关系,只需要知道:要展示到主区域的组件在vue项目里面的路径(vue组件所在项目路径-表中的component字段),以及该路由组件的路径(vue组件对应的路由路径-表中的path字段)

/api/admin/user/menus接口

MenuServiceImpl#listUserMenus

@Override
public List<UserMenuDTO> listUserMenus() {// 查询用户菜单信息//(仅通过tb_user_role、tb_role_menu、tb_menu连表查询 用户拥有的角色 有哪些菜单)List<Menu> menuList = menuDao.listMenusByUserInfoId(UserUtils.getLoginUser().getUserInfoId());// 获取目录列表//(仅返回上一步查询到的菜单中parent_id为null的菜单)List<Menu> catalogList = listCatalog(menuList);// 获取目录下的子菜单//(将相同parent_id的菜单进行分组,以parent_id作为key,放入map中,//  从这里就看出来了,它不支持多级菜单了)Map<Integer, List<Menu>> childrenMap = getMenuMap(menuList);// 转换前端菜单格式return convertUserMenuList(catalogList, childrenMap);
}private List<UserMenuDTO> convertUserMenuList(List<Menu> catalogList, Map<Integer, List<Menu>> childrenMap) {// 遍历每个parent_id为null的菜单,// 		- 如果通过上面构建的map中,能找到它的子菜单,//		  那么就把它当作多级菜单处理(认为是目录),//	      将它的子菜单排序,并添加到children属性中;//      - 如果没有找到,就作为菜单处理(认为是菜单),创建一个UserMenuDTO,并设置component为Layout,path为菜单的path//		  将此菜单(path会被置为空字符串,这个设置空字符串是有意义的),添加到刚刚创建的UserMenuDTO的children中,//        也就是说,如果一级是菜单,会把它包到里面去;// 整个过程,没有使用递归 或者 通过构建map的方式 构建多级菜单,但是如果是一级菜单,它是会把它包一层的return catalogList.stream().map(item -> {// 获取目录UserMenuDTO userMenuDTO = new UserMenuDTO();List<UserMenuDTO> list = new ArrayList<>();// 获取目录下的子菜单List<Menu> children = childrenMap.get(item.getId());if (CollectionUtils.isNotEmpty(children)) {// 多级菜单处理userMenuDTO = BeanCopyUtils.copyObject(item, UserMenuDTO.class);list = children.stream().sorted(Comparator.comparing(Menu::getOrderNum)).map(menu -> {UserMenuDTO dto = BeanCopyUtils.copyObject(menu, UserMenuDTO.class);dto.setHidden(menu.getIsHidden().equals(TRUE));return dto;}).collect(Collectors.toList());} else {// 一级菜单处理userMenuDTO.setPath(item.getPath());userMenuDTO.setComponent(COMPONENT); // "Layouot"list.add(UserMenuDTO.builder().path("").name(item.getName()).icon(item.getIcon()).component(item.getComponent()).build());}userMenuDTO.setHidden(item.getIsHidden().equals(TRUE));userMenuDTO.setChildren(list);return userMenuDTO;}).collect(Collectors.toList());
}

接口返回示例及分析

  • 观察下面的 首页 和 个人中心 的确是被包了一层,
  • 刚刚提到 前端需要 侧边栏菜单 和 添加动态路由,那么这里只提供一个接口的话,并且里面没有分 菜单路由,那么前端势必就要自己组装 出合适的数据格式了。
    • 大致猜想下,这2部分内容该如何组装出来?
      • 路由:首先分析路由,这个比较简单,从下面的数据返回就可以看出来,它实际上已经大致和vue-router所需要的路由类似了,只需要把component的部分,通过异步组件加载方式,把它导入进去就可以了。比如:下面的首页,当匹配到/,就会默认展示Layout,然后由于里面有一个path为空字符串的子路由,vue-router会把这个子路由渲染到Layout的路由出口的地方。里面还有个小问题,比如说下面的文章管理,它的path是/article-submenu,那我直接在地址上输入这个路径的话,它是会渲染一个Layout组件,然后路由出口是空的,也就是主区域是空白的,此时也可以给文章管理加一个path为空字符串的子路由,让它显示一个默认的页面,当然这个目录是点击不了的,只是为了防止用户输入这个路劲而已。此处可以参考:vue3后台管理系统、vue2异步组件
      • 菜单: 侧边栏第一层级的菜单有可能是菜单,也有可能是目录,目录是不能点击的,只能作展开/收缩。那如何区分它们呢?因为使用element-ui组件去渲染左侧菜单,那么就必须知道,当前这个菜单有没有子菜单,如果有子菜单,用的是el-sub-menu,如果直接是一个菜单的话,那就是el-menu-item(此处可参考:vue3后台管理系统 的 使用el-menu创建侧边栏菜单 部分),可以通过name来进行判断,因为通过包了一层的方式生成的最外面的那层菜单的name是没有赋值的,因此,它肯定为null,也就是说,碰到为null的name的一级菜单,直接拿这个菜单下面的一个子菜单(这种只会存在一个子菜单),比如首页、个人中心就是这样的。还有的就是有name的菜单就通过el-sub-menu把它渲染出来,这样,他就是一个目录了。
{"flag":true,"code":20000,"message":"操作成功","data":[{"name":null,"path":"/","component":"Layout","icon":null,"hidden":false,"children":[{"name":"首页","path":"","component":"/home/Home.vue","icon":"el-icon-myshouye","hidden":null,"children":null}]},{"name":"文章管理","path":"/article-submenu","component":"Layout","icon":"el-icon-mywenzhang-copy","hidden":false,"children":[{"name":"发布文章","path":"/articles","component":"/article/Article.vue","icon":"el-icon-myfabiaowenzhang","hidden":false,"children":null},{"name":"修改文章","path":"/articles/*","component":"/article/Article.vue","icon":"el-icon-myfabiaowenzhang","hidden":true,"children":null},{"name":"文章列表","path":"/article-list","component":"/article/ArticleList.vue","icon":"el-icon-mywenzhangliebiao","hidden":false,"children":null},{"name":"分类管理","path":"/categories","component":"/category/Category.vue","icon":"el-icon-myfenlei","hidden":false,"children":null},{"name":"标签管理","path":"/tags","component":"/tag/Tag.vue","icon":"el-icon-myicontag","hidden":false,"children":null}]},{"name":"消息管理","path":"/message-submenu","component":"Layout","icon":"el-icon-myxiaoxi","hidden":false,"children":[{"name":"评论管理","path":"/comments","component":"/comment/Comment.vue","icon":"el-icon-mypinglunzu","hidden":false,"children":null},{"name":"留言管理","path":"/messages","component":"/message/Message.vue","icon":"el-icon-myliuyan","hidden":false,"children":null}]},{"name":"用户管理","path":"/users-submenu","component":"Layout","icon":"el-icon-myyonghuliebiao","hidden":false,"children":[{"name":"用户列表","path":"/users","component":"/user/User.vue","icon":"el-icon-myyonghuliebiao","hidden":false,"children":null},{"name":"在线用户","path":"/online/users","component":"/user/Online.vue","icon":"el-icon-myyonghuliebiao","hidden":false,"children":null}]},{"name":"权限管理","path":"/permission-submenu","component":"Layout","icon":"el-icon-mydaohanglantubiao_quanxianguanli","hidden":false,"children":[{"name":"角色管理","path":"/roles","component":"/role/Role.vue","icon":"el-icon-myjiaoseliebiao","hidden":false,"children":null},{"name":"接口管理","path":"/resources","component":"/resource/Resource.vue","icon":"el-icon-myjiekouguanli","hidden":false,"children":null},{"name":"菜单管理","path":"/menus","component":"/menu/Menu.vue","icon":"el-icon-mycaidan","hidden":false,"children":null}]},{"name":"系统管理","path":"/system-submenu","component":"Layout","icon":"el-icon-myshezhi","hidden":false,"children":[{"name":"网站管理","path":"/website","component":"/website/Website.vue","icon":"el-icon-myxitong","hidden":false,"children":null},{"name":"页面管理","path":"/pages","component":"/page/Page.vue","icon":"el-icon-myyemianpeizhi","hidden":false,"children":null},{"name":"友链管理","path":"/links","component":"/friendLink/FriendLink.vue","icon":"el-icon-mydashujukeshihuaico-","hidden":false,"children":null},{"name":"关于我","path":"/about","component":"/about/About.vue","icon":"el-icon-myguanyuwo","hidden":false,"children":null}]},{"name":"相册管理","path":"/album-submenu","component":"Layout","icon":"el-icon-myimage-fill","hidden":false,"children":[{"name":"相册列表","path":"/albums","component":"/album/Album.vue","icon":"el-icon-myzhaopian","hidden":false,"children":null},{"name":"照片管理","path":"/albums/:albumId","component":"/album/Photo.vue","icon":"el-icon-myzhaopian","hidden":true,"children":null},{"name":"照片回收站","path":"/photos/delete","component":"/album/Delete.vue","icon":"el-icon-myhuishouzhan","hidden":true,"children":null}]},{"name":"说说管理","path":"/talk-submenu","component":"Layout","icon":"el-icon-mypinglun","hidden":false,"children":[{"name":"发布说说","path":"/talks","component":"/talk/Talk.vue","icon":"el-icon-myfabusekuai","hidden":false,"children":null},{"name":"说说列表","path":"/talk-list","component":"/talk/TalkList.vue","icon":"el-icon-myiconfontdongtaidianji","hidden":false,"children":null},{"name":"修改说说","path":"/talks/:talkId","component":"/talk/Talk.vue","icon":"el-icon-myshouye","hidden":true,"children":null}]},{"name":"日志管理","path":"/log-submenu","component":"Layout","icon":"el-icon-myguanyuwo","hidden":false,"children":[{"name":"操作日志","path":"/operation/log","component":"/log/Operation.vue","icon":"el-icon-myguanyuwo","hidden":false,"children":null}]},{"name":null,"path":"/setting","component":"Layout","icon":null,"hidden":false,"children":[{"name":"个人中心","path":"","component":"/setting/Setting.vue","icon":"el-icon-myuser","hidden":null,"children":null}]}]
}

前端代码分析

menu.js

  • 下面的代码只遍历了2层,只处理了图标 和 路由的组件异步加载,和 Layout的字符串转为实际的Layout组件,这些都是vue-router的要求。
  • 路由 和 菜单 用的 是同一份数据。此处可与vue3后台管理系统 # 调整路由处作对比学习,感觉的确他的更加灵活一点,他的可以不同path的路径都可以用Layout作为App.vue的路由出口展示的组件。我的是直接就当作Layout的子路由了,但更加简单,但有一点必须作为前提,那就是一点要跟着vue-router的用法走,这个是大前提,所以做的时候,肯定需要先把静态路由搭建出来,确认没问题之后,再搞动态路由。
import Layout from "@/layout/index.vue";
import router from "../../router";
import store from "../../store";
import axios from "axios";
import Vue from "vue";export function generaMenu() {// 查询用户菜单axios.get("/api/admin/user/menus").then(({ data }) => {if (data.flag) {var userMenuList = data.data;userMenuList.forEach(item => {if (item.icon != null) {item.icon = "iconfont " + item.icon;}if (item.component == "Layout") {item.component = Layout;}if (item.children && item.children.length > 0) {item.children.forEach(route => {route.icon = "iconfont " + route.icon;route.component = loadView(route.component);});}});// 添加侧边栏菜单store.commit("saveUserMenuList", userMenuList);// 添加菜单到路由router.addRoutes(userMenuList);} else {Vue.prototype.$message.error(data.message);router.push({ path: "/login" });}});
}export const loadView = view => {// 路由懒加载return resolve => require([`@/views${view}`], resolve);
};

SideBar.vue

  • 此处可对照 vue3后台管理系统 # 使用el-menu创建侧边栏菜单
  • 下面只做了2级遍历。多级菜单实现可参考: vue3后台管理系统 # 创建TreeMenu.vue递归组件
<template><div><el-menuclass="side-nav-bar"router:collapse="this.$store.state.collapse":default-active="this.$route.path"background-color="#304156"text-color="#BFCBD9"active-text-color="#409EFF"><template v-for="route of this.$store.state.userMenuList"><!-- 二级菜单 --><template v-if="route.name && route.children && !route.hidden"><el-submenu :key="route.path" :index="route.path"><!-- 二级菜单标题 --><template slot="title"><i :class="route.icon" /><span>{{ route.name }}</span></template><!-- 二级菜单选项 --><template v-for="(item, index) of route.children"><el-menu-item v-if="!item.hidden" :key="index" :index="item.path"><i :class="item.icon" /><span slot="title">{{ item.name }}</span></el-menu-item></template></el-submenu></template><!-- 一级菜单 --><template v-else-if="!route.hidden"><el-menu-item :index="route.path" :key="route.path"><i :class="route.children[0].icon" /><span slot="title">{{ route.children[0].name }}</span></el-menu-item></template></template></el-menu></div>
</template>

接口权限控制

资源表 及 分析

在这里插入图片描述

分析

  • 将系统中的每一controller里面的接口,当作一个资源,接口名称就是资源名称、接口访问路径就是资源url。每一个controller类也是一个资源,它用来管理内部的接口(作为它们的父资源,父资源的parent_id为null),也就是说里面只会存在2级关系。
  • 使用角色 去 关联 资源,用户 去 关联 角色,因此,就可以确定一个用户拥有哪些资源。一个角色如果关联了某个controller下面的某个或者某几个资源,那么它一定关联了这个controller资源(也就是子关联了,那么父也一定要关联)。那个菜单也应如此,但是我发现,角色分配菜单那里,选择了子菜单,却没有自动勾选对应的父级菜单,连父级菜单都没的话,返回的就是空菜单。资源那里是正常的。
  • 当确定某个用户具有哪些角色,就可以确定这个用户拥有了哪些资源,其实,就是拥有了哪些接口的访问权限,接口的访问权限是通过security这个权限框架控制的,并且博客中是做到了动态权限控制,即新增或者修改资源、更新角色 与 资源的关系时,项目不需要重启,用户也不需要退出再登录,即可按修改后的接口访问权限实时的生效,但是用户登录后,再修改这个用户的角色,这个是不能实时生效的,需要退出退出再登录。

WebSecurityConfig

package com.minzheng.blog.config;import com.minzheng.blog.handler.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.config.annotation.ObjectPostProcessor;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.session.SessionRegistry;
import org.springframework.security.core.session.SessionRegistryImpl;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
import org.springframework.security.web.access.intercept.FilterSecurityInterceptor;
import org.springframework.security.web.session.HttpSessionEventPublisher;/*** Security配置类** @author yezhiqiu* @date 2021/07/29*/
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {@Autowiredprivate AuthenticationEntryPointImpl authenticationEntryPoint;@Autowiredprivate AccessDeniedHandlerImpl accessDeniedHandler;@Autowiredprivate AuthenticationSuccessHandlerImpl authenticationSuccessHandler;@Autowiredprivate AuthenticationFailHandlerImpl authenticationFailHandler;@Autowiredprivate LogoutSuccessHandlerImpl logoutSuccessHandler;@Beanpublic FilterInvocationSecurityMetadataSource securityMetadataSource() {return new FilterInvocationSecurityMetadataSourceImpl();}@Beanpublic AccessDecisionManager accessDecisionManager() {return new AccessDecisionManagerImpl();}@Beanpublic SessionRegistry sessionRegistry() {return new SessionRegistryImpl();}@Beanpublic HttpSessionEventPublisher httpSessionEventPublisher() {return new HttpSessionEventPublisher();}/*** 密码加密** @return {@link PasswordEncoder} 加密方式*/@Beanpublic PasswordEncoder passwordEncoder() {return new BCryptPasswordEncoder();}/*** 配置权限** @param http http* @throws Exception 异常*/@Overrideprotected void configure(HttpSecurity http) throws Exception {// 配置登录注销路径http.formLogin().loginProcessingUrl("/login").successHandler(authenticationSuccessHandler).failureHandler(authenticationFailHandler).and().logout().logoutUrl("/logout").logoutSuccessHandler(logoutSuccessHandler);// 配置路由权限信息http.authorizeRequests().withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {@Overridepublic <O extends FilterSecurityInterceptor> O postProcess(O fsi) {fsi.setSecurityMetadataSource(securityMetadataSource());fsi.setAccessDecisionManager(accessDecisionManager());return fsi;}}).anyRequest().permitAll().and()// 关闭跨站请求防护.csrf().disable().exceptionHandling()// 未登录处理.authenticationEntryPoint(authenticationEntryPoint)// 权限不足处理.accessDeniedHandler(accessDeniedHandler).and().sessionManagement().maximumSessions(20).sessionRegistry(sessionRegistry());}}

权限控制整体流程

先说登录
  • 用户登录是通过Security配置的formLogin()配置的UsernamePasswordAuthenticationFilter这个过滤器来登录的,这个过滤器会提取登录请求中的"username","password"请求参数,交给认证管理器作认证,而认证管理器是security默认配置的,(具体可以看AbstractAuthenticationFilterConfigurer#configure(B http)这里是从sharedObject中拿到AuthenticationManager设置到UsernamePasswordAuthenticationFilter过滤器中)。而认证管理器是security它自己会默认创建一个,并且它默认会去寻找spring容器中定义的UserDetailsService这个类型的bean(具体见InitializeUserDetailsManagerConfigurer#configure(AuthenticationManagerBuilder auth)),里面的配置过程比较复杂(见Spring Security框架配置运行流程完整分析),
  • 需要花费不少的时间才能看明白配置过程,但只需要知道它默认会去寻找定义的UserDetailsService实现类bean,设置到AuthenticationManager认证管理中,而formLogin()配置的UsernamePasswordAuthenticationFilter正是需要认证管理器,因此实际的查询用户操作就交给了我们配置的UserDetailsService这个bean中。
  • 登录代码如下,实际上就是查询出了当前用户拥有的角色、当前用户点赞过哪些文章、评论、说说,以及ip地址和来源地和浏览器等
UserDetailsServiceImpl
@Service
public class UserDetailsServiceImpl implements UserDetailsService {@Autowiredprivate UserAuthDao userAuthDao;@Autowiredprivate UserInfoDao userInfoDao;@Autowiredprivate RoleDao roleDao;@Autowiredprivate RedisService redisService;@Resourceprivate HttpServletRequest request;@Overridepublic UserDetails loadUserByUsername(String username) {if (StringUtils.isBlank(username)) {throw new BizException("用户名不能为空!");}// 查询账号是否存在UserAuth userAuth = userAuthDao.selectOne(new LambdaQueryWrapper<UserAuth>().select(UserAuth::getId, UserAuth::getUserInfoId, UserAuth::getUsername, UserAuth::getPassword, UserAuth::getLoginType).eq(UserAuth::getUsername, username));if (Objects.isNull(userAuth)) {throw new BizException("用户名不存在!");}// 封装登录信息return convertUserDetail(userAuth, request);}/*** 封装用户登录信息** @param user    用户账号* @param request 请求* @return 用户登录信息*/public UserDetailDTO convertUserDetail(UserAuth user, HttpServletRequest request) {// 查询账号信息UserInfo userInfo = userInfoDao.selectById(user.getUserInfoId());// 查询账号角色List<String> roleList = roleDao.listRolesByUserInfoId(userInfo.getId());// 查询账号点赞信息Set<Object> articleLikeSet = redisService.sMembers(ARTICLE_USER_LIKE + userInfo.getId());Set<Object> commentLikeSet = redisService.sMembers(COMMENT_USER_LIKE + userInfo.getId());Set<Object> talkLikeSet = redisService.sMembers(TALK_USER_LIKE + userInfo.getId());// 获取设备信息String ipAddress = IpUtils.getIpAddress(request);String ipSource = IpUtils.getIpSource(ipAddress);UserAgent userAgent = IpUtils.getUserAgent(request);// 封装权限集合return UserDetailDTO.builder().id(user.getId()).loginType(user.getLoginType()).userInfoId(userInfo.getId()).username(user.getUsername()).password(user.getPassword()).email(userInfo.getEmail()).roleList(roleList).nickname(userInfo.getNickname()).avatar(userInfo.getAvatar()).intro(userInfo.getIntro()).webSite(userInfo.getWebSite()).articleLikeSet(articleLikeSet).commentLikeSet(commentLikeSet).talkLikeSet(talkLikeSet).ipAddress(ipAddress).ipSource(ipSource).isDisable(userInfo.getIsDisable()).browser(userAgent.getBrowser().getName()).os(userAgent.getOperatingSystem().getName()).lastLoginTime(LocalDateTime.now(ZoneId.of(SHANGHAI.getZone()))).build();}}
再看权限控制

看这一部分之前,需要先搞懂security他的工作原理,它是基于filter过滤器实现的,可以先看:Security源码学习笔记&OAuth2 # 第十节部分 关于FilterIntercetor的介绍。配置的起源在于使用http.authorizeRequests()修改了其中默认配置的组件,而替换成了博客中使用的组件。

自定义FilterInvocationSecurityMetadataSourceImpl

security会把当前访问的资源请求对象,封装为FilterInvocation,把它交给SecurityMetadataSource#getAttributes方法,以获得访问当前资源请求对象所需要的权限。

下面代码的过程就是在通过ant-style的路径匹配,根据配置的资源url,查询到访问当前的资源可以是哪些角色,也就是说,用户必须要有返回中的任一角色,才能访问FilterInvocation,否则不允许访问。

下面还有一个返回指定“disable”固定字符串的意思是没有任何角色能够访问这个资源,除非你有一个disable的角色,但这个角色显然不存在,也就是没人可以访问这个资源。

还有一点是:在查询之前给了一个钩子,如果resourceRoleList为null(也就是有地方修改了这个属性为null),那就重新加载这个resourceList。

package com.minzheng.blog.handler;import com.minzheng.blog.dao.RoleDao;
import com.minzheng.blog.dto.ResourceRoleDTO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.CollectionUtils;import javax.annotation.PostConstruct;
import java.util.Collection;
import java.util.List;/*** 接口拦截规则** @author yezhiqiu* @date 2021/07/27*/
@Component
public class FilterInvocationSecurityMetadataSourceImpl implements FilterInvocationSecurityMetadataSource {/*** 资源角色列表*/private static List<ResourceRoleDTO> resourceRoleList;@Autowiredprivate RoleDao roleDao;/*** 加载资源角色信息*/@PostConstructprivate void loadDataSource() {resourceRoleList = roleDao.listResourceRoles();}/*** 清空接口角色信息*/public void clearDataSource() {resourceRoleList = null;}@Overridepublic Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {// 修改接口角色关系后重新加载if (CollectionUtils.isEmpty(resourceRoleList)) {this.loadDataSource();}FilterInvocation fi = (FilterInvocation) object;// 获取用户请求方式String method = fi.getRequest().getMethod();// 获取用户请求UrlString url = fi.getRequest().getRequestURI();AntPathMatcher antPathMatcher = new AntPathMatcher();// 获取接口角色信息,若为匿名接口则放行,若无对应角色则禁止for (ResourceRoleDTO resourceRoleDTO : resourceRoleList) {if (antPathMatcher.match(resourceRoleDTO.getUrl(), url) && resourceRoleDTO.getRequestMethod().equals(method)) {List<String> roleList = resourceRoleDTO.getRoleList();if (CollectionUtils.isEmpty(roleList)) {return SecurityConfig.createList("disable");}return SecurityConfig.createList(roleList.toArray(new String[]{}));}}return null;}@Overridepublic Collection<ConfigAttribute> getAllConfigAttributes() {return null;}@Overridepublic boolean supports(Class<?> aClass) {return FilterInvocation.class.isAssignableFrom(aClass);}}
自定义AccessDecisionManagerImpl

在上一步,获取到了访问某一资源需要的权限后,接下来,按照security的尿性,它会交给访问决策管理器,然后决策管理器会交给投票器,然后再根据投票结果确定是否能访问当前资源。

但是博客中是直接查询到当前用户拥有的权限,然后看这些权限有没有符合要求的,一旦发现有符合要求的,直接返回,否则,抛出异常。这里所说的权限,是要看UserDetailDTO#getAuthorities(它实现了UserDetails接口),从该方法中可以看出,就是指的角色。

@Component
public class AccessDecisionManagerImpl implements AccessDecisionManager {@Overridepublic void decide(Authentication authentication, Object o, Collection<ConfigAttribute> collection) throws AccessDeniedException, InsufficientAuthenticationException {// 获取用户权限列表List<String> permissionList = authentication.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toList());for (ConfigAttribute item : collection) {if (permissionList.contains(item.getAttribute())) {return;}}throw new AccessDeniedException("没有操作权限");}@Overridepublic boolean supports(ConfigAttribute configAttribute) {return true;}@Overridepublic boolean supports(Class<?> aClass) {return true;}
}
会话管理

用户登录完成后,在后面的请求中如何标识到这个用户呢?以前的时候用的是cookie,前后端分离项目中一般用的是请求头,如Authorization。但是在博客中使用的是cookie做的会话管理,后面的请求都是通过cookie来标识用户的,也就是如果用户仅用了cookie,那就无法登录(可以登录成功,但是后面再发的请求就报用户未登录),也就是说只要删除某个cookie,那就把对应的用户给踢下线了。Security当用户登录完成后,会把用户认证的对象存入SecurityContext中,而SecurityContext会被存入HttpSession中,在security遇到一个请求时,第二个处理的过滤器就是:SecurityContextPersistenceFilter,它就是负责从会话(前端须传入cookie)中获取登陆时存入的SecurityContext,然后把它设置到当前线程上下文中。这也就是说,如果,我们需要改成请求头的方式,而不是用cookie,则需要自己实现这一段逻辑。

明白了上面的逻辑后,可以参考再参考下会话管理的源码:Springsecurity会话管理与配置

它也是通过过滤器来实现的,通过http.sessionManagement()添加的,

  • 一个SessionManagementFilter会话管理过滤器,它负责使用自己的securityContextRepository来对每个请求,验证是否有SecurityContext,如果有,直接放行;如果没有,则尝试获取绑定到当前线程的Authentcation,如果能获取到,则让会话认证策略处理,并存入自己的securityContextRepository。
  • 一个ConcurrentSessionFilter过滤器。其中:SessionManagementFilter
限制单个用户登录人数(挤掉登录 或 阻止登录)

这里似乎发现了原博客中的一点小问题,需要重写UserDetailDTO的hashcode和equals方法。不重写的话,达不到控制单个用户会话数量的效果。
在SessionManagementConfigurer#init(H http)中,会去获取会话认证策略,如果用户有设置maximumSessions这个属性,那么就会添加一个会话并发控制的会话策略到会话认证策略中,并且把它设置到sharedObject中。
而在formLogin()配置的AbstractAuthenticationFilterConfigurer在configure方法中,是有去从sharedObject拿会话认证策略的,显然,init方法执行的顺序在configure方法之前,所以,是能拿到的,所以,用户在UsernamePasswordAuthenticationFilter的父类AbstractAuthenticationProcessingFilter登录之后,就会来到ConcurrentSessionControlAuthenticationStrategy#onAuthentication方法里面,去判断数量是否超过允许的最大会话数量,如果超过,是否阻止当前登录或者移除最近未使用的会话,并让它们失效,注意,这个失效只是标记了SessionInformation的expired属性为true,真正的会话失效,在ConcurrentSessionFilter的doFilter方法中。

踢人下线

踢人下线的道理,跟上面是一样的,只要从sessionRegistry中找到对应的用户id的SessionInformation会话信息,标记它们失效,下次这些用户请求时,在ConcurrentSessionFilter的doFilter方法中会去检查它们,如果被标记为失效,那就走失效逻辑。

注册会话

上面提到了会话删除,那么会话是什么时候注册进去的呢?同样是在SessionManagementConfigurer#init(H http)中获取会话认证策略时,除了会添加那个ConcurrentSessionControlAuthenticationStrategy,也会添加RegisterSessionAuthenticationStrategy,那么在登录的时候在AbstractAuthenticationProcessingFilter就会来到RegisterSessionAuthenticationStrategy中去注册一个会话,然后放入sessionRegistry中,这样就起到了管理会话的作用

会话监听

当用户长时间无操作时,用户的这个会话应当要失效。web中的HttpSession会话,当长时间无访问时(默认30分钟),就会自己invalidate失效掉。那么security中既然用SessionRegistryImpl去维护HttpSession,那么它应当要监听会话销毁时间,因此,在博客中,注册了HttpSessionEventPublisher这个bean,它实现了HttpSessionListener接口来监听httpsession的各种事件,然后把事件通过spring容器发布出来。而SessionRegistry则应当要监听这些会话事件,可以看下SessionRegistryImpl的实现,它实现了ApplicationListener接口,监听的泛型事件类型为AbstractSessionEvent。这里面其实就是用到了spring的事件机制。

public class SessionRegistryImpl implements SessionRegistry, ApplicationListener<AbstractSessionEvent> {protected final Log logger = LogFactory.getLog(SessionRegistryImpl.class);// <principal:Object,SessionIdSet>private final ConcurrentMap<Object, Set<String>> principals;// <sessionId:Object,SessionInformation>private final Map<String, SessionInformation> sessionIds;public SessionRegistryImpl() {this.principals = new ConcurrentHashMap<>();this.sessionIds = new ConcurrentHashMap<>();}public SessionRegistryImpl(ConcurrentMap<Object, Set<String>> principals,Map<String, SessionInformation> sessionIds) {this.principals = principals;this.sessionIds = sessionIds;}@Overridepublic List<Object> getAllPrincipals() {return new ArrayList<>(this.principals.keySet());}@Overridepublic List<SessionInformation> getAllSessions(Object principal, boolean includeExpiredSessions) {Set<String> sessionsUsedByPrincipal = this.principals.get(principal);if (sessionsUsedByPrincipal == null) {return Collections.emptyList();}List<SessionInformation> list = new ArrayList<>(sessionsUsedByPrincipal.size());for (String sessionId : sessionsUsedByPrincipal) {SessionInformation sessionInformation = getSessionInformation(sessionId);if (sessionInformation == null) {continue;}if (includeExpiredSessions || !sessionInformation.isExpired()) {list.add(sessionInformation);}}return list;}@Overridepublic SessionInformation getSessionInformation(String sessionId) {Assert.hasText(sessionId, "SessionId required as per interface contract");return this.sessionIds.get(sessionId);}@Overridepublic void onApplicationEvent(AbstractSessionEvent event) {if (event instanceof SessionDestroyedEvent) {SessionDestroyedEvent sessionDestroyedEvent = (SessionDestroyedEvent) event;String sessionId = sessionDestroyedEvent.getId();removeSessionInformation(sessionId);}else if (event instanceof SessionIdChangedEvent) {SessionIdChangedEvent sessionIdChangedEvent = (SessionIdChangedEvent) event;String oldSessionId = sessionIdChangedEvent.getOldSessionId();if (this.sessionIds.containsKey(oldSessionId)) {Object principal = this.sessionIds.get(oldSessionId).getPrincipal();removeSessionInformation(oldSessionId);registerNewSession(sessionIdChangedEvent.getNewSessionId(), principal);}}}@Overridepublic void refreshLastRequest(String sessionId) {Assert.hasText(sessionId, "SessionId required as per interface contract");SessionInformation info = getSessionInformation(sessionId);if (info != null) {info.refreshLastRequest();}}@Overridepublic void registerNewSession(String sessionId, Object principal) {Assert.hasText(sessionId, "SessionId required as per interface contract");Assert.notNull(principal, "Principal required as per interface contract");if (getSessionInformation(sessionId) != null) {removeSessionInformation(sessionId);}if (this.logger.isDebugEnabled()) {this.logger.debug(LogMessage.format("Registering session %s, for principal %s", sessionId, principal));}this.sessionIds.put(sessionId, new SessionInformation(principal, sessionId, new Date()));this.principals.compute(principal, (key, sessionsUsedByPrincipal) -> {if (sessionsUsedByPrincipal == null) {sessionsUsedByPrincipal = new CopyOnWriteArraySet<>();}sessionsUsedByPrincipal.add(sessionId);this.logger.trace(LogMessage.format("Sessions used by '%s' : %s", principal, sessionsUsedByPrincipal));return sessionsUsedByPrincipal;});}@Overridepublic void removeSessionInformation(String sessionId) {Assert.hasText(sessionId, "SessionId required as per interface contract");SessionInformation info = getSessionInformation(sessionId);if (info == null) {return;}if (this.logger.isTraceEnabled()) {this.logger.debug("Removing session " + sessionId + " from set of registered sessions");}this.sessionIds.remove(sessionId);this.principals.computeIfPresent(info.getPrincipal(), (key, sessionsUsedByPrincipal) -> {this.logger.debug(LogMessage.format("Removing session %s from principal's set of registered sessions", sessionId));sessionsUsedByPrincipal.remove(sessionId);if (sessionsUsedByPrincipal.isEmpty()) {// No need to keep object in principals Map anymorethis.logger.debug(LogMessage.format("Removing principal %s from registry", info.getPrincipal()));sessionsUsedByPrincipal = null;}this.logger.trace(LogMessage.format("Sessions used by '%s' : %s", info.getPrincipal(), sessionsUsedByPrincipal));return sessionsUsedByPrincipal;});}}

http://www.ppmy.cn/news/48234.html

相关文章

MATLAB应用笔记

其他 1、NaN值 MATLAB判断数据是否为NaN可以直接使用函数&#xff1a;isnan() 三、数据分析 1、相关性 均值、方差、协方差、标准差、相关系数 mean() %均值 nanmean()%去除NAN值求均值 var() %方差 cov() %协方差 std() %标准差 corrcoef(B,b) %R 相关系数plot()…

node项目(一) koa脚手架的搭建

一、koa 安装 // 安装koa npm install -g koa-generator // 创建项目 koa2 项目名称 当出现这个框的时候安装完毕 之后就是进入目录文件&#xff0c;根据package.json执行即可 二、出现问题 汇总 问题一&#xff1a;koa-generator安装失败 没有出现koa-generator安装成功 …

【杂凑算法篇】密码杂凑算法的安全强度

【杂凑算法篇】密码杂凑算法的安全强度 杂凑&#xff08;哈希&#xff09;算法安全强度—【蘇小沐】 文章目录 【杂凑算法篇】密码杂凑算法的安全强度&#xff08;一&#xff09;安全强度&#xff08;Security Strength)&#xff08;二&#xff09;杂凑算法的安全强度与对比总…

2 常见模块库(2)

2.5 复用器与分路器模块 Mux是一种用于将多个信号组合成一个信号的模块。Mux模块的名称来源于多路复用器&#xff08;Multiplexer&#xff09;。 使用Mux可以将多个输入信号组合成一个向量或矩阵&#xff0c;以便在模型中传递和处理。Mux模块可以接受任意数量的输入信号&#x…

【Linux】动静态库

前言 在日后的项目中&#xff0c;我们会用到很多第三方库。人们常说&#xff0c;开发就是在用轮子&#xff0c;而这个轮子其实就是第三方库&#xff0c;但是我们作为学习阶段&#xff0c;我们还需要学会如何造轮子&#xff0c;这样才会对轮子更为了解&#xff0c;能更好的掌握&…

win10系统部署-zabbix客户端

一、下载win10系统 zabbix客户端 下载地址&#xff1a; 根据自己需求下载 https://www.zabbix.com/cn/download二、win系统安装客户端 1、解压安装包 c:\zabbix 2、编辑zabbix\conf\zabbix_agentd.conf文件 Server127.0.0.1,IP IP是你的zabbix服务器端地址 ServerActive127…

软件测试工程师的进阶之旅

很多人对测试工程师都有一些刻板印象&#xff0c;比如觉得测试“入门门槛低&#xff0c;没有技术含量”、“对公司不重要”、“操作简单工作枯燥”“一百个开发&#xff0c;一个测试”等等。 会产生这种负面评论&#xff0c;是因为很多人对测试的了解&#xff0c;还停留在几年…

linux下搭建Hbase分布式数据库

文章目录 Hbase概念1.安装Hbase1.jdk的配置2.安装hbase 2.启动和操作1.启动服务2 **web-ui访问地址:http://node01:16010/master-status** 3.简单的操作1.连接 HBase2.帮助命令3.创建一张表 create a table4.使用查看表是否存在5.describe 查看表描述6.put命令插入数据到表7. s…

Vue2-黑马(八)

目录&#xff1a; &#xff08;1&#xff09;router-动态路由 &#xff08;2&#xff09;router-重置路由 &#xff08;3&#xff09;router-页面刷新 &#xff08;1&#xff09;router-动态路由 我们有这样一个需求&#xff0c;不同的用户根据自己的身份不一样&#xff0c;…

我在“Now In Android”中学到的 9 件事

我在“Now In Android”中学到的 9 件事 Now in Android是一款功能齐全的 Android 应用程序&#xff0c;完全使用 Kotlin 和 Jetpack Compose 构建。它遵循 Android 设计和开发最佳实践&#xff0c;旨在为开发人员提供有用的参考。 https://github.com/android/nowinandroid UI…

故障分析 | 数据库服务器内存不足一例分析

作者&#xff1a;付祥 现居珠海&#xff0c;主要负责 Oracle、MySQL、mongoDB 和 Redis 维护工作。 本文来源&#xff1a;原创投稿 *爱可生开源社区出品&#xff0c;原创内容未经授权不得随意使用&#xff0c;转载请联系小编并注明来源。 现象 监控告警某台机器空闲内存低于10…

【每日一练】题目名称:划分窗口

题目描述 给定一个长度为 n 的数组 num 和滑动窗口的大小 size &#xff0c;找出所有滑动窗口里数值的最大值。例如&#xff0c;如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小 3&#xff0c;那么一共存在6 个滑动窗口&#xff0c;他们的最大值分别为{4,4,6,6,6,5}&#xff1b…

《C++高并发服务器笔记——第五章项目实战与总结》

代码地址 《C高并发服务器笔记——第五章》 5.1、阻塞/非阻塞、同步/异步&#xff08;网络IO&#xff09;1.阻塞/非阻塞、同步/异步(网络IO)①典型的一次IO的两个阶段是什么&#xff1f; 2.日志系统①基础知识②整体概述③本文内容④单例模式1.经典的线程安全懒汉模式2.局部静…

asp.net+sqlserver基于web的在校大学生贷款管理系统

采用的技术&#xff1a; 1.ASP.NET框架&#xff1b; 2. SQL Server 数据库&#xff1b; 3.AJAX技术&#xff1a;它不是一种新的编程语言&#xff0c;而是一种用于创建更好更快以及交互性更强的 Web 应用程序的技术&#xff1b; 4.HTML,CSSDIV,代码实现静态页面&#xff1b; 开…

集合例题,

package com.hspedu.homework;import java.util.*;/*** author 韩顺平* version 1.0*/ SuppressWarnings({"all"}) public class Homework03 {public static void main(String[] args) {Map m new HashMap();m.put("jack", 650);//int->Integerm.put(&…

C# ArrayList

ArrayList 是 System.Collections 命名空间中的一个类&#xff0c;是一个可动态增长和缩减的数组。与 C# 数组不同&#xff0c;ArrayList 可以自动扩容&#xff0c;并支持动态插入和删除元素&#xff0c;可以存储任何类型的对象。 使用 ArrayList 的步骤如下&#xff1a; 引入…

kafka概述

文章目录 1.kafka定义2.消息队列2.1 传统消息队列的应用场景2.2 消息队列的两种模式 3.Kafka 基础架构 1.kafka定义 2.消息队列 目前企业中比较常见的消息队列产品主 要有 Kafka、ActiveMQ 、RabbitMQ 、RocketMQ 等。 在大数据场景主要采用 Kafka 作为消息队列。在 JavaEE 开…

用户画像项目失败的表面原因

▌原因一&#xff1a;混淆了过去和未来 问1&#xff1a;一个用户昨天买了苹果&#xff0c;前天买了苹果&#xff0c;大前天也买了苹果&#xff0c;他今天买不买苹果&#xff1f; 问2&#xff1a;一个用户买了酱油&#xff0c;鸡翅&#xff0c;可乐&#xff0c;请问他是否还需要…

mysql 海量数据设计:对数据库存储有深入研究

索引&#xff1a; 聚簇索引 二级索引 联合索引&#xff1a;最左匹配原则、自动优化顺序 索引优化方向&#xff1a; 存储空间 主键选择&#xff1a;自增主键、随机主键、业务主键 如何设计一个雪花算法&#xff1a; 正数 时间戳 机器id(固定) 服务id 序号 package ut…

Redis的事务

Redis的事务 1. 是什么? Redis事务可以一次执行多个命令,本质是一组命令的集合 一个事务中的所有命令都会序列化,按顺序地串行化执行而不会被其他命令插入,不许加塞 2. 能干嘛 一个队列中,一次性、顺序性、排他性地执行一些列命令 3. Redis事务 VS MySQL事务 4. Redis事…