Java 8:ORM已经过时了

标签: java orm 经过 | 发表时间:2014-04-13 19:51 | 作者:
出处:http://it.deepinmind.com

ORM已经过时了

最近几十年来,关于ORM究竟还有没有用的争论一直不断。很多人承认Hibernate和JPA确实很好的解决了不少实际的问题(通常是复杂对象的持久化),但有些人认为,对于面向数据的应用而言,复杂的映射关系则有点大材小用了。

JPA通过在目标类型上使用硬编码的注解,来建立标准的声明式的映射规则,进而完成映射关系。但我们认为,很多以数据为中心的应用不应该受限于注解的局限性,而应该通过一种函数式的方式来解决。Java 8的Steam API终于让我们可以用一种简洁的方式来解决这个问题了!

我们先从一个简单的例子开始,这里我们使用H2的INFORMATION SCHEMA来查询所有的表及字段。我们专门用一个Map >类型的数据结构来存储这个信息。我们用<a href="http://blog.jooq.org" target="blank">来简化SQL的交互。下面来做一下准备工作:jOOQ

   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<Record> result =
        DSL.using(c)
           .fetch(sql)
    }
}

我们已经执行完查询了,现在来看下如何从查询结果中生成Map>信息。

   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)
   );

上述程序会输出如下的结果:

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

这是如何工作的?我们来一步一步的分析下:

   DSL.using(c)
   .fetch(sql)
 
//这里我们把一个列表转化成一个Stream
 .stream() 
// 把Stream中的元素汇集成一个新的类型
   .collect(
 
// 收集器是一个分组操作,会生成一个map
            groupingBy(
 
// 分组操作的key是jOOQ记录的TABLE_NAME字段
       r -> r.getValue("TABLE_NAME"),
 
// 分组操作的值是用这个映射表达式来生成的
       mapping(
 
// 实际上是映射到每条jOOQ记录的COLUMN_NAME字段上
           r -> r.getValue("COLUMN_NAME"),
 
// 然后将所有的值收集到一个java.util.List中
           toList()
       )
   ))
 
// 一旦拿到了<String, List<String>>列表,
// 就可以很容易通过一个lambda表达式来使用它了

   .forEach(
       (table, columns) -> 
           System.out.println(table + ": " + columns)
   );

看明白了吗?第一次使用这些方法的话可能的确需要费点工夫。新的类型,泛型,lambda表达式,这些东西加到一起的话,第一次看到的话的确会有些困惑。最好的办法就是不断的去实践直到你完全掌握了。毕竟来说,和Java Collections API比起来的话,Stream API可是一次革命性的进步。

不过有个好消息就是,这些方法已经确定就是这样,不会再变了。你的每一次实践都是对未来的一次投资。

注意上述的程序用到了如下的静态导入语句:

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

同样还应该注意到,输出的结果和数据库返回的顺序是不一样的。这是因为groupingBy收集器返回的是一个java.util.HashMap。在这个例子中,我们更希望能收集到一个java.util.LinkedHashMap里面,这个集合能保留插入时的顺序。

   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(...);

我们还可以用另一种转化结果的方法。想像一下,我们将要从上面的schema中生成DDL。这很简单。首先,我们需要知道每一列的数据类型。只需要把它加到我们的SQL查询语句中就好了:

   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";

这个例子中还引入了一个新的局部类,用来封装名字和类型属性:

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

现在我们来看下Streams API的方法调用该如何修改:

   result
    .stream()
    .collect(groupingBy(
        r -> r.getValue("TABLE_NAME"),
        LinkedHashMap::new,
        mapping(
 
            // We now collect this new wrapper type
            // instead of just the COLUMN_NAME
            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 + " (");
 
            // Map each "Column" type into a String
            // containing the column specification,
            // and join them using comma and
            // newline. Done!
            System.out.println(
                columns.stream()
                       .map(col -> "  " + col.name +
                                    " " + col.type)
                       .collect(Collectors.joining(",\n"))
            );
 
            System.out.println(");");
        }
    );

输出的结果简直是棒极了!

   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
);

激动吧?看来ORM的时代已经过去了

ORM的时代应该终结了。为什么?因为软件工程里有一个很重要的思想就是使用函数式表达式来进行数据集的转化。函数式编程表达性强,并且非常通用。它是数据及数据流处理的核心。Java开发人员现在也都知道函数式编程,而大家又都用过SQL。相像一下吧。你用SQL来声明表来源,把数据转化成新的元组流,然后要么将它们作为派生表提供给其它更高级的SQL语句来使用,要么将它们交给你的应用程序来处理。

如果你用的是XML的话,你可以使用XSLT来声明XML转化,并通过XProc管道把结果提供给其它XML处理的实体,比如说另一个XSL表格。

使用SQL和Streams API是数据处理里面一个很重要的概念。如果你使用了jOOQ的话,你还可以进行类型安全的数据库访问及查询。想像一下如何使用jOOQ的流API来改写前面的代码,而不是直接使用SQL语句。

整个方法链会是一个流式的数据转化链,就像这样:

   DSL.using(c)
   .select(
       COLUMNS.TABLE_NAME,
       COLUMNS.COLUMN_NAME,
       COLUMNS.TYPE_NAME
   )
   .from(COLUMNS)
   .orderBy(
       COLUMNS.TABLE_CATALOG,
       COLUMNS.TABLE_SCHEMA,
       COLUMNS.TABLE_NAME,
       COLUMNS.ORDINAL_POSITION
   )
   .fetch()  // jOOQ ends here
   .stream() // Streams start here
   .collect(groupingBy(
       r -> r.getValue(COLUMNS.TABLE_NAME),
       LinkedHashMap::new,
       mapping(
           r -> new Column(
               r.getValue(COLUMNS.COLUMN_NAME),
               r.getValue(COLUMNS.TYPE_NAME)
           ),
           toList()
       )
   ))
   .forEach(
       (table, columns) -> {
            // Just emit a CREATE TABLE statement
            System.out.println(
                "CREATE TABLE " + table + " (");
 
            // Map each "Column" type into a String
            // containing the column specification,
            // and join them using comma and
            // newline. Done!
            System.out.println(
                columns.stream()
                       .map(col -> "  " + col.name +
                                    " " + col.type)
                       .collect(Collectors.joining(",\n"))
            );
 
           System.out.println(");");
       }
   );

Java 8代表着未来,而有了jOOQ,Java 8以及Streams API,你可以写出强大的数据转化的API。希望你能和我们一样感到激动!还有更多的Java 8的内容,敬请收看。

原创文章转载请注明出处: Java 8:ORM已经过时了

英文原文链接

相关 [java orm 经过] 推荐:

Java 8:ORM已经过时了

- - Java译站
最近几十年来,关于ORM究竟还有没有用的争论一直不断. 很多人承认Hibernate和JPA确实很好的解决了不少实际的问题(通常是复杂对象的持久化),但有些人认为,对于面向数据的应用而言,复杂的映射关系则有点大材小用了. JPA通过在目标类型上使用硬编码的注解,来建立标准的声明式的映射规则,进而完成映射关系.

文章: MongoDB、Java及ORM

- - InfoQ cn
目前有很多互相竞争的NoSQL产品,它们使用的方式不尽相同,但都能很好地解决大数据问题. MongoDB就是其中一款非常不错的产品. MongoDB是面向文档、无Schema的存储解决方案,它用JSON风格的文档展现、查询、修改数据. MongoDB有很丰富的文档,安装和设置都很简单,而且易于扩展.

Android orm 框架xUtils简介 - lsc183

- - 博客园_首页
  数据库操作建议用ORM框架,简单高效. 这里推荐xUtils,里面包含DBUtils. github地址:https://github.com/wyouflf/xUtils.   获得数据库实例建议用单例模式.   创建一个实体类,对应数据库中的表.     private int id; //主键ID,必须.

看完不懂,你拍我——ORM框架中的对象状态

- - CSDN博客架构设计推荐文章
        不论是EJB3.0还是Hibernate,他们统称为ORM框架. 虽然每个框架对对象的状态都有自己的理解,但是都免不了有共性的东西.         在Hibernate中,对象的状态分为Transient、Persist、Detached,而在EJB中有四种状态,分别为:New、Managed、Detached、Removed.

最受欢迎的5个Android ORM框架

- - 极客521 | 极客521
在开发Android应用时,保存数据有这么几个方式,. 一个是本地保存,一个是放在后台(提供API接口),还有一个是放在开放云服务上(如 SyncAdapter 会是一个不错的选择). 对于第一种方式,即本地数据存储,如嵌入式 SQLite,你可以选择直接使用SQL语句、Content Provider 或 ORM(对象关系数据映射).

为什么要旗帜鲜明地反对 orm 和 sql builder

- - No Headback
这个问题在五六年前和前同事讨论过,没想到这么多年过去了,又要跟其他工程师再讨论一遍,有点恍如隔世. 因为我比较懒,所以记录一篇文章,以后碰到类似的问题就不再掺和了. toC 场景的系统大多要面对较高的 QPS,即使是小型/中型公司使用 MySQL,没有那么高的查询量,单表数据在百万量级也属常见. 无状态的服务当前用 k8s 的 HPA 能力能够做到很好的扩容,结合基本的优化知识,大多数问题能够较好地被初/中级工程师解决.

Android工具库xUtils1.9.8发布-orm性能优化,图片加载优化...

- - 开源中国社区最新新闻
感谢关注xUitls的网友最近一段时间给予的热心反馈,xUtils近期做了很多细节优化之后,功能和api已经稳定.         1.9.8主要更新内容:.         * orm模块添加列类型转换接口,支持自定义类型字段作为列映射;.         * bitmap模块优化默认参数,取消默认动画,加载更快速.

Java中的锁(Locks in Java)

- - 并发编程网 - ifeve.com
原文链接 作者:Jakob Jenkov 译者:申章 校对:丁一. 锁像synchronized同步块一样,是一种线程同步机制,但比Java中的synchronized同步块更复杂. 因为锁(以及其它更高级的线程同步机制)是由synchronized同步块的方式实现的,所以我们还不能完全摆脱synchronized关键字( 译者注:这说的是Java 5之前的情况).

Java PaaS 对决

- 呆瓜 - IBM developerWorks 中国 : 文档库
本文为 Java 开发人员比较了三种主要的 Platform as a Service (PaaS) 产品:Google App Engine for Java、Amazon Elastic Beanstalk 和 CloudBees [email protected] 它分析了每种服务独特的技术方法、优点以及缺点,而且还讨论了常见的解决方法.

Java浮点数

- d0ngd0ng - 译言-电脑/网络/数码科技
Thomas Wang, 2000年3月. Java浮点数的定义大体上遵守了二进制浮点运算标准(即IEEE 754标准). IEEE 754标准提供了浮点数无穷,负无穷,负零和非数字(Not a number,简称NaN)的定义. 在Java开发方面,这些东西经常被多数程序员混淆. 在本文中,我们将讨论计算这些特殊的浮点数相关的结果.