用 Groovy 进行 JDBC 编程

发布时间：2020-12-14 16:41:15 所属栏目：大数据来源：网络整理

导读：用 Groovy 进行 JDBC 编程用 GroovySql 构建下一个报告应用程序在? 实战 Groovy 系列的前几期中，您已经了解了 Groovy 的一些非常优美的特性。在?第 1 期中，学习了如何用 Groovy 对普通的 Java? 代码进行更简单、更迅速的单元测试。在?第 2 期中，看到了

用 Groovy 进行 JDBC 编程

用 GroovySql 构建下一个报告应用程序

在?实战 Groovy系列的前几期中，您已经了解了 Groovy 的一些非常优美的特性。在?第 1 期中，学习了如何用 Groovy 对普通的 Java? 代码进行更简单、更迅速的单元测试。在?第 2 期中，看到了 Groovy 能够给 Ant 构建带来的表现能力。这一次您会发现 Groovy 的另一个实际应用，即如何用它迅速地构建基于 SQL 的报告应用程序。

脚本语言对于迅速地构建报告应用程序来说是典型的优秀工具，但是构建这类应用程序对于 Groovy 来说特别容易。Groovy 轻量级的语法可以消除 Java 语言的 JDBC 的一些繁冗之处，但是它真正的威力来自闭包，闭包很优雅地把资源管理的责任从客户机转移到框架本身，因此更容易举重若轻。

在本月的文章中，我先从 GroovySql 的概述开始，然后通过构建一个简单的数据报告应用程序，向您演示如何将它们投入工作。为了从讨论中得到最大收获，您应当熟悉 Java 平台上的 JDBC 编程。您可能还想回顾?上个月对 Groovy 中闭包的介绍，因为它们在这里扮演了重要的角色。但是，本月关注的重点概念是迭代（iteration），因为迭代器在 Groovy 对 JDBC 的增强中扮演着重要角色。所以，我将从 Groovy 中迭代器的概述开始。

进入迭代器

迭代是各种编程环境中最常见、最有用的技术。?迭代器是某种代码助手，可以让您迅速地访问任何集合或容器中的数据，每次一个数据。Groovy 把迭代器变成隐含的，使用起来更简单，从而改善了 Java 语言的迭代器概念。在清单 1 中，您可以看到使用 Java 语言打印?String集合的每个元素需要做的工作。

清单 1. 普通 Java 代码中的迭代器

 
         import java.util.ArrayList;  
        
         import java.util.Collection;  
        
         import java.util.Iterator;  
        
         public class JavaIteratorExample {  
        
         ? 
         public static void main(String[] args) {  
        
         ???? 
         Collection coll = new ArrayList();  
        
         coll.add("JMS");  
        
         coll.add("EJB");  
        
         coll.add("JMX");  
        
         for(Iterator iter = coll.iterator(); iter.hasNext();){  
        
         ??????? 
         System.out.println(iter.next());  
        
         }  
        
         }  
        
         }

在清单 2 中，您可以看到 Groovy 如何简化了我的工作。在这里，我跳过了?Iterator接口，直接在集合上使用类似迭代器的方法。而且， Groovy 的迭代器方法接受闭包，每个迭代中都会调用闭包。清单 2 显示了前面基于 Java 语言的示例用 Groovy 转换后的样子。

清单 2. Groovy 中的迭代器

class IteratorExample1{

 
         ?? 
         static void main(args) {

 
         coll = ["JMS","EJB","JMX"]  
        

 
         coll.each{ item | println item }  
        

}

 
          关于本系列 把任何一个工具集成进您的开发实践的关键是，知道什么时候使用它而什么时候把它留在箱子中。脚本语言可以是您的工具箱中极为强大的附件，但是只有在恰当地应用到适当的场景时才是这样。为了这个目标，?实战 Groovy这一系列文章专门介绍了 Groovy 的实际应用，并教给您什么时候、如何成功地应用它们。

`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){}  
        

}

}

 
          清单 4. 欢迎使用 GroovySql ！

import groovy.sql.Sql

 
         class GroovySqlExample1{  
        

 
         static void main(args) {  
        

 
         sql = Sql.newInstance("jdbc:mysql://localhost:3306/words","words", 
        

 
         sql.eachRow("select * from word"){ row |  
        

 
         ?????? 
         println row.word_id + " " + row.spelling + " " + row.part_of_speech

}

}

 
          清单 5. GroovySql 中的?it变量

sql.eachRow("select * from word"){ println it.spelling +? " ${it.part_of_speech}"}

}

 
          清单 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  
         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 创建数据集

class GroovyDatasetsExample1{

 
         ????????? 
         words = sql.dataSet("word")

 
         words.each{ word |  
        

 
         println word.word_id + " " + word.spelling  
        

}

 
         words.add(word_id:"9999",spelling:"clerisy",part_of_speech:"Noun")  
        

}

 
          清单 11. 用 GroovySql 进行负索引

sql.eachRow("select * from word"){ grs |

 
         println "-1? = " + grs.getAt(-1) //prints spelling  
        

 
         println "2? = " + grs.getAt(2) //prints spelling  
        

 
          运行时间。
 处理的全部查询数量。
 特定查询的比例，例如?insert、?update和?select。
 用 GroovySql 从 MySQL 数据库得到这个信息太容易了。由于您正在为开发团队构建状态信息，所以您可能只是从一个简单的命令行报告开始，但是您可以在后面的迭代中把报告放在 Web 上。这个报告例子的用例看起来可能像这样：

 c. 全部?insert数

 d. 全部?update数

 e. 全部?select数

3.

 a. 每分钟查询数

 b. 全部?insert查询百分比

 c. 全部?update查询百分比

 d. 全部?select查询百分比

1.	连接到我们的应用程序的活动数据库。
2.	发布?`show status`查询并捕获：
?	a. 运行时间
b. 全部查询数
使用这些数据点，计算：

 
 在清单 12 中，您可以看到最终结果：一个将会报告所需数据库统计信息的应用程序。代码开始的几行获得到生产数据库的连接，接着是一系列?show status查询，让您计算每分钟的查询数，并按类型把它们分开。请注意像?uptime这样的变量如何在定义的时候就创建。 
 清单 12. 用 GroovySql 进行数据库状态报告 
 
 
  
   
   class DBStatusReport{  
         sql = Sql.newInstance("jdbc:mysql://yourserver.anywhere/tiger","scott",monospace!important; min-height:inherit!important'>???????? 
         "tiger",monospace!important; min-height:inherit!important'>sql.eachRow("show status"){ status |  
        
 
         if(status.variable_name == "Uptime"){  
        
 
         uptime =? status[1]  
        
 
         }else if (status.variable_name == "Questions"){  
        
 
         questions =? status[1]  
        
 
         }  
        
 
         println "Uptime for Database: " + uptime  
        
 
         println "Number of Queries: " + questions  
        
 
         println "Queries per Minute = "  
        
 
         + Integer.valueOf(questions)/Integer.valueOf(uptime) 
        
 
         sql.eachRow("show status like 'Com_%'"){ status |  
        
 
         if(status.variable_name == "Com_insert"){  
        
 
         insertnum =? Integer.valueOf(status[1])  
        
 
         }else if (status.variable_name == "Com_select"){  
        
 
         selectnum =? Integer.valueOf(status[1])  
        
 
         }else if (status.variable_name == "Com_update"){  
        
 
         updatenum =? Integer.valueOf(status[1])  
        
 
         }  
        
 
         }  
        
 
         println "% Queries Inserts = " + 100 * (insertnum / Integer.valueOf(uptime))  
        
 
         println "% Queries Selects = " + 100 * (selectnum / Integer.valueOf(uptime))  
        
 
         println "% Queries Updates = " + 100 * (updatenum / Integer.valueOf(uptime))  
        
 
         }  
        
 
         } 
        
 
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
     
 
  
 
 结束语 
 在?实战 Groovy本月的这一期文章中，您看到了 GroovySql 如何简化 JDBC 编程。这个干净漂亮的 API 把闭包和迭代器与 Groovy 轻松的语法结合在一起，有助于在 Java 平台上进行快速数据库应用程序开发。最强大的是，GroovySql 把资源管理任务从开发人员转移到底层的 Groovy 框架，这使您可以把精力集中在更加重要的查询和查询结果上。但是不要只记住我这句话。下次如果您被要求处理 JDBC 的麻烦事，那时可以试试小小的 GroovySql 魔力。然后给我发封电子邮件告诉我您的体会。


            
        	


                        （编辑：李大同）
【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!