AI 助理
备案控制台
开发者社区 数据库 文章 正文

像写SQL一样编写Java数据应用-TinySqlDsl

2016-05-09 2750
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

前言

话说企业应用，一般离不开数据库。要做数据库，可以有N种方案，比如：直接采用JDBC层自己封装下使用的，采用一些框架的，如:iBatis,Hiberate,Spring JDBC Template等等（这个太多了，因此不一一列举）的，这些方案也都在各自的领域展示了自己的特点，解决了相当部分的技术问题，并取得了相当好的应用效果。

但是不管是哪种方案，其优点和缺点往往也是连在一起的，究其原因是因为SQL和Java编程之间是割裂的，如果封装得不到位，做Java的人太难使用；如果封装得太多，在做一些用复杂SQL的时候又非常麻烦。比如：Hibernate就采用了封装HQL的方式来解决这方面的问题。iBatis对于SQL支持比较好，但是又会有一些割裂感，同时在解决时还要引入动态SQL来解决需要根据一些运行时条件来处理的问题，一定程度上又增加了使用的复杂度。

那么问题就来了，有没有更好的方式来解决数据库应用开发过程中的问题呢？究其根本原因是要如何解决数据库开发中的SQL与Java代码之间的割裂问题，如果能把这个问题解决掉，理论上会有一个不错的解。

我们知道SQL实际是是一种数据为领域的DSL语言，如果我们能直接在Java中编写SQL，然后执行结果就可以直接返回Java对象，这个问题不就有了良好的解决方案么？

TinySqlDsl解决方案

实际上这方面已经有一些现成的解决方案，但是有的不是开源的，有的支持的还不是非常到位，因此悠然就决定尝试着写一下，写了半天时间看了看效果，详见RESTful风格的支持实践一文，内部讨论了一下，感觉还不错，于是正式决定正式花时间来编写一个TinySqlDsl，当然实际编写的时候，还是有许多的问题点的，以至于最终的风格与上面的文章还有一些不一致，当然这也是正常的，容易理解的，否则那什么也太神了。

我们常见的SQL语句有Select、Insert、Update、Delete，因此我们的方案中也实现了这几个语句的编写方式。

首先来看看看TinySqlDsl版的Dao是怎么写的。

第一步：定义POJO

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Custom {
     
     private String id;
     
     private String name;
     
     private int age;
 
     public String getId() {
         return id;
     }
 
     public void setId(String id) {
         this .id = id;
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this .name = name;
     }
 
     public int getAge() {
         return age;
     }
 
     public void setAge( int age) {
         this .age = age;
     }
     
}

第二步：定义表结构定义文件

?
1
2
3
4
5
6
7
8
9
10
public class CustomTable extends Table {
     public static final CustomTable CUSTOM = new CustomTable();
     public final Column ID = new Column( this , "id" );
     public final Column NAME = new Column( this , "name" );
     public final Column AGE = new Column( this , "age" );
 
     private CustomTable() {
         super ( "custom" );
     }
}

第三步：编写DAO类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class CustomDao {
     private DslSession dslSession;
 
     public DslSession getDslSession() {
         return dslSession;
     }
 
     public void setDslSession(DslSession dslSession) {
         this .dslSession = dslSession;
     }
 
     public void insertCustom(Custom custom) {
         dslSession.execute(
             insertInto(CUSTOM).values(
                 CUSTOM.ID.value(custom.getId()),
                 CUSTOM.NAME.value(custom.getName()),
                 CUSTOM.AGE.value(custom.getAge())
             )
         );
     }
 
     public void updateCustom(Custom custom) {
         dslSession.execute(
             update(CUSTOM).set(
                 CUSTOM.NAME.value(custom.getName()),
                 CUSTOM.AGE.value(custom.getAge())).where(
                 CUSTOM.ID.eq(custom.getId())
             )
         );
     }
 
     public void deleteCustom(String id) {
         dslSession.execute(
                 delete(CUSTOM).where(
                         CUSTOM.ID.eq(id)
                 )
         );
     }
 
     public Custom getCustomById(String id) {
         return dslSession.fetchOneResult(
             selectFrom(CUSTOM).where(
                     CUSTOM.ID.eq(id)
             )
         , Custom. class );
     }
 
     public List<Custom> queryCustom(Custom custom) {
         return dslSession.fetchList(
             selectFrom(CUSTOM).where(
                 and(
                         CUSTOM.ID.eq(custom.getId()),
                         CUSTOM.NAME.equal(custom.getName()),
                         CUSTOM.AGE.equal(custom.getAge())
                 )
             )
         , Custom. class );
     }
}
看了上面的示例，会不会感觉有点奇怪，怎么可以这么写？呵呵，先别着急了解实际的实现机理，我们先品味一下这种DSL风格的数据库编写方式，嗯嗯，具体的来说就是像写SQL一样的方式来写SQL。

代码说明

每个数据表都要有两个类进行映射，一个是POJO类，这个大家都非常熟悉就不再花时间进行说明了，用于构建Dao代码的时候使用。另一个是表结构，用于在Java中定义数据库的表结构。

?
1
2
3
4
5
6
7
8
9
10
public class CustomTable extends Table {
     public static final CustomTable CUSTOM = new CustomTable();
     public final Column ID = new Column( this , "id" );
     public final Column NAME = new Column( this , "name" );
     public final Column AGE = new Column( this , "age" );
 
     private CustomTable() {
         super ( "custom" );
     }
}
这个类主要由如下几部分组成：

CustomTable对应于一个表结构类型，它继承自Table类。

构造函数，中的super("custom")使之与数据库的表名进行映射。

public static final CustomTable CUSTOM = new CustomTable();这句定义了一个常量CUSTOM，对应于具有的表，它的用得中在DSL语法用要用到表的时候使用。

这个类里定义了3个public成员变量，这些成员变量和具体的字段数相对应，表里有几个字段，这里就定义几个字段，这个实例化自Column。

OK，这样表结构的定义就做好了。

正因为有了上面的定义，才可以在Dao中用Java代码像SQL一样的编写程序，但是这些语句是怎么才能执行出结果的呢？这就要看DslSession的了。

DslSesssion

DslSession是与数据库打交道的类，说白了，它就是一个SQL执行器。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
public interface DslSession {
     /**
      * 执行Insert语句关返回
      *
      * @param insert
      * @return
      */
     int execute(Insert insert);
 
     /**
      * 执行更新语句
      *
      * @param update
      * @return
      */
     int execute(Update update);
 
     /**
      * 执行删除语句
      *
      * @param delete
      * @return
      */
     int execute(Delete delete);
 
     /**
      * 返回一个结果，既然是有多个结果也只返回第一个结果
      *
      * @param select
      * @param requiredType
      * @param <T>
      * @return
      */
     <T> T fetchOneResult(Select select, Class<T> requiredType);
 
     /**
      * 把所有的结果变成一个对象数组返回
      *
      * @param select
      * @param requiredType
      * @param <T>
      * @return
      */
     <T> T[] fetchArray(Select select, Class<T> requiredType);
 
     /**
      * 把所有的结果变成一个对象列表返回
      *
      * @param select
      * @param requiredType
      * @param <T>
      * @return
      */
     <T> List<T> fetchList(Select select, Class<T> requiredType);
     
     /**
      * 返回一个结果，既然是有多个结果也只返回第一个结果
      *
      * @param complexSelect
      * @param requiredType
      * @param <T>
      * @return
      */
     <T> T fetchOneResult(ComplexSelect complexSelect, Class<T> requiredType);
 
     
     /**
      * 把所有的结果变成一个对象数组返回
      *
      * @param complexSelect
      * @param requiredType
      * @param <T>
      * @return
      */
     <T> T[] fetchArray(ComplexSelect complexSelect, Class<T> requiredType);
 
     /**
      * 把所有的结果变成一个对象列表返回
      *
      * @param complexSelect
      * @param requiredType
      * @param <T>
      * @return
      */
     <T> List<T> fetchList(ComplexSelect complexSelect, Class<T> requiredType);
 
}
它的方法也比较简单，主要功能就是执行这几个语句。正是由于把复杂的SQL都封装到了Insert、Select、Update、Delete当中，因此这个执行器的接口方法反而是非常的简单，正因为它太简单了，因此根本就不需要介绍。仅仅要说明的是，当Select的时候，需要指定返回的类型，以便于告诉DslSession要返回的类型是什么。

Q&A

Q:是不是支持复杂的SQL？

A：必须支持，不管是Union，子查询，各种连接都可以支持

Q:是不是支持分页？

A：必须支持，不管是拼SQL语句分页的还是SQL默认就支持分页的，都可以支持

Q:你这个SQL条件一路写下来，是不是需要所有的条件都必须存在？

A：不用，对于没有给值的条件，框架会自动忽略此条件，所以你只要写一个大而全的就可以了。

Q:是不是支持数据库中的函数？

A：必须支持，所有的函数都可以使用，只是如果写了与某种数据库相关的函数，跨数据库时将不再有兼容性。

Q:是不是支持多表关联查询？

A：必须支持，不管是多表联合查询还是子查询啥的，全都支持。

Q:有啥不支持的不？

好像没有啥不支持的，只有写得漂亮不漂亮的，没有支持不支持的。由于支持自已编写SQL片断，因此理论上你可以用SQL片断完成所有的事情，只是看起来不够漂亮而已。

应用实践

支持类编写

使用Tiny元数据开发

如果使用Tiny元数据管理数据表，那么只要在工具中如下操作，即可自动生成POJO、表定义、及Dao层代码实现：

也就是只要选中表定义文件，选择右键->TinyStudio->生成DSL JAVA类，就可以自动生成Dao层的所有代码，如果需要可以对生成的类进行修改或扩展，但是一般情况下都足够使用了。

自行编写或生成

如果没有使用Tiny的元数据，那么可以自己写个工具类来生成这几个类，也可以手工编写，也可以分分钟编写出来。

DAO编写注意事项

?
1
2
3
4
5
6
import static org.tinygroup.tinysqldsl.CustomTable.CUSTOM;
import static org.tinygroup.tinysqldsl.Delete.delete;
import static org.tinygroup.tinysqldsl.Insert.insertInto;
import static org.tinygroup.tinysqldsl.Select.selectFrom;
import static org.tinygroup.tinysqldsl.base.StatementSqlBuilder.and;
import static org.tinygroup.tinysqldsl.Update.update;



这里用到一个技巧，就是通过静态引入这些要用到的语句或表定义，这样才可以方便的编写DSL格式的语句。

优缺点对比

任意一个方案都有它的优点，也有它的缺点，TinySqlDsl也不例外，这里简单的分析一下，如果不全面，请同学们下面补充，先谢谢了。

优点

  1. 熟悉SQL的同学，上手非常方便，可以说熟悉SQL的同学，可以非常快的上手，甚至不会Java都可以快速编写
  2. 即时提示效果非常好，所有的IDE都提供的语法提示，使得编写SQL时，对于表结构不必再记得一清二楚，第一编写速度快许多，第二不用担心拼写错误而花费大量的调试时间
  3. SQL的构建和Java的处理一体化完成，开发过程不必两个部分先分开再分离
  4. 完美的解决动态SQL方面的问题，不需要复杂的配置，不需要复杂的处理，一切浑然天成
  5. 像写SQL一样写Java数据库业务代码

缺点

  1. 这种方式毕竟和写SQL还是有一点区别，需要花一点时间熟悉
  2. 更多的亲们在下面补充

总结

目前，我们内部进行了试用，整体运行效果良好，后面准备主力推这种方式。

关心代码的同学，可以查看下面的URL：http://git.oschina.net/tinyframework/tiny/tree/master/db/org.tinygroup.tinysqldsl

亲，你有什么意见、建议，请告诉我们吧！

文章标签：
SQL
数据库
Java
数据库连接
关键词：
Java SQL
Java应用
Java数据
SQL应用
SQL数据
悠悠悠然然
目录
相关文章
2G冲浪词条
|
1月前
|
前端开发 JavaScript Java
java常用数据判空、比较和类型转换
本文介绍了Java开发中常见的数据处理技巧，包括数据判空、数据比较和类型转换。详细讲解了字符串、Integer、对象、List、Map、Set及数组的判空方法，推荐使用工具类如StringUtils、Objects等。同时，讨论了基本数据类型与引用数据类型的比较方法，以及自动类型转换和强制类型转换的规则。最后，提供了数值类型与字符串互相转换的具体示例。
2G冲浪词条
89 3
潜意识Java
|
3天前
|
Java 编译器 开发者
Java中的this关键字详解：深入理解与应用
本文深入解析了Java中`this`关键字的多种用法
潜意识Java
28 9
潜意识Java
|
3天前
|
SQL Java 数据库连接
【潜意识Java】MyBatis中的动态SQL灵活、高效的数据库查询以及深度总结
本文详细介绍了MyBatis中的动态SQL功能，涵盖其背景、应用场景及实现方式。
潜意识Java
42 6
潜意识Java
|
3天前
|
Java 应用服务中间件 API
【潜意识Java】javaee中的SpringBoot在Java 开发中的应用与详细分析
本文介绍了 Spring Boot 的核心概念和使用场景，并通过一个实战项目演示了如何构建一个简单的 RESTful API。
潜意识Java
22 5
潜意识Java
|
3天前
|
人工智能 自然语言处理 搜索推荐
【潜意识Java】了解并详细分析Java与AIGC的结合应用和使用方式
本文介绍了如何将Java与AIGC（人工智能生成内容）技术结合，实现智能文本生成。
潜意识Java
21 5
威哥爱编程
|
8天前
|
SQL Java 数据库连接
如何在 Java 代码中使用 JSqlParser 解析复杂的 SQL 语句？
大家好，我是 V 哥。JSqlParser 是一个用于解析 SQL 语句的 Java 库，可将 SQL 解析为 Java 对象树，支持多种 SQL 类型（如 `SELECT`、`INSERT` 等）。它适用于 SQL 分析、修改、生成和验证等场景。通过 Maven 或 Gradle 安装后，可以方便地在 Java 代码中使用。
威哥爱编程
106 11
运营研究坊
|
5天前
|
SQL Java 数据库连接
如何用 Java 校验 SQL 语句的合法性？
本文介绍了五种校验 SQL 语句合法性的方案：1) 使用 JDBC API 的 `execute()` 方法，通过捕获异常判断合法性；2) 使用 JSqlParser 库解析 SQL 语句为 Java 对象；3) 使用正则表达式检查 SQL 语句格式；4) 使用 ANTLR 生成 SQL 解析器；5) 使用 Apache Calcite 解析 SQL。每种方法各有优劣，具体选择取决于需求和个人偏好。需要注意的是，这些方法仅能校验语法合法性，无法保证语义正确性，仍需防范 SQL 注入攻击。
运营研究坊
23 6
潜意识Java
|
3天前
|
SQL Java 数据库连接
【潜意识Java】深入理解MyBatis的Mapper层，以及让数据访问更高效的详细分析
深入理解MyBatis的Mapper层，以及让数据访问更高效的详细分析
潜意识Java
11 1
潜意识Java
|
3天前
|
SQL Java 数据库连接
【潜意识Java】深入理解MyBatis，从基础到高级的深度细节应用
本文详细介绍了MyBatis，一个轻量级的Java持久化框架。内容涵盖MyBatis的基本概念、配置与环境搭建、基础操作（如创建实体类、Mapper接口及映射文件）以及CRUD操作的实现。此外，还深入探讨了高级特性，包括动态SQL和缓存机制。通过代码示例，帮助开发者更好地掌握MyBatis的使用技巧，提升数据库操作效率。总结部分强调了MyBatis的优势及其在实际开发中的应用价值。
潜意识Java
11 1
别惹CC
|
7天前
|
存储 分布式计算 Hadoop
基于Java的Hadoop文件处理系统：高效分布式数据解析与存储
本文介绍了如何借鉴Hadoop的设计思想，使用Java实现其核心功能MapReduce，解决海量数据处理问题。通过类比图书馆管理系统，详细解释了Hadoop的两大组件：HDFS（分布式文件系统）和MapReduce（分布式计算模型）。具体实现了单词统计任务，并扩展支持CSV和JSON格式的数据解析。为了提升性能，引入了Combiner减少中间数据传输，以及自定义Partitioner解决数据倾斜问题。最后总结了Hadoop在大数据处理中的重要性，鼓励Java开发者学习Hadoop以拓展技术边界。
别惹CC
34 7

热门文章

最新文章

  • 1
    Java volatile关键字：你真的懂了吗？
  • 2
    Java最新图形化界面开发技术——JavaFx教程（含UI控件用法介绍、属性绑定、事件监听、FXML）
  • 3
    java项目中jar启动执行日志报错：no main manifest attribute, in /www/wwwroot/snow-server/z-server.jar-jar打包的大小明显小于正常大小如何解决
  • 4
    springboot java.lang.ClassNotFoundException: dm.jdbc.driver.DmDriver应该如何解决
  • 5
    Java多线程编程秘籍：各种方案一网打尽，不要错过！
  • 6
    【Bug合集】——Java大小写引起传参失败，获取值为null的解决方案
  • 7
    Java中的数据类型
  • 8
    Java中的字符集编码入门－增补字符（转载）
  • 9
    JAVA线程池有哪些队列？ 以及它们的适用场景案例
  • 10
    FastExcel：开源的 JAVA 解析 Excel 工具，集成 AI 通过自然语言处理 Excel 文件，完全兼容 EasyExcel
  • 1
    MaxCompute操作报错合集之执行多条SQL语句时，使用同一个实例来运行，遇到报错，该如何解决
    99
  • 2
    MaxCompute产品使用合集之怎么使用SQL查询来获取ODPS中所有的表及字段信息
    158
  • 3
    SQL UNIQUE 约束
    69
  • 4
    SQL NOT NULL 约束
    62
  • 5
    SQL 约束
    39
  • 6
    SQL CREATE TABLE 语句
    54
  • 7
    SQL CREATE DATABASE 语句
    155
  • 8
    MaxCompute产品使用合集之如何识别并执行某个字段的 SQL 语句，并输出结果
    117
  • 9
    MaxCompute产品使用合集之如何提升sql任务并行度
    134
  • 10
    常用工具类---SQL工具，HTTP工具
    67

    • 相关课程

    更多
  • Java面向对象开发
  • Java高级开发
  • Java零基础入门
  • SQL入门与实践
  • 数据库及SQL/MySQL基础
  • SQL进阶及查询

    • 相关电子书

    更多
  • SQL Server 2017
  • GeoMesa on Spark SQL
  • 原生SQL on Hadoop引擎- Apache HAWQ 2.x最新技术解密malili

    • 相关实验场景

    更多
  • PolarDB for AI：在数据库中通过SQL实现AI能力
  • 玩转MaxCompute SQL! 30分钟搞定数据分析挖掘
  • 阿里云平台上进行Java程序的编译与运行
  • 使用SQL语句实现数据插入、修改和删除操作
  • 使用SQL语句实现数据查询操作
  • 使用SQL语句管理索引
    • 下一篇
    阿里云oss简介和如何对接使用