SpringBoot+Security动态配置权限

最新推荐文章于 2024-07-03 18:24:21 发布
最新推荐文章于 2024-07-03 18:24:21 发布
阅读量758 收藏 7
点赞数
分类专栏： SpringBoot 文章标签： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Curtisjia/article/details/104265019
版权

前言

在现在web开发中，安全权限的认证一直占着举足轻重的地位，为此Spring自己也出过security安全模块，但是这是一个比较重量级的框架，配置相当的繁琐。后来又出现了shiro这种轻量级的安全框架，里面提供的方法也基本满足开发者的需要。
随着springboot的出现，官方提供了一系列开箱即用的starter，security渐渐重回人们视野，组成了现在常用的springboot+security或者ssm+shiro这样的技术栈。

SQL脚本

这里数据库用的是MySQL5.7

/*
SQLyog Ultimate v12.4.3 (64 bit)
MySQL - 5.7.17-log : 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 utf8 */;

USE `security`;

/*Table structure for table `menu` */

DROP TABLE IF EXISTS `menu`;

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

/*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=utf8;

/*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 */;

添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>leo.study</groupId>
    <artifactId>security</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>security</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <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.1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.17</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

连接数据库

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://localhost:3306/security
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

首先创建实体类

package leo.study.security.bean;

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

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

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
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;
    }

    public Integer getId()
    {
        return id;
    }

    public void setId(Integer id)
    {
        this.id = id;
    }

    @Override
    public String getUsername()
    {
        return username;
    }

    public void setUsername(String username)
    {
        this.username = username;
    }

    @Override
    public String getPassword()
    {
        return password;
    }

    public void setPassword(String password)
    {
        this.password = password;
    }


    public void setEnabled(Boolean enabled)
    {
        this.enabled = enabled;
    }


    public void setLocked(boolean locked)
    {
        this.locked = locked;
    }

    public List<Role> getRoles()
    {
        return roles;
    }

    public void setRoles(List<Role> roles)
    {
        this.roles = roles;
    }
}

用户信息表里存放用户登录名、密码、账户锁定、账户可用标志等信息，所以实现UserDetails来保存我们用户的信息。

首先我们要关注的第一个地方是：

	@Override
    public Collection<? extends GrantedAuthority> getAuthorities()
    {
    	return null;
    }

这里存放的是用户的角色信息，而我们下面呢自己定义了一个role，角色类，所以要把用户对应的角色拿到的话我们需要把role放进user对象里。
这里具体怎么获取用户的角色？
首先创建一个List，因为这个继承来的方法的返回类型是Collection，然后这个集合的泛型是GrantedAuthority的一个继承类SimpleGrantedAuthority，然后开始遍历roles，通过实例化SimpleGrantedAuthority放入角色名称

  public SimpleGrantedAuthority(String role) {
        Assert.hasText(role, "A granted authority textual representation is required");
        this.role = role;
    }

第二我们要关注的地方：
我这里数据库里存在enabled和locked字段，而实现的UserDetails也给我们返回了这两个字段。这个是账户是否没有被锁定，注意看Non，所以你要取反，告诉他，没错，没被锁定！其他的我觉得没什么可说的。

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

package leo.study.security.bean;

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
public class Role
{
    private Integer id;
    private String name;
    private String nameZh;

    @Override
    public String toString()
    {
        return "Role{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", nameZh='" + nameZh + '\'' +
                '}';
    }

    public Integer getId()
    {
        return id;
    }

    public void setId(Integer id)
    {
        this.id = id;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public String getNameZh()
    {
        return nameZh;
    }

    public void setNameZh(String nameZh)
    {
        this.nameZh = nameZh;
    }
}

Menu

menu类要把角色放进来，待会要根据用户角色看他们对应的菜单

package leo.study.security.bean;

import java.util.List;

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
public class Menu
{
    private Integer id;
    private String pattern;
    private List<Role> roles;

    @Override
    public String toString()
    {
        return "Menu{" +
                "id=" + id +
                ", pattern='" + pattern + '\'' +
                ", roles=" + roles +
                '}';
    }

    public List<Role> getRoles()
    {
        return roles;
    }

    public void setRoles(List<Role> roles)
    {
        this.roles = roles;
    }

    public Integer getId()
    {
        return id;
    }

    public void setId(Integer id)
    {
        this.id = id;
    }

    public String getPattern()
    {
        return pattern;
    }

    public void setPattern(String pattern)
    {
        this.pattern = pattern;
    }
}

准备UserService

UserService需要实现UserDetailsService

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException
    {
    	return null;
    }

loadUserByUsername顾名思义，通过用户名查询用户信息，首先判断用户是否存在，如果存在判断他具备什么角色，如果不存在则抛出异常提示。

package leo.study.security.service;

import leo.study.security.bean.User;
import leo.study.security.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;

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
@Service
public class UserService implements UserDetailsService
{
    @Autowired
    UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException
    {
        User user=userMapper.loadUserByUsername(username);
        //判断查询结果为空时
        if(user==null){
            throw new UsernameNotFoundException("用户不存在");
        }
        user.setRoles(userMapper.getRolesById(user.getId()));
        return user;
    }
}

对应mapper类

package leo.study.security.mapper;

import leo.study.security.bean.Role;
import leo.study.security.bean.User;

import java.util.List;

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
public interface UserMapper
{

    User loadUserByUsername(String username);

    List<Role> getRolesById(Integer id);
}

mapper的配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="leo.study.security.mapper.UserMapper">
    <select id="loadUserByUsername" resultType="leo.study.security.bean.User">
        select * from user where username=#{username};
    </select>

    <select id="getRolesById" resultType="leo.study.security.bean.Role">
        select * from role where id in(select rid from user_role where uid=#{id});
    </select>
</mapper>

开始写配置类

package leo.study.security.config;

import leo.study.security.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;

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
@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);
    }
}

上面的包有些没去掉，没在意。首先BCryptPasswordEncoder是密码加密，现在的security提交的密码必须被加过密，其次就是自己犯的一个小失误@Configuration注解忘记加了，怪不得自己debug半天也找不到问题在哪。

写一个控制器

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

开始测试

security会默认重定向到他的登录页
在这里插入图片描述
登陆后请求，没有问题！
在这里插入图片描述
当然这是最基本的，我们要实现的是让对应的用户能访问到自己该访问的路径。

查询对应用户能访问的菜单路径

之前我们已经准备好了实体类，现在写服务层

menuservice

package leo.study.security.service;

import leo.study.security.bean.Menu;
import leo.study.security.bean.Role;
import leo.study.security.mapper.MenuMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
@Service
public class MenuService
{
    @Autowired
    MenuMapper menuMapper;
    public List<Menu> getAllMenus(){
        return menuMapper.getAllMenus();
    }
}

MenuMapper

package leo.study.security.mapper;

import leo.study.security.bean.Menu;

import java.util.List;

public interface MenuMapper
{
    List<Menu> getAllMenus();
}

配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="leo.study.security.mapper.MenuMapper">
    <resultMap id="BaseResultMap" type="leo.study.security.bean.Menu">
        <id property="id" column="id"></id>
        <result property="pattern" column="pattern"></result>
        <collection property="roles" ofType="leo.study.security.bean.Role">
            <id property="id" column="rid"></id>
            <result property="name" column="rname"></result>
            <result property="nameZh" column="rnameZh"></result>
        </collection>
    </resultMap>
    <select id="getAllMenus" resultMap="BaseResultMap">
        select m.*,r.id rid,r.name rname,r.nameZh rnameZh 
        from menu m left join menu_role mr on m.id=mr.mid left join role r on mr.rid=r.id
    </select>
</mapper>

准备完成之后，在配置类里写一个过滤器，作用是获取当前用户的请求地址再与他所有的权限比较，看是否一致。他这里只做比较。待会还会有一个处理类

package leo.study.security.config;

import leo.study.security.bean.Menu;
import leo.study.security.bean.Role;
import leo.study.security.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;

/**
 * @description:
 * 主要功能：
 * 分析请求地址
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
@Component
public class MyFilter implements FilterInvocationSecurityMetadataSource
{
    //路径匹配
    AntPathMatcher antPathMatcher=new AntPathMatcher();

    @Autowired
    MenuService menuService;

    @Override
    public Collection<ConfigAttribute> getAttributes(Object o) throws IllegalArgumentException
    {
        //获取请求的地址
        String requestUrl = ((FilterInvocation) o).getRequestUrl();
        List<Menu> list = menuService.getAllMenus();//获取所有用户角色对应的请求路径
        for (Menu menu : list)
        {
            //开始比较数据库获取的路径与请求路径是否一致
            if(antPathMatcher.match(menu.getPattern(),requestUrl)){
                //当路径完全一致时，就看这个路径需要哪些角色才能请求
                List<Role> roles = menu.getRoles();
                //创建一个数组，放置roles
                String[] roleStr=new String[roles.size()];
                //考虑一个人可能会有多个角色，需要遍历
                for (int i = 0; i < roles.size(); i++)
                {
                    //获取角色名
                    roleStr[i]=roles.get(i).getName();
                }
                //返回角色对象
                return SecurityConfig.createList(roleStr);
            }
        }
        //如果请求的方法，上面方法都没有判断上，那就返回一个ROLE_login标记符，当你请求上面无法
        //识别的路径时，自动跳转登陆
        return SecurityConfig.createList("ROLE_login");
    }

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

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

MyAccessDecisionManager

package leo.study.security.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;

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
@Component
public class MyAccessDecisionManager implements AccessDecisionManager
{
    //authentication 保存当前用户登陆的信息
    //o 获取当前请求对象
    //collection public Collection<ConfigAttribute> getAttributes(Object o) 的返回值
    @Override
    public void decide(Authentication authentication, Object o, Collection<ConfigAttribute> collection) throws AccessDeniedException, InsufficientAuthenticationException
    {
        //遍历collection
        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;
    }
}

添加配置类

package leo.study.security.config;

import leo.study.security.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;

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/11
 * @version: 1.0
 */
@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.setSecurityMetadataSource(myFilter);
                o.setAccessDecisionManager(myAccessDecisionManager);
                return o;
            }
        }).and().formLogin().permitAll().and().csrf().disable();
    }
}

后面会对这个地方做更详细的解释

没有狗头，未完待续！

朝花不迟暮
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot+springsecurity动态权限
weixin_43740982的博客
10-26 226
WebSecurityConfigurerAdapter 关键配置 .accessDeniedHandler(new MyAccessDeniedHandler())//权限不足是报错类 .and().authorizeRequests().withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() { @Override ..
springboot+security+jwt+mybaits-plus+mysql实现权限管理
03-13
在本项目中，我们主要探讨的是如何利用Spring Boot、Spring Security、JWT（JSON Web Tokens）、MyBatis-Plus以及MySQL数据库来构建一个完整的权限管理系统。下面将详细解析这些技术及其在项目中的应用。 1. Spring...
springboot springsecurity动态权限控制
09-18
springboot springsecurity动态权限控制，实现数据库动态管理菜单权限
SpringBoot Security 动态权限入门
qq_33601179的博客
10-20 919
废话 本案例是以最简单最简单的方式实现动态权限配置，摒弃各种花里胡哨的代码。 动态权限主要需要实现两个功能： 1、Url访问权限的动态设置 2、用户本身具备的权限动态设置 基础逻辑主要就是用Security作为登录、权限校验，权限允许则访问，权限不允许则提示权限不足。 一、准备工作 1、一个简单的SpringBoot工程 略 2、引入 <dependency> <groupId>org.springframework.bo
SpringBoot 整合 SpringSecurity
最新发布
一个95后开发者，热爱编程，喜欢玩游戏. 希望可以结识更多的小伙伴...
07-03 894
SpringSecurity整合SpringBoot中的动态权限配置
chengxuyuan316的博客
03-09 628
数据库有三张表 menu(菜单表) 、 menu_role 和 role(角色表) ![在这里插入图片描述](https://img-blog.csdnimg.cn/af946c70239b4a3bb34b43880a369b6a.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATFlISjQwMw==,size_20,color_FFFFFF,t_70,g_se,x_16 url字段存放该菜单下的所有
Spring Boot + security 动态权限配置简单案例
那杯热咖啡
09-06 285
项目已上传至 ：https://github.com/astronger/securitydy
springboot+security+mybatis+redis+jwt，鉴权框架搭建
06-22
本项目集成了springboot+security+mybatis+redis+jwt用于学习security鉴权功能，其中有...项目搭建已经比较成熟，能够直接进行使用，通过代码可以学习security的权限配置，菜单权限，注解权限等 有学习SPI机制的学习
springboot+security+cas集成demo
11-23
本文将详细解析"springboot+security+cas集成demo"的相关知识点。 首先，Spring Boot是由Pivotal团队提供的一个用于简化Spring应用初始搭建以及开发过程的框架。它集成了大量的常用组件，并提供了默认配置，使得...
springboot+jpa+security用户权限
11-04
1. 配置文件：`SecurityConfig.java`，这是Spring Security的配置类，用于定制认证和授权规则。 2. 控制器：可能有处理登录、注销请求的控制器，如`LoginController.java`。 3. 服务类：如`UserService.java`，可能...
springBoot+security+mybatis 实现用户权限的数据库动态管理
05-03
NULL 博文链接：https://veiking.iteye.com/blog/2429172
Spring Boot权限管理(最终)
08-17
Spring Boot权限管理
SpringBoot 权限控制（菜单控制，页面元素控制，url控制）
04-13
基于RBAC思想的权限控制，可先建立完整的库，也可以使用使用代码生成，包中提供两种方式， 代码先后顺序 菜单控制----》元素控制-------》url控制
springboot 项目动态开启权限（模仿@EnableXXXX）
qq_26634873的博客
04-18 479
1 创建一个EnableXXX 注解类 import com.cpiinfo.iot.isolar.config.PermissionsSelector; import org.springframework.context.annotation.Import; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy
Spring Security +Oauth2 +Spring boot 动态定义权限
weixin_30341735的博客
05-04 1245
Oauth2介绍：Oauth2是为用户资源的授权定义了一个安全、开放及简单的标准，第三方无需知道用户的账号及密码，就可获取到用户的授权信息，并且这是安全的。 简单的来说，当用户登陆网站的时候，需要账号和密码，但是你没有账号和密码，你需要注册网站的账号和密码，可是你不想注册，如果我有(qq,github,微博，facebook)第三方网站的账号，直接登陆当前网站访问网站的资源就好了？有没有这种实现...
SpringBoot 整合Shiro实现动态权限加载更新+Session共享+单点登录
z_ssyy的博客
01-15 1672
ADMIN这个号现在没有sys:info:all这个权限的,所以无法访问getInfoAll接口,我们要动态分配权限后,要清掉缓存,在访问接口时候,Shiro会去重新执行授权方法,之后再次把权限和角色数据放入缓存中。Shiro是一个安全框架,项目中主要用它做认证,授权,加密,以及用户的会话管理,虽然Shiro没有SpringSecurity功能更丰富,但是它轻量,简单,在项目中通常业务需求Shiro也都能胜任.再次访问getInfoAll接口,因为缓存中没有数据,Shiro会重新授权查询权限,拦截通过。
Spring Security-动态权限控制(1)
射手座的程序媛的专栏
01-18 1761
spring security 动态权限控制
SpringBoot整合Security动态权限案例
hq.zheng的博客
04-19 503
注意：需要实现Security中的UserDetailsService 的loadUserByUsername()方法。注意：User类需要实现Security中的UserDetails的getAuthorities()方法。4）、自定义Security配置案例代码。3）、service案例代码。一、RBAC权限模型表设计。1）、entity案例代码。2）、mapper案例代码。自定义登入密码加密工具类。1）、核心pom依赖。
Spring Boot动态权限变更实现的整体方案
alabo1999的博客
06-29 125
  利用ServletContext对象的共享特性，来实现用户权限变更的信息传递。然后在AOP类中查询用户是否有变更通知记录需要处理，如果权限发生变化，则修改response消息体，添加附加通知信息给前端。前端收到附加的通知信息，可更新功能权限树，并进行相关处理。   首发地址：Spring Boot动态权限变更实现的整体方案 ...
SpringBoot+SpringSecurity+JWT
09-19
SpringBoot是一个开源的Java开发框架，它简化了Spring应用程序的创建和配置过程。...6. 配置SpringSecurity：在SpringBoot的配置文件中配置SpringSecurity的相关属性，例如登录路径、认证路径和权限配置等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值