【Spring Security】springboot + mybatis-plus + mysql 用户token验证登录功能

已于 2023-03-05 11:44:59 修改
阅读量1.4k 收藏 3
点赞数
分类专栏： Spring 文章标签： spring boot spring mysql
于 2022-05-29 17:54:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fisherish/article/details/124930621
版权

在这里插入图片描述

目录

前言

回顾：

【Spring Security】springboot + mybatis-plus + mysql 从数据库读取用户信息验证登录

【Spring Security】springboot + mybatis-plus + mysql 密码加密存储下的数据库用户验证登录

本节实现token验证登录功能，仅仅实现功能能用，不完善。

配置

application.properties

#spring.datasource.name=mysql
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&serverTimezone=Asia/Shanghai&characterEncoding=utf8&autoReconnect=true&useSSL=false&allowMultiQueries=true
spring.datasource.username=xxx
spring.datasource.password=xxx

spring.security.jwt.secret=e9948PG02lURjvhjotDGQ6ksRdz3920MEfdy0q6HIszaxNNXw5D1yGq7l3zVWVfUbPBSA56JMqawy7Mt2vPDx5AveuOHHpT0uZB
# token expire time limit 20000ms = 20s, 14400000ms = 14400s = 240m = 4h
spring.security.jwt.expMillis=20000

UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.sample.dao.entity.UserPattern">

    <!-- 通用查询映射结果 -->
    <resultMap id="BaseResultMap" type="org.sample.dao.entity.UserPattern">
        <id column="id" property="id" />
        <result column="username" property="username" />
        <result column="passwd" property="passwd" />
        <result column="enabled" property="enabled" />
        <result column="account_non_expired" property="account_non_expired" />
        <result column="account_non_locked" property="account_non_locked" />
        <result column="credentials_non_expired" property="credentials_non_expired" />
    </resultMap>

    <!-- 通用查询结果列 -->
    <sql id="Base_Column_List">
        id, username, passwd, enabled, account_non_expired, account_non_locked, credentials_non_expired
    </sql>

</mapper>

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>org.example</groupId>
    <artifactId>spring-security-learning</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>spring-security-02</module>
        <module>spring-security-01</module>
        <module>spring-security-03</module>
        <module>spring-security-04</module>
        <module>spring-security-05</module>
        <module>spring-security-06</module>
    </modules>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- spring security -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-jwt</artifactId>
            <version>1.0.9.RELEASE</version>
        </dependency>

        <!-- jdbc启动器 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

        <!-- validation -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.80</version>
        </dependency>

        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.3</version>
        </dependency>
    </dependencies>

</project>

编码

common.utils.JWTUtils

package org.sample.common.utils;

import com.alibaba.fastjson.JSON;
import org.springframework.security.jwt.Jwt;
import org.springframework.security.jwt.JwtHelper;
import org.springframework.security.jwt.crypto.sign.MacSigner;

import java.util.Map;

public class JWTUtils {

    /**
     * 创建JWT
     * @param secret
     * @param claims 创建payload的私有声明（根据特定的业务需要添加，如果要拿这个做验证，一般是需要和jwt的接收方提前沟通好验证方式的）
     * @return
     */
    public static String getAccessToken(String secret, Map<String, Object> claims){

        // 指定签名的时候使用的签名算法，也就是header那部分，jjwt已经将这部分内容封装好了。
        MacSigner rsaSigner = new MacSigner(secret);
        Jwt jwt = JwtHelper.encode(JSON.toJSONString(claims), rsaSigner);
        return jwt.getEncoded();
    }

    public static Map<String,Object> parseToken(String token){
        Jwt jwt = JwtHelper.decode(token);
        return JSON.parseObject(jwt.getClaims());
    }

    /**
     * 根据传入的token过期时间判断token是否已过期
     * @param expiresIn
     * @return true-已过期，false-没有过期
     */
    public static boolean isExpiresIn(long expiresIn){
        long now=System.currentTimeMillis();
        return now>expiresIn;
    }
}

config.filter.JwtAuthenticationTokenFilter

package org.sample.config.filters;

import lombok.extern.slf4j.Slf4j;
import org.sample.common.utils.JWTUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
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;
import java.util.Map;

@Slf4j
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    private String tokenHead = "Bearer ";

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String tokenValue = request.getHeader(HttpHeaders.AUTHORIZATION);
        if (!StringUtils.hasText(tokenValue)){
            filterChain.doFilter(request, response);
            return;
        }
        String token = tokenValue.substring(tokenHead.length());
        Map<String, Object> parseJWT = JWTUtils.parseToken(token);

        if (JWTUtils.isExpiresIn((long) parseJWT.get("expiresIn"))){
            // token 已经过期
            SecurityContextHolder.getContext().setAuthentication(null);
            filterChain.doFilter(request, response);
            return;
        }
        String username = (String) parseJWT.get("username");
        if (StringUtils.hasText(username) && SecurityContextHolder.getContext().getAuthentication() == null){
            // 正常用户
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            if(userDetails != null && userDetails.isEnabled()){
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());

                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

                // 设置用户登录状态
                log.info("authenticated user {}, setting security context", username);
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        filterChain.doFilter(request, response);
    }
}

handler

UsernamePasswordAuthenticationEntryPoint


package org.sample.handler;

import com.alibaba.fastjson.JSON;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

/**
 * 异常策略
 * @author
 * @des:
 */
@Component
public class UsernamePasswordAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setContentType("application/json;charset=utf-8");
        response.setHeader("WWW-Authenticate", "Bearer");
        response.addHeader("Access-Control-Allow-Origin", "*");
        response.setStatus(HttpStatus.UNAUTHORIZED.value());
        PrintWriter out = response.getWriter();
        Map<String,Object> data = new HashMap<>();
        data.put("path", request.getRequestURI());
        data.put("time", LocalDateTime.now().toString());
        data.put("errCode", HttpStatus.UNAUTHORIZED.value());
        data.put("errMsg", HttpStatus.UNAUTHORIZED.getReasonPhrase());
        out.write(JSON.toJSONString(data));
        out.flush();
        out.close();
    }
}

UsernamePasswordAuthenticationFailureHandler.Java

package org.sample.handler;

import com.alibaba.fastjson.JSON;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;

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

/**
 * 失败策略
 * @author
 */
@Component
public class UsernamePasswordAuthenticationFailureHandler implements AuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        response.setContentType("application/json;charset=utf-8");
        PrintWriter out = response.getWriter();
        out.write(JSON.toJSONString(exception));
        out.flush();
        out.close();
    }
}

UsernamePasswordAuthenticationSuccessHandler.java

package org.sample.handler;

import com.alibaba.fastjson.JSON;
import org.sample.common.utils.JWTUtils;
import org.sample.dao.entity.UserPattern;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


@Component
public class UsernamePasswordAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
    @Value("${spring.security.jwt.secret: huangxuanheng@163.com}")
    private String secret;

    @Value("${spring.security.jwt.expMillis: 7200000}")
    private long expMillis;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        Object principal = authentication.getPrincipal();
        response.setContentType("application/json;charset=utf-8");
        PrintWriter out = response.getWriter();

        User user = (User) principal;
        List<GrantedAuthority> authorities = new ArrayList<>();
        authorities.add(new SimpleGrantedAuthority("auth"));
        // 生成token
        Map<String, Object> claims = new HashMap<>();
        claims.put("username", user.getUsername());
        claims.put("authorities", user.getAuthorities());
        claims.put("enabled", user.isEnabled());
        claims.put("expiresIn", (System.currentTimeMillis() + expMillis));

        String token = JWTUtils.getAccessToken(secret, claims);

        Map<String,Object>result = new HashMap<>();
        result.put("accessToken", token);
        out.write(JSON.toJSONString(result));
        out.flush();
        out.close();
    }


}

UsernamePasswordLogoutSuccessHandler.java

package org.sample.handler;

import com.alibaba.fastjson.JSON;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.stereotype.Component;

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

/**
 * @author
 */
@Component
public class UsernamePasswordLogoutSuccessHandler implements LogoutSuccessHandler {

    @Override
    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        Object principal = authentication.getPrincipal();
        response.setContentType("application/json;charset=utf-8");
        PrintWriter out = response.getWriter();
        out.write(JSON.toJSONString(principal));
        out.flush();
        out.close();
    }
}

config.SecurityConfig

package org.sample.config;

import com.alibaba.fastjson.JSON;
import org.sample.config.filters.JwtAuthenticationTokenFilter;
import org.sample.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;

import java.io.PrintWriter;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserService userService;

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private AuthenticationSuccessHandler authenticationSuccessHandler;

    @Autowired
    private AuthenticationFailureHandler authenticationFailureHandler;

    @Autowired
    private AuthenticationEntryPoint authenticationEntryPoint;

    @Autowired
    private LogoutSuccessHandler logoutSuccessHandler;

    @Autowired
    private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;


    /**
     * PasswordEncoder
     * @return PasswordEncoder
     */
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /**
     * 方法二
     * 实现configure(AuthenticationManagerBuilder auth)配置方法
     * 配置文件中的默认用户和默认密码注释掉了
     * @param auth
     * @throws Exception
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }

    /**
     * 方法一
     * auth.userDetailsService(userDetailsService())
     */
//    @Bean
//    public UserDetailsService userDetailsService(){
//        return new UserDetailsService() {
//            // username是用户登录时填的用户名
//            public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//                UserPattern user = new UserPattern();
//                user.setUsername("mike");
//                user.setPassword("123456");
//                try {
//                    user = userService.loadByUserName(username);
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//
//                // 如果查不到用户名，这里可以抛出UsernameNotFoundException异常
//                // 根据username查询权限，这里假设从任意位置查到权限是auth
//                List<GrantedAuthority> authorities = new ArrayList<>();
//                authorities.add(new SimpleGrantedAuthority("auth"));
//                // User是系统自带的UserDetails实现类，4个状态其中一个为false就会抛异常
//                return new User(user.getUsername(), user.getPassword(), true, true, true, true, authorities);
//            }
//        };
//    }

    /**
     * 通过HttpSecurity 对象，获取到表单登录配置对象，修改对应的用户名和密码参数名称，即可完成自定义用户名和密码参数名称
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("admin")
                .antMatchers("/user/**").hasRole("user")
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .successHandler(authenticationSuccessHandler)
                .failureHandler(authenticationFailureHandler)
                .permitAll()
                .and()
                .exceptionHandling()
                .authenticationEntryPoint(authenticationEntryPoint)
                .and()
                .logout()
                .logoutSuccessHandler(logoutSuccessHandler)
                .and().csrf().disable()
        ;
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }

    public static void main(String[] args) {
    }
}

controller.HelloController

package org.sample.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @RequestMapping("/sayHello")
    public String sayHello(){
        return "十年生死两茫茫，不思量，自难忘----苏轼，hello";
    }
}

dao.entity.UserPattern

package org.sample.dao.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 测试用entity
 *
 * @author 
 * @since 
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = false)
@TableName(value = "test.h_user")
public class UserPattern implements Serializable {

    /**
     * ID
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 用户名 userName
     */
    @TableField(value = "username")
    private String username;

    /**
     * 密码 password
     */
    @TableField(value = "passwd")
    private String password;

    @TableField(value = "enabled")
    private int enabled;

    @TableField(value = "account_non_expired")
    private int accountNonExpired;

    @TableField(value = "account_non_locked")
    private int accountNonLocked;

    @TableField(value = "credentials_non_expired")
    private int credentialsNonExpired;

}

dao.mapper.UserServiceMapper

package org.sample.dao.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.sample.dao.entity.UserPattern;

/**
 *
 * @author 
 * @since 
 */
public interface UserServiceMapper extends BaseMapper<UserPattern> {
}

service.UserService

package org.sample.service;

import com.baomidou.mybatisplus.extension.service.IService;
import org.sample.dao.entity.UserPattern;

/**
 *
 * @author 
 * @since 
 */
public interface UserService extends IService<UserPattern> {

    UserPattern loadByUserName(String username);
}

service.Impl.UserServiceImpl

package org.sample.service.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.sample.dao.entity.UserPattern;
import org.sample.dao.mapper.UserServiceMapper;
import org.sample.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

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

@Service
public class UserServiceImpl extends ServiceImpl<UserServiceMapper, UserPattern> implements UserService, UserDetailsService {

    @Autowired
    private UserServiceMapper userServiceMapper;

    /**
     * 方法一
     * auth.userDetailsService(userDetailsService())
     * @param username
     * @return
     */
    @Override
    public UserPattern loadByUserName(String username) {
        List<UserPattern> userPatterns = userServiceMapper.selectList(Wrappers.lambdaQuery(UserPattern.class)
                .likeLeft(UserPattern::getUsername, username)
                .likeRight(UserPattern::getUsername, username)
        );
        UserPattern userPattern = userPatterns.get(0);
        return userPattern;
    }

    /**
     * 方法二
     * auth.userDetailsService(userDetailsService)
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        List<UserPattern> userPatterns = userServiceMapper.selectList(Wrappers.lambdaQuery(UserPattern.class)
                .likeLeft(UserPattern::getUsername, username)
                .likeRight(UserPattern::getUsername, username)
        );
        UserPattern userPattern = userPatterns.get(0);

        boolean enabled = userPattern.getEnabled() == 1;
        // 如果查不到用户名，这里可以抛出UsernameNotFoundException异常
        // 根据username查询权限，这里假设从任意位置查到权限是auth
        List<GrantedAuthority> authorities = new ArrayList<>();
        authorities.add(new SimpleGrantedAuthority("auth"));
        return new User(userPattern.getUsername(), userPattern.getPassword(), enabled, true, true, true, authorities);
    }
}

MainApplication

package org.sample;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("org.sample.dao.mapper")
public class MainApplication {

    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}

文件结构

在这里插入图片描述

运行

运行MainApplication.java

postman登录：
在这里插入图片描述

复制得到的这个token：

写入sayHello接口的token中，访问接口：
在这里插入图片描述

再过20秒之后，token会自动失效，此时再访问：

在这里插入图片描述
显示未认证，说明token失效，需要重新登录获取token，成功！

postman使用时记得关掉这个设置，否则带不带token，都能够调用接口，因为postman自动记住token了：

在这里插入图片描述

锥栗
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Boot+Mybatis Plus+Thymeleaf实现用户登录和校验用户名是否重复功能
04-28
Spring Boot+Mybatis Plus+Thymeleaf实现用户登录和校验用户名是否重复功能
实战SpringBoot集成JWT实现token验证（附项目地址）
Java笔记虾
08-08 2345
作者：意识流丶www.jianshu.com/p/e88d3f8151dbJWT官网：https://jwt.io/JWT(Java版)的github地址:https://github....
Spring Boot +JWT +MybatisPlus，使用Token登录详细教程，附源码！
qq_41645986的博客
12-07 2504
一、新建Spring Boot项目 1.File→New→Module 2.点击下一步 3.写完这些，点击下一步 4.选择插件 5.选择项目地址，选择完成后点击Finish 二 1…创建完成后，修改pom.xml文件，添加以下依赖 <!-- MybatisPlus 核心库 --> <dependency> <groupId>com.baomidou</groupId> <artifac
使用SpringBoot+Mybatis+MySql实现登录功能（通俗易懂）
weixin_47458072的博客
11-12 1226
使用SpringBoot+Mybatis+MySql实现登录功能（通俗易懂） 项目搭建 （我的idea是汉化版的需要的可以点击settings选择plugin搜索Chinese，找到Simplified下载安装） 新建项目，在IDEA中，点击文件-> 新建->项目 进入这个页面，选择Spring Initializr，注意你要提前自己配置一下JDK环境，我这里使用的JDK版本是1.8。 因为我使用的IDEA版本是2021.2，不同的版本看到的页面可能不一样，不过...
JWT，springboot整合JWT完成token的验证，token的使用，java架构师技术栈
m0_64204730的博客
11-21 574
/** @author [email protected] @date 2020/11/8 12:40 */ public class JWTUtils { //签名 自己项目中的签名 private static final String SIGN = “token!@19weawe2r24@#$@%!wewa98du”; /** 生成token @param claim 传入的payload @return */ public static String getToken(M
基于SpringBoot + Mybatis-Plus + SpringSecurity + JWT 实现的社区系统+源代码+文
11-29
- [x] Spring Security - [x] JWT - [x] Flyway - [x] Elasticsearch - [x] Redis - [x] Swagger - [x] Lombok - [x] Hutool - [x] FastJson - [ ] JustAuth ## 使用指导 - 克隆当前项目到本地 - 创建本地数据库...
基于SpringBoot+Mybatis-Plus+JWT的前后端分离社区系统源码+项目说明.zip
最新发布
01-08
1、基于SpringBoot+Mybatis-Plus+JWT的前后端分离社区系统源码+项目说明.zip 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，...
zealsay_backend：Spring Boot快速开发脚手架，以博客论坛为示例展示，后台主要使用Spring Boot，Spring Security，Mybatis-plus，redis token，前端使用Nuxt，Vue，Vuex，Vue-Router，Vuetify
01-29
:shortcake:后台基于Spring Boot ，主体采用Spring Security和Mybatis-Plus 。 :cheese_wedge:预先采用基于Vue的服务端渲染解决方案Nuxt ，样式Vuetify基于Vuetify优秀的MD样式Vuetify库。 开发指南 :rocket: :...
基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 微信小程序
05-22
权限认证使用 Spring Security & Token & Redis，支持多终端、多种用户的认证系统，支持 SSO 单点登录 支持加载动态权限菜单，按钮级别权限控制，本地缓存提升性能 支持 SaaS 多租户系统，可自定义每个租户的权限，...
基于Springboot+Vue的景点管理系统+毕业设计
01-14
技术栈：springboot ，mybatis-plus ，mysql5.7，redis，jwt，token，Spring Security，swagger #### 设计模块： 登录模块，注册模块，权限管理模块，用户管理模块，景点管理模块，订单管理模块 ，景点评价管理...
Spirng Boot+Shiro+Druid+Mybatis Plus+Mysql搭建基础框架实现登录用户认证
07-31
Spirng Boot+Shiro+Druid+Mybatis Plus+Mysql搭建基础框架实现登录用户认证 可直接下载运行
SpringBoot整合Mybatis-Plus、Jwt实现登录token设置
不愧是暮言的博客
05-01 1926
首先，我们需要了解 JWT 的核心框架和使用规范，并通过代码实现 JWT 的生成和解析。在上述代码中，我们通过 addPathPatterns() 方法设置需要拦截的 URL 路径，并通过 excludePathPatterns() 方法排除不需要拦截的 URL 路径。在 Mybatis-plus 中使用 JWT 时，我们需要在登录成功之后生成 JWT，并将其返回给客户端。其中，“alg” 参数表示签名的算法（例如HS256），“typ” 参数表示令牌的类型（例如JWT）。
java编写用户登录接口_spring boot、mybatis 实现用户登录接口
weixin_33277243的博客
02-26 2006
上次写了用户注册接口的实现，接着写登录接口传统的登录验证方式是 session + cookie 的形式，这种验证方式不太适用于只提供 restful api 的后端系统，所以选择了 基于 token 的验证方式。token 是个长字符串，客户端向服务器申请。在需要登录的请求中每次都携带上申请到的token，服务器端验证 token 的有效性，只有验证通过了才允许访问。具体怎么验证 token 下...
SpringBoot 集成 Mybatis 实现用户登录
一条菜鸟鱼的博客
05-18 1792
SpringBoot 集成 Mybatis 实现用户登录SpringBoot 集成 Mybatis 实现用户登录① 引入 mybatis 依赖② 创建 bean 类③ mapper 层⑤ service 层⑥ controller 层⑦ 前端界面⑧ 数据库⑨ 运行结果 SpringBoot 集成 Mybatis 实现用户登录 这里我们书写这个的意义不仅是为了实现简单的用户登录功能, 而是为了了解 SpringBoot - MVC 设计模式的基本使用流程。 我们可以通过对用户登录一个功能的学习, 而拓展
SpringBoot整合JWT实现前后端Token验证
Shawn的个人博客
01-27 771
一、JWT介绍 1、JWT简介 Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。 官网：https://jwt.io/introduction/ 2
【Springboot 入门培训】#10 Security（二） 数据库DB 登录验证
zhtbs的博客
09-13 960
介绍Security中的自定义验证方法，继承UserDetailsService接口在实现类中连接数据库DB进行登录验证业务。 验证与授权 ​ 在上一章中我们学到了在「WebSecurityConfigurerAdapter」的子类中的如何定义验证与授权，来完成用户名称与密码的登录验证与授权功能。 验证方法 protected void configure(AuthenticationManagerBuilder auth) 授权方法 protected void configure(HttpSec
快速上手之SpringBoot+Mybatis实现简单登录功能
smietao的博客
05-26 4452
使用SpringBoot&Mybatis&通用Mapper快速实现一个简单的Web登录功能。
Spring security登录校验的实现
m0_64393446的博客
05-10 168
登录①自定义登录接口调用ProviderManager的方法进行认证 如果认证通过生成jwt把用户信息存入redis中②自定义UserDetailsService在这个实现类中去查询数据库注意配置passwordEncoder为BCryptPasswordEncoder校验：①定义Jwt认证过滤器获取token解析token获取其中的userid从redis中获取用户信息存入SecurityContextHolder3.6.4 准备工作①添加依赖。
Mybatis Plus 登录
m0_54883970的博客
04-06 776
//登录 @RequestMapping(“/goHouse”) @ResponseBody public APIResponse goHouse(String uname,String ph ){ HosUser hosUser=new HosUser(); hosUser.setUname(uname); hosUser.setHospassword(ph); System.out.println(hosUser); try { HosUser hosUser1 = hosUserService.get
springboot+mybatis-plus+layui+ajax+mysql实现登录按钮与注册按钮
03-26
这是一个比较完整的实现，需要以下步骤： 1.创建项目 使用Spring Boot、Mybatis-Plus和Layui创建一个Maven项目。 2.初始化项目 在项目中创建一个LoginController类和LoginService类，以处理登录和注册请求。 3.添加Mybatis-Plus配置 在application.properties文件中添加Mybatis-Plus配置。 ``` java #Mybatis-Plus配置 mybatis-plus.mapper-locations=classpath:/mapper/*Mapper.xml mybatis-plus.global-config.cache-enabled=true mybatis-plus.global-config.db-config.logic-delete-value=0 mybatis-plus.global-config.db-config.logic-not-delete-value=1 ``` 4.定义实体类和映射文件 在项目中定义一个User实体类，并通过Mybatis-Plus创建一个对应的UserMapper映射文件。 5.实现Mybatis-Plus数据库操作 在LoginService中实现Mybatis-Plus数据库操作，包括用户登录和注册。 6.添加前端页面 在src/main/resources/templates目录下新建login.html页面，使用Layui框架实现登录和注册表单。 7.添加Ajax请求 在login.html页面中添加Ajax请求，分别处理登录和注册请求。 8.测试应用程序 运行程序并在浏览器中打开login.html页面，测试登录和注册功能。 完整示例代码：https://github.com/Joyceq/springboot-mybatisplus-layui-ajax

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

锥栗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值