1. 简介

1.1 认识SpringSecurity

Spring Security 是 Spring 家族中的一个安全管理框架。相比与另外一个安全框架 Shiro，它提供了更丰富的功能，社区资源也比 Shiro 丰富。一般来说中大型的项目都是使用 SpringSecurity 来做安全框架。小项目有 Shiro 的比较多，因为相比与 SpringSecurity，Shiro 的上手更加的简单。

一般Web应用的需要进行认证和授权。

  • 认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户。
  • 授权：经过认证后判断当前用户是否有权限进行某个操作。

    1.2 引入依赖

    1. <dependency>
    2. <groupId>org.springframework.boot</groupId>
    3. <artifactId>spring-boot-starter-security</artifactId>
    4. </dependency>

    1.3 UserDetailsService

    当什么也没有配置的时候，账号和密码是由 Spring Security 定义生成的。而在实际项目中账号和密码都是从数据库中查询出来的。所以我们要通过自定义逻辑控制认证逻辑。只需要实现 UserDetailsService 接口即可。接口定义如下： ```java public interface UserDetailsService { // 用来判断用户是否存在，从数据库中获取用户信息，返回一个 UserDetails 对象。 // UserDetails 有一个具体实现类 User，上面方法返回的是一个 User 对象。 UserDetails loadUserByUsername(String username) throws UsernameNotFoundException; }

public interface UserDetails extends Serializable { Collection<? extends GrantedAuthority> getAuthorities(); String getPassword(); String getUsername(); boolean isAccountNonExpired(); … }

public class User implements UserDetails, CredentialsContainer { private String password; private final String username; private final Set authorities; private final boolean accountNonExpired; private final boolean accountNonLocked; private final boolean credentialsNonExpired; private final boolean enabled;

  1. // 用户名是前端传递过来的，密码是数据库中查询出来的，Spring Security会根据User中的password和客户端传递过来的password进行比较。如果相

同则表示认证通过，如果不相同表示认证失败。 public User(String username, String password, Collection<? extends GrantedAuthority> authorities) { this(username, password, true, true, true, true, authorities); } }

  1. <a name="Ygigl"></a>
  2. ## 1.4 PasswordEncoder
  3. PassWordEncoder 本质是一个接口，主要对用户密码进行加密及匹配操作，Spring Security 要求容器中必须有 PasswordEncoder 实例。所以当自定义登录逻辑时要求必须给容器注入 PaswordEncoder 的 bean 对象。我们常用的是 BCryptPasswordEncoder 实现类，主要有两个方法，encode 对密码进行盐加密，match 进行密码匹配。
  4. ```java
  5. public class BCryptPasswordEncoder implements PasswordEncoder {
  6.     public String encode(CharSequence rawPassword) {
  7.         if (rawPassword == null) {
  8.             throw new IllegalArgumentException("rawPassword cannot be null");
  9.         }
  11.         String salt;
  12.         if (random != null) {
  13.             salt = BCrypt.gensalt(version.getVersion(), strength, random);
  14.         } else {
  15.             salt = BCrypt.gensalt(version.getVersion(), strength);
  16.         }
  17.         return BCrypt.hashpw(rawPassword.toString(), salt);
  18.     }
  20.     public boolean matches(CharSequence rawPassword, String encodedPassword) {
  21.         if (rawPassword == null) {
  22.             throw new IllegalArgumentException("rawPassword cannot be null");
  23.         }
  25.         if (encodedPassword == null || encodedPassword.length() == 0) {
  26.             logger.warn("Empty encoded password");
  27.             return false;
  28.         }
  30.         if (!BCRYPT_PATTERN.matcher(encodedPassword).matches()) {
  31.             logger.warn("Encoded password does not look like BCrypt");
  32.             return false;
  33.         }
  35.         return BCrypt.checkpw(rawPassword.toString(), encodedPassword);
  36.     }
  37. }

1.5 常用接口图

认证和授权 - 图1

2. 资源管理

2.1 关闭CSRF

  1. // 关闭csrf
  2. http.cors().and().csrf().disable();

2.2 登录、登出、异常处理

  1. // 登入处理
  2. http.formLogin().permitAll()
  3.     .successHandler(authenticationSuccessHandler())
  4.     .failureHandler(authenticationFailureHandler());
  5. // 登出处理
  6. http.logout().permitAll()
  7.     .logoutSuccessHandler(logoutSuccessHandler())
  8.     .deleteCookies("JSESSIONID"); // 登出之后删除cookie
  9. // 异常处理
  10. http.exceptionHandling()
  11.     .accessDeniedHandler(accessDeniedHandler()) //权限拒绝处理逻辑
  12.     .authenticationEntryPoint(authenticationEntryPoint()); // 匿名用户访问无权限资源时的异常处理

2.3 页面访问权限

2.3.1 访问控制URL匹配

  1. http.authorizeRequests().anyRequest().authenticated()：表示匹配所有的请求，一般情况下此方法都会使用，设置全部内容都需要进行认证。
  2. http.authorizeRequests().antMatchers("/js/**","/css/**").permitAll()：不定向参数匹配，一般用来放行静态资源。
  3. http.authorizeRequests().regexMatchers( ".+[.]js").permitAll()：使用正则表达式进行匹配，类似于 .antMatchers。
  4. http.authorizeRequests().mvcMatchers("/demo").servletPath("/yjxxt").permitAll()：适用于配置了 servletPath 的情况，等效于 .antMatchers("/yjxxt/demo").permitAll()

2.3.2 内置访问控制方法

匹配了 URL 后调用了 permitAll() 表示不需要认证，随意访问。在 Spring Security 中提供了多种内置控制。

  1. http.authorizeRequests().anyRequest().permitAll()：表示所匹配的 URL 任何人都允许访问。
  2. http.authorizeRequests().anyRequest().denyAll()：所匹配的 URL 都不允许被访问
  3. http.authorizeRequests().anyRequest().authenticated()：表示所匹配的 URL 都需要被认证才能访问。
  4. http.authorizeRequests().anyRequest().http.authorizeRequests().anyRequest().anonymous(): 表示可以匿名访问匹配的URL。和permitAll()效果类似，只是设置为anonymous()的 url 会执行 filter 链中
  5. http.authorizeRequests().anyRequest().rememberMe()：被“remember me”的用户允许访问。

2.3.3 角色权限判断

  • hasAuthority(String)：判断用户是否具有特定的权限，用户的权限是在自定义登录逻辑中创建 User 对象时指定的。在配置类中通过 hasAuthority(“admin”) 设置具有 admin 权限时才能访问。
  • hasRole(String)：如果用户具备给定角色就允许访问，否则出现 403。参数取值来源于自定义登录逻辑UserDetailsService 实现类中创建 User 对象时给 User 赋予的授权。在给用户赋予角色时角色需要以： ROLE开头 ，后面添加角色名称。例如：ROLE_abc 其中 abc 是角色名，ROLE是固定的字符开头。
  • hasIpAddress(String)：如果请求是指定的 IP 就运行访问，注意的是在本机进行测试时 localhost 和 127.0.0.1 输出的 ip地址是不一样的。 ```java .antMatchers(“/main1.html”).hasAuthority(“admin”) //访问main1.html的用户是否具有admin权限 .antMatchers(“/main1.html”).hasAnyAuthority(“admin”, “adMin”) //具有两个权限中的一个

.antMatchers(“/main1.html”).hasRole(“abc”) //判断用户是否具备当前角色 abc .antMatchers(“/main1.html”).hasIpAddress(“127.0.0.1”) //根据ip地址进行访问

  1. <a name="I8URi"></a>
  2. ### 2.3.4 access方法解读
  3. 前面所使用的 permitAll() 和 hasRole 底层使用的是 access() 方法。<br />![](https://cdn.nlark.com/yuque/0/2021/png/446852/1616419436712-52f090ce-f5c7-4683-b0d1-8a826f596068.png?x-oss-process=image%2Fresize%2Cw_1046%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=rmrai&margin=%5Bobject%20Object%5D&originHeight=170&originWidth=1046&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)<br />案例：判断登录用户是否具有访问当前 URL 权限。
  5. - 接口
  6. ```java
  7. @Service
  8. public class MyServiceImpl implements MyService{
  10.     @Override
  11.     public boolean hasPermission(HttpServletRequest request, Authentication authentication) {
  12.         Object obj = authentication.getPrincipal();
  13.         if (obj instanceof UserDetails){
  14.             UserDetails userDetails = (UserDetails) obj;
  15.             Collection<? extends GrantedAuthority> authorities = userDetails.getAuthorities();
  16.             SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(request.getRequestURI());
  17.             Boolean flag = authorities.contains(simpleGrantedAuthority);
  18.             System.out.println(flag);
  19.             return flag;
  20.         }
  21.         return false;
  22.     }
  23. }

  • 配置类

    1. // 页面访问权限
    2. http.authorizeRequests()
    3.   // 登录页面执行放行
    4.   .antMatchers("/login.html").access("permitAll()")
    5.   .antMatchers("/error.html").access("permitAll()")
    6.   // 其他资源均需登录才可访问
    7.   //.anyRequest().authenticated();
    8.   .anyRequest().access("@myServiceImpl.hasPermission(request, authentication)");

    2.3.5 基于注解权限控制

    通过 @EnableGlobalMethodSecurity(securedEnabled = true)进行开启后使用，控制接口 URL 是否允许被访问。

  • @Secured：判断当前用户是否具有某个角色。

  • @PreAuthorize：表示访问方法或类在执行之前先判断权限，大多情况下都是使用这个注解，注解的参数和 access() 方法参数取值相同，都是权限表达式。

  • @PostAuthorize：表示方法或类执行结束后判断权限，此注解很少被使用到。

    1. @PreAuthorize("hasRole('ROLE_abc')")
    2. @RequestMapping("toMain")
    3. public String main(){
    4.   return "redirect:main.html";
    5. }

    3. 基于Cookie整合

    3.1 引入依赖

    ```xml <?xml version=”1.0” encoding=”UTF-8”?> <project xmlns=”http://maven.apache.org/POM/4.0.0“

    1.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    1.   <artifactId>springsecurity-demo</artifactId>
    2.   <groupId>com.xuwei</groupId>
    3.   <version>1.0-SNAPSHOT</version>

    4.0.0 springboot-security 11 11 com.zaxxer HikariCP org.springframework.boot spring-boot-starter-jdbc org.apache.tomcat tomcat-jdbc com.baomidou mybatis-plus-boot-starter com.baomidou mybatis-plus mysql mysql-connector-java ${mysql.version} org.springframework.boot spring-boot-starter-security ${spring-boot.version} com.alibaba fastjson org.apache.commons commons-lang3 3.12.0 org.projectlombok lombok org.springframework.boot spring-boot-starter org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-test test org.springframework.boot spring-boot-starter-thymeleaf 

  1. <a name="EmthG"></a>
  2. ## 3.2 引入sql文件
  3. [springboot_security.sql](https://www.yuque.com/attachments/yuque/0/2022/sql/446852/1646746353062-f13e6a89-89a5-43dd-b567-d077e3869a18.sql?_lake_card=%7B%22src%22%3A%22https%3A%2F%2Fwww.yuque.com%2Fattachments%2Fyuque%2F0%2F2022%2Fsql%2F446852%2F1646746353062-f13e6a89-89a5-43dd-b567-d077e3869a18.sql%22%2C%22name%22%3A%22springboot_security.sql%22%2C%22size%22%3A7693%2C%22type%22%3A%22%22%2C%22ext%22%3A%22sql%22%2C%22status%22%3A%22done%22%2C%22taskId%22%3A%22u8c3b9e5b-b3bc-4677-94fe-f74087e5753%22%2C%22taskType%22%3A%22transfer%22%2C%22id%22%3A%22fJddj%22%2C%22card%22%3A%22file%22%7D)
  4. <a name="L5M0O"></a>
  5. ## 3.3 配置类
  6. ```java
  7. @Configuration
  8. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  10.     /**
  11.      * 用户认证
  12.      * @return
  13.      */
  14.     @Bean
  15.     public UserDetailsService userDetailsService() {
  16.         // 获取用户账号密码及权限信息
  17.         return new UserDetailsServiceImpl();
  18.     }
  20.     /**
  21.      * 密码加密，多次加密结果是不同的，通过encode加密，matches密码匹配
  22.      * @return
  23.      */
  24.     @Bean
  25.     public BCryptPasswordEncoder passwordEncoder() {
  26.         // 设置默认的加密方式（强hash方式加密）
  27.         return new BCryptPasswordEncoder();
  28.     }
  30.     /**
  31.      * 匿名用户访问无权限资源
  32.      * @return
  33.      */
  34.     @Bean
  35.     public AuthenticationEntryPoint authenticationEntryPoint() {
  36.         return new CustomizeAuthenticationEntryPoint();
  37.     }
  39.     /**
  40.      * 权限拒绝处理器，即没有权限访问返回403
  41.      * @return
  42.      */
  43.     @Bean
  44.     public AccessDeniedHandler accessDeniedHandler() {
  45.         return new CustomizeAccessDeniedHandler();
  46.     }
  48.     @Bean
  49.     public AuthenticationSuccessHandler authenticationSuccessHandler() {
  50.         return new CustomizeAuthenticationSuccessHandler();
  51.     }
  53.     @Bean
  54.     public AuthenticationFailureHandler authenticationFailureHandler() {
  55.         return new CustomizeAuthenticationFailureHandler();
  56.     }
  58.     // 访问决策管理器
  59.     @Autowired
  60.     private CustomizeAccessDecisionManager accessDecisionManager;
  62.     // 设置安全元数据源
  63.     @Autowired
  64.     private CustomizeFilterInvocationSecurityMetadataSource securityMetadataSource;
  66.     // 权限拦截器
  67.     @Autowired
  68.     private CustomizeAbstractSecurityInterceptor securityInterceptor;
  70.     @Bean
  71.     public LogoutSuccessHandler logoutSuccessHandler() {
  72.         return new CustomizeLogoutSuccessHandler();
  73.     }
  75.     @Override
  76.     protected void configure(HttpSecurity http) throws Exception {
  77.         // 关闭csrf
  78.         http.cors().and().csrf().disable();
  80.         // 登入处理
  81.         http.formLogin().permitAll()
  82.             .successHandler(authenticationSuccessHandler())
  83.             .failureHandler(authenticationFailureHandler());
  84.         // 登出处理
  85.         http.logout().permitAll()
  86.             .logoutSuccessHandler(logoutSuccessHandler())
  87.             .deleteCookies("JSESSIONID"); // 登出之后删除cookie
  88.         // 异常处理
  89.         http.exceptionHandling()
  90.             .accessDeniedHandler(accessDeniedHandler()) //权限拒绝处理逻辑
  91.             .authenticationEntryPoint(authenticationEntryPoint()); // 匿名用户访问无权限资源时的异常处理
  92.         // 页面访问权限
  93.         http.authorizeRequests()
  94.                 //.antMatchers("/getUser").hasAuthority("query_user"); // 权限控制，写死的
  95.             .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
  96.                  @Override
  97.                  public <O extends FilterSecurityInterceptor> O postProcess(O o) {
  98.                      o.setAccessDecisionManager(accessDecisionManager);//决策管理器
  99.                      o.setSecurityMetadataSource(securityMetadataSource);//安全元数据源
  100.                      return o;
  101.                  }
  102.              });
  103.         http.authorizeRequests().anyRequest().authenticated();
  104.         http.addFilterBefore(securityInterceptor, FilterSecurityInterceptor.class);
  105.     }
  107.     @Override
  108.     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  109.         // 配置认证方式等
  110.         auth.userDetailsService(userDetailsService());
  111.     }
  112. }

3.4 用户认证逻辑

  1. public class UserDetailsServiceImpl implements UserDetailsService {
  2.     @Autowired
  3.     private SysUserService sysUserService;
  5.     @Autowired
  6.     private SysPermissionService sysPermissionService;
  8.     @Override
  9.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  10.         //需要构造出 org.springframework.security.core.userdetails.User 对象并返回
  11.         if (username == null || "".equals(username)) {
  12.             throw new RuntimeException("用户名不能为空");
  13.         }
  14.         // 根据用户名查找用户
  15.         SysUser sysUser = sysUserService.selectByName(username);
  16.         if (sysUser == null) {
  17.             throw new RuntimeException("用户不存在");
  18.         }
  19.         List<GrantedAuthority> grantedAuthorities = new ArrayList<>();
  20.         if (sysUser != null) {
  21.             //获取该用户所拥有的权限
  22.             List<SysPermission> sysPermissions = sysPermissionService.selectListByUser(sysUser.getId());
  23.             // 声明用户授权
  24.             sysPermissions.forEach(sysPermission -> {
  25.                 GrantedAuthority grantedAuthority = new SimpleGrantedAuthority(sysPermission.getPermissionCode());
  26.                 grantedAuthorities.add(grantedAuthority);
  27.             });
  28.         }
  29.         return new User(sysUser.getAccount(),
  30.                         sysUser.getPassword(),
  31.                         sysUser.getEnabled(),
  32.                         sysUser.getAccountNonExpired(),
  33.                         sysUser.getCredentialsNonExpired(),
  34.                         sysUser.getAccountNonLocked(),
  35.                         grantedAuthorities);
  36.     }
  37. }

3.5 相关处理器（登录成功、失败、登出）

  • 登录成功处理器

    1. public class CustomizeAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
    2.   @Autowired
    3.   private SysUserService sysUserService;
    5.   @Override
    6.   public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
    7.       // 更新用户表上次登录时间、更新人、更新时间等字段
    8.       User userDetails = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    9.       SysUser sysUser = sysUserService.selectByName(userDetails.getUsername());
    10.       sysUser.setLastLoginTime(new Date());
    11.       sysUser.setUpdateTime(new Date());
    12.       sysUser.setUpdateUser(sysUser.getId());
    13.       sysUserService.updateById(sysUser);
    15.       //此处还可以进行一些处理，比如登录成功之后可能需要返回给前台当前用户有哪些菜单权限，
    16.       //进而前台动态的控制菜单的显示等，具体根据自己的业务需求进行扩展
    18.       // 返回json数据
    19.       JsonResult result = ResultTool.success();
    20.       //处理编码方式，防止中文乱码的情况
    21.       response.setContentType("text/json;charset=utf-8");
    22.       //塞到HttpServletResponse中返回给前台
    23.       response.getWriter().write(JSON.toJSONString(result));
    24.   }
    25. }

  • 登录失败处理器

    1. public class CustomizeAuthenticationFailureHandler implements AuthenticationFailureHandler {
    2.   @Override
    3.   public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
    4.       //返回json数据
    5.       JsonResult result = null;
    6.       if (e instanceof AccountExpiredException) {
    7.           //账号过期
    8.           result = ResultTool.fail(ResultCode.USER_ACCOUNT_EXPIRED);
    9.       } else if (e instanceof BadCredentialsException) {
    10.           //密码错误
    11.           result = ResultTool.fail(ResultCode.USER_CREDENTIALS_ERROR);
    12.       } else if (e instanceof CredentialsExpiredException) {
    13.           //密码过期
    14.           result = ResultTool.fail(ResultCode.USER_CREDENTIALS_EXPIRED);
    15.       } else if (e instanceof DisabledException) {
    16.           //账号不可用
    17.           result = ResultTool.fail(ResultCode.USER_ACCOUNT_DISABLE);
    18.       } else if (e instanceof LockedException) {
    19.           //账号锁定
    20.           result = ResultTool.fail(ResultCode.USER_ACCOUNT_LOCKED);
    21.       } else if (e instanceof InternalAuthenticationServiceException) {
    22.           //用户不存在
    23.           result = ResultTool.fail(ResultCode.USER_ACCOUNT_NOT_EXIST);
    24.       }else{
    25.           //其他错误
    26.           result = ResultTool.fail(ResultCode.COMMON_FAIL);
    27.       }
    28.       //处理编码方式，防止中文乱码的情况
    29.       response.setContentType("text/json;charset=utf-8");
    30.       //塞到HttpServletResponse中返回给前台
    31.       response.getWriter().write(JSON.toJSONString(result));
    32.   }
    33. }

  • 登出成功处理器

    1. public class CustomizeLogoutSuccessHandler implements LogoutSuccessHandler {
    2.   @Override
    3.   public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
    4.       JsonResult result = ResultTool.success();
    5.       response.setContentType("text/json;charset=utf-8");
    6.       response.getWriter().write(JSON.toJSONString(result));
    7.   }
    8. }

  • 匿名用户无权访问资源处理器

    1. public class CustomizeAuthenticationEntryPoint implements AuthenticationEntryPoint {
    2.   @Override
    3.   public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
    4.       JsonResult result = ResultTool.fail(ResultCode.USER_NOT_LOGIN);
    5.       response.setContentType("text/json;charset=utf-8");
    6.       response.getWriter().write(JSON.toJSONString(result));
    7.   }
    8. }

  • 权限拒绝处理逻辑

    1. public class CustomizeAccessDeniedHandler implements AccessDeniedHandler {
    2.   @Override
    3.   public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
    4.       response.setStatus(HttpServletResponse.SC_FORBIDDEN);
    5.       JsonResult result = ResultTool.fail(ResultCode.NO_PERMISSION);
    6.       response.setContentType("text/json;charset=utf-8");
    7.       response.getWriter().write(JSON.toJSONString(result));
    8.   }
    9. }

    3.6 权限校验

    我们已经实现了一个所谓的基于 RBAC 的权限控制，只不过我们是在 WebSecurityConfig 中写死的，但是在平时开发中，不可能说加一个需要访问权限的资源都修改代码。最合理的办法是从数据库中获取请求 URL 的权限，当前用户是否已授权访问。

  1. 我们需要实现一个 AccessDecisionManager（访问决策管理器），在里面我们对当前请求的资源进行权限判断，判断当前登录用户是否拥有该权限，如果有就放行，如果没有就抛出一个”权限不足”的异常。
  2. 不过在实现 AccessDecisionManager 之前我们还需要做一件事，那就是拦截到当前的请求，并根据请求路径从数据库中查出当前资源路径需要哪些权限才能访问，然后将查出的需要的权限列表交给 AccessDecisionManager 去处理后续逻辑。那就是需要先实现一个 SecurityMetadataSource，翻译过来是”安全元数据源”，我们这里使用他的一个子类 FilterInvocationSecurityMetadataSource。
  3. 在自定义的 SecurityMetadataSource 编写好之后，我们还要编写一个拦截器，增加到 Spring security 默认的拦截器链中，以达到拦截的目的。
  4. 同样的最后需要在 WebSecurityConfig 中注入，并在 configure(HttpSecurity http) 方法中然后声明。

  • 访问决策管理器

    1. @Component
    2. public class CustomizeAccessDecisionManager
    3.       implements AccessDecisionManager {
    4.   @Override
    5.   public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes) throws AccessDeniedException, InsufficientAuthenticationException {
    6.       Iterator<ConfigAttribute> iterator = configAttributes.iterator();
    7.       while (iterator.hasNext()) {
    8.           ConfigAttribute ca = iterator.next();
    9.           //当前请求需要的权限
    10.           String needRole = ca.getAttribute();
    11.           //当前用户所具有的权限，UserDetailsService中传递过来的
    12.           Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
    13.           for (GrantedAuthority authority : authorities) {
    14.               if (authority.getAuthority().equals(needRole)) {
    15.                   return;
    16.               }
    17.           }
    18.       }
    19.       throw new AccessDeniedException("权限不足!");
    20.   }
    22.   @Override
    23.   public boolean supports(ConfigAttribute attribute) {
    24.       return true;
    25.   }
    27.   @Override
    28.   public boolean supports(Class<?> clazz) {
    29.       return true;
    30.   }
    31. }

  • 安全元数据源

    1. @Component
    2. public class CustomizeFilterInvocationSecurityMetadataSource
    3.       implements FilterInvocationSecurityMetadataSource {
    5.   AntPathMatcher antPathMatcher = new AntPathMatcher();
    7.   @Autowired
    8.   SysPermissionService sysPermissionService;
    10.   /**
    11.    * 获取请求路径对应的权限
    12.    * @param object
    13.    * @return
    14.    * @throws IllegalArgumentException
    15.    */
    16.   @Override
    17.   public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
    18.       //获取请求地址
    19.       String requestUrl = ((FilterInvocation) object).getRequestUrl();
    20.       //查询具体某个接口的权限
    21.       List<SysPermission> permissionList =  sysPermissionService.selectListByPath(requestUrl);
    22.       if(permissionList == null || permissionList.size() == 0){
    23.           //请求路径没有配置权限，表明该请求接口可以任意访问
    24.           return null;
    25.       }
    26.       String[] attributes = new String[permissionList.size()];
    27.       for(int i = 0;i<permissionList.size();i++){
    28.           attributes[i] = permissionList.get(i).getPermissionCode();
    29.       }
    30.       return SecurityConfig.createList(attributes);
    31.   }
    33.   @Override
    34.   public Collection<ConfigAttribute> getAllConfigAttributes() {
    35.       return null;
    36.   }
    38.   @Override
    39.   public boolean supports(Class<?> clazz) {
    40.       return true;
    41.   }
    42. }

  • 拦截器

    1. @Component
    2. public class CustomizeAbstractSecurityInterceptor
    3.       extends AbstractSecurityInterceptor implements Filter {
    4.   /**
    5.    * 过滤调用安全元数据源
    6.    */
    7.   @Autowired
    8.   private FilterInvocationSecurityMetadataSource securityMetadataSource;
    10.   /**
    11.    * 设置访问决策管理器
    12.    * @param accessDecisionManager
    13.    */
    14.   @Autowired
    15.   public void setMyAccessDecisionManager(CustomizeAccessDecisionManager accessDecisionManager) {
    16.       super.setAccessDecisionManager(accessDecisionManager);
    17.   }
    19.   @Override
    20.   public Class<?> getSecureObjectClass() {
    21.       return FilterInvocation.class;
    22.   }
    24.   @Override
    25.   public SecurityMetadataSource obtainSecurityMetadataSource() {
    26.       return this.securityMetadataSource;
    27.   }
    29.   @Override
    30.   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    31.       FilterInvocation fi = new FilterInvocation(servletRequest, servletResponse, filterChain);
    32.       invoke(fi);
    33.   }
    35.   public void invoke(FilterInvocation fi) throws IOException, ServletException {
    36.       //fi里面有一个被拦截的url
    37.       //里面调用MyInvocationSecurityMetadataSource的getAttributes(Object object)这个方法获取fi对应的所有权限
    38.       //再调用MyAccessDecisionManager的decide方法来校验用户的权限是否足够
    39.       InterceptorStatusToken token = super.beforeInvocation(fi);
    40.       try {
    41.           //执行下一个拦截器
    42.           fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
    43.       } finally {
    44.           super.afterInvocation(token, null);
    45.       }
    46.   }
    47. }