神奇的GroovySQL

原文地址：http://blog.itpub.net/17074730/viewspace-543127/






GroovySql 简介
Groovy 的 SQL 魔力在于一个叫做 GroovySql 的精致的 API。使用闭包和迭代器，GroovySql 干净漂亮地把 JDBC 的资源管理职责从开发人员转移到 Groovy 框架。这么做之后，就消除了 JDBC 编程的繁琐，从而使您可以把注意力放在查询和查询结果上。
如果您忘记了普通的 Java JDBC 编程有多麻烦，我会很高兴提醒您！在清单 3 中，您可以看到用 Java 语言进行的一个简单的 JDBC 编程示例。

清单 3. 普通 Java 的 JDBC 编程
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JDBCExample1 {
  public static void main(String[] args) {
    Connection con = null;
    Statement stmt = null;
    ResultSet rs = null;
    try{
      Class.forName("org.gjt.mm.mysql.Driver");
      con = DriverManager.getConnection("jdbc:mysql://localhost:3306/words",
           "words", "words");
      stmt = con.createStatement();
      rs = stmt.executeQuery("select * from word");
      while (rs.next()) {
        System.out.println("word id: " + rs.getLong(1) +
            " spelling: " + rs.getString(2) +
            " part of speech: " + rs.getString(3));
      }
    }catch(SQLException e){
      e.printStackTrace();
    }catch(ClassNotFoundException e){
      e.printStackTrace();
    }finally{
      try{rs.close();}catch(Exception e){}
      try{stmt.close();}catch(Exception e){}
      try{con.close();}catch(Exception e){}
   }
  }
}

哇。清单 3 包含近 40 行代码，就是为了查看表中的内容！如果用 GroovySql，您猜要用多少行？如果您猜超过 10 行，那么您就错了。请看清单 4 中，Groovy 替我处理底层资源，从而非常漂亮地让我把注意力集中在手边的任务 —— 执行一个简单的查询。

清单 4. 欢迎使用 GroovySql！
import groovy.sql.Sql
class GroovySqlExample1{
  static void main(args) {
    sql = Sql.newInstance("jdbc:mysql://localhost:3306/words", "words",
           "words", "org.gjt.mm.mysql.Driver")
    sql.eachRow("select * from word"){ row |
       println row.word_id + " " + row.spelling + " " + row.part_of_speech
    }
  }
}

真不错。只用了几行，我就编码出与清单 3 相同的行为，不用关闭 Connection，也不用关闭 ResultSet，或者在 JDBC 编程中可以找到的任何其他熟悉的重要特性。这是多么激动人心的事情啊，并且还是如此容易。现在让我来仔细介绍我是如何做到的。





回页首


执行简单的查询
在 清单 4 的第一行中，我创建了 Groovy 的 Sql 类的实例，用它来连接指定的数据库。在这个例子中，我创建了 Sql 实例，指向在我机器上运行的 MySQL 数据库。到现在为止都非常基本，对么？真正重要的是一下部分，迭代器和闭包一两下就显示出了它们的威力。
请把 eachRow 方法当成传进来的查询生成的结果上的迭代器。在底层，您可以看到返回了 JDBC ResultSet 对象，它的内容被传递进 for 循环。所以，每个迭代都要执行我传递进去的闭包。如果在数据库中找到的 word 表只有三行，那么闭包就会执行三次 —— 打印出 word_id、 spelling 和 part_of_speech 的值。
如果将等式中我指定的变量 row 去掉，而使用 Groovy 的一个隐含变量 it（它恰好就是迭代器的实例），代码可以进一步简化。如果我这样做，那么前面的代码就可以写成清单 5 所示的这样：

清单 5. GroovySql 中的 it 变量
import groovy.sql.Sql
class GroovySqlExample1{
  static void main(args) {
    sql = Sql.newInstance("jdbc:mysql://localhost:3306/words", "words",
           "words", "org.gjt.mm.mysql.Driver")
    sql.eachRow("select * from word"){ println it.spelling +  " ${it.part_of_speech}"}
  }
}

在这个代码中，我可以删除 row 变量，用 it 代替。而且，我还能在 String 语句中引用 it 变量，就像我在 ${it.part_of_speech} 中所做的那样。





回页首


执行更复杂的查询
前面的例子相当简单，但是 GroovySql 在处理更复杂的数据操纵查询（例如 insert、 update 和 delete 查询）时，也是非常可靠的。 对于这些查询，您没有必要用迭代器，所以 Groovy 的 Sql 对象另外提供了 execute 和 executeUpdate 方法。这些方法让人想起普通的 JDBC statement 类，它也有 execute 和 executeUpdate 方法。
在清单 6 中，您看到一个简单的 insert，它再次以 ${} 语法使用变量替换。这个代码只是向 word 表插入一个新行。

清单 6. 用 GroovySql 进行插入
wid = 999
spelling = "Nefarious"
pospeech = "Adjective"
sql.execute("insert into word (word_id, spelling, part_of_speech)
   values (${wid}, ${spelling}, ${pospeech})")

Groovy 还提供 execute 方法的一个重载版本，它接收一列值，这些值与查询中发现的 ? 元素对应。在清单 7 中，我简单地查询了 word 表中的某个行。在底层，GroovySql 创建了普通 Java 语言 java.sql.PreparedStatement 的一个实例。

清单 7. 用 GroovySql 创建 PreparedStatement 的实例
val = sql.execute("select * from word where word_id = ?", [5])

更新的方式基本相同，也使用 executeUpdate 方法。还请注意，在清单 8 中 executeUpdate 方法接收一列值，与查询中的 ? 元素对应。

清单 8. 用 GroovySql 进行更新
nid = 5
spelling = "Nefarious"
sql.executeUpdate("update word set word_id = ? where spelling = ?", [nid, spelling])

删除实际上与插入相同，当然，语法不同，如清单 9 所示。

清单 9. 用 GroovySql 进行删除
sql.execute("delete from word where word_id = ?" , [5])






回页首


简化数据操纵
任何想简化 JDBC 编程的 API 或工具最好有一些好的数据操纵特性，在这一节中，我要向您再介绍三个。
数据集(DataSet)
构建于 GroovySql 简单性的基础之上，GroovySql 支持 DataSet 类型的概念，这基本上是数据库表的对象表示。使用 DataSet，您可以在行中遍历，也可以添加新行。实际上，用数据集是方便地表示表格的公共数据集合的方式。
但是，目前 GroovySql DataSet 类型的不足之处是它们没有代表关系；它们只是与数据库表的一对一映射。在清单 10 中，我创建了一个来自 word 表的 DataSet。

清单 10. 用 GroovySql 创建数据集
import groovy.sql.Sql
class GroovyDatasetsExample1{
  static void main(args) {
    sql = Sql.newInstance("jdbc:mysql://localhost:3306/words", "words",
          "words", "org.gjt.mm.mysql.Driver")
    words = sql.dataSet("word")
    words.each{ word |
     println word.word_id + " " + word.spelling
    }
    words.add(word_id:"9999", spelling:"clerisy", part_of_speech:"Noun")
  }
}

您可以看到，GroovySql 的 DataSet 类型可以容易地用 each 方法对表的内容进行遍历，容易地用 add 方法添加新行， add 方法接受一个 map 表示需要的数据。
使用存储过程和负索引
存储过程调用和负索引（negative indexing）可能是数据操纵的重要方面。GroovySql 使存储过程调用简单得就像在 Sql 类上使用 call 方法一样。对于负索引， GroovySql 提供了自己增强的 ResultSet 类型，它工作起来非常像 Groovy 中的 collections。例如，如果您想获取结果集中的最后一个项目，您可以像清单 11 所示的那样做：

清单 11. 用 GroovySql 进行负索引
sql.eachRow("select * from word"){ grs |
   println "-1  = " + grs.getAt(-1) //prints spelling
   println "2  = " + grs.getAt(2) //prints spelling
}

您在清单 11 中可以看到，提取结果集的最后一个元素非常容易，只要用 -1 作索引就可以。如果想试试，我也可以用索引 2 访问同一元素。
这些例子非常简单，但是它们能够让您很好地感觉到 GroovySql 的威力。