SpringBoot Security | 三、简单自定义许可和角色

最新推荐文章于 2024-07-04 09:14:32 发布
最新推荐文章于 2024-07-04 09:14:32 发布
阅读量331 收藏
点赞数
分类专栏： security 文章标签： security
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oqqMiHu123/article/details/100704938
版权

目录

 

一、项目实现

增加数据库表：

加入自定义许可逻辑

二、测试

一、项目实现

增加数据库表：

sql：

DROP TABLE IF EXISTS `sys_permission`;
CREATE TABLE `sys_permission` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
  `description` varchar(200) COLLATE utf8mb4_general_ci DEFAULT NULL,
  `url` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
  `pid` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

-- ----------------------------
-- Records of sys_permission
-- ----------------------------
INSERT INTO `sys_permission` VALUES ('1', 'ROLE_HOME', 'home', '/', null);
INSERT INTO `sys_permission` VALUES ('2', 'ROLE_ADMIN', 'ABel', '/admin', null);
INSERT INTO `sys_permission` VALUES ('4', 'ROLE_USER', 'user', '/getUser', null);

-- ----------------------------
-- Table structure for sys_permission_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_permission_role`;
CREATE TABLE `sys_permission_role` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `role_id` bigint(20) unsigned NOT NULL,
  `permission_id` bigint(20) unsigned NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

-- ----------------------------
-- Records of sys_permission_role
-- ----------------------------
INSERT INTO `sys_permission_role` VALUES ('1', '1', '1');
INSERT INTO `sys_permission_role` VALUES ('2', '1', '2');
INSERT INTO `sys_permission_role` VALUES ('3', '2', '1');
INSERT INTO `sys_permission_role` VALUES ('4', '1', '4');

-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

-- ----------------------------
-- Records of sys_role
-- ----------------------------
INSERT INTO `sys_role` VALUES ('1', 'ROLE_ADMIN');
INSERT INTO `sys_role` VALUES ('2', 'ROLE_USER');

-- ----------------------------
-- Table structure for sys_role_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_role_user`;
CREATE TABLE `sys_role_user` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `sys_user_id` bigint(20) unsigned NOT NULL,
  `sys_role_id` bigint(20) unsigned NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

-- ----------------------------
-- Records of sys_role_user
-- ----------------------------
INSERT INTO `sys_role_user` VALUES ('1', '1', '1');
INSERT INTO `sys_role_user` VALUES ('2', '2', '2');

-- ----------------------------
-- Table structure for sys_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
  `password` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

-- ----------------------------
-- Records of sys_user
-- ----------------------------
INSERT INTO `sys_user` VALUES ('1', 'admin', '202cb962ac59075b964b07152d234b70');
INSERT INTO `sys_user` VALUES ('2', 'abel', 'abel');


public class Permission {

    private int id;
    //权限名称
    private String name;

    //权限描述
    private String descritpion;

    //授权链接
    private String url;

..
}
public class SecurityUser implements UserDetails {

    private static final long serialVersionUID=1L;
    private Long id;
    private String username;
    private String password;
    private List<GrantedAuthority> anthorities;

...
}

mapper:

public interface PermissionMapper {

    @Select("select * from sys_permission")
    public List<Permission> findAll();


    @Select("select p.* " +
            "from Sys_User u " +
            "LEFT JOIN sys_role_user sru on u.id= sru.Sys_User_id " +
            "LEFT JOIN Sys_Role r on sru.Sys_Role_id=r.id " +
            "LEFT JOIN Sys_permission_role spr on spr.role_id=r.id " +
            "LEFT JOIN Sys_permission p on p.id =spr.permission_id " +
            "where u.id=#{userId}")
    public List<Permission> findByAdminUserId(Long userId);
}

public interface SecurityUserMapper {

    //新增用户
    @Insert("insert into sys_user(username,password) value(#{username},#{password})")
    @Options(useGeneratedKeys=true,keyColumn="id",keyProperty="id")
    public void insert(SecurityUser SecurityUser);

    //查找所有用户
    @Select("select * from sys_user")
    public List<SecurityUser> getAll();

    //根据id查找用户
    @Select("select * from sys_user where id=#{id}")
    public SecurityUser getById(int id);

    @Select("select * from sys_user where username=#{username}")
    public SecurityUser getByName(String username);

    //根据id删除用户
    @Delete("delete from sys_user where id=#{id}")
    public boolean deleteById(int id);

}

加入自定义许可逻辑

MySecurityMetadataSource类，继承于FilterInvocationSecurityMetadataSource； 获取路径所需角色
public class MySecurityMetadataSource implements FilterInvocationSecurityMetadataSource {

    private Logger log = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private PermissionMapper permissionMapper;

    private HashMap<String, Collection<ConfigAttribute>> map =null;

    @PostConstruct
    public void init() {
        map = new HashMap<>();
        Collection<ConfigAttribute> array;
        ConfigAttribute cfg;
        List<Permission> permissions = permissionMapper.findAll();
        for(Permission permission : permissions) {
            array = new ArrayList<>();
            cfg = new SecurityConfig(permission.getName());
            array.add(cfg);
            map.put(permission.getUrl(), array);
        }
    }

    @Override
    public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
        HttpServletRequest request = ((FilterInvocation) object).getRequest();

        AntPathRequestMatcher matcher;
        for (String resUrl : map.keySet()) {
            log.info("MySecurityMetadataSource resUrl:{} request:{}", resUrl, request.getRequestURI());
            matcher = new AntPathRequestMatcher(resUrl);
            if (matcher.matches(request)) {
//                ConfigAttribute configAttribute = new MyConfigAttribute(request,new MyGrantedAuthority(jurisdiction.getMethod(),jurisdiction.getUrl()));
//                allConfigAttribute.add(configAttribute);
//                return allConfigAttribute;
                return map.get(resUrl);
            }
        }

        return null;
    }

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

    @Override
    public boolean supports(Class<?> clazz) {
//        return FilterInvocation.class.isAssignableFrom(clazz);
        return true;
    }
}
MyAccessDecisionManager类，继承于AccessDecisionManager， 用户角色与路径角色是否匹配。
public class MyAccessDecisionManager implements AccessDecisionManager {

    private Logger log = LoggerFactory.getLogger(this.getClass());

    @Override
    public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes) throws AccessDeniedException, InsufficientAuthenticationException {
        log.info("MyAccessDecisionManager join");
        if(configAttributes == null || configAttributes.size()==0) {
            return;
        }
//        if(!authentication.isAuthenticated()) {
//            throw new InsufficientAuthenticationException("未登录");
//        }
//        Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
//        for(ConfigAttribute attribute : collection){
//            MyConfigAttribute urlConfigAttribute = (MyConfigAttribute)attribute;
//            for(GrantedAuthority authority: authorities){
//                MyGrantedAuthority myGrantedAuthority = (MyGrantedAuthority)authority;
//                if(urlConfigAttribute.getMyGrantedAuthority().equals(myGrantedAuthority))
//                    return;
//            }
//        }
        String needRole;
        for (ConfigAttribute c : configAttributes) {
            needRole = c.getAttribute();
            log.info("MyAccessDecisionManager needRole:{}", needRole);
            for(GrantedAuthority ga : authentication.getAuthorities()) {//authentication 为在注释1 中循环添加到 GrantedAuthority 对象中的权限信息集合
                log.info("MyAccessDecisionManager ga:{}", ga.getAuthority());
                if(needRole.trim().equals(ga.getAuthority())) {
                    return;
                }
            }
        }
        throw new AccessDeniedException("无权限");
    }

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

    @Override
    public boolean supports(Class<?> aClass) {
        return true;
    }
}
MyFilterSecurityInterceptor类，过滤器，设置后角色权限逻辑通过过滤器启用
@Component
public class MyFilterSecurityInterceptor extends AbstractSecurityInterceptor implements Filter {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private MySecurityMetadataSource mySecurityMetadataSource;

    @Autowired
    private MyAccessDecisionManager myAccessDecisionManager;

    @PostConstruct
    public void setMyAccessDecisionManager() {
        super.setAccessDecisionManager(myAccessDecisionManager);
    }

    @Override
    public Class<?> getSecureObjectClass() {
        return FilterInvocation.class;
    }

    @Override
    public SecurityMetadataSource obtainSecurityMetadataSource() {
        return mySecurityMetadataSource;
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        FilterInvocation fi = new FilterInvocation(request, response, chain);
        invoke(fi);
    }

    public void invoke(FilterInvocation fi) throws IOException, ServletException {
        logger.info("MyFilterSecurityInterceptor {}", fi.getRequest().getRequestURI());
        InterceptorStatusToken token = super.beforeInvocation(fi);
        try {
            fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
        } finally {
            super.afterInvocation(token, null);
        }
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void destroy() {

    }
}

在SecurityConfig中，配置过滤器，启用逻辑

http.addFilterBefore(urlFilterSecurityInterceptor , FilterSecurityInterceptor.class);

二、测试

  1. 启动
  2. 访问路径 http://localhost:8001/getUser，跳转登陆界面
  3. 输入账户密码  admin/123
  4. 显示getUser接口信息

 

用户注册登陆时逻辑

  • SecurityUserService  获取用户名密码以及用户权限

  • MyPasswordEncoder  加密并匹配密码

  • MyFilterSecurityInterceptor  过滤器，设置后角色权限逻辑通过过滤器启用

  • MySecurityMetadataSource  获取路径所需角色

  • MyAccessDecisionManager  用户角色与路径角色是否匹配

代码传送门

参考：https://www.cnblogs.com/softidea/p/7068149.html

迷糊ker
关注
专栏目录
SpringSecurity3.2.5自定义角色及权限的教程
叶落伤城的专栏
12-12 6229
最近阴差阳错的搞上了SpringSecurity3，因为是自己做的小系统，中间遇到了很多坑，基本每个坑都踩过了，网上也查了不少资料，发现有不少错误的，更是让我绕了一圈又一圈，现在把一些基本的东西总结一下。 先从整体上总结一下为什么使用SS，一般的，在不使用ss的情况下，我们基本会在每个业务方法执行前，插入一段用于验证权限的代码，从而判断当前用户是否有相应权限进行操作，这样做就会让业务方法和验证权
springboot或者springsecurity跨域问题 ---简单有效
qq_56263094的博客
05-02 1498
目录 springboot后端配置解决跨域 为什么会出现跨域问题？ 首先一个定义一定要了解，就是浏览器的同源策略 什么是浏览器的同源策略，简单来说就是浏览器发送请求的协议、域名和端口要和服务器接收请求的协议、域名以及端口一致。这样才能完成交互，但是很显然这样是不可能的，尤其在对于在同一台电脑上开发前后端分离的项目的时候，一定是会使用两个端口的。那么这样就形成了跨域问题。 其中有俩种方法解决，一种是在前端配置跨域代理，第二种是后端新建一个配置类 在这里只介绍第一种，因为最为简便 s..
SpringSecurity3.2.5自己定义角色及权限的教程
aoe41606的博客
08-14 178
近期阴差阳错的搞上了SpringSecurity3。由于是自己做的小系统。中间遇到了非常多坑，基本每一个坑都踩过了，网上也查了不少资料，发现有不少错误的。更是让我绕了一圈又一圈，如今把一些主要的东西总结一下。 先从总体上总结一下为什么使用SS，一般的，在不使用ss的情况下，我们基本会在每一个业务方法运行前。插入一段用于验证权限的代码。从而推断当前用户是否有对应权限进行操...
使用 Spring Security 实现角色和权限管理
最新发布
FireFox1997
07-04 583
Spring Security 提供了一套强大且灵活的机制来实现角色和权限的管理。本文将详细介绍如何使用 Spring Security 实现角色和权限管理，从基本概念到具体实现步骤，并提供示例代码来帮助你理解和应用这些概念。Spring Security 提供了强大的功能来处理复杂的权限控制需求，包括角色、权限的定义和分配，以及在应用程序中的细粒度访问控制。配置 Spring Security 以使用自定义的用户详细信息服务，并定义角色和权限。通常，权限是更细粒度的控制，而角色是权限的组合。
SpringSecurity 自定义用户 角色 资源权限控制
weixin_33782386的博客
02-21 139
SpringSecurity 自定义用户 角色 资源权限控制 1 package com.joyen.learning.security; 2 3 import java.sql.ResultSet; 4 import java.sql.SQLException; 5 import java.util.List; 6 7 import o...
spring security3教程系列--自定义权限管理
pan-zy的专栏
09-18 1020
本文章摘编、转载需要注明来源 http://write.blog.csdn.net/postedit/8575062   spring security3中的权限管理虽然有文件可配置,但是很多时候我们是需要数据库的支持,下面我演示下如何配置自定义权限管理,这个时候需要重新实现下面的类, 该文章适合对spring security3 有一定理解的人员 Acces
Spring security4.1.0 自定义角色和权限
伐木累的博客
09-01 3867
文章大纲: 1.spring security 基本配置介绍 2.自定义角色和权限配置 3.跟着源码走一遍页面请求流程
springboot-security-oauth2 权限验证
05-10
总的来说，“springboot-security-oauth2”项目是一个结合了Spring Boot、Spring Security和OAuth2的示例，展示了如何在现代Web应用中实现用户认证、授权以及第三方服务的访问控制，对于学习和实践安全的微服务架构...
基于SpringBoot+SpringSecurity的RBAC管理系统.zip
03-09
通过这个项目，开发者不仅可以学习到SpringBoot和SpringSecurity的基本使用，还能了解到如何将它们结合到实际的RBAC系统中，提升权限管理的效率和安全性。此外，对于熟悉Git版本控制、Maven构建工具的开发者来说，此...
21.Springboot_Security_认证和授权
weixin_46174745的博客
06-03 238
认识SpringSecurity Spring Security 是针对Spring项目的安全框架，也是Spring Boot底层安全模块默认的技术选型，他可以实现强大的Web安全控制，对于安全控制，我们仅需要引入 spring-boot-starter-security 模块，进行少量的配置，即可实现强大的安全管理！ 记住几个类： WebSecurityConfigurerAdapter：自定义Security策略 AuthenticationManagerBuilder：自定义认证策略 @Enable
开发知识点-JAVA-springboot+Spring Security/Shiro
aming小老弟
02-18 609
Spring 还提供了一个名为 Spring Security 的子项目，用于处理应用程序的安全需求。Spring Security 可以与 Shiro 集成，以提供更强大的安全功能。Shiro 提供了一套灵活的安全管理功能，可以处理用户身份验证、访问控制、会话管理等任务。因此，可以说 Shiro 是一个独立的安全框架，而 Spring 平台可以与 Shiro 一起使用来增强应用程序的安全性。Shiro 和 Spring 平台是两个不同的项目，它们可以在一起使用来提供安全认证和授权功能。
spring security 深度定制：自定义角色继承的扩展实现
honlyme的专栏
10-09 358
写在前面：发表之前，特意google了一下，没有找到类似主题，因此，请尊重一下作者的劳动成果，如需转载，请注明作者。   spring security 框架的核心是通过建立用户-&gt;角色-&gt;资源三者的多对多关系来管理用户权限，它的配置非常灵活，但正是这种灵活性给框架的使用者带来了诸多困惑，倒底是该给单一用户分配更多角色还是该把更多资源分配给某个特定角色呢，没有一定之规，我的做法是给...
springboot项目授权许可
qq_43146871的博客
08-24 959
使用smart-license1.0.3，给pringboot请求加载拦截器，用于商业许可授权，软件试用。
SpringBoot -- 软件许可（License）证书生成+验证+应用完整流程
热门推荐
Appleyk的专栏
09-27 14万+
一、项目目录树结构 由于时间有限，不可能在博客上花太多时间、也不可能每一个细节都说的很细，所以，下面的内容虽然一时间看着比较懵，但是文末有项目的GitHub地址，或者不懂的可以留言； 这个是粗糙的项目结构，没有细分，实际应用的话应该是授权的代码要和验证的代码分开，防止授权的代码引进客户端系统中，被破解和拆穿，也为了防止公钥st...
spring boot添加License（软件许可）
MoLi的博客
05-27 1168
工作需要给软件加上许可。
Spring Security教程（8）---- 自定义决策管理器及修改权限前缀
hgffhh的博客
02-12 561
Spring Security教程（8）---- 自定义决策管理器及修改权限前缀
后端进阶之路——浅谈Spring Security用户、角色、权限和访问规则（三）
Why_does_it_work的博客
08-04 4365
通过定义用户、角色、权限和访问规则 可以在SpringSecurity中实现灵活的访问控制和权限管理。可以使用内存方式或数据库方式定义用户，设置用户名、密码和角色等信息。角色可以用来组织和控制权限，可以将一组权限赋予特定角色，并将角色分配给用户。权限是指用户可以执行的特定操作或访问的资源，可以细化到每个功能或数据级别。可以使用Ant风格的路径匹配规则或表达式语言编写更复杂的访问规则，以限制用户对特定路径或功能的访问权限。 通过定义这些元素，可以确保系统的安全性和可靠性。
关于 oauth2 jwt authentication.getPrincipal 获取的是用户名的问题
Firstmetcs的博客
05-06 4901
第一种方案重写转换类(DefaultUserAuthenticationConverter) public Map<String, ?> convertUserAuthentication(Authentication authentication) { Map<String, Object> map = new HashMap<>(1); //继承UserDetails的对象 Object o = authentication.
SpringBoot整合SpringSecurity element 自定义登录页面如何写
08-16
要在SpringBoot中整合SpringSecurity实现自定义登录页面，你可以按照以下步骤进行操作: 1. 首先，确保你的项目中已经引入了Spring Security和OAuth2的相关依赖，可以使用Maven或Gradle进行添加。<span class="em">1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值