1 前言

对于后端服务器接口的开发，其实就是对数据的增、删、改、查操作。最早的数据库是关系型数据库，如Oracle和MySQL等。随着数据类型的多样化倒退，又诞生了诸如MongoDB和Redis等非关系型数据库，以及时序型数据库，如InfluxDB和Prometheus等。内存型数据库个别用于缓存，如EhCache和Couchbase等。Spring Boot作为一款优良的框架，提供了数据库集成的Starter模块，让开发者能够更不便地操作数据库。

Spring反对JdbcTemplate的数据库拜访模式，但这个用法始终未被很多企业采纳。不过正如Spring所提倡的理念，它并不排挤其余优良的框架，而是通过提供各种各样的模板，使得这些框架可能整合到Spring中来，并且更加不便开发者的应用。依据以后时代的背景，本书将介绍JdbcTemplate和JPA（在Spring Boot中默认的JPA实现是Hibernate）的简略联合，并具体论述MyBatis的整合，在后续章节中咱们将以MyBatis为主整合数据库的利用。

在Spring Boot中，曾经主动默认数据源的配置，上面让咱们开启Spring Boot的数据库之旅。

2 应用数据库

数据库分为两种，即关系型数据库和非关系型数据库。关系型数据库是指通过关系模型组织数据的数据库，并且能够利用外键等放弃一致性；而非关系型数据库其实不像是数据库，更像是一种以key-value模式存储对象的构造。

2.1 应用MySQL

MySQL数据库（官网地址：https://www.mysql.com）是一种关系型数据库，由瑞典的一家公司开发，当初是Oracle公司旗下的产品。MySQL应用C和C++语言开发，提供多种存储引擎，提供多种连贯路径，例如ODBC、JDBC、TCP/IP等，并且反对多线程，是当今最风行的数据库之一，并且收费提供给开发者应用。同时，MySQL数据库是一个高性能的数据库，并且反对多种开发语言，如C、C++、Python、Java、PHP等。并且，MySQL反对大型的数据库，能够解决领有上千万条记录的大型数据库。

在Spring Boot中应用MySQL很简略，大抵分为两步：

（1）在pom文件中退出依赖，如下所示：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

（2）在配置文件application.yml中配置数据库信息，如下所示：

spring:
    datasource:
        url: jdbc:mysql://127.0.0.1:3306/fullset?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false
        driver-class-name: com.mysql.cj.jdbc.Driver
        username: root
        password: root

2.2 应用SQL Server

SQL Server是微软公司推出的关系型数据库（官网地址：https://www.microsoft.com/zh-…），SQL Server数据库同样提供了很多长处，如易用性、适宜分布式组织的可伸缩性、用于决策反对的数据仓库性能、与许多其余服务器软件严密关联的集成性、良好的性价比等。然而相较于MySQL，其有肯定的毛病，如局限性（只能运行在Windows零碎上）、当连接数过高时性能不够稳固等。

Spring Boot应用SQL Server数据库也很简略，分为两步：

（1）在pom文件中退出依赖，如下所示：

<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <scope>runtime</scope>
</dependency>

（2）在配置文件中配置数据库信息，如下所示：

spring:
    datasource:
        url: jdbc:sqlserver://127.0.0.1:1433;DatabaseName=fullset
        driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
        username: root
        password: root

2.3 应用MongoDB

MongoDB（官网地址：https://www.mongodb.com）是一种非关系型数据库，它是一个基于分布式文件存储的数据库。MongoDB由C++语言编写，有高性能、容易部署等长处。

Spring Boot应用MongoDB数据库很简略，分为两步：

（1）在pom文件退出依赖，如下所示：

<dependency> 
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

（2）在配置文件中退出MongoDB配置，如下所示：

spring:
  data:
    mongodb:
      host: localhost   #同127.0.0.1
      port: 27017
      database: fullset    #指定操作的数据库

2.4 应用Redis

Redis（官网地址：https://redis.io/）是一种非关系型数据库，应用ANSI C语言开发，是一种Key-Value模式的数据库，反对多种value类型，如string（字符串）、list（链表）、set（汇合）、zset（sorted set，有序汇合）和hash（哈希类型）。

Spring Boot应用Redis数据库分为两步：

（1）在pom文件中退出依赖，如下所示：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

（2）在配置文件中退出配置，如下所示：

  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    password: fs9158
    jedis:
      pool:
        max-active: 20
        max-wait: 100
        max-idle: 20
        min-idle: 5
    timeout: 10000

3 集成JDBC

JDBC的全名是Java DataBase Connectivity，是咱们最先接触到的数据库连贯，通过JDBC能够间接应用Java编程来操作数据库。JDBC能够了解为一个能够执行SQL语句的Java API。

3.1 JDBC依赖

新建我的项目，在pom文件中退出JDBC依赖和MySQL依赖以及Web性能的依赖，如下所示：

<!-- JDBC -->
<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <scope>runtime</scope>
</dependency>
<!-- MySQL -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>>runtime</scope>
</dependency>
<!-- Web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

3.2 JDBC办法

通过上面4个办法别离列举了JdbcTemplate操作数据库的增、删、改、查的办法：

@Api(tags="用户服务接口")
@RestController
@RequestMapping("/baseService/user")
public class SysUserController {

    @Autowired
    private SysUserService sysUserService;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    //新增
    @GetMapping(value="/add")
    public Boolean add (String userName, String passWord){
        int result = jdbcTemplate.update(" insert into user (user_name, pass_word) values (?, ?)", userName, passWord);
        return result>0 ? true : false;
    }

    //删除
    @GetMapping(value ="/delete")
    public Boolean delete (Integer id){
        int result = jdbcTemplate.update(" delete from user where id=?", id);
        return result>0 ? true : false;
    }


    //批改
    @GetMapping(value ="/update")
    public Boolean update (Integer id, String passWord){
        int result = jdbcTemplate.update(" update user set passWord=? where id=?", passWord, id);
        return result>0 ? true : false;
    }

    //查问
    @GetMapping(value ="/getById")
    public Map getById (Integer id){
        String sql = "select * from user where id = ?";
        Map map = jdbcTemplate.queryForMap(sql, id);
        return map;
    }
}

在理论开发中对JDBC的应用不是很多，有肯定根底就能够了。

4 集成JPA

4.1 JPA介绍

JPA（Java Persistence API）是Sun公司官网提出的Java长久化标准。所谓标准是指只定义规范规定，不提供实现，而JPA的次要实现有Hibernate、EclipseLink、OpenJPA等。JPA是一套标准，不是一套产品，Hibernate是一套产品，如果这些产品实现了JPA标准，那么咱们能够把它们叫作JPA的实现产品。

Spring Data JPA是Spring Data的一个子项目，它通过提供基于JPA的Respository，极大地缩小了JPA作为数据拜访计划的代码量。通过SpringData JPA框架，开发者能够省略实现长久层业务逻辑的工作，惟一要做的，就只是申明长久层的接口，其余都交给Spring Data JPA来帮你实现

Spring Data JPA同样实现了根本的CRUD办法，如增、删、改、查等。如果有个性化的查问，则须要自定义SQL语句。Spring Data JPA提供了以下几个外围接口：

Repository接口；
CrudRepository接口，继承自Repository；
PagingAndSortingRepository接口，继承自CrudRepository；
JpaRepository接口，继承自PagingAndSortingRepository。

4.2 JPA依赖配置

在Spring Boot中集成Spring Data JPA，首先须要在pom.xml文件中引入所需的依赖，具体代码如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

接下来进行JPA的根本配置，其中次要说一下配置项spring.jpa.hibernate.ddl-auto。它提供了如下几种配置。

validate：在加载hibernate时，验证创立数据库表构造。
create：每次加载hibernate，从新创立数据库表构造，设置时要留神，如果设置谬误的话，就会造成数据的失落。
create-drop：在加载的时候创立表，在敞开我的项目时删除表构造。
update：加载时更新表构造。
none：加载时不做任何操作。

依据具体情况抉择配置即可。

# JPA配置
spring.jpa.database=mysql
spring.jpa.show-sql=true
#validate加载hibernate时，验证创立数据库表构造
spring.jpa.hibernate.ddl-auto=none
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
#懒加载配置
spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true

4.3 JPA接口

JPA最顶级的接口是Repository，而它没有定义任何办法，定义方法的是它的子接口CrudRepository，其定义实体最根本的增删改的操作，功能性还不足够弱小，为此PagingAndSortingRepository则继承了它并且提供了分页和排序的性能，最初JpaRepository扩大了PagingAndSortingRepository，而且扩大了QueryByExampleExecutor接口。一般而言，咱们只须要定义JPA接口扩大JpaRepository便能够取得JPA提供的办法了。如下所示：

public interface BaseSysUserRepository extends JpaRepository<BaseSysUser, String> {

    //...
}

JPA还有很多用法，感兴趣的读者能够参考官网文档：https://docs.spring.io/spring…。

5 集成MyBatis

5.1 MyBatis简介

MyBatis是一款优良的长久层框架，它反对定制化SQL、存储过程以及高级映射。MyBatis防止了简直所有的JDBC代码和手动设置参数以及获取后果集。MyBatis能够应用简略的XML或注解来配置和映射原生信息，将接口和Java的POJOs（Plain Old Java Objects，一般的Java对象）映射成数据库中的记录。反对应用简略的XML文件或注解来配置和映射原生信息，从而将接口和Java的POJO对象映射成数据库中的记录。

5.2 MyBatis依赖配置

Spring Boot也提供了MyBatis的集成模块，即mybatis-spring-boot-starter。在pom文件中退出MyBatis依赖，如下所示：

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>

MyBatis罕用的配置如下所示：

mybatis:
  type-aliases-package: com.fs.orm.entity
  mapper-locations: classpath*:com/fs/orm/mapper/*.xml
  configuration:
    # 开启驼峰命名转换
    map-underscore-to-camel-case: true

5.3 基于XML的应用

创立Mapper对应接口类SysUserMapper，在类上退出注解@Mapper，表明这是一个Mapper。咱们提前定义1个办法：

依据用户名查问用户。

SysUserMapper接口，代码如下所示：

@Mapper
public interface SysUserMapper extends BaseMapper<SysUser> {
    SysUser findList(String userName);    
}

在src/mian/resources/mapper下创立SysUserMapper.xml，对应写好在SysUserMapper接口类的办法，代码如下：

<?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.fs.orm.mapper.SysUserMapper">

    <sql id="where">
        <where>
            <if test="id != null and id != ''">
                and t.id = #{id}
            </if>
            <if test="userName != null and userName != ''">
                and t.user_name = #{userName}
            </if>
        </where>
    </sql>

    <select id="count" resultType="int">
        select count(*) from sys_user t
        <include refid="where" />
    </select>
    
    <select id="findList" resultType="com.fs.orm.entity.SysUser">
        select * from sys_user t
        <include refid="where" />
        order by t.id desc
        <if test="page != null and page >= 0 and limit != null and limit > 0">
            limit #{page},#{limit}
        </if>
    </select>

</mapper>

5.4 基于注解应用

MyBatis不仅能够应用XML模式操作数据库，还能够应用注解模式操作数据库，比方如下注解。

@Select：其中值写查问SQL。
@Update：其中值写批改SQL。
@Delete：其中值写删除SQL。
@Insert：其中值写插入SQL。
@Results：是以@Result为元素的数据。
@Result：映射实体类属性和字段之间的关系。
@ResultMap：用于解决返回后果映射问题，与下面介绍的resultMap标签性能相似。
@Result：能够用作表明自定义对象，不便内容重用。
@SelectProvider：相当于间接应用在类中写好的SQL，将SQL封装到类内，方便管理。type属性表明应用哪个类，method对应应用办法。
@UpdateProvider：性能相似于@SelectProvider。
@DeleteProvider：性能相似于@SelectProvider。
@InsertProvider：性能相似于@SelectProvider。

其实现成果和应用XML模式是一样的，并且两种模式能够混用。如下代码所示：

@Select("select * from sys_user ")
List<SysUser> findAll();

@Select("select * from sys_user s where s.id=#{id} ")
SysUser findById(@Param("id") String id);

6 集成Mybatis-Plus插件

Mybatis-Plus是苞米豆团队开发的一个MyBatis增强型插件，官网上介绍只做加强，不做扭转，为简化开发、提高效率而生。其个性有很多，这里不一一介绍，感兴趣的读者能够在官网上查看，官网地址：https://mp.baomidou.com/。接下来咱们学习Spring Boot如何应用Mybatis-Plus插件。

6.1 Mybatis-Plus依赖配置

在pom文件中退出Mybatis-Plus依赖，如下所示：

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.0</version>
</dependency>

罕用配置如下所示：

mybatis-plus:
  mapper-locations: classpath*:com/fs/orm/mapper/*.xml
  typeAliasesPackage: com.fs.orm.entity
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

还是以用户类作为解说，实体类代码如下：

package com.fs.orm.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;

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

public class SysUser implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value="id",type= IdType.ASSIGN_ID)
    @JsonSerialize(using= ToStringSerializer.class)
    private Long id;

    private String userName;

    private Integer userState;

    private String mobile;

    private String salt;

    private String loginAccount;

    private String loginPwd;

    private String sex;

    private String email;

    private String avatar;

    private String title;

    private String description;

    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date createTime;

    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date updateTime;

    private Integer isDeleted;

    public SysUser() {
    }

   //get set办法 省略
}

mapper层集成mybatis-plus提供的BaseMapper，如下所示：

package com.fs.orm.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.fs.orm.entity.SysUser;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface SysUserMapper extends BaseMapper<SysUser> {
   
}

dao接口集成mybatis-plus提供的IService，代码如下：

package com.fs.orm.dao;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.IService;
import com.fs.orm.entity.SysUser;

import java.util.List;

public interface SysUserDao extends IService<SysUser> {

    boolean addUser(SysUser sysUser);

    boolean logicalDeleteById(String id);

    boolean batchDel(String ids);

    SysUser editUser(SysUser sysUser);

    SysUser selectOne(QueryWrapper qWrapper);

    List<SysUser> getList(QueryWrapper qWrapper);
}

dao接口实现集成了mybatis-plus提供的ServiceImpl并实现SysUserDao接口，代码如下：

package com.fs.orm.dao.Impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.fs.orm.dao.SysUserDao;
import com.fs.orm.entity.SysUser;
import com.fs.orm.mapper.SysUserMapper;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

@Service
public class SysUserDaoImpl extends ServiceImpl<SysUserMapper, SysUser> implements SysUserDao {

    @Override
    public boolean addUser(SysUser sysUser) {
        sysUser.setCreateTime(new Date());
        sysUser.setUpdateTime(new Date());
        return SqlHelper.retBool(baseMapper.insert(sysUser));
    }

    @Override
    public boolean logicalDeleteById(String id) {
        SysUser sysUser = new SysUser();
        sysUser.setIsDeleted(1);
        UpdateWrapper<SysUser> userUpdateWrapper = new UpdateWrapper<>();
        userUpdateWrapper.eq("id", id);
        int update = baseMapper.update(sysUser, userUpdateWrapper);
        return update > 0 ? true : false;
    }

    @Override
    public boolean batchDel(String ids) {
        String [] arr = ids.split(",");
        UpdateWrapper<SysUser> userUpdateWrapper = new UpdateWrapper<>();
        userUpdateWrapper.in("id", arr);
        userUpdateWrapper.set("is_deleted", 1);
        int update = baseMapper.update(null, userUpdateWrapper);
        return update > 0 ? true : false;
    }

    @Override
    public SysUser editUser(SysUser sysUser) {
        UpdateWrapper<SysUser> userUpdateWrapper = new UpdateWrapper<>();
        userUpdateWrapper.eq("id", sysUser.getId());
        userUpdateWrapper.set("user_name", sysUser.getUserName());
        baseMapper.update(sysUser, userUpdateWrapper);
        return sysUser;
    }

    @Override
    public SysUser selectOne(QueryWrapper qWrapper) {
        return baseMapper.selectOne(qWrapper);
    }

    @Override
    public List<SysUser> getList(QueryWrapper qWrapper) {
        return baseMapper.selectList(qWrapper);
    }
}

这里有两点须要阐明一下：

1、这里次要应用了mybatis-plus提供的条件结构器来实现数据库的操作。

2、在mapper层和service层两头又加了一层dao，笔者的用意有两点：第一是对返回后果可能为NULL的状况进行解决，其二是对工夫及其它一些固定操作在这里对立解决，使上游代码调用尽量更简便。

service业务实现层通过调用SysUserDao实现最终的业务数据逻辑解决。代码如下：

package com.fs.base.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.fs.base.service.SysUserService;
import com.fs.core.exception.BizException;
import com.fs.core.exception.BizExceptionEnum;
import com.fs.core.util.BeanUtil;
import com.fs.orm.dao.SysUserDao;
import com.fs.orm.data.XmSelectData;
import com.fs.orm.entity.SysUser;
import com.fs.orm.vo.form.SysUserForm;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
public class SysUserServiceImpl implements SysUserService {

    @Autowired
    private SysUserDao sysUserDao;


    @Override
    public SysUserForm addUser(SysUserForm sysUserForm) throws Exception {
        SysUser sysUser = new SysUser();
        BeanUtil.copyAttribute(sysUserForm, sysUser);
        boolean result;
        try {
            result = sysUserDao.addUser(sysUser);

        }catch (Exception e){
            throw new Exception("sql语法错误!");
        }
        if(!result){
            throw new BizException(BizExceptionEnum.SYS_USER_ADD_ERROR);
        }
        return sysUserForm;
    }

    @Override
    public SysUserForm editUser(SysUserForm sysUserForm) {
        SysUser sysUser = new SysUser();
        BeanUtil.copyAttribute(sysUserForm, sysUser);
        try {
            sysUser = sysUserDao.editUser(sysUser);

        }catch (Exception e){
            // throw new Exception("sql语法错误!");
        }
        return sysUserForm;
    }

    @Override
    public List<SysUser> getAll() {
        QueryWrapper qWrapper = new QueryWrapper();
        qWrapper.eq("is_deleted", 0);
        return sysUserDao.getList(qWrapper);
    }

    @Override
    public PageInfo<SysUser> getLayTable(Map<String, Object> params) {
        PageHelper.startPage(Integer.valueOf(String.valueOf(params.get("page"))),Integer.valueOf(String.valueOf(params.get("limit")))) ;
        QueryWrapper qWrapper = new QueryWrapper();
        if(null != params.get("userName")){
            qWrapper.likeLeft("user_name", String.valueOf(params.get("userName")));
        }
        qWrapper.orderByAsc("id");
        List<SysUser> list = sysUserDao.getList(qWrapper);
        PageInfo<SysUser> userPage =new PageInfo<>(list);
        return userPage;
    }

    @Override
    public SysUserForm initForm() {
        SysUserForm sysUserForm = new SysUserForm();
        sysUserForm.setUserStateList(XmSelectData.getUserState(sysUserForm.getUserState()));
        sysUserForm.setSexList(XmSelectData.getSex(sysUserForm.getSex()));
        return sysUserForm;
    }

    @Override
    public SysUserForm editForm(Long id) {
        SysUser sysUser = sysUserDao.getById(id);
        SysUserForm sysUserForm = new SysUserForm();
        BeanUtil.copyAttribute(sysUser, sysUserForm);
        sysUserForm.setUserStateList(XmSelectData.getUserState(sysUserForm.getUserState()));
        sysUserForm.setSexList(XmSelectData.getSex(sysUserForm.getSex()));
        return sysUserForm;
    }

    @Override
    public boolean logicalDeleteById(String id) {
        return sysUserDao.logicalDeleteById(id);
    }

    @Override
    public boolean batchDel(String ids) {
        return sysUserDao.batchDel(ids);
    }
}

再通过controller层对外公布接口。实现整个数据交互的流程。代码如下：

package com.fs.base.controller;

import com.fs.base.service.SysUserService;
import com.fs.core.web.BaseResult;
import com.fs.orm.entity.SysUser;
import com.fs.orm.vo.form.SysUserForm;
import com.github.pagehelper.PageInfo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.*;

import java.sql.Savepoint;
import java.util.List;
import java.util.Map;

@Api(tags="用户服务接口")
@RestController
@RequestMapping("/baseService/user")
public class SysUserController {

    @Autowired
    private SysUserService sysUserService;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    //新增
    @GetMapping(value="add")
    public Boolean add (String userName, String passWord){
        int result = jdbcTemplate.update(" insert into user (user_name, pass_word) values (?, ?)", userName, passWord);
        return result>0 ? true : false;
    }

    //删除
    @GetMapping(value ="delete")
    public Boolean delete (Integer id){
        int result = jdbcTemplate.update(" delete from user where id=?", id);
        return result>0 ? true : false;
    }


    //批改
    @GetMapping(value ="update")
    public Boolean update (Integer id, String passWord){
        int result = jdbcTemplate.update(" update user set passWord=? where id=?", passWord, id);
        return result>0 ? true : false;
    }

    //查问
    @GetMapping(value ="delete")
    public Map getById (Integer id){
        String sql = "select * from user where id = ?";
        Map map = jdbcTemplate.queryForMap(sql, id);
        return map;
    }

    @ApiOperation(value = "用户列表", notes = "")
    @PostMapping(value ="/layTable")
    public BaseResult<List<SysUser>> getLayTable(@RequestBody Map<String, Object> params) {
        PageInfo<SysUser> pageInfo = sysUserService.getLayTable(params);
        Long count = pageInfo.getTotal();
        return new BaseResult<>(count.intValue(), pageInfo.getList());
    }

    @ApiOperation(value="初始化用户表单")
    @PostMapping("/initForm")
    public BaseResult<SysUserForm> initForm() {
        return new BaseResult<>(sysUserService.initForm());
    }

    @ApiOperation(value="编辑用户表单")
    @PostMapping("/editForm/{id}")
    public BaseResult<SysUserForm> editForm(@PathVariable Long id) {
        return new BaseResult<>(sysUserService.editForm(id));
    }

    @ApiOperation(value = "增加用户", notes = "")
    @PostMapping(value ="/addUser")
    public BaseResult<SysUserForm> addUser(@RequestBody SysUserForm sysUserForm) throws Exception {
        return new BaseResult<>(sysUserService.addUser(sysUserForm));
    }

    @ApiOperation(value = "删除用户", notes = "逻辑删除")
    @PostMapping(value ="/logicalDel/{id}")
    public BaseResult<Boolean> logicalDel(@PathVariable String id)  {
        return new BaseResult<>(sysUserService.logicalDeleteById(id));
    }

    @ApiOperation(value = "批量删除用户", notes = "逻辑删除")
    @PostMapping(value ="/batchDel/{ids}")
    public BaseResult<Boolean> batchDel(@PathVariable String ids)  {
        return new BaseResult<>(sysUserService.batchDel(ids));
    }

    @ApiOperation(value = "编辑用户", notes = "")
    @PostMapping(value ="/editUser")
    public BaseResult<SysUserForm> editUser(@RequestBody SysUserForm sysUserForm) {
        return new BaseResult<>(sysUserService.editUser(sysUserForm));
    }
}

总结

本篇次要对Sring Boot应用关系数据库进行了全面的介绍，从简略的数据库配置到当初特地风行的JPA和MyBatis的应用都进行了详尽的介绍，置信你曾经对操作数据库有了肯定的意识，并且纯熟使用，能够独立进行开发了。

因为篇幅限度，这里只是对操作进行了简略阐明，无关Sring Boot数据库的底层配置和初始化加载原理及非关系型数据库的集成配置将别离独自进行介绍。

关于后端:Spring-Boot数据操作集成

1 前言

2 应用数据库

2.1 应用MySQL

2.2 应用SQL Server

2.3 应用MongoDB

2.4 应用Redis

3 集成JDBC

3.1 JDBC依赖

3.2 JDBC办法

4 集成JPA

4.1 JPA介绍

4.2 JPA依赖配置

4.3 JPA接口

5 集成MyBatis

5.1 MyBatis简介

5.2 MyBatis依赖配置

5.3 基于XML的应用

5.4 基于注解应用

6 集成Mybatis-Plus插件

6.1 Mybatis-Plus依赖配置

总结

最初的最初

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于后端:Spring-Boot数据操作集成

1 前言

2 应用数据库

2.1 应用MySQL

2.2 应用SQL Server

2.3 应用MongoDB

2.4 应用Redis

3 集成JDBC

3.1 JDBC依赖

3.2 JDBC办法

4 集成JPA

4.1 JPA介绍

4.2 JPA依赖配置

4.3 JPA接口

5 集成MyBatis

5.1 MyBatis简介

5.2 MyBatis依赖配置

5.3 基于XML的应用

5.4 基于注解应用

6 集成Mybatis-Plus插件

6.1 Mybatis-Plus依赖配置

总结

最初的最初

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复