基于spring的用户登录验证

最新推荐文章于 2024-05-09 11:50:53 发布
最新推荐文章于 2024-05-09 11:50:53 发布
阅读量1.8k 收藏 14
点赞数 5
分类专栏： Java 文章标签： java spring 4 springmvc 层次模型 javabean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39381361/article/details/115418319
版权

包结构

在这里插入图片描述

域对象层

package com.ruansongyun.domain;

import java.io.Serializable;
import java.util.Date;

public class User implements Serializable {
    private int userId;
    private String userName;
    private String password;
    private int credits;
    private String lastIp;
    private Date lastVisit;

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

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

    public int getCredits() {
        return credits;
    }

    public void setCredits(int credits) {
        this.credits = credits;
    }

    public String getLastIp() {
        return lastIp;
    }

    public void setLastIp(String lastIp) {
        this.lastIp = lastIp;
    }

    public Date getLastVisit() {
        return lastVisit;
    }

    public void setLastVisit(Date lastVisit) {
        this.lastVisit = lastVisit;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", credits=" + credits +
                ", lastIp='" + lastIp + '\'' +
                ", lastVisit=" + lastVisit +
                '}';
    }
}


package com.ruansongyun.domain;

import java.io.Serializable;
import java.util.Date;

public class LoginLog implements Serializable {
    private int LoginLogId;
    private int userId;
    private String ip;
    private Date loginDate;

    public int getLoginLogId() {
        return LoginLogId;
    }

    public void setLoginLogId(int loginLogId) {
        LoginLogId = loginLogId;
    }

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public Date getLoginDate() {
        return loginDate;
    }

    public void setLoginDate(Date loginDate) {
        this.loginDate = loginDate;
    }

    @Override
    public String toString() {
        return "LoginLog{" +
                "LoginLogId=" + LoginLogId +
                ", userId=" + userId +
                ", ip='" + ip + '\'' +
                ", loginDate=" + loginDate +
                '}';
    }
}

持久层

package com.ruansongyun.dao;
import com.ruansongyun.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.sql.SQLException;

@Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;


    public int getMatchCount(String userName,String password){
        String sqlStr = " select count(*) from t_user where user_name = ? and password = ? ";
        //return jdbcTemplate.queryForInt(sqlStr,new Object[]{userName,password});
        //queryForInt方法过时 改用queryForObject 在方法的第三个参数写明返回类型 如String 则写成String.class
        return jdbcTemplate.queryForObject(sqlStr,new Object[]{userName,password},Integer.class);
    }

    public User findUserByUserName(String userName){
        String sqlStr = " select user_id,credits from t_user where user_name = ? ";
        User user = new User();
        jdbcTemplate.query(sqlStr, new Object[]{userName},
                new RowCallbackHandler() {
                    @Override
                    public void processRow(ResultSet resultSet) throws SQLException {
                        user.setUserId(resultSet.getInt("user_id"));
                        user.setUserName(userName);
                        user.setCredits(resultSet.getInt("credits"));
                        System.out.println(user.getCredits());
                    }
                });
        return user;
    }

    public void updateLoginInfo(User user){
        String sqlStr = " update t_user set credits = ? , last_visit = ? , last_ip = ? where user_id = ? ";
        jdbcTemplate.update(sqlStr,new Object[]{user.getCredits(),user.getLastVisit(),user.getLastIp(),user.getUserId()});
    }

}


package com.ruansongyun.dao;

import com.ruansongyun.domain.LoginLog;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class LoginLogDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void insertLoginLog(LoginLog loginLog){
        String sqlStr = " insert into t_login_log(user_id,ip,login_datetime) values (?,?,?) ";
        jdbcTemplate.update(sqlStr,new Object[]{loginLog.getUserId(), loginLog.getIp(), loginLog.getLoginDate()});
    }

}

服务层

package com.ruansongyun.service;

import com.ruansongyun.dao.LoginLogDao;
import com.ruansongyun.dao.UserDao;
import com.ruansongyun.domain.LoginLog;
import com.ruansongyun.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private LoginLogDao loginLogDao;

    public boolean hasMatchUser(String userName,String password){
        int matchCount = userDao.getMatchCount(userName, password);
        return matchCount > 0;
    }

    public User findUserByUserName(String userName){
        return userDao.findUserByUserName(userName);
    }

    @Transactional
    public void loginSuccess(User user){
        LoginLog loginLog = new LoginLog();
        loginLog.setUserId(user.getUserId());
        loginLog.setIp(user.getLastIp());
        loginLog.setLoginDate(user.getLastVisit());
        System.out.println(user.toString());
        userDao.updateLoginInfo(user);
        loginLogDao.insertLoginLog(loginLog);
    }
}

控制层

package com.ruansongyun.controller;

public class LoginCommand {
    private String userName;
    private String password;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

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

package com.ruansongyun.controller;

import com.ruansongyun.domain.User;
import com.ruansongyun.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.util.Date;

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping(value = "/index.html")
    public String loginPage(){
        return "login";
    }

    @RequestMapping(value = "/loginCheck.html")
    public ModelAndView loginCheck(HttpServletRequest request,LoginCommand loginCommand){
        boolean isValidUser = userService.hasMatchUser(loginCommand.getUserName(), loginCommand.getPassword());
        if (!isValidUser){
            return new ModelAndView("login","error","用户名或密码错误");
        }else{
            User user = userService.findUserByUserName(loginCommand.getUserName());
            user.setLastIp(request.getRemoteAddr());//获取ip地址 方法
            user.setLastVisit(new Date());
            user.setCredits(5+user.getCredits());
            //System.out.println("loginCheck："+user.getCredits());
            //System.out.println(user.toString());
            userService.loginSuccess(user);
            request.getSession().setAttribute("user",user);
            return new ModelAndView("main");
        }
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--配置扫描类包，将spring注解添加到ioc容器-->
    <context:component-scan base-package="com.ruansongyun.dao"/>
    <context:component-scan base-package="com.ruansongyun.service"/>

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close"
          p:driverClassName="com.mysql.jdbc.Driver"
          p:url="jdbc:mysql://localhost:3306/数据库?serverTimezone=UTC&amp;characterEncoding=utf-8"
          p:username="用户名"
          p:password="密码"  />

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
          p:dataSource-ref="dataSource"  />

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
          p:dataSource-ref="dataSource"/>
    <!--通过AOP配置事务增强，让Service包下所有bean的所有方法拥有事务-->
    <aop:config proxy-target-class="true">
        <aop:pointcut id="serviceMethod" expression=" execution(* com.ruansongyun.service..*(..))" />
        <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice"/>
    </aop:config>
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
</beans>

main.jsp

<%--
  Created by IntelliJ IDEA.
  User: r
  Date: 2021/4/3
  Time: 11:38
  To change this template use File | Settings | File Templates.
--%>
<%@ page language="java" contentType="text/html;charset=UTF-8;charset=UTF-8"  pageEncoding="UTF-8" %>
<html>
<head>
    <title>R论坛首页</title>
</head>
<body>
    ${user.userName},您好,欢迎您进入论坛,用户积分+5，现积分有${user.credits}
</body>
</html>

login.jsp

<%--
  Created by IntelliJ IDEA.
  User: r
  Date: 2021/4/3
  Time: 11:17
  To change this template use File | Settings | File Templates.
--%>
<%@ page language="java" contentType="text/html;charset=UTF-8;charset=UTF-8"  pageEncoding="UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<html>
<head>
    <title>R论坛登录页</title>
</head>
<body>
    <c:if test="${!empty error}">
        <font color="red"><c:out value="${error}"></c:out></font>
    </c:if>
    <form action="<c:url value="/loginCheck.html"></c:url>" method="post">
        用户名：<input type="text" name="userName"><br>
        密 码：<input type="password" name="password"><br>
        <input type="submit" value="登录">
        <input type="reset" value="重置">
    </form>
</body>
</html>

masterServlet-servlet.xml (masterServlet自定义就行 要和web.xml中servlet名称对应)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置扫描类包，将spring注解添加到ioc容器-->
    <context:component-scan base-package="com.ruansongyun.controller"/>

    <!--配置视图解析器，将ModelAndView及字符串解析为具体的页面-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
                p:viewClass="org.springframework.web.servlet.view.JstlView"
                p:prefix="/WEB-INF/jsp/"
                p:suffix=".jsp"/>
</beans>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <servlet>
        <servlet-name>masterServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--上面的类需要的jar包在spring-webmvc中-->
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>masterServlet</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
</web-app>

pom.xml(参考)

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>groupId</groupId>
    <artifactId>web-framework-spring</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>
        <dependency>
            <!--web.xml中org.springframework.web.context.ContextLoaderListener-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>
        <dependency>
            <!--web.xml中org.springframework.web.servlet.DispatcherServlet-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.testng/testng -->
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.9.10</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
    </dependencies>
</project>

这个案例也是《精通Spring 4.x 企业应用开发实战》的快速入门案例。

阮松云
关注
  • 5
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
利用Spring IOC技术实现用户登录验证机制
09-01
主要为大家详细介绍了Spring IOC技术实现用户登录验证机制的相关资料,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
学习记录-Springboot-web开发中网页的登录验证
Nchai的博客
05-23 447
1.1需要创建LoginController类，实现登陆方法，1.2登陆方法调用操作用户的Controller类，1.3用户Controller类调用Mapper接口，编写sql语句，进行用户信息查询，判断用户是否存在，并返回，
Spring-登录校验
吃土的柚的博客
04-26 308
全称：JSON Web Token （https://jwt.io/）,用于对应用程序上的用户进行身份标记头信息（Header）：记录令牌类型和签名算法，例如：{“alg”: “HS256”,“typ”: “JWT”}有效载荷（Payload）：记录一些自定义能够区分身份的非敏感信息，例如：{“id”: “1”,“username”: “tom”}签名（Signature）：用于保证Token在传输过程中不被篡改，它是header、payload，加入指定算法计算得来的。
springboot项目中登录校验
最新发布
qq_58216887的博客
05-09 1988
​ 1.定义拦截器，实现HandlerInterceptor接口，并重写其所有方法。方案一：在Controller的方法中进行try…catch处理（代码臃肿，不推荐）方案二：全局异常处理器（简单，优雅，推荐）程序开发过程中不可避免的会遇到的异常现象。优点：HTTP协议中支持的技术。优点：存储在服务器，安全。出现异常该如何处理？
（idea）利用SpringSecurity完成登录验证的流程
junqiqi77的博客
06-05 1686
spring security是一个安全可靠且高度可定制的安全框架，它提供身份验证和访问权限控制。按照框架的要求提供相关的信息和配置就可以利用spring security写出企业级安全的登录功能。认证：验证登录者的身份授权：定义登录者登录后可以做什么攻击防护：防止身份伪造有了springboot之后，springboot对spring security提供了自动化配置的方案，所以在springboot项目中可以实现零配置使用spring security。
用 Spring Web MVC 框架实现用户验证登录。程序从一个页面 login.jsp 进入，要求提供的服务是判断登录的用户和密码是否都是“admin“，若是跳转到页面 loginSucces
weixin_73603602的博客
05-30 1189
用 Spring Web MVC 框架实现用户验证登录。程序从一个页面 login.jsp 进入，要求提 供的服务是判断登录的用户和密码是否都是"admin"，若是跳转到页面 loginSuccess.jsp, 反 之跳转到 loginError.jsp。
Spring 没有ApplicationContext类 报红
qq_38862981的博客
03-23 1195
到pom文件导入相关依赖 <!--Spring的基础包Spring-core--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>5.2.8.RELEASE</version&gt
SpringBoot---登录校验
m0_62486174的博客
08-05 1570
● 该浏览器在后续的请求中，每一次请求都会将该令牌携带到服务端，然后接下来在服务端，我们可以通过Filter或Interceptor对所有的请求进行拦截，然后进行校验，获取到请求中携带过来的令牌，进行判断，如果令牌正确合法，则放行，如果令牌不合法，则直接返回错误信息给前端，前端跳转到登录页面。如果查询到的用户不存在，则说明用户输入的用户名和密码错误。中的信息，如果有登录成功的信息，就说明用户登录成功，放行请求，如果发现登录标记中没有登录成功的标记，则给前端返回错误信息，跳转至登录页面。
浅析Spring Security登录验证流程
08-25
Spring Security登录验证流程是Spring Security框架中最核心的部分之一，本文将详细介绍Spring Security登录验证流程的源码解析，通过源码讲解登录验证流程，具有很高的参考价值。 一、登录认证基于过滤器链 ...
如何基于spring security实现在线用户统计
08-19
Spring Security 是一个基于Spring Framework的安全框架，它提供了一个灵活、可扩展、可配置的安全解决方案。Spring Security 提供了许多功能，包括身份验证、授权、加密、会话管理等。 在线用户统计的重要性 在线...
基于spring boot 2和shiro实现身份验证案例
08-19
"基于Spring Boot 2和Shiro实现身份验证案例" 基于Spring Boot 2和Shiro实现身份验证案例是当前网络安全领域中的一种常见解决方案。Shiro是一个功能强大且易于使用的Java安全框架，官网：https://shiro.apache.org/...
Spring Security实现验证码登录功能
08-25
验证码的输入验证是通过 Spring Security的AuthenticationProvider来实现的，该provider将用户输入的验证码与生成的验证码进行比较，如果正确则允许用户登录。 知识点七：Spring Security验证码登录功能的优点 ...
04 SpringMVC中，使用拦截器验证用户是否登录功能（认证用户）【SpringMVC】
qq_53950878的博客
11-10 1236
使用拦截器验证用户是否登录功能（认证用户），防盗链、拦截器执行流程、拦截器概述、过滤器与拦截器的区别、
Spring学习笔记（八）基于Spring mvc技术的简单后台登录验证系统
weixin_72154059的博客
03-10 634
本项目主要是对用户登录状态的验证，只有登录成功的用户才可以访问系统中的资源。为了保证后台系统的页面不能被客户直接请求访问，本案例中所有的页面都存放在项目的WEB-INF文件夹下，客户需要访问相关页面时，需要在服务器端转发到相关页面。如果没有登录系统而直接访问系统首页，拦截器会将请求拦截，并转发到登录页面，同时在登录页面中给出提示信息。如果用户登录时提交的用户名或密码错误，也会在登录页面给出相应的提示信息。当已登录的用户在系统页面中单击“退出”链接时，系统同样会回到登录页面。
Spring学习：Spring整合web详解（用户登陆校验案例）
给时光以文明
07-06 237
文章目录一、总体思路总结二、DAO层、Service层和Controller层的区别三、用户登陆校验示例基本流程（一）添加web所需要的依赖包（二）初始Spring容器（三）定义DAO层类1. 定义用户信息类2. 定义DAO层数据库操作类（四）定义Service层类（五）将DAO层和Service层定义的类加载到IOC容器中1.创建IOC管理工具类2.配置IOC容器的核心文件3.创建IOC容器并加载配置文件（六）创建Controller层中Servlet（七）解决post请求中文乱码 一、总体思路总结 Sp
Spring AOP【用户登陆统一验证功能】
积跬步以至千里
01-14 1070
对于以上问题 Spring 中提供了具体的实现拦截器：HandlerInterceptor，拦截器的实现分为以下两个步创建⾃定义拦截器，实现接⼝的preHandle（执⾏具体⽅法之前的预处理）⽅法将⾃定义拦截器加⼊实现接口类的,重写⽅法中具体实现如下:/*** 自定义登陆用户登陆拦截器/*** 返回 ture 表示拦截判断通过, 可以访问后面的接口, 如果返回false 表示拦截未通过,直接返回结果给前端= null) {// 表示已经登陆 return true;
Springboot简单用户登录验证
zzds111的博客
11-14 6334
初版 结合了spring后，以及前面l连接数据库的内容，做出初版的页面匹配代码 先创建一个User类，如果输入的用户名存在，就从数据库中将这个用户的信息读取出来存储到我们创建的user类中，然后与输入的密码进行匹配 通过lombok插件，可以省略类里面的很多的创建步骤 import lombok.*; //set,get方法，构造方法有参无参，toString方法 @Setter @Getter @AllArgsConstructor @NoArgsConstructor @ToString pu
springSecurity实现登录验证
剪刀手何金银的技术博客
12-28 4148
文章目录实现AbstractAuthenticationToken自定义验证对象定义登录filter实现AbstractAuthenticationProcessingFilter的attemptAuthentication方法自定义身份验证处理器定义认证成功处理器定义认证失败处理器配置登录过滤器到springSecurity 实现AbstractAuthenticationToken自定义验证对象 在SpringSecurity认证过程中，最核心的对象为Authentication，这个对象用于在认证过
springsecurity登录验证流程
05-18
Spring Security是一个基于Spring框架的安全性框架，可以帮助我们实现身份验证、授权、攻击防护等安全功能。下面是Spring Security登录验证的基本流程： 1. 用户在登录页面输入用户名和密码，提交表单。 2. Spring ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值