• Java 使用 JDBI 库访问MySQL 数据库

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

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

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

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

    在 MySQL 中创建数据库

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

    cars_mysql.sql

    1. DROP TABLE IF EXISTS Cars;
    2. CREATE TABLE Cars(Id INT PRIMARY KEY AUTO_INCREMENT, 
    3.                   Name TEXT, Price INT) ENGINE=InnoDB;
    4.                   
    5. INSERT INTO Cars(Name, Price) VALUES('Audi', 52642);
    6. INSERT INTO Cars(Name, Price) VALUES('Mercedes', 57127);
    7. INSERT INTO Cars(Name, Price) VALUES('Skoda', 9000);
    8. INSERT INTO Cars(Name, Price) VALUES('Volvo', 29000);
    9. INSERT INTO Cars(Name, Price) VALUES('Bentley', 350000);
    10. INSERT INTO Cars(Name, Price) VALUES('Citroen', 21000);
    11. INSERT INTO Cars(Name, Price) VALUES('Hummer', 41400);
    12. 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我们使用监视器 连接到数据库。

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

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

    1. mysql> USE testdb;
    2. mysql> SOURCE cars_mysql.sql

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

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

    我们验证数据。

    pom.xml 文件

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

    pom.xml 
    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" 
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.     <groupId>com.zetcodegroupId>
    7.     <artifactId>JDBIExartifactId>
    8.     <version>1.0-SNAPSHOTversion>
    9.     <packaging>jarpackaging>
    10.     <properties>
    11.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    12.         <maven.compiler.source>1.8maven.compiler.source>
    13.         <maven.compiler.target>1.8maven.compiler.target>
    14.     properties>
    15.  
    16.     <dependencies>
    17.         <dependency>
    18.             <groupId>org.jdbigroupId>
    19.             <artifactId>jdbiartifactId>
    20.             <version>2.73version>
    21.         dependency>
    22.         
    23.         <dependency>
    24.             <groupId>mysqlgroupId>
    25.             <artifactId>mysql-connector-javaartifactId>
    26.             <version>5.1.39version>
    27.         dependency>
    28.         
    29.     dependencies>    
    30.     
    31. project>

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

    流畅的 API

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

    检索所有汽车

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

    JDBIEx.java 
    1. package com.zetcode;
    2.  
    3. import java.util.List;
    4. import java.util.Map;
    5. import org.skife.jdbi.v2.DBI;
    6. import org.skife.jdbi.v2.Handle;
    7. import org.skife.jdbi.v2.Query;
    8.  
    9. public class JDBIEx {
    10.  
    11.     public static void main(String[] args) {
    12.  
    13.         Handle handle = null;
    14.         DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
    15.                 "testuser", "test623");
    16.         
    17.         String sql = "SELECT * FROM Cars";
    18.  
    19.         try {
    20.  
    21.             handle = dbi.open();
    22.             Query> q = handle.createQuery(sql);
    23.             List> l = q.list();
    24.  
    25.             for (Map m : l) {
    26.             
    27.                 System.out.printf("%d ", m.get("Id"));
    28.                 System.out.printf("%s ", m.get("Name"));
    29.                 System.out.println(m.get("Price"));
    30.             }
    31.  
    32.         } finally {
    33.             if (handle != null) {
    34.                 handle.close();
    35.             }
    36.         }
    37.     }
    38. }

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

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

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

    handle = dbi.open();

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

    Query> q = handle.createQuery(sql);

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

    List> l = q.list();

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

    1. for (Map m : l) {
    2.  
    3.     System.out.printf("%d ", m.get("Id"));
    4.     System.out.printf("%s ", m.get("Name"));
    5.     System.out.println(m.get("Price"));
    6. }

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

    1. } finally {
    2.     if (handle != null) {
    3.         handle.close();
    4.     }
    5. }

    最后，我们关闭手柄。

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

    这是示例的输出。

    通过 ID 检索汽车

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

    JDBIEx2.java 
    1. package com.zetcode;
    2.  
    3. import java.util.Map;
    4. import org.skife.jdbi.v2.DBI;
    5. import org.skife.jdbi.v2.Handle;
    6. import org.skife.jdbi.v2.Query;
    7. import org.skife.jdbi.v2.util.StringColumnMapper;
    8.  
    9. public class JDBIEx2 {
    10.  
    11.     public static void main(String[] args) {
    12.  
    13.         Handle handle = null;
    14.         DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
    15.                 "testuser", "test623");
    16.  
    17.         try {
    18.  
    19.             handle = dbi.open();
    20.             
    21.             String sql = "SELECT Name FROM Cars WHERE Id = ?";
    22.             
    23.             Query> q = handle.createQuery(sql);
    24.             q.bind(0, 1);
    25.             
    26.             String carName = q.map(StringColumnMapper.INSTANCE).first();
    27.             
    28.             System.out.println(carName);
    29.  
    30.         } finally {
    31.         
    32.             if (handle != null) {
    33.                 handle.close();
    34.             }
    35.         }
    36.     }
    37. }

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

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

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

    Query> 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 
    1. # mysql properties
    2. mysql.driver=com.mysql.jdbc.Driver
    3. mysql.url=jdbc:mysql://localhost:3306/testdb
    4. mysql.username=testuser
    5. mysql.password=test623

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

    图：数据库属性

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

    JDBIEx3.java 
    1. package com.zetcode;
    2.  
    3. import com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource;
    4. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
    5. import java.io.FileInputStream;
    6. import java.io.FileNotFoundException;
    7. import java.io.IOException;
    8. import java.util.Map;
    9. import java.util.Properties;
    10. import org.skife.jdbi.v2.DBI;
    11. import org.skife.jdbi.v2.Handle;
    12. import org.skife.jdbi.v2.Query;
    13. import org.skife.jdbi.v2.util.IntegerColumnMapper;
    14.  
    15. public class JDBIEx3 {
    16.  
    17.     public static MysqlDataSource getMySQLDataSource() throws 
    18.             FileNotFoundException, IOException {
    19.         
    20.         Properties props = new Properties();
    21.         FileInputStream fis = null;
    22.         MysqlDataSource ds = null;
    23.  
    24.         fis = new FileInputStream("src/main/Resources/db.properties");
    25.         props.load(fis);
    26.         
    27.         ds = new MysqlConnectionPoolDataSource();
    28.         ds.setURL(props.getProperty("mysql.url"));
    29.         ds.setUser(props.getProperty("mysql.username"));
    30.         ds.setPassword(props.getProperty("mysql.password"));
    31.  
    32.         return ds;
    33.     }
    34.  
    35.     public static void main(String[] args) throws IOException {
    36.  
    37.         Handle handle = null;
    38.         MysqlDataSource ds = getMySQLDataSource();
    39.  
    40.         DBI dbi = new DBI(ds);
    41.  
    42.         try {
    43.  
    44.             handle = dbi.open();
    45.  
    46.             String sql = "SELECT Price FROM Cars WHERE Id = ?";
    47.  
    48.             Query> q = handle.createQuery(sql);
    49.             q.bind(0, 1);
    50.  
    51.             Integer price = q.map(IntegerColumnMapper.WRAPPER).first();
    52.  
    53.             System.out.println(price);
    54.  
    55.         } finally {
    56.             if (handle != null) {
    57.                 handle.close();
    58.             }
    59.         }
    60.     }
    61. }

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

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

    我们从Resources目录加载属性。

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

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

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

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

    withHandle() 方法

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

    JDBIEx4.java 
    1. package com.zetcode;
    2.  
    3. import org.skife.jdbi.v2.DBI;
    4. import org.skife.jdbi.v2.Handle;
    5. import org.skife.jdbi.v2.util.IntegerColumnMapper;
    6.  
    7. public class JDBIEx4 {
    8.  
    9.     public static void main(String[] args) {
    10.  
    11.         DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
    12.                 "testuser", "test623");
    13.         String sql = "SELECT Price FROM Cars WHERE Id = :id";
    14.         int id = 3;
    15.  
    16.         Integer price = dbi.withHandle((Handle h) -> {
    17.  
    18.             return h.createQuery(sql)
    19.                     .map(IntegerColumnMapper.WRAPPER)
    20.                     .bind("id", id) 
    21.                     .first(); 
    22.         });
    23.         
    24.         System.out.println(price);
    25.     }
    26. }

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

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

    此 SQL 查询使用命名参数。

    1. Integer price = dbi.withHandle((Handle h) -> {
    2.  
    3.     return h.createQuery(sql)
    4.             .map(IntegerColumnMapper.WRAPPER)
    5.             .bind("id", id) 
    6.             .first(); 
    7. });

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

    映射自定义类

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

    Car.java 
    1. package com.zetcode;
    2.  
    3. public class Car {
    4.     
    5.     private Long Id;
    6.     private String Name;
    7.     private int Price;
    8.  
    9.     public Car(Long Id, String Name, int Price) {
    10.         this.Id = Id;
    11.         this.Name = Name;
    12.         this.Price = Price;
    13.     }
    14.  
    15.     public Long getId() {
    16.         return Id;
    17.     }
    18.  
    19.     public void setId(Long Id) {
    20.         this.Id = Id;
    21.     }
    22.  
    23.     public String getName() {
    24.         return Name;
    25.     }
    26.  
    27.     public void setName(String Name) {
    28.         this.Name = Name;
    29.     }
    30.  
    31.     public int getPrice() {
    32.         return Price;
    33.     }
    34.  
    35.     public void setPrice(int Price) {
    36.         this.Price = Price;
    37.     }
    38.  
    39.     @Override
    40.     public String toString() {
    41.         return "Car{" + "Id=" + Id + ", Name=" + Name + ", Price=" + Price + '}';
    42.     }
    43. }

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

    CarMapper.java 
    1. package com.zetcode;
    2.  
    3. import java.sql.ResultSet;
    4. import java.sql.SQLException;
    5. import org.skife.jdbi.v2.StatementContext;
    6. import org.skife.jdbi.v2.tweak.ResultSetMapper;
    7.  
    8.  
    9. public class CarMapper implements ResultSetMapper {
    10.    
    11.     @Override
    12.     public Car map(int idx, ResultSet rs, StatementContext ctx) throws SQLException {
    13.         return new Car(rs.getLong("Id"), rs.getString("Name"), rs.getInt("Price"));
    14.     }
    15. }

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

    JDBIEx5.java 
    1. package com.zetcode;
    2.  
    3. import org.skife.jdbi.v2.DBI;
    4. import org.skife.jdbi.v2.Handle;
    5.  
    6. public class JDBIEx5 {
    7.  
    8.     public static void main(String[] args) {
    9.  
    10.         DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
    11.                 "testuser", "test623");
    12.                 
    13.         String sql = "SELECT * FROM Cars WHERE Id = :id";
    14.         int id = 3;
    15.  
    16.         Car car = dbi.withHandle((Handle h) -> {
    17.  
    18.             return h.createQuery(sql)
    19.                     .map(new CarMapper())
    20.                     .bind("id", id) 
    21.                     .first(); 
    22.         });
    23.                 
    24.         System.out.println(car);
    25.     }
    26. }

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

    1. Car car = dbi.withHandle((Handle h) -> {
    2.  
    3.     return h.createQuery(sql)
    4.             .map(new CarMapper())
    5.             .bind("id", id) 
    6.             .first(); 
    7. });

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

    批量操作

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

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

    JDBIEx6.java 
    1. package com.zetcode;
    2.  
    3. import org.skife.jdbi.v2.Batch;
    4. import org.skife.jdbi.v2.DBI;
    5. import org.skife.jdbi.v2.Handle;
    6.  
    7. public class JDBIEx6 {
    8.  
    9.     public static void main(String[] args) {
    10.  
    11.         DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
    12.                 "testuser", "test623");
    13.  
    14.         Handle handle = dbi.open();
    15.         Batch batch = handle.createBatch();
    16.  
    17.         batch.add("DROP TABLE IF EXISTS Friends");
    18.         batch.add("CREATE TABLE Friends(Id INT AUTO_INCREMENT PRIMARY KEY, Name TEXT)");
    19.         batch.add("INSERT INTO Friends(Name) VALUES ('Monika')");
    20.         batch.add("INSERT INTO Friends(Name) VALUES ('Tom')");
    21.         batch.add("INSERT INTO Friends(Name) VALUES ('Jane')");
    22.         batch.add("INSERT INTO Friends(Name) VALUES ('Robert')");
    23.  
    24.         batch.execute();
    25.     }
    26. }

    该示例创建一个新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 
    1. package com.zetcode;
    2.  
    3. import org.skife.jdbi.v2.Batch;
    4. import org.skife.jdbi.v2.DBI;
    5. import org.skife.jdbi.v2.Handle;
    6. import org.skife.jdbi.v2.TransactionStatus;
    7. import org.skife.jdbi.v2.VoidTransactionCallback;
    8.  
    9. public class JDBIEx7 {
    10.  
    11.     public static void main(String[] args) {
    12.  
    13.         DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
    14.                 "testuser", "test623");
    15.  
    16.         dbi.inTransaction(new VoidTransactionCallback() {
    17.             @Override
    18.             protected void execute(Handle handle, TransactionStatus status)
    19.                     throws Exception {
    20.  
    21.                 Batch batch = handle.createBatch();
    22.                 
    23.                 batch.add("DROP TABLE IF EXISTS Friends");
    24.                 batch.add("CREATE TABLE Friends(Id INT AUTO_INCREMENT PRIMARY KEY, Name TEXT)");
    25.                 batch.add("INSERT INTO Friends(Name) VALUES ('Monika')");
    26.                 batch.add("INSERT INTO Friends(Name) VALUES ('Tom')");
    27.                 batch.add("INSERT INTO Friends(Name) VALUES ('Jane')");
    28.                 batch.add("INSERT INTO Friends(Name) VALUES ('Robert')");
    29.                 
    30.                 batch.execute();
    31.             }
    32.         });
    33.     }
    34. }

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

    1. dbi.inTransaction(new VoidTransactionCallback() {
    2.     @Override
    3.     protected void execute(Handle handle, TransactionStatus status)
    4.             throws Exception {
    5.  
    6.         ...
    7.     }
    8. });

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

    SQL 对象 API

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

    简单的例子

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

    1. <dependency>
    2.     <groupId>org.projectlombokgroupId>
    3.     <artifactId>lombokartifactId>
    4.     <version>1.16.8version>
    5. dependency>

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

    Car.java 
    1. package com.zetcode;
    2.  
    3. import lombok.Data;
    4.  
    5. @Data 
    6. public class Car {
    7.     
    8.     private final Long Id;
    9.     private final String Name;
    10.     private final int Price;
    11. }

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

    CarMapper.java 
    1. package com.zetcode;
    2.  
    3. import java.sql.ResultSet;
    4. import java.sql.SQLException;
    5. import org.skife.jdbi.v2.StatementContext;
    6. import org.skife.jdbi.v2.tweak.ResultSetMapper;
    7.  
    8. public class CarMapper implements ResultSetMapper {
    9.    
    10.     @Override
    11.     public Car map(int idx, ResultSet rs, StatementContext ctx) throws SQLException {
    12.         return new Car(rs.getLong("Id"), rs.getString("Name"), rs.getInt("Price"));
    13.     }
    14. }

    将CarMapper结果集映射到Car类。

    MyDAO.java 
    1. package com.zetcode;
    2.  
    3. import org.skife.jdbi.v2.sqlobject.Bind;
    4. import org.skife.jdbi.v2.sqlobject.SqlQuery;
    5. import org.skife.jdbi.v2.sqlobject.customizers.Mapper;
    6.  
    7. public interface MyDAO {
    8.  
    9.     @SqlQuery("SELECT * FROM Cars WHERE Id = :id")
    10.     @Mapper(CarMapper.class)
    11.     Car findById(@Bind("id") int id);
    12.  
    13.     @SqlQuery("SELECT COUNT(Id) FROM Cars")
    14.     int countCars();
    15. }

    这里我们有一个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 
    1. package com.zetcode;
    2.  
    3. import org.skife.jdbi.v2.DBI;
    4.  
    5. public class JDBIEx8 {
    6.  
    7.     public static void main(String[] args) {
    8.  
    9.         DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
    10.                 "testuser", "test623");
    11.         
    12.         int id = 3;
    13.         
    14.         MyDAO dao = dbi.onDemand(MyDAO.class);
    15.         Car car = dao.findById(id);
    16.  
    17.         System.out.println(car);
    18.         
    19.         int nCars = dao.countCars();
    20.         
    21.         System.out.printf("There are %d cars in the table", nCars);
    22.     }
    23. }

    在此客户端应用程序中，我们找到 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 
    1. CREATE TABLE IF NOT EXISTS Authors(Id BIGINT PRIMARY KEY AUTO_INCREMENT, 
    2.     Name VARCHAR(25)) ENGINE=InnoDB;
    3.  
    4. CREATE TABLE IF NOT EXISTS Books(Id BIGINT PRIMARY KEY AUTO_INCREMENT, 
    5.     AuthorId BIGINT, Title VARCHAR(100), 
    6.     FOREIGN KEY(AuthorId) REFERENCES Authors(Id) ON DELETE CASCADE)
    7.     ENGINE=InnoDB;

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

    MyDAO.java 
    1. package com.zetcode;
    2.  
    3. import java.util.List;
    4. import org.skife.jdbi.v2.exceptions.TransactionFailedException;
    5. import org.skife.jdbi.v2.sqlobject.Bind;
    6. import org.skife.jdbi.v2.sqlobject.SqlQuery;
    7. import org.skife.jdbi.v2.sqlobject.SqlUpdate;
    8. import org.skife.jdbi.v2.sqlobject.Transaction;
    9.  
    10. public abstract class MyDAO {
    11.  
    12.     @SqlUpdate("INSERT INTO Authors(Name) VALUES(:author)")
    13.     public abstract void createAuthor(@Bind("author") String author);
    14.    
    15.     @SqlQuery("SELECT Id FROM Authors WHERE Name = :name")
    16.     abstract long getAuthorId(@Bind("name") String name);        
    17.         
    18.     @SqlUpdate("INSERT INTO Books(AuthorId, Title) VALUES(:authorId, :title)")
    19.     abstract void insertBook(@Bind("authorId") Long authorId, @Bind("title") String title);
    20.     
    21.     @Transaction
    22.     public void insertBooksForAuthor(String author, List titles) {
    23.         
    24.         Long authorId = getAuthorId(author);
    25.         
    26.         if (authorId == null) {
    27.             throw new TransactionFailedException("No author found");
    28.         }
    29.         
    30.         for (String title : titles) {
    31.             
    32.             insertBook(authorId, title);
    33.         }
    34.     }
    35. }

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

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

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

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

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

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

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

    1. @Transaction
    2. public void insertBooksForAuthor(String author, List titles) {
    3.     
    4.     Long authorId = getAuthorId(author);
    5.     
    6.     if (authorId == null) {
    7.         throw new TransactionFailedException("No author found");
    8.     }
    9.     
    10.     for (String title : titles) {
    11.         
    12.         insertBook(authorId, title);
    13.     }
    14. }

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

    JDBIEx9.java 
    1. package com.zetcode;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.HashMap;
    5. import java.util.List;
    6. import java.util.Map;
    7. import java.util.Set;
    8. import org.skife.jdbi.v2.DBI;
    9.  
    10. public class JDBIEx9 {
    11.  
    12.     public static void main(String[] args) {
    13.  
    14.         DBI dbi = new DBI("jdbc:mysql://localhost:3306/testdb",
    15.                 "testuser", "test623");
    16.  
    17.         List>> authorsBooks = new ArrayList<>();
    18.         
    19.         Map> autMap1 = new HashMap<>();
    20.         
    21.         List books1 = new ArrayList<>();
    22.         books1.add("Call of the Wild");
    23.         books1.add("Martin Eden");
    24.         books1.add("The Iron Heel");
    25.         books1.add("White Fang");
    26.         
    27.         autMap1.put("Jack London", books1);
    28.         
    29.         Map> autMap2 = new HashMap<>();
    30.         
    31.         List books2 = new ArrayList<>();
    32.         books2.add("Father Goriot");
    33.         books2.add("Colonel Chabert");
    34.         books2.add("Cousing Pons");
    35.         
    36.         autMap2.put("Honore de Balzac", books2);        
    37.         
    38.         authorsBooks.add(autMap1);
    39.         authorsBooks.add(autMap2);
    40.         
    41.         MyDAO dao = dbi.onDemand(MyDAO.class);
    42.         
    43.         for (Map> map : authorsBooks) {
    44.             
    45.             Set ks = map.keySet();
    46.             
    47.             for (String author : ks) {
    48.                 
    49.                 dao.createAuthor(author);
    50.                 
    51.                 List titles = map.get(author);
    52.  
    53.                 dao.insertBooksForAuthor(author, titles);
    54.             }
    55.         }
    56.     }
    57. }

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

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

  • 相关阅读:
    011：获取上证50的所有股票代码，并下载各个股K线数到excel表中
    MyBatis基本操作及SpringBoot单元测试
    LC926. 将字符串翻转到单调递增(JAVA - 动态规划)
    java毕业设计电影订票系统Mybatis+系统+数据库+调试部署
    11.ElasticSearch系列之搜索相关性算分机制
    MongoDB安装及进程介绍
    npm设置国内源（淘宝镜像源），解决npm包下载速度慢的问题
    【Python入门】文件夹操作
    网络运维的重要性
    C++编程（五）单例模式 友元
  • 原文地址：https://blog.csdn.net/allway2/article/details/126907374