基于Spring Security5 和 JWT做前后端分离安全验证实践

最新推荐文章于 2024-04-26 11:04:38 发布
最新推荐文章于 2024-04-26 11:04:38 发布
阅读量560 收藏
点赞数 2
分类专栏： JAVA 文章标签： spring java jwt spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tq26556570/article/details/107447044
版权

文章目录

基于Spring Security + JWT的权限管理的简单实践

项目介绍

这是一个基于Spring Security + JWT的前后端分离权限管理小例子，方便入门Spring Security的朋友学习，用到的框架和数据库如下：

  • Spring Boot 2.2.2
  • Spring Security
  • Spring Data JPA
  • jjwt
  • Ehcache
  • MySQL 8.0.16

主要功能是

  • 用户登录验证后返回token，根据token可以访问其他资源
  • token有效期为30分钟，每次请求成功都会重新刷新token，旧的token就会失效
  • 如果30分钟内没有任何操作，一旦token过期需要重新登录
  • 做了获取当前用户信息和获取当前用户的角色可以访问的资源菜单的简单演示

基于安全的策略

  • 为了防止token被劫持，添加了与客户端MAC地址绑定的机制
  • 为了应对同一用户发送了并发请求，由于token刷新造成的部分请求token验证不通过的情况，将旧的token缓存起来，有效期为3秒

代码地址

项目需要依赖heart-parent及其子项目heart-base两个项目

项目如何运行

  1. 从gitee上克隆项目
  2. 创建MySQL数据库，并运行项目根目录中的security-manager.sql
  3. resources目录下的application.yml配置好数据库链接
  4. 运行org.my.heart.SecurityManagerApplication.java启动项目

项目如何访问

需要安装Postman

登录请求

POST请求：127.0.0.1:8080/user/login

data：{“username”: “zhangsan”, “password”: “1234”}

在这里插入图片描述

请求成功，响应头将会返回token

在这里插入图片描述

在这里插入图片描述

后面的请求，头信息都必须带上这个token才能通过验证。

获取用户信息和菜单权限

  • 获取用户信息
    GET请求：127.0.0.1:8080/user/info

将登录返回的token放到请求头里面

在这里插入图片描述

请求成功会看到下面的效果

输入图片说明

响应头会返回新的token

在这里插入图片描述

下一次请求就要用这个新的token了

  • 获取菜单权限
    GET请求：127.0.0.1:8080/role/menu/0

请求的方法跟获取用户信息一样

请求成功会看到下面的效果

在这里插入图片描述

代码分析

入口

项目启动的时候，Spring Security会运行用注解**@EnableWebSecurity标注的配置类，来配置Spring Security的策略，这个类需要继承WebSecurityConfigurerAdapter**，并且实现下面两个configure方法。

因此，按照上述规则，创建HeartSecurityConfig类

@Configuration
@EnableWebSecurity
public class HeartSecurityConfig extends WebSecurityConfigurerAdapter {

	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
		// 配置AuthenticationManager，全局认证管理对象
	}

	@Override
	protected void configure(HttpSecurity http) throws Exception {
		// 配置请求过滤规则
	}
}

所以我们下面自定义的种种验证规则，最后都会通过这个类配置到Spring Security中

简单了解Spring Security的登录验证

登录时一般会通过用户名和密码进行验证，Spring Security给出的默认实现是UsernamePasswordAuthenticationFilter过滤器，默认拦截/login请求，通过attemptAuthentication方法获取用户名和密码，默认是通过request.getParameter()，最后将获取到的用户名和密码传到后面的类进行验证。有兴趣的朋友可以自行跟踪源码了解整个机制。

public Authentication attemptAuthentication(HttpServletRequest request,HttpServletResponse response) throws AuthenticationException {
	if (postOnly && !request.getMethod().equals("POST")) {
		throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
	}

	// request.getParameter()方法获取请求中的用户名和密码
	String username = obtainUsername(request);
	String password = obtainPassword(request);

	if (username == null) {
        username = "";
        }

    if (password == null) {
    	password = "";
	}

	username = username.trim();

	UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);

	// Allow subclasses to set the "details" property
	setDetails(request, authRequest);

	// 将获取的用户名和密码传递给后续的类进行验证
	return this.getAuthenticationManager().authenticate(authRequest);
}

改造UsernamePasswordAuthenticationFilter

需要改造的有两点：

  1. 前后端分离的情况下，前端会发送POST的Ajax请求到后端，用户名和密码一般是通过request body发送的，request.getParameter()是拿不到的，所以用户名和密码的获取方式需要改变
  2. 登录请求地址不一定是/login，可以自定义

首先处理第1点，下面是创建一个自定义的过滤器RequestBodyUsernamePasswordAuthenticationFilter，继承UsernamePasswordAuthenticationFilter，并重写attemptAuthentication方法

public class RequestBodyUsernamePasswordAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

	private static final Logger log = LoggerFactory.getLogger(RequestBodyUsernamePasswordAuthenticationFilter.class);

	@Autowired
	private ExceptionResovler exceptionResovler;
	
	@Override
	public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
		try {
			// 从request body中获取前端发送的用户名和密码
			LoginUser loginUser = new ObjectMapper().readValue(request.getInputStream(), LoginUser.class);
			if (loginUser == null) {
				log.error("账号不存在");
				exceptionResovler.handleAuthenticationException(response, new AuthenticationCredentialsNotFoundException("账号不存在"));
				return null;
			}
			log.debug("获取到用户名：" + loginUser.getUsername() + "，密码：" + loginUser.getPassword());
			// 下面的逻辑就跟UsernamePasswordAuthenticationFilter一样了
			UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(loginUser.getUsername(), loginUser.getPassword());
			return this.getAuthenticationManager().authenticate(authRequest);
		} catch (Exception e) {
			log.error("登录异常，错误：" + e.getMessage());
			try {
				exceptionResovler.handleAccessDeniedException(response, new AuthorizationServiceException("登录异常，请与管理员联系"));
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		}
		return null;
	}
}

处理第2点，在HeartSecurityConfig中注入RequestBodyUsernamePasswordAuthenticationFilter，实例化的时候可以自定义拦截的登录路径

@Configuration
@EnableWebSecurity
public class HeartSecurityConfig extends WebSecurityConfigurerAdapter {

	// 登录验证过滤器
	@Bean
	public UsernamePasswordAuthenticationFilter requestBodyUsernamePasswordAuthenticationFilter() throws Exception {
		RequestBodyUsernamePasswordAuthenticationFilter filter = new RequestBodyUsernamePasswordAuthenticationFilter();
		// 不指定拦截路径就算替换了UsernamePasswordAuthenticaitonFilter都不会进来
		filter.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher("/user/login", HttpMethod.POST.name()));
		// 自定义UsernamePasswordAuthenticationFilter就会导致原来configure中的.successHandler和.failureHandler失效
		filter.setAuthenticationSuccessHandler(jwtAuthenticationSuccessHandler);
		filter.setAuthenticationFailureHandler(jwtAuthentiacionFailureHandler);
		// 自定义filter必须指定AuthenticationManager
		filter.setAuthenticationManager(authenticationManager());
		return filter;
	}

	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
		// 配置AuthenticationManager，全局认证管理对象
	}

	@Override
	protected void configure(HttpSecurity http) throws Exception {
		// 配置请求过滤规则
	}
}

从数据库中读取用户信息与前端用户名和密码对比

从数据库读取用户信息，Spring Security提供了默认的实现，JdbcUserDetailsManager，不过每个系统都有自己的业务逻辑，所以一般都会自定义一个，Spring Security给我们提供了UserDetailsService接口，只要实现这个接口，即可自定义自已的业务逻辑。

这里创建了JWTUserDetailsService，通过前端传递的username从数据库读取用户信息。返回的用户信息对象JWTUser则需要实现UserDetails接口，可以根据自己的业务需要来定义用户信息的成员变量。

JWTUser

public class JWTUser implements UserDetails {

	private static final long serialVersionUID = -8259845930972485319L;

	private Long id;

	private String username;

	private String name;

	private String password;

	private List<GrantedAuthority> authorities;
	
	private Boolean nonLock;

	private Boolean gredentialsNonExpired;

	private Boolean enabled;
	
	private String macAddress;

	public static JWTUser build() {
		return new JWTUser();
	}

	public Long getId() {
		return id;
	}

	public JWTUser setId(Long id) {
		this.id = id;
		return this;
	}

	public JWTUser setUsername(String username) {
		this.username = username;
		return this;
	}

	public String getName() {
		return name;
	}

	public JWTUser setName(String name) {
		this.name = name;
		return this;
	}

	public JWTUser setPassword(String password) {
		this.password = password;
		return this;
	}

	public JWTUser setAuthorities(List<GrantedAuthority> authorities) {
		this.authorities = authorities;
		return this;
	}

	public JWTUser setNonLock(Boolean nonLock) {
		this.nonLock = nonLock;
		return this;
	}

	public JWTUser setGredentialsNonExpired(Boolean gredentialsNonExpired) {
		this.gredentialsNonExpired = gredentialsNonExpired;
		return this;
	}

	public JWTUser setEnabled(Boolean enabled) {
		this.enabled = enabled;
		return this;
	}

	@Override
	public Collection<? extends GrantedAuthority> getAuthorities() {
		return this.authorities;
	}

	@Override
	public String getPassword() {
		return this.password;
	}

	@Override
	public String getUsername() {
		return this.username;
	}

	@Override
	public boolean isAccountNonExpired() {
		return true;
	}

	@Override
	public boolean isAccountNonLocked() {
		return this.nonLock;
	}

	@Override
	public boolean isCredentialsNonExpired() {
		return this.gredentialsNonExpired;
	}

	@Override
	public boolean isEnabled() {
		return this.enabled;
	}

	public String getMacAddress() {
		return macAddress;
	}

	public JWTUser setMacAddress(String macAddress) {
		this.macAddress = macAddress;
		return this;
	}

}

JWTUserDetailsService

@Service("jwtUserDetailsService")
public class JWTUserDetailsService implements UserDetailsService {

	@Autowired
	private UserRepository userRepository;

	@Override
	@Transactional(readOnly = true)
	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
		// 通过username查询对应的用户信息，下面是JPA的条件查询写法
		Optional<User> userOptional = userRepository.findOne(new Specification<User>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
				Predicate equal = criteriaBuilder.equal(root.get("username"), username);
				return equal;
			}
		});
		User user = userOptional.get();
		
		// 生成用户信息，提供给Spring Security进行校验
		JWTUser jwtUser = JWTUser.build()
									.setId(user.getId())
									.setUsername(username)
									.setName(user.getName())
									.setPassword(user.getPassword())
									.setNonLock(user.getNonLock())
									.setGredentialsNonExpired(user.getGredentialsNonExpired())
									.setEnabled(user.getEnabled());
		// 读取角色数据
		List<Role> roles = user.getRoles();
		if (roles != null && roles.size() > 0) {
			String[] roleIdArr = new String[roles.size()];
			for (int i = 0; i < roles.size(); i++) {
				roleIdArr[i] = roles.get(i).getId().toString();
			}
			jwtUser.setAuthorities(AuthorityUtils.commaSeparatedStringToAuthorityList(StringUtils.join(roleIdArr, ",")));
		}
		return jwtUser;
	}

}

自定义密码加密算法

Spring Security会使用定义好的加密算法，将前端传来的密码加密,然后跟数据库中读取到的用户信息中的密码进行对比，所以数据库中存的密码是经过加密后的字符串。

至于用什么加密算法，需要我们先声明和注入到Spring容器中。在HeartSecurityConfig中注入加密处理类，这里使用加盐算法：

// 全局加密算法
@Bean
public PasswordEncoder getPasswordEncoder() {
	// 加盐算法
	return new BCryptPasswordEncoder();
}

自定义登录验证成功和失败处理

登录的验证Spring Security底层已帮我们做好，成功和失败的处理也有默认实现，不过我们一般都要根据自己的业务来定义处理逻辑，我们需要定义两个类，实现AuthenticationSuccessHandler和AuthenticationFailureHandler。

项目结合的是JWT，所以成功是会返回一个JWT规范的token，失败则返回错误信息。这里创建JWTAuthenticationSuccessHandler和JWTAuthentiacionFailureHandler：

JWTAuthenticationSuccessHandler

@Component("jwtAuthenticationSuccessHandler")
public class JWTAuthenticationSuccessHandler implements AuthenticationSuccessHandler {

	private static final Logger log = LoggerFactory.getLogger(JWTAuthenticationSuccessHandler.class);

	@Autowired
	private JWTTokenHandler jwtTokenHandler;

	@Override
	public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
		// Spring Security会将用户信息传递过来
		JWTUser jwtUser = (JWTUser) authentication.getPrincipal();

		// 生成JWT规范的token，绑定客户端MAC地址
		String ipAddress = IpUtils.getIpAddress(request);
		String macAddress = IpUtils.getMacAddress(ipAddress);
		// 按照规范，token会响应到Authorization头信息中
		response.setHeader(JWTTokenHandler.TOKEN_HEADER_NAME, jwtTokenHandler.buildToken(jwtUser.setMacAddress(macAddress)));
		ResponseUtils.buildResponseBody(response, Result.ok("登录成功"));
		log.debug("登录成功");
	}

}

其中JWTTokenHandler类封装了所有token的操作方法

JWTAuthentiacionFailureHandler

@Component("jwtAuthentiacionFailureHandler")
public class JWTAuthentiacionFailureHandler implements AuthenticationFailureHandler {

	private static final Logger log = LoggerFactory.getLogger(JWTAuthentiacionFailureHandler.class);

	@Override
	public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
		ResponseUtils.buildResponseBody(response, Result.failure(HttpStatus.UNAUTHORIZED.value()).setMessage(exception.getMessage()));
		log.debug("登录失败");
	}

}

至此整个登录验证过程结束了

根据token验证请求

登录验证成功之后，响应token到前端，前端根据这个token来访问其他资源，所以需要定义一个过滤器来验证token的有效性，为了确保这个过滤器每个请求都会触发一次，所以需要继承OncePerRequestFilter。

当请求被登录验证过滤器拦截后，OncePerRequestFilter不会被触发

这里创建JWTAuthenticationFilter进行token验证：

@Component("jwtAuthenticationFilter")
public class JWTAuthenticationFilter extends OncePerRequestFilter {

	@Autowired
	private JWTTokenHandler jwtTokenHandler;
	
	@Autowired
	private ExceptionResovler exceptionResovler;
	
	@Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
		// 获取前端传来的token
		String token = jwtTokenHandler.getToken(request);
		if (StringUtils.isBlank(token)) {
			exceptionResovler.handleAuthenticationException(response, new AuthenticationCredentialsNotFoundException("请登录"));
			return;
		}
		try {
			// 解析token，如果token解析失败，这句代码会根据失败的类型抛出不同的异常，所以解析token即是验证token的合法性
			JWTUser jwtUser = jwtTokenHandler.parseToken(token);
			// 从缓存中读取最新的token
			String tokenFromCache = jwtTokenHandler.getTokenFromCache(jwtUser.getId());
			// 判断这个token是否失效
			if(!token.equals(tokenFromCache)) {
				// 前端传来的可能是老的token，从缓存中读取为过期的老token
				tokenFromCache = jwtTokenHandler.getTokenFromOldCache(token);
				if(StringUtils.isBlank(tokenFromCache)) {
					// 如果缓存中没有这个老token，说明已经失效了
					exceptionResovler.handleAuthenticationException(response, new CredentialsExpiredException("令牌已失效"));
					return;
				}
			}
			// 判断请求方的mac地址是否也token里的一致，防止劫持token发起的攻击
			if (jwtUser.getMacAddress().equals(IpUtils.getMacAddress(IpUtils.getIpAddress(request)))) {
				// token通过验证
				authorizeSuccess(token, jwtUser, response);
				filterChain.doFilter(request, response);
			} else {
				// token被劫持
				exceptionResovler.handleAuthenticationException(response, new BadCredentialsException("这样做是犯法的哦^_^"));
				return;
			}
		} catch (ExpiredJwtException e) {
			// 超过了30分钟，token过期
			exceptionResovler.handleAuthenticationException(response, new CredentialsExpiredException("令牌过期，请重新登录"));
			return;
		} catch (SignatureException e) {
			// token被篡改
			exceptionResovler.handleAuthenticationException(response, new BadCredentialsException("这样做是犯法的哦^_^"));
			return;
		}catch (MalformedJwtException e) {
			// token格式异常
			exceptionResovler.handleAuthenticationException(response, new BadCredentialsException("这样做是犯法的哦^_^"));
			return;
		}
	}
	
	/*
	 * token验证成功
	 */
	private void authorizeSuccess(String oldToken, JWTUser jwtUser, HttpServletResponse response) throws IOException {
		// 产生新token
		String newToken = jwtTokenHandler.buildToken(jwtUser);
		
		// 以老token为key缓存新token，期限为3秒，防止同时多个异步请求
		String tokenFromCache = jwtTokenHandler.getTokenFromOldCache(oldToken);
		if(StringUtils.isBlank(tokenFromCache)) {
			jwtTokenHandler.cacheOldToken(oldToken, newToken);
		}
		
		// 将新token写到响应头信息中
		response.setHeader(JWTTokenHandler.TOKEN_HEADER_NAME, newToken);
	}

}

只有通过了这个过滤器后，请求才能到达controller层

将自定义策略配置到Spring Security

上面自定义的策略需要在HeartSecurityConfig里配置才能生效，HeartSecurityConfig完整代码如下：

@Configuration
@EnableWebSecurity
public class HeartSecurityConfig extends WebSecurityConfigurerAdapter {

	@Autowired
	private UserDetailsService jwtUserDetailService;

	@Autowired
	private AuthenticationSuccessHandler jwtAuthenticationSuccessHandler;

	@Autowired
	private AuthenticationFailureHandler jwtAuthentiacionFailureHandler;

	@Autowired
	private OncePerRequestFilter jwtAuthenticationFilter;

	// 全局加密算法
	@Bean
	public PasswordEncoder getPasswordEncoder() {
		return new BCryptPasswordEncoder();
	}

	// 登录验证过滤器
	@Bean
	public UsernamePasswordAuthenticationFilter requestBodyUsernamePasswordAuthenticationFilter() throws Exception {
		RequestBodyUsernamePasswordAuthenticationFilter filter = new RequestBodyUsernamePasswordAuthenticationFilter();
		// 不指定拦截路径就算替换了UsernamePasswordAuthenticaitonFilter都不会进来
		filter.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher("/user/login", HttpMethod.POST.name()));
		// 自定义UsernamePasswordAuthenticationFilter就会导致原来configure中的.successHandler和.failureHandler失效
		filter.setAuthenticationSuccessHandler(jwtAuthenticationSuccessHandler);
		filter.setAuthenticationFailureHandler(jwtAuthentiacionFailureHandler);
		// 自定义filter必须指定AuthenticationManager
		filter.setAuthenticationManager(authenticationManager());
		return filter;
	}

	/**
	 * 配置AuthenticationManager，全局认证管理对象
	 */
	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
		// 配置从数据库读取用户信息的自定义实现
		auth.userDetailsService(jwtUserDetailService);
	}

	/**
	 * 配置请求过滤规则
	 */
	@Override
	protected void configure(HttpSecurity http) throws Exception {
		// 表单登录
		http.formLogin().and()
				// 替换默认的用户名密码验证过滤器UsernamePasswordAuthenticationFilter
				.addFilterAt(requestBodyUsernamePasswordAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class)
				// JWT验证不需要session
				.sessionManagement().disable()
				// 没有session机制则不需要csrf防护
				.csrf().disable()
				// 添加权限验证过滤器
				.addFilterAfter(jwtAuthenticationFilter, RequestBodyUsernamePasswordAuthenticationFilter.class);
	}
}

整个项目的主要业务逻辑到这里结束了，业务细节可以通过阅读源码了解，再见_

素者素心
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring boot2 + springsecurity5 + jwt 例子
神盾局码农
07-15 238
准备 开始本教程的时候希望对下面知识点进行粗略的了解。 知道 JWT 的基本概念 了解过 Spring Security 本项目中JWT密钥是使用用户自己的登入密码，这样每一个token的密钥都不同，相对比较安全。 大体思路： 登入： POST 用户名密码到 \login 请求到达JwtAuthenticationFilter中的attemptAuthentication()方法，获取 request 中的 POST 参数，包装成一个Usernam...
SpringSecurity与JWT鉴权
qq_43244309的博客
05-05 265
最近在博客开发中使用SpringSecurity框架，记录一下。
spring-security5.x+jwt
qq_67832732的博客
04-26 360
创建过滤器@Component@Autowired@Override//获取tokenif (!//放行return;//解析tokentry {throw new RuntimeException("token非法");//从redis中获取用户信息throw new RuntimeException("用户未登录");//存入SecurityContextHolder。
SpringBoot 2 + Spring Security 5 + JWT 的单页应用 Restful 解决方案
好好学java
11-07 353
点击上方好好学java，选择星标公众号重磅资讯、干货，第一时间送达 今日推荐：硬刚一周，3W字总结，一年的经验告诉你如何准备校招！个人原创100W+访问量博客：点击前往，查看...
Spring Security框架 前后端分离版
asddasddeedd的博客
11-19 3318
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring Security 重要核心功能。
Spring Security 前后端分离
Markix的博客
11-14 3241
前后端分离指的就是前后端分离部署，前端 调用后端API，后端 返回 JSON格式数据，页面是由前端渲染并展示到浏览器中。Spring Security 涉及到的扩展点： 登录成功处理：AuthenticationSuccessHandler 登录失败处理：AuthenticationFailureHandler 登出成功处理：LogoutSuccessHandler 未登录处理：AuthenticationEntryPoint 鉴权失败处理：AccessDeniedHandler
Spring-Boot结合Security+JWT 简单实现前后端分离用户登录、授权案例
07-12
Spring-Security结合JWT 实现前后端分离完成权限验证功能案例，案例中，主要完成用户登录获取Token，通过Token访问Rest接口，没有权限或授权失败时返回JSON，前端根据状态码进行重新登录；案例中的用户名称： jake_j...
基于SpringBoot+Spring Security+JWT+Vue+Elemen的前后端分离权限管理系统+数据库.zip
最新发布
07-02
基于SpringBoot+Spring Security+JWT+Vue+Elemen的前后端分离权限管理系统+数据库.zip基于SpringBoot+Spring Security+JWT+Vue+Elemen的前后端分离权限管理系统+数据库.zip基于SpringBoot+Spring Security+JWT+Vue+...
基于 SpringBoot、Spring Security、JWT 的前后端分离权限管理系统.zip
02-22
这是一个基于 Spring Boot、Spring Security 和 JSON Web Token (JWT) 构建的前后端分离权限管理系统的项目。在本文中，我们将深入探讨这些技术组件以及它们如何协同工作来创建一个高效且安全的系统。 1. **Spring ...
基于SpringBoot，Spring Security，JWT的前后端分离权限管理系统.zip
08-05
"基于SpringBoot，Spring Security，JWT的前后端分离权限管理系统"这个标题表明，这是一个使用了现代Web开发技术的项目，主要涉及以下几个关键知识点： 1. SpringBoot：SpringBoot是Spring框架的一个扩展，它简化了...
spring boot security 自定义登陆、成功处理、失败处理
我是一只蘑菇17的博客
09-27 820
网上默认添加认证成功处理类在我们自己定义的安全配置类中 BrowerSecurityConfig extends WebSecurityConfigurerAdapter。定义自定义成功处理类，继承SavedRequestAwareAuthenticationSuccessHandler。在configure 方法中的http 设置了自定义登录成功与登录失败处理（如上）// 定义当需要用户登录时候，转到的登录页面。... 此处省略不关键代码。// 自定义登录成功处理。// 自定义登录失败处理。
一文搞懂SpringSecurity+JWT前后端分离~
weixin_45647685的博客
04-27 1万+
1、简介 SpringSecurity属于Spring家族中的一款安全管理框架，，它提供了一套Web应用安全性的完整解决方案。主要的功能是认证和授权。 **认证 *验证当前访问系统的是不是本系统的用户，并且要确定具体是哪个用户。 **授权 *经过认证后判断当前用户是否有权限进行某个操作。 2、快速入门 2.1、创建一个SpringBoot工程 1、先创建一个最基本的SpringBoot工程，配置好相关数据库，并且编写一个Controller进行测试。 ① 导入依赖 ...
前后端分离 SpringBoot + SpringSecurity + JWT + RBAC 实现用户无状态请求验证
IT小村
07-16 4万+
一、前言 修改自前文，十分贴近公司开发的生产环境 前后端分离 SpringBoot + SpringSecurity 权限解决方案 二、代码 代码已经放在 github 上了：https://github.com/larger5/SpringBoot_SpringSecurity_JWT_RBAC.git 1.pom &amp;amp;amp;amp;amp;amp;lt;!--安全框架--&amp;amp;amp;amp;amp;amp;gt;
SpringSecurity+JWT使用步骤及心得
qq_35213765的博客
05-06 1230
1、添加相关依赖 主要是springsecurity和jwt依赖 <?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 https://mav
SpringBoot+SpringSecurity+JWT实RESTfulAPI权限控制
热门推荐
林老师带你学编程
10-26 4万+
关于什么是jwt（json web token），还有jwt的工作流程我这边就不多介绍，主要给大家介绍一下SpringBoot中如何整合Security然后在添加jwt的支持。 想学习分布式、微服务、JVM、多线程、架构、java、python的童鞋，千万不要扫码，否则后果自负~ 通过SpringBoot+Security+JWT来实现token校验的过程。在生产环境中，对发布API增加授...
傻瓜式使用SpringSecurity完成前后端分离+JWT+登录认证+权限控制
weixin_46684099的博客
06-01 1944
流程分析 流程说明： 客户端发起一个请求，进入 Security 过滤器链。当到 LogoutFilter 的时候判断是否是登出路径，如果是登出路径则到 logoutHandler ，如果登出成功则到 logoutSuccessHandler 登出成功处理。 如果不是登出路径则直接进入下一个过滤器。当到 UsernamePasswordAuthenticationFilter 的时候判断是否为登录路径，如果是，则进入该过滤器进行登录操作，如果登录失败则到 AuthenticationFailureHan
SpringSecurity5-教程5-前后端分离系统OAuth2授权登录后渲染指定页面
zhouwenjun0820的博客
03-24 739
spring security
Spring Boot 2 + Spring Security 5 + JWT 的单页应用Restful解决方案
weixin_34010566的博客
04-01 407
准备 项目GitHub：github.com/Smith-Cruis… 我之前写过两篇关于安全框架的问题，大家可以大致看一看，打下基础。 Shiro+JWT+Spring Boot Restful简易教程 Spring Boot+Spring Security+Thymeleaf 简单教程 在开始前你至少需要了解 Spring Security 的基本配置和 JWT 机制。 一些关于 Maven ...
SpringBoot整合SpringSecurity实现JWT认证
我的博客
03-30 3万+
前言 微服务架构，前后端分离目前已成为互联网项目开发的业界标准，其核心思想就是前端（APP、小程序、H5页面等）通过调用后端的API接口，提交及返回JSON数据进行交互。 在前后端分离项目中，首先要解决的就是登录及授权的问题。微服务架构下，传统的session认证限制了应用的扩展能力，无状态的JWT认证方法应运而生，该认证机制特别适用于分布式站点的单点登录（SSO）场景 目录 该文会通过创建...
spring security，jwt和redis实现前后端分离
05-31
好的，这是一个关于Spring Security、JWT和Redis实现前后端分离的问题。 首先，Spring Security是一个基于Spring框架的安全框架，可以用来实现用户认证、授权等功能。 JWT（JSON Web Token）是一种用于在网络上...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值