1.实现用户的注册

原创

wx635131693f6f9 2022-10-21 10:16:26 博主文章分类：3.电脑商城项目 ©著作权

文章标签 json 用户名 spring 文章分类 运维

©著作权归作者所有：来自51CTO博客作者wx635131693f6f9的原创作品，请联系作者获取转载授权，否则将追究法律责任

1.总结：在昨天的学习中，主要是搭建mapper的两个接口方法实现用户的注册业务；首先是项目的创建，在创建的是够导入web，mybatis以及mysql driver

　　　　然后在生成项目的时候会自动生成mybatis，mysql的配置文件，我们根据自己的数据库进行更改。再就是创建mapper接口生成注册的插入和通过用户名

　　　　查询用户信息的两个接口方法，接着就是配置两个接口方法的xml文件，编写SQL语句。其次就是编写register业务，在这个过程中，我们首先是通过用户名

　　　　查询用户信息，再设置用户信息，注册到mysql中，其中密码是经过三次的MD5+password+MD5进行加密的；然后是根据具体方法编写异常基类和具体的异常

　　　　最后就是编写JSON的结果响应类，开始是较繁琐的把异常和成功地写在一起，后面生成一个基类，将异常放在基类中，让实际的继承基类，在实际的controller

　　　　中只写成功的，是一种很好地改进。

实体类基类

package com.ku.store.entity;

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

/**
 * 实体类的基类
 */
@Data
public class BaseEntity implements Serializable {
    private String createdUser;
    private Date createdTime;
    private String modifiedUser;
    private Date modifiedTime;
}

用户实体类

package com.ku.store.entity;

import lombok.Data;

@Data
public class User extends BaseEntity{
    private Integer uid;
    private String username;
    private String password;
    private String salt;
    private String phone;
    private String email;
    private Integer gender;
    private String avatar;
    private Integer isDelete;//逻辑删除

UserMapper接口

package com.ku.store.mapper;

import com.ku.store.entity.User;

public interface UserMapper {
    Integer insert(User user);

    User findByUsername(String username);
}

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="com.ku.store.mapper.UserMapper">

    <resultMap id="UserEntityMap" type="com.ku.store.entity.User">
        <id column="uid" property="uid"/>
        <result column="is_delete" property="isDelete"/>
        <result column="created_user" property="createdUser"/>
        <result column="created_time" property="createdTime"/>
        <result column="modified_user" property="modifiedUser"/>
        <result column="modified_time" property="modifiedTime"/>
    </resultMap>
    <!--useGeneratedKeys="true" ：如果插入的表id以自增列为主键，则允许 JDBC 支持自动生成主键，
    并可将自动生成的主键id返回。
    keyProperty="uid"
    useGeneratedKeys="true"配合keyProperty="uid"：将一个对象保存成功后，将插入的这条主键id返回，
    并保存到对象中，供后续使用
    -->
    <insert id="insert" useGeneratedKeys="true" keyProperty="uid">
        INSERT into
        store.t_user(username, password, salt, phone, email, gender, avatar, is_delete, created_user, created_time, modified_user, modified_time)
        values
        (#{username}, #{password}, #{salt}, #{phone}, #{email}, #{gender}, #{avatar},
         #{isDelete}, #{createdUser}, #{createdTime}, #{modifiedUser}, #{modifiedTime})
    </insert>

    <select id="findByUsername" resultMap="UserEntityMap">
        select * from store.t_user where username = #{username}
    </select>

</mapper>

IUserService接口

package com.ku.store.service;

import com.ku.store.entity.User;

public interface IUserService {
    /**
     * 通过用户进行注册
     * @param user
     */
    void reg(User user);
}

UserServiceImpl

package com.ku.store.service.impl;

import com.ku.store.entity.User;
import com.ku.store.mapper.UserMapper;
import com.ku.store.service.IUserService;
import com.ku.store.service.exception.InsertException;
import com.ku.store.service.exception.UsernameDuplicateException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.Date;
import java.util.UUID;

@Service
public class UserServiceImpl implements IUserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public void reg(User user) {
        //1.1 根据user参数获取注册的用户名
        //1.2 调用UserMapper的findByUsername根据用户名查询用户信息
        //1.3 判断查询结果是否为空，若为空，表示用户名已占用，抛出UsernameDuplicateException
        String username = user.getUsername();
        User result = userMapper.findByUsername(username);
        if(result != null){
            throw new UsernameDuplicateException("注册的用户"+username+"已被占用！");
        }

        //2.1创建当前时间对象：
        // 2.2 补全数据：加密后的密码
        // 2.3 补全数据：盐值
        // 2.4 补全数据：IsDelete(0)
        // 2.5 补全数据：4项日志属性
        Date now = new Date();
        String salt = UUID.randomUUID().toString().toUpperCase();
        String md5Password = getMd5Password(user.getPassword(), salt);
        user.setPassword(md5Password);
        user.setSalt(salt);
        user.setIsDelete(0);
        user.setCreatedUser(username);
        user.setCreatedTime(now);
        user.setModifiedUser(username);
        user.setModifiedTime(now);

        //3.1用户名没有被注册，则允许注册
        //3.2调用UserMapper的insert方法，执行注册并返回结果，判断是否不为1，
        // 是则插入错误抛出InsertException异常
        Integer rows = userMapper.insert(user);
        if(rows != 1){
            throw new InsertException("注册用户出现未知问题，请联系系统管理员！");
        }
    }

    private String getMd5Password(String password, String salt){
        /**
         * 加密规则：
         * 1.无视原始密码强度
         * 2.使用UUID作为盐值，在原始密码两侧拼接
         * 3.循环加密3次
         */
        for (int i = 0; i <3 ; i++) {
            password = DigestUtils.md5DigestAsHex((salt + password + salt).getBytes()).toUpperCase();
        }
        return password;
    }
}

exception

package com.ku.store.service.exception;

/**
 * 业务异常的基类
 */
public class ServiceException extends RuntimeException {
    public ServiceException() {
        super();
    }

    public ServiceException(String message) {
        super(message);
    }

    public ServiceException(String message, Throwable cause) {
        super(message, cause);
    }

    public ServiceException(Throwable cause) {
        super(cause);
    }

    protected ServiceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}


package com.ku.store.service.exception;

public class UsernameDuplicateException extends ServiceException {
    public UsernameDuplicateException() {
        super();
    }

    public UsernameDuplicateException(String message) {
        super(message);
    }

    public UsernameDuplicateException(String message, Throwable cause) {
        super(message, cause);
    }

    public UsernameDuplicateException(Throwable cause) {
        super(cause);
    }

    protected UsernameDuplicateException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}


package com.ku.store.service.exception;

public class InsertException extends ServiceException {
    public InsertException() {
        super();
    }

    public InsertException(String message) {
        super(message);
    }

    public InsertException(String message, Throwable cause) {
        super(message, cause);
    }

    public InsertException(Throwable cause) {
        super(cause);
    }

    protected InsertException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

JsonResult

package com.ku.store.utils;

import lombok.Data;

import java.io.Serializable;

@Data
public class JsonResult<E> implements Serializable {
    private Integer state;

    private String message;

    private E data;

    public JsonResult(){//要加上无参构造，不然controller层创建返回值报错
        super();
    }

    public JsonResult(Integer state){
        super();
        this.state = state;
    }

    /**
     * 出现异常时调用
     */
    public JsonResult(Throwable e){
        super();
        this.message = e.getMessage();
    }

    public JsonResult(Integer state, E data){
        super();
        this.state = state;
        this.data = data;
    }
}

没有提取异常的controller

package com.ku.store.controller;

import com.ku.store.entity.User;
import com.ku.store.service.exception.InsertException;
import com.ku.store.service.exception.UsernameDuplicateException;
import com.ku.store.service.impl.UserServiceImpl;
import com.ku.store.utils.JsonResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/users")
public class PreviousUserController {
    @Autowired
    private UserServiceImpl userService;

    @RequestMapping("/reg0")
    public JsonResult<Void> reg(User user){
        //创建返回值
        JsonResult<Void> result = new JsonResult<Void>();
        try {
            userService.reg(user);
            result.setState(200);
            result.setMessage("注册成功！");
        } catch (UsernameDuplicateException e) {
            result.setState(400);
            result.setMessage("用户名已被占用！");
        }catch (InsertException e) {
            result.setState(500);
            result.setMessage("注册失败，请联系系统管理员！");
        }
        return result;
    }
}

改进后的controller

package com.ku.store.controller;

import com.ku.store.service.exception.InsertException;
import com.ku.store.service.exception.ServiceException;
import com.ku.store.service.exception.UsernameDuplicateException;
import com.ku.store.utils.JsonResult;
import org.springframework.web.bind.annotation.ExceptionHandler;

/**
 * 该类用于响应成功的状态码以及统一处理异常 ,简化原来的controller
 */
//控制类基类
public class BaseController {
    public static final int OK = 200;

    @ExceptionHandler(ServiceException.class)
    public JsonResult<Void>handleException(Throwable e){
        JsonResult<Void> result = new JsonResult<>();
        if (e instanceof UsernameDuplicateException){
            result.setState(400);
        }else if(e instanceof InsertException){
            result.setState(500);
        }
        return result;
    }
}

package com.ku.store.controller;

import com.ku.store.entity.User;
import com.ku.store.service.impl.UserServiceImpl;
import com.ku.store.utils.JsonResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 处理用户相关请求的控制类
 */

@RestController
@RequestMapping("/users")
public class UserController extends BaseController {
    @Autowired
    private UserServiceImpl userService;

    @RequestMapping("/reg")
    public JsonResult<Void>reg(User user){
        userService.reg(user);
        return new JsonResult<>(OK);
    }
}