【爱上Java8】Java 8 不在需要ORM了

前两天在网上看到一篇文章,说java8不再需要ORM了。看了以后 ，觉得还可以，再次做一下分享。

首先，我要对ORM做一些吐槽，以hibernate为代表的ORM简直见识开发者的噩梦呀。本人对此深恶痛绝。什么one-to-many, many-to-many ，搞死人不说，还特别麻烦，该死的延迟加载等等，用起来就是非常不爽。这里我还是觉得MyBatis靠谱一点。很早就想吐槽Hibernate的，一直没机会。

不需要ORM，java8提供了什么东东呢？那就是流式api以及函数式编程。

来看一个简单的例子，这里使用H2（我超喜欢H2，绝对是个好东西呀~~~），访问H2的系统表INFORMATION_SCHEMA ，去收集表和列的关系。

数据结构使用 Map<String, List<String>>，使用jOOQ来操作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

public static void main(String[] args)
throws Exception {
Class.forName("org.h2.Driver");
try (Connection c = getConnection(
"jdbc:h2:~/sql-goodies-with-mapping",
"sa", "")) {
// This SQL statement produces all table
// names and column names in the H2 schema
String sql =
"select table_name, column_name " +
"from information_schema.columns " +
"order by " +
"table_catalog, " +
"table_schema, " +
"table_name, " +
"ordinal_position";
// This is jOOQ's way of executing the above
// statement. Result implements List, which
// makes subsequent steps much easier
Result result =
DSL.using(c)
.fetch(sql)
}
}

产生处理结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

DSL.using(c)
   .fetch(sql)
   .stream()
   .collect(groupingBy(
       r -> r.getValue("TABLE_NAME"),
       mapping(
           r -> r.getValue("COLUMN_NAME"),
           toList()
       )
   ))
   .forEach(
       (table, columns) -> 
           System.out.println(table + ": " + columns)
   );

输出如下：

1
2
3

FUNCTION_COLUMNS: [ALIAS_CATALOG, ALIAS_SCHEMA, ...]
CONSTANTS: [CONSTANT_CATALOG, CONSTANT_SCHEMA, ...]
SEQUENCES: [SEQUENCE_CATALOG, SEQUENCE_SCHEMA, ...]

它的工作过程如下的注释：

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

DSL.using(c)
   .fetch(sql)
 
//将List转为流
   .stream()
 
// 将流内的内容转入另外一个集合
   .collect(
 
// 用group操作产生一个Map
            groupingBy(
 
//  指定Group操作的key
       r -> r.getValue("TABLE_NAME"),
 
// 这个mapping返回group操作的内容
       mapping(
 
// 我要的值就是表的列名啦
           r -> r.getValue("COLUMN_NAME"),
 
// 将收集到的东东转为List
           toList()
       )
   ))
 
// 得到集合后，用lambda 表达式输出
   .forEach(
       (table, columns) -> 
           System.out.println(table + ": " + columns)
   );

以上代码直接用流式表达式处理了SQL的返回。当然，这是有些革命性的变化，如果你不喜欢java这么写，理解起来要花点时间，
但是，习惯的话，应该还好。
这里注意一下，以上代码有一个static import

1

import static java.util.stream.Collectors.*;

还有一个问题，就是排序，因为我们用了HashMap，如果需要排序就可以用 LinkedHashMap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

DSL.using(c)
   .fetch(sql)
   .stream()
   .collect(groupingBy(
       r -> r.getValue("TABLE_NAME"),
 
       // Add this Supplier to the groupingBy
       // method call
       LinkedHashMap::new,
       mapping(
           r -> r.getValue("COLUMN_NAME"),
           toList()
       )
   ))
   .forEach(...);

LinkedHashMap的特点以及与HashMap的区别，大家可以参考这本书看看。

更进一步，让我们看看如何根据数据库的信息，来产生对应的DDL脚本。首先，我们要取得我们需要的信息，列明，数据类型云云。

1
2
3
4
5
6
7
8
9
10
11

String sql =
    "select " +
        "table_name, " +
        "column_name, " +
        "type_name " + // Add the column type
    "from information_schema.columns " +
    "order by " +
        "table_catalog, " +
        "table_schema, " +
        "table_name, " +
        "ordinal_position";

引入一个类，来包装一下，

1
2
3
4
5
6
7
8
9

class Column {
    final String name;
    final String type;
 
    Column(String name, String type) {
        this.name = name;
        this.type = type;
    }
}

改一下我们的流式代码，让他生成DDL

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

result
    .stream()
    .collect(groupingBy(
        r -> r.getValue("TABLE_NAME"),
        LinkedHashMap::new,
        mapping(
 
            // 我们要包装到我们自己的类里去了哦~~~
            r -> new Column(
                r.getValue("COLUMN_NAME", String.class),
                r.getValue("TYPE_NAME", String.class)
            ),
            toList()
        )
    ))
    .forEach(
        (table, columns) -> {
 
            // Just emit a CREATE TABLE statement
            System.out.println(
                "CREATE TABLE " + table + " (");
 
            System.out.println(
                columns.stream()
                       .map(col -> "  " + col.name +
                                    " " + col.type)
                       .collect(Collectors.joining(",\n"))
            );
 
            System.out.println(");");
        }
    );

以下就是程序的输出，完美的DDL脚本：

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

CREATE TABLE CATALOGS(
  CATALOG_NAME VARCHAR
);
CREATE TABLE COLLATIONS(
  NAME VARCHAR,
  KEY VARCHAR
);
CREATE TABLE COLUMNS(
  TABLE_CATALOG VARCHAR,
  TABLE_SCHEMA VARCHAR,
  TABLE_NAME VARCHAR,
  COLUMN_NAME VARCHAR,
  ORDINAL_POSITION INTEGER,
  COLUMN_DEFAULT VARCHAR,
  IS_NULLABLE VARCHAR,
  DATA_TYPE INTEGER,
  CHARACTER_MAXIMUM_LENGTH INTEGER,
  CHARACTER_OCTET_LENGTH INTEGER,
  NUMERIC_PRECISION INTEGER,
  NUMERIC_PRECISION_RADIX INTEGER,
  NUMERIC_SCALE INTEGER,
  CHARACTER_SET_NAME VARCHAR,
  COLLATION_NAME VARCHAR,
  TYPE_NAME VARCHAR,
  NULLABLE INTEGER,
  IS_COMPUTED BOOLEAN,
  SELECTIVITY INTEGER,
  CHECK_CONSTRAINT VARCHAR,
  SEQUENCE_NAME VARCHAR,
  REMARKS VARCHAR,
  SOURCE_DATA_TYPE SMALLINT
);