Spring Boot 整合JDBC 实现后端项目开发

源码: https://github.com/niaonao/jdbcproject

一、前言

前后端分离开发是将项目开发工作前后端交互工作拆分，使前端开发人员能够专注于页面开发或APP 开发，后端开发人员专注与接口开发、业务逻辑开发。

此处开发后端项目，给前端或者APP 端提供接口。不涉及复杂的业务逻辑，通过简单的增删改查来演示后端开发项目。

环境介绍：

二、新建Spring Boot 项目

通过功能菜单File - New - Project 新建Spring Initializr 项目，Project SDK 选择Java 1.8.0，其他默认即可Next 下一步。



图2-1、新建Spring Initializr 项目

坐标Group 填写pers.niaonao，坐标Artifact 填写jdbcproject，项目Name 为jdbcproject，Package 包名为pers.niaonao.jdbcproject。



图2-2、Project Metadata 图

项目依赖选择Web、JDBC、MySQL 然后Next 下一步。



图2-3、选择项目依赖图



图2-4、完成项目创建

你可以另外配置Maven 也可以使用默认的Maven，我这里是自己配置的Maven 3.5



图2-5、Maven 配置图

三、Spring Boot 整合JDBC 与MySQL 交互

3.1 新建数据表skr_user

-- ----------------------------
-- Table structure for skr_user
-- ----------------------------
DROP TABLE IF EXISTS `skr_user`;
CREATE TABLE `skr_user` (
`id` int(5) NOT NULL AUTO_INCREMENT COMMENT '主键',
`user_id` varchar(20) NOT NULL COMMENT '用户ID',
`user_nick_name` varchar(10) DEFAULT NULL COMMENT '用户昵称',
`user_real_name` varchar(10) DEFAULT NULL COMMENT '用户名称',
`user_phone` varchar(11) DEFAULT NULL,
`user_password` varchar(32) DEFAULT NULL,
`user_address` varchar(32) DEFAULT NULL,
`user_gender` int(1) DEFAULT NULL COMMENT '性别: 0/1 - 男/女',
`user_card` varchar(20) DEFAULT NULL COMMENT '身份证',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=21 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of skr_user
-- ----------------------------
INSERT INTO `skr_user` VALUES ('1', '2018072910221899540', 'kecun', '柯纯', '15728287364', 'E10ADC3949BA59ABBE56E057F20F883E', 'hpu松7', '0', '340824199202010355');
INSERT INTO `skr_user` VALUES ('2', '2018072910221067312', 'huangza', '皇子昂', '15746938428', 'E10ADC3949BA59ABBE56E057F20F883E', '安徽省安庆市潜山县', '0', '340824198102115159');
INSERT INTO `skr_user` VALUES ('3', '2018072910221030545', 'guosb', '郭淑白', '15647338496', 'E10ADC3949BA59ABBE56E057F20F883E', '广东省江门市鹤山市', '1', '440784198602241121');
INSERT INTO `skr_user` VALUES ('4', '2018072910221012658', 'gongcj', '龚才俊', '15746938428', 'E10ADC3949BA59ABBE56E057F20F883E', '海南省三亚市万宁市', '0', '340824199808213429');
INSERT INTO `skr_user` VALUES ('5', '2018072910221060270', 'chenh', '陈鸿祯', '13857288463', 'E10ADC3949BA59ABBE56E057F20F883E', '江苏省淮阴市金湖县', '0', '460006197201070474');
INSERT INTO `skr_user` VALUES ('6', '2018072910221209445', 'lie', '李尔', '12094847738', 'E10ADC3949BA59ABBE56E057F20F883E', '河北省邢台市沙河市', '0', '513427199812291899');
INSERT INTO `skr_user` VALUES ('7', '2018072910221053415', 'guxz', '顾兴朝', '17461937475', 'E10ADC3949BA59ABBE56E057F20F883E', '西藏自治区日喀则地区', '0', '320831199707251836');
INSERT INTO `skr_user` VALUES ('8', '2018072910221052908', 'taohh', '陶鸿晖', '11537495365', 'E10ADC3949BA59ABBE56E057F20F883E', '山西省忻州地区定襄县', '0', '130582197910124575');
INSERT INTO `skr_user` VALUES ('9', '2018072910221189175', 'qincc', '秦痴春', '15377464838', 'E10ADC3949BA59ABBE56E057F20F883E', '云南省昆明市呈贡县', '0', '142222197709186791');
INSERT INTO `skr_user` VALUES ('10', '2018072910221068870', 'long', '龙伟兆', '11827629283', 'E10ADC3949BA59ABBE56E057F20F883E', '广西壮族自治区南宁市', '0', '542300199409116469');
INSERT INTO `skr_user` VALUES ('11', '2018072910221053349', 'qian', '钱逸明', '15847562672', 'E10ADC3949BA59ABBE56E057F20F883E', '陕西省安康地区', '0', '530121197909145993');
INSERT INTO `skr_user` VALUES ('12', '2018072910221041169', 'weih', '韦宏旷', '18484575399', 'E10ADC3949BA59ABBE56E057F20F883E', '安徽省安庆市潜山县', '0', '45010019710713799X');
INSERT INTO `skr_user` VALUES ('13', '2018072910221654738', 'songms', '宋妙松', '18494737626', 'E10ADC3949BA59ABBE56E057F20F883E', '西藏自治区日喀则地区日喀则市', '0', '15212719921025705X');
INSERT INTO `skr_user` VALUES ('14', '2018072910221025795', 'zhanghc', '张宏畅', '15122321464', 'E10ADC3949BA59ABBE56E057F20F883E', '安徽省安庆市枞阳县', '0', '612400199301127581');
INSERT INTO `skr_user` VALUES ('15', '2018072910221079179', 'fangxq', '方新晴', '15253545293', 'E10ADC3949BA59ABBE56E057F20F883E', '辽宁省葫芦岛市兴城市', '1', '542301199907030111');
INSERT INTO `skr_user` VALUES ('16', '2018072910221091637', 'linz', '林芷天', '15847372626', 'E10ADC3949BA59ABBE56E057F20F883E', '四川省凉山彝族自治州宁南县', '1', '21148119971204138X');
INSERT INTO `skr_user` VALUES ('17', '2018072910221022477', 'qianyw', '钱阳文', '12828474795', 'E10ADC3949BA59ABBE56E057F20F883E', '河北省石家庄市赞皇县', '0', '513427198007131419');
INSERT INTO `skr_user` VALUES ('18', '2018072910221766265', 'panyq', '潘雅琴', '15748237348', 'E10ADC3949BA59ABBE56E057F20F883E', '河南省濮阳市市区', '1', '430412199410027117');
INSERT INTO `skr_user` VALUES ('19', '2018072910221022477', 'hanyh', '韩宇航', '12582738394', 'E10ADC3949BA59ABBE56E057F20F883E', '湖南省衡阳市南岳区', '0', '130129198810294762');
INSERT INTO `skr_user` VALUES ('20', '2018072910221066822', 'luth', '卢天华', '15943732827', 'E10ADC3949BA59ABBE56E057F20F883E', '安徽省安庆市潜山县', '0', '410902199204160559');

3.2 Jdbcproject 项目结构如下

图3-1、项目初始结构图

添加JSON 依赖，pom.xml 文件如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>

<groupId>pers.niaonao</groupId>
<artifactId>jdbcproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>jdbcproject</name>
<description>Demo project for Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.3.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<!--1.JDBC 依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--2.Web 依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!--3.MySQL 依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<!--4.JSON依赖-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.8</version>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

</project>

此处添加了JSON 依赖，前后端数据的传输格式统一为JSON 类型。引入依赖。



图3-2、引入Maven 依赖图

3.3 搭建文件结构

在pers.niaonao.jdbcproject 下新建package 包


在资源路径resources 新建application.yml 和application-dev.yml 文件。





图3-3、搭建文件结构图

application.xml 文件如下

spring:
profiles:
active: dev

application-dev.xml 文件如下

#develop environment
#端口
server:
port: 8082
#数据库
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/yonyou_nc
username: root
password: root

3.4 新建工具类

在util 包下新建加密工具类MD5Util.java，新建id 生成工具类。

加密工具类MD5Util.java

package pers.niaonao.jdbcproject.util;

import java.security.MessageDigest;

/**
* @Author: niaonao
* @Date: Created in 15:21 2018/7/29
* @Description :md5加密工具类
*/
public class MD5Util {
/**
* 生成md5
*
* @param message
* @return
*/
public static String getMD5(String message) {
String md5str = "";
try {
// 1 创建一个提供信息摘要算法的对象，初始化为md5算法对象
MessageDigest md = MessageDigest.getInstance("MD5");

// 2 将消息变成byte数组
byte[] input = message.getBytes("UTF-8");

// 3 计算后获得字节数组,这就是那128位了
byte[] buff = md.digest(input);

// 4 把数组每一字节（一个字节占八位）换成16进制连成md5字符串
md5str = bytesToHex(buff);

} catch (Exception e) {
e.printStackTrace();
}
return md5str;
}

/**
* 二进制转十六进制
*
* @param bytes
* @return
*/
public static String bytesToHex(byte[] bytes) {
StringBuffer md5str = new StringBuffer();
// 把数组每一字节换成16进制连成md5字符串
int digital;
for (int i = 0; i < bytes.length; i++) {
digital = bytes[i];

if (digital < 0) {
digital += 256;
}
if (digital < 16) {
md5str.append("0");
}
md5str.append(Integer.toHexString(digital));
}
return md5str.toString().toLowerCase();
}
}

GenerateIdUtil.java

package pers.niaonao.jdbcproject.util;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;

/**
* @Author: niaonao
* @Date: Created in 15:21 2018/7/29
* @Desprition: 实体类ID 生成工具类
*/
public class GenerateIdUtil {

/** 默认用户分表位 */
private static final String DEFAULT_USER_PARTITION  = "1";

/** 默认替代位 */
private static final String DEFAULT_REPLACE = "0";

/** 默认横线 */
private static final String DEFAULT_LINE = "-";

/**
* 生成 id 方法
* 一般项目会有多个实体类(数据表)
* 此处生成id 添加四位标记码可以区分不同的数据表，且能够降低出现重复的id
* @param tableBizCode 数据表标记码
* @return
*/
public static String generateId(String tableBizCode){
//获取当前日期字符串
String dateString = getPartition(new Date());
//获取随机生成十四位数字
String ranString = String.valueOf(new Random().nextLong()).substring(0,6);
//如果当前随机数第一位是-,则用0代替
if (ranString.contains(DEFAULT_LINE)){
ranString = ranString.replace(DEFAULT_LINE,DEFAULT_REPLACE);
}
//iD规则:当前日期字符串 +       1 +         数据表标记码 + 6位随机数字符串
return dateString + DEFAULT_USER_PARTITION + tableBizCode + ranString;
}

/**
* 日期转换
* @param date   当前时间
* @return       日期字符串
*/
public static String getPartition(Date date) {
//前8位yyyyMMdd格式
DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
return dateFormat.format(date);
}

public static void main(String args[]){
//生成数据格式：2018072910221899540
System.out.println(generateId("0221"));
}
}

3.5 新建实体类

在entity 包下新建实体类SkrUser.java、RequestEntity.java、ResultEntity.java

数据表对应用户实体类SkrUser.java

package pers.niaonao.jdbcproject.entity;

/**
* @Author: niaonao
* @Date: Created in 16:24 2018/7/29
* @Desprition: 用户实体类
*/
public class SkrUser {

/**
* 用户ID
*/
private String userId;
/**
* 用户注册昵称
*/
private String userNickName;
/**
* 用户真实名称
*/
private String userRealName;
/**
* 用户手机号码
*/
private String userPhone;
/**
* 用户登录密码
*/
private String userPassword;
/**
* 用户地址
*/
private String userAddress;
/**
* 用户身份证号
*/
private String userCard;
/**
* 用户性别
* 0/1 - 男/女
*/
private int userGender = -1;

public String getUserId() { return userId; }

public void setUserId(String userId) { this.userId = userId; }

public String getUserNickName() { return userNickName; }

public void setUserNickName(String userNickName) { this.userNickName = userNickName; }

public String getUserRealName() { return userRealName; }

public void setUserRealName(String userRealName) { this.userRealName = userRealName; }

public String getUserPhone() { return userPhone; }

public void setUserPhone(String userPhone) { this.userPhone = userPhone; }

public String getUserPassword() { return userPassword; }

public void setUserPassword(String userPassword) { this.userPassword = userPassword; }

public String getUserAddress() { return userAddress; }

public void setUserAddress(String userAddress) { this.userAddress = userAddress; }

public String getUserCard() { return userCard; }

public void setUserCard(String userCard) { this.userCard = userCard; }

public int getUserGender() { return userGender; }

public void setUserGender(int userGender) { this.userGender = userGender; }
}

请求参数封装实体类RequsetEntity.java

package pers.niaonao.jdbcproject.entity;

import java.io.Serializable;

/**
* @Author: niaonao
* @Date: Created in 16:36 2018/7/29
* @Desprition: 请求参数封装类
*/
public class RequestEntity implements Serializable {
private static final long serialVersionUID = 3401781428101852075L;

/**
* 请求响应数据
*/
private String treasureData;

public String getTreasureData() {
return treasureData;
}

public void setTreasureData(String treasureData) {
this.treasureData = treasureData;
}

}

后台响应结果封装实体类ResultEntity.java

package pers.niaonao.jdbcproject.entity;

import java.io.Serializable;

/**
* @Author: niaonao
* @Date: Created in 16:36 2018/7/29
* @Desprition: 返回结果封装实体类
*/
public class ResultEntity implements Serializable {

private static final long serialVersionUID = 3401781428101852075L;

/**
* 接口请求处理结果
* 成功true，失败-false
*/
private Boolean success;

/**
* 处理结果信息
*/
private String errorMsg;

/**
* 返回数据对象
*/
private Object object;

public Boolean getSuccess() {
return success;
}

public void setSuccess(Boolean success) {
this.success = success;
}

public String getErrorMsg() {
return errorMsg;
}

public void setErrorMsg(String errorMsg) {
this.errorMsg = errorMsg;
}

public Object getObject() {
return object;
}

public void setObject(Object object) {
this.object = object;
}

/**
* 构造函数
* @param success
* @param errorMsg
* @param object
*/
public ResultEntity(Boolean success, String errorMsg, Object object) {
this.success = success;
this.errorMsg = errorMsg;
this.object = object;
}
}

3.6 完善持久层和业务层代码

新建持久层接口SkrUserDao.java

package pers.niaonao.jdbcproject.dao;

import pers.niaonao.jdbcproject.entity.SkrUser;

import java.util.List;

/**
* @Author: niaonao
* @Date: Created in 16:25 2018/7/29
* @Desprition: 用户持久层接口类
*/
public interface SkrUserDao {
/**
* 多条件查询获取实体信息
* @param SkrUser
* @return
*/
SkrUser selectByParams(SkrUser SkrUser);

/**
* 获取全部用户
* @param SkrUser
* @return
*/
List<SkrUser> getList(SkrUser SkrUser);

/**
* 更新用户信息(如果字段不为空更新)
* @param SkrUser
* @return
*/
int updateByIdSelective(SkrUser SkrUser);

/**
* 根据id删除实体信息
* @param SkrUser
* @return
*/
int deleteById(SkrUser SkrUser);

/**
* 插入用户记录
* @param SkrUser
* @return
*/
int insert(SkrUser SkrUser);

/**
* 根据不为空的参数插入用户记录
* @param SkrUser
* @return
*/
int insertBySelective(SkrUser SkrUser);
}

在包pers.niaonao.jdbcproject.dao 下新建package 包 daoimpl

在daoimpl 下新建实现类SkrUserDaoImpl.java

package pers.niaonao.jdbcproject.dao.daoimpl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import pers.niaonao.jdbcproject.dao.SkrUserDao;
import pers.niaonao.jdbcproject.entity.SkrUser;
import pers.niaonao.jdbcproject.util.MD5Util;

import java.util.List;

/**
* @Author: niaonao
* @Date: Created in 16:29 2018/7/29
* @Desprition: 用户持久层接口实现类
*/
@Repository
public class SkrUserDaoImpl implements SkrUserDao  {
@Autowired
private JdbcTemplate jdbcTemplate;

@Override
public SkrUser selectByParams(SkrUser skrUser) {

//拼接多条件查询语句，支持模糊查询
String sql = " select user_id, user_nick_name, user_password, user_real_name," +
" user_gender, user_card, user_phone, user_address from skr_user WHERE ";
if (skrUser.getUserId() != null){
sql = sql + " user_id = '" + skrUser.getUserId() + "' AND ";
}
if (skrUser.getUserRealName() != null) {
sql = sql + " user_real_name = '" + skrUser.getUserRealName() + "' AND ";
}
if (skrUser.getUserNickName() != null){
sql = sql + " user_nick_name = '" + skrUser.getUserNickName() + "' AND ";
}
if (skrUser.getUserPassword() != null){
sql = sql + " user_password = '" + MD5Util.getMD5(skrUser.getUserPassword()) + "' AND ";
}
if (skrUser.getUserPassword() != null){
sql = sql + " user_phone = '" + skrUser.getUserPhone() + "' AND ";
}
if (skrUser.getUserPassword() != null){
sql = sql + " user_gender = '" + skrUser.getUserGender() + "' AND ";
}
if (skrUser.getUserPassword() != null){
sql = sql + " user_address = '" + skrUser.getUserAddress() + "' AND ";
}

//截取SQl语句多余后缀
if (sql.endsWith("AND ")){
sql = sql.substring(0,sql.length() - 4);
}

//封装执行SQL 语句结果
List<SkrUser> skrUserList = jdbcTemplate.query(sql ,new Object[]{}, new BeanPropertyRowMapper(SkrUser.class)) ;
if (skrUserList == null || skrUserList.size() < 1){
return null;
}
return skrUserList.get(0);
}

@Override
public List<SkrUser> getList(SkrUser skrUser) {
//拼接SQL语句
String sql = " SELECT user_id, user_nick_name, user_password, user_real_name," +
" user_gender, user_card, user_phone, user_address FROM skr_user WHERE ";

if (skrUser.getUserId() != null){
sql = sql + " user_id = '" + skrUser.getUserId() + "' AND ";
}
if (skrUser.getUserRealName() != null) {
sql = sql + " user_real_name LIKE '%" + skrUser.getUserRealName() + "%' AND ";
}
if (skrUser.getUserNickName() != null){
sql = sql + " user_nick_name LIKE '%" + skrUser.getUserNickName() + "%' AND ";
}
if (skrUser.getUserPassword() != null){
sql = sql + " user_password LIKE '%" + MD5Util.getMD5(skrUser.getUserPassword()) + "%' AND ";
}
if (skrUser.getUserPhone() != null){
sql = sql + " user_phone LIKE '%" + skrUser.getUserPhone() + "%' AND ";
}
if (skrUser.getUserGender() == 1 || skrUser.getUserGender() == 0){
sql = sql + " user_gender LIKE '%" + skrUser.getUserGender() + "%' AND ";
}
if (skrUser.getUserAddress() != null){
sql = sql + " user_address LIKE '%" + skrUser.getUserAddress() + "%' AND ";
}

//截取SQl语句多余后缀
if (sql.endsWith("WHERE ")){
sql = sql.substring(0,sql.length() - 6);
}else if (sql.endsWith("AND ")){
sql = sql.substring(0,sql.length() - 4);
}

return jdbcTemplate.query(sql, new Object[]{}, new BeanPropertyRowMapper(SkrUser.class));
}

@Override
public int updateByIdSelective(SkrUser skrUser) {
//根据对象唯一ID更新
if (skrUser.getUserId() == null){
return 0;
}

//拼接SQL语句,拼接SQL语句考虑拼接的数据加单引号
String sql = "UPDATE skr_user SET " ;
if (skrUser.getUserRealName() != null) {
sql = sql + " user_real_name = '" + skrUser.getUserRealName() + "' , ";
}
if (skrUser.getUserNickName() != null) {
sql = sql + " user_nick_name = '" + skrUser.getUserNickName() + "' , ";
}
if (skrUser.getUserPassword() != null) {
sql = sql + " user_password = '" + skrUser.getUserPassword() + "' , ";
}
if (skrUser.getUserAddress() != null) {
sql = sql + " user_address = '" + skrUser.getUserAddress() + "' , ";
}
if (skrUser.getUserGender() == 1 || skrUser.getUserGender() == 0) {
sql = sql + " user_gender = '" + skrUser.getUserGender() + "' , ";
}
if (skrUser.getUserCard() != null) {
sql = sql + " user_card = '" + skrUser.getUserCard() + "' , ";
}
if (skrUser.getUserPhone() != null) {
sql = sql + " user_phone = '" + skrUser.getUserPhone() + "' , ";
}

if (sql.endsWith("SET")){
return 0;
}

//截取SQl语句多余后缀","并拼接WHERE条件
if (sql.endsWith(", ")){
sql = sql.substring(0,sql.length() - 2) + " WHERE user_id = '" + skrUser.getUserId() + "'";
}
return jdbcTemplate.update(sql);
}

@Override
public int deleteById(SkrUser skrUser) {
//根据对象唯一ID删除
if (skrUser.getUserId() == null){
return 0;
}
return jdbcTemplate.update("DELETE from skr_user WHERE user_id=?",skrUser.getUserId());
}

@Override
public int insert(SkrUser skrUser) {

String sql = "INSERT INTO skr_user " +
"(user_id, user_nick_name, user_password, user_address, user_real_name, user_gender, user_card, user_phone)" +
" VALUES (?,?,?,?,?,?,?,?)";
return jdbcTemplate.update(sql, skrUser.getUserId(), skrUser.getUserNickName(), skrUser.getUserPassword(),
skrUser.getUserAddress(),skrUser.getUserRealName(),skrUser.getUserGender(),skrUser.getUserCard(),skrUser.getUserPhone());
}

@Override
public int insertBySelective(SkrUser skrUser) {

skrUser.setUserRealName(skrUser.getUserRealName() == null ? "" : skrUser.getUserRealName());
skrUser.setUserNickName(skrUser.getUserNickName() == null ? "" : skrUser.getUserNickName());
skrUser.setUserPassword(skrUser.getUserPassword() == null ? "" : skrUser.getUserPassword());
skrUser.setUserNickName(skrUser.getUserNickName() == null ? "" : skrUser.getUserNickName());
skrUser.setUserAddress(skrUser.getUserAddress() == null ? "" : skrUser.getUserAddress());
skrUser.setUserCard(skrUser.getUserCard() == null ? "" : skrUser.getUserCard());
skrUser.setUserGender(skrUser.getUserGender());
skrUser.setUserId(skrUser.getUserId());

String sql = "INSERT INTO skr_user " +
"(user_id, user_nick_name, user_password, user_address, user_real_name, user_gender, user_card, user_phone)" +
" VALUES (?,?,?,?,?,?,?,?)";

return jdbcTemplate.update(sql, skrUser.getUserId(), skrUser.getUserNickName(), skrUser.getUserPassword(),
skrUser.getUserAddress(),skrUser.getUserRealName(),skrUser.getUserGender(),skrUser.getUserCard(),skrUser.getUserPhone());
}
}

在包service 下新建业务接口SkrUserService.java

package pers.niaonao.jdbcproject.service;

import pers.niaonao.jdbcproject.entity.RequestEntity;
import pers.niaonao.jdbcproject.entity.ResultEntity;

/**
* @Author: niaonao
* @Date: Created in 16:26 2018/7/29
* @Desprition: 用户业务接口
*/
public interface SkrUserService {
/**
* 多条件获取用户
* @param requestEntity
* @return
*/
ResultEntity getSkrUser(RequestEntity requestEntity);

/**
* 获取全部用户
* @param requestEntity
* @return
*/
ResultEntity getSkrUserList(RequestEntity requestEntity);

/**
* 更新用户信息(如果字段不为空更新)
* @param requestEntity
* @return
*/
ResultEntity updateSkrUser(RequestEntity requestEntity);

/**
* 根据id删除用户信息
* @param requestEntity
* @return
*/
ResultEntity deleteSkrUser(RequestEntity requestEntity);

/**
* 注册用户
* @param requestEntity
* @return
*/
ResultEntity addSkrUser(RequestEntity requestEntity);
}

在pers.niaonao.jdbcproject.service 下新建package 包serviceimpl

在serviceimpl 下新建业务实现类SkrUserServiceImpl.java

package pers.niaonao.jdbcproject.service.serviceimpl;

import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import pers.niaonao.jdbcproject.dao.SkrUserDao;
import pers.niaonao.jdbcproject.entity.RequestEntity;
import pers.niaonao.jdbcproject.entity.ResultEntity;
import pers.niaonao.jdbcproject.entity.SkrUser;
import pers.niaonao.jdbcproject.service.SkrUserService;
import pers.niaonao.jdbcproject.util.GenerateIdUtil;
import pers.niaonao.jdbcproject.util.MD5Util;

import java.util.List;

/**
* @Author: niaonao
* @Date: Created in 16:29 2018/7/29
* @Desprition: 用户业务实现类
*/
@Service(value = "skrUserService")
public class SkrUserServiceImpl implements SkrUserService {

@Autowired
private SkrUserDao skrUserDao;

@Override
public ResultEntity getSkrUser(RequestEntity requestEntity) {
//解析请求数据
SkrUser user = JSONObject.parseObject(requestEntity.getTreasureData(), SkrUser.class);

Boolean success = Boolean.FALSE;
String errorMsg = "获取用户信息成功！";
if (user == null){
errorMsg = "请求数据不能为空！";
} else {
//根据请求参数查询用户信息
user = skrUserDao.selectByParams(user);
if (user == null){
errorMsg = "用户信息不存在！";
} else {
success = Boolean.TRUE;
}
}

//封装返回结果
ResultEntity resultEntity = new ResultEntity(success,errorMsg,user);
return resultEntity;
}

@Override
public ResultEntity getSkrUserList(RequestEntity requestEntity) {
//解析请求数据
SkrUser user = JSONObject.parseObject(requestEntity.getTreasureData(), SkrUser.class);
if (user == null){
user = new SkrUser();
}

//获取用户信息集合
List<SkrUser> userList = skrUserDao.getList(user);

//初始化执行结果
Boolean success = Boolean.TRUE;
String errorMsg = "获取用户信息成功！";
if (userList == null) {
success = Boolean.FALSE;
errorMsg = "用户信息不存在！！";
}

//封装返回结果
ResultEntity resultEntity = new ResultEntity(success,errorMsg,userList);
return resultEntity;
}

@Override
public ResultEntity updateSkrUser(RequestEntity requestEntity) {
//解析请求数据
SkrUser user = JSONObject.parseObject(requestEntity.getTreasureData(), SkrUser.class);

Boolean success = Boolean.FALSE;
String errorMsg = "更新用户信息成功！";
if (user == null){
errorMsg = "请求数据不能为空！";
} else if (user.getUserId() == null || user.getUserId().equals("")){
errorMsg = "用户编号不能为空！";
} else {
//更新用户信息
int resultRow = skrUserDao.updateByIdSelective(user);
if (resultRow < 1){
errorMsg = "更新用户失败！";
}else {
success = Boolean.TRUE;
}
}

//封装返回结果
ResultEntity resultEntity = new ResultEntity(success, errorMsg, null);
return resultEntity;
}

@Override
public ResultEntity deleteSkrUser(RequestEntity requestEntity) {

//解析请求数据
SkrUser user = JSONObject.parseObject(requestEntity.getTreasureData(), SkrUser.class);

Boolean success = Boolean.FALSE;
String errorMsg = "用户删除成功！";
if (user == null){
errorMsg = "请求数据不能为空！";
} else if (user.getUserId() == null || user.getUserId().equals("")){
errorMsg = "用户编号不能为空！";
} else {
//删除用户信息
int resultRow = skrUserDao.deleteById(user);
if (resultRow < 1){
errorMsg = "删除用户失败！";
}else {
success = Boolean.TRUE;
}
}

//封装返回结果
ResultEntity resultEntity = new ResultEntity(success, errorMsg, null);
return resultEntity;
}

@Override
public ResultEntity addSkrUser(RequestEntity requestEntity) {

//解析请求数据
SkrUser user = JSONObject.parseObject(requestEntity.getTreasureData(), SkrUser.class);

Boolean success = Boolean.FALSE;
String errorMsg = "添加用户成功！";
if (user == null){
errorMsg = "请求数据不能为空！";
} else if (user.getUserNickName() == null || user.getUserPassword() == null
|| user.getUserNickName().equals("") || user.getUserPassword().equals("")){
errorMsg = "用户名和密码不能为空！";
} else {
//生成id，此处参数自定义，作为数据表标识。此处以1234 标识skr_user
user.setUserId(GenerateIdUtil.generateId("1234"));
//登录密码加密
user.setUserPassword(MD5Util.getMD5(user.getUserPassword()));

//插入用户信息
int resultRow = skrUserDao.insertBySelective(user);
if (resultRow < 1){
errorMsg = "添加用户失败！";
}else {
success = Boolean.TRUE;
}
}

//封装返回结果
ResultEntity resultEntity = new ResultEntity(success, errorMsg, null);
return resultEntity;
}
}

至此基本的业务逻辑和数据库交互开发完成。

四、后端项目对外接口开发

后端项目通过控制层Controller 来处理前端发出的请求。在控制层调用业务层Service ，具体的业务逻辑代码编写工作在业务层实现。

此处在包web 下新建用户控制类AppUserController.java 来响应前端请求。

package pers.niaonao.jdbcproject.web;

import org.springframework.web.bind.annotation.*;
import pers.niaonao.jdbcproject.entity.RequestEntity;
import pers.niaonao.jdbcproject.entity.ResultEntity;
import pers.niaonao.jdbcproject.service.SkrUserService;

import javax.annotation.Resource;

/**
* @Author: niaonao
* @Date: Created in 16:27 2018/7/29
* @Desprition: 前端访问接口的控制类
*/
@RestController
@RequestMapping(value = "/app")
public class AppUserController {

@Resource
private SkrUserService skrUserService;

/**
* 获取用户信息列表
* 多条件模糊查询
* @return
*/
@ResponseBody
@PostMapping(value = "/user/getAllSkrUser", produces ="application/json;charset=UTF-8" )
public ResultEntity getSkrUserList(@RequestBody RequestEntity requestEntity) {
return skrUserService.getSkrUserList(requestEntity);
}

/**
* 获取用户
* @param requestEntity
* @return
*/
@ResponseBody
@PostMapping(value = "/user/getSkrUser", produces ="application/json;charset=UTF-8" )
public ResultEntity getSkrUser(@RequestBody RequestEntity requestEntity) {
return skrUserService.getSkrUser(requestEntity);
}

/**
* 更新用户
* @param requestEntity
* @return
*/
@ResponseBody
@PostMapping(value = "/user/updateSkrUser", produces ="application/json;charset=UTF-8" )
public ResultEntity updateSkrUser(@RequestBody RequestEntity requestEntity) {
return skrUserService.updateSkrUser(requestEntity);
}

/**
* 注册用户
* @param requestEntity
* @return
*/
@ResponseBody
@PostMapping(value = "/user/registerSkrUser", produces ="application/json;charset=UTF-8" )
public ResultEntity addSkrUser(@RequestBody RequestEntity requestEntity) {
return skrUserService.addSkrUser(requestEntity);
}

/**
* 删除用户
* @param requestEntity
* @return
*/
@ResponseBody
@PostMapping(value = "/user/deleteSkrUser", produces ="application/json;charset=UTF-8" )
public ResultEntity deleteSkrUser(@RequestBody RequestEntity requestEntity) {
return skrUserService.deleteSkrUser(requestEntity);
}

}

项目最终结构图如下：



图4-1、项目完成结构图

五、后端开发项目测试

此处使用接口测试工具Postman 进行测试项目JdbcProject。快捷键Shift + Alt + D 运行项目。打开Postman 新建测试数据测试截图如下。以上五个接口均已测试通过。以注册用户接口为例。


测试请求数据格式如下：

{
"treasureData":"{\"userPassword\":\"yixiaochuan\",\"userNickName\":\"lvsu\",\"userRealName\":\"吕素\",\"userAddress\":\"秦朝单父县\",\"userGender\":\"1\"}"
}

图5-1、用户注册测试图