该笔记基于B站视频和自己的理解整理而成。视频地址:SpringSecurity框架教程-Spring Security+JWT实现项目级前端分离认证授权-B站最通俗易懂的Spring Security课程_哔哩哔哩_bilibili课程已完结,资料获取方式请看置顶评论。https://www.bilibili.com/video/BV1mm4y1X7Hc?p=41&spm_id_from=333.337.header_right.history_list.click
什么是springsecurity?
Spring Security 是 Spring 家族中的一个安全管理框架,侧重于为Java应用程序提供身份验证和授权。
优点:在用户认证方面,Spring Security 框架支持主流的认证方式,包括 HTTP 基本认证、HTTP 表单验证、HTTP 摘要认证、OpenID 和 LDAP 等。在用户授权方面,Spring Security 提供了基于角色的访问控制和访问控制列表(Access Control List,ACL),可以对应用中的领域对象进行细粒度的控制。
对于中大型的项目来说一般更倾向于用springsecurity来做安全框架,小项目用一般Shiro的比较多,因为Shiro的上手更加的简单。
实战测试:
一、实验环境搭建
1.新建一个springboot项目(此处是基于idea编译器进行操作演示的)
2.创建HelloController
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello() {
return "hello";
}
}
3.启动SpringBootApplication,检查测试实验环境是否OK!
二、引入SpringSecurity
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
引入依赖后我们在尝试去访问之前的接口就会自动跳转到一个SpringSecurity的默认登陆页面,默认用户名是user,密码会输出在控制台。
必须登陆之后才能对接口进行访问。此时springsecurity身份认证的效果就体现出来了。
三、认证
3.1、登录校验流程:
3.2、原理剖析:
上述图片我们可以很清楚的了解springsecurity认证授权的过程是怎样的,那么我们又该如何去实现呢?
UsernamePasswordAuthenticationFilter:负责处理我们在登陆页面填写了用户名密码后的登陆请求。入门案例的认证工作主要有它负责。
ExceptionTranslationFilter:处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException 。
FilterSecurityInterceptor:负责权限校验的过滤器。
3.3、认证流程详解:
Authentication接口: 它的实现类,表示当前访问系统的用户,封装了用户相关信息。
AuthenticationManager接口:定义了认证Authentication的方法
UserDetailsService接口:加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。
UserDetails接口:提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中。
3.4、思路分析
登录:
①自定义登录接口
调用ProviderManager的方法进行认证 如果认证通过生成jwt
把用户信息存入redis中
②自定义UserDetailsService
在这个实现类中去查询数据库
校验:
①定义Jwt认证过滤器
获取token
解析token获取其中的userid
从redis中获取用户信息
存入SecurityContextHolder
四、搭建项目(这里只是准备工作,详细代码见Gitee)
spring_security: springSecurity学习记录https://gitee.com/DZ_QY/spring_security.git1、在pom中引入相关依赖;
2、在com/zhao/config下添加Redis相关配置 (RedisConfig.class);
在com/zhao/utils下添加Redis使用FastJson序列化工具类(FastJsonRedisSerializer.class);
3、封装ResponseResult响应类(返回相应的提示信息);
4、封装JwtUtil工具类;
5、封装RedisCache工具类,缓存基本的对象,Integer、String、实体类等等;
6、封装WebUtils工具类,将字符串渲染到客户端;
7、定义一个User实体类并实现Serializable接口,使得User对象可序列化;
8、在MySQL数据库中创建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=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表'
9、在.yml中配置数据库信息;
spring:
datasource:
url: jdbc:mysql://localhost:3306/sys_security?characterEncoding=utf-8&serverTimezone=UTC
username: root
password: root
driver-class-name: com.mysql.cj.jdbc.Driver
redis:
database: 0
# Redis服务器地址
host: 127.0.0.1
# Redis服务器连接端口
port: 6379
# Redis服务器连接密码(默认为空)
mybatis-plus:
mapper-locations: classpath*:/mapper/**/*.xml
server:
port: 8888
五、登录认证具体实现(重要)
一、基础代码:
1、在com/zhao/mapper下定义UserMapper接口:
public interface UserMapper extends BaseMapper<User> {}
2、在该项目的启动类上配置Mapper扫描:
@MapperScan("com.zhao.mapper")
@SpringBootApplication
public class SecurityApplication {
public static void main(String[] args) {
SpringApplication.run(SecurityApplication.class, args);
}
}
3、测试mapper能否正常使用:
//....省略部分代码
@Autowired //注入UserMapper
private UserMapper userMapper;
@Test
public void testUserMapper(){
List<User> users = userMapper.selectList(null);
System.out.println(users);
}
二、核心代码:
1、创建一个类实现UserDetailsService接口,重写其中的方法。根据用户名从数据库中查询用户信息;
/**
* @description 用于security根据用户名获取用户对象
*/
@Service //注入到spring容器中
public class UserDetailsServiceImpl implements UserDetailsService {
//注入相应的mapper即可操作数据库
@Autowired
private UserMapper userMapper;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//查询用户信息
LambdaQueryWrapper<User> queryWrapper =new LambdaQueryWrapper();
queryWrapper.eq(User::getUserName,username);
User user = userMapper.selectOne(queryWrapper);
//如果没有查询到用户,就抛出异常
if (Objects.isNull(user)){
throw new RuntimeException("用户名或密码错误");
}
//TODO 查询对应的权限信息(就是一个个有特殊含义的字符串)
//把数据封装成UserDetails返回
return new LoginUser(user);
}
}
2、由于UserDetailsService方法的返回值是UserDetails类型,所以需要定义一个类,实现该接口,把用户信息封装在其中。
@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; }
}
注意:如果这时候需要进行测试,需要往sys_user表中写入用户数据,并且如果你想让用户的密码是明文存储,需要在密码前加{noop}。
但是在实际的开发过程中我们并不会把密码明文存储在数据库中,此时就需要对密码进行加密;
在springsecurity中,我们一般使用它为我们提供的BCryptPasswordEncoder进行加密。具体操作如下:
<1>定义SecurityConfig配置类,要求继承WebSecurityConfigurerAdapter(com/zhao/config/SecurityConfig.class)
<2>将BCryptPasswordEncode注入到spring容器中
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
}
3、自定义登录接口LoginController(com/zhao/controller),然后让SpringSecurity对这个接口放行,用户在访问这个接口的时候不用登录也能访问。
具体操作:
<1>在SecurityConfig中配置把AuthenticationManager注入容器。
<2>在SpringSecurity进行配置,对登录接口放行,使用户不用登陆也能访问该接口;
<3>注入AuthenticationManager,通过它的authenticate方法来进行用户认证;
<4>如果认证成功,就生成一个jwt,通过ResponseResult响应返回【调用service,具体操作在service层实现】;
<5>为了让用户下回请求时能通过jwt识别出具体的是哪个用户,我们需要把用户信息存入redis,可以把用户id作为key。
(1)SecurityConfig 配置类:
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//关闭csrf
.csrf().disable()
//不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
// 对于登录接口 允许匿名访问
.antMatchers("/user/login").anonymous()
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
}
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
}
LoginController.class:
@RestController
public class LoginController {
@Autowired
private LoginServcie loginServcie;
@PostMapping("/user/login")
public ResponseResult login(@RequestBody User user){
return loginServcie.login(user);
}
}
LoginServcie 接口:
public interface LoginServcie {
ResponseResult login(User user);
}
接口实现类:
@Service
public class LoginServiceImpl implements LoginServcie {
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private RedisCache redisCache;
@Override
public ResponseResult login(User user) {
//当在页面中输入用户名和密码之后首先会进入到UsernamePasswordAuthenticationToken验证(Authentication),
//然后生成的Authentication会被交由AuthenticationManager来进行管理
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
Authentication authenticate = authenticationManager.authenticate(authenticationToken);
if(Objects.isNull(authenticate)){
throw new RuntimeException("用户名或密码错误");
}
//使用userid生成token
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userId = loginUser.getUser().getId().toString();
String jwt = JwtUtil.createJWT(userId);
//authenticate存入redis
redisCache.setCacheObject("login:"+userId,loginUser);
//把token响应给前端
HashMap<String,String> map = new HashMap<>();
map.put("token",jwt);
return new ResponseResult(200,"登陆成功",map);
}
}
4、认证过滤器:
<1>在SecurityConfig 配置类中注入JwtAuthenticationTokenFilter
<2>自定义一个过滤器JwtAuthenticationTokenFilter继承OncePerRequestFilter
<3>在这个过滤器中去获取请求头中的token,对token进行解析取出其中的userid。
<4>使用userid去redis中获取对应的LoginUser对象。
<5>然后封装Authentication对象存入SecurityContextHolder
SecurityConfig配置类:
//....省略代码
@Autowired
JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
JwtAuthenticationTokenFilter类:
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
@Autowired
private RedisCache redisCache;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//获取token
String token = request.getHeader("token");
if (!StringUtils.hasText(token)) {
//放行
filterChain.doFilter(request, response);
return;
}
//解析token
String userid;
try {
Claims claims = JwtUtil.parseJWT(token);
userid = claims.getSubject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("token非法");
}
//从redis中获取用户信息
String redisKey = "login:" + userid;
LoginUser loginUser = redisCache.getCacheObject(redisKey);
if(Objects.isNull(loginUser)){
throw new RuntimeException("用户未登录");
}
//存入SecurityContextHolder
//TODO 获取权限信息封装到Authentication中
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(loginUser,null,null);
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//放行
filterChain.doFilter(request, response);
}
}
5、退出登录:
<1>获取SecurityContextHolder中的认证信息
<2>删除redis中对应的数据
LoginController.class:
//...省略代码
@RequestMapping("/user/logout")
public ResponseResult logOut(){
//注销
return loginService.logout();
}
LoginService接口:
//....省略部分代码
public interface LoginServcie {
ResponseResult login(User user);
ResponseResult logout();
}
接口实现类:
//...省略部分代码
@Override
public ResponseResult logout() {
//获取SecurityContextHolder中的用户id
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
Long userid = loginUser.getUser().getId();
//删除redis中的值
redisCache.deleteObject("login:"+userid);
return new ResponseResult(200,"注销成功");
}
六、授权认证具体实现(重要)
授权认证的作用:不同的用户可以使用不同的功能
1、授权认证的基本流程:
<1>把当前登录用户的权限信息存入Authentication。
<2>在springsecurity中,默认使用FilterSecurityInterceptor来进行权限校验。
<3>在FilterSecurityInterceptor中会从SecurityContextHolder获取其中的Authentication,然后获取其中的权限信息。
<4>判断当前用户是否拥有访问当前资源所需的权限。
2、具体实现:
(1)SpringSecurity为我们提供了基于注解的权限控制方案,我们可以使用注解去指定访问对应的资源所需的权限。但是要使用它我们需要先在SecurityConfig开启相关配置。然后就可以使用对应的注解@PreAuthorize。
@EnableGlobalMethodSecurity(prePostEnabled = true)
HelloController:
@RestController
public class HelloController {
@RequestMapping("/hello")
@PreAuthorize("hasAuthority('test')")
public String hello(){
return "hello";
}
}
(2)在认证UserDetailsServiceImpl阶段,我们查询出用户后还要获取对应的权限信息,封装到UserDetails中返回。
我们先直接把权限信息在实现类UserDetailsServiceImpl中 写死,然后封装到LoginUser中进行测试。
UserDetailsService接口实现类:
//...省略
//查询对应的权限信息(就是一个个有特殊含义的字符串)
List<String> list = new ArrayList<>(Arrays.asList("test","admin"));
//把数据封装成UserDetails返回
return new LoginUser(user,list);
UserDetails实现类:
@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;
}
//存储SpringSecurity所需要的权限信息的集合
@JSONField(serialize = false) //避免在redis中序列化
private List<GrantedAuthority> authorities;
@Override
//返回权限信息
public Collection<? extends GrantedAuthority> getAuthorities() {
if (authorities!=null){
return authorities;
}
//把permissions中字符串类型的权限信息转换成GrantedAuthority对象存入authorities中
authorities = new ArrayList<>();
for (String permission : permissions) {
SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permission);
authorities.add(authority);
}
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; }
}
3、从数据库查询用户权限信息【RBAC权限模型:基于角色的权限控制。这是目前最常被开发者使用也是相对易用、通用权限模型。 】
(1)数据库建表:
CREATE DATABASE /*!32312 IF NOT EXISTS*/`sg_security` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
USE `sg_security`;
/*Table structure for table `sys_menu` */
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='菜单表';
/*Table structure for table `sys_role` */
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='角色表';
/*Table structure for table `sys_role_menu` */
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;
/*Table structure for table `sys_user` */
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='用户表';
/*Table structure for table `sys_user_role` */
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;
(2)创建对应的实体类Menu.class并实现序列化【代码见gitee】
(3)根据用户id去查询对应的权限
MenuMapper:
public interface MenuMapper extends BaseMapper<Menu> {
List<String> selectPermsByUserId(Long id);
}
(4)自定义mapper文件,定义对应的SQL语句
<?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.zhao.mapper.MenuMapper">
<select id="selectPermsByUserId" resultType="java.lang.String" parameterType="long">
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>
(5)在application.yml中配置mapperXML文件的位置
mybatis-plus:
mapper-locations: classpath*:/mapper/**/*.xml
(6)在UserDetailsServiceImpl中去调用该mapper的方法查询权限信息封装到LoginUser对象中,替换掉之前写死的权限集合。
//注入相应的mapper即可操作数据库
@Autowired
private UserMapper userMapper;
//查询对应的权限信息(就是一个个有特殊含义的字符串)
List<String> list = menuMapper.selectPermsByUserId(user.getId());
七、自定义失败处理
说明:
在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到。在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常。
如果是认证过程中出现的异常会被封装成AuthenticationException然后调用AuthenticationEntryPoint对象的方法去进行异常处理。
如果是授权过程中出现的异常会被封装成AccessDeniedException然后调用AccessDeniedHandler对象的方法去进行异常处理。
所以如果我们需要自定义异常处理,我们只需要自定义AuthenticationEntryPoint和AccessDeniedHandler然后配置给SpringSecurity。
具体实现:
(1)在com/zhao/handler下自定义AccessDeniedHandlerImpl实现AccessDeniedHandler(重写该方法)
@Component //注入到Spring容器中
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);
}
}
在com/zhao/handler下自定义AuthenticationEntryPointImpl实现AuthenticationEntryPoint(重写该方法)
@Component //注入到Spring容器中
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
//处理异常
//通过枚举类型设置状态码
ResponseResult responseResult = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "用户认证失败,请重新登录");
String json = JSON.toJSONString(responseResult);
WebUtils.renderString(response,json);
}
}
(2)配置给SpringSecurity:
@Autowired
private AuthenticationEntryPoint authenticationEntryPoint;
@Autowired
private AccessDeniedHandler accessDeniedHandler;
//....省略部分代码
@Override
protected void configure(HttpSecurity http) throws Exception {
//...省略部分代码
//配置异常处理器
http.exceptionHandling()
.authenticationEntryPoint(authenticationEntryPoint)
.accessDeniedHandler(accessDeniedHandler);
}
八、跨域
说明:
前后端分离项目,前端项目和后端项目一般都不是同源的,所以肯定会存在跨域请求的问题。
具体实现:
<1>对SpringBoot配置,执行跨域请求【定义一个CorsConfig 配置文件】
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
// 设置允许跨域的路径
registry.addMapping("/**")
// 设置允许跨域请求的域名
.allowedOriginPatterns("*")
// 是否允许cookie
.allowCredentials(true)
// 设置允许的请求方式
.allowedMethods("GET", "POST", "DELETE", "PUT")
// 设置允许的header属性
.allowedHeaders("*")
// 跨域允许时间
.maxAge(3600);
}
}
<2>开启SpringSecurity的跨域访问
在上述这种安全模式框架下资源会受到SpringSecurity的保护,所以想要跨域访问还要让SpringSecurity运行跨域访问。
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//关闭csrf
.csrf().disable()
//不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
// 对于登录接口 允许匿名访问
.antMatchers("/user/login").anonymous()//匿名访问,登录才能访问
.antMatchers("/testCors").hasAnyAuthority("system:test:list")
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
//添加自定义过滤器在UsernamePasswordAuthenticationFilter前
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
//配置异常处理器
http.exceptionHandling()
.authenticationEntryPoint(authenticationEntryPoint)
.accessDeniedHandler(accessDeniedHandler);
//允许跨域
http.cors();
}
九、其它权限校验方法
在上述权限校验时我们使用的是@PreAuthorize注解,然后在其中使用的是hasAuthority方法进行校验。SpringSecurity还为我们提供了其它方法例如:hasAnyAuthority,hasRole,hasAnyRole等。
hasAnyAuthority方法可以传入多个权限,只有用户有其中任意一个权限都可以访问对应资源。
@RestController
public class HelloController {
@PreAuthorize("hasAnyAuthority('admin','test','system:dept:list')")
public String hello(){
return "hello";
}
}
hasRole要求有对应的角色才可以访问,但是它内部会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。
@RestController
public class HelloController {
@PreAuthorize("hasRole('system:dept:list')")
public String hello(){
return "hello";
}
}
hasAnyRole 有任意的角色就可以访问。它内部也会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。
@RestController
public class HelloController {
@PreAuthorize("hasAnyRole('admin','system:dept:list')")
public String hello(){
return "hello";
}
}