• SpringBoot整合Spring Security【超详细教程】


    好好学习,天天向上

    本文已收录至我的Github仓库DayDayUP:github.com/Lee/DayDayUP,欢迎Star,更多文章请前往:目录导航

    前言

    Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。提供了完善的认证机制和方法级的授权功能。是一款非常优秀的权限管理框架。它的核心是一组过滤器链,不同的功能经由不同的过滤器。这篇文章就是想通过一个小案例将Spring Security整合到SpringBoot中去。要实现的功能就是在认证服务器上登录,然后获取Token,再访问资源服务器中的资源。

    基本概念

    • 单点登录

    什么叫做单点登录呢。就是在一个多应用系统中,只要在其中一个系统上登录之后,不需要在其它系统上登录也可以访问其内容。举个例子,京东那么复杂的系统肯定不会是单体结构,必然是微服务架构,比如订单功能是一个系统,交易是一个系统…那么我在下订单的时候登录了,付钱难道还需要再登录一次吗,如果是这样,用户体验也太差了吧。实现的流程就是我在下单的时候系统发现我没登录就让我登录,登录完了之后系统返回给我一个Token,就类似于身份证的东西;然后我想去付钱的时候就把Token再传到交易系统中,然后交易系统验证一下Token就知道是谁了,就不需要再让我登录一次。

    • JWT

    上面提到的Token就是JWT(JSON Web Token),是一种用于通信双方之间传递安全信息的简洁的、URL安全的表述性声明规范。一个JWT实际上就是一个字符串,它由三部分组成,头部、载荷与签名。为了能够直观的看到JWT的结构,我画了一张思维导图:

    最终生成的JWT令牌就是下面这样,有三部分,用 . 分隔。

    base64UrlEncode(JWT 头)+“.”+base64UrlEncode(载荷)+“.”+HMACSHA256(base64UrlEncode(JWT 头) + “.” + base64UrlEncode(有效载荷),密钥)

    eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

    • RSA

    从上面的例子中可以看出,JWT在加密解密的时候都用到了同一个密钥 “ robod666 ”,这将会带来一个弊端,如果被黑客知道了密钥的内容,那么他就可以去伪造Token了。所以为了安全,我们可以使用非对称加密算法RSA

    RSA的基本原理有两点:

    • 私钥加密,持有私钥或公钥才可以解密
    • 公钥加密,持有私钥才可解密

    认证服务器用户登录功能

    前期准备

    介绍完了基本概念之后就可以开始整合了,受限于篇幅,只贴最核心的代码,其它内容请小伙伴们去源码中找,地址在文末。 首先需要准备好数据库:

    -- ----------------------------
    -- Table structure for sys_role
    -- ----------------------------
    DROP TABLE IF EXISTS `sys_role`;
    CREATE TABLE `sys_role`  (
      `ID` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
      `ROLE_NAME` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色名称',
      `ROLE_DESC` varchar(60) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色描述',
      PRIMARY KEY (`ID`) USING BTREE
    ) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
    
    -- ----------------------------
    -- Records of sys_role
    -- ----------------------------
    INSERT INTO `sys_role` VALUES (1, 'ROLE_USER', '基本角色');
    INSERT INTO `sys_role` VALUES (2, 'ROLE_ADMIN', '超级管理员');
    INSERT INTO `sys_role` VALUES (3, 'ROLE_PRODUCT', '管理产品');
    INSERT INTO `sys_role` VALUES (4, 'ROLE_ORDER', '管理订单');
    
    -- ----------------------------
    -- Table structure for sys_user
    -- ----------------------------
    DROP TABLE IF EXISTS `sys_user`;
    CREATE TABLE `sys_user`  (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户名称',
      `password` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '密码',
      `status` int(1) NULL DEFAULT 1 COMMENT '1开启0关闭',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
    
    -- ----------------------------
    -- Records of sys_user
    -- ----------------------------
    INSERT INTO `sys_user` VALUES (1, 'xiaoming', '$2a$10$CYX9OMv0yO8wR8rE19N2fOaXDJondci5uR68k2eQJm50q8ESsDMlC', 1);
    INSERT INTO `sys_user` VALUES (2, 'xiaoma', '$2a$10$CYX9OMv0yO8wR8rE19N2fOaXDJondci5uR68k2eQJm50q8ESsDMlC', 1);
    
    -- ----------------------------
    -- Table structure for sys_user_role
    -- ----------------------------
    DROP TABLE IF EXISTS `sys_user_role`;
    CREATE TABLE `sys_user_role`  (
      `UID` int(11) NOT NULL COMMENT '用户编号',
      `RID` int(11) NOT NULL COMMENT '角色编号',
      PRIMARY KEY (`UID`, `RID`) USING BTREE,
      INDEX `FK_Reference_10`(`RID`) USING BTREE,
      CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `sys_role` (`ID`) ON DELETE RESTRICT ON UPDATE RESTRICT,
      CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `sys_user` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
    
    -- ----------------------------
    -- Records of sys_user_role
    -- ----------------------------
    INSERT INTO `sys_user_role` VALUES (1, 1);
    INSERT INTO `sys_user_role` VALUES (2, 1);
    INSERT INTO `sys_user_role` VALUES (1, 3);
    INSERT INTO `sys_user_role` VALUES (2, 4);
    
    SET FOREIGN_KEY_CHECKS = 1;
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    一共三张表,分别是用户表,角色表,用户-角色表。用户是登录用的,密码其实就是加密过的字符串,内容是“ 123 ”;角色是做权限控制时用的。

    然后创建一个空的父工程SpringSecurityDemo,然后在父工程里面创建一个Module作为认证服务,名叫authentication_server。添加必要的依赖。(内容较占篇幅,有需要的去源码中获取,源码地址见文末)。

    项目的配置文件内容截取了核心的部分贴在下面:

    …………
    # 配置了公钥和私钥的位置
    rsa:
      key:
        pubKeyPath: C:Users
    obodDesktopauth_keyid_key_rsa.pub
        priKeyPath: C:Users
    obodDesktopauth_keyid_key_rsa
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    最后的公私钥的标签是自定义的,并不是Spring提供的标签,后面我们会在RSA的配置类中去加载这一部分内容。

    为了方便起见,我们还可以准备几个工具类(内容较占篇幅,有需要的去源码中获取,源码地址见文末):

    • JsonUtils:提供了json相关的一些操作;
    • JwtUtils:生成token以及校验token相关方法;
    • RsaUtils:生成公钥私钥文件,以及从文件中读取公钥私钥。

    我们可以将载荷单独封装成一个对象:

    @Data
    public class Payload {
        private String id;
        private T userInfo;
        private Date expiration;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    现在再去写一个测试类,调用RsaUtils中的相应方法去生成公钥和私钥。那公钥私钥生成好了在使用的时候是怎么获取的呢?为了解决这个问题,我们需要创建一个RSA的配置类,

    @Data
    @ConfigurationProperties("rsa.key")     //指定配置文件的key
    public class RsaKeyProperties {
    
        private String pubKeyPath;
    
        private String priKeyPath;
    
        private PublicKey publicKey;
        private PrivateKey privateKey;
    
        @PostConstruct
        public void createKey() throws Exception {
            this.publicKey = RsaUtils.getPublicKey(pubKeyPath);
            this.privateKey = RsaUtils.getPrivateKey(priKeyPath);
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    首先我们使用了**@ConfigurationProperties**注解去指定公钥私钥路径的key,然后在构造方法中就可以去获取到公钥私钥的内容了。这样在需要公钥私钥的时候就可以直接调用这个类了。但是不放入Spring容器中怎么调用这个类,所以在启动类中添加一个注解:

    @EnableConfigurationProperties(RsaKeyProperties.class) 
    
    • 1

    这表示把RSA的配置类放入Spring容器中。

    用户登录

    在实现用户登录的功能之前,先说一下登录的相关内容。关于登录流程我在网上看了篇文章感觉挺好的,贴出来给小伙伴们看看:

    https://www.jianshu.com/p/a65f883de0c1

    首先会进入UsernamePasswordAuthenticationFilter并且设置权限为null和是否授权为false,然后进入ProviderManager查找支持UsernamepasswordAuthenticationTokenprovider并且调用provider.authenticate(authentication);再然后就是UserDetailsService接口的实现类(也就是自己真正具体的业务了),这时候都检查过了后,就会回调UsernamePasswordAuthenticationFilter并且设置权限(具体业务所查出的权限)和设置授权为true(因为这时候确实所有关卡都检查过了)。

    在上面这段话中,提到了一个UsernamePasswordAuthenticationFilter,我们一开始进入的就是这个过滤器的attemptAuthentication()方法,但是这个方法是从form表单中获取用户名密码,和我们的需求不符,所以我们需要重写这个方法。然后经过一系列的周转,进入到了UserDetailsService.loadUserByUsername()方法中,所以我们为了实现自己的业务逻辑,需要去实现这个方法。这个方法返回的是一个UserDetails接口对象,如果想返回自定义的对象,可以去实现这个接口。最终用户验证成功之后,调用的是UsernamePasswordAuthenticationFilter的父类AbstractAuthenticationProcessingFilter.successfulAuthentication()方法,我们也需要去重写这个方法去实现我们自己的需求。

    所以现在就来实现一下上面说的这些东西吧

    @Data
    public class SysUser implements UserDetails {
    
        private Integer id;
        private String username;
        private String password;
        private Integer status;
        private List roles = new ArrayList<>();	//SysRole封装了角色信息,和登录无关,我放在后面讲
    
    	//这里还有几个UserDetails中的方法,我就不贴代码了
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    我们自定义了一个SysUser类去实现UserDetails接口,然后添加了几个自定义的字段

    public interface UserService extends UserDetailsService {
    }
    //-----------------------------------------------------------
    @Service("userService")
    public class UserServiceImpl implements UserService {
    	…………
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            SysUser sysUser = userMapper.findByUsername(username);
            return sysUser;
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    在这段代码中,我们先定义了一个接口UserService去继承UserDetailsService,然后用UserServiceImpl实现了UserService,就相当于UserServiceImpl实现了UserDetailsService,这样我们就可以去实现loadUserByUsername()方法,内容很简单,就是用用户名去数据库中查出对应的SysUser,然后具体的验证流程就可以交给其它的过滤器去实现了,我们就不用管了。

    前面提到了需要去重写**attemptAuthentication()successfulAuthentication()**方法,那就自定义一个过滤器去继承UsernamePasswordAuthenticationFilter然后重写这两个方法吧

    public class JwtLoginFilter extends UsernamePasswordAuthenticationFilter {
    
        private AuthenticationManager authenticationManager;
        private RsaKeyProperties rsaKeyProperties;
    
        public JwtLoginFilter(AuthenticationManager authenticationManager, RsaKeyProperties rsaKeyProperties) {
            this.authenticationManager = authenticationManager;
            this.rsaKeyProperties = rsaKeyProperties;
        }
    
        //这个方法是用来去尝试验证用户的
        @Override
        public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
            try {
                SysUser user = JSONObject.parseObject(request.getInputStream(),SysUser.class);
                return authenticationManager.authenticate(
                        new UsernamePasswordAuthenticationToken(
                               user.getUsername(),
                               user.getPassword())
                );
            } catch (Exception e) {
                try {
                    response.setContentType("application/json;charset=utf-8");
                    response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                    PrintWriter out = response.getWriter();
                    Map map = new HashMap<>();
                    map.put("code", HttpServletResponse.SC_UNAUTHORIZED);
                    map.put("message", "账号或密码错误!");
                    out.write(new ObjectMapper().writeValueAsString(map));
                    out.flush();
                    out.close();
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
                throw new RuntimeException(e);
            }
        }
    
        //成功之后执行的方法
        @Override
        public void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
            SysUser sysUser = new SysUser();
            sysUser.setUsername(authResult.getName());
            sysUser.setRoles((List) authResult.getAuthorities());
            String token = JwtUtils.generateTokenExpireInMinutes(sysUser,rsaKeyProperties.getPrivateKey(),24*60);
            response.addHeader("Authorization", "Token " + token);	//将Token信息返回给用户
            try {
                //登录成功时,返回json格式进行提示
                response.setContentType("application/json;charset=utf-8");
                response.setStatus(HttpServletResponse.SC_OK);
                PrintWriter out = response.getWriter();
                Map map = new HashMap(4);
                map.put("code", HttpServletResponse.SC_OK);
                map.put("message", "登陆成功!");
                out.write(new ObjectMapper().writeValueAsString(map));
                out.flush();
                out.close();
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62

    代码的逻辑还是很清晰的,我就不去讲解了。

    现在重点来了,Spring Security怎么知道我们要去调用自己的UserService和自定义的过滤器呢?所以我们需要配置一下,这也是使用Spring Security的一个核心——>配置类

    @Configuration
    @EnableWebSecurity      //这个注解的意思是这个类是Spring Security的配置类
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    	…………
        @Bean
        public BCryptPasswordEncoder passwordEncoder() {
            return new BCryptPasswordEncoder();
        }
    
        //认证用户的来源
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
            auth.userDetailsService(userService).passwordEncoder(passwordEncoder());
        }
    
        //配置SpringSecurity相关信息
        @Override
        public void configure(HttpSecurity http) throws Exception {
            http.csrf().disable()  //关闭csrf
                    .addFilter(new JwtLoginFilter(super.authenticationManager(),rsaKeyProperties))
                    .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);    //禁用session
        }
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    在配置类中,配置了认证用户的来源和添加了自定义的过滤器。这样就可以实现登录的功能了。

    可以看到,现在已经成功登录了,但是这个**/login**是从哪儿来的呢,这个是Spring Security自己提供的,用户名的键必须是”username“,密码的键必须是 ”password“,提交方式必须是POST。

    总结一下,实现登录的功能需要做哪些操作:

    • 认证用户实现UserDetails接口
    • 用户来源的Service实现UserDetailsService接口,实现loadUserByUsername()方法,从数据库中获取数据
    • 实现自己的过滤器继承UsernamePasswordAuthenticationFilter,重写attemptAuthentication()和successfulAuthentication()方法实现自己的逻辑
    • Spring Security的配置类继承自WebSecurityConfigurerAdapter,重写里面的两个config()方法
    • 如果使用RSA非对称加密,就准备好RSA的配置类,然后在启动类中加入注解将其加入IOC容器中

    资源服务器权限校验

    在这一小节,我们要实现去访问资源服务器中的资源,并进行鉴权的操作。在父工程SpringSecirityDemo中再创建一个模块recourse_server。因为我们现在并不需要从数据库中获取用户信息。所以就不需要自己去定义Service和Mapper了。也不需要登录的过滤器了。下面这张目录结构图是资源服务工程所需要的所有东西。

    SysRole上一节中用到了但是没有详细说明。这个类是用来封装角色信息的,做鉴权的时候用的,实现了GrantedAuthority接口:

    @Data
    public class SysRole implements GrantedAuthority {
    
        private Integer id;
        private String roleName;
        private String roleDesc;
    
        /**
         * 如果授予的权限可以当作一个String的话,就可以返回一个String
         * @return
         */
        @JsonIgnore
        @Override
        public String getAuthority() {
            return roleName;
        }
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    里面实现了getAuthority方法,直接返回roleName即可。roleName是角色名。

    客户端将Token传到资源服务器中,服务器需要对Token进行校验并取出其中的载荷信息。所以我们可以自定义一个过滤器继承自BasicAuthenticationFilter,然后重写**doFilterInternal()**方法,实现自己的逻辑。

    public class JwtVerifyFilter extends BasicAuthenticationFilter {
    	…………
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
                throws IOException, ServletException {
            String header = request.getHeader("Authorization");
            //没有登录
            if (header == null || !header.startsWith("Token ")) {
                chain.doFilter(request, response);
                response.setContentType("application/json;charset=utf-8");
                response.setStatus(HttpServletResponse.SC_FORBIDDEN);
                PrintWriter out = response.getWriter();
                Map map = new HashMap(4);
                map.put("code", HttpServletResponse.SC_FORBIDDEN);
                map.put("message", "请登录!");
                out.write(new ObjectMapper().writeValueAsString(map));
                out.flush();
                out.close();
                return;
            }
            //登录之后从token中获取用户信息
            String token = header.replace("Token ","");
            SysUser sysUser = JwtUtils.getInfoFromToken(token, rsaKeyProperties.getPublicKey(), SysUser.class).getUserInfo();
            if (sysUser != null) {
                Authentication authResult = new UsernamePasswordAuthenticationToken
                        (sysUser.getUsername(),null,sysUser.getAuthorities());
                SecurityContextHolder.getContext().setAuthentication(authResult);
                chain.doFilter(request, response);
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    在这段代码中,先是从请求头中获取"Authorization"的值,如果值未null或者不是以我们规定的 “Token ” 开头就说明不是我们设置的Token,就是没登录,提示用户登录。有Token的话就调用JwtUtils.getInfoFromToken()去验证并获取载荷的内容。验证通过的话就在Authentication的构造方法中把角色信息传进去,然后交给其它过滤器去执行即可。

    私钥应该只保存在认证服务器中,所以资源服务器中只要存公钥就可以了。

    …………
    rsa:
      key:
        pubKeyPath: C:Users
    obodDesktopauth_keyid_key_rsa.pub
    
    
    @Data
    @ConfigurationProperties("rsa.key")     //指定配置文件的key
    public class RsaKeyProperties {
    
        private String pubKeyPath;
    
        private PublicKey publicKey;
    
        @PostConstruct
        public void createKey() throws Exception {
            this.publicKey = RsaUtils.getPublicKey(pubKeyPath);
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    接下来就是Spring Security核心的配置文件了

    @Configuration
    @EnableWebSecurity
    @EnableGlobalMethodSecurity(securedEnabled = true)  //开启权限控制的注解支持,securedEnabled表示SpringSecurity内部的权限控制注解开关
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    	…………
        //配置SpringSecurity相关信息
        @Override
        public void configure(HttpSecurity http) throws Exception {
            http.csrf().disable()  //关闭csrf
                    .authorizeRequests()
                    .antMatchers("/**").hasAnyRole("USER") //角色信息
                    .anyRequest()   //其它资源
                    .authenticated()    //表示其它资源认证通过后
                    .and()
                    .addFilter(new JwtVerifyFilter(super.authenticationManager(),rsaKeyProperties))
                    .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);    //禁用session
        }
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    这里面有个注解 @EnableGlobalMethodSecurity(securedEnabled = true),这个注解的意思是开启权限控制的注解支持。然后添加了自定义的Token解析过滤器。最后在需要进行权限控制的方法上添加注解即可

    @RestController
    @RequestMapping("/product")
    public class ProductController {
    
        @Secured("ROLE_PRODUCT")
        @RequestMapping("/findAll")
        public String findAll() {
            return "产品列表查询成功";
        }
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    好了,这样findAll方法就需要有"ROLE_PRODUCT"权限才能访问。我们来测试一下:

    登录成功之后,响应头中有服务器返回的Token信息,把它复制下来,然后添加到我们请求的请求头中。

    可以看到,现在已经成功访问到资源了。再来换个没有权限的用户登录测试一下:

    请求被拒绝了,说明权限控制功能是没有问题的。总结一下步骤:

    • 封装权限信息的类实现GrantedAuthority接口,并实现里面的getAuthority()方法
    • 实现自己的Token校验过滤器继承自BasicAuthenticationFilter,并重写doFilterInternal()方法,实现自己的业务逻辑
    • 编写Spring Security的配置类继承WebSecurityConfigurerAdapter,重写configure()方法添加自定义的过滤器,并添加@EnableGlobalMethodSecurity(securedEnabled = true)注解开启注解权限控制的功能
    • 如果使用RSA非对称加密,就准备好RSA的配置类,然后在启动类中加入注解将其加入IOC容器中,注意这里不要只要配置公钥即可

    总结

    SpringBoot 整合 Spring Security到这里就结束了。文章只是简单的说了一下整合的流程,很多其它的东西都没有说,比如各个过滤器都有什么作用等。还有,这里采用的认证服务器和资源服务器分离的方式,要是集成在一起也是可以的。类似的问题还有很多,小伙伴们就自行研究吧。问了让文章不会太臃肿,很多代码都没有贴出来,有需要的小伙伴可以通过下方的链接进行下载。

    https://gitee.com/Lee/DayDayUP/blob/master/Code/SpringSecurityDemo.zip

    如果我的文章对你有些帮助,不要忘了点赞收藏转发关注。要是有什么好的意见欢迎在下方留言。让我们下期再见!

    先自我介绍一下,小编13年上师交大毕业,曾经在小公司待过,去过华为OPPO等大厂,18年进入阿里,直到现在。深知大多数初中级java工程师,想要升技能,往往是需要自己摸索成长或是报班学习,但对于培训机构动则近万元的学费,着实压力不小。自己不成体系的自学效率很低又漫长,而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家,初衷也很简单,就是希望帮助到想自学又不知道该从何学起的朋友,同时减轻大家的负担。添加下方名片,即可获取全套学习资料哦

  • 相关阅读:
    基于springboot+vue的线上教育系统(源码+论文)
    redis基础与安装
    C++智能指针[下](shared_ptr/weak_ptr/循环引用/删除器)
    水果店圈子:现在开水果店需要什么设备,开水果店所需要的设备有哪些
    Vue 动态加载全局样式css(切换ui主题方案)
    【OpenCV-Python】教程:3-9 轮廓(5)轮廓层级
    JS基础6--逻辑运算符
    Ansible 自动化运维企业实战(一)
    linux安装kafka
    百花齐放:解锁大型语言模型的潜力 | 开源专题 No.32
  • 原文地址:https://blog.csdn.net/m0_67402914/article/details/126115013