【SpringBoot篇】再战登录注册操作

喜欢ヅ旅行 2024-04-17 06:42 50阅读 0赞

#### 文章目录 ####

*  ⭐model.dto.user层
 *   *  ?UserRegisterRequest.java
     *  ?UserLoginRequest.java
 *  ⭐model.dto.entity层
 *   *  ?User.java
 *  ⭐service层
 *   *  ?UserService.java
     *  ?UserServiceimpl.java
 *  ⭐controller层
 *  ⭐mapper层
 *   *  ?UserMapper.java
 *  ⭐common层
 *   *  ?BaseResponse.java
     *  ?ErrorCode.java
     *  ?ResultUtils.java
 *  ⭐expection层
 *   *  ?BusinessException.java
     *  ?GlobalExceptionHandler.java

![在这里插入图片描述][efdef4fdc11049edad666ee1ad826174.png]

总结了一下登录注册的操作，担心忘了。就记录一下，方便以后复习使用。  
本篇文章仅仅作为我自己复习使用，可能会有问题，请谅解！

## ⭐model.dto.user层 ##

### ?UserRegisterRequest.java ###

@Data
    public class UserRegisterRequest implements Serializable {
        
    
        private static final long serialVersionUID = 3191241716373120793L;
    
        private String userAccount;
    
        private String userPassword;
    
        private String checkPassword;
    }

### ?UserLoginRequest.java ###

@Data
    public class UserLoginRequest implements Serializable {
        
    
        private static final long serialVersionUID = 3191241716373120793L;
    
        private String userAccount;
    
        private String userPassword;
    }

## ⭐model.dto.entity层 ##

### ?User.java ###

/**
     * 用户
     * @TableName user
     */
    @TableName(value ="user")
    @Data
    public class User implements Serializable {
        
        /**
         * id
         */
        @TableId(type = IdType.ASSIGN_ID)
        private Long id;
    
        /**
         * 账号
         */
        private String userAccount;
    
        /**
         * 密码
         */
        private String userPassword;
    
        /**
         * 用户昵称
         */
        private String userName;
    
        /**
         * 用户头像
         */
        private String userAvatar;
    
        /**
         * 用户角色：user/admin
         */
        private String userRole;
    
        /**
         * 创建时间
         */
        private Date createTime;
    
        /**
         * 更新时间
         */
        private Date updateTime;
    
        /**
         * 是否删除
         */
        @TableLogic
        private Integer isDelete;
    
        @TableField(exist = false)
        private static final long serialVersionUID = 1L;
    }

## ⭐service层 ##

### ?UserService.java ###

public interface UserService extends IService<User> {
        
    
        /**
         * 用户注册
         *
         * @param userAccount   用户账户
         * @param userPassword  用户密码
         * @param checkPassword 校验密码
         * @return 新用户 id
         */
        long userRegister(String userAccount, String userPassword, String checkPassword);
    
        /**
         * 用户登录
         *
         * @param userAccount  用户账户
         * @param userPassword 用户密码
         * @param request
         * @return 脱敏后的用户信息
         */
        LoginUserVO userLogin(String userAccount, String userPassword, HttpServletRequest request);
        
    }

### ?UserServiceimpl.java ###

@Service
    @Slf4j
    public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
        
    
        /**
         * 盐值，混淆密码
         */
        private static final String SALT = "chihiro";
    
        @Override
        public long userRegister(String userAccount, String userPassword, String checkPassword) {
        
            // 1. 校验
            if (StringUtils.isAnyBlank(userAccount, userPassword, checkPassword)) {
        
                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 (!userPassword.equals(checkPassword)) {
        
                throw new BusinessException(ErrorCode.PARAMS_ERROR, "两次输入的密码不一致");
            }
            synchronized (userAccount.intern()) {
        
                // 账户不能重复
                QueryWrapper<User> queryWrapper = new QueryWrapper<>();
                queryWrapper.eq("userAccount", userAccount);
                long count = this.baseMapper.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);
                boolean saveResult = this.save(user);
                if (!saveResult) {
        
                    throw new BusinessException(ErrorCode.SYSTEM_ERROR, "注册失败，数据库错误");
                }
                return user.getId();
            }
        }
    
        @Override
        public LoginUserVO userLogin(String userAccount, String userPassword, HttpServletRequest request) {
        
            // 1. 校验
            if (StringUtils.isAnyBlank(userAccount, userPassword)) {
        
                throw new BusinessException(ErrorCode.PARAMS_ERROR, "参数为空");
            }
            if (userAccount.length() < 4) {
        
                throw new BusinessException(ErrorCode.PARAMS_ERROR, "账号错误");
            }
            if (userPassword.length() < 8) {
        
                throw new BusinessException(ErrorCode.PARAMS_ERROR, "密码错误");
            }
            // 2. 加密
    //        String encryptPassword = DigestUtils.md5DigestAsHex((SALT + userPassword).getBytes());
            // 查询用户是否存在
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("userAccount", userAccount);
    //        queryWrapper.eq("userPassword", encryptPassword);
            User user = this.baseMapper.selectOne(queryWrapper);
            // 用户不存在
            if (user == null) {
        
                log.info("user login failed, userAccount cannot match userPassword");
                throw new BusinessException(ErrorCode.PARAMS_ERROR, "用户不存在或密码错误");
            }
            // 3. 记录用户的登录态
            request.getSession().setAttribute(USER_LOGIN_STATE, user);
            return this.getLoginUserVO(user);
    
        }
     }

## ⭐controller层 ##

@RestController
    @RequestMapping("/user")
    @Slf4j
    public class UserController {
        
    
        @Resource
        private UserService userService;
    
      
    
        /**
         * 用户注册
         *
         * @param userRegisterRequest
         * @return
         */
        @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();
            if (StringUtils.isAnyBlank(userAccount, userPassword, checkPassword)) {
        
                return null;
            }
            long result = userService.userRegister(userAccount, userPassword, checkPassword);
            return ResultUtils.success(result);
        }
    
        /**
         * 用户登录
         *
         * @param userLoginRequest
         * @param request
         * @return
         */
        @PostMapping("/login")
        public BaseResponse<LoginUserVO> userLogin(@RequestBody UserLoginRequest userLoginRequest, HttpServletRequest request) {
        
            if (userLoginRequest == null) {
        
                throw new BusinessException(ErrorCode.PARAMS_ERROR);
            }
            String userAccount = userLoginRequest.getUserAccount();
            String userPassword = userLoginRequest.getUserPassword();
            if (StringUtils.isAnyBlank(userAccount, userPassword)) {
        
                throw new BusinessException(ErrorCode.PARAMS_ERROR);
            }
            LoginUserVO loginUserVO = userService.userLogin(userAccount, userPassword, request);
            return ResultUtils.success(loginUserVO);
        }
    }

## ⭐mapper层 ##

### ?UserMapper.java ###

public interface UserMapper extends BaseMapper<User> {
        
    
    }

## ⭐common层 ##

### ?BaseResponse.java ###

@Data
    public class BaseResponse<T> implements Serializable {
        
    
        private int code;
    
        private T data;
    
        private String message;
    
        public BaseResponse(int code, T data, String message) {
        
            this.code = code;
            this.data = data;
            this.message = message;
        }
    
        public BaseResponse(int code, T data) {
        
            this(code, data, "");
        }
    
        public BaseResponse(ErrorCode errorCode) {
        
            this(errorCode.getCode(), null, errorCode.getMessage());
        }
    }

### ?ErrorCode.java ###

public enum ErrorCode {
        
    
        SUCCESS(0, "ok"),
        PARAMS_ERROR(40000, "请求参数错误"),
        NOT_LOGIN_ERROR(40100, "未登录"),
        NO_AUTH_ERROR(40101, "无权限"),
        NOT_FOUND_ERROR(40400, "请求数据不存在"),
        FORBIDDEN_ERROR(40300, "禁止访问"),
        SYSTEM_ERROR(50000, "系统内部异常"),
        OPERATION_ERROR(50001, "操作失败");
    
        /**
         * 状态码
         */
        private final int code;
    
        /**
         * 信息
         */
        private final String message;
    
        ErrorCode(int code, String message) {
        
            this.code = code;
            this.message = message;
        }
    
        public int getCode() {
        
            return code;
        }
    
        public String getMessage() {
        
            return message;
        }
    
    }

### ?ResultUtils.java ###

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
         * @return
         */
        public static BaseResponse error(int code, String message) {
        
            return new BaseResponse(code, null, message);
        }
    
        /**
         * 失败
         *
         * @param errorCode
         * @return
         */
        public static BaseResponse error(ErrorCode errorCode, String message) {
        
            return new BaseResponse(errorCode.getCode(), null, message);
        }
    }

## ⭐expection层 ##

全局异常处理

### ?BusinessException.java ###

public class BusinessException extends RuntimeException {
        
    
        /**
         * 错误码
         */
        private final int code;
    
        public BusinessException(int code, String message) {
        
            super(message);
            this.code = code;
        }
    
        public BusinessException(ErrorCode errorCode) {
        
            super(errorCode.getMessage());
            this.code = errorCode.getCode();
        }
    
        public BusinessException(ErrorCode errorCode, String message) {
        
            super(message);
            this.code = errorCode.getCode();
        }
    
        public int getCode() {
        
            return code;
        }
    }

### ?GlobalExceptionHandler.java ###

@RestControllerAdvice
    @Slf4j
    public class GlobalExceptionHandler {
        
    
        @ExceptionHandler(BusinessException.class)
        public BaseResponse<?> businessExceptionHandler(BusinessException e) {
        
            log.error("BusinessException", e);
            return ResultUtils.error(e.getCode(), e.getMessage());
        }
    
        @ExceptionHandler(RuntimeException.class)
        public BaseResponse<?> runtimeExceptionHandler(RuntimeException e) {
        
            log.error("RuntimeException", e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "系统错误");
        }
    }

--------------------

Spring Boot 是一种流行的 Java 开发框架，为开发者提供了快速构建应用程序的能力。在实际应用中，用户登录和注册是几乎所有 Web 应用程序都需要的功能之一。Spring Boot 提供了丰富而强大的功能来支持用户身份验证和管理，使得实现用户登录和注册功能变得更加便捷和高效。

在用户登录过程中，通常用户会提供用户名和密码作为身份验证的凭证。后端服务器接收到这些凭证后，需要进行有效性验证。这可能涉及到查询数据库来验证用户名和密码的正确性。Spring Boot 支持多种数据访问方式，比如 JPA、MyBatis 等，开发者可以根据项目需求选择适合的方式来操作数据库，并验证用户提供的登录信息。

一旦用户的登录信息验证通过，后端可以生成一个令牌（Token）作为用户的身份认证凭证。这个令牌可以包含用户的角色、权限等信息，以便于后续的权限控制和访问管理。在现代 Web 应用中，常用的做法是使用 JWT（JSON Web Token）来生成和管理用户身份认证信息。通过 JWT，用户登录成功后会获得一个加密的 Token，前端可以将 Token 存储在 Cookie 或者本地存储中，用于在后续的请求中进行身份验证。

另一方面，用户注册功能也是至关重要的一部分。在用户注册过程中，用户需要提供必要的注册信息，例如用户名、密码、邮箱等。后端服务器需要对用户提供的注册信息进行有效性校验，确保注册信息的完整性和正确性。这可能包括检查用户名是否已存在、密码是否符合要求等。一旦注册信息验证通过，后端将用户信息持久化到数据库中，以便后续的登录和其他操作使用。

总的来说，Spring Boot 提供了强大的开发能力和丰富的生态系统，使得用户登录和注册功能的实现变得更加简单和高效。开发者可以利用 Spring Boot 的各种功能和插件来构建安全可靠的用户身份验证系统，保障用户信息的安全性和数据的完整性。通过合理设计和开发，结合各种安全机制和最佳实践，可以为用户提供更加安全、便捷和友好的登录和注册体验。

[efdef4fdc11049edad666ee1ad826174.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/ffd4e5b67be8477a9380d828e7e12e25.png