搞懂登录流程，新手看这篇就够了-六虎

找实习、找实习、找实习求内推有没有大佬们愿意给我一次机会。求求啦！

前语

本文章循序渐进从而完成一个企业级别的用户办理体系

写在前面咱们知道登录功用作为咱们开发的项目必备的一个功用，也是最基本的初始化功用！

但是怎么完成、功用全不全这个里边学问就很大了

比方倘若咱们仅仅是一张表的crud 这固然简略

但实在的登录或许注册功用考虑的肯定会更多比方怎么防止被恶意调用接口、仅有ID确保事务性、有没有集成三方登录、用户名的灵敏词汇的检索等等

那么就跟随作者一起去看看吧~

前置技能栈：首要您需求会创立 springBoot 项目以及具有 mysql （操作数据库）的根底！

作者水平有限、请多多包容~

初学者

以注册、和登录举比方就好了

首要咱们先结构一个SpringBoot项目
接下来咱们先引进 slf4j （测验文档）的依靠便利测验

<!--         https://doc.xiaominfo.com/knife4j/documentation/get_start.html-->
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>knife4j-spring-boot-starter</artifactId>
<version>3.0.3</version>
</dependency>

yaml 中装备一下 swagger

# 支撑 swagger3
spring:
	mvc:
		pathmatch:
			matching-strategy: ant_path_matcher

咱们就能够再项目中去编写完成功用啦

先搞一个用户表

create table user
(
  username     varchar(256)                       null comment '用户昵称',
  id           bigint auto_increment comment 'id'
  primary key,
  userAccount  varchar(256)                       null comment '账号',
  avatarUrl    varchar(1024)                      null comment '用户头像',
  gender       tinyint                            null comment '性别',
  userPassword varchar(512)                       not null comment '暗码',
  phone        varchar(128)                       null comment '电话',
  email        varchar(512)                       null comment '邮箱',
  userStatus   int      default 0                 not null comment '状况 0 - 正常',
  createTime   datetime default CURRENT_TIMESTAMP null comment '创立时间',
  updateTime   datetime default CURRENT_TIMESTAMP null on update CURRENT_TIMESTAMP,
  isDelete     tinyint  default 0                 not null comment '是否删去',
  userRole     int      default 0                 not null comment '用户人物 0 - 普通用户 1 - 办理员',
  planetCode   varchar(512)                       null comment '编号'
)
    comment '用户';

编写实体类（这儿咱们能够运用MybatisX 插件来进行一键生成）

package com.lizhi.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
 * 用户
 * @TableName user
 */
@TableName(value ="user") //告知MP 这是用户表
// 下面三个是Lombok的注解 作用是不需求 写 get set 了
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    /**
     * id
     */
    @TableId(type = IdType.AUTO)
    private Long id;
    /**
     * 用户昵称
     */
    private String username;
    /**
     * 账号
     */
    private String userAccount;
    /**
     * 用户头像
     */
    private String avatarUrl;
    /**
     * 性别
     */
    private Integer gender;
    /**
     * 暗码
     */
    private String userPassword;
    /**
     * 电话
     */
    private String phone;
    /**
     * 邮箱
     */
    private String email;
    /**
     * 状况 0 - 正常
     */
    private Integer userStatus;
    /**
     * 创立时间
     */
    private Date createTime;
    /**
     * 
     */
    private Date updateTime;
    /**
     * 是否删去
     */
    @TableLogic
    private Integer isDelete;
    /**
     * 用户人物 0 - 普通用户 1 - 办理员
     */
    private Integer userRole;
    /**
     * 编号
     */
    private String planetCode;
    @TableField(exist = false)
    private static final long serialVersionUID = 1L;
}

所以看到上面其实咱们还需求引进 mysql 连接池依靠 spring mybatis 依靠 mybatis-plus 依靠以及 lombok 依靠

<!-- 这个依靠是快速构建 启动项目 -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
  <optional>true</optional>
</dependency>
<!-- 数据库 -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <scope>runtime</scope>
</dependency>
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.2.2</version>
</dependency>
<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
  <version>3.5.1</version>
</dependency>
<!-- lombok -->
<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

mapper 层我就不搞了（MP帮你封装好了）

controller 操控层

package com.lizhi.controller;
import com.lizhi.entity.User;
import com.lizhi.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
/**
 * @author <a href="https://github.com/lizhe-0423">荔枝</a>
 */
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {
    @Resource
    private UserService userService;
    @PostMapping("/register")
    public String userRegister(@RequestBody User userRegisterRequest) {
        String userAccount = userRegisterRequest.getUserAccount();
        String userPassword = userRegisterRequest.getUserPassword();
        String planetCode = userRegisterRequest.getPlanetCode();
        long result = userService.userRegister(userAccount, userPassword, planetCode);
        return "注册成功";
    }
    @PostMapping("/login")
    public String userLogin(@RequestBody User userLoginRequest, HttpServletRequest request) {
        String userAccount = userLoginRequest.getUserAccount();
        String userPassword = userLoginRequest.getUserPassword();
        User user = userService.userLogin(userAccount, userPassword, request);
        return "登录成功";
    }
}

能够看到操控层更多的是进行一个交互咱们把具体的逻辑封装在 service层（处理事务）

service层

接口

package com.lizhi.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.lizhi.entity.User;
import javax.servlet.http.HttpServletRequest;
/**
 * 用户服务
 *
 * @author 荔枝
 */
public interface UserService extends IService<User> {
    /**
     * 用户注册
     *
     * @param userAccount   用户账户
     * @param userPassword  用户暗码
     * @param planetCode 编号
     * @return 新用户 id
     */
    long userRegister(String userAccount, String userPassword, String planetCode);
    /**
     * 用户登录
     *
     * @param userAccount  用户账户
     * @param userPassword 用户暗码
     * @param request
     * @return 用户信息
     */
    User userLogin(String userAccount, String userPassword, HttpServletRequest request);
}

完成

package com.lizhi.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lizhi.entity.User;
import com.lizhi.mapper.UserMapper;
import com.lizhi.service.UserService;
import lombok.extern.slf4j.Slf4j;
import lombok.val;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * 用户服务完成类
 *
 * @author 荔枝
 */
@Service
@Slf4j
public class UserServiceImpl extends ServiceImpl<UserMapper, User>
implements UserService {
    @Resource
    private UserMapper userMapper;
    @Override
    public long userRegister(String userAccount, String userPassword, String planetCode) {
        // 3. 刺进数据
        User user = new User();
        user.setUserAccount(userAccount);
        user.setUserPassword(userPassword);
        user.setPlanetCode(planetCode);
        boolean saveResult = this.save(user);
        if (!saveResult) {
            return -1;
        }
        return user.getId();
    }
    @Override
    public User userLogin(String userAccount, String userPassword, HttpServletRequest request) {
        val user = new User();
        user.setUserAccount(userAccount);
        user.setUserPassword(userPassword);
        // 4. 记载用户的登录态
        request.getSession().setAttribute("user", user);
        return user;
    }
}

访问下面这个地址

http://127.0.0.1:2318/api/doc.html

测验：

收成

上面仅仅一个简略的 demo 但demo 便是 demo 在实在开发中先不说安全问题的危险就说这些代码格式想必各位应该就受不了吧！

记得我还在上大二的时分那个时分身边有一个常常带着我做项目的”好哥哥” 其时便是他教给我代码的书写标准

其实这个东西你说他重要吧如同很重要不重要也不重要由于这个东西更多的便是”潜规“则一样以后早晚会懂得！！！

那么让咱们来说说上面有什么问题吧

首要从代码自身的视点来看：

拿注册来看 @requestBody 咱们知道获取的json 数据主动转换成对应的实体类也便是说这个当地是用来接收前端用户传来的数据的那么这个当地就有问题了咱们最好不要直接用一个User实体类来承受数据

由于一个完好实体类少了还好太多了话前端就不知道他要给你传什么了

所以在Java中咱们专门有一种说法叫 DTO 也便是恳求表明前端向后端传递的数据理解成request

/**
 * 用户注册恳求体
 *
 * @author 荔枝
 */
@Data
public class UserRegisterRequest implements Serializable {
    private static final long serialVersionUID = 3191241716373120793L;
    private String userAccount;
    private String userPassword;
    private String checkPassword;
    private String planetCode;
}

咱们仅仅把用到的数据封装成一个实体类已然有了前端向后端传递的数据了那么是不是有后端向前端传递的数据呢？没错咱们管这种叫 VO

比方前端展示的用户信息（在User 实体类中包括了ID、创立时间、更新时间等等这些是不给前端用户看的所以关于其他的数据咱们再封装成VO进行回来）

不要呈现魔法值

比方我session 那里存储的数据要用常量

package com.yupi.usercenter.contant;
/**
 * 用户常量
 *
 * @author 荔枝
 */
public interface UserConstant {
    /**
     * 用户登录态键
     */
    String USER_LOGIN_STATE = "userLoginState";
    //  ------- 权限 --------
    /**
     * 默认权限
     */
    int DEFAULT_ROLE = 0;
    /**
     * 办理员权限
     */
    int ADMIN_ROLE = 1;
}

不要回来前端字符串自界说通用回来类进行回来

安全性/功用性：

首要传递过来的数据咱们应该先进行校验（前端也需求进行校验）
一个完好的用户流程或许还包括删去用户、刊出登录等常见功用

进阶者

当你能考虑上述的东西的话那么在我的印象中你的实力应该有大二的实在水平啦

然后就让咱们来完成它吧！

接下来我只举例一些重要的功用完好的代码我会附上GitHub地址

用户操控层

package com.lizhi.usercenter.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.lizhi.usercenter.common.BaseResponse;
import com.lizhi.usercenter.common.ErrorCode;
import com.lizhi.usercenter.common.ResultUtils;
import com.lizhi.usercenter.exception.BusinessException;
import com.lizhi.usercenter.model.domain.User;
import com.lizhi.usercenter.model.domain.request.UserLoginRequest;
import com.lizhi.usercenter.model.domain.request.UserRegisterRequest;
import com.lizhi.usercenter.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.stream.Collectors;
import static com.lizhi.usercenter.contant.UserConstant.ADMIN_ROLE;
import static com.lizhi.usercenter.contant.UserConstant.USER_LOGIN_STATE;
/**
 * 用户接口
 *
 * @author 荔枝
 */
@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {
    @Resource
    private UserService userService;
    @PostMapping("/register")
    public BaseResponse<Long> userRegister(@RequestBody UserRegisterRequest userRegisterRequest) {
        if (userRegisterRequest == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        String userAccount = userRegisterRequest.getUserAccount();
        String userPassword = userRegisterRequest.getUserPassword();
        String checkPassword = userRegisterRequest.getCheckPassword();
        String planetCode = userRegisterRequest.getPlanetCode();
        if (StringUtils.isAnyBlank(userAccount, userPassword, checkPassword, planetCode)) {
            return null;
        }
        long result = userService.userRegister(userAccount, userPassword, checkPassword, planetCode);
        return ResultUtils.success(result);
    }
    @PostMapping("/login")
    public BaseResponse<User> userLogin(@RequestBody UserLoginRequest userLoginRequest, HttpServletRequest request) {
        if (userLoginRequest == null) {
            return ResultUtils.error(ErrorCode.PARAMS_ERROR);
        }
        String userAccount = userLoginRequest.getUserAccount();
        String userPassword = userLoginRequest.getUserPassword();
        if (StringUtils.isAnyBlank(userAccount, userPassword)) {
            return ResultUtils.error(ErrorCode.PARAMS_ERROR);
        }
        User user = userService.userLogin(userAccount, userPassword, request);
        return ResultUtils.success(user);
    }
    @PostMapping("/logout")
    public BaseResponse<Integer> userLogout(HttpServletRequest request) {
        if (request == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        int result = userService.userLogout(request);
        return ResultUtils.success(result);
    }
    @GetMapping("/current")
    public BaseResponse<User> getCurrentUser(HttpServletRequest request) {
        Object userObj = request.getSession().getAttribute(USER_LOGIN_STATE);
        User currentUser = (User) userObj;
        if (currentUser == null) {
        throw new BusinessException(ErrorCode.NOT_LOGIN);
    }
        long userId = currentUser.getId();
        // TODO 校验用户是否合法
        User user = userService.getById(userId);
        User safetyUser = userService.getSafetyUser(user);
        return ResultUtils.success(safetyUser);
    }
        @GetMapping("/search")
        public BaseResponse<List<User>> searchUsers(String username, HttpServletRequest request) {
        if (!isAdmin(request)) {
        throw new BusinessException(ErrorCode.PARAMS_ERROR);
    }
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        if (StringUtils.isNotBlank(username)) {
        queryWrapper.like("username", username);
    }
        List<User> userList = userService.list(queryWrapper);
        List<User> list = userList.stream().map(user -> userService.getSafetyUser(user)).collect(Collectors.toList());
        return ResultUtils.success(list);
    }
        @PostMapping("/delete")
        public BaseResponse<Boolean> deleteUser(@RequestBody long id, HttpServletRequest request) {
        if (!isAdmin(request)) {
        throw new BusinessException(ErrorCode.NO_AUTH);
    }
        if (id <= 0) {
        throw new BusinessException(ErrorCode.PARAMS_ERROR);
    }
        boolean b = userService.removeById(id);
        return ResultUtils.success(b);
    }
        /**
        * 是否为办理员
        *
        * @param request
        * @return
        */
        private boolean isAdmin(HttpServletRequest request) {
        // 仅办理员可查询
        Object userObj = request.getSession().getAttribute(USER_LOGIN_STATE);
        User user = (User) userObj;
        return user != null && user.getUserRole() == ADMIN_ROLE;
    }
    }

不知道童鞋们看到这儿有没有蒙不过不要慌就像我说的那些多出来的代码只不过是一些规则校验

当然了假如是正式或许担任的规则校验咱们应该抽取成一个代码片段

比方在 service层中接口 verfy接口（校验接口）

自界说的回来类

package com.lizhi.usercenter.common;
import lombok.Data;
import java.io.Serializable;
/**
 * 通用回来类
 *
 * @param <T>
 * @author 荔枝
 */
@Data
public class BaseResponse<T> implements Serializable {
    private int code;
    private T data;
    private String message;
    private String description;
    public BaseResponse(int code, T data, String message, String description) {
        this.code = code;
        this.data = data;
        this.message = message;
        this.description = description;
    }
    public BaseResponse(int code, T data, String message) {
        this(code, data, message, "");
    }
    public BaseResponse(int code, T data) {
        this(code, data, "", "");
    }
    public BaseResponse(ErrorCode errorCode) {
        this(errorCode.getCode(), null, errorCode.getMessage(), errorCode.getDescription());
    }
}

自界说回来信息

package com.lizhi.usercenter.common;
/**
 * 回来东西类
 *
 * @author 荔枝
 */
public class ResultUtils {
    /**
     * 成功
     *
     * @param data
     * @param <T>
     * @return
     */
    public static <T> BaseResponse<T> success(T data) {
        return new BaseResponse<>(0, data, "ok");
    }
    /**
     * 失利
     *
     * @param errorCode
     * @return
     */
    public static BaseResponse error(ErrorCode errorCode) {
        return new BaseResponse<>(errorCode);
    }
    /**
     * 失利
     *
     * @param code
     * @param message
     * @param description
     * @return
     */
    public static BaseResponse error(int code, String message, String description) {
        return new BaseResponse(code, null, message, description);
    }
    /**
     * 失利
     *
     * @param errorCode
     * @return
     */
    public static BaseResponse error(ErrorCode errorCode, String message, String description) {
        return new BaseResponse(errorCode.getCode(), null, message, description);
    }
    /**
     * 失利
     *
     * @param errorCode
     * @return
     */
    public static BaseResponse error(ErrorCode errorCode, String description) {
        return new BaseResponse(errorCode.getCode(), errorCode.getMessage(), description);
    }
}

此时咱们再来看到操控层

类型便是咱们自己界说的通用回来类型

咱们回来数据的时分便是自己界说的回来东西类

自界说过错代码

package com.lizhi.usercenter.common;
/**
 * 过错码
 *
 * @author 荔枝
 */
public enum ErrorCode {
    SUCCESS(0, "ok", ""),
    PARAMS_ERROR(40000, "恳求参数过错", ""),
    NULL_ERROR(40001, "恳求数据为空", ""),
    NOT_LOGIN(40100, "未登录", ""),
    NO_AUTH(40101, "无权限", ""),
    SYSTEM_ERROR(50000, "体系内部反常", "");
    private final int code;
    /**
     * 状况码信息
     */
    private final String message;
    /**
     * 状况码描绘（概况）
     */
    private final String description;
    ErrorCode(int code, String message, String description) {
        this.code = code;
        this.message = message;
        this.description = description;
    }
    public int getCode() {
        return code;
    }
    public String getMessage() {
        return message;
    }
    public String getDescription() {
        return description;
    }
}

这儿的用法便是再进行权限校验的时分假如报错自界说回来的过错

下面注册为例

参数校验假如不符合主动抛出咱们自界说的过错
账号校验有没有特别字符
账号有无与数据库重复
进行暗码的加密
回来用户id 假如注册失利回来-1

/**
 * 盐值，混淆暗码
 */
private static final String SALT = "lizhi";
@Override
public long userRegister(String userAccount, String userPassword, String checkPassword, String planetCode) {
    // 1. 校验
    if (StringUtils.isAnyBlank(userAccount, userPassword, checkPassword, planetCode)) {
        throw new BusinessException(ErrorCode.PARAMS_ERROR, "参数为空");
    }
    if (userAccount.length() < 4) {
        throw new BusinessException(ErrorCode.PARAMS_ERROR, "用户账号过短");
    }
    if (userPassword.length() < 8 || checkPassword.length() < 8) {
        throw new BusinessException(ErrorCode.PARAMS_ERROR, "用户暗码过短");
    }
    if (planetCode.length() > 5) {
        throw new BusinessException(ErrorCode.PARAMS_ERROR, "星球编号过长");
    }
    // 账户不能包括特别字符
    String validPattern = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";
    Matcher matcher = Pattern.compile(validPattern).matcher(userAccount);
    if (matcher.find()) {
        return -1;
    }
    // 暗码和校验暗码相同
    if (!userPassword.equals(checkPassword)) {
        return -1;
    }
    // 账户不能重复
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("userAccount", userAccount);
    long count = userMapper.selectCount(queryWrapper);
    if (count > 0) {
        throw new BusinessException(ErrorCode.PARAMS_ERROR, "账号重复");
    }
    // 星球编号不能重复
    queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("planetCode", planetCode);
    count = userMapper.selectCount(queryWrapper);
    if (count > 0) {
        throw new BusinessException(ErrorCode.PARAMS_ERROR, "编号重复");
    }
    // 2. 加密
    String encryptPassword = DigestUtils.md5DigestAsHex((SALT + userPassword).getBytes());
    // 3. 刺进数据
    User user = new User();
    user.setUserAccount(userAccount);
    user.setUserPassword(encryptPassword);
    user.setPlanetCode(planetCode);
    boolean saveResult = this.save(user);
    if (!saveResult) {
        return -1;
    }
    return user.getId();
}

收成

当你看到此时下来我想你应该对一个项目尤其是登录项目应该做什么有了一个明晰的认知

首要

你知道了 VO 和 DTO
实在的项目自界说通用回来与过错代码

咱们此时再来考虑一些东西以及上述的代码是不是能够再进行简化

问题如下

灵敏词汇的检索比方用户账号有无灵敏词汇（谩骂、种族歧视等等）
同一时间两个用户一起登陆是否会一起登录假如此时进行签到、打卡（会不会产生双倍积分？）
怎么防止被爬虫然后进行接口的调用
有没有完成找回暗码、记住暗码的功用？

以及更丰厚的功用或许更高档的技能

jwt 和 session + redis
springSecurity 或许 Sa-Token 登录框架辅助开发
查询用户追求性能咱们直接走Redis缓存

……

感悟者

针对上述罗列的问题

1 .灵敏词汇的检索比方用户账号有无灵敏词汇（谩骂、种族歧视等等）

解决方法：

数据库建立这么一张词汇表然后注册账号的时分用户名去匹配假如匹配到就回来用户名非法信息，不然注册成功

同一时间的确有或许会登录成功

解决方法：锁操作（这仅仅单机锁单机锁的意思假如处于分布式环境就会失效）

synchronized (unionId.intern()) {
    // 查询用户是否已存在
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("unionId", unionId);
    User user = this.getOne(queryWrapper);
    // 被封号，禁止登录
    if (user != null && UserRoleEnum.BAN.getValue().equals(user.getUserRole())) {
        throw new BusinessException(ErrorCode.FORBIDDEN_ERROR, "该用户已被封，禁止登录");
    }
    // 用户不存在则创立
    if (user == null) {
        user = new User();
        user.setUnionId(unionId);
        user.setMpOpenId(mpOpenId);
        user.setUserAvatar(wxOAuth2UserInfo.getHeadImgUrl());
        user.setUserName(wxOAuth2UserInfo.getNickname());
        boolean result = this.save(user);
        if (!result) {
            throw new BusinessException(ErrorCode.SYSTEM_ERROR, "登录失利");
        }
    }
    // 记载用户的登录态
    request.getSession().setAttribute(USER_LOGIN_STATE, user);
    return getLoginUserVO(user);

运用验证码每次登录或许注册的时分让用户进行验证码验证

解决方法：运用hutool 引进 hutool东西库的验证码功用：

package com.lizhi.stpspringbootinit.util;
import cn.hutool.captcha.CaptchaUtil;
import cn.hutool.captcha.ShearCaptcha;
import lombok.val;
/**
 * @author <a href="https://github.com/lizhe-0423">荔枝</a>
 * 图片验证码
 */
public class Captcha {
    /**
     * 生成 扭曲干扰验证码
     * @param str 传入 暗码进行验证
     * @return true 验证码正确 false 验证码过错
     */
    public boolean shearCaptcha(String str){
        ShearCaptcha captcha = CaptchaUtil.createShearCaptcha(200, 100, 4, 4);
        //图形验证码写出，能够写出到文件，也能够写出到流
        //        captcha.write("d:/shear.png");
        boolean verify = captcha.verify(str);
        return verify;
    }
}

找回暗码通过密保找回（数据表操作）而记住暗码其实便是登录用户的时分将用户信息存入 session 上面演示的功用中主动完成了此功用
jwt 和 session+redis 具体百度吧简略来说是两种不同的登录手法 jwt 愈加简略但扩展性差 session+redis的方法扩展性强

前面咱们知道用户将信息存入session 完成记住用户的功用

但这样有坏处咱们知道session表明一次会话所以关闭浏览器或许重启使用 session就会消失

而所谓的session+redis 不过便是将session信息存储到redis中罢了这样就能够进行长久的保存了！

而jwt 其实便是将用户信息携带在jwt（字符串）中（前后端传递jwt）

6.引进 Sa-Token

能够看我的另一篇笔记玩转Sa-Token 2023年，不会还有人用SpringSecurity登录鉴权吧 – ()

收成

假如你看到这儿假如你读到这儿那这便是真爱你难以抗拒~~~

好了此时你现已会自己考虑了你的实力现已不仅仅限制在代码自身我承认你的实力有大三的水平了（大三强者、恐怖如斯）

漫笔

过度考虑

所谓过度考虑在码农身上便是指过度优化关于你我新手来说便是只懂了解的技能选型假如叫你完成什么功用你有必要依靠它的前置代码而不能自身具有编写代码的能力

我把新手分为两个阶段

第一个阶段萌新

学习便是看视频你是一个真实在正的代码小白你获取信息学习的方法便是看视频假如遇到没有视频的新技能就会捉襟见肘一起在编程中假如遇到的过错的当地，也是百度假如百度不到也和前面一样！

你敲代码仅仅本能的仿照

第二个阶段初窥门径

你尝试开端阅读源码

你学习的方法开端变得厌烦看视频由于你觉得这样获取信息的速度太慢了

你能够尝试着写点功用而且有自己直接比方这篇文章用户办理功用

第三个阶段高档新手

你现已会看源码而且看得懂大部分源码

你获取信息的途径也不是纸质书籍教程而是阅读官方文档

你觉得自己什么都会又如同仅仅什么都会一点

你年轻气盛你迈入了编程的第一步

所以道阻且长咱们都应该尽力✊

关于成为怎样的人？

其实作者我没考上高中读的也是职高我费力尽力上的也不过是个三本

我厌烦这个大学我认为这是一个没有学术气氛而且官僚横行的校园我与朋友参与竞赛看其他校园导师带着一起答辩我也很羡慕

我高中常常想上了大学就好了

我上了大学还真的是这样大一我课余时间打篮球报吉他社

我常常看到网上有人说假如大一就开端学习编程就好了假如大一就看到这篇文章就好了

我也在想假如我大一学习就好了

但细心一想我真的懊悔码？

不管怎样这便是芳华不是吗？大学就应该干点大学的事不是吗？恋爱、散步、live house 、聚餐、运动 ……

****等等等等记得一句话 咱们不应该站在现在的高度去批评其时的自己 假如站在其时的视点或许又是一次重蹈覆辙但这一切真的仅仅重蹈覆辙吗？

结束

找实习找实习找实习、求内推~~~~

项目地址：

github.com/lizhe-0423/…

hutool（三方东西库）：

www.hutool.cn/

MybatisPlus（数据库）：

baomidou.com/

Sa-Token（登录框架）

sa-token.cc/

搞懂登录流程，新手看这篇就够了

前语

初学者

收成

进阶者

收成

感悟者

收成

漫笔

结束

相关文章

高可用架构的设计方法

听老外吐槽框架设计，Why I Hate Frameworks?

问题排查不再愁，Nacos 上线推送轨迹功能

LeakCanary 2.0 源码分析及总结

作者信息