你知道怎么Spring security整合JWT么
- 模型分类
- 增加用户名和密码
- 基于内存的认证
- 导入依赖
- 创建一个 JwtUser 实现 UserDetails
- 编写工具类生成令牌
- 编写拦截器
- 编写 userDetailsService 的实现类
- 编写登录
- 最后配置 Config
- 运行，返回 token
- 重写 UsernamePasswordAnthenticationFilter
- 配置 SecurityConfig
- 设计数据表
- 着重配置 SpringConfig
权限系统躲不开的概念，在Shiro和Spring Security之间，你一般选啥？在前后端分离的项目中，你知道怎么Spring security整合JWT么，来看看这篇文章哈！
思维导图如下：
RBAC 全称为基于角色的权限控制，本段将会从什么是 RBAC，模型分类，什么是权限，用户组的使用，实例分析等几个方面阐述 RBAC.
思维导图
绘制思维导图如下
什么是 RBAC
RBAC 全称为用户角色权限控制，通过角色关联用户，角色关联权限，这种方式，间阶的赋予用户的权限，如下图所示
对于通常的系统而言，存在多个用户具有相同的权限，在分配的时候，要为指定的用户分配相关的权限，修改的时候也要依次的对这几个用户的权限进行修改，有了角色这个权限，在修改权限的时候，只需要对角色进行修改，就可以实现相关的权限的修改。这样做增加了效率，减少了权限漏洞的发生。
模型分类
对于 RBAC 模型来说，分为以下几个模型 分别是 RBAC0，RBAC1，RBAC2，RBAC3，这四个模型，这段将会依次介绍这四个模型，其中最常用的模型有 RBAC0.
RBAC0
RBAC0 是最简单的 RBAC 模型，这里面包含了两种。
用户和角色是多对一的关系，即一个用户只充当一种角色，一个角色可以有多个角色的担当。用户和角色是多对多的关系，即，一个用户可以同时充当多个角色，一个角色可以有多个用户。此系统功能单一，人员较少，这里举个栗子，张三既是行政，也负责财务，此时张三就有俩个权限，分别是行政权限，和财务权限两个部分。
RBAC1
相对于 RBAC0 模型来说，增加了子角色，引入了继承的概念。
RBAC2 模型
这里 RBAC2 模型，在 RBAC0 模型的基础上，增加了一些功能，以及限制
角色互斥
即，同一个用户不能拥有两个互斥的角色，举个例子，在财务系统中，一个用户不能拥有会计员和审计这两种角色。
基数约束
即，用一个角色，所拥有的成员是固定的，例如对于 CEO 这种角色，同一个角色，也只能有一个用户。
先决条件
即，对于该角色来说，如果想要获得更高的角色，需要先获取低一级别的角色。举个栗子，对于副总经理和经理这两个权限来说，需要先有副总经理权限，才能拥有经理权限，其中副总经理权限是经理权限的先决条件。
运行时互斥
即，一个用户可以拥有两个角色，但是这俩个角色不能同时使用，需要切换角色才能进入另外一个角色。举个栗子，对于总经理和专员这两个角色，系统只能在一段时间，拥有其一个角色，不能同时对这两种角色进行操作。
RBAC3 模型
即，RBAC1，RBAC2，两者模型全部累计，称为统一模型。
什么是权限
权限是资源的集合，这里的资源指的是软件中的所有的内容，即，对页面的操作权限，对页面的访问权限，对数据的增删查改的权限。举个栗子。对于下图中的系统而言，
拥有，计划管理，客户管理，合同管理，出入库通知单管理，粮食安全追溯，粮食统计查询，设备管理这几个页面，对这几个页面的访问，以及是否能够访问到菜单，都属于权限。
用户组的使用
对于用户组来说，是把众多的用户划分为一组，进行批量授予角色，即，批量授予权限。举个栗子，对于部门来说，一个部门拥有一万多个员工，这些员工都拥有相同的角色，如果没有用户组，可能需要一个个的授予相关的角色，在拥有了用户组以后，只需要，把这些用户全部划分为一组，然后对该组设置授予角色，就等同于对这些用户授予角色。
优点：减少工作量，便于理解，增加多级管理，等。
首先添加依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-securityartifactId>
dependency>
然后添加相关的访问接口
packagecom.example.demo.web;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/test")
publicclassTest{
@RequestMapping("/test")
publicStringtest(){
return"test";
}
}
最后启动项目，在日志中查看相关的密码
访问接口，可以看到相关的登录界面
输入用户名和相关的密码
用户名：user
密码984cccf2-ba82-468e-a404-7d32123d0f9c
登录成功
基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能
- 项目地址：https://gitee.com/zhijiantianya/ruoyi-vue-pro
- 视频教程：https://doc.iocoder.cn/video/
增加用户名和密码
在配置文件中，书写相关的登录和密码
spring:
security:
user:
name:ming
password:123456
roles:admin
在登录页面，输入用户名和密码，即可正常登录
基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能
基于内存的认证
需要自定义类继承 WebSecurityConfigurerAdapter 代码如下
packagecom.example.demo.config;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
importorg.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
importorg.springframework.security.crypto.password.NoOpPasswordEncoder;
importorg.springframework.security.crypto.password.PasswordEncoder;
@Configuration
publicclassMyWebSecurityConfigextendsWebSecurityConfigurerAdapter{
@Bean
PasswordEncoderpasswordEncoder(){
returnNoOpPasswordEncoder.getInstance();
}
@Override
protectedvoidconfigure(AuthenticationManagerBuilderauth)throwsException{
auth.inMemoryAuthentication()
.withUser("admin").password("123").roles("admin");
}
}
即，配置的用户名为 admin，密码为 123，角色为 admin
HttpSecurity
这里对一些方法进行拦截
packagecom.ming.demo.interceptor;
@Configuration
@EnableWebSecurity
publicclassSecurityConfigextendsWebSecurityConfigurerAdapter{
@Override
publicvoidconfigure(AuthenticationManagerBuilderauth)throwsException{
auth.inMemoryAuthentication()
.withUser("itguang").password("123456").roles("USER").and()
.withUser("admin").password("{noop}"+"123456").roles("ADMIN");
}
@Override
protectedvoidconfigure(HttpSecurityhttp)throwsException{
http.authorizeRequests()
.anyRequest().permitAll()
.and()
.formLogin()
.permitAll()
.and()
.logout()
.permitAll();
}
}
即，这里完成了对所有的方法访问的拦截。
这是一个小 demo，目的，登录以后返回 jwt 生成的 token
导入依赖
添加 web 依赖
导入 JWT 和 Security 依赖
<dependency>
<groupId>io.jsonwebtokengroupId>
<artifactId>jjwtartifactId>
<version>0.9.1version>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-securityartifactId>
<version>2.3.1.RELEASEversion>
dependency>
创建一个 JwtUser 实现 UserDetails
创建 一个相关的 JavaBean
packagecom.example.demo;
importorg.springframework.security.core.GrantedAuthority;
importorg.springframework.security.core.userdetails.UserDetails;
importjava.util.Collection;
publicclassJwtUserimplementsUserDetails{
privateStringusername;
privateStringpassword;
privateIntegerstate;
privateCollectionauthorities;
publicJwtUser(){
}
publicJwtUser(Stringusername,Stringpassword,Integerstate,Collectionauthorities){
this.username=username;
this.password=password;
this.state=state;
this.authorities=authorities;
}
@Override
publicCollectiongetAuthorities(){
returnauthorities;
}
@Override
publicStringgetPassword(){
returnthis.password;
}
@Override
publicStringgetUsername(){
returnthis.username;
}
@Override
publicbooleanisAccountNonExpired(){
returntrue;
}
@Override
publicbooleanisAccountNonLocked(){
returntrue;
}
@Override
publicbooleanisCredentialsNonExpired(){
returntrue;
}
@Override
publicbooleanisEnabled(){
returntrue;
}
}
编写工具类生成令牌
编写工具类，用来生成 token，以及刷新 token，以及验证 token。
packagecom.example.demo;
publicclassJwtTokenUtilimplementsSerializable{
privateStringsecret;
privateLongexpiration;
privateStringheader;
privateStringgenerateToken(Mapclaims) {
DateexpirationDate=newDate(System.currentTimeMillis()+expiration);
returnJwts.builder().setClaims(claims).setExpiration(expirationDate).signWith(SignatureAlgorithm.HS512,secret).compact();
}
privateClaimsgetClaimsFromToken(Stringtoken){
Claimsclaims;
try{
claims=Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
}catch(Exceptione){
claims=null;
}
returnclaims;
}
publicStringgenerateToken(UserDetailsuserDetails){
Mapclaims=newHashMap<>(2);
claims.put("sub",userDetails.getUsername());
claims.put("created",newDate());
returngenerateToken(claims);
}
publicStringgetUsernameFromToken(Stringtoken){
Stringusername;
try{
Claimsclaims=getClaimsFromToken(token);
username=claims.getSubject();
}catch(Exceptione){
username=null;
}
returnusername;
}
publicBooleanisTokenExpired(Stringtoken){
try{
Claimsclaims=getClaimsFromToken(token);
Dateexpiration=claims.getExpiration();
returnexpiration.before(newDate());
}catch(Exceptione){
returnfalse;
}
}
publicStringrefreshToken(Stringtoken){
StringrefreshedToken;
try{
Claimsclaims=getClaimsFromToken(token);
claims.put("created",newDate());
refreshedToken=generateToken(claims);
}catch(Exceptione){
refreshedToken=null;
}
returnrefreshedToken;
}
publicBooleanvalidateToken(Stringtoken,UserDetailsuserDetails){
JwtUseruser=(JwtUser)userDetails;
Stringusername=getUsernameFromToken(token);
return(username.equals(user.getUsername())&&!isTokenExpired(token));
}
}
编写拦截器
编写 Filter 用来检测 JWT
packagecom.example.demo;
@Component
publicclassJwtAuthenticationTokenFilterextendsOncePerRequestFilter{
@Autowired
privateUserDetailsServiceuserDetailsService;
@Autowired
privateJwtTokenUtiljwtTokenUtil;
@Override
protectedvoiddoFilterInternal(HttpServletRequesthttpServletRequest,HttpServletResponsehttpServletResponse,FilterChainfilterChain)throwsServletException,IOException{
StringauthHeader=httpServletRequest.getHeader(jwtTokenUtil.getHeader());
if(authHeader!=null&&StringUtils.isNotEmpty(authHeader)){
Stringusername=jwtTokenUtil.getUsernameFromToken(authHeader);
if(username!=null&&SecurityContextHolder.getContext().getAuthentication()==null){
UserDetailsuserDetails=this.userDetailsService.loadUserByUsername(username);
if(jwtTokenUtil.validateToken(authHeader,userDetails)){
UsernamePasswordAuthenticationTokenauthentication=
newUsernamePasswordAuthenticationToken(userDetails,null,userDetails.getAuthorities());
authentication.setDetails(newWebAuthenticationDetailsSource().buildDetails(httpServletRequest));
SecurityContextHolder.getContext().setAuthentication(authentication);
}
}
}
filterChain.doFilter(httpServletRequest,httpServletResponse);
}
}
编写 userDetailsService 的实现类
在上方代码中，编写 userDetailsService，类，实现其验证过程
packagecom.example.demo;
@Service
publicclassJwtUserDetailsServiceImplimplementsUserDetailsService{
@Autowired
privateUserMapperuserMapper;
@Override
publicUserDetailsloadUserByUsername(Strings)throwsUsernameNotFoundException{
Useruser=userMapper.selectByUserName(s);
if(user==null){
thrownewUsernameNotFoundException(String.format("'%s'.这个用户不存在",s));
}
Listcollect=user.getRoles().stream().map(Role::new).collect(Collectors.toList());
returnnewJwtUser(user.getUsername(),user.getPassword(),user.getState(),collect);
}
}
编写登录
编写登录业务的实现类 其 login 方法会返回一个 JWTUtils 的 token
@Service
publicclassUserServiceImplimplementsUserService{
@Autowired
privateUserMapperuserMapper;
@Autowired
privateAuthenticationManagerauthenticationManager;
@Autowired
privateUserDetailsServiceuserDetailsService;
@Autowired
privateJwtTokenUtiljwtTokenUtil;
publicUserfindByUsername(Stringusername){
Useruser=userMapper.selectByUserName(username);
returnuser;
}
publicRetResultlogin(Stringusername,Stringpassword)throwsAuthenticationException{
UsernamePasswordAuthenticationTokenupToken=newUsernamePasswordAuthenticationToken(username,password);
finalAuthenticationauthentication=authenticationManager.authenticate(upToken);
SecurityContextHolder.getContext().setAuthentication(authentication);
UserDetailsuserDetails=userDetailsService.loadUserByUsername(username);
returnnewRetResult(RetCode.SUCCESS.getCode(),jwtTokenUtil.generateToken(userDetails));
}
}
最后配置 Config
@EnableGlobalMethodSecurity(prePostEnabled=true)
@EnableWebSecurity
publicclassWebSecurityextendsWebSecurityConfigurerAdapter{
@Autowired
privateUserDetailsServiceuserDetailsService;
@Autowired
privateJwtAuthenticationTokenFilterjwtAuthenticationTokenFilter;
@Autowired
publicvoidconfigureAuthentication(AuthenticationManagerBuilderauthenticationManagerBuilder)throwsException{
authenticationManagerBuilder.userDetailsService(this.userDetailsService).passwordEncoder(passwordEncoder());
}
@Bean(name=BeanIds.AUTHENTICATION_MANAGER)
@Override
publicAuthenticationManagerauthenticationManagerBean()throwsException{
returnsuper.authenticationManagerBean();
}
@Bean
publicPasswordEncoderpasswordEncoder(){
returnnewBCryptPasswordEncoder();
}
@Override
protectedvoidconfigure(HttpSecurityhttp)throwsException{
http.csrf().disable().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and().authorizeRequests()
.antMatchers(HttpMethod.OPTIONS,"/**").permitAll()
.antMatchers("/auth/**").permitAll()
.anyRequest().authenticated()
.and().headers().cacheControl();
http.addFilterBefore(jwtAuthenticationTokenFilter,UsernamePasswordAuthenticationFilter.class);
ExpressionUrlAuthorizationConfigurer.ExpressionInterceptUrlRegistryregistry=http.authorizeRequests();
registry.requestMatchers(CorsUtils::isPreFlightRequest).permitAll();
}
@Bean
publicCorsFiltercorsFilter(){
finalUrlBasedCorsConfigurationSourceurlBasedCorsConfigurationSource=newUrlBasedCorsConfigurationSource();
finalCorsConfigurationcors=newCorsConfiguration();
cors.setAllowCredentials(true);
cors.addAllowedOrigin("*");
cors.addAllowedHeader("*");
cors.addAllowedMethod("*");
urlBasedCorsConfigurationSource.registerCorsConfiguration("/**",cors);
returnnewCorsFilter(urlBasedCorsConfigurationSource);
}
}
运行，返回 token
运行，返回结果为 token
这里配置 SpringSecurity 之 JSON 登录
这里需要重写 UsernamePasswordAnthenticationFilter 类，以及配置 SpringSecurity
重写 UsernamePasswordAnthenticationFilter
publicclassCustomAuthenticationFilterextendsUsernamePasswordAuthenticationFilter{
@Override
publicAuthenticationattemptAuthentication(HttpServletRequestrequest,HttpServletResponseresponse)throwsAuthenticationException{
if(request.getContentType().equals(MediaType.APPLICATION_JSON_UTF8_VALUE)
||request.getContentType().equals(MediaType.APPLICATION_JSON_VALUE)){
ObjectMappermapper=newObjectMapper();
UsernamePasswordAuthenticationTokenauthRequest=null;
try(InputStreamis=request.getInputStream()){
AuthenticationBeanauthenticationBean=mapper.readValue(is,AuthenticationBean.class);
authRequest=newUsernamePasswordAuthenticationToken(
authenticationBean.getUsername(),authenticationBean.getPassword());
}catch(IOExceptione){
e.printStackTrace();
authRequest=newUsernamePasswordAuthenticationToken(
"","");
}finally{
setDetails(request,authRequest);
returnthis.getAuthenticationManager().authenticate(authRequest);
}
}
else{
returnsuper.attemptAuthentication(request,response);
}
}
}
配置 SecurityConfig
@Override
protectedvoidconfigure(HttpSecurityhttp)throwsException{
http
.cors().and()
.antMatcher("/**").authorizeRequests()
.antMatchers("/","/login**").permitAll()
.anyRequest().authenticated()
.and().formLogin().loginPage("/")
.and().csrf().disable();
http.addFilterAt(customAuthenticationFilter(),
UsernamePasswordAuthenticationFilter.class);
}
@Bean
CustomAuthenticationFiltercustomAuthenticationFilter()throwsException{
CustomAuthenticationFilterfilter=newCustomAuthenticationFilter();
filter.setAuthenticationSuccessHandler(newSuccessHandler());
filter.setAuthenticationFailureHandler(newFailureHandler());
filter.setFilterProcessesUrl("/login/self");
filter.setAuthenticationManager(authenticationManagerBean());
returnfilter;
}
这样就完成使用 json 登录 SpringSecurity
需要在 Config 类中配置如下内容
@Bean
publicBCryptPasswordEncoderpasswordEncoder(){
returnnewBCryptPasswordEncoder();
}
即，使用此方法，对密码进行加密， 在业务层的时候，使用此加密的方法
@Service
@Transactional
publicclassUserServiceImplimplementsUserService{
@Resource
privateUserRepositoryuserRepository;
@Resource
privateBCryptPasswordEncoderbCryptPasswordEncoder;
@Override
publicUseradd(Useruser){
user.setPassword(bCryptPasswordEncoder.encode(user.getPassword()));
Useruser2=userRepository.save(user);
returnuser2;
}
@Override
publicResultInfologin(Useruser){
ResultInforesultInfo=newResultInfo();
Useruser2=userRepository.findByName(user.getName());
if(user2==null){
resultInfo.setCode("-1");
resultInfo.setMessage("用户名不存在");
returnresultInfo;
}
if(!bCryptPasswordEncoder.matches(user.getPassword(),user2.getPassword())){
resultInfo.setCode("-1");
resultInfo.setMessage("密码不正确");
returnresultInfo;
}
resultInfo.setMessage("登录成功");
returnresultInfo;
}
}
即，使用 BCryptPasswordEncoder 对密码进行加密，保存数据库
这里使用数据库认证 SpringSecurity
设计数据表
这里设计数据表
着重配置 SpringConfig
@Configurable
publicclassWebSecurityConfigextendsWebSecurityConfigurerAdapter{
@Autowired
privateUserServiceuserService;
@Bean
PasswordEncoderpasswordEncoder(){
returnnewBCryptPasswordEncoder();
}
@Override
protectedvoidconfigure(AuthenticationManagerBuilderauth)throwsException{
auth.userDetailsService(userService);
}
@Override
protectedvoidconfigure(HttpSecurityhttp)throwsException{
http.authorizeRequests()
.antMatchers("/admin/**").hasRole("admin")
.anyRequest().authenticated()
.and()
.formLogin()
.loginProcessingUrl("/login").permitAll()
.and()
.csrf().disable();
}
}
这里着重配置 SpringConfig。
着重讲解了 RBAC 的权限配置，以及简单的使用 SpringSecurity，以及使用 SpringSecurity + JWT 完成前后端的分离，以及配置 json 登录，和密码加密方式。
声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。
举报投诉
-
RBAC
+关注
关注
0文章
44浏览量
9975 -
权限系统
+关注
关注
0文章
6浏览量
5963
原文标题：公司新来了一个同事，把权限系统设计的炉火纯青！
文章出处：【微信号：芋道源码，微信公众号：芋道源码】欢迎添加关注！文章转载请注明出处。
发布评论请先 登录
相关推荐
Spring Security 的关键配置
class SecurityConfig extends WebSecurityConfigurerAdapter { //配置 Spring Security 中的过滤器链 @Override
什么是java spring
，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。 所有Spring的这些特征使你能够编
发表于 09-11 11:16
wifi wl18xx整合编译内核关闭CONFIG_SECURITY，会造成什么影响吗?
wifi wl18xx整合编译内核关闭CONFIG_SECURITY这个配置项，会造成什么影响吗?
发表于 04-01 09:57
Mybatis整合spring的思路和步骤
1、整合思路（1）SqlSessionFactory对象应该放到spring容器中作为单例存在。（2）传统dao的开发方式中，应该从spring容器中获得sqlsession对象。（3）Mapper
发表于 11-04 09:06
启动Spring Boot项目应用的三种方法
，从而使开发人员不再需要定义样板化的配置。用我的话来理解，就是spring boot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot
发表于 01-14 17:33
基于Spring Security安全框架的联通资源管理系统安全分析
基于为联通资源管系统提供一个方便可靠的安全框架的目的，采用面向切面编程（AOP）的Spring Security安全框架，结合了Spring框架提供的控制反转技术，最终创建了一个功能强大、安全可
发表于 05-14 11:56
•0次下载
你知道Linux Security模块是怎样的？
Linux Security Modules (LSM) 是一种 Linux 内核子系统，旨在将内核以模块形式集成到各种安全模块中。在 2001 年的 Linux Kernel 峰会上，NSA 代表
发表于 05-15 16:38
•2626次阅读
为什么使用spring-authorization-server？
官方原因：原先使用Spring Security OAuth，而该项目已经逐渐被淘汰，虽然网上还是有不少该方案，但秉着技术要随时代更新，从而使用spring-authorization-server
Spring Boot 3.1 中如何整合Spring Security和Keycloak
虽然Keycloak 团队宣布了不再对Spring Security提供适配，但Spring Security长期以来一直为OAuth和OIDC提供强大的内置支持。所以，只要我们理解
工商网监
评论