乐趣区

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

jiezi

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 数据库的底层配置和初始化加载原理及非关系型数据库的集成配置将别离独自进行介绍。

最初的最初

为初学者提供学习指南，为从业者提供参考价值。我深信码农也具备产生洞见的能力。关注【码农洞见】，一起学习和交换吧！

退出移动版