Spring Boot 集成 MariaDB Connector/J 连接 MySQL

本文介绍 Spring Boot 2 集成 MariaDB Connector/J 驱动连接 MySQL 数据库的方法。

目录

  • MariaDB Connector/J 简介
  • 版本说明
  • 代码示例

MariaDB Connector/J 简介

MariaDB 是一个开源关系型数据库，由 MySQL 的一些原始开发者领导，与 MySQL 保持高度兼容。

尽管 MySQL 官方提供了 MySQL Connector/J 驱动，但是因为使用了 GPL V2.0 协议，导致所有引用此驱动的软件都不得不开源，MariaDB Connector/J 驱动使用的是 LGPL V2.1 开源协议，对商业应用更加友好，因此可以使用 MariaDB Connector/J 替代 MySQL Connector/J 用于连接 MySQL 数据库。

版本说明

  • JDK 8
  • MySQL 8.x
  • MariaDB Connector/J 2.6.0

代码示例

  1. 创建存储用户信息的数据表。
CREATE TABLE `user` (
    `id`    BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    `name`  VARCHAR(16)     NOT NULL COMMENT '姓名',
    `age`   INT UNSIGNED    NOT NULL COMMENT '年龄',
    `email` VARCHAR(32)     NOT NULL DEFAULT '' COMMENT '电子邮箱',
    PRIMARY KEY (`id`),
    UNIQUE INDEX `uk_name` (`name` ASC)
) COMMENT='用户信息';

  1. 创建 Spring Boot 工程，参考：IntelliJ IDEA 创建 Spring Boot 工程。

  2. 在生成的 pom 文件中添加 spring-boot-starter-jdbc 和 mariadb-java-client 依赖。

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.7.RELEASE</version>
        <relativePath/>
    </parent>
    <groupId>tutorial.spring.boot</groupId>
    <artifactId>spring-boot-mysql-mariadb-driver</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-mysql-mariadb-driver</name>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mariadb.jdbc</groupId>
            <artifactId>mariadb-java-client</artifactId>
            <version>2.6.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

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

</project>
  1. 在 application.yml 中添加数据源配置。
spring:
  datasource:
    driver-class-name: org.mariadb.jdbc.Driver
    username: root
    password: 123456
    url: jdbc:mysql://127.0.0.1:3306/test?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8&useSSL=false
  1. 编写映射数据表的领域模型类。
package tutorial.spring.boot.mysql.domain;

import java.util.Objects;

public class User {

    /**
     * 数据库表 user 列名
     */
    public static class ColumnConstant {

        public static final String ID = "id";

        public static final String NAME = "name";

        public static final String AGE = "age";

        public static final String EMAIL = "email";
    }

    private Long id;

    private String name;

    private Integer age;

    private String email;

    public User(String name, Integer age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    // Getter and Setter 略

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        User user = (User) o;
        if (!Objects.equals(name, user.name)) {
            return false;
        }
        if (!Objects.equals(age, user.age)) {
            return false;
        }
        return Objects.equals(email, user.email);
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (age != null ? age.hashCode() : 0);
        result = 31 * result + (email != null ? email.hashCode() : 0);
        return result;
    }

    // toString 略
}
  1. 编写 DAO（Data Access Object）层接口。
package tutorial.spring.boot.mysql.dao;

import tutorial.spring.boot.mysql.domain.User;

import java.sql.SQLException;
import java.util.List;

public interface UserDao {

    /**
     * 查询用户总数
     *
     * @return 记录总数
     */
    int count() throws SQLException;

    /**
     * 根据 ID 删除用户
     *
     * @param id 用户ID，对应主键
     * @return 删除记录数目
     */
    int delete(long id);

    /**
     * 新增用户
     *
     * @param user 封装用户信息的User对象
     * @return 插入记录主键
     */
    long insert(User user) throws SQLException;

    /**
     * 批量新增用户
     *
     * @return 新增记录总数
     */
    int insertBatch(List<User> users);

    /**
     * 根据 ID 查询用户
     *
     * @param id 用户ID，对应主键
     * @return 查询到的用户记录，如无对应记录则返回 null
     */
    User select(long id);

    /**
     * 查询全部用户
     *
     * @return 封装用户信息的User对象列表
     */
    List<User> selectAll();

    /**
     * 更新用户
     *
     * @param user 封装用户信息的User对象
     * @return 更新记录数
     */
    int update(User user);
}
  1. 编写 DAO（Data Access Object）层实现。
package tutorial.spring.boot.mysql.dao.impl;

import org.springframework.jdbc.core.JdbcOperations;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Repository;
import tutorial.spring.boot.mysql.dao.UserDao;
import tutorial.spring.boot.mysql.domain.User;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

@Repository
public class UserDaoImpl implements UserDao {

    private final JdbcOperations jdbcOperations;

    public UserDaoImpl(JdbcOperations jdbcOperations) {
        this.jdbcOperations = jdbcOperations;
    }

    @Override
    public int count() throws SQLException {
        String sql = "SELECT COUNT(*) FROM user";
        Integer count = jdbcOperations.queryForObject(sql, Integer.class);
        if (Objects.isNull(count)) {
            throw new SQLException();
        }
        return count;
    }

    @Override
    public int delete(long id) {
        String sql = "DELETE FROM user WHERE id=?";
        return jdbcOperations.update(sql, id);
    }

    @Override
    public long insert(User user) throws SQLException {
        if (Objects.isNull(user)) {
            throw new IllegalArgumentException("Param[user] is null!");
        }
        final String sql = "INSERT INTO user ("
                + User.ColumnConstant.NAME + ", "
                + User.ColumnConstant.AGE + ", "
                + User.ColumnConstant.EMAIL + ") VALUES (?, ?, ?)";
        KeyHolder keyHolder = new GeneratedKeyHolder();
        jdbcOperations.update(connection -> {
            PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            preparedStatement.setString(1, Objects.isNull(user.getName()) ? "Anonymous User" : user.getName());
            preparedStatement.setInt(2, Objects.isNull(user.getAge()) ? -1 : user.getAge());
            preparedStatement.setString(3, Objects.isNull(user.getEmail()) ? "" : user.getEmail());
            return preparedStatement;
        }, keyHolder);
        if (Objects.isNull(keyHolder.getKey())) {
            throw new SQLException();
        }
        return keyHolder.getKey().longValue();
    }

    @Override
    public int insertBatch(List<User> users) {
        List<Object[]> params = users.stream().map(user -> new Object[]{
                user.getName(),
                user.getAge(),
                user.getEmail()
        }).collect(Collectors.toList());
        final String sql = "INSERT INTO user ("
                + User.ColumnConstant.NAME + ", "
                + User.ColumnConstant.AGE + ", "
                + User.ColumnConstant.EMAIL + ") VALUES (?, ?, ?)";
        int[] result = jdbcOperations.batchUpdate(sql, params);
        return Arrays.stream(result).sum();
    }

    @Override
    public User select(long id) {
        String sql = "SELECT "
                + User.ColumnConstant.ID + ", "
                + User.ColumnConstant.NAME + ", "
                + User.ColumnConstant.AGE + ", "
                + User.ColumnConstant.EMAIL
                + " FROM user WHERE id=?";
        List<User> users = jdbcOperations.query(sql, this::mapResultSetToUser, id);
        return users.size() == 0 ? null : users.get(0);
    }

    private User mapResultSetToUser(ResultSet resultSet, int rowNum)
            throws SQLException {
        User user = new User(resultSet.getString(User.ColumnConstant.NAME),
                resultSet.getInt(User.ColumnConstant.AGE),
                resultSet.getString(User.ColumnConstant.EMAIL));
        user.setId(resultSet.getLong(User.ColumnConstant.ID));
        return user;
    }

    @Override
    public List<User> selectAll() {
        String sql = "SELECT "
                + User.ColumnConstant.ID + ", "
                + User.ColumnConstant.NAME + ", "
                + User.ColumnConstant.AGE + ", "
                + User.ColumnConstant.EMAIL
                + " FROM user";
        return jdbcOperations.query(sql, this::mapResultSetToUser);
    }

    @Override
    public int update(User user) {
        if (Objects.isNull(user)) {
            throw new IllegalArgumentException("Param[user] is null!");
        }
        if (Objects.isNull(user.getId())) {
            throw new IllegalArgumentException("The [id] attribute in param[user] is null!");
        }
        String sql = "UPDATE user SET name=?, age=?, email=? WHERE id=?";
        return jdbcOperations.update(sql,
                Objects.isNull(user.getName()) ? "Anonymous User" : user.getName(),
                Objects.isNull(user.getAge()) ? -1 : user.getAge(),
                Objects.isNull(user.getEmail()) ? "" : user.getEmail(),
                user.getId()
        );
    }
}
  1. 基于 JUnit 5 和 Spring Boot 测试框架编写单元测试。
package tutorial.spring.boot.mysql.dao;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
import tutorial.spring.boot.mysql.domain.User;

import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;

@SpringBootTest
@Transactional(rollbackFor = Exception.class)
public class UserDaoTest {

    @Autowired
    private UserDao userDao;

    @Test
    @Order(1)
    public void testNotNull() {
        Assertions.assertThat(userDao).isNotNull();
    }

    @Test
    @Order(2)
    public void testCount() throws SQLException {
        Assertions.assertThat(userDao.count()).isEqualTo(0);
        userDao.insert(new User("Tom", 32, "tom@zzz.org"));
        userDao.insert(new User("Lily", 16, "lily@zzz.org"));
        userDao.insert(new User("James", 28, "james@zzz.org"));
        Assertions.assertThat(userDao.count()).isEqualTo(3);
    }

    @Test
    @Order(3)
    public void testDelete() throws SQLException {
        long id = userDao.insert(new User("Harry", 12, "harry@magic.com"));
        Assertions.assertThat(userDao.delete(id)).isEqualTo(1);
    }

    @Test
    @Order(4)
    public void testInsert() throws SQLException {
        int count = userDao.count();
        User user = new User("Jack", 18, "jack@xxx.com");
        long id = userDao.insert(user);
        Assertions.assertThat(id).isGreaterThan(0);
        Assertions.assertThat(userDao.count()).isEqualTo(count + 1);
        User result = userDao.select(id);
        Assertions.assertThat(result).isEqualTo(user);
    }

    @Test
    @Order(5)
    public void testInsertBatch() {
        List<User> users = Arrays.asList(new User("Tom", 32, "tom@zzz.org"),
                new User("Lily", 16, "lily@zzz.org"),
                new User("James", 28, "james@zzz.org"),
                new User("Jack", 18, "jack@xxx.com"));
        Assertions.assertThat(userDao.insertBatch(users)).isEqualTo(4);
        List<User> allUsers = userDao.selectAll();
        users.forEach(user -> Assertions.assertThat(allUsers.contains(user)).isTrue());
    }

    @Test
    @Order(6)
    public void testSelect() throws SQLException {
        User user = new User("Lily", 16, "lily@zzz.org");
        long id = userDao.insert(user);
        User result = userDao.select(id);
        Assertions.assertThat(result).isNotNull();
        Assertions.assertThat(result).isEqualTo(user);
    }

    @Test
    @Order(7)
    public void testSelectAll() throws SQLException {
        int count = userDao.count();
        List<User> users = Arrays.asList(new User("Tom", 32, "tom@zzz.org"),
                new User("Lily", 16, "lily@zzz.org"),
                new User("James", 28, "james@zzz.org"),
                new User("Jack", 18, "jack@xxx.com"),
                new User("Harry", 12, "harry@magic.com"));
        Assertions.assertThat(userDao.insertBatch(users)).isEqualTo(5);
        List<User> allUsers = userDao.selectAll();
        Assertions.assertThat(allUsers.size()).isGreaterThan(0);
        Assertions.assertThat(userDao.count()).isEqualTo(count + 5);
        users.forEach(user -> Assertions.assertThat(allUsers.contains(user)).isTrue());
    }

    @Test
    @Order(8)
    public void testUpdate() throws SQLException {
        User user = new User("Jack", 18, "jack@xxx.com");
        long id = userDao.insert(user);
        user.setId(id);
        User result1 = userDao.select(id);
        Assertions.assertThat(result1).isEqualTo(user);
        user.setName("Changed");
        user.setAge(19);
        user.setEmail("unknown@yyy.com");
        Assertions.assertThat(userDao.update(user)).isEqualTo(1);
        User result2 = userDao.select(id);
        Assertions.assertThat(result2).isNotEqualTo(result1);
        Assertions.assertThat(result2).isEqualTo(user);
    }
}

执行过程略。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 157,012评论 4赞 359
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 66,589评论 1赞 290
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 106,819评论 0赞 237
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,652评论 0赞 202
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 51,954评论 3赞 285
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,381评论 1赞 210
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,687评论 2赞 310
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,404评论 0赞 194
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,082评论 1赞 238
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,355评论 2赞 241
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,880评论 1赞 255
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,249评论 2赞 250
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 32,864评论 3赞 232
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,007评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,760评论 0赞 192
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,394评论 2赞 269
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,281评论 2赞 259