spring security 用户角色权限登录配置

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

1.准备数据库表

在这里插入图片描述

/*
 Navicat Premium Data Transfer

 Source Server         : khm1
 Source Server Type    : MySQL
 Source Server Version : 50734
 Source Host           : localhost:3306
 Source Schema         : security

 Target Server Type    : MySQL
 Target Server Version : 50734
 File Encoding         : 65001

 Date: 23/08/2021 10:49:32
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for permission
-- ----------------------------
DROP TABLE IF EXISTS `permission`;
CREATE TABLE `permission`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `pname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of permission
-- ----------------------------
INSERT INTO `permission` VALUES (1, '/admin/**');
INSERT INTO `permission` VALUES (2, '/user/**');
INSERT INTO `permission` VALUES (3, '/dba/**');

-- ----------------------------
-- Table structure for role
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `rname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `rnameZh` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of role
-- ----------------------------
INSERT INTO `role` VALUES (1, 'ROLE_admin', '管理员');
INSERT INTO `role` VALUES (2, 'ROLE_user', '普通用户');
INSERT INTO `role` VALUES (3, 'ROLE_dba', '数据库管理员');

-- ----------------------------
-- Table structure for role_permission
-- ----------------------------
DROP TABLE IF EXISTS `role_permission`;
CREATE TABLE `role_permission`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `rid` int(11) NOT NULL,
  `pid` int(11) NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of role_permission
-- ----------------------------
INSERT INTO `role_permission` VALUES (1, 1, 1);
INSERT INTO `role_permission` VALUES (2, 1, 2);
INSERT INTO `role_permission` VALUES (3, 2, 2);
INSERT INTO `role_permission` VALUES (4, 3, 2);
INSERT INTO `role_permission` VALUES (5, 3, 3);
INSERT INTO `role_permission` VALUES (6, 1, 3);

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `gender` tinyint(1) NOT NULL DEFAULT 1,
  `nonLocked` tinyint(1) NULL DEFAULT 1,
  `enabled` tinyint(1) NULL DEFAULT 1,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'root', '$2a$10$Z7tAYN0UaT6y.Mg40Ir3QOyz78mp/7jjgaV3KRyuMxIMbodtADH8C', 0, 1, 1);
INSERT INTO `user` VALUES (2, 'admin', '$2a$10$Z7tAYN0UaT6y.Mg40Ir3QOyz78mp/7jjgaV3KRyuMxIMbodtADH8C', 1, 1, 1);
INSERT INTO `user` VALUES (3, 'user', '$2a$10$Z7tAYN0UaT6y.Mg40Ir3QOyz78mp/7jjgaV3KRyuMxIMbodtADH8C', 1, 1, 1);

-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `uid` int(11) NOT NULL,
  `rid` int(11) NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user_role
-- ----------------------------
INSERT INTO `user_role` VALUES (1, 1, 1);
INSERT INTO `user_role` VALUES (2, 1, 2);
INSERT INTO `user_role` VALUES (3, 2, 2);
INSERT INTO `user_role` VALUES (4, 3, 2);
INSERT INTO `user_role` VALUES (5, 1, 3);

SET FOREIGN_KEY_CHECKS = 1;

2.配置代码

1.application.properties

server.port=8080

spring.application.name=khm_security

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/security?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&verifyServerCertificate=false&useSSL=false
spring.datasource.username=root
spring.datasource.password=root

logging.level.com.example.spring_security.mapper=debug
2.pom.xml
<?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.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>org.khm</groupId>
    <artifactId>spring_security01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring_security01</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</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.2.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

</project>

3.Java代码

1.SecurityConfig
package org.khm.config;

import org.khm.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.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
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;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    MyFilterInvocationSecurityMetadataSource myFilterInvocationSecurityMetadataSource;
    @Autowired
    MyAccessDecisionManager myAccessDecisionManager;

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

    @Autowired
    UserService userService;

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

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/index","/login");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
//                .antMatchers("/index").permitAll()
                .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {

                    @Override
                    public <O extends FilterSecurityInterceptor> O postProcess(O o) {
                        o.setSecurityMetadataSource(myFilterInvocationSecurityMetadataSource);
                        o.setAccessDecisionManager(myAccessDecisionManager);
                        return o;
                    }
                })
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .loginPage("/login")
                .loginProcessingUrl("/doLogin")
                .successHandler((req, resp, authentication) -> {
                    String username = req.getParameter("username");
                    String password = req.getParameter("password");
                    System.out.println(authentication.getPrincipal());
                    System.out.println(username);
                    System.out.println(password);
                })
                .permitAll()
                .and()
                .csrf().disable();

    }
}
2.MyFilterInvocationSecurityMetadataSource.java
package org.khm.config;

import org.khm.model.Permission;
import org.khm.model.Role;
import org.khm.service.PermissionService;
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;

/**
 * 根据访问接口 返回角色信息
 */
@Component
public class MyFilterInvocationSecurityMetadataSource implements FilterInvocationSecurityMetadataSource {

//    @Autowired
//    AntPathMatcher antPathMatcher;
    @Autowired
    PermissionService permissionService;

    @Override
    public Collection<ConfigAttribute> getAttributes(Object o) throws IllegalArgumentException {
        //获取请求接口
        FilterInvocation filterInvocation = (FilterInvocation) o;
        String requestUrl = filterInvocation.getRequestUrl();

        //查询所有接口和角色对应关系
        List<Permission> permissions = permissionService.getPermissionRoles();
        AntPathMatcher antPathMatcher = new AntPathMatcher();
        //找该接口对应角色
        for (Permission permission : permissions) {
            if (antPathMatcher.match(permission.getPname(), requestUrl)) {
                List<Role> roles = permission.getRoles();
                String[] arr = new String[roles.size()];
                for (int i = 0; i < arr.length; i++) {
                    arr[i]=roles.get(i).getRname();
                }
                return SecurityConfig.createList(arr);
            }
        }
        return SecurityConfig.createList("ROLE_login");
    }

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

    @Override
    public boolean supports(Class<?> aClass) {
        return true;
    }
}
3.MyAccessDecisionManager.java
package org.khm.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;

/**
 * 判断返回角色信息和用户角色信息
 */
@Component
public class MyAccessDecisionManager implements AccessDecisionManager {
    @Override
    public void decide(Authentication authentication, Object o, Collection<ConfigAttribute> collection) throws AccessDeniedException, InsufficientAuthenticationException {
        for (ConfigAttribute configAttribute : collection) {
            String attribute = configAttribute.getAttribute();
            if ("ROLE_login".equals(attribute)) {
                //判断是否登录
                if (authentication instanceof AnonymousAuthenticationToken) {
                    throw new AccessDeniedException("用户未登录");
                }
                return;
            }

            //对比角色权限和接口权限
            Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
            for (GrantedAuthority authority : authorities) {
                if (authority.getAuthority().equals(attribute)) {
                    return;
                }
            }
        }
        throw new AccessDeniedException("权限不足");
    }

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

    @Override
    public boolean supports(Class<?> aClass) {
        return true;
    }
}
4.PermissionService.java
package org.khm.service;

import org.khm.mapper.PermissionMapper;
import org.khm.model.Permission;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Transactional
public class PermissionService {
    @Autowired
    PermissionMapper permissionMapper;
    public List<Permission> getPermissionRoles() {
        return permissionMapper.getPermissionRoles();
    }
}
5.UserService.java
package org.khm.service;

import org.khm.mapper.UserMapper;
import org.khm.model.Role;
import org.khm.model.User;
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;

import java.util.List;

@Service
public class UserService implements UserDetailsService {
    @Autowired
    UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userMapper.findUserByUserName(username);
        if (user == null) {
            throw new UsernameNotFoundException("没有此用户");
        }
        List<Role> roles = userMapper.findRoleByUserId(user.getId());
        user.setRoles(roles);
        return user;
    }
}
6.PermissionMapper
package org.khm.mapper;

import org.khm.model.Permission;

import java.util.List;

public interface PermissionMapper {
    //查询所有接口角色信息
    List<Permission> getPermissionRoles();
}


<?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="org.khm.mapper.PermissionMapper">
    <resultMap id="BaseResultMap" type="org.khm.model.Permission">
        <id column="pid" property="id"></id>
        <result column="pname" property="pname"></result>
        <collection property="roles" ofType="org.khm.model.Role">
            <id column="rid" property="id"></id>
            <result column="rname" property="rname"></result>
            <result column="rnameZh" property="rnameZh"></result>
        </collection>
    </resultMap>
    <select id="getPermissionRoles" resultMap="BaseResultMap">
        select p.id as pid, pname, r.id as rid, rname, rnameZh
        from role r
                 join role_permission rp
                      on r.id = rp.rid
                 join permission p
                      on rp.pid = p.id
    </select>
</mapper>
7.UserMapper
package org.khm.mapper;

import org.khm.model.Role;
import org.khm.model.User;

import java.util.List;

public interface UserMapper {

    User findUserByUserName(String username);

    List<Role> findRoleByUserId(Integer id);
}


<?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="org.khm.mapper.UserMapper">
    <select id="findUserByUserName" resultType="org.khm.model.User">
        select *
        from user
        where username = #{username}
    </select>

    <select id="findRoleByUserId" resultType="org.khm.model.Role">
        select *
        from role
        where id in (select rid from user_role where uid = #{id})
    </select>
</mapper>
8.Controller.java
package org.khm.controller;

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

@RestController
public class UserController {
    @RequestMapping("/home")
    public String hello() {
        return "HOME";
    }

    @RequestMapping("/index")
    public String index() {
        return "首页";
    }

    @RequestMapping("/login")
    public String login() {
        return "请登录";
    }

    @RequestMapping("/doLogin")
    public String loginUser() {
        return "你好";
    }

    @RequestMapping("/admin/hello")
    public String loginAdmin() {
        return "你好,管理员";
    }

    @RequestMapping("/user/hello")
    public String loginPerson() {
        return "你好,用户";
    }

    @RequestMapping("/dba/hello")
    public String loginDBA() {
        return "你好,DBA";
    }
}
康梓潼
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringSecurity、RBAC角色权限控制
user__kk的博客
09-12 1131
RBAC 全称为用户角色权限控制，通过角色关联用户，角色关联权限，这种方式，间阶的赋予用户的权限。对于通常的系统而言，存在多个用户具有相同的权限，在分配的时候，要为指定的用户分配相关的权限，修改的时候也要依次的对这几个用户的权限进行修改，有了角色这个权限，在修改权限的时候，只需要对角色进行修改，就可以实现相关的权限的修改。这样做增加了效率，减少了权限漏洞的发生。权限是资源的集合，这里的资源指的是软件中的所有的内容，即，对页面的操作权限，对页面的访问权限，对数据的增删查改的权限。
SpringSecurity动态加载用户角色权限实现登录及鉴权功能
08-25
Spring Security 动态加载用户角色权限实现登录及鉴权功能 在 Spring Security 中，动态加载用户角色权限是实现登录及鉴权功能的关键步骤。本文将详细介绍如何使用 Spring Security 实现动态加载用户角色权限，并...
使用 Spring Security 实现角色和权限管理
FireFox1997
07-04 315
Spring Security 提供了一套强大且灵活的机制来实现角色和权限的管理。本文将详细介绍如何使用 Spring Security 实现角色和权限管理，从基本概念到具体实现步骤，并提供示例代码来帮助你理解和应用这些概念。Spring Security 提供了强大的功能来处理复杂的权限控制需求，包括角色、权限的定义和分配，以及在应用程序中的细粒度访问控制。配置 Spring Security 以使用自定义的用户详细信息服务，并定义角色和权限。通常，权限是更细粒度的控制，而角色是权限的组合。
SpringSecurity——Web权限方案用户授权（基于角色访问控制）
程序员阿皓的博客
04-27 630
SpringSecurity——Web权限方案用户授权（基于角色访问控制）
SpringSecurity实现角色权限控制（SpringBoot+SpringSecurity+JWT）
lans_g的博客
05-14 6796
通过springboot整合jwt和security，以用户名/密码的方式进行认证和授权。认证通过jwt+数据库的，授权这里使用了两种方式，分别是SpringSecurity自带的hasRole方法+SecurityConfig和 我们自定义的permission+@PreAuthorize注解。用来存储和获取当前线程关联的 SecurityContext 对象的类。
【Spring Security系列】基于Spring Security实现权限动态分配之用户-角色分配
c18213590220的博客
12-27 1532
本文将介绍基于Spring Security实现安全框架中角色动态分配的功能。
SpringSecurity动态加载用户角色权限实现登录及鉴权
wh柒八九的博客
10-12 1414
本文来说下SpringSecurity如何动态加载用户角色权限实现登录及鉴权 文章目录概述 概述 很多人觉得Spring Security实现登录验证很难，我最开始学习的时候也这样觉得。因为我好久都没看懂我该怎么样将自己写的用于接收用户名密码的Controller与Spring Security结合使用，这是一个先入为主的误区。后来我搞懂了：根本不用你自己去写Controller。你只需要告诉Spring Security用户信息、角色信息、权限信息、登录页是什么？登陆成功页是什么？或者其他有关登录的.
在 Spring Security中授予权限与角色
allway2的博客
11-20 1651
当然，这是一种非常简单的方法，可以在开发过程中与一些初步测试用户一起开始运行 - 而不是您应该在生产中处理数据的方式。重点是 - 我们保留了我们在代码中使用的权限。Spring 安全框架没有就我们应该如何使用这个概念提供任何指导，所以选择完全是特定于实现的。这是一种更高层次的角色方法，使它们成为更面向业务的概念，而不是以实施为中心的概念。现在我们更好地理解了核心概念，让我们谈谈在应用程序启动时创建一些设置数据。前缀是可配置的，但解释如何做到这一点超出了本文的范围。这样的表达式，我们以粗粒度的方式限制访问。
SpringBoot整合Spring Security实现用户角色验证以及权限控制
爱吃鸡腿的明仔
01-14 6090
文章目录一。Spring Security介绍二。工程搭建1.工程结构图：2.导入依赖3.编写security配置类4.编写UserDetailsService验证类5.Dao层6.model层7.控制器层8.工具类9.配置文件10.jsp示例登录页面11.启动类三。数据库结构t_user（用户表）t_role（角色表）t_permission（权限表）t_user_role（用户角色表）t_permission（角色权限表）四。测试1.用户登录验证2.用户权限验证五。项目地址 一。Spring Secu
Spring Security对用户权限进行管理
theVicTory的博客
11-03 2407
基于角色的访问控制 隐式访问控制：根据用户的角色判断是否具有某项操作 显示访问控制：为用户分配某种权限，根据权限判断是否可以进行某种操作。与具体角色无关，权限控制更加灵活 认证（ authentication )：是建立主体（ principal) 的过程。"主体"不仅指用户，还可以是其他执行操作的系统或设备。 授权（authorization )：或称为"访问控制（access-control), 是指决定是否允许主体在应用程序中执行操作 Spring Security是Spring中常用的安全服务框架，
SpringBoot + SpringSecurity + JPA 实现用户角色权限登录认证
09-10
在这个项目中，SpringSecurity被用来处理用户登录、角色权限分配和防止非法请求。 3. **JPA**：Java Persistence API是Java平台上的ORM（对象关系映射）规范，它允许开发者以面向对象的方式操作数据库，将数据对象...
Spring security实现登陆和权限角色控制
09-09
通过以上步骤，你已经配置了Spring Security来处理登录、权限和角色控制。当用户尝试访问受保护的资源时，Spring Security会自动重定向到登录页面。登录成功后，它会根据用户的角色决定是否允许访问请求的资源。同时...
springsecurity轻松实现角色权限的示例代码
08-19
在Spring Security中，我们可以使用角色权限来控制用户的访问权限。我们可以创建一个Role实体类，定义了角色名称和描述信息。 ```java @Entity public class Role { @Id @GeneratedValue(strategy = ...
springsecurity角色和权限
12-13
在Spring Security中，"角色"是赋予用户的标识，表示用户在系统中的职责或权限集合。例如，"管理员"、"用户"等。"权限"则更加具体，代表用户可以执行的操作，如"查看报告"、"编辑内容"等。角色通常包含一组权限，...
Spring Boot组成的分布式系统中实现日志跟踪
最新发布
心猿意码
07-25 431
除了使用Sleuth和Zipkin之外，我们还可以自定义日志输出格式，以便更容易地识别请求的追踪信息。Xml深色版本1通过使用Spring Cloud Sleuth和Zipkin，我们可以轻松地为Spring Boot应用实现日志跟踪。这种方式不仅简化了日志跟踪的实现，还提供了强大的可视化工具，帮助我们更好地理解和调试分布式系统。此外，通过自定义日志输出格式和使用MDC，我们可以进一步定制日志以适应特定的需求。
Spring boot 2.0 升级到 3.3.1 的相关问题 （六）
飞一站的博客
07-24 806
解决Spring boot 2.0 升级到3.3.1 版本的`BeanPostProcessor`警告问题。
Spring Boot 配置文件
m0_60963435的博客
07-23 1384
T04BF👋专栏:🫵 今天你敲代码了吗。
Spring Boot 项目中使用事件发布和监听来实现消息推送和处理
servepeople的博客
07-23 573
首先，定义一个事件类，该类继承自import org} }} }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

康梓潼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值