Spring boot+mybatis 编写接口（例：注册账号）

一、新建项目，连接数据库（略）

项目文件图片如下
图片:

二、在store数据库中创建表t_user

CREATE TABLE t_user (
uid INT AUTO_INCREMENT COMMENT '用户id',
username VARCHAR(20) NOT NULL UNIQUE COMMENT '用户名',
password CHAR(32) NOT NULL COMMENT '密码',
salt CHAR(36) COMMENT '盐值',
phone VARCHAR(20) COMMENT '电话号码',
email VARCHAR(30) COMMENT '电子邮箱',
gender INT COMMENT '性别:0-女，1-男',
avatar VARCHAR(50) COMMENT '头像',
is_delete INT COMMENT '是否删除：0-未删除，1-已删除',
created_user VARCHAR(20) COMMENT '日志-创建人',
created_time DATETIME COMMENT '日志-创建时间',
modified_user VARCHAR(20) COMMENT '日志-最后修改执行人',
modified_time DATETIME COMMENT '日志-最后修改时间',
PRIMARY KEY (uid)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

三、创建用户实体类

1.项目中许多实体类都会有日志相关的四个属性，所以在创建实体类之前，应先创建这些实体类的基
类，将4个日志属性声明在基类中。在com.cy.store.entity包下创建BaseEntity类，作为实体类的基类。

package com.cy.store.entity;
import java.io.Serializable;
import java.util.Date;
/** 实体类的基类 */
public class BaseEntity implements Serializable {
private String createdUser;
private Date createdTime;
private String modifiedUser;
private Date modifiedTime;
// Generate: Getter and Setter、toString()
}

因为这个基类的作用就是用于被其它实体类继承的，所以应声明为抽象类。
2.创建com.cy.store.entity.User用户数据的实体类，继承自BaseEntity类，在类中声明与数据表中对应的属性。

package com.cy.store.entity;
import java.io.Serializable;
import java.util.Objects;
/** 用户数据的实体类 */
public class User extends BaseEntity implements Serializable {
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;
// Generate: Getter and Setter、Generate hashCode() and equals()、toString()
}

四、用户注册持久层

(1)接口与抽象方法

1.创建com.cy.store.mapper.UserMapper接口，并在接口中添加抽象方法

package com.cy.mapper;
import com.cy.store.entity.User;
/** 处理用户数据操作的持久层接口 */
public interface UserMapper {
/**
* 插入用户数据
* @param user 用户数据
* @return 受影响的行数
*/
Integer insert(User user);
/**
* 根据用户名查询用户数据
* @param username 用户名
* @return 匹配的用户数据，如果没有匹配的数据，则返回null
*/
User findByUsername(String username);
}

在这里相当于定义函数，函数内容在后面实现

2.由于这是项目中第一次创建持久层接口，还应在StoreApplication启动类之前添加
@MapperScan(“com.cy.store.mapper”)注解，以配置接口文件的位置。
MyBatis与Spring整合后需要实现实体和数据表的映射关系。实现实体和数据表的映射关系可以在
Mapper接口上添加@Mapper注解。但建议以后直接在SpringBoot启动类中加
@MapperScan(“mapper包”) 注解，（mapper包为所在具体路径 com.cy.store.mapper），这样会比较方便，不需要对每个Mapper都添加@Mapper注
解。
（可以在入口一次性添加mapper注解，也可以每个持久层接口添加mapper注解）

@SpringBootApplication
@MapperScan("com.cy.store.mapper")
public class ApiApplication {
    public static void main(String[] args) {
        SpringApplication.run(ApiApplication.class, args);
        System.out.println("Api Start!!!!");
    }
}

(2)配置Sql映射

1.在src/main/resources下创建mapper文件夹，并在该文件夹下创建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.cy.store.mapper">
<resultMap id="UserEntityMap" type="com.cy.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>
<!-- 插入用户数据：Integer insert(User user) -->
<insert id="insert" useGeneratedKeys="true" keyProperty="uid">
INSERT INTO
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>
<!-- 根据用户名查询用户数据：User findByUsername(String username) -->
<select id="findByUsername" resultMap="UserEntityMap">
SELECT
*
FROM
t_user
WHERE
username = #{username}
</select>
</mapper>

resultMap 标签中 的内容 将表中_的写法 变成 大写开头的写法
在select中 通过 resultEntityMap与resultMap的id对应
2.由于这是项目中第一次使用SQL映射，所以需要在application.properties中添加mybatis.mapperlocations属性的配置，以指定XML文件的位置。

mybatis.mapper-locations=classpath:mapper/*.xml

五、用户注册 业务层

1.为了便于统一管理自定义异常，应先创建com.cy.store.service.ex.ServiceException自定义异常的基
类异常，继承自RuntimeException类，并从父类生成子类的五个构造方法。

package com.cy.store.service.ex;
/** 业务异常的基类 */
public class ServiceException extends RuntimeException {
// Override Methods...
}

2.当用户进行注册时，可能会因为用户名被占用而导致无法正常注册，此时需要抛出用户名被占用的异
常，因此可以设计一个用户名重复的com.cy.store.service.ex.UsernameDuplicateException异常类，
继承自ServiceException类，并从父类生成子类的五个构造方法。

package com.cy.store.service.ex;
/** 用户名重复的异常 */
public class UsernameDuplicateException extends ServiceException {
// Override Methods...
}

3.在用户进行注册时，会执行数据库的INSERT操作，该操作也是有可能失败的。则创建
cn.tedu.store.service.ex.InsertException`异常类，继承自ServiceException类，并从父类生成子类的5
个构造方法。

package com.cy.store.service.ex;
/** 插入数据的异常 */
public class InsertException extends ServiceException {
// Override Methods...
}

(1)接口与抽象方法

1.先创建com.cy.store.service.IUserService业务层接口，并在接口中添加抽象方法

package com.cy.store.service;
import com.cy.store.entity.User;
/** 处理用户数据的业务层接口 */
public interface IUserService {
/**
* 用户注册
* @param user 用户数据
*/
void reg(User user);
}

reg 是用户注册函数 在此命名 后面重写
2.创建com.cy.store.service.impl.UserServiceImpl业务层实现类，并实现IUserService接口。在类之前
添加@Service注解，并在类中添加持久层UserMapper对象。

package com.cy.store.service.impl;
import com.cy.store.entity.User;
import com.cy.store.mapper.UserMapper;
import com.cy.store.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/** 处理用户数据的业务层实现类 */
@Service
public class UserServiceImpl implements IUserService {
@Autowired
private UserMapper userMapper;
@Override
public void reg(User user) {
// TODO
}
}

3.UserServiceImpl类需要重写IUserService接口中的抽象方法

@Service
public class UserServiceImpl implements IUserService {
@Autowired
private UserMapper userMapper;
@Override
public void reg(User user) {
// 根据参数user对象获取注册的用户名
String username = user.getUsername();
// 调用持久层的User findByUsername(String username)方法，根据用户名查询用户数据
User result = userMapper.findByUsername(username);
// 判断查询结果是否不为null
if (result != null) {
// 是：表示用户名已被占用，则抛出UsernameDuplicateException异常
throw new UsernameDuplicateException("尝试注册的用户名[" + username +
"]已经被占用");
}
// 创建当前时间对象
Date now = new Date();
// 补全数据：加密后的密码
String salt = UUID.randomUUID().toString().toUpperCase();
String md5Password = getMd5Password(user.getPassword(), salt);
user.setPassword(md5Password);
// 补全数据：盐值
user.setSalt(salt);
// 补全数据：isDelete(0)
user.setIsDelete(0);
// 补全数据：4项日志属性
user.setCreatedUser(username);
user.setCreatedTime(now);
user.setModifiedUser(username);
user.setModifiedTime(now);
// 表示用户名没有被占用，则允许注册
// 调用持久层Integer insert(User user)方法，执行注册并获取返回值(受影响的行数)
Integer rows = userMapper.insert(user);
// 判断受影响的行数是否不为1
if (rows != 1) {
// 是：插入数据时出现某种错误，则抛出InsertException异常
throw new InsertException("添加用户数据出现未知错误，请联系系统管理员");
}
}
/**
* 执行密码加密
* @param password 原始密码
* @param salt 盐值
* @return 加密后的密文
*/
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;
}
}

六、用户-注册-控制器

1.创建com.cy.store.util.JsonResult响应结果类型。

package com.cy.store.util;
import java.io.Serializable;
/**
* 响应结果类
* @param <E> 响应数据的类型 代表所以数据类型
*/
public class JsonResult<E> implements Serializable {
/** 状态码 */
private Integer state;
/** 状态描述信息 */
private String message;
/** 数据 */
private E data;
public JsonResult() {
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;
}
// Generate: Getter and Sette
}

相当于定义一个框架 最后接口返回什么值 都是安装这个框架来
2.创建com.cy.store.controller.UserController控制器类，在类的声明之前添加@RestController和
@RequestMapping(“users”)注解，在类中添加IUserService业务对象并使用@Autowired注解修饰。

package com.cy.store.controller;
import com.cy.store.service.IUserService;
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 {
@Autowired
private IUserService userService;
}
//然后在类中添加处理请求的用户注册方法。
@RequestMapping("reg")
public JsonResult<Void> reg(User user) {
// 创建返回值
JsonResult<Void> result = new JsonResult<Void>();
try {
// 调用业务对象执行注册
userService.reg(user);
// 响应成功
result.setState(200);
} catch (UsernameDuplicateException e) {
// 用户名被占用
result.setState(4000);
result.setMessage("用户名已经被占用");
} catch (InsertException e) {
// 插入数据异常
result.setState(5000);
result.setMessage("注册失败，请联系系统管理员");
}
return result;
}

七、结果

1…完成后启动项目，打开浏览器访问http://localhost:8080/users/reg?username=controller&passwor
d=123456请求进行测试。
2.

{
state: 200,
message: null,
data: null
}