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

60次阅读

共计 7107 个字符，预计需要花费 18 分钟才能阅读完成。

之前博主写过一篇介绍《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

（2）插入数据 insert

（3）更新数据 update

（4）删除数据 delete

截止目前，一个基于 Spring Boot 2.x，mySQL 和 myBatis 完成简单的用 Web 操作数据库的全 xml 实现 demo 程序就已经完成啦~

正文完
maven mybatis mysql springboot
发表至： java
2019-11-13
 0
关于java:史诗巨制13万字腾讯高工手写JDK源码笔记-带你飙向实战
关于java:Maven实战与原理分析二maven实战
关于java:git-多个commit-如何合并
关于java:SpringMVC入门点击超链接访问controller报404的填坑之路