介绍
HasorDB 是一个全功能数据库拜访工具，提供对象映射、丰盛的类型解决、动静SQL、存储过程、 内置分页方言20+、
反对嵌套事务、多数据源、条件结构器、INSERT 策略、多语句/多后果。并兼容 Spring 及 MyBatis 用法。
它不依赖任何其它框架，因而能够很不便的和任意一个框架整合在一起应用。
性能个性
相熟的形式
- JdbcTemplate 接口方式（高度兼容 Spring JDBC）
- Mapper 文件形式（高度兼容 MyBatis）
- LambdaTemplate （高度靠近 MyBatis Plus、jOOQ 和 BeetlSQL）
- @Insert、@Update、@Delete、@Query、@Callable 注解（相似 JPA）
事务反对
- 反对 5 个事务隔离级别、7 个事务流传行为（与 Spring tx 雷同）
- 提供 TransactionTemplate、TransactionManager 接口方式申明式事务控制能力（用法与 Spring 雷同）
特色劣势
- 反对 分页查问 并且提供多种数据库方言（20+）
- 反对 INSERT 策略（INTO、UPDATE、IGNORE）
- 更加丰盛的 TypeHandler（MyBatis 40+，HasorDB 60+）
- Mapper XML 反对多语句、多后果
- 提供独特的规定机制，让动静 SQL 更加简略
- 反对 存储过程
- 反对 JDBC 4.2 和 Java8 中工夫类型
- 反对多数据源
引入依赖
截止到目前为止 HasorDB 的最新版本为：4.3.0
- 在 https://mvnrepository.com/art... 上也能够查问到最新版本
<dependency> <groupId>net.hasor</groupId> <artifactId>hasor-db</artifactId> <version>4.3.0</version></dependency>而后再引入数据库驱动以 MySQL，Maven 形式为例：
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.22</version></dependency>应用 HasorDB 能够不依赖数据库连接池，但有数据库连接池是大多数我的项目的标配。这里选用 Alibaba 的 Druid
<dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.23</version></dependency>最初筹备一个数据库表，并初始化一些数据（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());执行 SQL
应用 SQL 的形式读取数据，PrintUtils 和 DsUtils 两个工具类能够在例子工程中找到
// 创立数据源DataSource dataSource = DsUtils.dsMySql();// 创立 JdbcTemplate 对象JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);// 加载测试数据脚本jdbcTemplate.loadSQL("CreateDB.sql");// 查问数据并 Map 模式返回List<Map<String, Object>> mapList = jdbcTemplate.queryForList("select * from test_user");// 打印测试数据PrintUtils.printMapList(mapList);控制台能够失去如下后果
/--------------------------------------------\| 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 对象接收数据，则须要创立一个 DTO 对象。
// 如果属性名和列名能够齐全匹配，那么无需任何注解。// - 本列中因为 `test_user` 的表名和列名合乎驼峰转下划线，那么能够简略的通过 @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` 办法间接查问，控制台就能够失去雷同的后果String sqlString = "select * from test_user";List<TestUser> dtoList = jdbcTemplate.queryForList(sqlString, TestUser.class);PrintUtils.printObjectList(dtoList);单表 CRUD
对于单表 CRUD 操作能够应用 JdbcTemplate 的子类 LambdaTemplate
// 创立数据源DataSource dataSource = DsUtils.dsMySql();// 创立 LambdaTemplate 对象和创立 JdbcTemplate 一样LambdaTemplate lambdaTemplate = new LambdaTemplate(dataSource);// 初始化一些数据lambdaTemplate.loadSQL("CreateDB.sql");// 查问，所有数据List<TestUser> dtoList = lambdaTemplate.lambdaQuery(TestUser.class) .queryForList();PrintUtils.printObjectList(dtoList);// 插入新数据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 更新为 malaTestUser sample = new TestUser();sample.setName("mala");int result = lambdaTemplate.lambdaUpdate(TestUser.class) .eq(TestUser::getId, 1) .updateToBySample(sample) .doUpdate();// 删除，ID 为 2 的数据int result = lambdaTemplate.lambdaUpdate(TestUser.class) .eq(TestUser::getId, 1) .updateToBySample(sample) .doUpdate();应用 DAO
应用 DAO 能够继承 BaseMapper<T> 通用 DAO 接口来实现一些基本操作，依然以单表 CRUD 为例。
// DAO 的一些接口须要辨认 ID 属性，因而有必要在 DTO 对象上通过 @Column 注解标记出它们@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}// 创立数据源DataSource dataSource = DsUtils.dsMySql();// 创立通用 DAODalSession session = new DalSession(dataSource);BaseMapper<TestUser> baseMapper = session.createBaseMapper(TestUser.class);// 初始化一些数据baseMapper.template().loadSQL("CreateDB.sql");// 查问数据List<TestUser> dtoList = baseMapper.query().queryForList();PrintUtils.printObjectList(dtoList);// 插入新数据TestUser newUser = new TestUser();newUser.setName("new User");newUser.setAge(33);newUser.setCreateTime(new Date());int result = baseMapper.insert(newUser);// 更新，将name 从 mali 更新为 malaTestUser sample = baseMapper.queryById(1);sample.setName("mala");int result = baseMapper.updateById(sample);// 删除，ID 为 2 的数据int result = baseMapper.deleteById(2);作为 DAO 能够定义本人的办法，并通过注解配置具体执行的 SQL 语句。
// BaseMapper 是可选的，继承它相当于多了一组单表 CURD 的扩大性能。@SimpleMapperpublic 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);}// 创立 DalRegistry 并注册 TestUserDAODalRegistry dalRegistry = new DalRegistry();dalRegistry.loadMapper(TestUserDAO.class);// 应用 DalRegistry 创立 SessionDalSession session = new DalSession(dataSource, dalRegistry);// 创立 DAO 接口TestUserDAO userDAO = session.createMapper(TestUserDAO.class);应用 Mapper
对立治理 SQL 的最佳场合依然是 Mapper 文件，而且 HasorDB 的 Mapper 文件高度兼容 MyBatis 学习老本极低。
// 利用 @RefMapper 注解将 Mapper 文件和 接口类分割起来（继承 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加以验证。另外 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 < #{endAge} </select></mapper>:::caution
因为 Mapper 文件无奈感知 BaseMapper 接口的范型，如果须要 Mapper 文件混合 BaseMapper 一起应用。
则倡议 @Table、@Column 注解配置也加上。这部分内容请参考文档中的 对象映射
:::
疾速条件拼接
疾速条件拼接蕴含 疾速'与'条件 和 疾速'或'条件 它们是两个规定用于取代简略的 if 标签和简略的 foreach 标签。
如下语句，当参数不为空时候才拼接 sql
<select id="queryUser"> select * from `test_user` where 1 = 1 <if test="age != null"> and age = #{age} </if></select>能够简化为疾速规定写法，其中 :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>能够简化为疾速规定写法，其中 :list 为汇合属性名。
<select id="queryUser"> select * from `test_user` @{and, id in (:list)}</select>分页查问
HasorDB 的分页能力仅在 LambdaTemplate、BaseMapper、Mapper DAO 三个层面上受到反对。上面为不同的应用形式：
应用 LambdaTemplate 进行分页查问
// 结构 LambdaTemplate 和初始化一些数据DataSource dataSource = DsUtils.dsMySql();LambdaTemplate lambdaTemplate = new LambdaTemplate(dataSource);lambdaTemplate.loadSQL("CreateDB.sql");// 构建分页对象，每页 3 条数据(默认第一页的页码为 0)Page pageInfo = new PageObject();pageInfo.setPageSize(3);// 分页查问数据List<TestUser> pageData1 = lambdaTemplate.lambdaQuery(TestUser.class) .usePage(pageInfo) .queryForList();// 分页查问下一页数据pageInfo.nextPage();List<TestUser> pageData2 = lambdaTemplate.lambdaQuery(TestUser.class) .usePage(pageInfo) .queryForList();用接口 BaseMapper 进行分页查问
// 结构 BaseMapper 和初始化一些数据DataSource dataSource = DsUtils.dsMySql();DalSession session = new DalSession(dataSource);BaseMapper<TestUser> baseMapper = session.createBaseMapper(TestUser.class);baseMapper.template().loadSQL("CreateDB.sql");// 构建分页对象，每页 3 条数据(默认第一页的页码为 0)Page pageInfo = new PageObject();pageInfo.setPageSize(3);// 分页查问数据PageResult<TestUser> pageData1 = baseMapper.pageBySample(null, pageInfo);// 分页查问下一页数据pageInfo.nextPage();PageResult<TestUser> pageData2 = baseMapper.pageBySample(null, pageInfo);若想分页查问 Mapper 文件中的查问，仅需在对应 DAO 接口办法中减少一个 Page 参数即可。
@RefMapper("/mapper/quick_page3/TestUserMapper.xml")public interface TestUserDAO extends BaseMapper<TestUser> { // 能够间接返回分页之后的数据后果 public List<TestUser> queryByAge(@Param("beginAge") int beginAge, @Param("endAge") int endAge, Page pageInfo); // 也能够返回蕴含分页信息的分页后果 public List<TestUser> queryByAge(@Param("beginAge") int beginAge, @Param("endAge") int endAge, Page pageInfo);}// 构建分页条件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);应用事务
HasorDB 提供了三种形式应用事务，别离为：
- 申明式事务，通过调用
TransactionManager接口来实现事务管制。 - 模版事务，通过
TransactionTemplate接口来实现事务管制。 - 注解事务，基于
@Transaction的注解事务管制（开发中...）
申明式事务
启动和递交一个事务，例如：
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(); // 开启一个事务...manager.commit(); //递交最近的一个事务启动和递交多个事务，例如：
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 办法的参数能够设置事务的 流传属性 和 隔离级别
TransactionStatus tranA = manager.begin( Propagation.REQUIRES_NEW, // 流传属性 Isolation.READ_COMMITTED // 隔离级别);模版事务
通常应用事务都会遵循下列逻辑：
try { manager.begin(behavior, level); ... manager.commit();} catch (Throwable e) { manager.rollBack(); throw e;}而模版事务会遵循这个惯例逻辑使其变为一个更加通用 API 调用形式，上面这段代码就是模版事务类的实现逻辑：
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); } }}应用模版事务的形式为：
Object result = template.execute(new TransactionCallback<Object>() { @Override public Object doTransaction(TransactionStatus tranStatus) { ... return null; }});// 应用 Java8 Lambda 语法能够简化为上面这种Object result = template.execute(tranStatus -> { return ...;});在事务模版中抛出异样会导致事务回滚，同时异样会持续上抛：
try { Object result = template.execute(new TransactionCallback<Object>() { public Object doTransaction(TransactionStatus tranStatus) { throw new Exception("..."); } });} catch (Throwable e) { ... run here}也能够设置事务状态为 rollBack 或 readOnly 也会导致回滚
Object result = template.execute(new TransactionCallback<Object>() { public Object doTransaction(TransactionStatus tranStatus) { tranStatus.setReadOnly(); // 或 tranStatus.setRollback(); return ...; }});没有返回值的模版事务，须要用到 TransactionCallbackWithoutResult 接口。具体用法如下：
template.execute((TransactionCallbackWithoutResult) tranStatus -> { ...});联系方式
官网首页是：http://www.hasor.cn/
如果你想进一步探讨，能够在它的官方网站上找到更多联系方式。