Spring Boot 2.x + myBatis全xml实现CRUD及自动建表

2019年11月13日 276次阅读 来源: BlinkAce

之前博主写过一篇介绍《Spring Boot 2.x + myBatis全注解实现CRUD及自动建表》的文章，这次会写基于xml配置的demo。主要支持的功能和之前一样：
（1） 数据库自动建表，如本例中的user表。
（2） 数据库CRUD(create read update delete)操作。
（3） 通过http get操作user表。

就自动建表功能来看，本文实现自动建表功能的方式要相较于之前全注解的方式更加简洁:
（1）首先没有借用第三方的依赖，并且少了很多配置的代码，是直接通过mybatis支持的框架进行的。
（2）再者，本文的实现是将建表功能以xml mapper中的sql语句的方式实现的，理论上与其他的插入，查询，修改，删除的sql mapper的方式并没有什么区别。
（3）最后，由于是通过sql语句实现的，理论上这种实现方式也可以通过sql语句实现很多其他的功能，比如删除数据表等等。

环境准备：
（1） IDEA(建议使用Ultimate版本，会自带通过IDEA操作database的功能)
（2） MySQL
（3） Maven + JDK8

项目目录结构：

+---main
|   +---java
|   |   \---hello
|   |       |   MainApplication.java
|   |       |   
|   |       +---bean
|   |       |       User.java
|   |       |       
|   |       +---controller
|   |       |       UserController.java
|   |       |       
|   |       +---dao
|   |       |       UserDao.java
|   |       |       
|   |       \---service
|   |               UserService.java
|   |               
|   \---resources
|       |   application.properties
|       |   
|       \---mapper
|               UserMapper.xml
|               
pom.xml

数据库和用户表：
默认的使用数据库是MySQL下的sakila，这个可以通过修改application.properties里的配置更改本地数据库名。
user表用的是类似如下语句中创建的：

CREATE TABLE `user` (
    `id` int(13) NOT NULL AUTO_INCREMENT COMMENT '主键',
    `name` varchar(33) DEFAULT NULL COMMENT '姓名',
    `age` int(3) DEFAULT NULL COMMENT '年龄',
    `money` double DEFAULT NULL COMMENT '账户余额',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8

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>MybatisDemo2</groupId>
    <artifactId>MybatisDemo2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
</project>

配置 application.properties，连接本地MySQL数据库，以及xml mapper

server.port=8333
# 数据库为sakila
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/sakila?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 配置映射文件加载
mybatis.mapper-locations=classpath*:mapper/*.xml

User.java

package hello.bean;

public class User {

    private int id;

    private String name;

    private int age;

    private double money;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

UserDao.java
Dao 层开发基于全xml实现数据库CRUD操作

package hello.dao;

import hello.bean.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
 * 基于xml实现数据库 CRUD(create read update delete)
 */
@Mapper
public interface UserDao {


    /**
     * 创建一个新表，如果表明不存在
     */
    void createTable(@Param("tableName")String tableName);

    /**
     * 插入用户信息
     */
    void insertUser(String name, Integer age, Double money);

    /**
     * 通过名字查询用户信息
     */
    List<User> findUserByName(String name);

    /**
     * 查询所有用户信息
     */
    List<User> findAllUser();

    /**
     * 根据 id 更新用户信息
     */
    void updateUser(String name, Integer age, Double money, int id);

    /**
     * 根据 id 删除用户信息
     */
    void deleteUser(String name);

    /**
     * 删除user表里面的所有数据
     */
    void deleteAllUserData();
}

UserService.java
Service层

package hello.service;

import hello.bean.User;
import hello.dao.UserDao;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    /**
     * 如果表不存在则创建表
     */
    public void createTable(String tableName) {
        userDao.createTable(tableName);
    }

    /**
     * 根据名字查找用户
     */
    public List<User> selectUserByName(String name) {
        return userDao.findUserByName(name);
    }

    /**
     * 查找所有用户
     */
    public List<User> selectAllUser() {
        return userDao.findAllUser();
    }

    /**
     * 插入两个用户
     */
    public void insertService() {
        userDao.insertUser("Ace", 22, 3000.0);
        userDao.insertUser("Blink", 19, 3000.0);
    }

    /**
     * 插入某个指定用户
     */
    public void insertOneService(String name, int age, double money) {
        userDao.insertUser(name, age, money);
    }

    /**
     * 通过名字更新用户信息
     */
    @Transactional
    public void updateService(String name, int age, double money) {
        List<User> users = userDao.findUserByName(name);
        if (users.isEmpty()) {
            return;
        }
        List<Integer> ids = users.stream().map(User::getId).collect(Collectors.toList());
        ids.forEach(id -> userDao.updateUser(name, age, money, id));
    }

    /**
     * 根据id 删除用户
     */
    public void deleteService(String name) {
        userDao.deleteUser(name);
    }

    /**
     * 清除表内所有数据
     */
    public void clearService() {
        userDao.deleteAllUserData();
    }

    /**
     * 模拟事务。由于加上了 @Transactional注解，如果转账中途出了意外 Ace 和 Blink 的钱都不会改变。
     */
    @Transactional
    public void changemoney() {
        userDao.updateUser("Ace", 22, 2000.0, 3);
        // 模拟转账过程中可能遇到的意外状况
        int temp = 1 / 0;
        userDao.updateUser("Blink", 19, 4000.0, 4);
    }
}

UserMapper.xml
配置了mapper映射，实现SQL语句操作数据库CRUD操作。这里如果SQL语句中的变量与MySQL保留关键字重复了，可以加单引号如name。这里实现了基于SQL语句进行新建表的mapper方法。理论上，SQL语句是默认用大写单词书写。但是为了阅读方便，这里所有的SQL语句都使用小写编写了。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="hello.dao.UserDao">

    <update id="createTable">
        create table if not exists ${tableName}(
        id int(13) not null auto_increment,
        `name` varchar(33) not null,
        age int(3) not null,
        money double not null,
        primary key (id)) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8
    </update>

<!--这里的name, age 和 money可以自动匹配insertUser(String name, Integer age, Double money)的入参-->
    <insert id="insertUser">
        insert into user(name, age, money) values(#{name}, #{age}, #{money})
    </insert>

    <select id="findUserByName" resultType="hello.bean.User">
        SELECT * FROM user WHERE name = #{name}
    </select>

    <select id="findAllUser" resultType="hello.bean.User">
        select * from user
    </select>

    <update id="updateUser">
        update user set name = #{name}, age = #{age}, money = #{money} where id = #{id}
    </update>

    <delete id="deleteUser">
        delete from user where name = #{name}
    </delete>

    <delete id="deleteAllUserData">
        delete from user where 1 = 1
    </delete>
</mapper>

MainApplication.java
Spring Boot启动类，通过继承CommandLineRunner在Spring Boot启动的时候，在表自动创建完后会在表中插入一些数据。

package hello;

import hello.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 这份demo需要本地安装mySQL,并会在Spring Boot启动的时候自动在sakila数据库下新建一个user的表
 */
@SpringBootApplication
public class MainApplication implements CommandLineRunner {

    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }

    @Autowired
    UserService userService;

    @Override
    public void run(String... args) throws Exception {
        userService.createTable("user");
        userService.insertService();
    }
}

功能演示：
（1）查询query
《Spring Boot 2.x + myBatis全xml实现CRUD及自动建表》
（2）插入数据insert
《Spring Boot 2.x + myBatis全xml实现CRUD及自动建表》
（3）更新数据update
《Spring Boot 2.x + myBatis全xml实现CRUD及自动建表》
（4）删除数据delete
《Spring Boot 2.x + myBatis全xml实现CRUD及自动建表》
截止目前，一个基于Spring Boot 2.x，mySQL和myBatis完成简单的用Web操作数据库的全xml实现demo程序就已经完成啦~

    原文作者：BlinkAce
    原文地址: https://segmentfault.com/a/1190000020983276
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞