基于SpringBoot编写增删查改一套接口
目录
-
- SpringBoot介绍
- 目的
- 工具准备
- 一、配置Gradle
- 二、新建SpringBoot项目
- 实现基础
-
-
- 建立功能模块实体类Entity
- 建立Dao数据库操作持久层
- 建立对应Mapper查询文件
- 建立对应Service事务控制服务层及其文件
- 建立Controller控制层服务
-
- 实现需求
-
-
- 新增用户
- 删除用户
- 查询用户
- 修改用户
- 列表分页查询用户
-
- 项目Demo的GITHUB地址
SpringBoot介绍
SpringBoot 是由 Pivotal 团队提供的全新框架，是在2003那一年兴起的一个轻量级的Java 开发框架。由于Spring 其配置文件过于繁琐，我们对Spring平台和第三方库有一个独到的见解，这样我们就可以从最少的麻烦开始了。大多数Spring引导应用程序只需要很少的Spring配置，其可以说是整合了很多框架。
好了，不啰嗦了，SpringBoot理论原理网上一堆资源，本篇博文适合对SpringBoot有一定了解的朋友，接下来就开始实践吧。
目的
通过此篇博文，可以实现在IDEA中搭建SpringBoot对前端传来的请求进行处理:
1.对前端传来的新增用户请求进行处理。
2.对前端传来的删除用户请求进行处理。
3.对前端传来的查找用户详情请求进行处理。
4.对前端传来的修改用户请求进行处理。
5.对前端传来的列表分页查询用户请求进行处理。
工具准备
本教程需要用到的软件:
1.IDEA
不同的版本可能不支持比较高版本的Gradle和Manven,因此下载的版本也需要对应不同的插件版本。
2.PostMan
模拟POST表单提交测试用
3.Navicat
数据库管理工具。
一、配置Gradle
点击进入Gradle下载
因为我的IDEA版本比较低，是2018.2，在这里，我下载的Gradle版本是5.3的。
下载好后，自己新建一个目录，然后对其解压，解压后如下：
返回桌面，右键我的电脑---->属性
点击高级系统设置
点击环境变量
配置GRADLE_HOME
配置本地仓库GRADLE_USER_HOME
配置Gradle的bin目录
配置好后，打开Cmd，查看gradle版本
二、新建SpringBoot项目
打开IDEA，点击Create New Project.
左边框架选择spring Initializr,右上角选择自己的sdk，然后点击Next。
项目的包名的根目录=GroupId+artifactId。
随便填写项目名称Goup、模块名Artifact，也可以默认，然后选择Type为Gradle Project。
Language默认选Java。
Packaging即包的类型是jar或者war，以后打包项目的类型就会变成这个选择的。
JavaVersion选择8默认。
version填写项目版本号、Name填写项目名称、Description填写项目描述、Package会根据你上面填写的项目名称进行动态变化。
在这里项目名我填写的是老人养老系统，即 elderlycaresystem ，其他默认。
点击Next
接下来从其SpringBoot中整合的框架中选择需要哪些服务，我们选择三个服务。
1.SpringWeb 服务
使之支持Https、Post、GET、XmlHttpRequest、Patch等前端发来的请求的服务。
2.Mysql数据库服务
在这里插入图片描述添加Driver驱动，用于java跟数据库之间进行连接，相当于JDBC数据库连接池的驱动。
3.Mybatis服务
基于原生JDBC封装好的框架，让我们更加方便跟数据库打交道，不需要写那么多繁琐的代码。
想要更多了解此框架请前往:Mybatis基础教程
点击Next，输入Projejct Name ，输入后点击Finish。
配置Gradle的弹出选择框，点击Ok。
由于一开始下载和配置的时间比较长，我们这里将gradle仓库下载源更换为国内的。打开build.gradle文件。
将下面这行代码复制到mavenCentral()的上面。
maven{
url 'https://maven.aliyun.com/repository/public'}
在右下角会弹出对话框，点击导入改变Gradle projects。
接下来，我们去配置数据库文件，选择application.properties
鼠标右键，Show in explorer。更改后缀名为yml
复制下面这段代码进去，用于配置mybatis的mapper资源文件路径和数据库相关。
下面中，你需要替换数据库名称、账号密码为自己的。
spring:
datasource:
url: jdbc:mysql://localhost:3306/数据库名称?serverTimezone=UTC&serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=UTF-8
username: 账号
password: 密码
driver-class-name: com.mysql.cj.jdbc.Driver
mybatis:
mapper-locations: classpath*:mapper/*.xml
如图:
在Resource资源文件夹下建立mapper文件夹，用来存放相关Dao数据库操作的映射的Mapper文件。
等待构建完成，第一次可能会时间稍微久点。提示sync finished 7 m 33 s 218 ms 表示已经构建成功。
构建好后，点击右上角的启动按钮，启动SpringBoot项目
如果运行后结果如下，那么恭喜你，空框架搭建好了，项目成功启动。项目运行端口是8080，如果想改启动端口，可以去application.yml配置一下，这里就使用默认端口。
实现基础
建立功能模块实体类Entity
基于我们需要达到的服务，想要与数据库中的表进行交互的话，在java中，我们需要建立与数据库中的表对应的实体类(entity)。实体类一般不需要注入，对于建立的实体类要求有以下两个:
1.属性get set方法必须存在
2.顺序要跟表的字段一一对应。
数据库中用户表结构如下:
创建此表的Sql语句:
CREATE TABLE `user` (
`user_code` varchar(64) NOT NULL COMMENT '用户编号',
`user_acct` varchar(30) NOT NULL COMMENT '用户账号',
`user_name` varchar(30) NOT NULL COMMENT '用户名称',
`user_password` varchar(30) NOT NULL COMMENT '用户密码',
`user_email` varchar(320) DEFAULT NULL COMMENT '用户邮箱',
`user_phone` varchar(11) DEFAULT NULL COMMENT '用户手机',
`user_address` varchar(100) DEFAULT NULL COMMENT '用户住址',
`user_id_card` varchar(18) DEFAULT NULL COMMENT '身份证',
`user_role` int(1) NOT NULL COMMENT '用户角色',
`user_create_time` varchar(40) NOT NULL COMMENT '注册时间',
`user_create_ip` varchar(20) DEFAULT NULL COMMENT '注册ip',
`user_update_time` varchar(40) DEFAULT NULL COMMENT '更新时间',
`is_delete` int(1) NOT NULL COMMENT '是否删除',
PRIMARY KEY (`user_code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
在项目包下建立名称为user的模块文件夹和dao模块文件夹，注意这里要跟启动程序DemoApplication在同级目录，不然后面系统会找不到服务入口。
在user文件夹下新建实体文件夹entity，在实体文件夹下建立用户实体类UserEntity，如下:
UserEntity的代码如下:
package com.elderlycaresystem.demo.user.entity;
/**
* @prec:用户实体类
* @author:CharLinHeng
* @time:2020年3月28日20:09:56
*/
public class UserEntity {
/**
* 用户编号
*/
private String userCode;
/**
* 用户账号
*/
private String userAcct;
/**
* 用户名称
*/
private String userName;
/**
* 用户密码
*/
private String userPass;
/**
* 用户邮箱
*/
private String userEmail;
/**
* 用户手机号
*/
private String userPhone;
/**
* 用户地址
*/
private String userAddress;
/**
* 用户身份证
*/
private String userIdCard;
/**
* 用户角色
*/
private int userRole;
/**
* 用户注册时间
*/
private String userCreateTime;
/**
* 用户注册ip地址
*/
private String userCreateIp;
/**
* 用户更新时间
*/
private String userUpdateTime;
/**
* 用户是否已经删除
*/
private int userIsDelete;
public String getUserCode() {
return userCode;
}
public void setUserCode(String userCode) {
this.userCode = userCode;
}
public String getUserAcct() {
return userAcct;
}
public void setUserAcct(String userAcct) {
this.userAcct = userAcct;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserPass() {
return userPass;
}
public void setUserPass(String userPass) {
this.userPass = userPass;
}
public String getUserEmail() {
return userEmail;
}
public void setUserEmail(String userEmail) {
this.userEmail = userEmail;
}
public String getUserPhone() {
return userPhone;
}
public void setUserPhone(String userPhone) {
this.userPhone = userPhone;
}
public String getUserAddress() {
return userAddress;
}
public void setUserAddress(String userAddress) {
this.userAddress = userAddress;
}
public String getUserIdCard() {
return userIdCard;
}
public void setUserIdCard(String userIdCard) {
this.userIdCard = userIdCard;
}
public int getUserRole() {
return userRole;
}
public void setUserRole(int userRole) {
this.userRole = userRole;
}
public String getUserCreateTime() {
return userCreateTime;
}
public void setUserCreateTime(String userCreateTime) {
this.userCreateTime = userCreateTime;
}
public String getUserCreateIp() {
return userCreateIp;
}
public void setUserCreateIp(String userCreateIp) {
this.userCreateIp = userCreateIp;
}
public String getUserUpdateTime() {
return userUpdateTime;
}
public void setUserUpdateTime(String userUpdateTime) {
this.userUpdateTime = userUpdateTime;
}
public int getUserIsDelete() {
return userIsDelete;
}
public void setUserIsDelete(int userIsDelete) {
this.userIsDelete = userIsDelete;
}
}
建立Dao数据库操作持久层
Dao层的描述: 此层是主要做数据持久层的工作，它负责和数据库进行关联的一些方法都封装在此层，Dao层的设计首先是需要设计模块对应Dao的接口，接着就可在Service层中调用此接口来进行数据业务的处理，因此不需要关心Dao接口的具体实现类是哪个类，这样一来显得结构非常清晰。
在Dao文件夹下建立对应Dao文件,命名为UserDao.java，注意，这是个接口，需要把文件类型切换成接口:
代码如下:
package com.elderlycaresystem.demo.user.dao;
import org.apache.ibatis.annotations.Mapper;
/**
* @Description UserDao层服务
* @author CharLinHengu
* @date 2020年3月28日21:09:42
*/
@Mapper
public interface UserDao {
}
这里的@Mapper注解需要说明一下：
为了把Mapper的Dao操作交給SpringBoot管理，在这里添加Mapper注解是申明注解标记这个接口作为一个映射接口。
@Mapper注解意味着给Mapper接口自动的去根据一个添加@Mapper注解的接口生成一个实现类，添加了@Mapper注解之后这个接口在编译时会生成相应的实现类。
建立对应Mapper查询文件
为了实现POJO与SQL之间的映射关系。即让我们的实体类跟数据库中的表关联起来，做映射关系。我们知道，MyBatis是基于半自动的ORM框架，即SQL语句和对应的实体映射需要开发者自定义。接下来，我们需要去建立Mybatis中的mapper文件，需要在Mapper.xml中配置SQL语句自定义。
在mapper文件夹下建立UserDaoMapper.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.elderlycaresystem.demo.user.dao.UserDao">
</mapper>
建立对应Service事务控制服务层及其文件
上面在建立了能跟数据库打交道的Dao层和相关Mapper文件后，我们怎么用它从数据库获取数据？我们如何接收经过Dao从数据库中获取的数据？那么需要在Service层中建立Dao实例并且调用其操作方法。该service事务控制层用于与Dao层交互来操作User表。通过Dao方法接收其返回的数据。
springBoot使用事务控制相对Spring来说比较简单，在对应的启动类同级目录在其功能模块的子目录下添加service文件夹，在其service文件夹下添加文件。
在项目包目录下建立service文件夹，在service文件夹下建立UserService.java。
在UserService.javaz中编写代码如下：
package com.elderlycaresystem.demo.user.service;
import org.springframework.stereotype.Service;
/**
* @Deprecated 用于用户表相关事务服务
* @author CharLinHeng
* @date 2020年3月28日22:02:45
*/
@Service
public class UserService {
}
其中，@Service注解表示用于标注业务层组件，@Service对应的是业务层Bean，加上此注解之后，@Service注解是告诉Spring，当Spring要创建事务控制层实例时，bean的名字必须叫做此类名，这样当Action需要使用此模块的事务控制的实例时,就可以由Spring创建好的此bean对象，然后注入给Action：在Action只需要声明一个名字叫当前类的变量来接收由Spring注入的相关实例即可。
建立Controller控制层服务
数据库交互有了，处理数据请求渠道也有了，那系统怎么知道我们要使用哪个服务呢？当前台传来POST请求时，我们怎么根据处理请求路径进行处理并且相应前台？Controller层为我们提供了相关控制，称为控制层，负责接收和返回请求这一交互逻辑，用于处理Http请求，Controller即是MVC的C层，所以主要在于接口的创建功能。
在user模块下建立controller文件夹，在其文件夹下建立userController.java文件
代码如下:
package com.elderlycaresystem.demo.user.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/user")
public class UserController {
}
对于其中的注解，说明一下:
- @Controller用于标注控制层组件（如struts中的action)，对应表现层的Bean，这里可以不用写，主要是在项目中已经自动注入。
- @RestController Spring4之后新加的注解，原来返回json需要@ResponseBody配合@Controller
- @RequestMapping 配置url映射
- @PostMapping
实现需求
新增用户
现在我们来实现使用接口来新增用户功能。当前台发送POST请求传来新增用户所需要的参数的时候，我们需要接收相关参数并且对表进行操作，然后将结果返回给前台。假设前台已经对数据准确性进行验证，我们只需要负责存储即可。当然，在存储用户之前，我们还需要判断用户账号是否已经存在，手机是否已经注册等。
在UserDao.java中编写判断用户名是否存在的抽象函数countAcct(…):
package com.elderlycaresystem.demo.user.dao;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;
/**
* @Description UserDao层服务
* @author CharLinHengu
* @date 2020年3月28日21:09:42
*/
@Mapper
public interface UserDao {
/**
* 判断用户账号是存在
* 当返回的值大于0时表示此用户账号已经存在。
* @param user
* @return int
*/
int countAcct(UserEntity user);
}
在UserDaoMapper.xml中编写判断用户名是否存在的sql查询语句:
<?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.elderlycaresystem.demo.user.dao.UserDao">
<select id="countAcct" parameterType="com.elderlycaresystem.demo.user.entity.UserEntity" resultType="int">
select
count(*)
from
user
where
user_acct = #{userAcct}
</select>
</mapper>
这里要注意的是:
- id要跟Dao中的方法名称要一样
- parameterType是对应的用户实体类[输入参数]
- resultType 是返回类型，这里为count整数
查询用户账号名是否存在的数据请求已经做好，接下来是新增用户请求。
在UserDao中编写新增用户函数:
package com.elderlycaresystem.demo.user.dao;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;
/**
* @Description UserDao层服务
* @author CharLinHengu
* @date 2020年3月28日21:09:42
*/
@Mapper
public interface UserDao {
/**
* 判断用户账号是存在
* 当返回的值大于0时表示此用户账号已经存在。
* @param user
* @return int
*/
int countAcct(UserEntity user);
/**
* 新增用户
* @param userEntity
* @return
* 2020年3月28日23:24:33
*/
int addUser(UserEntity userEntity);
}
接下来，在UserDaoMapper.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.elderlycaresystem.demo.user.dao.UserDao">
<!--计算用户账号名称存在数量-->
<select id="countAcct" parameterType="com.elderlycaresystem.demo.user.entity.UserEntity" resultType="int">
select
count(*)
from
user
where
user_acct = #{userAcct}
</select>
<!--用户新增-->
<insert id="addUser" parameterType="com.elderlycaresystem.demo.user.entity.UserEntity">
INSERT INTO `user`
(
`user_code`,
`user_acct`,
`user_name`,
`user_password`,
`user_email`,
`user_phone`,
`user_address`,
`user_id_card`,
`user_role`,
`user_create_time`,
`user_create_ip`,
`user_update_time`,
`is_delete`
)
VALUES
(
#{userCode},
#{userAcct},
#{userName},
#{userPass},
#{userEmail},
#{userPhone},
#{userAddress},
#{userIdCard},
#{userRole},
now(),
#{userCreateIp},
#{userUpdateTime},
0
)
</insert>
</mapper>
接下来去UserService.java中处理业务逻辑。
为了规范输出结果，我们需要自己实现两个工具类，这个工具类的作用是按照自己定义的规范格式输出结果给前端。在项目包目录下建立util,然后在util下建立
ResponceData.java,ResponceDataState.java。
ResponceData.java
package com.elderlycaresystem.demo.util;
import java.io.Serializable;
/**
* 系统统一返回格式
* 创建日期：2020年3月28日
* @author CharLinHeng
*/
public class ResponceData<T> implements Serializable {
/**
* 返回编码
*/
private int code;
/**
* 消息描述
*/
private String msg;
/**
* 返回内容
*/
private T data;
public int getCode() {
return code;
}
public String getMsg() {
return msg;
}
public T getData() {
return data;
}
public ResponceData(int code, String msg, T data) {
this.code = code;
this.msg = msg;
this.data = data;
}
public static <T> AppResponseBuilder builder() {
return new AppResponseBuilder<T>();
}
/**
*
* @return
*/
public static ResponceData success() {
return builder().code(ResponceDataState.SUCCESS).build();
}
public static class AppResponseBuilder<T> {
private int code;
private String msg;
private T data;
public ResponceData build() {
ResponceData appResponse = new ResponceData<>(this.code, this.msg, this.data);
return appResponse;
}
public AppResponseBuilder code(ResponceDataState status) {
this.code = status.code;
return this;
}
public AppResponseBuilder msg(String msg) {
this.msg = msg;
return this;
}
public AppResponseBuilder data(T data) {
this.data = data;
return this;
}
}
}
ResponceData是对结果进行标准输出的格式，输出格式如下:
{
"code": 0,
"msg": "success",
"data": {
"user_code": "d2d1a2s3d1a2sd12a31dd",
"user_name": "李四",
"user_account": "apple",
"user_pass": "123456",
"user_id_card": "412345646586454545",
"user_sex": 1,
"user_role": 3,
"user_tel": "7542139",
"user_phone": "17329504072",
"user_integral": 10000,
"user_email": "[email protected]",
"is_delete": 0,
"create_user": "admin",
"create_time": "2020-3-24 17:39:25",
"update_user": "",
"update_time": "",
"version": 0
}
}
其中:
1.code是对应状态码，也就是下面的ResponceDataState的状态的枚举成员的值。
2.msg是消息提示，比如新增用户成功就提示新增成功，
3.data指的是泛型数据类型T装载的返回给前台的数据。一般来说，这里装的数据是对应功能模块的实体类。
ResponceDataState.java
package com.elderlycaresystem.demo.util;
/**
* 状态
* 时间 2020年3月28日
* author :CharLinHeng
*/
public enum ResponceDataState {
/**
* 操作成功
*/
SUCCESS(0),
/**
* 服务繁忙
*/
SERVERS_ARE_TOO_BUSY(6),
/**
* 未查询到数据
*/
NOT_FOUND(5),
/**
* 操作失败
*/
ERROR(-1),
/**
* 未登录或token非法
*/
INVALID_TOKEN(2001),
/**
*
*/
NO_PERMISSION(2003),
/**
* 未知异常
*/
UNKNOWN_EXCEPTION(3000),
/**
* 调用端异常
*/
CLIENT_EXCEPTION(4000),
/**
* 请求参数非法
*/
PARAM_EXCEPTION(4010),
/**
* 服务端异常
*/
SERVER_EXCEPTION(5000),
/**
* 业务异常
*/
BIZ_ERROR(10000),
/**
* 验证码错误
*/
INVALID_IMAGE(6000);
public int code;
ResponceDataState(int code) {
this.code = code;
}
public int getCode() {
return code;
}
}
这是返回给前台状态码枚举工具类。
在新增用户中，我需要给随机生成用户编号，所以编写RandomCode工具类来随机生成用户编号。
RandomCode.java代码如下:
package com.elderlycaresystem.demo.util;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 随机生成用户编号
* CharLinHeng
* 2020年3月28日23:44:17
*/
public class RandomCode {
public static String radmonkey(){
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
StringBuffer sbf=new StringBuffer();
sbf.append(sdf.format(new Date()));
for (int i = 0; i <18; i++) {
int num=(int)(Math.random()*10);
sbf.append(num);
}
return sbf.toString();
}
}
上面的工具类每次调用后会生成32位编号，由时间戳14位+随机18位数字进行组成。
目录文件一览如下:
在UserService.java中进行调用新增用户方法:
package com.elderlycaresystem.demo.user.service;
import com.elderlycaresystem.demo.user.dao.UserDao;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import com.elderlycaresystem.demo.util.RandomCode;
import com.elderlycaresystem.demo.util.ResponceData;
import com.elderlycaresystem.demo.util.ResponceDataState;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @Deprecated 用于用户表相关事务服务
* @author CharLinHeng
* @date 2020年3月28日22:02:45
*/
@Service
public class UserService {
private ResponceData responceData;
@Resource
private UserDao userDao;
/**
* 新增用户服务控制
* @param userEntity
* @return
*/
public ResponceData addUser(UserEntity userEntity){
//先判断用户账号是否存在
int userAcctNum = userDao.countAcct(userEntity);
if(userAcctNum>0){
//说明用户账号已经存在
responceData = new ResponceData(ResponceDataState.values()[9].getCode(),"用户账号已经存在",null);
return responceData;
}
//给用户创建用户编号
userEntity.setUserCode(RandomCode.radmonkey());
//没问题后，新增
int result = userDao.addUser(userEntity);
if(result>0){
//说明新增成功
responceData = new ResponceData(ResponceDataState.values()[0].getCode(),"新增用户成功!",null);
}
else{
// 失败
responceData = new ResponceData(ResponceDataState.values()[3].getCode(),"新增用户失败!",null);
}
return responceData;
}
}
然后再UserController中调用服务。
package com.elderlycaresystem.demo.user.controller;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import com.elderlycaresystem.demo.user.service.UserService;
import com.elderlycaresystem.demo.util.ResponceData;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
@RequestMapping("/user")
/**
* 用户模块控制类
* CharLinHeng
* 2020年3月28日23:53:19
*/
public class UserController {
@Resource
private UserService userService;
private ResponceData responceData;
@ResponseBody
@PostMapping("addUser")
/**
* 新增用户调用地址
* 2020年3月28日23:53:46
*/
public ResponceData addUser(UserEntity userEntity){
try{
responceData = userService.addUser(userEntity);
return responceData;
}catch (Exception e){
throw e;
}
}
}
现在就让我们用PostMan来测试一下:
发现新增用户成功!
我们去数据库查一下看看新增的数据是否已经插入
发现已经插入
这时候我们再来点击申请POST新增用户：
提示说用户账号已存在！新增失败
我们去数据库查看是否已经插入:
发现没有插入.
密码加密工具可以去网上搜搜 BCryptPasswordEncoder 的使用，这里就不演示。
持续更新.
------5-24------
删除用户
现在我们来实现使用接口来删除用户功能。当前台发送POST请求传来删除指定的用户的时候，我们需要接收相关参数并且对表进行操作，然后将结果返回给前台。假设前台已经对数据准确性进行验证，我们只需要负责操作即可。当然，这里的删除可以接收请求删除n个用户(n >=0)，需要删除的编号需要用逗号隔开来，删除之后返回具体对应数量和信息给前台。注意，这里的删除，并不是真的delete，而是把用户删除标志字段is_delete设置为1,1表示删除。
在接口中定义删除抽象方法deleteUser:
package com.elderlycaresystem.demo.user.dao;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @Description UserDao层服务
* @author CharLinHengu
* @date 2020年3月28日21:09:42
*/
@Mapper
public interface UserDao {
/**
* 判断用户账号是存在
* 当返回的值大于0时表示此用户账号已经存在。
* @param user
* @return int
*/
int countAcct(UserEntity user);
/**
*查看是否存在
*/
int judgeHasExist(@Param("userAcct")String acct);
/**
* 新增用户
* @param userEntity
* @return
* 2020年3月28日23:24:33
*/
int addUser(UserEntity userEntity);
/**
* 删除用户
* @param deleteUserCodeList
* @return
*/
int deleteUser(@Param("deleteCodeList")List<String>deleteUserCodeList);
其中 @Param(“deleteCodeList”) 注解表示通过此注解，给参数进行命名，参数命名后就能根据名字得到参数值，这里得到List集合。deleteUserCodeList是待删除的用户编号集合列表。
接下来，在对应的mapper文件中编写相关sql语句。如下:
<update id="deleteUser" parameterType="com.elderlycaresystem.demo.user.entity.UserEntity">
update
user
set
is_delete = 1
where
is_delete = 0
and
user_code in
<foreach collection="deleteCodeList" index="index" item="item" open="(" separator="," close=")">
#{item}
foreach>
update>
这里说一下，这里foreach是Mybatis循环语法， foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。
将Dao接口中的参数数组进行遍历，collection传入的就是接口中数组参数列表，item是每个数组的每个元素，index通过指定当前元素的一个名字，用于表示在迭代过程中，每次迭代到的位置，open表示该语句以什么开始，close表示啥结束，separator表示元素与元素之间用什么来分割。
接下来，在UserService中对controller传过来的String类型的字符串进行处理，并且将处理后的List传给上面咱定义的Dao的deleteUser方法中:
package com.elderlycaresystem.demo.user.service;
import com.elderlycaresystem.demo.user.dao.UserDao;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import com.elderlycaresystem.demo.util.RandomCode;
import com.elderlycaresystem.demo.util.ResponceData;
import com.elderlycaresystem.demo.util.ResponceDataState;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
/**
* @Deprecated 用于用户表相关事务服务
* @author CharLinHeng
* @date 2020年3月28日22:02:45
*/
@Service
public class UserService {
private ResponceData responceData;
@Resource
private UserDao userDao;
/**
* 删除用户服务控制
* @param httpServletRequest
* @return
*/
public ResponceData deleteUser(HttpServletRequest httpServletRequest){
//判断是否为空
if(null == httpServletRequest.getParameter("userCodeList") || httpServletRequest.getParameter("userCodeList")==""){
return new ResponceData(ResponceDataState.values()[3].getCode(),"参数不存在或者不能为空!",null);
}
//将字符串转成List
List<String>deleteUserList = Arrays.asList(httpServletRequest.getParameter("userCodeList").split(","));
//调用删除方法，进行删除
int result = userDao.deleteUser(deleteUserList);
return new ResponceData(ResponceDataState.values()[0].getCode(),"删除成功!",result);
}
}
在controller中接收到的信息传至Servcie:
package com.elderlycaresystem.demo.user.controller;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import com.elderlycaresystem.demo.user.service.UserService;
import com.elderlycaresystem.demo.util.PhoneCode;
import com.elderlycaresystem.demo.util.RandomCode;
import com.elderlycaresystem.demo.util.ResponceData;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@RestController
@RequestMapping("/user")
@CrossOrigin
/**
* 用户模块控制类
* CharLinHeng
* 2020年3月28日23:53:19
*/
public class UserController {
private ResponceData responceData;
@Resource
private UserService userService;
@ResponseBody
/**
* 删除用户controller
*/
@PostMapping("deleteUser")
public ResponceData deleteUser(HttpServletRequest httpServletRequest){
try{
return userService.deleteUser(httpServletRequest);
}catch (Exception e){
throw e;
}
}
}
运行项目，接下来用postman测试一下:
准备三条数据，开始都是为0，就是删除标志位为。
首先，我们啥参数都加，点击发送，结果如下:
提示，需要参数。
接下来，输入不存在的编号，结果如下:
成功为0个。
输入正确的:
提示删除3条成功，接下来往数据库里瞅瞅:
发现删除标志已经标志为1.
查询用户
一样的，先在dao中声明查询数据库的方法queryDetails，如下:
package com.elderlycaresystem.demo.user.dao;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @Description UserDao层服务
* @author CharLinHengu
* @date 2020年3月28日21:09:42
*/
@Mapper
public interface UserDao {
/**
* 判断用户账号是存在
* 当返回的值大于0时表示此用户账号已经存在。
* @param user
* @return int
*/
int countAcct(UserEntity user);
/**
*查看是否存在
*/
int judgeHasExist(@Param("userAcct")String acct);
/**
* 新增用户
* @param userEntity
* @return
* 2020年3月28日23:24:33
*/
int addUser(UserEntity userEntity);
/**
* 删除用户
* @param deleteUserCodeList
* @return
*/
int deleteUser(@Param("deleteCodeList")List<String>deleteUserCodeList);
/**
* 用户详情
*/
UserEntity queryDetails(@Param("userCode")String userCode);
}
在mapper中建立对应的查询sql:
<select id="queryDetails" parameterType="com.elderlycaresystem.demo.user.entity.UserEntity" resultType="com.elderlycaresystem.demo.user.entity.UserEntity">
SELECT
`user_code` userCode,
`user_acct` userAcct,
`user_name` userName,
`user_password` userPass,
`user_email` userEmail,
`user_phone` userPhone,
`user_address` userAddress,
`user_id_card` userIdCard,
`user_role` userRole,
`user_create_time` userCreateTime,
`user_create_ip` userCreateIp,
`user_update_time` userUpdateTime,
`is_delete` userIsDelete
FROM
`user`
WHERE
user_code = #{
userCode}
</select>
在service中将接受到的参数处理下，然后传给dao的queryUser方法:
/**
* 查询值顶用户信息
* @param httpServletRequest
* @return
*/
public ResponceData queryDetails(HttpServletRequest httpServletRequest){
if(null == httpServletRequest.getParameter("userCode") || httpServletRequest.getParameter("userCode")==""){
return new ResponceData(ResponceDataState.values()[3].getCode(),"参数不存在或者不能为空!",null);
}
UserEntity result = userDao.queryDetails(httpServletRequest.getParameter("userCode"));
return new ResponceData(ResponceDataState.values()[0].getCode(),"查询成功!",result);
}
在controller中接受处理请求:
/**
* 查询用户详情
* @param httpServletRequest
* @return
*/
@PostMapping("userDetail")
public ResponceData userDetail(HttpServletRequest httpServletRequest){
try{
responceData = userService.queryDetails(httpServletRequest);
return responceData;
}catch (Exception e){
throw e;
}
}
测试:
查询成功.
修改用户
一样，在dao中声明更新方法updateUserData:
package com.elderlycaresystem.demo.user.dao;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @Description UserDao层服务
* @author CharLinHengu
* @date 2020年3月28日21:09:42
*/
@Mapper
public interface UserDao {
/**
* 判断用户账号是存在
* 当返回的值大于0时表示此用户账号已经存在。
* @param user
* @return int
*/
int countAcct(UserEntity user);
/**
*查看是否存在
*/
int judgeHasExist(@Param("userAcct")String acct);
/**
* 新增用户
* @param userEntity
* @return
* 2020年3月28日23:24:33
*/
int addUser(UserEntity userEntity);
/**
* 删除用户
* @param deleteUserCodeList
* @return
*/
int deleteUser(@Param("deleteCodeList")List<String>deleteUserCodeList);
/**
* 用户详情
*/
UserEntity queryDetail(@Param("userCode")String userCode);
/**
* 更新用户信息
* @param userEntity
* @return
*/
int updateUserData(UserEntity userEntity);
}
在，mapper中定义:
<!--更新用户信息-->
<update id="updateUserData" parameterType="com.elderlycaresystem.demo.user.entity.UserEntity">
UPDATE
`user`
SET
`user_acct` = #{
userAcct},
`user_name` = #{
userName},
`user_email` = #{
userEmail},
`user_phone` = #{
userPhone},
`user_address` = #{
userAddress},
`user_id_card` = #{
userIdCard},
`user_update_time` = now()
WHERE
user_code = #{
userCode}
</update>
在service中处理并传参至dao方法:
/**
* 修改用户信息
* @param userEntity
* @return
*/
public ResponceData updateUserData(UserEntity userEntity){
if(null == userEntity.getUserCode() || userEntity.getUserCode() == ""){
return new ResponceData(ResponceDataState.values()[3].getCode(),"编号参数不存在或者不能为空!",null);
}
//先判断用户账号是否存在
int userAcctNum = userDao.countAcct(userEntity);
if(userAcctNum>0){
//说明用户账号已经存在
responceData = new ResponceData(ResponceDataState.values()[9].getCode(),"用户账号已经存在",null);
return responceData;
}
//没问题后，新增 当然也可以在mybatis中使用if来判断，根据个人需求
if(null == userEntity.getUserAcct()){
userEntity.setUserAcct("");
}
if(null == userEntity.getUserEmail()){
userEntity.setUserEmail("");
}
if(null == userEntity.getUserPhone()){
userEntity.setUserPhone("");
}
//更新
int result = userDao.updateUserData(userEntity);
return new ResponceData(ResponceDataState.values()[0].getCode(),"更新成功!",result);
}
controller:
/**
* 更新用户
* @param userEntity
* @return
*/
@PostMapping("updateUserData")
public ResponceData updateUserData(UserEntity userEntity){
try{
responceData = userService.updateUserData(userEntity);
return responceData;
}catch (Exception e){
throw e;
}
}
测试:
去数据库看看是否已经成功更新信息:
发现已经成功更新信息.
列表分页查询用户
这里的话，使用的地方很多，当每页需要显示10条或者更多或者用户自定义显示数量的时候，并且通过过滤也就是模糊查询进行返回相关结果。
这里我们根据用户编号和手机号进行模糊查询。
我们需要知道PageHelper插件，此插件很方便，可以用来对数据进行分页以及对数据进行封装。
在build.gradle中加入一句话，如下:
'com.github.pagehelper:pagehelper-spring-boot-starter:1.2.10'
下载好后，就可以开始使用了。
首先，这里我们为了接收前台传来的参数，因为其中包含pageSize和pageNum，所以为了方便,我们需要新建一个实体类VO来进行格式化接受参数，如下:
package com.elderlycaresystem.demo.user.entity;
/**
* @Deprecated 分页列表显示参数-实体类
* @author charlinheng
* @date 2020年5月24日
*/
public class UserListParamEntiry {
/**
* 用户编号
*/
private String userCode;
/**
*用户手机号
*/
private String userPhone;
/**
*页显示数量
*/
private int pageSize;
/**
*页号
*/
private int pageNum;
public String getUserCode() {
return userCode;
}
public void setUserCode(String userCode) {
this.userCode = userCode;
}
public String getUserPhone() {
return userPhone;
}
public void setUserPhone(String userPhone) {
this.userPhone = userPhone;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getPageNum() {
return pageNum;
}
public void setPageNum(int pageNum) {
this.pageNum = pageNum;
}
}
我们先在dao中声明 列表查询方法queryUserList:
package com.elderlycaresystem.demo.user.dao;
import com.elderlycaresystem.demo.user.entity.UserEntity;
import com.elderlycaresystem.demo.user.entity.UserListParamEntiry;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @Description UserDao层服务
* @author CharLinHengu
* @date 2020年3月28日21:09:42
*/
@Mapper
public interface UserDao {
/**
* 判断用户账号是存在
* 当返回的值大于0时表示此用户账号已经存在。
* @param user
* @return int
*/
int countAcct(UserEntity user);
/**
*查看是否存在
*/
int judgeHasExist(@Param("userAcct")String acct);
/**
* 新增用户
* @param userEntity
* @return
* 2020年3月28日23:24:33
*/
int addUser(UserEntity userEntity);
/**
* 删除用户
* @param deleteUserCodeList
* @return
*/
int deleteUser(@Param("deleteCodeList")List<String>deleteUserCodeList);
/**
* 用户详情
*/
UserEntity queryDetail(@Param("userCode")String userCode);
/**
* 更新用户信息
* @param userEntity
* @return
*/
int updateUserData(UserEntity userEntity);
/**
* 分页列表查询用户信息
* @param userListParamEntiry
* @return
*/
List<UserEntity> queryUserList(UserListParamEntiry userListParamEntiry);
}
在sql中撰写相关sql语句:
<select id="queryUserList" parameterType="com.elderlycaresystem.demo.user.entity.UserListParamEntiry" resultType="com.elderlycaresystem.demo.user.entity.UserEntity">
SELECT
`user_code` userCode,
`user_acct` userAcct,
`user_name` userName,
`user_password` userPass,
`user_email` userEmail,
`user_phone` userPhone,
`user_address` userAddress,
`user_id_card` userIdCard,
`user_role` userRole,
`user_create_time` userCreateTime,
`user_create_ip` userCreateIp,
`user_update_time` userUpdateTime
FROM
`user`
WHERE
`is_delete` = 0
<if test="null != userCode and userCode != ''">
and user_code like concat('%',#{userCode},'%')
if>
<if test="null != userPhone and userCode != ''">
and user_phone like concat('%',#{userPhone},'%')
if>
select>
这里使用了if来进行模糊查询。
在Service中接受controll传来的参数并且调用数据库操作函数queryUserList：
/**
* 列表分页模糊查询
* @param userListParamEntiry
* @return
*/
public ResponceData queryUserList(UserListParamEntiry userListParamEntiry){
//分页工具进行 分页，参数为 页显示数量，页显示号
PageHelper.startPage(userListParamEntiry.getPageNum(),userListParamEntiry.getPageSize());
//调用方法
List<UserEntity>userEntityList = userDao.queryUserList(userListParamEntiry);
//包装查询后的信息，增加一些分页信息
PageInfo<UserEntity>userEntityPageInfo = new PageInfo<>(userEntityList);
return new ResponceData(ResponceDataState.values()[0].getCode(),"查询成功!",userEntityPageInfo);
}
在controller中:
/**
* 列表分页模糊查询用户
* @param userListParamEntiry
* @return
*/
@PostMapping("getUserListData")
public ResponceData getUserListData(UserListParamEntiry userListParamEntiry){
try{
responceData = userService.queryUserList(userListParamEntiry);
return responceData;
}catch (Exception e){
throw e;
}
}
测试:
当啥参数都不输入:
当输入一页显示1条，第2页:
每页显示2条，第一页。在此基础上，进行模糊查询，查询手机号有4个3的用户:
4个4的。
如果是查询不到满足条件的请求，返回为空的List。
这样的话，基本的增删查改就实现了。对于Spring，要学习的东西还很多很多。将会继续学习下去。
项目Demo的GITHUB地址
Demo