1. 权限管理 权限管理，一般指根据系统设置的安全规则或者安全策略，用户可以访问而且只能访问自己被授权的资源，不多不少。
2. SpringSecurity 介绍 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。
正如你可能知道的关于安全方面的两个主要区域是“认证 ”和“授权 ”（或者访问控制），一般来说，Web 应用的安全性包括用户认证（Authentication [ɔːˌθentɪˈkeɪʃn]）和用户授权（Authorization [ˌɔːθəraɪˈzeɪʃn]） 两个部分，这两点也是 Spring Security 重要核心功能。
用户认证指的是：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统 。用户认证一般要求用户提供用户名和密码 。系统通过校验用户名和密码来完成认证过程。通俗点说就是系统认为用户是否能登录
用户授权指的是验证某个用户是否有权限执行某个操作 。在一个系统中，不同用户所具有的权限是不同的。比如对一个文件来说，有的用户只能进行读取，而有的用户可以进行修改。一般来说，系统会为不同的用户分配不同的角色，而每个角色则对应一系列的权限。通俗点讲就是系统判断用户是否有权限去做某些事情。
3. SpringSecurity 与 Shiro 对比 SpringSecurity 特点：
Shiro的特点:
Apache 旗下的轻量级权限控制框架。
好处：不局限于Web 环境，可以脱离Web 环境使用。
缺陷：在Web 环境下一些特定的需求需要手动编写代码定制。
1 2 SSM + Shiro Spring Boot/Spring Cloud + Spring Security
以上只是一个推荐的组合而已，如果单纯从技术上来说，无论怎么组合，都是可以运行
4. 创建 SpringSecurity 入门程序 pom.xml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 <parent > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-parent</artifactId > <version > 2.3.0.RELEASE</version > </parent > <dependencies > <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-web</artifactId > </dependency > <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-security</artifactId > </dependency > </dependencies >
编写Controller
1 2 3 4 5 6 7 8 9 @RestController @CrossOrigin @RequestMapping("/member") public class MemberController { @GetMapping("/hello") public String hello () { return "hello" ; } }
呀……..没有达到预期效果
SpringSecurity 默认了一个用户:
1 2 user 密码在控制台打印查看: Using generated security password: 421c81ab-874b-4502-a9d3-5fa51b7b24b3
5. SpringSecurity 的概念 主体 英文单词：principal
使用系统的用户或设备或从其他系统远程登录的用户等等。简单说就是谁使用系统谁就是主体。
认证 英文单词：authentication
权限管理系统确认一个主体的身份，允许主体进入系统。简单说就是“主体”证明自己是谁。
笼统的认为就是以前所做的登录操作。
授权 英文单词：authorization
将操作系统的“权力”—> “授予” —>”主体”，这样主体就具备了操作系统中特定功能的能力。
所以简单来说，授权就是给用户分配权限。
6. SpringSecurity 的运行原理 springsecurity 底层实现为一条过滤器链，就是用户请求进来，判断有没有请求的权限，抛出异常，重定向跳转。
Spring Security 对 Web 资源的保护是靠 Filter 实现的。当初始化 Spring Securit y时，会创建一个类型为org.springframework.security.web.FilterChainProxy的对象，它实现了 javax.servlet.Filter，因此外部的请求会经过此类
1 2 3 4 1. 默认自动配置了 DelegatingFilterProxy 过滤器 2. DelegatingFilterProxy-->initDelegate()方法中得到一个delegate对象,类型为FilterChainProxy; 3. 调用FilterChainProxy-->doFilter()--->doFilterInternal() 5. 获取到List<Filter> filters = getFilters(fwRequest);//获取到一个过滤器列表
filters有很多个：重点看三个过滤器：
UsernamePasswordAuthenticationFilter ：对登录的 POST 请求做拦截，校验表单中用户名，密码。
ExceptionTranslationFilter：是个异常过滤器，用来处理在认证授权过程中抛出的异常
FilterSecurityInterceptor：是一个方法级的权限过滤器，基本位于过滤链的最底部。
7. SpringSecurity简单的用户认证 Authentication接口：它的实现类，表示当前访问系统的用户，封装了用户相关信息。
AuthenticationManager接口：定义了认证 Authentication 的方法
UserDetailsService接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。
UserDetails接口：提供核心用户信息。通过 UserDetailsService 根据用户名获取处理的用户信息要封装成 UserDetails 对象返回。然后将这些信息封装到 Authentication 对象中。
7.1 基于配置文件的用户认证 SpringSecurity 默认的用户:用户名为user,密码在控制台打印生成;
我们可以配置一个用户名和密码:
application.properties
1 2 3 # 配置SpringSecurity的用户和密码 spring.security.user.name=admin spring.security.user.password=admin123
这样就可以使用上面配置的用户登录(认证)了;
7.2 基于配置类的用户认证 我们需要创建一个配置类让 SpringBoot 进行加载: WebSecurityConfigurerAdapter
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 @Configuration public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure (AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication().withUser("admin" ).password(new BCryptPasswordEncoder ().encode("admin123" )).roles("" ); } @Bean public PasswordEncoder passwordEncoder () { return new BCryptPasswordEncoder (); } }
再次访问就可以使用我们配置类中配置的用户名和密码进行认证了
8. SpringSecurity 前后端分离开发
思路
登录:
首先得屏蔽掉默认的的认证规则的校验，httpSecurity.formLogin().disable(); 这样就使得默认的登录弹出表单的验证规则失效了
自定义登录接口,调用ProviderManager的方法进行认证，如果通过验证，生成Token，把Token存放到Redis
校验:
8.1 pom依赖 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 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 <?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 http://maven.apache.org/xsd/maven-4.0.0.xsd" > <modelVersion > 4.0.0</modelVersion > <groupId > com.xzy</groupId > <artifactId > vue-admin-template-api</artifactId > <version > 1.0-SNAPSHOT</version > <properties > <maven.compiler.source > 8</maven.compiler.source > <maven.compiler.target > 8</maven.compiler.target > </properties > <parent > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-parent</artifactId > <version > 2.3.0.RELEASE</version > </parent > <dependencies > <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-web</artifactId > </dependency > <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-security</artifactId > </dependency > <dependency > <groupId > mysql</groupId > <artifactId > mysql-connector-java</artifactId > <version > 8.0.22</version > </dependency > <dependency > <groupId > org.projectlombok</groupId > <artifactId > lombok</artifactId > <version > 1.18.10</version > </dependency > <dependency > <groupId > com.baomidou</groupId > <artifactId > mybatis-plus-boot-starter</artifactId > <version > 3.0.5</version > </dependency > <dependency > <groupId > io.jsonwebtoken</groupId > <artifactId > jjwt</artifactId > <version > 0.7.0</version > </dependency > <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-test</artifactId > </dependency > </dependencies > <build > <plugins > <plugin > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-maven-plugin</artifactId > </plugin > </plugins > </build > </project >
8.2 编写UserDetailsService的实现类 我们自己编写接口实现UserDetailsService,Spring会把我们自己编写的UserDetailsService的实现类加载到容器中,并且作为默认的UserDetailsService
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 @Component public class UserDetailsServiceImpl implements UserDetailsService { @Autowired private SysUserMapper sysUserMapper; @Autowired private SysRoleMapper sysRoleMapper; @Autowired private SysPermissionMapper sysPermissionMapper; @Override public UserDetails loadUserByUsername (String username) throws UsernameNotFoundException { QueryWrapper<SysUser> queryWrapper = new QueryWrapper <>(); queryWrapper.eq("username" , username); SysUser sysUser = sysUserMapper.selectOne(queryWrapper); if (sysUser == null ) { throw new UsernameNotFoundException ("用户没有找到" ); } List<SysRole> roleList = sysRoleMapper.selectList(sysUser.getUsername()); List<SysPermission> permissionList = sysPermissionMapper.selectList(sysUser.getUsername()); List<GrantedAuthority> authorityList = new LinkedList <>(); roleList.forEach(sysRole -> { GrantedAuthority grantedAuthority = new SimpleGrantedAuthority ("ROLE_" + sysRole.getName()); authorityList.add(grantedAuthority); }); permissionList.forEach(sysPermission -> { GrantedAuthority grantedAuthority = new SimpleGrantedAuthority (sysPermission.getName()); authorityList.add(grantedAuthority); }); UserDetails userDetails = new User (username, sysUser.getPassword(), authorityList); return userDetails; } }
其实现在不用做任何配置的情况下已经实现了基于数据库的认证了;
8.3 编写自定义的登录控制器
编写自定义的登录控制器
在自定义的登录控制器中调用 authenticationManager.authenticate(authen)进行认证
那么我们就需要有一个 authenticationManager对象,可以在WebSecurityConfig中进行重写authenticationManagerBean,然后交给Spring(@Bean)就能获取到了
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 package com.xzy.api.controller;@RestController @CrossOrigin @RequestMapping("/user") public class UserController { @Autowired AuthenticationManager authenticationManager; @PostMapping("/login") public ResponseResult login (String nickname, String password) { ResponseResult responseResult = new ResponseResult (); UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken (nickname, password); try { Authentication authentication = authenticationManager.authenticate(usernamePasswordAuthenticationToken); UserDetails userDetails = (UserDetails) authentication.getPrincipal(); HashMap<String, String> tokenMap = new HashMap <>(); tokenMap.put("access_token" , JwtUtils.generateJwt(userDetails.getUsername())); responseResult.code(ResponseMessage.LOGINSUCCESS.code).msg(ResponseMessage.LOGINSUCCESS.msg).data(tokenMap); } catch (AuthenticationException e) { responseResult.code(ResponseMessage.LOGINFAIL.code).msg(ResponseMessage.LOGINFAIL.msg + ":::" +e.getMessage()); } return responseResult; } }
8.4 编写配置类 WebSecurityConfig.java
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 @Configuration public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Bean @Override public AuthenticationManager authenticationManagerBean () throws Exception { return super .authenticationManagerBean(); } @Override protected void configure (HttpSecurity httpSecurity) throws Exception { httpSecurity .csrf().disable() .authorizeRequests().antMatchers("/user/login" ).anonymous().anyRequest().authenticated() .and().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS); } @Bean public PasswordEncoder passwordEncoder () { return new BCryptPasswordEncoder (); } }
8.5 编写自定义的JwtFilter 我们尽量不要直接实现Servlet中的Filter接口,因为在不同的Tomcat中,可能存在Bug,相同的请求会被重复的过滤;使用Spring中给我们进行优化过后的Filter(OncePerRequestFilter);
调用UserDetailsService的loadUserByUsername获取到授权对象之后,需要把授权信息加入到SecurityContext中,后面系统自带的授权过滤器要使用授权对象中的信息来判断权限;
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 @Component public class JwtFilter extends OncePerRequestFilter { @Autowired private UserService userService; @Override protected void doFilterInternal (HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { String access_token = request.getHeader("Authorization" ); if (access_token != null ) { String username = JwtUtil.getUsernameByToken(request); User user = userService.queryUserByUsername(username); Authentication authentication = new UsernamePasswordAuthenticationToken (user.getUsername(), user.getPassword(), user.getAuthors()); SecurityContextHolder.getContext().setAuthentication(authentication); } filterChain.doFilter(request, response); } }
9. ant风格的路径表达式 Ant风格的路径表达式在日常开发中进行一些系统配置的时候非常有用;web.xml和spring中大量的使用这种风格的表达式表示路径;
通配符
说明
?
匹配任何单字符
*
匹配0或者任意数量的字符
**
匹配0或者更多的目录
URL路径
说明
/app/*.x
匹配(Matches)所有在app路径下的.x文件
/app/p?ttern
匹配(Matches) /app/pattern 和 /app/pXttern,但是不包括/app/pttern
/**/example
匹配(Matches) /app/example, /app/foo/example, 和 /example
/app/dir/file.*
匹配(Matches) /app/dir/file.jsp, /app/foo/dir/file.html,/app/foo/bar/dir/file.pdf, 和 /app/dir/file.java
/*.jsp
匹配(Matches)/下任何的.jsp 文件
9. anyRequest()详解 表示所有请求;一般会放在授权配置的末尾;
1 2 3 4 5 httpSecurity.authorizeRequests() .antMatchers("/mylogin" ).permitAll() .anyRequest().authenticated();
10. antMatchers()详解 1 2 3 4 5 6 7 httpSecurity.authorizeRequests() .antMatchers("/mylogin" ).permitAll() .antMatchers("/css/**" ).permitAll() .antMatchers("/js/**" ).permitAll() .anyRequest().authenticated();
11. SpringSecurity的访问控制 要想开启SpringBoot方法级别注解的权限控制,必须先进行启用,在入口类或者SpringSecurity的配置类上加以下注解来进行启用:
1 @EnableGlobalMethodSecurity(prePostEnabled = true)
1 2 3 4 5 6 7 8 9 10 11 12 permitAll();//允许所有的用户访问 denyAll();//禁止所有的所有用户访问 anonymous();//匿名的用户访问 authenticated();//认证的用户访问 fullyAuthenticated();//完全登录才可以访问的(rememberMe不算完全登录) rememberMe();//记住我 hasRole();//是否拥有某个角色,直接可以写角色名称,不需要前缀 ROLE_ hasAnyRole(...);//是否拥有其中任意一个角色,直接可以写角色名称,不需要前缀 ROLE_ hasAuthority();//是否拥有某个权限,这个也可以判断角色,需要加ROLE_ hasAnyAuthority(...);//是否拥有其中任意一个权限,这个也可以判断角色,需要加ROLE_ hasIpAddress();
在Security中，角色和权限共用GrantedAuthority接口，唯一的不同角色就是多了个前缀”ROLE_”，而且它没有Shiro的那种从属关系，即一个角色包含哪些权限等等。在Security看来角色和权限时一样的，它认证的时候，把所有权限（角色、权限）都取出来，而不是分开验证。
Security才不管你是角色，还是权限。它只比对字符串;
所以角色信息存储的时候可以没有”ROLE_”前缀，但是包装成GrantedAuthority对象的时候必须要有。
所以hasRole(“admin”)就相当于hasAuthority(“ROLE_admin”)
我们前面都是使用@PreAuthorize注解，然后在其中使用的是hasAuthority方法进行校验。SpringSecurity还为我们提供了其它方法例如：hasAnyAuthority，hasRole，hasAnyRole等。
hasAuthority方法实际是执行到了SecurityExpressionRoot的hasAuthority;
它内部其实是调用authentication的getAuthorities方法获取用户的权限列表。然后判断我们存入的方法参数数据在权限列表中
hasAnyAuthority方法可以传入多个权限，只有用户有其中任意一个权限都可以访问对应资源。
1 2 3 4 @PreAuthorize("hasAnyAuthority('admin','test','system:dept:list')") public String hello () { return "hello" ; }
自定义权限校验方法
我们也可以定义自己的权限校验方法，在@PreAuthorize注解中使用我们的方法。
1 2 3 4 5 6 7 8 9 10 11 @Component("ex") public class SGExpressionRoot { public boolean hasAuthority (String authority) { Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); LoginUser loginUser = (LoginUser) authentication.getPrincipal(); List<String> permissions = loginUser.getPermissions(); return permissions.contains(authority); } }
在SPEL表达式中使用 @ex相当于获取容器中bean的名字为ex的对象。然后再调用这个对象的hasAuthority方法
1 2 3 4 5 @RequestMapping("/hello") @PreAuthorize("@ex.hasAuthority('system:dept:list')") public String hello () { return "hello" ; }
12. 退出登录 由于我们现在使用的是前后端分离的模式,所以已经把Session禁用了;我们只需要编写写一个logout接口,移除redis中存放的的认证信息即可;
1 2 3 4 5 Authentication authentication = SecurityContextHolder.getContext().getAuthentication();LoginUser loginUser = (LoginUser) authentication.getPrincipal();Long userid = loginUser.getUser().getId();redisCache.deleteObject(userid); return new ResponseResult (200 ,"退出成功" );
13. 自定义认证失败和授权失败处理器 我们还希望在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的json，这样可以让前端能对响应进行统一的处理。要实现这个功能我们需要知道SpringSecurity的异常处理机制。
在SpringSecurity中，如果我们在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到。在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常。
如果是认证过程中出现的异常会被封装成AuthenticationException然后调用AuthenticationEntryPoint 对象的方法去进行异常处理。
如果是授权过程中出现的异常会被封装成AccessDeniedException然后调用AccessDeniedHandler 对象的方法去进行异常处理。
所以如果我们需要自定义异常处理，我们只需要自定义AuthenticationEntryPoint和AccessDeniedHandler然后配置给SpringSecurity即可(这两个处理器必须都配置,要不然只配置授权异常处理器,则不生效,因为被默认的认证处理器直接处理了);
自定义实现类
1 2 3 4 5 6 7 8 9 10 11 12 13 @Component public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint { @Override public void commence (HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException { response.setStatus(HttpServletResponse.SC_FORBIDDEN); ResponseResult resp = new ResponseResult (); resp.code(ResponseMessage.NOAUTHEN.code).msg(ResponseMessage.NOAUTHEN.msg + authException.getMessage()); ObjectMapper objectMapper = new ObjectMapper (); String json = objectMapper.writeValueAsString(resp); response.setContentType("application/json;charset=utf8" ); response.getWriter().write(json); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 @Component public class AccessDeniedHandlerImpl implements AccessDeniedHandler { @Override public void handle (HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException { response.setStatus(HttpServletResponse.SC_FORBIDDEN); ResponseResult resp = new ResponseResult (); resp.code(ResponseMessage.NOAUTHOR.code).msg(ResponseMessage.NOAUTHOR.msg + accessDeniedException.getMessage()); ObjectMapper objectMapper = new ObjectMapper (); String json = objectMapper.writeValueAsString(resp); response.setContentType("application/json;charset=utf8" ); response.getWriter().write(json); } }
WebSecurityConfig.java
1 2 3 4 5 6 7 8 @Override protected void configure (HttpSecurity httpSecurity) throws Exception { httpSecurity.csrf().disable(); httpSecurity.authorizeRequests().antMatchers("/user/login" ).anonymous().anyRequest().authenticated(); httpSecurity.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS); httpSecurity.addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class); httpSecurity.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint).accessDeniedHandler(accessDeniedHandler); }
14. 权限系统的设计 14.1 权限系统的作用 例如一个学校图书馆的管理系统，如果是普通学生登录就能看到借书还书相关的功能，不可能让他看到并且去使用添加书籍信息，删除书籍信息等功能。但是如果是一个图书馆管理员的账号登录了，应该就能看到并使用添加书籍信息，删除书籍信息等功能。
总结起来就是不同的用户可以使用不同的功能 。这就是权限系统要去实现的效果。
我们不能只依赖前端去判断用户的权限来选择显示哪些菜单哪些按钮。因为如果只是这样，如果有人知道了对应功能的接口地址就可以不通过前端，直接去发送请求来实现相关功能操作。
所以我们还需要在后台进行用户权限的判断，判断当前用户是否有相应的权限，必须具有所需权限才能进行相应的操作。
14.2 授权基本流程 在SpringSecurity中，会使用默认的FilterSecurityInterceptor来进行权限校验。在FilterSecurityInterceptor中会从SecurityContextHolder获取其中的Authentication，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限。
所以我们在项目中只需要把当前登录用户的权限信息也存入Authentication。
然后设置我们的资源所需要的权限即可。
14.3 RBAC权限模型 RBAC权限模型（Role-Based Access Control）即：基于角色的权限控制。这是目前最常被开发者使用也是相对易用、通用权限模型。
14.4 数据库设计 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 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 SET NAMES utf8mb4;SET FOREIGN_KEY_CHECKS = 0 ;DROP TABLE IF EXISTS `goods`;CREATE TABLE `goods` ( `id` char (19 ) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL , `name` varchar (10000 ) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL , `descp` varchar (255 ) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL , PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic ; INSERT INTO `goods` VALUES ('1' , 'Thinkpad笔记本电脑' , '这是IBM旗下的笔记本电脑' );INSERT INTO `goods` VALUES ('2' , 'MacBookPro2020' , '这是苹果公司旗下的笔记本电脑' );DROP TABLE IF EXISTS `sys_permission`;CREATE TABLE `sys_permission` ( `id` int NOT NULL AUTO_INCREMENT COMMENT '编号' , `name` varchar (30 ) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '菜单名称' , `url` varchar (100 ) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '菜单地址' , `parent_id` int NOT NULL DEFAULT 0 COMMENT '父菜单id' , PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic ; INSERT INTO `sys_permission` VALUES (1 , 'sys:goods' , NULL , 0 );INSERT INTO `sys_permission` VALUES (2 , 'sys:goods:add' , NULL , 1 );INSERT INTO `sys_permission` VALUES (3 , 'sys:goods:delete' , NULL , 1 );INSERT INTO `sys_permission` VALUES (4 , 'sys:goods:update' , NULL , 1 );INSERT INTO `sys_permission` VALUES (5 , 'sys:goods:query' , NULL , 1 );DROP TABLE IF EXISTS `sys_role`;CREATE TABLE `sys_role` ( `id` int NOT NULL AUTO_INCREMENT COMMENT '编号' , `name` varchar (30 ) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色名称' , `descp` varchar (60 ) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色描述' , PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic ; INSERT INTO `sys_role` VALUES (1 , 'super_admin' , '超级管理员角色' );INSERT INTO `sys_role` VALUES (2 , 'admin' , '管理员角色' );INSERT INTO `sys_role` VALUES (3 , 'normal' , '普通角色' );DROP TABLE IF EXISTS `sys_role_permission`;CREATE TABLE `sys_role_permission` ( `rid` int NOT NULL COMMENT '角色编号' , `pid` int NOT NULL COMMENT '权限编号' , PRIMARY KEY (`rid`, `pid`) USING BTREE ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic ; INSERT INTO `sys_role_permission` VALUES (1 , 2 );INSERT INTO `sys_role_permission` VALUES (1 , 3 );INSERT INTO `sys_role_permission` VALUES (1 , 4 );INSERT INTO `sys_role_permission` VALUES (1 , 5 );INSERT INTO `sys_role_permission` VALUES (2 , 2 );INSERT INTO `sys_role_permission` VALUES (2 , 4 );INSERT INTO `sys_role_permission` VALUES (2 , 5 );DROP TABLE IF EXISTS `sys_user`;CREATE TABLE `sys_user` ( `id` int 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 '密码' , PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic ; INSERT INTO `sys_user` VALUES (4 , 'sadmin' , '$2a$10$G7sfIk0xllhdVQhDalogqOe0gQ9W9reB2l7CtA4ASyu7onjB1E31m' );INSERT INTO `sys_user` VALUES (5 , 'admin' , '$2a$10$G7sfIk0xllhdVQhDalogqOe0gQ9W9reB2l7CtA4ASyu7onjB1E31m' );DROP TABLE IF EXISTS `sys_user_role`;CREATE TABLE `sys_user_role` ( `uid` int NOT NULL COMMENT '用户编号' , `rid` int NOT NULL COMMENT '角色编号' , PRIMARY KEY (`uid`, `rid`) USING BTREE ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic ; INSERT INTO `sys_user_role` VALUES (4 , 1 );INSERT INTO `sys_user_role` VALUES (5 , 2 );SET FOREIGN_KEY_CHECKS = 1 ;
14.5 查询角色和权限信息SQL 1 2 3 4 5 6 7 8 9 SELECT p.id, p.name FROM sys_user u INNER JOIN sys_user_role ur ON u.id = ur.uid INNER JOIN sys_role_permission rp on ur.rid = rp.rid INNER JOIN sys_permission p on p.id = rp.pid WHERE u.username = #{username}
1 2 3 4 5 6 7 8 SELECT role.id, role.name, role.descp FROM sys_user user INNER JOIN sys_user_role user_role ON user.id= user_role.uid INNER JOIN sys_role role on user_role.rid= role.id where user.username= #{username}
14.6 SpringSecurity权限控制的方式 配置文件中进行权限配置(不灵活) 1 2 3 4 5 6 7 8 9 10 11 12 @Override protected void configure (HttpSecurity httpSecurity) throws Exception { httpSecurity .csrf().disable() .authorizeRequests().antMatchers("/user/login" ).anonymous() .antMatchers("/goods/add" ).hasAuthority("sys:user:add" ) .anyRequest().authenticated() .and() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) .and() .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class).exceptionHandling().accessDeniedHandler(accessDeniedHandler); }
方法级别的权限控制 首先要启用方法级别的权限控制 @EnableGlobalMethodSecurity(prePostEnabled = true)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 package com.xzy.api.controller;@RestController @RequestMapping("/goods") @CrossOrigin public class GoodsController { @Autowired private GoodsMapper goodsMapper; @GetMapping("/add") @PreAuthorize("hasAuthority('sys:goods:add')") public ResponseResult add () {...} @GetMapping("/delete") @PreAuthorize("hasAuthority('sys:goods:delete') and hasRole('super_admin')") public ResponseResult delete () {...} @GetMapping("/update") @PreAuthorize("hasAuthority('sys:goods:update') ") public ResponseResult update () {...} }
15. 跨域问题的解决 浏览器出于安全的考虑，使用 XMLHttpRequest对象发起 HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。 同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。
前后端分离项目，前端项目和后端项目一般都不是同源的，所以肯定会存在跨域请求的问题。
所以我们就要处理一下，让前端能进行跨域请求。
先对SpringBoot配置，允许跨域请求
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 @Configuration public class CorsConfig implements WebMvcConfigurer { @Override public void addCorsMappings (CorsRegistry registry) { registry.addMapping("/**" ) .allowedOrigins("*" ) .allowedMethods("GET" , "POST" , "DELETE" , "PUT" , "OPTIONS" ) .allowCredentials(true ) .allowedHeaders("*" ) .maxAge(3600 ); } }
开启SpringSecurity的跨域访问
由于我们的资源都会受到SpringSecurity的保护，所以想要跨域访问还要让SpringSecurity运行跨域访问。
16. CSRF CSRF是指跨站请求伪造（Cross-site request forgery），是web常见的攻击之一。
跨站请求攻击，简单地说，是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并运行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去运行。这利用了web 中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的 。
https://blog.csdn.net/freeking101/article/details/86537087
从 Spring Security 4.0 开始，默认情况下会启用CSRF 保护，以防止CSRF 攻击应用程序，Spring Security CSRF 会针对 PATCH，POST，PUT 和DELETE 方法进行防护。
SpringSecurity去防止CSRF攻击的方式就是通过csrf_token。后端会生成一个csrf_token，前端发起请求的时候需要携带这个csrf_token,后端会有过滤器进行校验，如果没有携带或者是伪造的就不允许访问。
我们可以发现CSRF攻击依靠的是cookie中所携带的认证信息。但是在前后端分离的项目中我们的认证信息其实是token，而token并不是存储中cookie中，并且需要前端代码去把token设置到请求头中才可以，所以我们基于Token的认证,天然就不用怕CSRF攻击。
SpringSecurity从入门到精通
0. 简介 Spring Security 是 Spring 家族中的一个安全管理框架。相比与另外一个安全框架 Shiro ，它提供了更丰富的功能，社区资源也比 Shiro 丰富。
一般来说中大型的项目都是使用 SpringSecurity 来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。
一般Web应用的需要进行认证 和授权 。
认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户
授权：经过认证后判断当前用户是否有权限进行某个操作
而认证和授权也是SpringSecurity作为安全框架的核心功能。
1. 快速入门 1.1 准备工作 我们先要搭建一个简单的SpringBoot工程
① 设置父工程 添加依赖
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 <parent > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-parent</artifactId > <version > 2.5.0</version > </parent > <dependencies > <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-web</artifactId > </dependency > <dependency > <groupId > org.projectlombok</groupId > <artifactId > lombok</artifactId > <optional > true</optional > </dependency > </dependencies >
② 创建启动类
1 2 3 4 5 6 7 8 @SpringBootApplication public class SecurityApplication { public static void main (String[] args) { SpringApplication.run(SecurityApplication.class,args); } }
③ 创建Controller
1 2 3 4 5 6 7 8 9 10 11 12 import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestController public class HelloController { @RequestMapping("/hello") public String hello () { return "hello" ; } }
1.2 引入SpringSecurity 在SpringBoot项目中使用SpringSecurity我们只需要引入依赖即可实现入门案例。
1 2 3 4 <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-security</artifactId > </dependency >
引入依赖后我们在尝试去访问之前的接口就会自动跳转到一个SpringSecurity的默认登陆页面，默认用户名是user，密码会输出在控制台。
必须登陆之后才能对接口进行访问。
2. 认证 2.1 登陆校验流程
2.2 原理初探 想要知道如何实现自己的登陆流程就必须要先知道入门案例中 SpringSecurity 的流程。
2.2.1 SpringSecurity 完整流程 SpringSecurity 的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。这里我们可以看看入门案例中的过滤器。
图中只展示了核心过滤器，其它的非核心过滤器并没有在图中展示。
UsernamePasswordAuthenticationFilter ：负责处理我们在登陆页面填写了用户名密码后的登陆请求。入门案例的认证工作主要有它负责。
ExceptionTranslationFilter： 处理过滤器链中抛出的任何 AccessDeniedException 和 AuthenticationException 。
FilterSecurityInterceptor： 负责权限校验的过滤器。
我们可以通过 Debug 查看当前系统中SpringSecurity过滤器链中有哪些过滤器及它们的顺序。
2.2.2 认证流程详解
概念速查:
Authentication 接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息。
AuthenticationManager 接口：定义了认证 Authentication 的方法
UserDetailsService 接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。
UserDetails 接口：提供核心用户信息。通过 UserDetailsService 根据用户名获取处理的用户信息要封装成 UserDetails 对象返回。然后将这些信息封装到Authentication 对象中。
2.3 解决问题 2.3.1 思路分析 登录
①自定义登录接口
调用 ProviderManager 的方法进行认证 如果认证通过生成 jwt
把用户信息存入redis 中
②自定义 UserDetailsService
在这个实现类中去查询数据库
校验：
①定义 Jwt 认证过滤器
获取 token
解析 token 获取其中的 userid
从 redis 中获取用户信息
存入 SecurityContextHolder
2.3.2 准备工作 ①添加依赖
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-data-redis</artifactId > </dependency > <dependency > <groupId > com.alibaba</groupId > <artifactId > fastjson</artifactId > <version > 1.2.33</version > </dependency > <dependency > <groupId > io.jsonwebtoken</groupId > <artifactId > jjwt</artifactId > <version > 0.9.0</version > </dependency >
② 添加Redis相关配置
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 import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.serializer.SerializerFeature;import com.fasterxml.jackson.databind.JavaType;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.type.TypeFactory;import org.springframework.data.redis.serializer.RedisSerializer;import org.springframework.data.redis.serializer.SerializationException;import com.alibaba.fastjson.parser.ParserConfig;import org.springframework.util.Assert;import java.nio.charset.Charset;public class FastJsonRedisSerializer <T> implements RedisSerializer <T>{ public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8" ); private Class<T> clazz; static { ParserConfig.getGlobalInstance().setAutoTypeSupport(true ); } public FastJsonRedisSerializer (Class<T> clazz) { super (); this .clazz = clazz; } @Override public byte [] serialize(T t) throws SerializationException { if (t == null ) { return new byte [0 ]; } return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET); } @Override public T deserialize (byte [] bytes) throws SerializationException { if (bytes == null || bytes.length <= 0 ) { return null ; } String str = new String (bytes, DEFAULT_CHARSET); return JSON.parseObject(str, clazz); } protected JavaType getJavaType (Class<?> clazz) { return TypeFactory.defaultInstance().constructType(clazz); } }
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 import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.data.redis.connection.RedisConnectionFactory;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.serializer.StringRedisSerializer;@Configuration public class RedisConfig { @Bean @SuppressWarnings(value = { "unchecked", "rawtypes" }) public RedisTemplate<Object, Object> redisTemplate (RedisConnectionFactory connectionFactory) { RedisTemplate<Object, Object> template = new RedisTemplate <>(); template.setConnectionFactory(connectionFactory); FastJsonRedisSerializer serializer = new FastJsonRedisSerializer (Object.class); template.setKeySerializer(new StringRedisSerializer ()); template.setValueSerializer(serializer); template.setHashKeySerializer(new StringRedisSerializer ()); template.setHashValueSerializer(serializer); template.afterPropertiesSet(); return template; } }
③ 响应类
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 import com.fasterxml.jackson.annotation.JsonInclude;@JsonInclude(JsonInclude.Include.NON_NULL) public class ResponseResult <T> { private Integer code; private String msg; private T data; public ResponseResult (Integer code, String msg) { this .code = code; this .msg = msg; } public ResponseResult (Integer code, T data) { this .code = code; this .data = data; } public Integer getCode () { return code; } public void setCode (Integer code) { this .code = code; } public String getMsg () { return msg; } public void setMsg (String msg) { this .msg = msg; } public T getData () { return data; } public void setData (T data) { this .data = data; } public ResponseResult (Integer code, String msg, T data) { this .code = code; this .msg = msg; this .data = data; } }
④工具类
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 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 import io.jsonwebtoken.Claims;import io.jsonwebtoken.JwtBuilder;import io.jsonwebtoken.Jwts;import io.jsonwebtoken.SignatureAlgorithm;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;import java.util.Base64;import java.util.Date;import java.util.UUID;public class JwtUtil { public static final Long JWT_TTL = 60 * 60 *1000L ; public static final String JWT_KEY = "sangeng" ; public static String getUUID () { String token = UUID.randomUUID().toString().replaceAll("-" , "" ); return token; } public static String createJWT (String subject) { JwtBuilder builder = getJwtBuilder(subject, null , getUUID()); return builder.compact(); } public static String createJWT (String subject, Long ttlMillis) { JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID()); return builder.compact(); } private static JwtBuilder getJwtBuilder (String subject, Long ttlMillis, String uuid) { SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256; SecretKey secretKey = generalKey(); long nowMillis = System.currentTimeMillis(); Date now = new Date (nowMillis); if (ttlMillis==null ){ ttlMillis=JwtUtil.JWT_TTL; } long expMillis = nowMillis + ttlMillis; Date expDate = new Date (expMillis); return Jwts.builder() .setId(uuid) .setSubject(subject) .setIssuer("sg" ) .setIssuedAt(now) .signWith(signatureAlgorithm, secretKey) .setExpiration(expDate); } public static String createJWT (String id, String subject, Long ttlMillis) { JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id); return builder.compact(); } public static void main (String[] args) throws Exception { String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJjYWM2ZDVhZi1mNjVlLTQ0MDAtYjcxMi0zYWEwOGIyOTIwYjQiLCJzdWIiOiJzZyIsImlzcyI6InNnIiwiaWF0IjoxNjM4MTA2NzEyLCJleHAiOjE2MzgxMTAzMTJ9.JVsSbkP94wuczb4QryQbAke3ysBDIL5ou8fWsbt_ebg" ; Claims claims = parseJWT(token); System.out.println(claims); } public static SecretKey generalKey () { byte [] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY); SecretKey key = new SecretKeySpec (encodedKey, 0 , encodedKey.length, "AES" ); return key; } public static Claims parseJWT (String jwt) throws Exception { SecretKey secretKey = generalKey(); return Jwts.parser() .setSigningKey(secretKey) .parseClaimsJws(jwt) .getBody(); } }
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 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 import java.util.*;import java.util.concurrent.TimeUnit;@SuppressWarnings(value = { "unchecked", "rawtypes" }) @Component public class RedisCache { @Autowired public RedisTemplate redisTemplate; public <T> void setCacheObject (final String key, final T value) { redisTemplate.opsForValue().set(key, value); } public <T> void setCacheObject (final String key, final T value, final Integer timeout, final TimeUnit timeUnit) { redisTemplate.opsForValue().set(key, value, timeout, timeUnit); } public boolean expire (final String key, final long timeout) { return expire(key, timeout, TimeUnit.SECONDS); } public boolean expire (final String key, final long timeout, final TimeUnit unit) { return redisTemplate.expire(key, timeout, unit); } public <T> T getCacheObject (final String key) { ValueOperations<String, T> operation = redisTemplate.opsForValue(); return operation.get(key); } public boolean deleteObject (final String key) { return redisTemplate.delete(key); } public long deleteObject (final Collection collection) { return redisTemplate.delete(collection); } public <T> long setCacheList (final String key, final List<T> dataList) { Long count = redisTemplate.opsForList().rightPushAll(key, dataList); return count = = null ? 0 : count; } public <T> List<T> getCacheList (final String key) { return redisTemplate.opsForList().range(key, 0 , -1 ); } public <T> BoundSetOperations<String, T> setCacheSet (final String key, final Set<T> dataSet) { BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key); Iterator<T> it = dataSet.iterator(); while (it.hasNext()) { setOperation.add(it.next()); } return setOperation; } public <T> Set<T> getCacheSet (final String key) { return redisTemplate.opsForSet().members(key); } public <T> void setCacheMap (final String key, final Map<String, T> dataMap) { if (dataMap != null ) { redisTemplate.opsForHash().putAll(key, dataMap); } } public <T> Map<String, T> getCacheMap (final String key) { return redisTemplate.opsForHash().entries(key); } public <T> void setCacheMapValue (final String key, final String hKey, final T value) { redisTemplate.opsForHash().put(key, hKey, value); } public <T> T getCacheMapValue (final String key, final String hKey) { HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash(); return opsForHash.get(key, hKey); } public void delCacheMapValue (final String key, final String hkey) { HashOperations hashOperations = redisTemplate.opsForHash(); hashOperations.delete(key, hkey); } public <T> List<T> getMultiCacheMapValue (final String key, final Collection<Object> hKeys) { return redisTemplate.opsForHash().multiGet(key, hKeys); } public Collection<String> keys (final String pattern) { return redisTemplate.keys(pattern); } }
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 import javax.servlet.http.HttpServletResponse;import java.io.IOException;public class WebUtils { public static String renderString (HttpServletResponse response, String string) { try { response.setStatus(200 ); response.setContentType("application/json" ); response.setCharacterEncoding("utf-8" ); response.getWriter().print(string); } catch (IOException e) { e.printStackTrace(); } return null ; } }
⑤实体类
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 63 64 65 66 67 68 69 70 71 72 73 74 75 76 import java.io.Serializable;import java.util.Date;@Data @AllArgsConstructor @NoArgsConstructor public class User implements Serializable { private static final long serialVersionUID = -40356785423868312L ; private Long id; private String userName; private String nickName; private String password; private String status; private String email; private String phonenumber; private String sex; private String avatar; private String userType; private Long createBy; private Date createTime; private Long updateBy; private Date updateTime; private Integer delFlag; }
2.3.3 实现 2.3.3.1 数据库校验用户 从之前的分析我们可以知道，我们可以自定义一个 UserDetailsService，让 SpringSecurity 使用我们的 UserDetailsService。我们自己的 UserDetailsService 可以从数据库中查询用户名和密码。
准备工作 我们先创建一个用户表， 建表语句如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 CREATE TABLE `sys_user` ( `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键', `user_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名', `nick_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称', `password` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '密码', `status` CHAR(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）', `email` VARCHAR(64) DEFAULT NULL COMMENT '邮箱', `phonenumber` VARCHAR(32) DEFAULT NULL COMMENT '手机号', `sex` CHAR(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）', `avatar` VARCHAR(128) DEFAULT NULL COMMENT '头像', `user_type` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）', `create_by` BIGINT(20) DEFAULT NULL COMMENT '创建人的用户id', `create_time` DATETIME DEFAULT NULL COMMENT '创建时间', `update_by` BIGINT(20) DEFAULT NULL COMMENT '更新人', `update_time` DATETIME DEFAULT NULL COMMENT '更新时间', `del_flag` INT(11) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）', PRIMARY KEY (`id`) ) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表'
引入MybatisPuls和mysql驱动的依赖
1 2 3 4 5 6 7 8 9 <dependency > <groupId > com.baomidou</groupId > <artifactId > mybatis-plus-boot-starter</artifactId > <version > 3.4.3</version > </dependency > <dependency > <groupId > mysql</groupId > <artifactId > mysql-connector-java</artifactId > </dependency >
配置数据库信息
1 2 3 4 5 6 spring: datasource: url: jdbc:mysql://localhost:3306/sg_security?characterEncoding=utf-8&serverTimezone=UTC username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver
定义Mapper接口
1 2 public interface UserMapper extends BaseMapper <User> {}
修改User实体类
1 类名上加@TableName(value = "sys_user") ,id字段上加 @TableId
配置Mapper扫描
1 2 3 4 5 6 7 8 @SpringBootApplication @MapperScan("com.sangeng.mapper") public class SimpleSecurityApplication { public static void main (String[] args) { ConfigurableApplicationContext run = SpringApplication.run(SimpleSecurityApplication.class); System.out.println(run); } }
添加junit依赖
1 2 3 4 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> </dependency>
测试MAP是否能正常使用
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 @SpringBootTest public class MapperTest { @Autowired private UserMapper userMapper; @Test public void testUserMapper () { List<User> users = userMapper.selectList(null ); System.out.println(users); } }
核心代码实现 创建一个类实现 UserDetailsService 接口，重写其中的方法。更加用户名从数据库中查询用户信息
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 @Service public class UserDetailsServiceImpl implements UserDetailsService { @Autowired private UserMapper userMapper; @Override public UserDetails loadUserByUsername (String username) throws UsernameNotFoundException { LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper <>(); wrapper.eq(User::getUserName,username); User user = userMapper.selectOne(wrapper); if (Objects.isNull(user)){ throw new RuntimeException ("用户名或密码错误" ); } return new LoginUser (user); } }
因为 UserDetailsService 方法的返回值是 UserDetails 类型，所以需要定义一个类，实现该接口，把用户信息封装在其中。
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 @Data @NoArgsConstructor @AllArgsConstructor public class LoginUser implements UserDetails { private User user; @Override public Collection<? extends GrantedAuthority > getAuthorities() { return null ; } @Override public String getPassword () { return user.getPassword(); } @Override public String getUsername () { return user.getUserName(); } @Override public boolean isAccountNonExpired () { return true ; } @Override public boolean isAccountNonLocked () { return true ; } @Override public boolean isCredentialsNonExpired () { return true ; } @Override public boolean isEnabled () { return true ; } }
注意：如果要测试，需要往用户表中写入用户数据，并且如果你想让用户的密码是明文存储，需要在密码前加{noop}。例如
这样登陆的时候就可以用 sg 作为用户名，1234作为密码来登陆了。
2.3.3.2 密码加密存储 实际项目中我们不会把密码明文存储在数据库中。
默认使用的 PasswordEncoder要求数据库中的密码格式为：{id}password 。它会根据id去判断密码的加密方式。但是我们一般不会采用这种方式。所以就需要替换PasswordEncoder。
我们一般使用SpringSecurity为我们提供的BCryptPasswordEncoder。
我们只需要使用把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验。
我们可以定义一个SpringSecurity的配置类，SpringSecurity要求这个配置类要继承WebSecurityConfigurerAdapter。
1 2 3 4 5 6 7 8 9 10 11 12 13 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Bean public PasswordEncoder passwordEncoder () { return new BCryptPasswordEncoder (); } }
2.3.3.3 登陆接口 接下我们需要自定义登陆接口，然后让 SpringSecurity 对这个接口放行，让用户访问这个接口的时候不用登录也能访问。
在接口中我们通过 AuthenticationManager 的 authenticate 方法来进行用户认证，所以需要在 SecurityConfig 中配置把 AuthenticationManager 注入容器。
认证成功的话要生成一个 jwt，放入响应中返回。并且为了让用户下回请求时能通过 jwt 识别出具体的是哪个用户，我们需要把用户信息存入 redis，可以把用户 id作为 key。
1 2 3 4 5 6 7 8 9 10 11 12 @RestController public class LoginController { @Autowired private LoginServcie loginServcie; @PostMapping("/user/login") public ResponseResult login (@RequestBody User user) { return loginServcie.login(user); } }
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 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Bean public PasswordEncoder passwordEncoder () { return new BCryptPasswordEncoder (); } @Override protected void configure (HttpSecurity http) throws Exception { http .csrf().disable() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) .and() .authorizeRequests() .antMatchers("/user/login" ).anonymous() .anyRequest().authenticated(); } @Bean @Override public AuthenticationManager authenticationManagerBean () throws Exception { return super .authenticationManagerBean(); } }
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 @Service public class LoginServiceImpl implements LoginServcie { @Autowired private AuthenticationManager authenticationManager; @Autowired private RedisCache redisCache; @Override public ResponseResult login (User user) { UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken (user.getUserName(),user.getPassword()); Authentication authenticate = authenticationManager.authenticate(authenticationToken); if (Objects.isNull(authenticate)){ throw new RuntimeException ("用户名或密码错误" ); } LoginUser loginUser = (LoginUser) authenticate.getPrincipal(); String userId = loginUser.getUser().getId().toString(); String jwt = JwtUtil.createJWT(userId); redisCache.setCacheObject("login:" +userId,loginUser); HashMap<String,String> map = new HashMap <>(); map.put("token" ,jwt); return new ResponseResult (200 ,"登陆成功" ,map); } }
2.3.3.4 认证过滤器 我们需要自定义一个过滤器，这个过滤器会去获取请求头中的 token，对 token 进行解析取出其中的 userid。
使用 userid 去 redis 中获取对应的 LoginUser 对象。
然后封装Authentication对象存入SecurityContextHolder
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 @Component public class JwtAuthenticationTokenFilter extends OncePerRequestFilter { @Autowired private RedisCache redisCache; @Override protected void doFilterInternal (HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { String token = request.getHeader("token" ); if (!StringUtils.hasText(token)) { filterChain.doFilter(request, response); return ; } String userid; try { Claims claims = JwtUtil.parseJWT(token); userid = claims.getSubject(); } catch (Exception e) { e.printStackTrace(); throw new RuntimeException ("token非法" ); } String redisKey = "login:" + userid; LoginUser loginUser = redisCache.getCacheObject(redisKey); if (Objects.isNull(loginUser)){ throw new RuntimeException ("用户未登录" ); } UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken (loginUser,null ,null ); SecurityContextHolder.getContext().setAuthentication(authenticationToken); filterChain.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 32 33 34 35 36 37 38 39 40 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Bean public PasswordEncoder passwordEncoder () { return new BCryptPasswordEncoder (); } @Autowired JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter; @Override protected void configure (HttpSecurity http) throws Exception { http .csrf().disable() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) .and() .authorizeRequests() .antMatchers("/user/login" ).anonymous() .anyRequest().authenticated(); http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class); } @Bean @Override public AuthenticationManager authenticationManagerBean () throws Exception { return super .authenticationManagerBean(); } }
2.3.3.5 退出登陆 我们只需要定义一个登陆接口，然后获取 SecurityContextHolder 中的认证信息，删除 redis 中对应的数据即可。
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 @Service public class LoginServiceImpl implements LoginServcie { @Autowired private AuthenticationManager authenticationManager; @Autowired private RedisCache redisCache; @Override public ResponseResult login (User user) { UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken (user.getUserName(),user.getPassword()); Authentication authenticate = authenticationManager.authenticate(authenticationToken); if (Objects.isNull(authenticate)){ throw new RuntimeException ("用户名或密码错误" ); } LoginUser loginUser = (LoginUser) authenticate.getPrincipal(); String userId = loginUser.getUser().getId().toString(); String jwt = JwtUtil.createJWT(userId); redisCache.setCacheObject("login:" +userId,loginUser); HashMap<String,String> map = new HashMap <>(); map.put("token" ,jwt); return new ResponseResult (200 ,"登陆成功" ,map); } @Override public ResponseResult logout () { Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); LoginUser loginUser = (LoginUser) authentication.getPrincipal(); Long userid = loginUser.getUser().getId(); redisCache.deleteObject("login:" +userid); return new ResponseResult (200 ,"退出成功" ); } }
3. 授权 3.0 权限系统的作用 例如一个学校图书馆的管理系统，如果是普通学生登录就能看到借书还书相关的功能，不可能让他看到并且去使用添加书籍信息，删除书籍信息等功能。但是如果是一个图书馆管理员的账号登录了，应该就能看到并使用添加书籍信息，删除书籍信息等功能。
总结起来就是不同的用户可以使用不同的功能 。这就是权限系统要去实现的效果。
我们不能只依赖前端去判断用户的权限来选择显示哪些菜单哪些按钮。因为如果只是这样，如果有人知道了对应功能的接口地址就可以不通过前端，直接去发送请求来实现相关功能操作。
所以我们还需要在后台进行用户权限的判断，判断当前用户是否有相应的权限，必须具有所需权限才能进行相应的操作。
3.1 授权基本流程 在 SpringSecurity 中，会使用默认的 FilterSecurityInterceptor 来进行权限校验。在 FilterSecurityInterceptor 中会从 SecurityContextHolder 获取其中的Authentication，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限。
所以我们在项目中只需要把当前登录用户的权限信息也存入Authentication。
然后设置我们的资源所需要的权限即可。
3.2 授权实现 3.2.1 限制访问资源所需权限 SpringSecurity 为我们提供了基于注解的权限控制方案，这也是我们项目中主要采用的方式。我们可以使用注解去指定访问对应的资源所需的权限。
但是要使用它我们需要先开启相关配置。
1 @EnableGlobalMethodSecurity(prePostEnabled = true)
然后就可以使用对应的注解。@PreAuthorize
1 2 3 4 5 6 7 8 9 @RestController public class HelloController { @RequestMapping("/hello") @PreAuthorize("hasAuthority('test')") public String hello () { return "hello" ; } }
3.2.2 封装权限信息 我们前面在写 UserDetailsServiceImpl 的时候说过，在查询出用户后还要获取对应的权限信息，封装到 UserDetails 中返回。
我们先直接把权限信息写死封装到 UserDetails 中进行测试。
我们之前定义了 UserDetails 的实现类 LoginUser，想要让其能封装权限信息就要对其进行修改。
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 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 package com.sangeng.domain;import com.alibaba.fastjson.annotation.JSONField;import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;import org.springframework.security.core.GrantedAuthority;import org.springframework.security.core.authority.SimpleGrantedAuthority;import org.springframework.security.core.userdetails.UserDetails;import java.util.Collection;import java.util.List;import java.util.stream.Collectors;@Data @NoArgsConstructor public class LoginUser implements UserDetails { private User user; private List<String> permissions; public LoginUser (User user,List<String> permissions) { this .user = user; this .permissions = permissions; } @JSONField(serialize = false) private List<GrantedAuthority> authorities; @Override public Collection<? extends GrantedAuthority > getAuthorities() { if (authorities!=null ){ return authorities; } authorities = permissions.stream(). map(SimpleGrantedAuthority::new ) .collect(Collectors.toList()); return authorities; } @Override public String getPassword () { return user.getPassword(); } @Override public String getUsername () { return user.getUserName(); } @Override public boolean isAccountNonExpired () { return true ; } @Override public boolean isAccountNonLocked () { return true ; } @Override public boolean isCredentialsNonExpired () { return true ; } @Override public boolean isEnabled () { return true ; } }
LoginUser修改完后我们就可以在UserDetailsServiceImpl中去把权限信息封装到LoginUser中了。我们写死权限进行测试，后面我们再从数据库中查询权限信息。
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 package com.sangeng.service.impl;import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;import com.sangeng.domain.LoginUser;import com.sangeng.domain.User;import com.sangeng.mapper.UserMapper;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.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Objects;@Service public class UserDetailsServiceImpl implements UserDetailsService { @Autowired private UserMapper userMapper; @Override public UserDetails loadUserByUsername (String username) throws UsernameNotFoundException { LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper <>(); wrapper.eq(User::getUserName,username); User user = userMapper.selectOne(wrapper); if (Objects.isNull(user)){ throw new RuntimeException ("用户名或密码错误" ); } List<String> list = new ArrayList <>(Arrays.asList("test" )); return new LoginUser (user,list); } }
3.2.3 从数据库查询权限信息 3.2.3.1 RBAC权限模型 RBAC权限模型（Role-Based Access Control）即：基于角色的权限控制。这是目前最常被开发者使用也是相对易用、通用权限模型。
3.2.3.2 准备工作 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 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 CREATE DATABASE `sg_security` ;USE `sg_security`; DROP TABLE IF EXISTS `sys_menu`;CREATE TABLE `sys_menu` ( `id` bigint (20 ) NOT NULL AUTO_INCREMENT, `menu_name` varchar (64 ) NOT NULL DEFAULT 'NULL' COMMENT '菜单名' , `path` varchar (200 ) DEFAULT NULL COMMENT '路由地址' , `component` varchar (255 ) DEFAULT NULL COMMENT '组件路径' , `visible` char (1 ) DEFAULT '0' COMMENT '菜单状态（0显示 1隐藏）' , `status` char (1 ) DEFAULT '0' COMMENT '菜单状态（0正常 1停用）' , `perms` varchar (100 ) DEFAULT NULL COMMENT '权限标识' , `icon` varchar (100 ) DEFAULT '#' COMMENT '菜单图标' , `create_by` bigint (20 ) DEFAULT NULL , `create_time` datetime DEFAULT NULL , `update_by` bigint (20 ) DEFAULT NULL , `update_time` datetime DEFAULT NULL , `del_flag` int (11 ) DEFAULT '0' COMMENT '是否删除（0未删除 1已删除）' , `remark` varchar (500 ) DEFAULT NULL COMMENT '备注' , PRIMARY KEY (`id`) ) ENGINE= InnoDB AUTO_INCREMENT= 2 DEFAULT CHARSET= utf8mb4 COMMENT= '菜单表' ; DROP TABLE IF EXISTS `sys_role`;CREATE TABLE `sys_role` ( `id` bigint (20 ) NOT NULL AUTO_INCREMENT, `name` varchar (128 ) DEFAULT NULL , `role_key` varchar (100 ) DEFAULT NULL COMMENT '角色权限字符串' , `status` char (1 ) DEFAULT '0' COMMENT '角色状态（0正常 1停用）' , `del_flag` int (1 ) DEFAULT '0' COMMENT 'del_flag' , `create_by` bigint (200 ) DEFAULT NULL , `create_time` datetime DEFAULT NULL , `update_by` bigint (200 ) DEFAULT NULL , `update_time` datetime DEFAULT NULL , `remark` varchar (500 ) DEFAULT NULL COMMENT '备注' , PRIMARY KEY (`id`) ) ENGINE= InnoDB AUTO_INCREMENT= 3 DEFAULT CHARSET= utf8mb4 COMMENT= '角色表' ; DROP TABLE IF EXISTS `sys_role_menu`;CREATE TABLE `sys_role_menu` ( `role_id` bigint (200 ) NOT NULL AUTO_INCREMENT COMMENT '角色ID' , `menu_id` bigint (200 ) NOT NULL DEFAULT '0' COMMENT '菜单id' , PRIMARY KEY (`role_id`,`menu_id`) ) ENGINE= InnoDB AUTO_INCREMENT= 2 DEFAULT CHARSET= utf8mb4; DROP TABLE IF EXISTS `sys_user`;CREATE TABLE `sys_user` ( `id` bigint (20 ) NOT NULL AUTO_INCREMENT COMMENT '主键' , `user_name` varchar (64 ) NOT NULL DEFAULT 'NULL' COMMENT '用户名' , `nick_name` varchar (64 ) NOT NULL DEFAULT 'NULL' COMMENT '昵称' , `password` varchar (64 ) NOT NULL DEFAULT 'NULL' COMMENT '密码' , `status` char (1 ) DEFAULT '0' COMMENT '账号状态（0正常 1停用）' , `email` varchar (64 ) DEFAULT NULL COMMENT '邮箱' , `phonenumber` varchar (32 ) DEFAULT NULL COMMENT '手机号' , `sex` char (1 ) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）' , `avatar` varchar (128 ) DEFAULT NULL COMMENT '头像' , `user_type` char (1 ) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）' , `create_by` bigint (20 ) DEFAULT NULL COMMENT '创建人的用户id' , `create_time` datetime DEFAULT NULL COMMENT '创建时间' , `update_by` bigint (20 ) DEFAULT NULL COMMENT '更新人' , `update_time` datetime DEFAULT NULL COMMENT '更新时间' , `del_flag` int (11 ) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）' , PRIMARY KEY (`id`) ) ENGINE= InnoDB AUTO_INCREMENT= 3 DEFAULT CHARSET= utf8mb4 COMMENT= '用户表' ; DROP TABLE IF EXISTS `sys_user_role`;CREATE TABLE `sys_user_role` ( `user_id` bigint (200 ) NOT NULL AUTO_INCREMENT COMMENT '用户id' , `role_id` bigint (200 ) NOT NULL DEFAULT '0' COMMENT '角色id' , PRIMARY KEY (`user_id`,`role_id`) ) ENGINE= InnoDB DEFAULT CHARSET= utf8mb4;
1 2 3 4 5 6 7 8 9 10 11 SELECT DISTINCT m.`perms` FROM sys_user_role ur LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id` LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id` LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id` WHERE user_id = 2 AND r.`status` = 0 AND m.`status` = 0
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 63 64 65 66 67 68 69 70 71 72 73 package com.sangeng.domain;import com.baomidou.mybatisplus.annotation.TableId;import com.baomidou.mybatisplus.annotation.TableName;import com.fasterxml.jackson.annotation.JsonInclude;import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;import java.io.Serializable;import java.util.Date;@TableName(value="sys_menu") @Data @AllArgsConstructor @NoArgsConstructor @JsonInclude(JsonInclude.Include.NON_NULL) public class Menu implements Serializable { private static final long serialVersionUID = -54979041104113736L ; @TableId private Long id; private String menuName; private String path; private String component; private String visible; private String status; private String perms; private String icon; private Long createBy; private Date createTime; private Long updateBy; private Date updateTime; private Integer delFlag; private String remark; }
3.2.3.3 代码实现 我们只需要根据用户 id 去查询到其所对应的权限信息即可。
所以我们可以先定义个mapper，其中提供一个方法可以根据 userid 查询权限信息。
1 2 3 4 5 6 7 8 9 10 11 import com.baomidou.mybatisplus.core.mapper.BaseMapper;import com.sangeng.domain.Menu;import java.util.List;public interface MenuMapper extends BaseMapper <Menu> { List<String> selectPermsByUserId (Long id) ; }
尤其是自定义方法，所以需要创建对应的 mapper 文件，定义对应的sql语句
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 <?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 ="com.sangeng.mapper.MenuMapper" > <select id ="selectPermsByUserId" resultType ="java.lang.String" > SELECT DISTINCT m.`perms` FROM sys_user_role ur LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id` LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id` LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id` WHERE user_id = #{userid} AND r.`status` = 0 AND m.`status` = 0 </select > </mapper >
在application.yml中配置mapperXML文件的位置
1 2 3 4 5 6 7 8 9 10 11 12 spring: datasource: url: jdbc:mysql://localhost:3306/sg_security?characterEncoding=utf-8&serverTimezone=UTC username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver redis: host: localhost port: 6379 mybatis-plus: mapper-locations: classpath*:/mapper/**/*.xml
然后我们可以在 UserDetailsServiceImpl 中去调用该 mapper 的方法查询权限信息封装到LoginUser对象中即可。
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 @Service public class UserDetailsServiceImpl implements UserDetailsService { @Autowired private UserMapper userMapper; @Autowired private MenuMapper menuMapper; @Override public UserDetails loadUserByUsername (String username) throws UsernameNotFoundException { LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper <>(); wrapper.eq(User::getUserName,username); User user = userMapper.selectOne(wrapper); if (Objects.isNull(user)){ throw new RuntimeException ("用户名或密码错误" ); } List<String> permissionKeyList = menuMapper.selectPermsByUserId(user.getId()); return new LoginUser (user,permissionKeyList); } }
4. 自定义失败处理 我们还希望在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的 json，这样可以让前端能对响应进行统一的处理。要实现这个功能我们需要知道 SpringSecurity 的异常处理机制。
在 SpringSecurity 中，如果我们在认证或者授权的过程中出现了异常会被 ExceptionTranslationFilter 捕获到。在 ExceptionTranslationFilter 中会去判断是认证失败还是授权失败出现的异常。
如果是认证过程中出现的异常会被封装成 AuthenticationException 然后调用 AuthenticationEntryPoint 对象的方法去进行异常处理。
如果是授权过程中出现的异常会被封装成 AccessDeniedException 然后调用AccessDeniedHandler 对象的方法去进行异常处理。
所以如果我们需要自定义异常处理，我们只需要自定义AuthenticationEntryPoint和AccessDeniedHandler然后配置给SpringSecurity即可。
①自定义实现类
1 2 3 4 5 6 7 8 9 10 11 @Component public class AccessDeniedHandlerImpl implements AccessDeniedHandler { @Override public void handle (HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException { ResponseResult result = new ResponseResult (HttpStatus.FORBIDDEN.value(), "权限不足" ); String json = JSON.toJSONString(result); WebUtils.renderString(response,json); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 @Component public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint { @Override public void commence (HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException { ResponseResult result = new ResponseResult (HttpStatus.UNAUTHORIZED.value(), "认证失败请重新登录" ); String json = JSON.toJSONString(result); WebUtils.renderString(response,json); } }
②配置给SpringSecurity
先注入对应的处理器
1 2 3 4 5 @Autowired private AuthenticationEntryPoint authenticationEntryPoint;@Autowired private AccessDeniedHandler accessDeniedHandler;
然后我们可以使用HttpSecurity对象的方法去配置。
1 2 http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint). accessDeniedHandler(accessDeniedHandler);
5. 跨域 浏览器出于安全的考虑，使用 XMLHttpRequest对象发起 HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。 同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。
前后端分离项目，前端项目和后端项目一般都不是同源的，所以肯定会存在跨域请求的问题。
所以我们就要处理一下，让前端能进行跨域请求。
①先对SpringBoot配置，运行跨域请求
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 @Configuration public class CorsConfig implements WebMvcConfigurer { @Override public void addCorsMappings (CorsRegistry registry) { registry.addMapping("/**" ) .allowedOriginPatterns("*" ) .allowCredentials(true ) .allowedMethods("GET" , "POST" , "DELETE" , "PUT" ) .allowedHeaders("*" ) .maxAge(3600 ); } }
②开启SpringSecurity的跨域访问
由于我们的资源都会收到SpringSecurity的保护，所以想要跨域访问还要让SpringSecurity运行跨域访问。
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 @Override protected void configure (HttpSecurity http) throws Exception { http .csrf().disable() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) .and() .authorizeRequests() .antMatchers("/user/login" ).anonymous() .anyRequest().authenticated(); http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class); http.exceptionHandling() .authenticationEntryPoint(authenticationEntryPoint) .accessDeniedHandler(accessDeniedHandler); http.cors(); }
6. 遗留小问题 其它权限校验方法 我们前面都是使用@PreAuthorize注解，然后在在其中使用的是hasAuthority方法进行校验。SpringSecurity还为我们提供了其它方法例如：hasAnyAuthority，hasRole，hasAnyRole等。
这里我们先不急着去介绍这些方法，我们先去理解hasAuthority的原理，然后再去学习其他方法你就更容易理解，而不是死记硬背区别。并且我们也可以选择定义校验方法，实现我们自己的校验逻辑。
hasAuthority方法实际是执行到了SecurityExpressionRoot的hasAuthority，大家只要断点调试既可知道它内部的校验原理。
它内部其实是调用authentication的getAuthorities方法获取用户的权限列表。然后判断我们存入的方法参数数据在权限列表中。
hasAnyAuthority方法可以传入多个权限，只有用户有其中任意一个权限都可以访问对应资源。
1 2 3 4 @PreAuthorize("hasAnyAuthority('admin','test','system:dept:list')") public String hello () { return "hello" ; }
hasRole要求有对应的角色才可以访问，但是它内部会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。
1 2 3 4 @PreAuthorize("hasRole('system:dept:list')") public String hello () { return "hello" ; }
hasAnyRole 有任意的角色就可以访问。它内部也会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。
1 2 3 4 @PreAuthorize("hasAnyRole('admin','system:dept:list')") public String hello () { return "hello" ; }
自定义权限校验方法 我们也可以定义自己的权限校验方法，在@PreAuthorize注解中使用我们的方法。
1 2 3 4 5 6 7 8 9 10 11 12 @Component("ex") public class SGExpressionRoot { public boolean hasAuthority (String authority) { Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); LoginUser loginUser = (LoginUser) authentication.getPrincipal(); List<String> permissions = loginUser.getPermissions(); return permissions.contains(authority); } }
在SPEL表达式中使用 @ex相当于获取容器中bean的名字未ex的对象。然后再调用这个对象的hasAuthority方法
1 2 3 4 5 @RequestMapping("/hello") @PreAuthorize("@ex.hasAuthority('system:dept:list')") public String hello () { return "hello" ; }
基于配置的权限控制 我们也可以在配置类中使用使用配置的方式对资源进行权限控制。
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 @Override protected void configure (HttpSecurity http) throws Exception { http .csrf().disable() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) .and() .authorizeRequests() .antMatchers("/user/login" ).anonymous() .antMatchers("/testCors" ).hasAuthority("system:dept:list222" ) .anyRequest().authenticated(); http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class); http.exceptionHandling() .authenticationEntryPoint(authenticationEntryPoint) .accessDeniedHandler(accessDeniedHandler); http.cors(); }
CSRF CSRF是指跨站请求伪造（Cross-site request forgery），是web常见的攻击之一。
https://blog.csdn.net/freeking101/article/details/86537087
SpringSecurity去防止CSRF攻击的方式就是通过csrf_token。后端会生成一个csrf_token，前端发起请求的时候需要携带这个csrf_token,后端会有过滤器进行校验，如果没有携带或者是伪造的就不允许访问。
我们可以发现CSRF攻击依靠的是cookie中所携带的认证信息。但是在前后端分离的项目中我们的认证信息其实是token，而token并不是存储中cookie中，并且需要前端代码去把token设置到请求头中才可以，所以CSRF攻击也就不用担心了。
认证成功处理器 实际上在UsernamePasswordAuthenticationFilter进行登录认证的时候，如果登录成功了是会调用AuthenticationSuccessHandler的方法进行认证成功后的处理的。AuthenticationSuccessHandler就是登录成功处理器。
我们也可以自己去自定义成功处理器进行成功后的相应处理。
1 2 3 4 5 6 7 8 9 @Component public class SGSuccessHandler implements AuthenticationSuccessHandler { @Override public void onAuthenticationSuccess (HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException { System.out.println("认证成功了" ); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private AuthenticationSuccessHandler successHandler; @Override protected void configure (HttpSecurity http) throws Exception { http.formLogin().successHandler(successHandler); http.authorizeRequests().anyRequest().authenticated(); } }
认证失败处理器 实际上在UsernamePasswordAuthenticationFilter进行登录认证的时候，如果认证失败了是会调用AuthenticationFailureHandler的方法进行认证失败后的处理的。AuthenticationFailureHandler就是登录失败处理器。
我们也可以自己去自定义失败处理器进行失败后的相应处理。
1 2 3 4 5 6 7 @Component public class SGFailureHandler implements AuthenticationFailureHandler { @Override public void onAuthenticationFailure (HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException { System.out.println("认证失败了" ); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private AuthenticationSuccessHandler successHandler; @Autowired private AuthenticationFailureHandler failureHandler; @Override protected void configure (HttpSecurity http) throws Exception { http.formLogin() .successHandler(successHandler) .failureHandler(failureHandler); http.authorizeRequests().anyRequest().authenticated(); } }
登出成功处理器 1 2 3 4 5 6 7 8 @Component public class SGLogoutSuccessHandler implements LogoutSuccessHandler { @Override public void onLogoutSuccess (HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException { System.out.println("注销成功" ); } }
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 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private AuthenticationSuccessHandler successHandler; @Autowired private AuthenticationFailureHandler failureHandler; @Autowired private LogoutSuccessHandler logoutSuccessHandler; @Override protected void configure (HttpSecurity http) throws Exception { http.formLogin() .successHandler(successHandler) .failureHandler(failureHandler); http.logout() .logoutSuccessHandler(logoutSuccessHandler); http.authorizeRequests().anyRequest().authenticated(); } }
其他认证方案畅想 7. 源码讲解
