Spring Security学习总结

àì夳堔傛蜴生んèń 2022-04-18 05:50 142阅读 0赞

关于设计模式的文章在公众号上面已经更新完了，感兴趣的小伙伴可以关注公众号每天学Java随时查看！

学习Spring Security是在一个客户的项目上看到客户在自己项目上使用Spring Security，当时很好奇这么框架是干嘛的，就私下问了他们的技术人员：Security是做什么的。他大致的意思是说，Security是一个提供安全权限控制的框架，利用这个框架可以为系统中的人员定制相关的权限，实现无权的拦截。

所以我就私下学习一下这个框架，个人觉得还不错（一开始就使用前后端分离，利用jquery的ajax进行访问接口）.

GitHub地址：[https://github.com/xynuSuMu/SpringSecurity.git][https_github.com_xynuSuMu_SpringSecurity.git]

学习这个框架的时候我觉得最主要是要明白HttpSecurity这个类，他是允许为特定的http请求配置基于web的安全性。默认情况下，它将应用于所有请求，但是可以使用requestMatcher(requestMatcher)或其他类似的方法进行限制。换句话说，就是通过这个HttpSecurity这个类我们对于HTTP请求进行控制，比如说是否拦截。

这个类的所有方法可以去[查看官方文档][Link 1]，我这里主要说几个我用到的：

<table> 
 <tbody> 
  <tr> 
   <td>&nbsp;addFilterBefore(javax.servlet.Filter filter, java.lang.Class&lt;? extends javax.servlet.Filter&gt; beforeFilter)</td> 
   <td>在已知的过滤器类之前添加过滤器。</td> 
  </tr> 
  <tr> 
   <td>&nbsp;antMatcher(java.lang.String antPattern)</td> 
   <td>只有匹配提供的路径时调用配置的HttpSecurity。</td> 
  </tr> 
  <tr> 
   <td>authorizeRequests()</td> 
   <td>允许使用HttpServletRequest限制访问，在他的后面我们会通过antMatcher增加一些请求路径的过滤。或者使用anyRequest()</td> 
  </tr> 
  <tr> 
   <td>cors()</td> 
   <td>添加要使用的CorsFilter。也就是允许跨域</td> 
  </tr> 
  <tr> 
   <td>csrf()</td> 
   <td>添加CSRF的支持。</td> 
  </tr> 
  <tr> 
   <td>formLogin()</td> 
   <td>指定支持基于表单的身份验证。</td> 
  </tr> 
  <tr> 
   <td>sessionManagement()</td> 
   <td>配置会话管理。</td> 
  </tr> 
 </tbody> 
</table>

然后就是WebSecurityConfigurerAdapter这个类，它为创建WebSecurityConfigurer实例提供了一个方便的基类。该实现允许通过覆盖方法进行定制。看下面的代码：我们继承这个类，重写他的config方法（三个config方法参数不同），我们主要看参数是HttpSecurity的这个方法，具体的可以看一下注解。

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        @Autowired
        private EntryPoint entryPoint;
        @Autowired
        private JwtAjaxFilter jwtAjaxFilter;
        @Autowired
        private MyUserService myUserService;
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                    //我的项目是使用Ajax访问接口，所以这里取消Session。
                    .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                    .and()
                    //httpBasic返回HttpBasicConfigurer对象，
                    //HttpBasicConfigurer对象的authenticationEntryPoint方法是在身份验证失败时，将触发AuthenticationEntryPoint类commence方法
                    .httpBasic().authenticationEntryPoint(entryPoint)//登陆失败执行的接口
                    .and()
                    //authorizeRequests返回ExpressionUrlAuthorizationConfigurer对象，.anyRequest().access会去进行URL映射使得
                    .authorizeRequests().anyRequest().access("@rbacauthorityservice.hasPermission(request,authentication)")//角色资源
                    .and()
                    //这个URL比较特殊， Security自带无需定义
                    .formLogin().loginPage("/login")
                    //登录成功触发
                    .successHandler(new AuthenticationSuccessHandler() {
                        @Override
                        public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
                            System.out.println("登录成功");
                            AjaxResponseBody responseBody = new AjaxResponseBody();
                            responseBody.setStatus("200");
                            responseBody.setMsg("Login Success!");
                            UserVO userVO = (UserVO) authentication.getPrincipal();
                            //生成Token
                            String JWT = JwtUtil.generateToken(userVO.getUsername(), 30000);
                            responseBody.setJwtToken(JWT);
    
                            httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
                            httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS, HEAD");
                            httpServletResponse.getWriter().write(JSON.toJSONString(responseBody));
                        }
                    })
                    //登录成功触发
                    .failureHandler(new AuthenticationFailureHandler() {
                        @Override
                        public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
                            System.out.println("登录失败");
                            AjaxResponseBody responseBody = new AjaxResponseBody();
                            responseBody.setStatus("400");
                            responseBody.setMsg("Login Failure!");
                            httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
                            httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS, HEAD");
    
                            httpServletResponse.getWriter().write(JSON.toJSONString(responseBody));
                        }
                    })
                    .permitAll()
                    .and()
                    .cors()
                    .and()
                    .csrf().disable();//允许跨域
            //403
            http.exceptionHandling().accessDeniedHandler(new AccessDeniedHandler() {
                @Override
                public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
                    System.out.println("没有权限");
                    AjaxResponseBody responseBody = new AjaxResponseBody();
                    responseBody.setStatus("403");
                    responseBody.setMsg("need Authorities!");
                    httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
                    httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS, HEAD");
    
                    httpServletResponse.getWriter().write(JSON.toJSONString(responseBody));
                }
            });
            //拦截
            http.addFilterBefore(jwtAjaxFilter, UsernamePasswordAuthenticationFilter.class);
            // 禁用缓存
            http.headers().cacheControl();
        }
    
        //自定义认证方式
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
            auth.userDetailsService(myUserService).passwordEncoder(new BCryptPasswordEncoder());
        }
    }

上面的代码刚开始让我最为难的地方，因为在博客找的案例完全看不懂，后来没有办法，根据HttpSecurity这个参数一点点去向下研究，于是大致明白Spring Boot结合Spring Security的项目中WebSecurityConfigurerAdapter是配置的关键，但是HttpSecurity是关键中关键，通过它我们会牵扯出很多类出来，就像上面的代码一样。下面具体来说明一下自己学习的经过：

首先是通过IDEA新建一个Spring Security应用。

当应用加载完成之后我们就启动它，我们会发现在控制台中出现一行密码

使用浏览器访问127.0.0.1:8080的时候会默认到登录界面，这个登录界面是应用自带的，我们输入user和控制台的密码就登录成功了。（上面的步骤在公众号文章中配有图，可关注查看）

这个时候应用就算是跑起来了，但是这个时候的登录是使用框架自带的并非我们自定义登录验证的。

这是我遇到的第一个问题：如何实现自定义登录验证

由于Spring Security自带的有认证方式，所以如果我们使用这个框架，我们肯定要重写这些认证方式，最终我们得知UserDetails，UserDetailsService类是进行人员角色认证的。所以我们要实现这两个类：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxNDQyMjcwNjM2_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxNDQyMjcwNjM2_size_16_color_FFFFFF_t_70 1][]

然后我们再配合 WebSecurityConfigurerAdapter的自定义子类成功的实现了用户登录(代码在最上面)，但是后续我就发现一个问题：在我登录成功之后，我访问数据接口的时候仍然会报错，因为请求被拦截了，其实很好理解：因为前后端分离，每一次请求都是无状态的，服务端无法通过Session获取我的用户信息，怎么办呢？Token处理。思路如下：

在我们登录请求/login这个接口的时候服务端是不会进行拦截的，所以我们首先利用这个接口登录，但是不同的是，我们在登录成功后要返回一个Token，这个Token存储的有用户信息。如下代码，通过JwTUtil生成字符串，这里我是使用网上的代码，我们自己可以通过JDK生成jks文件，然后进行RSA方式加密用户信息。（当然我们还要引用JWT的依赖）

//登录成功触发
                    .successHandler(new AuthenticationSuccessHandler() {
                        @Override
                        public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
                            System.out.println("登录成功");
                            AjaxResponseBody responseBody = new AjaxResponseBody();
                            responseBody.setStatus("200");
                            responseBody.setMsg("Login Success!");
                            UserVO userVO = (UserVO) authentication.getPrincipal();
                            //生成Token,有效时常3分钟
                            String JWT = JwtUtil.generateToken(userVO.getUsername(), 30000);
                            responseBody.setJwtToken(JWT);
    
                            httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
                            httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS, HEAD");
                            httpServletResponse.getWriter().write(JSON.toJSONString(responseBody));
                        }
                    })

然后Ajax会接收到这个Token。然后我们将Token保存到sessionStorage中，在下一次我们访问非login接口时，我们header中要携带Token，但是问题又来了，服务端如何拿到这个Token呢？虽然Spring Boot拦截器可以实现，但是Spring Security该怎么办？我们在最开始说HttpSecurity的时候又这个方法addFilterBefore，我们可以通过它增加一个拦截器在Security自己的拦截器之前执行，然后在这里面进行判断Token是否合法或者是否登录。具体代码如下：

@Component
    public class JwtAjaxFilter extends OncePerRequestFilter {
    
        @Autowired
        private MyUserService myUserService;
    
        @Override
        protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
            String authHeader = httpServletRequest.getHeader("Authorization");
            System.out.println(authHeader);
            if (authHeader != null && authHeader.startsWith("Bearer ")) {
                System.out.println("获取Bearer");
                final String openId = authHeader.substring("Bearer ".length());
                String username = JwtUtil.parseToken(openId);
                System.out.println("username==="+username);
                if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                    System.out.println("userName=" + username);
                    UserDetails userDetails = myUserService.loadUserByUsername(username);
                    if (userDetails != null) {
                        UsernamePasswordAuthenticationToken authentication =
                                new UsernamePasswordAuthenticationToken(userDetails, userDetails.getPassword(), userDetails.getAuthorities());
                        authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpServletRequest));
                        SecurityContextHolder.getContext().setAuthentication(authentication);
                    }
                }
            }
            System.out.println(1);
            filterChain.doFilter(httpServletRequest, httpServletResponse);
        }
    }

到这里我们基本上就实现了前后端分离的形式来达成安全访问。但是权限控制好像没有体现到。怎么做呢？

.authorizeRequests().anyRequest().access("@rbacauthorityservice.hasPermission(request,authentication)")//角色资源

在我的配置代码中有上面这么一行代码。这里实现了URL和角色的关联，更具体的实现就看下面的代码

@Component("rbacauthorityservice")
    public class RbacAuthorityService {
        public boolean hasPermission(HttpServletRequest request, Authentication authentication) {
    
            //得到的principal的信息
            Object o = authentication.getPrincipal();
            //默认是未授权角色
            boolean hasPermission = false;
            //获得的对象是否实现UserDetails
            if (o instanceof UserDetails) {
                //取得用户名
                String userName = ((UserDetails) o).getUsername();
                // Authentication是一个接口，用来表示用户认证信息的
                Collection<? extends GrantedAuthority> authorities = ((UserDetails) o).getAuthorities();
                Iterator<? extends GrantedAuthority> iterator = authorities.iterator();
                for (GrantedAuthority authority : authorities) {
                    //输出角色
                    System.out.println(authentication.getAuthorities());
                    //管理员角色
                    if (authority.getAuthority().equals("ROLE_ADMIN")) {
                        //管理员可以访问的URL
                        Set<String> urls = new HashSet();
                        urls.add("/sys/**");
                        urls.add("/test/**");
                        //AntPathMatcher用来做类URLs字符串匹配
                        AntPathMatcher antPathMatcher = new AntPathMatcher();
                        for (String url : urls) {
                            if (antPathMatcher.match(url, request.getRequestURI())) {
                                hasPermission = true;
                                break;
                            }
                        }
    
                    }
                }
                //普通用户可以访问的URL
                Set<String> urls = new HashSet();
                urls.add("/test/**");
                urls.add("/pay/**");
                AntPathMatcher antPathMatcher = new AntPathMatcher();
                for (String url : urls) {
                    if (antPathMatcher.match(url, request.getRequestURI())) {
                        hasPermission = true;
                        break;
                    }
                }
                return hasPermission;
            }
            return hasPermission;
        }
    }

更多文章请关注公众号：每天学Java。想获得更多最新面试提醒请进入小程序：每天学Java

公众号二维码：                                                                                          小程序二维码：

![70][]                       ![70 1][]

[https_github.com_xynuSuMu_SpringSecurity.git]: https://github.com/xynuSuMu/SpringSecurity.git
[Link 1]: https://docs.spring.io/spring-security/site/docs/5.0.0.M3/api/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxNDQyMjcwNjM2_size_16_color_FFFFFF_t_70]: /images/20220418/0220688804d1419ba9f12d0044fcfdd9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxNDQyMjcwNjM2_size_16_color_FFFFFF_t_70 1]: /images/20220418/dfab8541f60644c2a989e8aba0348636.png
[70]: https://img-blog.csdn.net/20180821214620778?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxNDQyMjcwNjM2/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 1]: /images/20220418/3b9e9a64d6a4460bb4982b25f3e6ba20.png