1.自定义 认证逻辑

不破坏原有的过滤器链，又实现了自定义认证功能（基于Session，不是JSON交互）

（1）验证码生成工具

package com.oldbai.Util; import com.google.code.kaptcha.Producer; import com.google.code.kaptcha.impl.DefaultKaptcha; import com.google.code.kaptcha.util.Config; import org.springframework.context.annotation.Bean; import javax.imageio.ImageIO; import java.awt.*; import java.awt.image.BufferedImage; import java.io.IOException; import java.io.OutputStream; import java.util.Properties; import java.util.Random; /**
 * 生成验证码的工具类
 */ public class VerifyCode { private int width = 100;// 生成验证码图片的宽度 private int height = 50;// 生成验证码图片的高度 private String[] fontNames = { "宋体", "楷体", "隶书", "微软雅黑" }; private Color bgColor = new Color(255, 255, 255);// 定义验证码图片的背景颜色为白色 private Random random = new Random(); private String codes = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; private String text;// 记录随机字符串 /**
     * 获取一个随意颜色
     *
     * @return
     */ private Color randomColor() { int red = random.nextInt(150); int green = random.nextInt(150); int blue = random.nextInt(150); return new Color(red, green, blue); } /**
     * 获取一个随机字体
     *
     * @return
     */ private Font randomFont() { String name = fontNames[random.nextInt(fontNames.length)]; int style = random.nextInt(4); int size = random.nextInt(5) + 24; return new Font(name, style, size); } /**
     * 获取一个随机字符
     *
     * @return
     */ private char randomChar() { return codes.charAt(random.nextInt(codes.length())); } /**
     * 创建一个空白的BufferedImage对象
     *
     * @return
     */ private BufferedImage createImage() { BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); Graphics2D g2 = (Graphics2D) image.getGraphics(); g2.setColor(bgColor);// 设置验证码图片的背景颜色 g2.fillRect(0, 0, width, height); return image; } public BufferedImage getImage() { BufferedImage image = createImage(); Graphics2D g2 = (Graphics2D) image.getGraphics(); StringBuffer sb = new StringBuffer(); for (int i = 0; i < 4; i++) { String s = randomChar() + ""; sb.append(s); g2.setColor(randomColor()); g2.setFont(randomFont()); float x = i * width * 1.0f / 4; g2.drawString(s, x, height - 15); } this.text = sb.toString(); drawLine(image); return image; } /**
     * 绘制干扰线
     *
     * @param image
     */ private void drawLine(BufferedImage image) { Graphics2D g2 = (Graphics2D) image.getGraphics(); int num = 5; for (int i = 0; i < num; i++) { int x1 = random.nextInt(width); int y1 = random.nextInt(height); int x2 = random.nextInt(width); int y2 = random.nextInt(height); g2.setColor(randomColor()); g2.setStroke(new BasicStroke(1.5f)); g2.drawLine(x1, y1, x2, y2); } } public String getText() { return text; } public static void output(BufferedImage image, OutputStream out) throws IOException { ImageIO.write(image, "JPEG", out); } /**
     * 提供一个实体类，使用网上一个现成的验证码库 kaptcha
     * @return
     */ @Bean Producer verifyCode(){ Properties properties = new Properties(); properties.setProperty("kaptcha.image.width", "150"); properties.setProperty("kaptcha.image.height", "50"); properties.setProperty("kaptcha.textproducer.char.string", "0123456789"); properties.setProperty("kaptcha.textproducer.char.length", "4"); Config config = new Config(properties); DefaultKaptcha defaultKaptcha = new DefaultKaptcha(); defaultKaptcha.setConfig(config); return defaultKaptcha; } }

（2）验证码获取接口

package com.oldbai.controller; import com.oldbai.Util.VerifyCode; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; import javax.imageio.ImageIO; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import java.awt.image.BufferedImage; import java.io.FileOutputStream; import java.io.IOException; @RestController public class LoginController { //提供生成图片的接口 @GetMapping("/verifyCode") public void verifyCode(HttpSession session, HttpServletResponse response) throws IOException { VerifyCode code = new VerifyCode(); BufferedImage image = code.getImage(); //        检查是否生成图片 ImageIO.write(image,"JPEG",new FileOutputStream("F:/a.jpg")); String text = code.getText(); session.setAttribute("verify_code",text); VerifyCode.output(image,response.getOutputStream()); } }

（3）在过滤器中进行验证码校验

package com.oldbai.config; import org.springframework.security.authentication.AuthenticationServiceException; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.authentication.dao.DaoAuthenticationProvider; import org.springframework.security.core.AuthenticationException; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.web.context.request.RequestContextHolder; import org.springframework.web.context.request.ServletRequestAttributes; import javax.servlet.http.HttpServletRequest; public class MyAuthenticationProvider extends DaoAuthenticationProvider { /**
     * 目的是在于，验证验证码，只需要在登陆请求中验证即可。
     * 之前的过滤器没问题，只是这个是更加高级的玩法
     * 这样既不破坏原有的过滤器链，又实现了自定义认证功能。
     * <p>
     * 首先获取当前请求，注意这种获取方式，在基于 Spring 的 web 项目中，我们可以随时随地获取到当前请求，获取方式就是我上面给出的代码。
     * 从当前请求中拿到 code 参数，也就是用户传来的验证码。
     * 从 session 中获取生成的验证码字符串。
     * 两者进行比较，如果验证码输入错误，则直接抛出异常。
     * 最后通过 super 调用父类方法，也就是 DaoAuthenticationProvider 的 additionalAuthenticationChecks 方法，该方法中主要做密码的校验。
     * </p>
     */ @Override protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException { HttpServletRequest req = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest(); String code = req.getParameter("code"); String verify_code = (String) req.getSession().getAttribute("verify_code"); if (code == null || verify_code == null || !code.toLowerCase().equals(verify_code.toLowerCase())) { throw new AuthenticationServiceException("验证码错误"); } super.additionalAuthenticationChecks(userDetails, authentication); } }

（4）在SecurityConfig中进行配置过滤器（因为我是使用MP-Security数据库认证，所以可以这样直接简单配制）

 /**
     * <p>
     *   所有的 AuthenticationProvider 都是放在 ProviderManager 中统一管理的，
     *   所以接下来我们就要自己提供 ProviderManager，
     *   然后注入自定义的 MyAuthenticationProvider
     * </p>
     * <P>
     *    我们需要提供一个 MyAuthenticationProvider 的实例，
     *    创建该实例时，需要提供 UserDetailService 和 PasswordEncoder 实例。
     * </P>
     * <p>
     *    通过重写 authenticationManager 方法来提供一个自己的 AuthenticationManager，
     *    实际上就是 ProviderManager，
     *    在创建 ProviderManager 时，加入自己的 myAuthenticationProvider。
     * </p>
     */ @Bean MyAuthenticationProvider myAuthenticationProvider(){ MyAuthenticationProvider myAuthenticationProvider = new MyAuthenticationProvider(); myAuthenticationProvider.setPasswordEncoder(new BCryptPasswordEncoder()); myAuthenticationProvider.setUserDetailsService(userService); return myAuthenticationProvider; } @Override @Bean protected AuthenticationManager authenticationManager() throws Exception { ProviderManager manager = new ProviderManager(Arrays.asList(myAuthenticationProvider())); return manager; }

（5）实验截图

2.让 Spring Security 中的资源可以匿名访问

SecurityConfig 中添加配制

 /**
     * 解决Spring Security 登录成功后总是获取不到登录用户信息
     * <p>
     *     在不同线程中，不能获取同一个用户登陆信息
     * </p>
     * <p>
     *     这是不走过滤器的解决方法
     * 让 Spring Security 中的资源可以匿名访问
     * 不走 Spring Security 过滤器链
     * 登陆接口如果放在这里，登录请求将不走 SecurityContextPersistenceFilter 过滤器，
     * 也就意味着不会将登录用户信息存入 session，进而导致后续请求无法获取到登录用户信息。
     * 下面是放行静态资源：/css/**、/js/**、/index.html、/img/**、/fonts/**、/favicon.ico
     * 放行接口：/verifyCode
     * 不能把登陆接口放这
     * </p>
     */ @Override public void configure(WebSecurity web) throws Exception { web.ignoring().antMatchers("/css/**","/js/**","/index.html","/img/**","/fonts/**","/favicon.ico","/verifyCode"); }

3. 保存关于 Http 请求的更多信息（变相的验证码验证）

当然，WebAuthenticationDetails 也可以自己定制，因为默认它只提供了 IP 和 sessionid 两个信息，如果我们想保存关于 Http 请求的更多信息，就可以通过自定义 WebAuthenticationDetails 来实现。
如果我们要定制 WebAuthenticationDetails，还要连同 WebAuthenticationDetailsSource 一起重新定义。
里面主要保存 SessionId 和用户IP地址，也可以自定义保存其他东西。

（1）MyWebAuthenticationDetails

package com.oldbai.config; import org.springframework.security.web.authentication.WebAuthenticationDetails; import javax.servlet.http.HttpServletRequest; public class MyWebAuthenticationDetails extends WebAuthenticationDetails { /**
     * 用来保存是否验证正确
     */ private boolean isPassed; private String v_code; /**
     * <p>
     *     如果我们想扩展属性，只需要在 MyWebAuthenticationDetails 中再去定义更多属性，
     *     然后从 HttpServletRequest 中提取出来设置给对应的属性即可，
     *     这样，在登录成功后就可以随时随地获取这些属性了。
     * </p>
     */ public MyWebAuthenticationDetails(HttpServletRequest request) { super(request); String code = request.getParameter("code"); this.v_code = code; String verify_code = (String) request.getSession().getAttribute("verify_code"); if (code != null && verify_code != null && code.toLowerCase().equals(verify_code.toLowerCase())) { isPassed = true; } } public boolean isPassed(){ return isPassed; } public String getV_code() { return v_code; } public void setV_code(String v_code) { this.v_code = v_code; } }

（2）MyWebAuthenticationDetailsSource

@Component public class MyWebAuthenticationDetailsSource implements AuthenticationDetailsSource<HttpServletRequest,MyWebAuthenticationDetails> { @Override public MyWebAuthenticationDetails buildDetails(HttpServletRequest context) { return new MyWebAuthenticationDetails(context); } }

（3）MyAuthenticationProvider（用上面1的代码进行改写）

public class MyAuthenticationProvider extends DaoAuthenticationProvider { @Override protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException { MyWebAuthenticationDetails details = (MyWebAuthenticationDetails) authentication.getDetails(); if (!details.isPassed()) { throw new AuthenticationServiceException("验证码错误"); } super.additionalAuthenticationChecks(userDetails, authentication); } }

（4）SecurityConfig（添加配制）

 /**
     * 自定义的myWebAuthenticationDetailsSource替换系统默认的WebAuthenticationDetailsSource
     */ @Autowired MyWebAuthenticationDetailsSource myWebAuthenticationDetailsSource; @Override protected void configure(HttpSecurity http) throws Exception { http.formLogin() .xxx .authenticationDetailsSource(myWebAuthenticationDetailsSource) .xxx }

（5）测试接口

/**
     * 测试接口
     * @return
     */ @GetMapping("/hello") public MyWebAuthenticationDetails HelloWorld() { Authentication auth = SecurityContextHolder.getContext().getAuthentication(); MyWebAuthenticationDetails details = (MyWebAuthenticationDetails) auth.getDetails(); return details; }

（6）测试结果

4.踢掉上一个登陆用户

（1）基于用户内存的方法

直接在 SecurityConfig 中配制

 @Bean HttpSessionEventPublisher httpSessionEventPublisher(){ return new HttpSessionEventPublisher(); } @Override protected void configure(HttpSecurity http) throws Exception { /**
         * <p>
         *     想要用新的登录踢掉旧的登录，我们只需要将最大会话数设置为 1 即可
         * </p>
         * <p>
         *     设置session会话最大会话数为 1
         * </p>
         * <p>
         *      禁止新的登陆操作
         * </p>
         *
         */ http.sessionManagement() .maximumSessions(1) .maxSessionsPreventsLogin(true); }

（2）前后端分离，使用数据库认证

直接在User类里面添加这两个，重写方法

 @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; User user = (User) o; return Objects.equals(username, user.username); } @Override public int hashCode() { return Objects.hash(username); }

（3）前后端分离，JSON交互

①SecurityConfig进行配置

这里我们要自己提供 SessionAuthenticationStrategy，
而前面处理 session 并发的是 ConcurrentSessionControlAuthenticationStrategy，
也就是说，我们需要自己提供一个 ConcurrentSessionControlAuthenticationStrategy 的实例，
然后配置给 LoginFilter，
但是在创建 ConcurrentSessionControlAuthenticationStrategy 实例的过程中，
还需要有一个 SessionRegistryImpl 对象

@Bean SessionRegistryImpl sessionRegistry() { return new SessionRegistryImpl(); }

②在 SecurityConfig 中的 LoginFilter 中配置 SessionAuthenticationStrategy

在这里自己手动构建 ConcurrentSessionControlAuthenticationStrategy 实例，构建时传递 SessionRegistryImpl 参数，然后设置 session 的并发数为 1，最后再将 sessionStrategy 配置给 LoginFilter。

/**
*手动构建 ConcurrentSessionControlAuthenticationStrategy 实例，构建时传递 *SessionRegistryImpl 参数，然后设置 session 的并发数为 1，最后再将 sessionStrategy 配置给 *LoginFilter
*/ @Bean LoginFilter loginFilter() throws Exception { LoginFilter loginFilter = new LoginFilter(); loginFilter.setAuthenticationSuccessHandler((request, response, authentication) -> { //... } ); loginFilter.setAuthenticationFailureHandler((request, response, exception) -> { //... } ); loginFilter.setAuthenticationManager(authenticationManagerBean()); loginFilter.setFilterProcessesUrl("/doLogin"); ConcurrentSessionControlAuthenticationStrategy sessionStrategy = new ConcurrentSessionControlAuthenticationStrategy(sessionRegistry()); sessionStrategy.setMaximumSessions(1); loginFilter.setSessionAuthenticationStrategy(sessionStrategy); return loginFilter; }

③在SecurityConfig 中的 http 的config 中添加配制

重新创建一个 ConcurrentSessionFilter 的实例，代替系统默认的即可。
在创建新的 ConcurrentSessionFilter 实例时，需要两个参数：
sessionRegistry 就是我们前面提供的 SessionRegistryImpl 实例。
第二个参数，是一个处理 session 过期后的回调函数，也就是说，当用户被另外一个登录踢下线之后，你要给什么样的下线提示，就在这里来完成。

@Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() ... http.addFilterAt(new ConcurrentSessionFilter(sessionRegistry(), event -> { HttpServletResponse resp = event.getResponse(); resp.setContentType("application/json;charset=utf-8"); resp.setStatus(401); PrintWriter out = resp.getWriter(); out.write(new ObjectMapper().writeValueAsString(RespBean.error("您已在另一台设备登录，本次登录已下线!"))); out.flush(); out.close(); }), ConcurrentSessionFilter.class); http.addFilterAt(loginFilter(), UsernamePasswordAuthenticationFilter.class); }

④手动向 SessionRegistryImpl 中添加一条记录

手动调用 sessionRegistry.registerNewSession 方法，向 SessionRegistryImpl 中添加一条 session 记录。

public class LoginFilter extends UsernamePasswordAuthenticationFilter { @Autowired SessionRegistry sessionRegistry; @Override public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException { //省略 UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken( username, password); setDetails(request, authRequest); User principal = new User(); principal.setUsername(username); sessionRegistry.registerNewSession(request.getSession(true).getId(), principal); return this.getAuthenticationManager().authenticate(authRequest); } ... ... } }

⑤使用JSON交互的登陆，比基于数据库需要多几个步骤是：

1.配制一个SessionRegistryImpl
2.在 SecurityConfig 中的 LoginFilter 中配置 SessionAuthenticationStrategy
3.在SecurityConfig 中的 http 的config 中添加配制
4.手动向 SessionRegistryImpl 中添加一条记录
推荐有项目进行测试，反正我在postman测试没成功

5.跨域配制

SecurityConfig

@Override protected void configure(HttpSecurity http) throws Exception { /**
         * <p>
         *     开启跨域
         * </p>
         */ http.cors().configurationSource(corsConfigurationSource()); } /**
     * <p>
     * 开启跨域
     * </p>
     * <p>
     * 通过 CorsConfigurationSource 实例对跨域信息作出详细配置，
     * 例如允许的请求来源、
     * 允许的请求方法、
     * 允许通过的请求头、
     * 探测请求的有效期、
     * 需要处理的路径
     * 等等。
     * </p>
     */ @Bean CorsConfigurationSource corsConfigurationSource() { UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); CorsConfiguration configuration = new CorsConfiguration(); configuration.setAllowCredentials(true); configuration.setAllowedOrigins(Arrays.asList("*")); configuration.setAllowedMethods(Arrays.asList("*")); configuration.setAllowedHeaders(Arrays.asList("*")); configuration.setMaxAge(Duration.ofHours(1)); source.registerCorsConfiguration("/**", configuration); return source; }

6.csrf 攻击如何防御

 /**
        * 前后端分离中
        * 不是将 _csrf 放在 Model 中返回前端了，
        * 而是放在 Cookie 中返回前端
         * <p>
         *     前端需要从cookie 中的'XSRF-TOKEN' 提取 _csrf 的值交给后端
         *     通过一个 POST 请求执行操作，注意携带上 _csrf 参数
         * </p>
        */ http.csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());

7.更新当前用户信息

 /**
     * 先获取当前用户信息
     */ @GetMapping("/hr/info") public User getCurrentHr(Authentication authentication) { return ((User) authentication.getPrincipal()); } /**
     * 更新最新当前用户信息
     *
     */ @PostMapping("/hr/info") public String updata(@RequestBody User user, Authentication authentication) { if (userService.saveOrUpdate(user)){ SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(user,authentication.getCredentials(),authentication.getAuthorities())); return "更新成功"; } return "更新失败"; }

8.防止会话固定攻击

默认的 migrateSession ，在用户匿名访问的时候是一个 sessionid，当用户成功登录之后，又是另外一个 sessionid，这样就可以有效避免会话固定攻击。

migrateSession 表示在登录成功之后，创建一个新的会话，然后把旧的 session 中的信息复制到新的 session 中，「默认即此」

http.sessionManagement().sessionFixation().migrateSession();

none 表示不做任何事情，继续使用旧的 session。

http.sessionManagement().sessionFixation().none ();

changeSessionId 表示 session 不变，但是会修改 sessionid，这实际上用到了 Servlet 容器提供的防御会话固定攻击。

http.sessionManagement().sessionFixation().changeSessionId ();

newSession 表示登录后创建一个新的 session。

http.sessionManagement().sessionFixation().newSession ();

写在最后

以上这些，对于个人的练习开放小项目，足够了。
个人思路构建一个小型项目逻辑

1.创建工程，导入MyBatis-Plus 依赖，进行配置，单元测试是否连接成功
2.导入Security 依赖，进行配置
3.使用MP与Security进行整合，基于数据库的认证。
4.进行角色等级配置
5.设置最大会话数，也就是踢掉登陆或者不让登陆
6.配置登陆成功、失败、无状态访问、注销回调
7.配置验证码生成工具，开放验证码接口
8.自定义一个登陆逻辑过滤器用于验证验证码是否正确
9.如果是前后端分离项目，进行跨域配制
10.防止固定会话、开启csrf 防御，前端记得要从cookid中拿到并携带 _csrf 的参数进行请求
11.更新用户信息的配制，主要是在接口中进行配置
12.修改密码的配制，还没会，所以先不急。

本文地址：https://blog.csdn.net/qq_45031575/article/details/107876749

Java实现自定义认证功能（基于session）

1.自定义 认证逻辑

2.让 Spring Security 中的资源可以匿名访问

3. 保存关于 Http 请求的更多信息（变相的验证码验证）

4.踢掉上一个登陆用户

（1）基于用户内存的方法

（2）前后端分离，使用数据库认证

（3）前后端分离，JSON交互

5.跨域配制

6.csrf 攻击如何防御

7.更新当前用户信息

8.防止会话固定攻击

写在最后

相关推荐

java输出流怎么表示

java强制类型转换的规则是什么

java隐式转换规则是什么

java调用js脚本的方法是什么

java怎么调用json接口

java如何获取当前日期

java怎么显示当前时间

shell怎么设置java环境变量