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

一、前言

二、新建Spring Boot 项目

三、Spring Boot 整合JDBC 与MySQL 交互

3.1 新建数据表skr_user 

3.2 Jdbcproject 项目结构如下

3.3 搭建文件结构

    3.3.1 创建package 

    3.3.2 创建开发环境配置文件

3.4 新建工具类

    3.4.1 加密工具类MD5Util.java

    3.4.2 单据编号生成工具类GenerateIdUtil.java

3.5 新建实体类

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

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

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

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

    3.6.1 新建持久层接口SkrUserDao.java

    3.6.2 新建持久层实现类SkrUserDaoImpl.java

    3.6.3 新建业务接口SkrUserService.java

    3.6.4 新建业务实现类SkrUserServiceImpl.java

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

4.1 新建Controller 控制层类

4.2 项目最终结构图如下

五、后端开发项目测试 

---

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

 一、前言

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

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

    环境介绍：

• 开发工具：IDEA
• JDK: 1.7 及以上
• Spring Boot: 2.0 及以上
• Maven: 3.0 及以上
• MySQL: 5.7

二、新建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.0modelVersion>

    <groupId>pers.niaonaogroupId>
    <artifactId>jdbcprojectartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <packaging>jarpackaging>

    <name>jdbcprojectname>
    <description>Demo project for Spring Bootdescription>

    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.0.3.RELEASEversion>
        <relativePath/> 
    parent>

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

    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <scope>runtimescope>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>

        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>fastjsonartifactId>
            <version>1.2.8version>
        dependency>
    dependencies>

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

project>

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

图3-2、引入Maven 依赖图

3.3 搭建文件结构

    在pers.niaonao.jdbcproject 下新建package 包

• dao: 存放持久层接口
• entity: 存放实体类
• service: 存放业务层相关接口
• util: 存放工具类
• web: 存放Controller 控制层相关类

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

• application.yml: 和application.properties 配置文件一样，只是文件格式不一样。Spring Boot 推荐使用yaml 格式配置文件。
• application-dev.yml: 作为开发环境配置文件。(一个项目的开发一般有正式环境application-master.yml，开发环境application-dev.yml，测试环境application-feature.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 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 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 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 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 新建测试数据测试截图如下。以上五个接口均已测试通过。以注册用户接口为例。

• 项目运行端口8082
• 请求方式为Post
• 请求数据类型为JSON 类型

    测试请求数据格式如下：

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

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

转载于:https://www.cnblogs.com/niaonao/p/9386705.html