Java 使用 JDBI 库访问MySQL 数据库

不念不忘少年蓝@ 2023-09-27 10:16 137阅读 0赞

在本教程中，我们将展示如何使用 JDBI 处理数据。我们选择 MySQL 作为我们的数据库。

JDBI是一个建立在 JDBC 之上的便利库。它使数据库编程变得更加容易。它管理异常。它具有用于自动资源管理和将结果集映射到类的工具。JDBI 在概念上类似于 Spring 的`JdbcTemplate。`

实例通过`DBI`实例提供与数据库的连接`Handle`。 `Handle`表示与数据库系统的连接；它是 JDBC Connection 对象的包装器。

JDBI 提供了两种不同的风格 API：流式风格和对象风格。

### 在 MySQL 中创建数据库 ###

在本节中，我们`testdb`在 MySQL 中创建一个新数据库。我们使用`mysql`监视器来完成这项工作，但我们也可以使用 NetBeans 数据库工具。

cars\_mysql.sql

DROP TABLE IF EXISTS Cars;
    CREATE TABLE Cars(Id INT PRIMARY KEY AUTO_INCREMENT, 
                      Name TEXT, Price INT) ENGINE=InnoDB;
                      
    INSERT INTO Cars(Name, Price) VALUES('Audi', 52642);
    INSERT INTO Cars(Name, Price) VALUES('Mercedes', 57127);
    INSERT INTO Cars(Name, Price) VALUES('Skoda', 9000);
    INSERT INTO Cars(Name, Price) VALUES('Volvo', 29000);
    INSERT INTO Cars(Name, Price) VALUES('Bentley', 350000);
    INSERT INTO Cars(Name, Price) VALUES('Citroen', 21000);
    INSERT INTO Cars(Name, Price) VALUES('Hummer', 41400);
    INSERT INTO Cars(Name, Price) VALUES('Volkswagen', 21600);

这是在 MySQL 中创建`Cars`表的 SQL。

要创建数据库和表，我们使用`mysql` 监控工具。

$ sudo service mysql start

MySQL 是用`sudo service mysql start`命令启动的。

$ mysql -u testuser -p

`mysql`我们使用监视器 连接到数据库。

mysql> CREATE DATABASE testdb;
    Query OK, 1 row affected (0.02 sec)

使用该`CREATE DATABASE`语句，将创建一个新数据库。

mysql> USE testdb;
    mysql> SOURCE cars_mysql.sql

使用`source`命令，我们加载并执行`cars_mysql.sql` 文件。

mysql> SELECT * FROM Cars;
    +----+------------+--------+
    | Id | Name       | Price  |
    +----+------------+--------+
    |  1 | Audi       |  52642 |
    |  2 | Mercedes   |  57127 |
    |  3 | Skoda      |   9000 |
    |  4 | Volvo      |  29000 |
    |  5 | Bentley    | 350000 |
    |  6 | Citroen    |  21000 |
    |  7 | Hummer     |  41400 |
    |  8 | Volkswagen |  21600 |
    +----+------------+--------+
    8 rows in set (0.00 sec)

我们验证数据。

### pom.xml 文件 ###

这些示例将使用以下 Maven POM 文件：

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>com.zetcode</groupId>
        <artifactId>JDBIEx</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>jar</packaging>
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.jdbi</groupId>
                <artifactId>jdbi</artifactId>
                <version>2.73</version>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.39</version>
            </dependency>
            
        </dependencies>    
        
    </project>

我们已经为 JDBI 库和 MySQL 驱动程序定义了依赖关系。

### 流畅的 API ###

在以下示例中，我们将使用 JDBI Fluent API 来处理 MySQL 数据库。

#### 检索所有汽车 ####

在第一个示例中，我们从`Cars`表中获取所有汽车。

JDBIEx.java

package com.zetcode;
    
    import java.util.List;
    import java.util.Map;
    import org.skife.jdbi.v2.DBI;
    import org.skife.jdbi.v2.Handle;
    import org.skife.jdbi.v2.Query;
    
    public class JDBIEx {
    
        public static void main(String[] args) {
    
            Handle handle = null;
            DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
                    "testuser", "test623");
            
            String sql = "SELECT * FROM Cars";
    
            try {
    
                handle = dbi.open();
                Query<Map<String, Object>> q = handle.createQuery(sql);
                List<Map<String, Object>> l = q.list();
    
                for (Map<String, Object> m : l) {
                
                    System.out.printf("%d ", m.get("Id"));
                    System.out.printf("%s ", m.get("Name"));
                    System.out.println(m.get("Price"));
                }
    
            } finally {
                if (handle != null) {
                    handle.close();
                }
            }
        }
    }

该示例连接到`testdb`数据库并从`Cars`表中检索所有汽车。

DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
            "testuser", "test623");

`DBI`使用该类 为数据库创建一个访问点。

handle = dbi.open();

使用`Handle`该`DBI's` `open()`方法创建数据库。它表示与数据库的连接。与数据库的连接是使用`DriverManager`.

Query<Map<String, Object>> q = handle.createQuery(sql);

使用该方法创建一个`Query`对象`createQuery()`。

List<Map<String, Object>> l = q.list();

从查询对象中，我们得到一个键/值对列表。

for (Map<String, Object> m : l) {
    
        System.out.printf("%d ", m.get("Id"));
        System.out.printf("%s ", m.get("Name"));
        System.out.println(m.get("Price"));
    }

我们遍历列表并打印所有列。

} finally {
        if (handle != null) {
            handle.close();
        }
    }

最后，我们关闭手柄。

1 Audi 52642
    2 Mercedes 57127
    3 Skoda 9000
    4 Volvo 29000
    5 Bentley 350000
    6 Citroen 21000
    7 Hummer 41400
    8 Volkswagen 21600

这是示例的输出。

#### 通过 ID 检索汽车 ####

在下一个示例中，我们`Cars` 通过 ID 从表中获取汽车名称。

JDBIEx2.java

package com.zetcode;
    
    import java.util.Map;
    import org.skife.jdbi.v2.DBI;
    import org.skife.jdbi.v2.Handle;
    import org.skife.jdbi.v2.Query;
    import org.skife.jdbi.v2.util.StringColumnMapper;
    
    public class JDBIEx2 {
    
        public static void main(String[] args) {
    
            Handle handle = null;
            DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
                    "testuser", "test623");
    
            try {
    
                handle = dbi.open();
                
                String sql = "SELECT Name FROM Cars WHERE Id = ?";
                
                Query<Map<String, Object>> q = handle.createQuery(sql);
                q.bind(0, 1);
                
                String carName = q.map(StringColumnMapper.INSTANCE).first();
                
                System.out.println(carName);
    
            } finally {
            
                if (handle != null) {
                    handle.close();
                }
            }
        }
    }

在示例中，我们从`Cars`表中选择汽车名称。SQL 查询采用稍后绑定的参数。

String sql = "SELECT Name FROM Cars WHERE Id = ?";

这是用于从表中选择汽车名称的 SQL 代码。问号是稍后在代码中填写的标记。

Query<Map<String, Object>> q = handle.createQuery(sql);

`Query`从 SQL 语句创建 一个新对象。

q.bind(0, 1);

使用该`bind()`方法，我们绑定缺少的参数。该参数是按位置绑定的。

String carName = q.map(StringColumnMapper.INSTANCE).first();

我们将结果集的一列映射`StringColumnMapper` 到字符串类型。该`first()`方法用于返回一个值。

System.out.println(carName);

汽车的名称打印在控制台上。

#### 数据源 ####

在此示例中，我们使用数据源连接到数据库。数据源的使用提高了应用程序的性能和可伸缩性。

db.properties

# mysql properties
    mysql.driver=com.mysql.jdbc.Driver
    mysql.url=jdbc:mysql://localhost:3306/testdb
    mysql.username=testuser
    mysql.password=test623

在`db.properties`文件中，我们有连接属性。

![eb94f3b2db8ac8c4027107bb982971d9.png][]

图：数据库属性

该文件被放置在项目的`Resources`目录中。

JDBIEx3.java

package com.zetcode;
    
    import com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource;
    import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.util.Map;
    import java.util.Properties;
    import org.skife.jdbi.v2.DBI;
    import org.skife.jdbi.v2.Handle;
    import org.skife.jdbi.v2.Query;
    import org.skife.jdbi.v2.util.IntegerColumnMapper;
    
    public class JDBIEx3 {
    
        public static MysqlDataSource getMySQLDataSource() throws 
                FileNotFoundException, IOException {
            
            Properties props = new Properties();
            FileInputStream fis = null;
            MysqlDataSource ds = null;
    
            fis = new FileInputStream("src/main/Resources/db.properties");
            props.load(fis);
            
            ds = new MysqlConnectionPoolDataSource();
            ds.setURL(props.getProperty("mysql.url"));
            ds.setUser(props.getProperty("mysql.username"));
            ds.setPassword(props.getProperty("mysql.password"));
    
            return ds;
        }
    
        public static void main(String[] args) throws IOException {
    
            Handle handle = null;
            MysqlDataSource ds = getMySQLDataSource();
    
            DBI dbi = new DBI(ds);
    
            try {
    
                handle = dbi.open();
    
                String sql = "SELECT Price FROM Cars WHERE Id = ?";
    
                Query<Map<String, Object>> q = handle.createQuery(sql);
                q.bind(0, 1);
    
                Integer price = q.map(IntegerColumnMapper.WRAPPER).first();
    
                System.out.println(price);
    
            } finally {
                if (handle != null) {
                    handle.close();
                }
            }
        }
    }

该示例选择通过 ID 找到的汽车的价格。

fis = new FileInputStream("src/main/Resources/db.properties");
    props.load(fis);

我们从`Resources`目录加载属性。

ds = new MysqlConnectionPoolDataSource();
    ds.setURL(props.getProperty("mysql.url"));
    ds.setUser(props.getProperty("mysql.username"));
    ds.setPassword(props.getProperty("mysql.password"));

`MysqlConnectionPoolDataSource`已创建。我们从属性文件中设置参数。

Integer price = q.map(IntegerColumnMapper.WRAPPER).first();

由于 SQL 查询返回一个整数，因此我们使用`IntegerColumnMapper`该类。

#### withHandle() 方法 ####

该类`DBI`有一个名为 的便捷方法`withHandle()`，它管理句柄的生命周期并将其交给回调以供客户端使用。

JDBIEx4.java

package com.zetcode;
    
    import org.skife.jdbi.v2.DBI;
    import org.skife.jdbi.v2.Handle;
    import org.skife.jdbi.v2.util.IntegerColumnMapper;
    
    public class JDBIEx4 {
    
        public static void main(String[] args) {
    
            DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
                    "testuser", "test623");
            String sql = "SELECT Price FROM Cars WHERE Id = :id";
            int id = 3;
    
            Integer price = dbi.withHandle((Handle h) -> {
    
                return h.createQuery(sql)
                        .map(IntegerColumnMapper.WRAPPER)
                        .bind("id", id) 
                        .first(); 
            });
            
            System.out.println(price);
        }
    }

该示例选择由 ID 标识的汽车价格。

String sql = "SELECT Price FROM Cars WHERE Id = :id";

此 SQL 查询使用命名参数。

Integer price = dbi.withHandle((Handle h) -> {
    
        return h.createQuery(sql)
                .map(IntegerColumnMapper.WRAPPER)
                .bind("id", id) 
                .first(); 
    });

创建并执行查询，我们不必担心关闭句柄。

#### 映射自定义类 ####

可以将自定义类映射到结果集。映射类必须实现`ResultSetMapper<T>`接口。

Car.java

package com.zetcode;
    
    public class Car {
        
        private Long Id;
        private String Name;
        private int Price;
    
        public Car(Long Id, String Name, int Price) {
            this.Id = Id;
            this.Name = Name;
            this.Price = Price;
        }
    
        public Long getId() {
            return Id;
        }
    
        public void setId(Long Id) {
            this.Id = Id;
        }
    
        public String getName() {
            return Name;
        }
    
        public void setName(String Name) {
            this.Name = Name;
        }
    
        public int getPrice() {
            return Price;
        }
    
        public void setPrice(int Price) {
            this.Price = Price;
        }
    
        @Override
        public String toString() {
            return "Car{" + "Id=" + Id + ", Name=" + Name + ", Price=" + Price + '}';
        }
    }

这是`Car`我们要将结果集映射到的自定义类。

CarMapper.java

package com.zetcode;
    
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import org.skife.jdbi.v2.StatementContext;
    import org.skife.jdbi.v2.tweak.ResultSetMapper;
    
    
    public class CarMapper implements ResultSetMapper<Car> {
       
        @Override
        public Car map(int idx, ResultSet rs, StatementContext ctx) throws SQLException {
            return new Car(rs.getLong("Id"), rs.getString("Name"), rs.getInt("Price"));
        }
    }

我们提供映射类。它返回一个`Car`填充了结果集中数据的新对象。

JDBIEx5.java

package com.zetcode;
    
    import org.skife.jdbi.v2.DBI;
    import org.skife.jdbi.v2.Handle;
    
    public class JDBIEx5 {
    
        public static void main(String[] args) {
    
            DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
                    "testuser", "test623");
                    
            String sql = "SELECT * FROM Cars WHERE Id = :id";
            int id = 3;
    
            Car car = dbi.withHandle((Handle h) -> {
    
                return h.createQuery(sql)
                        .map(new CarMapper())
                        .bind("id", id) 
                        .first(); 
            });
                    
            System.out.println(car);
        }
    }

该示例`Car`从由其 ID 标识的表中选择一个对象。

Car car = dbi.withHandle((Handle h) -> {
    
        return h.createQuery(sql)
                .map(new CarMapper())
                .bind("id", id) 
                .first(); 
    });

自定义`CarMapper`对象被传递给该`map()` 方法。

#### 批量操作 ####

批处理允许我们将相关的 SQL 语句分组到一个批处理中，并通过一次调用数据库来提交它们。这可以显着提高我们应用程序的性能。

批处理操作不是原子的；他们没有提供全有或全无的解决方案。例如，如果我们创建了不正确的 INSERT 语句，它会失败，但会执行其他 INSERT 语句。

JDBIEx6.java

package com.zetcode;
    
    import org.skife.jdbi.v2.Batch;
    import org.skife.jdbi.v2.DBI;
    import org.skife.jdbi.v2.Handle;
    
    public class JDBIEx6 {
    
        public static void main(String[] args) {
    
            DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
                    "testuser", "test623");
    
            Handle handle = dbi.open();
            Batch batch = handle.createBatch();
    
            batch.add("DROP TABLE IF EXISTS Friends");
            batch.add("CREATE TABLE Friends(Id INT AUTO_INCREMENT PRIMARY KEY, Name TEXT)");
            batch.add("INSERT INTO Friends(Name) VALUES ('Monika')");
            batch.add("INSERT INTO Friends(Name) VALUES ('Tom')");
            batch.add("INSERT INTO Friends(Name) VALUES ('Jane')");
            batch.add("INSERT INTO Friends(Name) VALUES ('Robert')");
    
            batch.execute();
        }
    }

该示例创建一个新`Friends`表。SQL 命令被分组为一个批处理操作。

Batch batch = handle.createBatch();

`Batch`代表一组未准备好的语句；它是使用该`createBatch()`方法创建的。

batch.add("DROP TABLE IF EXISTS Friends");

该`add()`方法将语句添加到批处理中。

batch.execute();

使用该`execute()`方法执行批处理。

#### 事务 ####

事务是针对 一个或多个数据库中的数据的数据库操作的原子单元。事务中所有 SQL 语句的影响可以全部提交给数据库，也可以全部回滚。

另请注意，在 MySQL 中，DROP TABLE 和 CREATE TABLE 等 DDL 语句会导致对事务的隐式提交。

JDBIEx7.java

package com.zetcode;
    
    import org.skife.jdbi.v2.Batch;
    import org.skife.jdbi.v2.DBI;
    import org.skife.jdbi.v2.Handle;
    import org.skife.jdbi.v2.TransactionStatus;
    import org.skife.jdbi.v2.VoidTransactionCallback;
    
    public class JDBIEx7 {
    
        public static void main(String[] args) {
    
            DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
                    "testuser", "test623");
    
            dbi.inTransaction(new VoidTransactionCallback() {
                @Override
                protected void execute(Handle handle, TransactionStatus status)
                        throws Exception {
    
                    Batch batch = handle.createBatch();
                    
                    batch.add("DROP TABLE IF EXISTS Friends");
                    batch.add("CREATE TABLE Friends(Id INT AUTO_INCREMENT PRIMARY KEY, Name TEXT)");
                    batch.add("INSERT INTO Friends(Name) VALUES ('Monika')");
                    batch.add("INSERT INTO Friends(Name) VALUES ('Tom')");
                    batch.add("INSERT INTO Friends(Name) VALUES ('Jane')");
                    batch.add("INSERT INTO Friends(Name) VALUES ('Robert')");
                    
                    batch.execute();
                }
            });
        }
    }

该示例将批处理操作置于事务中。由于 MYSQL 中 DDL 语句的隐式提交，只有 INSERT 语句处于全有或全无模式。

dbi.inTransaction(new VoidTransactionCallback() {
        @Override
        protected void execute(Handle handle, TransactionStatus status)
                throws Exception {
    
            ...
        }
    });

使用该`inTransaction()`方法创建事务。这`VoidTransactionCallback` 是一个不返回值的事务回调。

### SQL 对象 API ###

SQL 对象 API 为常见的 JDBI 操作提供了一种声明机制。要使用 SQL 对象 API，我们创建一个带有注释的接口或抽象类，例如`@SqlQuery`或`@SqlUpdate`。

#### 简单的例子 ####

我们创建一个示例，我们将在其中使用 SQL 对象 API 创建简单查询。

<dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.8</version>
    </dependency>

在示例中，我们还使用了`lombok`库，它减少了一些样板代码。

Car.java

package com.zetcode;
    
    import lombok.Data;
    
    @Data 
    public class Car {
        
        private final Long Id;
        private final String Name;
        private final int Price;
    }

该类`Car`使用 lombok 的`@Data` 注释进行装饰。它将自动创建 getter 和 setter 方法、 `equals()`方法、`toString()`方法、 `hashCode()`方法和参数构造函数。

CarMapper.java

package com.zetcode;
    
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import org.skife.jdbi.v2.StatementContext;
    import org.skife.jdbi.v2.tweak.ResultSetMapper;
    
    public class CarMapper implements ResultSetMapper<Car> {
       
        @Override
        public Car map(int idx, ResultSet rs, StatementContext ctx) throws SQLException {
            return new Car(rs.getLong("Id"), rs.getString("Name"), rs.getInt("Price"));
        }
    }

将`CarMapper`结果集映射到`Car`类。

MyDAO.java

package com.zetcode;
    
    import org.skife.jdbi.v2.sqlobject.Bind;
    import org.skife.jdbi.v2.sqlobject.SqlQuery;
    import org.skife.jdbi.v2.sqlobject.customizers.Mapper;
    
    public interface MyDAO {
    
        @SqlQuery("SELECT * FROM Cars WHERE Id = :id")
        @Mapper(CarMapper.class)
        Car findById(@Bind("id") int id);
    
        @SqlQuery("SELECT COUNT(Id) FROM Cars")
        int countCars();
    }

这里我们有一个`MyDAO`装饰有两个 `@SqlQuery`注解的界面。这些方法通过 ID 查找汽车并计算表中的所有汽车。

@SqlQuery("SELECT * FROM Cars WHERE Id = :id")

`@SqlQuery`注解表示该方法执行指定的查询 。

@Mapper(CarMapper.class)

`@Mapper`指定查询方法上的结果集映射器 。

Car findById(@Bind("id") int id);

注释将`@Bind`方法的参数绑定到 SQL 查询参数。

JDBIEx8.java

package com.zetcode;
    
    import org.skife.jdbi.v2.DBI;
    
    public class JDBIEx8 {
    
        public static void main(String[] args) {
    
            DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
                    "testuser", "test623");
            
            int id = 3;
            
            MyDAO dao = dbi.onDemand(MyDAO.class);
            Car car = dao.findById(id);
    
            System.out.println(car);
            
            int nCars = dao.countCars();
            
            System.out.printf("There are %d cars in the table", nCars);
        }
    }

在此客户端应用程序中，我们找到 ID 等于 3 的汽车，并计算表中的所有汽车。

MyDAO dao = dbi.onDemand(MyDAO.class);

该`onDemand()`方法创建一个新的 sql 对象，该对象将根据需要和可以分别从该 dbi 实例获取和释放连接。我们不应该显式关闭这个 sql 对象。

Car car = dao.findById(id);

我们得到一辆具有指定 ID 的汽车。

int nCars = dao.countCars();

我们计算数据库表中的汽车数量。

#### 事务 ####

在 SQL Object API 中，我们可以使用`@Transaction`注解来创建事务。

authors\_books.sql

CREATE TABLE IF NOT EXISTS Authors(Id BIGINT PRIMARY KEY AUTO_INCREMENT, 
        Name VARCHAR(25)) ENGINE=InnoDB;
    
    CREATE TABLE IF NOT EXISTS Books(Id BIGINT PRIMARY KEY AUTO_INCREMENT, 
        AuthorId BIGINT, Title VARCHAR(100), 
        FOREIGN KEY(AuthorId) REFERENCES Authors(Id) ON DELETE CASCADE)
        ENGINE=InnoDB;

对于此示例，我们创建两个表：`Authors`和`Books`.

MyDAO.java

package com.zetcode;
    
    import java.util.List;
    import org.skife.jdbi.v2.exceptions.TransactionFailedException;
    import org.skife.jdbi.v2.sqlobject.Bind;
    import org.skife.jdbi.v2.sqlobject.SqlQuery;
    import org.skife.jdbi.v2.sqlobject.SqlUpdate;
    import org.skife.jdbi.v2.sqlobject.Transaction;
    
    public abstract class MyDAO {
    
        @SqlUpdate("INSERT INTO Authors(Name) VALUES(:author)")
        public abstract void createAuthor(@Bind("author") String author);
       
        @SqlQuery("SELECT Id FROM Authors WHERE Name = :name")
        abstract long getAuthorId(@Bind("name") String name);        
            
        @SqlUpdate("INSERT INTO Books(AuthorId, Title) VALUES(:authorId, :title)")
        abstract void insertBook(@Bind("authorId") Long authorId, @Bind("title") String title);
        
        @Transaction
        public void insertBooksForAuthor(String author, List<String> titles) {
            
            Long authorId = getAuthorId(author);
            
            if (authorId == null) {
                throw new TransactionFailedException("No author found");
            }
            
            for (String title : titles) {
                
                insertBook(authorId, title);
            }
        }
    }

我们有一个抽象`MyDAO`类，我们在其中使用`@SqlUpdate`、`@SqlQuery`和`@Transaction`注释。

@SqlUpdate("INSERT INTO Authors(Name) VALUES(:author)")
    public abstract void createAuthor(@Bind("author") String author);

此方法添加了一个新作者。

@SqlQuery("SELECT Id FROM Authors WHERE Name = :name")
    abstract long getAuthorId(@Bind("name") String name);

`getAuthorId()`用于获取作者的 ID 。`Books`当我们向表中 插入新书时，需要该 ID 。

@SqlUpdate("INSERT INTO Books(AuthorId, Title) VALUES(:authorId, :title)")
    abstract void insertBook(@Bind("authorId") Long authorId, @Bind("title") String title);

这些`insertBook()`方法将一本书插入到`Books` 表中。

@Transaction
    public void insertBooksForAuthor(String author, List<String> titles) {
        
        Long authorId = getAuthorId(author);
        
        if (authorId == null) {
            throw new TransactionFailedException("No author found");
        }
        
        for (String title : titles) {
            
            insertBook(authorId, title);
        }
    }

`@Transaction`注释导致 在`insertBooksForAuthor()` 事务中运行。所以要么所有的书都被插入，要么没有。

JDBIEx9.java

package com.zetcode;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import org.skife.jdbi.v2.DBI;
    
    public class JDBIEx9 {
    
        public static void main(String[] args) {
    
            DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
                    "testuser", "test623");
    
            List<Map<String, List<String>>> authorsBooks = new ArrayList<>();
            
            Map<String, List<String>> autMap1 = new HashMap<>();
            
            List<String> books1 = new ArrayList<>();
            books1.add("Call of the Wild");
            books1.add("Martin Eden");
            books1.add("The Iron Heel");
            books1.add("White Fang");
            
            autMap1.put("Jack London", books1);
            
            Map<String, List<String>> autMap2 = new HashMap<>();
            
            List<String> books2 = new ArrayList<>();
            books2.add("Father Goriot");
            books2.add("Colonel Chabert");
            books2.add("Cousing Pons");
            
            autMap2.put("Honore de Balzac", books2);        
            
            authorsBooks.add(autMap1);
            authorsBooks.add(autMap2);
            
            MyDAO dao = dbi.onDemand(MyDAO.class);
            
            for (Map<String, List<String>> map : authorsBooks) {
                
                Set<String> ks = map.keySet();
                
                for (String author : ks) {
                    
                    dao.createAuthor(author);
                    
                    List<String> titles = map.get(author);
    
                    dao.insertBooksForAuthor(author, titles);
                }
            }
        }
    }

该示例将两位作者及其书籍插入数据库。

在本教程中，我们介绍了 JDBI 库。

[eb94f3b2db8ac8c4027107bb982971d9.png]: https://img-blog.csdnimg.cn/img_convert/eb94f3b2db8ac8c4027107bb982971d9.png