springboot项目注册接口

基于eclipse工具上的

一、Controller层

package cn.kooun.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import cn.kooun.pojo.params.UserLoginParam;
import cn.kooun.pojo.params.UserRegisterParam;
import cn.kooun.service.UserService;

/**
 *  用户Controller
 * @author HuangJingNa
 * @date 2019年12月20日 上午9:21:38
 *
 */
@RestController //@Controller+@Responsebody
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserService userService;
    
    /**
     *   用户注册
     * @author HuangJingNa
     * @date 2019年12月20日 上午9:23:15
     *
     * @return
     * 客户端请求的数据一般封装在自定义的pojo类中（XxxParam）
     */
    /* 业务需求
     * 1.校验数据
     *  校验账号（非空、长度、唯一性）
     *  校验密码（非空、长度、格式）
     * 2.数据库操作（插入操作）
     * 3.将数据响应给客户端/页面
     */
    @GetMapping("register")
    public Object register(UserRegisterParam userRegisterParam) {
        return userService.register(userRegisterParam);
    }
}

注册接口参数封装类UserRegisterParam

package cn.kooun.pojo.params;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 *  注册接口参数封装
 * @author HuangJingNa
 * @date 2019年12月20日 上午9:28:47
 *
 */
@Setter
@Getter
@ToString
public class UserRegisterParam {
    /**账号名称*/
    private String username;
    /**账号密码*/   
    private String password;
}

二、service层

业务层：主要分为三步走：
1. 数据校验
2. 数据库的相关操作
3. 返回响应结果给客户端/页面

一般多次创建实例的，可以使用工厂模式
加密：使用Md5（较易破解），可以加入“盐”混合加密，越复杂越难破解
一般的标准校验（非空、长度、格式的判断）放在数据校验工具类中
操作数据库的代码较多，一般封装成一个方法（选中按alt+shift+M可以生成方法）

package cn.kooun.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import cn.kooun.common.CheckUtils;
import cn.kooun.common.Md5Utils;
import cn.kooun.common.UuidUtils;
import cn.kooun.common.result.Result;
import cn.kooun.common.result.ResultUtils;
import cn.kooun.mapper.UserMapper;
import cn.kooun.pojo.params.UserLoginParam;
import cn.kooun.pojo.params.UserRegisterParam;
import cn.kooun.pojo.table.User;

/**
 *   用户service
 * @author HuangJingNa
 * @date 2019年12月20日 上午9:29:25
 *
 */
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    /**
     *  注册业务
     * @author HuangJingNa
     * @date 2019年12月20日 上午9:30:21
     *
     * @param userRegisterParam
     * @return
     */
    public Object register(UserRegisterParam userRegisterParam) {
        //数据校验
        Object result = this.checkRegister(userRegisterParam);
        if(result != null) {
            return result;
        }
        //插入数据库
        //由于字段可能会发生变化，插入需要动态生成（使mapper类继承通用mapper）
        this.saveRegister(userRegisterParam);
        //返回友好提示，注册成功（使用工具类）
        return ResultUtils.success("注册成功~", Result.JUMP_LOGIN);
    }
    /**
     *  将账号密码插入数据库中
     * @author HuangJingNa
     * @date 2019年12月20日 下午3:33:48
     *
     * @param userRegisterParam
     */
    private void saveRegister(UserRegisterParam userRegisterParam) {
        User user = new User();
        user.setId(UuidUtils.getUuid());
        user.setUsername(userRegisterParam.getUsername());
        user.setPassword(Md5Utils.getPassword(
                userRegisterParam.getPassword(),
                userRegisterParam.getUsername()));
        user.setNickName("kooun_" + user.getId());
        user.setType(1);
        userMapper.insertSelective(user);
    }
    /**
     *  注册业务数据校验
     * @author HuangJingNa
     * @date 2019年12月20日 下午2:43:37
     *
     * @param userRegisterParam
     * @return
     */
    private Object checkRegister(UserRegisterParam userRegisterParam) {
        String username = userRegisterParam.getUsername();
        String password = userRegisterParam.getPassword();
        
        //校验账号
        if(!CheckUtils.checkUsername(username)) {
            return ResultUtils.error("账号不合法，请输入6-16个字母和数字的组合");
        }
            //校验账号是否存在
        if(userMapper.isExistUserNameByUsername(username)) {
            return ResultUtils.error("账号已被占用了~");
        }
        //校验密码
        if(!CheckUtils.checkPassword(password)) {
            return ResultUtils.error("密码不合法，请输入6-20个字母和数字的组合");
        }
        return null;
    }
}

数据校验工具类CheckUtils

package cn.kooun.common;

import org.springframework.util.StringUtils;

/**
 *  数据校验工具
 * @author HuangJingNa
 * @date 2019年12月20日 下午2:49:58
 *
 */
public class CheckUtils {
    /**
     *  校验账户数据
     * @author HuangJingNa
     * @param username 
     * @date 2019年12月20日 下午2:50:11
     *
     * @return
     */
    public static boolean checkUsername(String username) {
        boolean flag = true;
        if(StringUtils.isEmpty(username)) {
            return !flag;
        }
        if(!username.matches("[0-9a-zA-Z]{6,16}")) {
            return !flag;
        }
        return flag;
    }
    /**
     *  校验密码数据
     * @author HuangJingNa
     * @date 2019年12月20日 下午3:28:00
     *
     * @param password
     * @return
     */
    public static boolean checkPassword(String password) {
        boolean flag = true;
        if(StringUtils.isEmpty(password)) {
            return !flag;
        }
        if(!password.matches("[0-9a-zA-Z]{6,20}")) {
            return !flag;
        }
        return flag;
    }

}

响应消息封装工具类
响应返回的数据Result

package cn.kooun.common.result;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 *  通用响应数据模型
 * @author HuangJingNa
 * @date 2019年12月20日 下午2:57:50
 *
 */
@Setter
@Getter
@ToString
public class Result {
    /*
     * {
     *  status: "success/error",
     *  message: "友好提示消息",
     *  result: "业务数据",
     *  jump: "跳转标记=> index(首页),login(登录页)"
     * }
     */
    /**成功状态*/
    public static final String STATUS_SUCCESS = "success";
    /**错误状态*/
    public static final String STATUS_ERROR = "error";
    /**登录页跳转*/
    public static final String JUMP_LOGIN = "login";
    /**首页跳转*/
    public static final String JUMP_INDEX = "index";
    
    
    /**响应状态*/
    private String status;
    /**响应消息*/
    private String message;
    /**响应数据*/
    private Object result;
    /**跳转标识*/
    private String jump;
}

工具类

package cn.kooun.common.result;

import cn.kooun.common.factory.ErrorResultFactory;
import cn.kooun.common.factory.SuccessResultFactory;

/**
 *  业务响应标准类
 * @author HuangJingNa
 * @date 2019年12月20日 下午2:54:48
 *
 */
public class ResultUtils {
    /**
     *  业务成功响应
     * @author HuangJingNa
     * @date 2019年12月20日 下午2:56:45
     *
     * @param string
     * @return
     */
    public static Object success(String message) {
        SuccessResult successResult = SuccessResultFactory.getInstance();
        successResult.setMessage(message);
        return successResult;
    }
    /**
     *  业务成功响应
     * @author HuangJingNa
     * @date 2019年12月20日 下午2:56:45
     *
     * @param string
     * @return
     */
    public static Object success(String message, String jump) {
        SuccessResult successResult = SuccessResultFactory.getInstance();
        successResult.setMessage(message);
        successResult.setJump(jump);
        return successResult;
    }
    /**
     *  业务错误响应
     * @author HuangJingNa
     * @date 2019年12月20日 下午3:30:09
     *
     * @param string
     * @return
     */
    public static Object error(String message) {
        ErrorResult errorResult = ErrorResultFactory.getInstance();
        errorResult.setMessage(message);
        return errorResult;
    }
    /**
     *  业务成功响应
     * @author HuangJingNa
     * @date 2019年12月20日 下午7:57:51
     *
     * @param string
     * @param jumpIndex
     * @param ticket
     * @return
     */
    public static Object success(
            String message,
            String jump, 
            Object result) {
        SuccessResult successResult = SuccessResultFactory.getInstance();
        successResult.setMessage(message);
        successResult.setJump(jump);
        successResult.setResult(result);
        return successResult;
    }
}

成功数据封装

package cn.kooun.common.result;

/**
 *  成功业务封装数据
 * @author HuangJingNa
 * @date 2019年12月20日 下午3:01:58
 *
 */
public class SuccessResult extends Result{
    {
        this.setStatus(Result.STATUS_SUCCESS);
    }
}

错误数据封装

package cn.kooun.common.result;

/**
 *  错误业务封装数据
 * @author HuangJingNa
 * @date 2019年12月20日 下午3:01:58
 *
 */
public class ErrorResult extends Result{
    {
        this.setStatus(Result.STATUS_ERROR);
    }
}

由于要多次创建对象，则使用工厂模式
抽象工厂

package cn.kooun.common.factory;

/**
 *  响应结果抽象工厂
 * @author HuangJingNa
 * @date 2019年12月20日 下午3:11:37
 *
 */
public interface Factory<T> {
    /**
     *   创建具体实例
     * @author HuangJingNa
     * @date 2019年12月20日 下午3:12:50
     *
     * @return
     */
    T newInstance();
}

成功响应实例工厂

package cn.kooun.common.factory;

import cn.kooun.common.result.SuccessResult;

/**
 *  成功响应数据工厂
 * @author HuangJingNa
 * @date 2019年12月20日 下午3:31:15
 *
 */
public class SuccessResultFactory implements Factory<SuccessResult> {
    //懒汉式
    private static SuccessResultFactory successResultFactory;
    static{
        if(successResultFactory == null) {
            successResultFactory = new SuccessResultFactory();
        }
    }
    
    /**
     *  创建具体实例
     */
    public SuccessResult newInstance() {
        return new SuccessResult();
    }

    /**
     *  创建具体实例
     */
    public static SuccessResult getInstance() {
        return new SuccessResultFactory().newInstance();
    }
}

失败响应实例工厂

package cn.kooun.common.factory;

import cn.kooun.common.result.ErrorResult;

/**
 *  错误响应数据工厂
 * @author HuangJingNa
 * @date 2019年12月20日 下午3:31:07
 *
 */
public class ErrorResultFactory implements Factory<ErrorResult> {
    private static ErrorResultFactory errorResultFactory;
    static{
        if(errorResultFactory == null) {
            errorResultFactory = new ErrorResultFactory();
        }
    }
    
    /**
     *  创建具体实例
     */
    public ErrorResult newInstance() {
        return new ErrorResult();
    }

    /**
     *  创建具体实例
     */
    public static ErrorResult getInstance() {
        return new ErrorResultFactory().newInstance();
    }
}

三、使用逆向工程生成pojo类和mapper接口及mapper.xml文件

逆向工程的生成：https://www.jianshu.com/p/c61f0bf1efe0
数据库创建表通常都有的字段封装到一个基础表类中（BaseTable），要实现序列化，便于客户端使用json数据（要求实现序列化以及拥有序列化id）响应

package cn.kooun.pojo.table.base;

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

import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 *  基础表
 *  需要实现序列化，给与一个序列化id
 * @author HuangJingNa
 * @date 2019年12月20日 下午2:30:37
 *
 */
@Setter
@Getter
@ToString
public class BaseTable implements Serializable{
    
    //由于createTime和updateTime每次创建对象的时候需要赋值
    //可以使用构造代码块，避免每次创建对象时都需要set
    {
        this.setCreateTime(new Date());
        this.setUpdateTime(new Date());
    }

    private static final long serialVersionUID = 8533571383425561865L;
    
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY,generator="Mysql")
    private String id;
    
    //@Column(name = "create_time")//告诉通用mapper此变量对应表的字段名
    //这里开启了驼峰命名，可以省略以上步骤
    private Date createTime;
    
    private Date updateTime;
}

pojo类：User.java

package cn.kooun.pojo.table;

import javax.persistence.Table;

import cn.kooun.pojo.table.base.BaseTable;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 *  用户表
 * @author HuangJingNa
 * @date 2019年12月20日 下午2:32:09
 *  1.通过lombok日志包可以通过注解动态生成get&set方法，但是需要注明是哪一张表，方便映射
 *  2.开启驼峰命名，可以在类和数据库中将两个单词通过_连接，改为小驼峰命名，
 *      同时可以省略注解@Column(name = "create_time")
 *  3.主键需要注明，以及自动增长
 */
@Setter
@Getter
@ToString
//@Data  //@Setter+@Getter+@ToString等的集合体
@Table(name = "u_user")
public class User extends BaseTable{
    private static final long serialVersionUID = -2649200110993098831L;
    /**账号名称*/
    private String username;
    /**账号密码*/
    private String password;
    /**账号类型*/
    private Integer type;
    /**账号昵称*/
    private String nickName;

}

mapper接口：UserMapper.java

package cn.kooun.mapper;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import cn.kooun.pojo.table.User;
import tk.mybatis.mapper.common.Mapper;
/**
 *  用户mapper
 *  1.需要继承通过Mapper的泛型类，可以获取其本身拥有的增删改查操作
 * @author HuangJingNa
 * @date 2019年12月20日 下午3:44:22
 *
 */
public interface UserMapper extends Mapper<User>{
    /**
     *   判断该用户是否存在
     * @author HuangJingNa
     * @date 2019年12月20日 下午3:44:02
     *
     * @param username
     * @return
     */
    @Select("SELECT " + 
            "   CASE COUNT(u.id) WHEN 0 THEN 0 ELSE 1 END" + 
            " FROM u_user u" + 
            " WHERE u.username = #{username}")
    boolean isExistUserNameByUsername(@Param("username")String username);
}

mapper.xml文件：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="cn.kooun.mapper.UserMapper">
  
</mapper>

springboot项目注册接口

一、Controller层

二、service层

三、使用逆向工程生成pojo类和mapper接口及mapper.xml文件

推荐阅读更多精彩内容