Spring Security实现Restful认证功能与RememberMe功能

最新推荐文章于 2024-05-24 14:50:10 发布
最新推荐文章于 2024-05-24 14:50:10 发布
阅读量1k 收藏 5
点赞数 3
分类专栏： Java Web Spring Security 文章标签： Spring Security Restful 重写认证 重写RememberMe 包装Request
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40562161/article/details/92643252
版权

最近在接触spring security，它是个好东西，只是对Restful的支持并不是那么友好。对于习惯使用Restful接口的我，还是选择把spring security认证功能与RememberMe功能所用到的某些类进行重写，以实现spring security对Restful支持。

重写认证功能

1. 重写UsernamePasswordAuthenticationFilter

package com.tinyhelp.security;


import java.io.IOException;
import java.io.InputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.http.MediaType;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinyhelp.security.AuthenticationBean;


public class TinyHelpUsernamePasswordAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

	@Override
	@SuppressWarnings("finally")
	public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {	 
		if(request != null && request.getMethod().equalsIgnoreCase("POST") && 
			request.getContentType() != null && 
		    (request.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_UTF8_VALUE) || 
			 request.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE))) {
	    	//当认证请求是JSON
			//使用fastjson转换
		    ObjectMapper mapper = new ObjectMapper();
		    UsernamePasswordAuthenticationToken authRequest = null;
		    try (InputStream is = request.getInputStream()){
		    	//忽略未知属性
		    	mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);		  
		    	//读到认证Bean
		    	AuthenticationBean authenticationBean = mapper.readValue(is,AuthenticationBean.class);
		    	//生成认证令牌
		    	authRequest = new UsernamePasswordAuthenticationToken(
		    			authenticationBean.getPhoneNumber(), authenticationBean.getPassword());
		    }catch (IOException e) {
		    	e.printStackTrace();
		    }finally {
		    	//配置将request，authRequest注入到认证请求详情的属性中
		    	setDetails(request, authRequest);
		    	//返回认证后的身份
		    	return this.getAuthenticationManager().authenticate(authRequest);
		    }
	    }
		//否则非Json请求，使用原本的认证方式
	    return super.attemptAuthentication(request, response);
	}
}

package com.tinyhelp.security;

/**
 * 自定义认证Bean
 */
public class AuthenticationBean {

	private String phoneNumber;
	private String password;
	private String rememberMe;
	
	public String getPhoneNumber() {
		return phoneNumber;
	}
	public void setPhoneNumber(String phoneNumber) {
		this.phoneNumber = phoneNumber;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getRememberMe() {
		return rememberMe;
	}
	public void setRememberMe(String rememberMe) {
		this.rememberMe = rememberMe;
	}
}

2. 将重写了的Filter在configure(HttpSecurity http)中配置

		//自定义用户认证filter与原来的filter放在相同位置，但不覆盖原来的filter
		http
		  .addFilterAt(tinyHelpUsernamePasswordAuthenticationFilter(), 
				  UsernamePasswordAuthenticationFilter.class);

    @Bean
	TinyHelpUsernamePasswordAuthenticationFilter tinyHelpUsernamePasswordAuthenticationFilter() throws Exception {
		TinyHelpUsernamePasswordAuthenticationFilter filter = new TinyHelpUsernamePasswordAuthenticationFilter();
		//只接受post请求
		filter.setPostOnly(true);
		//设置自定义认证成功处理类
		filter.setAuthenticationSuccessHandler(new TinyHelpAuthenticationSuccessHandler());
		//设置自定义认证失败处理类
	    filter.setAuthenticationFailureHandler(new TinyHelpAuthenticationFailureHandler());
	    //设置自定义认证处理url
		filter.setFilterProcessesUrl("/account/login");
		//设置自定义RememberMe功能
		filter.setRememberMeServices(rememberMeServices());
		//重用WebSecurityConfigurerAdapter配置的AuthenticationManager，不然要自己组装AuthenticationManager
		filter.setAuthenticationManager(authenticationManagerBean());	
		return filter;
	}

package com.tinyhelp.security;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinyhelp.entity.Msg;

public class TinyHelpAuthenticationSuccessHandler implements AuthenticationSuccessHandler {

	@Override
	public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
			Authentication authentication) throws IOException, ServletException {
		//设置为普通文本响应，但文本为json格式
		response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();
        // 成功，跳转首页
        Msg msg = new Msg();
        msg.setCode(0);
		msg.setMsg("/index.html");
		// 输出Json
        out.write(new ObjectMapper().writeValueAsString(msg));
        out.flush();
        out.close();
	}

}


package com.tinyhelp.security;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinyhelp.entity.Msg;

public class TinyHelpAuthenticationFailureHandler implements AuthenticationFailureHandler {

	@Override
	public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
			AuthenticationException exception) throws IOException, ServletException {
	    //设置为普通文本响应，但文本为json格式
		response.setContentType("text/html;charset=utf-8");
	    PrintWriter out = response.getWriter();
	    // 失败
	    Msg msg = new Msg();
	    if(exception.getMessage().equals("用户不存在")) {
	    	msg.setCode(16);
		    msg.setMsg("手机号不存在");
	    }else if(exception.getMessage().equals("认证信息没有手机号")){
	    	msg.setCode(500);
	   	    msg.setMsg("认证信息没有手机号");
	    }else{
	    	msg.setCode(16);
	    	msg.setMsg("密码错误");
	    }
	    out.write(new ObjectMapper().writeValueAsString(msg));
	    out.flush();
	    out.close();
	}

}


	@Bean
	public RememberMeServices rememberMeServices(){
		TinyHelpTokenBasedRememberMeServices tokenBasedRememberMeServices = new TinyHelpTokenBasedRememberMeServices(
				REMEMBER_ME_KEY, new TinyHelpUserDetailsService(userService));
		//cookie名
	    tokenBasedRememberMeServices.setCookieName(REMEMBER_ME_COOKIE_NAME);
	    //cookie时间
	    tokenBasedRememberMeServices.setTokenValiditySeconds(REMEMBER_ME_TOKEN_TIME_OUT);
	    return tokenBasedRememberMeServices;
	}

	private static final String REMEMBER_ME_COOKIE_NAME = "rememberMe";	//cookie名
	private static final int REMEMBER_ME_TOKEN_TIME_OUT = 2419200;	//token四周内有效
	private static final String REMEMBER_ME_KEY = "TinyHelpSecured";	//私钥名

3. 自定义的daoAuthenticationProvider，并在configure(AuthenticationManagerBuilder auth)中配置

		auth
		  .authenticationProvider(daoAuthenticationProvider());	//使用自定义的daoAuthenticationProvider

	@Bean
	public DaoAuthenticationProvider daoAuthenticationProvider() {
		//自定义数据库认证提供者
	    DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
	    //不隐藏UserNotFoundExceptions
	    provider.setHideUserNotFoundExceptions(false);
	    //使用自定义用户详情服务类
	    provider.setUserDetailsService(new TinyHelpUserDetailsService(userService));
	    //使用自定义MD5编码器
	    provider.setPasswordEncoder(passwordEncoder());
	    return provider;
	}

	@Autowired
	private UserService userService;

package com.tinyhelp.security;

import java.util.ArrayList;
import java.util.List;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

import com.tinyhelp.entity.User;
import com.tinyhelp.service.UserService;

public class TinyHelpUserDetailsService implements UserDetailsService {

	private final UserService userService;	//从外部赋予
	
	public TinyHelpUserDetailsService(UserService userService) {
		this.userService = userService;
	}
	
	@Override
	public UserDetails loadUserByUsername(String phoneNumber) throws UsernameNotFoundException {
		if(phoneNumber == null) {
			throw new UsernameNotFoundException("认证信息没有手机号");
		}
		//通过手机号找用户
		User user = userService.findUserByPhone(phoneNumber);	
		if (user != null) {
			//创建权限列表
			List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
			authorities.add(new SimpleGrantedAuthority("ROLE_USER"));
			//返回用户详情，包括手机号，密码和权限
			return new org.springframework.security.core.userdetails.User(
					user.getPhoneNumber(),
					user.getPassword(),
					authorities);	
        }	
		throw new UsernameNotFoundException("用户不存在");
	}

}


	@Bean
    PasswordEncoder passwordEncoder() {
		//自定义MD5编码器
        return new MD5PasswordEncoder();
    }

重写RememberMe功能

1. 重写TokenBasedRememberMeServices

package com.tinyhelp.security;

import java.io.IOException;
import java.io.InputStream;

import javax.servlet.http.HttpServletRequest;

import org.springframework.http.MediaType;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.rememberme.TokenBasedRememberMeServices;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

public class TinyHelpTokenBasedRememberMeServices extends TokenBasedRememberMeServices{

	private boolean alwaysRemember;
	
	public void setAlwaysRemember(boolean alwaysRemember) {
		this.alwaysRemember = alwaysRemember;
	}

	public TinyHelpTokenBasedRememberMeServices(String key, UserDetailsService userDetailsService) {
		super(key, userDetailsService);
	}
	
	@Override
	protected boolean rememberMeRequested(HttpServletRequest request, String parameter) {
		if (alwaysRemember) {
			return true;
		}
		if(request != null && request.getMethod().equalsIgnoreCase("POST") && 
			request.getContentType() != null && 
			(request.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_UTF8_VALUE) || 
		     request.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE))) {
			//当认证请求是JSON
			//使用fastjson转换
		    ObjectMapper mapper = new ObjectMapper();
		    try (InputStream is = request.getInputStream()) {
		    	//忽略未知属性
		    	mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);		  
		    	//remember-me读到认证Bean
		    	AuthenticationBean authenticationBean = mapper.readValue(is,AuthenticationBean.class);
		    	//如果请求中有remember-me 字段并且值为on则返回true
		    	if(authenticationBean.getRememberMe() != null &&
		    	   authenticationBean.getRememberMe().equalsIgnoreCase("on")){
				    return true;  
				}
		    }catch (IOException e) {
		    	e.printStackTrace();
		    }
	    }
		//否则调用原本的自我记住功能
		return super.rememberMeRequested(request, parameter);
	}
}

2. 组建RememberMeAuthenticationFilter，并在configure(HttpSecurity http)中配置

		//自定义记住我filter与原来的filter放在相同位置，但不覆盖原来的filter
		http
		  .addFilterAt(rememberMeAuthenticationFilter(),
				  RememberMeAuthenticationFilter.class);

	@Bean
	public RememberMeAuthenticationFilter rememberMeAuthenticationFilter() throws Exception {
		//重用WebSecurityConfigurerAdapter配置的AuthenticationManager，不然要自己组装AuthenticationManager
	    return new RememberMeAuthenticationFilter(authenticationManagerBean(), rememberMeServices());
	}

	@Bean
	public RememberMeServices rememberMeServices(){
		TinyHelpTokenBasedRememberMeServices tokenBasedRememberMeServices = new TinyHelpTokenBasedRememberMeServices(
				REMEMBER_ME_KEY, new TinyHelpUserDetailsService(userService));
		//cookie名
	    tokenBasedRememberMeServices.setCookieName(REMEMBER_ME_COOKIE_NAME);
	    //cookie时间
	    tokenBasedRememberMeServices.setTokenValiditySeconds(REMEMBER_ME_TOKEN_TIME_OUT);
	    return tokenBasedRememberMeServices;
	}

3.自定义的rememberMeAuthenticationProvider，并在configure(AuthenticationManagerBuilder auth)中配置

		auth
		  .authenticationProvider(rememberMeAuthenticationProvider()); //使用自定义的rememberMeAuthenticationProvider

	@Bean
	public RememberMeAuthenticationProvider rememberMeAuthenticationProvider() {
		//自定义记住我提供者
		return new RememberMeAuthenticationProvider(REMEMBER_ME_KEY);
	}

包装Request

我知道你已经很累，但这是最后一关。细心的你可能已经发现代码里要获取两遍request的inputStream流，但事实真能获取两遍吗。如果你没有包装request，第二次获取的时候会为空。因为request只能读取一次。

原因参见：https://blog.csdn.net/zj20142213/article/details/80012221

实现：

//包装request的filter，放在spring security UsernamePasswordAuthenticationFilter之前
		http
		  .addFilterBefore(new WrapRequestFilter(), 
				  UsernamePasswordAuthenticationFilter.class);

package com.tinyhelp.security;

import java.io.IOException;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

import org.springframework.http.MediaType;
import org.springframework.web.filter.GenericFilterBean;

import com.tinyhelp.tool.TinyHelpHttpServletRequestWrapper;

/**
 * 用于包装request，
 * 以便实现对request inputStream的多次读取
 */
public class WrapRequestFilter extends GenericFilterBean{

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		HttpServletRequest httpRequest = null;
		if(request instanceof HttpServletRequest){
			httpRequest = (HttpServletRequest) request;	
		}	
		//判断request是否是POST请求并且是json请求
		if(httpRequest != null && httpRequest.getMethod().equalsIgnoreCase("POST") && 
		   httpRequest.getContentType() != null && 
		   (httpRequest.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_UTF8_VALUE) || 
			httpRequest.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE))){	
			//是的话，包装request请求
			request = new TinyHelpHttpServletRequestWrapper(httpRequest);
		}
		chain.doFilter(request, response);    
	}
}


package com.tinyhelp.tool;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
 
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
 
public class TinyHelpHttpServletRequestWrapper extends HttpServletRequestWrapper {
	
	private HttpServletRequest request;
	private String requestBody = null;
 
	public TinyHelpHttpServletRequestWrapper(HttpServletRequest request) {
		super(request);
		this.request = request;
		if (requestBody == null) {
			requestBody = readBody(this.request);
		}
	}
 
	@Override
	public ServletInputStream getInputStream() throws IOException {
		return new CustomServletInputStream(requestBody);
	}
	
	@Override
	public BufferedReader getReader() throws IOException {
		return new BufferedReader(new InputStreamReader(getInputStream()));
	}
	
	private static String readBody(ServletRequest request) {
		StringBuilder sb = new StringBuilder();
		String inputLine;
		BufferedReader br = null;
		try {
			br = request.getReader();
			while ((inputLine = br.readLine()) != null) {
				sb.append(inputLine);
			}
		} catch (IOException e) {
			throw new RuntimeException("Failed to read body.", e);
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
				}
			}
		}
		return sb.toString();
	}
 
	private class CustomServletInputStream extends ServletInputStream {
		
		private ByteArrayInputStream buffer;
 
		public CustomServletInputStream(String body) {
			body = body == null ? "" : body;
			this.buffer = new ByteArrayInputStream(body.getBytes());
		}
 
		@Override
		public int read() throws IOException {
			return buffer.read();
		}
 
		@Override
		public boolean isFinished() {
			return buffer.available() == 0;
		}
 
		@Override
		public boolean isReady() {
			return true;
		}
 
		@Override
		public void setReadListener(ReadListener listener) {
			throw new RuntimeException("Not implemented");
		}
	}
}

以上代码中有注释，但最好还是深入理解一下spring security运行机制，你将会获得更多收获。楼主重写这些的时候，也是这么过来的。

至于原理，推荐以下博文：

https://blog.csdn.net/qq_37142346/article/details/80114609

https://www.cnblogs.com/vincent2010/p/4911057.html

https://blog.csdn.net/liushangzaibeijing/article/details/81220610#   

cyyJames
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
springsecurity UsernamePasswordAuthenticationFilter PasswordEncoder
six_teen的博客
11-17 1703
最近开始学习了springsecurity框架，为写后台页面做个权限管理什么的打基础。 springsecurity是基础springboot的，所以创建一个springboot工程引入依赖就可以很轻松的整合springsecurity了。（类似的权限管理框架还有shiro） 1. 创建一个普通的springboot项目（不用勾选任何东西）,我这边使用的springboot版本是2.2.1.RELEASE 依赖如下： pom.xml <dependencies> <!--sprin
【编程不良人】SpringSecurity实战学习笔记04---RememberMe
Mr.Cui的Java学习之路
08-27 1429
【编程不良人】SpringSecurity实战学习笔记04---RememberMe
【Spring Security】重写 UsernamePasswordAuthenticationFilter 支持登录校验 JSON 数据
最新发布
healer_ai的博客
05-24 1052
在 Spring Security 5.7 及更高版本中，`WebSecurityConfigurerAdapter` 已被弃用。取而代之的是配置类和 `SecurityFilterChain` Bean 的方式
Spring Security 5: UsernamePasswordAuthenticationFilter 的子类重写 unsuccessfulAuthentication 方法不执行分析及解决
Specif1c的博客
02-28 5397
一、前言： 在 Spring Security 框架中，最常用的 Filter 便是表单登录Filter，即 UsernamePasswordAuthenticationFilter。从下图中，能清晰的了解到 UsernamePasswordAuthenticationFilter 的继承关系。 最近我用 Spring Security 做登录验证的时候遇到一个问题。UsernamePasswordAuthenticationFilter 继承的子类重写successfulAuthentication 、u
Spring Security 使用JSON格式参数登录的两种方式
BASK2311的博客
11-21 649
通过前面几篇文章的分析，我们已经知道了登录参数的提取在过滤器中提取的，因此我们只需要模仿过滤器重写一个过滤器，替代原有的过滤器即可。的源代码如下：接下来就是将我们自定义的 LoginFilter 过滤器代替默认的。当我们替换了之后，原本在 SecurityConfig#configure 方法中关于 form 表单的配置就会失效，那些失效的属性，都可以在配置 LoginFilter 实例的时候配置；还需要记得配置，否则启动时会报错。
学习SpringSecurity的日常生活（三）——前后台分离登录
dongbeihuxiao的博客
04-11 2122
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代.
SpringSecurity学习笔记（九）RememberMe进阶
怕什么真理无穷，进一寸有一寸的欢喜。即使开了一辆老掉牙的破车，只要在前行就好，偶尔吹点小风，这就是幸
10-07 535
前面我们介绍了rememberMe的实现原理，从中我们可以思考这样一个问题，如果我们的cookie被非法用户获取，然后携带这个cookie进行访问我们的项目中的内容，就会导致非法用户登录。这个问题怎么解决呢？
spring_security_3.1
09-14
Spring Security 3.1支持两种Remember Me实现：基于令牌的和基于持久化记住的。 7. **集成Spring MVC**：Spring Security 3.1与Spring MVC无缝集成，可以方便地保护Web控制器和视图。通过注解，如`@Secured`和`@...
2016_Spring Security Essentials
04-28
同时，Spring Security支持Remember Me服务，使得用户在一定时间内无需反复登录。 授权是Spring Security的另一核心功能，它通过AccessDecisionManager和AccessDecisionVoter来决定用户是否可以访问特定资源。...
spring3.0+spring security3.1.4 api chm 中文版
07-19
同时，它还提供了对Remember-Me服务、CSRF防护、以及基于角色的权限控制等功能，确保了应用的安全性。 在《Spring Security 3.1.4 API》文档中，你可以找到关于配置、过滤器链、访问决策管理器、权限表达式、以及...
Spring Security 把授权信息写入数据库
07-15
在处理与数据库交互方面，Spring Security提供了更强大的支持，包括长期的remember-me功能和基于数据库的角色与用户管理API。 24.2. 目标 在原有应用中，用户信息和资源访问控制已经在数据库中管理。目标是将现有...
SpringSecurity学习
06-08
SpringSecurity是Java开发中用于构建安全Web应用的框架，它提供了全面的身份验证、授权和访问控制功能。在本文中，我们将深入探讨SpringSecurity的核心概念、关键组件以及如何使用它来保护应用程序。 首先，Spring_...
spring security6重写登陆验证
weixin_44877713的博客
04-05 1074
spring security6重写登陆验证
Java Spring Security 安全框架：（十四）Remember Me 功能实现
地球村
10-12 370
Remember Me 功能实现1.添加依赖2.配置数据源3.编写配置4.修改 SecurityConfig5.在客户端页面中添加复选框6.有效时间 Spring Security 中 Remember Me 为“记住我”功能，用户只需要在登录时添加 remember-me 复选框，取值为 true。Spring Security 会自动把用户信息存储到数据源中，以后就可以不登录进行访问 1.添加依赖 Spring Security 实现 Remember Me 功能时底层实现依赖 Spring-JD
springboot security5 + vue 前后分离json方式登录（包括remember-me）实现
liukangjie520的博客
12-24 1222
由于security只支持formData方式提交表单，前端请求axios post为json格式数据，所以产生security接收不到登录参数等一系列问题（spring security应该升级这块功能了）。 问题找到了接下来就是解决问题， ...
【spring security】前后端分离，设置rememberMe后通过cookie自动登录（二）
Meditation_Crazy
10-08 1393
前言 使用前后端分离，前面已经实现了登录时把remember-me存到数据库，同时返回到前端。 但是测试关闭浏览器，再次直接调接口，发现提示未登录。 在调试的过程中看到有这个方法： 然后在它里面加断点，再次测试，发现携带cookie自动登录的过程中，会跑它里面的方法。所以算是找对对方了。 接下来就是查找为什么没有成功。 调试 在测试过程中，发现登录时候，也会跑这个方法：this.processAutoLoginCookie(cookieTokens, request, response)。但是在登录和自动
Spring Boot Security学习：支持接收前端登录json格式
xu_fanghai的博客
01-06 1008
spring security简介 主要的核心功能就是： 认证 授权 攻击防护 支持spring security接收json格式 其实最要的就是重写UsernamePasswordAuthenticationFilter这个过滤器。 这个类的主要目的就是用于处理基于表单的登录请求，从表单中获取用户名和密码。默认就是username和password。也可以修改这两个值，只需要调用他的两个方法。 接下来重写UsernamePasswordAuthenticationFilter这个类。 重写attem
怎样做到SpringSecurity密码大小写不敏感
zyh5068的专栏
07-14 310
SpringSecurity里面是没有设置“大小写不敏感”的地方的。所以只有采用我的这个方法。首先重写UsernamePasswordAuthenticationFilter，因为SpringSecurity的实现实际上就是很多Filter，所以这里还是重写一下attemptAuthentication（HttpServletRequest request,HttpServletResponse response）的方法。这个方法里面会读取password并且去验证。 然后去下面这个类里面去设定。这个类
Spring Security自定义用户认证过程（1）
weixin_44612246的博客
03-10 588
SpringSecurity自定义认证过程
采用Spring框架构建你的RestfulAPI
03-04
Spring构建后端API的实战总结，包括各种请求类型和数据格式的处理，安全认证等，比较实用

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值