SpringSecurity 动态配置权限

最新推荐文章于 2023-03-31 09:51:53 发布
最新推荐文章于 2023-03-31 09:51:53 发布
阅读量264 收藏 1
点赞数
分类专栏： java 文章标签： 数据库 c# mysql
原文链接：https://gitee.com/antia11/spring-security-demos/tree/master/security-dynamic
版权

gitee源码：https://gitee.com/antia11/spring-security-demos/tree/master/security-dynamic

搭建一个简单 SpringSecurity 环境

secruity.sql

/*
SQLyog Ultimate v13.1.1 (64 bit)
MySQL - 5.7.19 : Database - security
*********************************************************************
*/

/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`security` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci */;

USE `security`;

/*Table structure for table `menu` */

DROP TABLE IF EXISTS `menu`;

CREATE TABLE `menu` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `pattern` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

/*Data for the table `menu` */

insert  into `menu`(`id`,`pattern`) values 
(1,'/db/**'),
(2,'/admin/**'),
(3,'/user/**');

/*Table structure for table `menu_role` */

DROP TABLE IF EXISTS `menu_role`;

CREATE TABLE `menu_role` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `mid` int(11) DEFAULT NULL,
  `rid` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

/*Data for the table `menu_role` */

insert  into `menu_role`(`id`,`mid`,`rid`) values 
(1,1,1),
(2,2,2),
(3,3,3);

/*Table structure for table `role` */

DROP TABLE IF EXISTS `role`;

CREATE TABLE `role` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) DEFAULT NULL,
  `nameZh` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

/*Data for the table `role` */

insert  into `role`(`id`,`name`,`nameZh`) values 
(1,'ROLE_dba','数据库管理员'),
(2,'ROLE_admin','系统管理员'),
(3,'ROLE_user','用户');

/*Table structure for table `user` */

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  `enabled` tinyint(1) DEFAULT NULL,
  `locked` tinyint(1) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

/*Data for the table `user` */

insert  into `user`(`id`,`username`,`password`,`enabled`,`locked`) values 
(1,'root','$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq',1,0),
(2,'admin','$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq',1,0),
(3,'sang','$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq',1,0);

/*Table structure for table `user_role` */

DROP TABLE IF EXISTS `user_role`;

CREATE TABLE `user_role` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `uid` int(11) DEFAULT NULL,
  `rid` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

/*Data for the table `user_role` */

insert  into `user_role`(`id`,`uid`,`rid`) values 
(1,1,1),
(2,1,2),
(3,2,2),
(4,3,3);

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

在这里插入图片描述
pom.xml

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.6</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

静态资源过滤

 <resources>
     <resource>
         <directory>src/main/java</directory>
         <includes>
             <include>**/*.xml</include>
         </includes>
     </resource>
     <resource>
         <directory>src/main/resources</directory>
     </resource>
</resources>

bean.User.java

package com.zhuantai.securitydynamic.bean;

import lombok.Data;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * @author ANTIA1
 * @date 2021/7/10 1:10
 */
@Data
public class User implements UserDetails {
    private Integer id;
    private String username;
    private String password;
    private Boolean enabled;
    private Boolean locked;
    private List<Role> roles;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        List<SimpleGrantedAuthority> authorities = new ArrayList<>();
        for (Role role : roles) {
            authorities.add(new SimpleGrantedAuthority(role.getName()));
        }
        return authorities;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return !locked;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return enabled;
    }
}

bean.Role.java

package com.zhuantai.securitydynamic.bean;

import lombok.Data;

/**
 * @author ANTIA1
 * @date 2021/7/10 1:17
 */
@Data
public class Role {
    private Integer id;
    private String name;
    private String nameZh;
}

bean.Menu.java

package com.zhuantai.securitydynamic.bean;

import lombok.Data;

/**
 * @author ANTIA1
 * @date 2021/7/10 11:48
 */
@Data
public class Menu {
    private Integer id;
    private String pattern;
}

service.UserService.java

package com.zhuantai.securitydynamic.service;

import com.zhuantai.securitydynamic.bean.User;
import com.zhuantai.securitydynamic.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

/**
 * @author ANTIA1
 * @date 2021/7/10 11:51
 */
@Service
public class UserService implements UserDetailsService {

    @Autowired
    UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        User user = userMapper.loadUserByUsername(s);
        if (user == null){
            throw new UsernameNotFoundException("用户不存在!");
        }
        user.setRoles(userMapper.getRolesById(user.getId()));
        return user;
    }
}

mapper.UserMapper.java

package com.zhuantai.securitydynamic.mapper;

import com.zhuantai.securitydynamic.bean.Role;
import com.zhuantai.securitydynamic.bean.User;

import java.util.List;

/**
 * @author ANTIA1
 * @date 2021/7/10 11:49
 */
public interface UserMapper {

    User loadUserByUsername(String username);

    List<Role> getRolesById(Integer id);
}

mapper.UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhuantai.securitydynamic.mapper.UserMapper">
    <select id="loadUserByUsername" resultType="User">
        select *
        from user where username = #{username};
    </select>
    <select id="getRolesById" resultType="Role">
        select *
        from role where id in (select rid from user_role where uid = #{id});
    </select>
</mapper>

controller.HelloController.java

package com.zhuantai.securitydynamic.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author ANTIA1
 * @date 2021/7/10 12:05
 */
@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(){
        return "hello";
    }
}

config.SecurityConfig.java

package com.zhuantai.securitydynamic.config;

import com.zhuantai.securitydynamic.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @author ANTIA1
 * @date 2021/7/10 12:02
 */
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    UserService userService;

    @Bean
    PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
    }
}

application.properties

# 应用名称
spring.application.name=security-dynamic
# 应用服务 WEB 访问端口
server.port=8080
#下面这些内容是为了让MyBatis映射
#指定Mybatis的Mapper文件
mybatis.mapper-locations=classpath:mappers/*xml
#指定Mybatis的实体目录
mybatis.type-aliases-package=com.zhuantai.securitydynamic.bean
# 数据库驱动：
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据源名称
spring.datasource.name=defaultDataSource
# 数据库连接地址
spring.datasource.url=jdbc:mysql://localhost:3306/security?serverTimezone=UTC
# 数据库用户名&密码：
spring.datasource.username=root
spring.datasource.password=123

启动程序，在浏览器中访问 http://localhost:8080/hello 输入用户名 root 密码 123 点击登陆，显示 hello 表示环境搭建成功。
在这里插入图片描述

配置动态权限

配置动态权限也就是将权限放在数据库中进行管理，方便之后对其的更改。

menu.table
在这里插入图片描述
menu_role.table
在这里插入图片描述

如果想要访问某个pattern，会要求有权限。
ok，那么在项目中如何去具体实现呢？

创建一个 Filter 实现 FilterInvocationSecurityMetadataSource 接口

这一步的作用是：根据你请求的地址，分析出你请求的地址需要哪些角色。
MyFilter.java

package com.zhuantai.securitydynamic.config;

import com.zhuantai.securitydynamic.bean.Menu;
import com.zhuantai.securitydynamic.bean.Role;
import com.zhuantai.securitydynamic.service.MenuService;
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 java.util.Collection;
import java.util.List;

/**
 * @author ANTIA1
 * @date 2021/7/10 12:38
 */
@Component
public class MyFilter implements FilterInvocationSecurityMetadataSource {

    //Java自带的路径匹配工具
    AntPathMatcher pathMatcher = new AntPathMatcher();

    @Autowired
    MenuService menuService;

    /**
     * 根据你请求的地址，进而分析出你请求的地址需要哪些角色
     * @param o FilterInvocation
     * @return 该路径所需要的的角色
     * @throws IllegalArgumentException
     */
    @Override
    public Collection<ConfigAttribute> getAttributes(Object o) throws IllegalArgumentException {

        String requestUrl = ((FilterInvocation) o).getRequestUrl();//获取请求地址
        List<Menu> allMenus = menuService.getAllMenus();

        for (Menu menu : allMenus) {
            if (pathMatcher.match(menu.getPattern(),requestUrl)){//查看当前请求地址是否和menu中pattern存在匹配
                //如果匹配上
                List<Role> roles = menu.getRoles();//获取该地址需要哪些角色

                //将角色名存入一个String[]中，return出去
                String[] rolesStr = new String[roles.size()];
                for (int i = 0; i < roles.size(); i++) {
                    rolesStr[i] = roles.get(i).getName();
                }
                return SecurityConfig.createList(rolesStr);
            }
        }
        //ROLE_login 标记为该路径不需要角色，只要登录就可以访问
        return SecurityConfig.createList("ROLE_login");//默认返回值，如果没有匹配上，做额外处理
    }

    @Override
    public Collection<ConfigAttribute> getAllConfigAttributes() {
        return null;
    }

    @Override
    public boolean supports(Class<?> aClass) {
        return true;
    }
}

ok，获取到访问这个地址需要具备哪些角色后，我们继续来看

创建MyAccessDecisionManager 实现 AccessDecisionManager

上一步我们获取到了访问这个地址需要具备哪些角色权限后，这一步的作用是，判断当前用户是否具备所要求的角色权限。

package com.zhuantai.securitydynamic.config;

import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.authentication.AnonymousAuthenticationToken;
import org.springframework.security.authentication.InsufficientAuthenticationException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.stereotype.Component;

import java.util.Collection;

/**
 * @author ANTIA1
 * @date 2021/7/10 13:02
 */
@Component
public class MyAccessDecisionManager implements AccessDecisionManager {
    /**
     *
     * @param authentication 当前登录用户的信息
     * @param o              FilterInvocation 当前请求的信息
     * @param collection     MyFilter中的返回值;当前请求所需要的的角色
     * @throws AccessDeniedException
     * @throws InsufficientAuthenticationException
     */
    @Override
    public void decide(Authentication authentication, Object o, Collection<ConfigAttribute> collection) throws AccessDeniedException, InsufficientAuthenticationException {
        
        for (ConfigAttribute attribute : collection) {
            if ("ROLE_login".equals(attribute.getAttribute())){//说明和之前那些地址都没匹配上
                //说明不需要以上那些权限,登录就可以访问，那么需要判断是否登录了。
                if (authentication instanceof AnonymousAuthenticationToken){ //判断是不是匿名用户
                     throw new AccessDeniedException("非法请求!");//匿名用户未登录直接抛异常
                }else{
                    return;//否则说明不是匿名用户，已经登录，可以访问该资源路径
                }
            }
            //我现在具备的角色
            Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
            for (GrantedAuthority authority : authorities) {
                if (authority.getAuthority().equals(attribute.getAttribute())){//如果具备所需要的角色
                    return;
                }
            }
        }
        //如果都没匹配上，那就还是一个非法请求
        throw new AccessDeniedException("非法请求!");//匿名用户未登录直接抛异常
    }

    @Override
    public boolean supports(ConfigAttribute configAttribute) {
        return true;
    }

    @Override
    public boolean supports(Class<?> aClass) {
        return true;
    }
}

配置SecurityConfig

两步配置完成后，需要将他们配置到SecurityConfig中让他们生效

package com.zhuantai.securitydynamic.config;

import com.zhuantai.securitydynamic.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.ObjectPostProcessor;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.access.intercept.FilterSecurityInterceptor;

/**
 * @author ANTIA1
 * @date 2021/7/10 12:02
 */
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    UserService userService;

    @Autowired
    MyFilter myFilter;

    @Autowired
    MyAccessDecisionManager myAccessDecisionManager;

    @Bean
    PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
                    @Override
                    public <O extends FilterSecurityInterceptor> O postProcess(O o) {
                        o.setAccessDecisionManager(myAccessDecisionManager);
                        o.setSecurityMetadataSource(myFilter);
                        return o;
                    }
                })
                .and()
                .formLogin()
                .permitAll()
                .and()
                .csrf().disable();
    }
}

修改bean.Menu.java

修改menu对象，menu中需要具备角色权限，所以一个menu可能对应多个权限，那我们需要在其中添加一个Listroles的属性。

package com.zhuantai.securitydynamic.bean;

import lombok.Data;

import java.util.List;

/**
 * @author ANTIA1
 * @date 2021/7/10 11:48
 */
@Data
public class Menu {
    private Integer id;
    private String pattern;
    private List<Role> roles;
}

补充代码
MenuService.java

package com.zhuantai.securitydynamic.service;

import com.zhuantai.securitydynamic.bean.Menu;
import com.zhuantai.securitydynamic.mapper.MenuMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author ANTIA1
 * @date 2021/7/10 12:43
 */
@Service
public class MenuService {

    @Autowired
    MenuMapper menuMapper;

    public List<Menu> getAllMenus(){
        return menuMapper.getAllMenus();
    }
}

MenuMapper.java

package com.zhuantai.securitydynamic.mapper;

import com.zhuantai.securitydynamic.bean.Menu;

import java.util.List;

/**
 * @author ANTIA1
 * @date 2021/7/10 12:43
 */
public interface MenuMapper {
    List<Menu> getAllMenus();
}

MenuMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhuantai.securitydynamic.mapper.MenuMapper">
    <resultMap id="BaseResultMap" type="Menu">
        <id property="id" column="id"/>
        <result property="pattern" column="pattern"/>
        <collection property="roles" ofType="com.zhuantai.securitydynamic.bean.Role">
            <id column="rid" property="id"/>
            <result property="name" column="rname"/>
            <result column="rnameZh"  property="nameZh"/>
        </collection>
    </resultMap>
    <select id="getAllMenus" resultMap="BaseResultMap">
        SELECT
            menu.*,r.`id`AS rid,r.`name` AS rname ,r.`nameZh` AS rnameZh
        FROM
            menu LEFT JOIN menu_role mr ON menu.id = mr.`mid` LEFT JOIN role r ON mr.`rid` = r.`id`
    </select>
</mapper>

HelloController.java

package com.zhuantai.securitydynamic.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author ANTIA1
 * @date 2021/7/10 12:05
 */
@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(){
        return "hello";
    }

    @GetMapping("/db/hello")
    public String db(){
        return "hello db";
    }

    @GetMapping("/admin/hello")
    public String admin(){
        return "hello admin";
    }

    @GetMapping("/user/hello")
    public String user(){
        return "hello user";
    }
}

运行测试结果

我们先使用root登录，密码是123,访问：

http://localhost:8080/hello
http://localhost:8080/admin/hello
http://localhost:8080/db/hello
http://localhost:8080/user/hello
如果1、2、3可以访问，4不能访问结果为403，那就说明成功了。

/hello - ok
在这里插入图片描述
/admin/hello - ok
在这里插入图片描述
/db/hello - ok
在这里插入图片描述
/user/hello - 403
在这里插入图片描述

ok，运行成功。基于数据库的动态配置权限验证梳理完毕。

明平姚博客
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【系统权限管理】SpringSecurity实现动态权限菜单控制
2401_84048542的博客
04-18 504
现在正是金三银四的春招高潮，前阵子小编一直在搭建自己的网站，并整理了全套的**【一线互联网大厂Java核心面试题库+解析】：包括Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等**《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！/getAuthority()返回用户对应的菜单权限。
springboot springsecurity动态权限控制
09-18
在这个“springboot springsecurity动态权限控制”的主题中，我们将深入探讨如何在Spring Boot项目中集成Spring Security，实现动态权限控制，让菜单权限的管理更加灵活和高效。 首先，我们需要理解Spring Security...
Spring Security 动态url权限控制
程序员小明1024
12-19 2489
一、前言 本篇文章将讲述Spring Security 动态分配url权限，未登录权限控制，登录过后根据登录用户角色授予访问url权限 基本环境 spring-boot 2.1.8 mybatis-plus 2.2.0 mysql 数据库 maven项目 Spring Security入门学习可参考之前文章： SpringBoot集成Spring Security入门体验(一)blog....
SpringSecurity授权流程分析+动态授权实现
张氏小毛驴的博客
08-12 1927
代码运行到这里后，我们拿到了系统配置的URL权限attributes，认证用户对象Authentication也拿到了，还有当前请求相关的信息FilterInvocation ,也就是这个方法的参数object，接下来授权肯定是拿着三部分的信息去实现的。之前说过，SpringSecurity过滤器链，图中绿色的是认证相关的，蓝色部分是异常相关的，而橙色部分是授权相关，今天我们就是要理清橙色部分授权相关的流程，以及实现动态授权。通过上面的分析，我们大体能了解到整个授权的流程是这样的：(网上找的图)......
SpringSecurity - 用户动态授权 及 动态角色权限
热门推荐
小毕超博客
01-09 1万+
一、SpringSecurity 动态授权 上篇文章我们介绍了SpringSecurity的动态认证，上篇文章就说了SpringSecurity 的两大主要功能就是认证和授权，既然认证以及学习了，那本篇文章一起学习了SpringSecurity 的动态授权。 上篇文章地址：https://blog.csdn.net/qq_43692950/article/details/122393435 二、SpringSecurity 授权 我们接着上篇文章的项目继续修改，上篇文章中有说到我们WebSecurity
Spring Security实现动态路由权限控制
SampsonKong的博客
02-13 1440
Spring Security实现动态路由权限控制
SpringSecurity之授权
Littewood的博客
07-24 3357
SpringSecurity之授权介绍
spring security动态配置url权限的2种实现方法
08-27
本文将探讨两种在Spring Security中实现动态配置URL权限的方法。 ### 方法一：自定义Filter 虽然自定义Filter可以实现动态权限判断，但这并不符合Spring Security的设计原则，因为这会使你绕过框架提供的安全机制...
SpringSecurity动态加载用户角色权限实现登录及鉴权功能
08-25
在 Spring Security 中，用户、角色、权限信息通常存放在 RBAC 权限模型的数据库表中，而不是写死在配置文件中。为了动态加载这些信息，我们需要实现 UserDetails 和 UserDetailsService 接口。 UserDetails 接口...
Vue 动态路由的实现及 Springsecurity 按钮级别的权限控制
10-16
主要介绍了Vue 动态路由的实现以及 Springsecurity 按钮级别的权限控制的相关知识，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
Spring security实现登陆和权限角色控制
09-09
通过以上步骤，你已经配置了Spring Security来处理登录、权限和角色控制。当用户尝试访问受保护的资源时，Spring Security会自动重定向到登录页面。登录成功后，它会根据用户的角色决定是否允许访问请求的资源。同时...
spring security3动态权限
06-15
struts2 + spring3 + hibernate3 + spring security3 + mysql + tomcat sys_users;sys_roles;sys_authorities;sys_resources;sys_users_roles;sys_roles_authorities;sys_authorities_resources; PS：此项目运行不起来的，请参考代码，呵呵！
一个基于 Spring Security 的动态权限控制快速使用包
dzqxwzoe的博客
02-15 83
在日常项目中，Spring Security 的默认认证流程满足不了的需求。但是，一般的项目对于认证、鉴权这块儿的需要又是十分类似的。所以，我针对日常项目的认证鉴权需求，将 Spring Security 进行了一层包装。项目地址、以及测试项目地址，都放在文尾了。
SpringSecurity + jwt + Oauth2实现动态权限管理(有源码)
最新发布
qq_44993268的博客
03-31 1195
spring security权限管理
Spring Security 实现 antMatchers 配置路径的动态获取
MrLee的博客
12-26 2325
2，实现 SecurityConfigAttributeLoader (这里也可以从数据库获取)
SpringSecurity动态授权流程及实现
zjy660358的专栏
11-13 1304
需求：如何通过修改数据库中某个角色的对某一访问路径的权限，进而动态的限制该角色的权限。
六、SpringSecurity实现动态权限控制
a2231476020的博客
08-21 9432
前面已经实现了登陆，即认证，下面是登陆之后的鉴权(即某些角色只能访问特定的资源) /** * @auther Mr.Liao * @date 2019/8/20 20:24 */ @Component public class MySecurityMetadataSource implements FilterInvocationSecurityMetadataSource { @A...
SpringSecurity动态配置权限
小夢書亭的博客
09-14 805
SpringSecurity动态配置权限 自定义 UserDetailsService UserDetailsService 的主要作用是，获取数据库里面的信息，然后封装成对象，我们既然需要从数据库中读取用户，那么我们就需要实现自己的 UserDetailsService ，按照我们的逻辑完成从数据库中获取信息； /** * 主要是封装从数据库获取的用户信息 * * @author yiaz * @date 2019年3月19日10:50:58 */ @Component public c

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值