SpringBoot整合Spring Security实现自定义页面以及验证码登录

已于 2022-03-23 16:06:02 修改
阅读量4.7k 收藏 13
点赞数 1
分类专栏： springboot 文章标签： spring boot spring java
于 2022-03-14 00:54:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44737094/article/details/123462481
版权

文章目录

前言

接上文 SpringBoot整合Spring Security

环境版本说明

MongoDB：5.0.6
SpringBoot：2.5.3
JDK：1.8

本文测试使用了 Swagger的增强工具knife4j 进行测试

在这里插入图片描述

后端代码

1、pom.xml

依赖较多 这里全部粘贴出来

 	<dependencies>
     	<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <!--页面使用-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
		<!--mongodb 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
            <version>2.6.4</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- knife4j -->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
            <version>2.0.2</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 阿里FastJson转换工具依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.79</version>
        </dependency>
    </dependencies>

其中MongoDB 我是用来存储用户登录日志 你们可以删掉或者使用mysql 其中的swagger也是可以去掉的

2、SecurityConfig .java Security配置类

package com.king.security.config;

import com.king.security.config.login.DefaultAuthenticationFailureHandler;
import com.king.security.config.login.DefaultAuthenticationSuccessHandler;
import com.king.security.config.login.LoginFilter;
import com.king.security.service.UserServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;


/**
 * @program: springboot
 * @description:
 * @author: King
 * @create: 2022-03-13 08:28
 */
@EnableGlobalMethodSecurity(prePostEnabled = true)//开启方法权限控制
@EnableWebSecurity
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserServiceImpl userService;
    @Autowired
    private DefaultAuthenticationSuccessHandler defaultAuthenticationSuccessHandler;
    @Autowired
    private DefaultAuthenticationFailureHandler defaultAuthenticationFailureHandler;
    @Autowired
    LoginFilter loginFilter;

    /**
     * 加密方式
     */
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }


    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //配置自己实现的登录认证的service,并设置密码的加密方式（）
        auth.userDetailsService(userService).passwordEncoder(passwordEncoder());
    }

    //静态资源配置
    @Override
    public void configure(WebSecurity web) throws Exception {
        //swagger2所需要用到的静态资源，允许访问
        web.ignoring().antMatchers("/swagger/**")
                .antMatchers("/swagger-ui.html")
                .antMatchers("/webjars/**")
                .antMatchers("/v2/**")
                .antMatchers("/v2/api-docs-ext/**")
                .antMatchers("/swagger-resources/**")
                .antMatchers("/doc.html")

                .antMatchers("/lib/**")
                .antMatchers("/layer/**")
                .antMatchers("/layui/**")
                .antMatchers("/layui/css/**")
                .antMatchers("/login.html")
                .antMatchers("/index.html");

    }


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //关闭跨域保护
        http.csrf().disable();
        //验证码校验
        http.addFilterBefore(loginFilter, UsernamePasswordAuthenticationFilter.class);
        //放行验证码
        http.authorizeRequests().antMatchers("/login_code.png").permitAll();
        // 指定指定要的登录页面
        http.formLogin().loginPage("/login").loginProcessingUrl("/api/user/login.do")
                .successHandler(defaultAuthenticationSuccessHandler)
                .failureHandler(defaultAuthenticationFailureHandler).permitAll();
        http.authorizeRequests().anyRequest().fullyAuthenticated();
       	http.logout().logoutUrl("logout.do");

    }
    
}

3、自定义处理登录成功/失败

DefaultAuthenticationSuccessHandler.java

自定义处理登录成功

package com.king.security.config.login;

import com.alibaba.fastjson.JSON;
import com.king.security.entity.User;
import com.king.security.entity.UserLog;
import com.king.security.mapper.UserLogMapper;
import com.king.security.vo.ResultObj;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @program: springboot
 * @description: 登录成功
 * @author: King
 * @create: 2022-03-13 08:41
 */
@Component
public class DefaultAuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    UserLogMapper userLogMapper;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request,
                                        HttpServletResponse response,
                                        Authentication authentication)
            throws IOException {
        User user = (User) authentication.getPrincipal();
        UserLog log = UserLog.builder().uid(user.getId()).name(user.getName()).ip(getIpAddress(request)).build();
        userLogMapper.save(log);
        logger.info("----login in succcess----");
        logger.info(log.toString());
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().write(JSON.toJSONString(ResultObj.ok("登录成功！")));
    }

	//获取IP地址
    public static String getIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }

}

DefaultAuthenticationFailureHandler.java

自定义处理登录失败

package com.king.security.config.login;

import com.alibaba.fastjson.JSON;
import com.king.security.vo.ResultObj;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.authentication.*;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @program: springboot
 * @description:
 * @author: King
 * @create: 2022-03-13 08:43
 */
@Component
public class DefaultAuthenticationFailureHandler extends SimpleUrlAuthenticationFailureHandler {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, 
                                        AuthenticationException e) throws IOException,
            ServletException {
        logger.info("login in failure : " + e.getMessage());
        ResultObj resultObj = new ResultObj();
        if (e instanceof LockedException) {
            resultObj = ResultObj.error("账户被锁定，登录失败！");
        } else if (e instanceof BadCredentialsException) {
            resultObj = ResultObj.error("账户名或密码输入错误，登录失败！");
        } else if (e instanceof DisabledException) {
            resultObj = ResultObj.error("账户被禁用，登录失败！");
        } else if (e instanceof AccountExpiredException) {
            resultObj = ResultObj.error("账户已过期，登录失败！");
        } else if (e instanceof CredentialsExpiredException) {
            resultObj = ResultObj.error("账户已过期，登录失败！");
        } else {
            resultObj = ResultObj.error(e.getMessage());
        }
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().write(JSON.toJSONString(resultObj));
    }




}

}

4、自定义登录过滤器 - 验证码验证

package com.king.security.config.login;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.AuthenticationException;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @program: springboot
 * @description: 验证码拦截器
 * @author: King
 * @create: 2022-03-12 06:16
 */
@Component
public class LoginFilter extends OncePerRequestFilter {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private DefaultAuthenticationFailureHandler authenticationFailureHandler;

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        //如果是 登录请求 则执行
        if ((request.getMethod().equalsIgnoreCase("post") &&
                request.getRequestURI().endsWith("login.do"))) {
            try {
                validate(request, response);
            } catch (ValidateCodeException e) {
                //调用错误处理器，最终调用自己的
                authenticationFailureHandler.onAuthenticationFailure(request, response, e);
                return;//结束方法，不再调用过滤器链
            }
        }
        chain.doFilter(request, response);
    }

    public void validate(HttpServletRequest request, HttpServletResponse response) throws ValidateCodeException {
        //请求中传来的验证码
        String code = request.getParameter("login_code");
        //session 存储的验证码
        String session_Code = (String) request.getSession().getAttribute("login_code");
        logger.info("用户输入验证码：{}========session中存的验证码：{}", code, session_Code);
        if (StringUtils.isEmpty(code)) {
            throw new ValidateCodeException("验证码不能为空！");
        }
        if (StringUtils.isEmpty(session_Code)) {
            throw new ValidateCodeException("验证码已经失效！");
        }
        if (!session_Code.equalsIgnoreCase(code)) {
            throw new ValidateCodeException("验证码输入错误！");
        }

    }


    /**
     * 验证码错误异常，继承spring security的认证异常
     */
    public static class ValidateCodeException extends AuthenticationException {
        /**
         * @Fields serialVersionUID : TODO
         */
        private static final long serialVersionUID = 1L;

        public ValidateCodeException(String msg) {
            super(msg);
        }
    }
}

5、controller 部分代码

HelloController.java

package com.king.security.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @program: springboot
 * @description:
 * @author: King
 * @create: 2022-03-02 00:34
 */
@Controller
public class HelloController {
    @RequestMapping("login")
    public String openLogin() {
        return "login.html";
    }
}

VerifyCodeController.java 图片验证码接口

这里就是生成一个图片验证码传到前端 可以看看我之前的文章

package com.king.security.controller;

import com.king.security.util.VerifyCodeGen;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

@RestController()
@Api(value = "图形验证码接口", tags = "图形验证码接口")
public class VerifyCodeController {

    @ApiOperation(value = "获取登录图形验证码", tags = "图形验证码接口")
    @GetMapping(value = "/login_code.png")
    public void login(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        HttpSession session = req.getSession();
        session.setAttribute("login_code", VerifyCodeGen.outputImage(resp));
    }
}

AdminController.java

这是一个测试类 其中@PreAuthorize 表示只有 ADMIN 权限的可以访问此接口

package com.king.security.controller;

import io.swagger.annotations.Api;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @program: springboot
 * @description:
 * @author: King
 * @create: 2022-03-02 13:00
 */
@RestController
@RequestMapping("/api/admin")
@PreAuthorize("hasAuthority('ADMIN')")
@Api(value = "管理员操作接口",tags = "管理员操作接口")
public class AdminController {
    @GetMapping("/hello")
    public String hello(){
        return "Hello Admin!";
    }
}

UserController.java

同理 这里只有 USER 或者 ADMIN 权限可以访问

package com.king.security.controller;


import com.king.security.vo.ResultObj;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * @program: springboot
 * @description:
 * @author: King
 * @create: 2022-03-02 13:03
 */
@RestController
@RequestMapping("/api/user")
@PreAuthorize("hasAnyRole('ADMIN','USER')")
@Api(value = "用户操作接口",tags = "用户操作接口")
public class UserController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello User!";
    }

    /**
     * 获得用户登录信息
     *
     * @return
     */
    @ApiOperation(value = "获得用户登录信息", httpMethod = "GET")
    @GetMapping("/info")
    public Object info() {
        return SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    }

主要代码就这样全部代码可以在文末获取

前端部分

前端 使用了一些框架 所以代码有点多就不全部粘贴出来了，文章末尾发源码地址

Vue 与 axios 部分代码

 const app = new Vue({
        el: "#main",
        data: {
            name: "",
            password: "",
            validateCode: ""
        },
        methods: {
            login: function () {
                let url = "/api/user/login.do";
                let param = new URLSearchParams()
                param.append('username', this.name)
                param.append('password', this.password)
                param.append('login_code', this.validateCode);
                console.log(this.validateCode)
                axios({
                    method: 'post',
                    url: url,
                    data: param
                }).then(function (res) {
                    if (res.data.code === 1) {
                        alertLayer(res.data.msg,"index.html")
                    } else {
                        alertMy(res.data.msg)
                    }
                    console.log(res);
                }).catch(function (error) {
                    console.log(error);
                });


            }
        }
    });

效果截图

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

源码地址

Github https://github.com/KingJin-web/springboot

Gitee https://gitee.com/KingJin-web/springboot

盛夏省下
关注
专栏目录
Spring boot 项目（二十二）——集成Spring Security，完成用户登录
weixin_45974176的博客
06-05 1278
集成SpringSecurity + mybatisplus完成自定义登录验证
SpringBoot集成Spring Security实现登录流程
wwyywwsaber的博客
05-05 888
前篇：https://blog.csdn.net/wwyywwsaber/article/details/123979279 登录验证码 使用kaptcha实现验证码 <dependency> <groupId>com.github.axet</groupId> <artifactId>kaptcha</artifactId> <version&g
spring boot集成spring security自定义登录认证、授权教程
最新发布
a360284634的博客
07-22 506
spring boot集成spring security框架，自定义登录认证、授权教程
Springboot整合SpringSecurity：自定义用户认证
weixin_40127083的博客
02-14 1241
Springboot整合SpringSecurity：自定义用户认证 文章目录Springboot整合SpringSecurity：自定义用户认证1 引言2 数据库表3 SpringSecurity的配置文件4 MyAuthenticationProvider实现4.1 从数据库里拿用户数据4.2 校验用户名与密码4.3 授予角色权限5 测试6 写在最后 1 引言 SpringSecurity可以...
Spring boot + Spring Security 实现用户登录管理
热门推荐
wtopps的专栏
10-20 2万+
前言 Spring Security，这是一种基于 Spring AOP 和 Servlet 过滤器的安全框架。它提供全面的安全性解决方案，同时在 Web 请求级和方法调用级处理身份确认和授权。其自身拥有一套管理用户登录信息的方法，本文就将介绍简单的使用Spring Security 来实现用户登录。 框架介绍 本文将使用Spring boot + Spring Security实现，S...
Springboot集成spring-security实现基于验证码的登录认证项目源码+项目说明.7z
12-18
Springboot集成spring-security实现基于验证码的登录认证项目源码+项目说明.7z ...SpringBoot整合security实现基于验证码的登录认证和动态角色管理，在此基础上集成JWT采用token代替session， 并将token存储到redis。
springboot+ spring security实现登录认证
05-04
SpringBoot结合Spring Security实现登录认证是企业级应用开发中常见的安全框架组合，它们为Web应用程序提供了强大的安全性。本文将深入探讨这两个技术的核心概念、配置以及如何整合以实现用户登录认证功能。 ...
SpringBoot2.7整合SpringSecurity+Jwt+Redis+MySQL+MyBatis完整项目代码
10-30
在本项目中，我们主要关注的是SpringBoot 2.7版本与多个技术的深度整合，包括Spring Security、JWT（JSON Web Token）、Redis缓存以及MySQL数据库，并利用MyBatis作为持久层框架。以下是对这些技术及其整合应用的...
Spring Security OAuth2集成短信验证码登录以及第三方登录
08-27
在实现集成登录认证组件时，我们需要了解OAuth2.0认证体系、SpringBoot、SpringSecurity以及Spring Cloud等相关知识。同时，我们还需要了解如何定义拦截器、如何在拦截的通知进行预处理、如何在UserDetailService....
Springboot项目整合springsecurity框架实现自定义登录认证
qq_41522183的博客
02-23 1914
目录Springsecurity框架整合实现自定义登录认证1.导入依赖：2.进行自定义登录配置3.进行UserDetailsService接口实现类的实现4.自定义认证核心代码类LoginValidateAuthenticationProvider5.认证成功处理器LoginSuccessHandler6.认证失败处理器LoginFailureHandler7.登录界面login.html8.各个路由请求路径9.springsecurity核心配置10.小结 Springsecurity框架整合实现自定义登
SpringBoot+SpringSecurity整合（实现了登录认证和权限验证）完整案例，基于IDEA项目
02-16
SpringBoot+SpringSecurity整合示例代码，实现了从数据库中获取信息进行登录认证和权限认证。 本项目为idea工程，请用idea2019导入（老版应该也可以）。 本项目用户信息所需sql文件，在工程的resources文件夹下，请自行导入mysql中。 运行SpringBootMainClass启动后，请在地址栏访问http://ip:port，在页面中登录，成功后会跳转至下一个页面，此时需要后退到刚才的页面，点击各个超链接来试验用户的授权情况。未登录时点击任何链接都会跳回首页。 一共提供了4个用户： 1.admin：可以访问所有请求 2.user1：只能访问user1Call请求 3.user2：只能访问user2Call请求 4.user3：只能访问user3Call请求 具体代码配置逻辑和说明，详见代码的注释
Spring Boot中整合Spring Security并自定义验证代码实例
08-30
本篇文章主要介绍了Spring Boot中整合Spring Security并自定义验证代码实例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
SpringBoot 整合 SpringSecurity
一个95后开发者，热爱编程，喜欢玩游戏. 希望可以结识更多的小伙伴...
07-03 1165
SpringBoot集成SpringSecurity（十五、添加验证码）
伍妖捌的小屋
05-22 311
前言 为什么需要添加验证码呢，如果没有验证码，不是也可以登录吗？验证码的主要作用是为了区分是人操作还是机器操作，防止机器自动注册和登录；如果没有验证码环节，机器可以无限制的注册用户，压垮数据库，当然登录也是一样，可以通过机器登录，然后肆无忌惮地朝网络上倾倒大量的、无意义的僵尸信息，垃圾邮件、垃圾广告、垃圾评论。 实现 添加依赖 <dependency> <groupId>com.github.penggle</groupId> <artifactId>ka
Spring boot 集成Spring security的自定义认证
Nopromises的博客
09-16 417
SpringBoot集成Spring Security分析1.首先，导入依赖:2.覆盖spring security的原认证配置：3.处理用户信息获取逻辑：登陆凭证校验：登陆规则校验：凭证加密：总结： 1.首先，导入依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifac...
springboot+springsecurity实现验证码验证功能
weixin_45411740的博客
07-19 720
于我们使用的是security权限管理，登陆是由security自行完成的，所以添加验证吗功能还比较复杂，具体的来说就是要在我们登录的时候去拦截登录流程，然后去判断我们的验证码是否正确，在校对后，流程继续进行，如果错误，抛出一个异常（刚开始是这么做的，但是后来发现异常无法捕获，导致页面报错，为了简单我就直接返回首页面了。...
spring boot 2.1.4整合spring Security实现自定义的登录
joeyin
05-08 422
总体项目结构 数据库的设计 1. 首先在pom.xml中添加对应的依赖 <!-->spring-boot 整合security --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-se...
spring boot整合spring security(自定义验证方式)
lichuangcsdn的博客
07-03 2619
spring security支持传统的查询数据库方式，也即根据用户名查询出用户信息，然后再比较前端传来的密码和数据库中的密码。 这种方式很常用。但不适合通过第三方进行的授权认证模式。这时候，我们需要自己处理登录验证过程。 针对这些情况，我们需要自定义Authentication Provider @Component public class CustomAuthenticationPr...
SpringBoot整合SpringSecurity element 自定义登录页面如何写
08-16
要在SpringBoot中整合SpringSecurity实现自定义登录页面，你可以按照以下步骤进行操作: 1. 首先，确保你的项目中已经引入了Spring Security和OAuth2的相关依赖，可以使用Maven或Gradle进行添加。<span class="em">1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值