HasorDB 快速上手

從 4.3.0 開始 HasorDB 從技術(shù)架構(gòu)上完全獨(dú)立于 Hasor 技術(shù)體系不在依賴 Hasor 架構(gòu)。

引入依賴?

截止到目前為止 HasorDB 的最新版本為：?4.3.0?

• 在 https://mvnrepository.com/artifact/net.hasor/hasor-db 上也可以查詢到最新版本

• Maven

  <dependency>
      <groupId>net.hasor</groupId>
      <artifactId>hasor-db</artifactId>
      <version>4.3.0</version>
  </dependency>

• Gradle

  // Gradle
  implementation group: 'net.hasor', name: 'hasor-db', version: '4.3.0'
  
  // Gradle(Short)
  implementation 'net.hasor:hasor-db:4.3.0'
  
  // Gradle (Kotlin)
  implementation("net.hasor:hasor-db:4.3.0")

• SBT

  libraryDependencies += "net.hasor" % "hasor-db" % "4.3.0"

• Ivy

  <dependency org="net.hasor" name="hasor-db" rev="4.3.0"/>

• Grape

  @Grapes(
      @Grab(group='net.hasor', module='hasor-db', version='4.3.0')
  )

• Leiningen

  [net.hasor/hasor-db "4.3.0"]

• Buildr

  'net.hasor:hasor-db:jar:4.3.0'

然后再引入數(shù)據(jù)庫驅(qū)動(dòng)以 MySQL，Maven 方式為例：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.22</version>
</dependency>

使用 HasorDB 可以不依賴數(shù)據(jù)庫連接池，但有數(shù)據(jù)庫連接池是大多數(shù)項(xiàng)目的標(biāo)配。這里選用 Alibaba 的 Druid

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.23</version>
</dependency>

最后準(zhǔn)備一個(gè)數(shù)據(jù)庫表，并初始化一些數(shù)據(jù)（?CreateDB.sql? 文件）

drop table if exists `test_user`;
    create table `test_user` (
    `id`          int(11) auto_increment,
    `name`        varchar(255),
    `age`         int,
    `create_time` datetime,
    primary key (`id`)
);

insert into `test_user` values (1, 'mali', 26, now());
insert into `test_user` values (2, 'dative', 32, now());
insert into `test_user` values (3, 'jon wes', 41, now());
insert into `test_user` values (4, 'mary', 66, now());
insert into `test_user` values (5, 'matt', 25, now());

執(zhí)行 SQL?

使用 SQL 的方式讀取數(shù)據(jù)，?PrintUtils ?和 ?DsUtils ?兩個(gè)工具類可以在示例項(xiàng)目中找到

// 創(chuàng)建數(shù)據(jù)源
DataSource dataSource = DsUtils.dsMySql();
// 創(chuàng)建 JdbcTemplate 對象
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
// 加載測試數(shù)據(jù)腳本
jdbcTemplate.loadSQL("CreateDB.sql");

// 查詢數(shù)據(jù)并 Map 形式返回
List<Map<String, Object>> mapList = jdbcTemplate.queryForList("select * from test_user");
// 打印測試數(shù)據(jù)
PrintUtils.printMapList(mapList);

控制臺可以得到如下結(jié)果

/--------------------------------------------\
| id | name    | age | create_time           |
|--------------------------------------------|
| 1  | mali    | 26  | 2021-11-12 19:14:06.0 |
| 2  | dative  | 32  | 2021-11-12 19:14:06.0 |
| 3  | jon wes | 41  | 2021-11-12 19:14:06.0 |
| 4  | mary    | 66  | 2021-11-12 19:14:06.0 |
| 5  | matt    | 25  | 2021-11-12 19:14:06.0 |
\--------------------------------------------/

如果想使用 DTO 對象接收數(shù)據(jù)，則需要?jiǎng)?chuàng)建一個(gè) DTO 對象。

// 如果屬性名和列名可以完全匹配，那么無需任何注解。
//  - 本列中由于 `test_user` 的表名和列名符合駝峰轉(zhuǎn)下劃線，那么可以簡單的通過 @Table 注解聲明一下。
//  - 如果需要映射表名和列名請參照注解 @Table、@Column 更多的屬性
@Table(mapUnderscoreToCamelCase = true)
public class TestUser {
    private Integer id;
    private String  name;
    private Integer age;
    private Date    createTime;

    // getters and setters omitted
}

// 然后通過 `queryForList` 方法直接查詢，控制臺就可以得到相同的結(jié)果
String sqlString = "select * from test_user";
List<TestUser> dtoList = jdbcTemplate.queryForList(sqlString, TestUser.class);
PrintUtils.printObjectList(dtoList);

單表 CRUD?

對于單表 CRUD 操作可以使用 ?JdbcTemplate ?的子類 ?LambdaTemplate?

// 創(chuàng)建數(shù)據(jù)源
DataSource dataSource = DsUtils.dsMySql();
// 創(chuàng)建 LambdaTemplate 對象和創(chuàng)建 JdbcTemplate 一樣
LambdaTemplate lambdaTemplate = new LambdaTemplate(dataSource);
// 初始化一些數(shù)據(jù)
lambdaTemplate.loadSQL("CreateDB.sql");

// 查詢，所有數(shù)據(jù)
List<TestUser> dtoList = lambdaTemplate.lambdaQuery(TestUser.class)
                .queryForList();
PrintUtils.printObjectList(dtoList);

// 插入新數(shù)據(jù)
TestUser newUser = new TestUser();
newUser.setName("new User");
newUser.setAge(33);
newUser.setCreateTime(new Date());
int result = lambdaTemplate.lambdaInsert(TestUser.class)
                .applyEntity(newUser)
                .executeSumResult();

// 更新，將name 從 mali 更新為 mala
TestUser sample = new TestUser();
sample.setName("mala");
int result = lambdaTemplate.lambdaUpdate(TestUser.class)
                .eq(TestUser::getId, 1)
                .updateToBySample(sample)
                .doUpdate();

// 刪除，ID 為 2 的數(shù)據(jù)
int result = lambdaTemplate.lambdaUpdate(TestUser.class)
                .eq(TestUser::getId, 2)
                .doDelete();

使用 DAO?

使用 DAO 可以繼承 ?BaseMapper<T> ?通用 DAO 接口來完成一些基本操作，仍然以單表 CRUD 為例。

// DAO 的一些接口需要識別 ID 屬性，因此有必要在 DTO 對象上通過 @Column 注解標(biāo)記出它們
@Table(mapUnderscoreToCamelCase = true)
public class TestUser {
    @Column(primary = true)
    private Integer id;
    private String  name;
    private Integer age;
    private Date    createTime;
    
    // getters and setters omitted
}

// 創(chuàng)建數(shù)據(jù)源
DataSource dataSource = DsUtils.dsMySql();
// 創(chuàng)建通用 DAO
DalSession session = new DalSession(dataSource);
BaseMapper<TestUser> baseMapper = session.createBaseMapper(TestUser.class);
// 初始化一些數(shù)據(jù)
baseMapper.template().loadSQL("CreateDB.sql");

// 查詢數(shù)據(jù)
List<TestUser> dtoList = baseMapper.query().queryForList();
PrintUtils.printObjectList(dtoList);

// 插入新數(shù)據(jù)
TestUser newUser = new TestUser();
newUser.setName("new User");
newUser.setAge(33);
newUser.setCreateTime(new Date());
int result = baseMapper.insert(newUser);

// 更新，將name 從 mali 更新為 mala
TestUser sample = baseMapper.queryById(1);
sample.setName("mala");
int result = baseMapper.updateById(sample);

// 刪除，ID 為 2 的數(shù)據(jù)
int result = baseMapper.deleteById(2);

作為 DAO 可以定義自己的方法，并通過注解配置具體執(zhí)行的 SQL 語句。

定義部分：

// BaseMapper 是可選的，繼承它相當(dāng)于多了一組單表 CURD 的擴(kuò)展功能。
@SimpleMapper
public interface TestUserDAO extends BaseMapper<TestUser> {
    @Insert("insert into `test_user` (name,age,create_time) values (#{name}, #{age}, now())")
    public int insertUser(@Param("name") String name, 
                          @Param("age") int age);
    
    @Update("update `test_user` set age = #{age} where id = #{id}")
    public int updateAge(@Param("id") int userId, 
                         @Param("age") int newAge);
    
    @Delete("delete from `test_user` where age > #{age}")
    public int deleteByAge(@Param("age") int age);
    
    @Query(value = "select * from `test_user` where  #{beginAge} < age and age < #{endAge}",
           resultType = TestUser.class)
    public List<TestUser> queryByAge(@Param("beginAge") int beginAge, 
                                     @Param("endAge") int endAge);
}

使用：

// 創(chuàng)建 DalRegistry 并注冊 TestUserDAO
DalRegistry dalRegistry = new DalRegistry();
dalRegistry.loadMapper(TestUserDAO.class);
// 使用 DalRegistry 創(chuàng)建 Session
DalSession session = new DalSession(dataSource, dalRegistry);
// 創(chuàng)建 DAO 接口
TestUserDAO userDAO = session.createMapper(TestUserDAO.class);

使用 Mapper?

統(tǒng)一管理 SQL 的最佳場所仍然是 Mapper 文件，而且 HasorDB 的 Mapper 文件高度兼容 MyBatis 學(xué)習(xí)成本極低。

// 利用 @RefMapper 注解將 Mapper 文件和 接口類聯(lián)系起來（繼承 BaseMapper 是可選的）
@RefMapper("/mapper/quick_dao3/TestUserMapper.xml")
public interface TestUserDAO extends BaseMapper<TestUser> {
    public int insertUser(@Param("name") String name, 
                          @Param("age") int age);
    
    public int updateAge(@Param("id") int userId, 
                         @Param("age") int newAge);
    
    public int deleteByAge(@Param("age") int age);
    
    public List<TestUser> queryByAge(@Param("beginAge") int beginAge, 
                                     @Param("endAge") int endAge);
}

為了更好了解和使用 HasorDB 的 Mapper 文件建議增加 DTD加以驗(yàn)證。另外 HasorDB 兼容 MyBatis3 的 DTD 對于絕大部分 MyBatis 工程都可以正常兼容。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//hasor.net//DTD Mapper 1.0//EN" 
                        "https://www.hasor.net/schema/hasordb-mapper.dtd">
<mapper namespace="net.hasor.db.example.quick.dao3.TestUserDAO">
    <resultMap id="testuser_resultMap" type="net.hasor.db.example.quick.dao3.TestUser">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
        <result column="create_time" property="createTime"/>
    </resultMap>
    
    <sql id="testuser_columns">
        name,age,create_time
    </sql>
    
    <insert id="insertUser">
        insert into `test_user` (
            <include refid="testuser_columns"/>
        ) values (
            #{name}, #{age}, now()
        )
    </insert>
    
    <update id="updateAge">
        update `test_user` set age = #{age} where id = #{id}
    </update>
    
    <delete id="deleteByAge"><![CDATA[
        delete from `test_user` where age > #{age}
    ]]></delete>
    
    <select id="queryByAge" resultMap="testuser_resultMap">
        select id,<include refid="testuser_columns"/>
        from `test_user`
        where  #{beginAge} < age and age &lt; #{endAge}
    </select>
</mapper>

注意：
由于 Mapper 文件無法感知 BaseMapper 接口的范型，如果需要 Mapper 文件混合 BaseMapper 一起使用。 則建議 @Table、@Column 注解配置也加上。這部分內(nèi)容請參考 對象映射

快速條件拼接?

快速條件拼接包含 快速'與'條件 拼接和 快速'或'條件拼接，它們是兩個(gè)用于取代簡單的 ?if ?標(biāo)簽和簡單的 ?foreach ?標(biāo)簽的規(guī)則。 如下語句，當(dāng)參數(shù)不為空時(shí)候才拼接 sql

<select id="queryUser">
    select * from `test_user`
    where 1 = 1
    <if test="age != null">
        and age = #{age}
    </if>
</select>

可以簡化為快速規(guī)則寫法，其中 ?:age ?為屬性名。

<select id="queryUser">
    select * from `test_user`
    @{and, age = :age}
</select>

例如如下 ?foreach ?操作：

<select id="queryUser">
    select * from `test_user`
    where
    id in <foreach item="item" index="index" collection="list"
             open="(" separator="," close=")">
        #{item}
    </foreach>
</select>

可以簡化為快速規(guī)則寫法，其中? :list? 為集合屬性名。

<select id="queryUser">
    select * from `test_user`
    @{and, id in (:list)}
</select>

分頁查詢?

HasorDB 的分頁能力僅在 ?LambdaTemplate?、?BaseMapper?、?Mapper DAO? 三個(gè)層面上受到支持。下面為不同的使用方式：

使用 ?LambdaTemplate ?進(jìn)行分頁查詢

// 構(gòu)造 LambdaTemplate 和初始化一些數(shù)據(jù)
DataSource dataSource = DsUtils.dsMySql();
LambdaTemplate lambdaTemplate = new LambdaTemplate(dataSource);
lambdaTemplate.loadSQL("CreateDB.sql");

// 構(gòu)建分頁對象，每頁 3 條數(shù)據(jù)(默認(rèn)第一頁的頁碼為 0)
Page pageInfo = new PageObject();
pageInfo.setPageSize(3);

// 分頁查詢數(shù)據(jù)
List<TestUser> pageData1 = lambdaTemplate.lambdaQuery(TestUser.class)
    .usePage(pageInfo)
    .queryForList();

// 分頁查詢下一頁數(shù)據(jù)
pageInfo.nextPage();
List<TestUser> pageData2 = lambdaTemplate.lambdaQuery(TestUser.class)
    .usePage(pageInfo)
    .queryForList();

用接口 ?BaseMapper ?進(jìn)行分頁查詢

// 構(gòu)造 BaseMapper 和初始化一些數(shù)據(jù)
DataSource dataSource = DsUtils.dsMySql();
DalSession session = new DalSession(dataSource);
BaseMapper<TestUser> baseMapper = session.createBaseMapper(TestUser.class);
baseMapper.template().loadSQL("CreateDB.sql");

// 構(gòu)建分頁對象，每頁 3 條數(shù)據(jù)(默認(rèn)第一頁的頁碼為 0)
Page pageInfo = new PageObject();
pageInfo.setPageSize(3);

// 分頁查詢數(shù)據(jù)
PageResult<TestUser> pageData1 = baseMapper.pageBySample(null, pageInfo);

// 分頁查詢下一頁數(shù)據(jù)
pageInfo.nextPage();
PageResult<TestUser> pageData2 = baseMapper.pageBySample(null, pageInfo);

若想分頁查詢 Mapper 文件中的查詢，僅需在對應(yīng) DAO 接口方法中增加一個(gè) Page 參數(shù)即可。

@RefMapper("/mapper/quick_page3/TestUserMapper.xml")
public interface TestUserDAO extends BaseMapper<TestUser> {
    // 可以直接返回分頁之后的數(shù)據(jù)結(jié)果
    public List<TestUser> queryByAge(@Param("beginAge") int beginAge, 
                                     @Param("endAge") int endAge, 
                                     Page pageInfo);
    
    // 也可以返回包含分頁信息的分頁結(jié)果
    public List<TestUser> queryByAge(@Param("beginAge") int beginAge, 
                                     @Param("endAge") int endAge, 
                                     Page pageInfo);
}

使用：

// 構(gòu)建分頁條件
Page pageInfo = new PageObject();
pageInfo.setPageSize(3);

// 分頁方式查詢 mapper 中的查詢
List<TestUser> data1 = userDAO.queryByAge(25, 100, pageInfo);
PageResult<TestUser> page1 = userDAO.queryByAge2(25, 100, pageInfo);

// 分頁方式查詢 mapper 中的查詢
pageInfo.nextPage();
List<TestUser> data2 = userDAO.queryByAge(25, 100, pageInfo);
PageResult<TestUser> page2 = userDAO.queryByAge2(25, 100, pageInfo);

使用事務(wù)?

HasorDB 提供了三種方式使用事務(wù)，分別為：

• 聲明式事務(wù)，通過調(diào)用 ?TransactionManager ?接口來實(shí)現(xiàn)事務(wù)控制。
• 模版事務(wù)，通過 ?TransactionTemplate ?接口來實(shí)現(xiàn)事務(wù)控制。
• 注解事務(wù)，基于? @Transaction? 的注解事務(wù)控制（開發(fā)中...）

聲明式事務(wù)?

啟動(dòng)和遞交一個(gè)事務(wù)，例如：

DataSource dataSource = DsUtils.dsMySql();
TransactionManager manager = DataSourceManager.getManager(dataSource);

TransactionStatus tranA = manager.begin();

...

manager.commit(tranA);

或者使用快捷方式

DataSource dataSource = DsUtils.dsMySql();
TransactionManager manager = DataSourceManager.getManager(dataSource);

manager.begin(); // 開啟一個(gè)事務(wù)

...

manager.commit(); //遞交最近的一個(gè)事務(wù)

啟動(dòng)和遞交多個(gè)事務(wù)，例如：

DataSource dataSource = DsUtils.dsMySql();
TransactionManager manager = DataSourceManager.getManager(dataSource);

TransactionStatus tranA = manager.begin();
TransactionStatus tranB = manager.begin();
TransactionStatus tranC = manager.begin();

...

manager.commit(tranC);
manager.commit(tranB);
manager.commit(tranA);

通過 ?begin ?方法的參數(shù)可以設(shè)置事務(wù)的 傳播屬性 和 隔離級別

TransactionStatus tranA = manager.begin(
        Propagation.REQUIRES_NEW, // 傳播屬性
        Isolation.READ_COMMITTED  // 隔離級別
);

模版事務(wù)?

通常使用事務(wù)都會遵循下列邏輯：

try {
    manager.begin(behavior, level);

    ...

    manager.commit();
} catch (Throwable e) {
    manager.rollBack();
    throw e;
}

而模版事務(wù)會遵循這個(gè)常規(guī)邏輯使其變?yōu)橐粋€(gè)更加通用 API 調(diào)用方式，下面這段代碼就是模版事務(wù)類的實(shí)現(xiàn)邏輯：

?類：?net.hasor.db.transaction.support.TransactionTemplateManager??

public <T> T execute(TransactionCallback<T> callBack,
                     Propagation behavior, Isolation level) throws Throwable {
    TransactionStatus tranStatus = null;
    try {
        tranStatus = this.transactionManager.begin(behavior, level);
        return callBack.doTransaction(tranStatus);
    } catch (Throwable e) {
        if (tranStatus != null) {
            tranStatus.setRollback();
        }
        throw e;
    } finally {
        if (tranStatus != null && !tranStatus.isCompleted()) {
            this.transactionManager.commit(tranStatus);
        }
    }
}

使用模版事務(wù)的方式為：

Object result = template.execute(new TransactionCallback<Object>() {
    @Override
    public Object doTransaction(TransactionStatus tranStatus) {
        ...
        return null;
    }
});

// 使用 Java8 Lambda 語法可以簡化為下面這種
Object result = template.execute(tranStatus -> {
    return ...;
});

在事務(wù)模版中拋出異常會導(dǎo)致事務(wù)回滾，同時(shí)異常會繼續(xù)上拋：

try {
    Object result = template.execute(new TransactionCallback<Object>() {
        public Object doTransaction(TransactionStatus tranStatus) {
            throw new Exception("...");
        }
    });
} catch (Throwable e) {
    ... run here
}

也可以設(shè)置事務(wù)狀態(tài)為 ?rollBack ?或 ?readOnly ?也會導(dǎo)致回滾

Object result = template.execute(new TransactionCallback<Object>() {
    public Object doTransaction(TransactionStatus tranStatus) {
        tranStatus.setReadOnly();
        // 或
        tranStatus.setRollback();

        return ...;
    }
});

沒有返回值的模版事務(wù)，需要用到 ?TransactionCallbackWithoutResult ?接口。具體用法如下：

template.execute((TransactionCallbackWithoutResult) tranStatus -> {
    ...
});