欢迎来到 IT实训基地-南通科迅教育
咨询电话:0513-81107100
便捷,轻巧的Groovy数据库操作
2014/9/24
南通科讯教育
1374
南通零基础IT培训收费标准
  本文主要介绍Groovy对数据的CRUD操作,熟悉groovy.sql包,测试使用的数据库是H2。

  

   1.数据库连接配置

1
2
3
4
5
6
7
//数据库连接配置
def db = [
    url:'jdbc:h2:mem:groovy',
    user:'root',
    password:'root',
    driver:'org.h2.Driver'
];


 2.创建数据库连接,这里使用到Groovy的Sql类。

1
2
//创建数据库连接
def sql = Sql.newInstance(db.url, db.user, db.password, db.driver);

 3.创建数据库表

1
2
3
4
5
6
7
8
//创建数据库表
sql.execute('''
    CREATE TABLE account(
        id integer NOT NULL,
        name varchar(20),
        url varchar(100)
    )
''');


 使用了groovy.sql.Sql类的execute方法执行一条SQL命令,在数据库groovy中创建了表account。


4.向数据库表中写入数据,并查询写入的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
//写入数据
def datas=[
[100'Jack''http://www.jack.net'], 
[101'Groovy''http://groovy.com'], 
[102'Apache''http://apache.org']
];
datas.each { param->
    sql.execute('INSERT INTO account(id, name, url) values(?,?,?)', param);
}
println('Insert After:');
sql.eachRow('SELECT id, name, url FROM account') { row->
    printf('|%d|%s|%s|\n', row.id, row.name, row.url);
}


      从4中的程序可以看出,向表account中写入3条数据记录,然后查询并遍历出查询结果,再这一过程中使用了Groovy的闭包特性,列表数据结构。

      下面是查询的结果:

1
2
3
4
Insert After:
|100|Jack|http://www.jack.net|
|101|Groovy|http://groovy.com|
|102|Apache|http://apache.org|

 5.查询数据

1
2
3
4
//查询第一行数据
def rs=sql.firstRow('SELECT * FROM account');
println('Query First Row:');
println(rs);


      Groovy的Sql类提供了大量的查询方法(具体参见Groovy的API),上面5中的代码是查询第一条记录,返回的类型是GroovyRowReasult,其实现了Map接口。打印输出则是一个Groovy的Map类型表示。如下:

      

1
2
Query First Row:
[ID:100, NAME:ZhangSan, URL:http://aiilive.blog.51cto.com]

 6.更新数据

1
2
3
4
5
6
7
def name='ZhangSan';
def url='http://aiilive.blog.51cto.com';
sql.executeUpdate("UPDATE account SET name=$name, url=$url where id=100");
println('Update After:');
sql.eachRow('SELECT id, name, url FROM account') { row->
    printf('|%d|%s|%s|\n', row.id, row.name, row.url);
}

 7.删除数据

1
2
3
4
5
6
7
8
9
//删除指定条件的数据
name='Groovy';
sql.executeUpdate('DELETE FROM account WHERE name = ?', [name]);
name='Apache';
sql.execute('DELETE FROM account WHERE name=:name', ['name':name]);
println('Delete After:');
sql.eachRow('SELECT id, name, url FROM account') { row->
    printf('|%d|%s|%s|\n', row.id, row.name, row.url);
}


  8.使用DataSet来处理数据

     DataSet是Sql类的直接子类,用DataSet来操作数据库表更加有操作对象的样子。

1
2
3
4
5
6
7
8
9
10
11
12
13
def account=sql.dataSet('account');
account.add([id:103, name:'h2', url:'http://h2.org']);
name='51cto';
url='http://www.51cto.com';
account.add([id:104, name:name, url:url]);
println('DataSet Update After');
account.eachRow('SELECT id, name, url FROM account') { row->
    printf('|%d|%s|%s|\n', row.id, row.name, row.url);
};
def accountRows=account.rows();
accountRows.each { row->
    printf('|%d|%s|%s|\n', row.id, row.name, row.url);
}


   如上dataSet的参数account表示数据库中的表名。account是一个DataSet类型的对象,通过add方法想数据库表中添加一条记录,通过rows方法返回数据库表中的所有记录,如果rows方法添加参数则可以实现分页的功能。

 

   上面通过groovy.sql包提供的API实现了数据库的基本操作,而该包中的类的其它更多的方法能够实现更丰富的操作。下面介绍数据库表和对象的映射操作以及集成Spring来操作数据库表。


 数据库表和对象的映射操作:

  1.准备工作

     创建一个抽象的类SqlQuery

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
import groovy.sql.*;
abstract class SqlQuery {
def sql;
def query;
def SqlQuery(sql,query){
this.sql=sql;
this.query=query;
}
def execute(){
def rowList=sql.rows(query);
def results=[];
def size=rowList.size();
0.upto(size-1) { index->
results <<this.mapRow(rowList[index]);
}
return results;
}
def abstract mapRow(row);
}
     创建一个Account类,其属性对应account表的字段
class Account {
def id;
def name;
def url;
@Override
public String toString() {
return "|$id|$name|$url|";
}
}

    创建一个AccountQuery类继承SqlQuery类并实现其中的抽象方法rowMap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import com.demo.db.SqlQuery;
class AccountQuery extends SqlQuery {
def AccountQuery(sql){
super(sql, 'SELECT id, name, url FROM account');
}
@Override
public Object mapRow(Object row) {
//映射非常之灵活
//def acc=new Account(id:row.getAt('id'),name:row.getAt('name'),url:row.getAt('url'));
//def acc=new Account(id:row.getAt(0),name:row.getAt(1),url:row.getAt(2));
def acc=new Account(
id:row.getProperty('id'),
name:row.getProperty('name'),
url:row.getProperty('url'));
return acc;
}
}


   AccountQuery类实现了rowMap方法,正是该方法将对象和表记录关联起来的,即达到了Table - Object的映射效果。

  注意:上面代码中的注释部分是实现同样功能的不同写法。


 2.通过SqlQuery类来查询account表的数据

1
2
3
4
5
6
7
//表映射对象查询
def accountQuery=new AccountQuery(sql);
def accList=accountQuery.execute();
println 'Table <-> Object Query: ';
accList.each { acc->
    println acc.toString();
}


accList则是Account对象的一个数组集合,这样就实现了数据库表和对象的映射操作。


集成Spring来操作数据库表:

 1.准备工作

    Spring提供了一个MappingSqlQuery类,我们可以用AccountQuery继承该类并实行其中的rowMap方法来达到数据库表和对象的映射。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import com.demo.db.Account;
import org.springframework.jdbc.object.MappingSqlQuery
class AccountQuery extends MappingSqlQuery {
def AccountQuery(ds){
super(ds,'SELECT id, name, url FROM account');
this.compile();
}
@Override
protected Object mapRow(ResultSet rs, int rowNumber) throws SQLException {
def acc=new Account(
id:rs.getInt('id'),
name:rs.getString('name'),
url:rs.getString('url'));
return acc;
}
}


   需要注意的地方是Spring的MappingSqlQuery类的带参数构造方法需要提供一个DataSource对象和查询的SQL命令。


   创建一个Account类的DAO类,AccountDAO来实现数据库的操作,可以定义一个接口,然后另外实现该接口。应用程序操作数据库则只需要依赖定义的接口即可。这里省略了接口的定义。

1
2
3
4
5
6
7
class AccountDao {
def ds;
def getAccounts(){
def aq=new AccountQuery(ds);
return aq.execute();
}
}

 AccountDao有一个getAccounts方法,通过该方法则可以获取到表account的所有记录,通过AccountQuery的Mapping映射,将返回一个集合对象。


2.通过AccountDao类操作数据库

1
2
3
4
5
6
7
8
//集成Spring
def ds=new DriverManagerDataSource(db.url, db.user, db.password);
def accountDao=new AccountDao(ds:ds);
accLists=accountDao.getAccounts();
println 'Spring MappingSqlObject Query: ';
accList.each { acc->
    println acc.toString();
}


     至此Groovy操作数据库就到这里了。Groovy让Java操作数据库变得轻巧许多,同时又没有引入多余复杂的API负担。了解PHP的数据库操作就能很快感受到Groovy让Java操作数据库不那么繁琐了。

77
关闭
先学习,后交费申请表
每期5位名额
在线咨询
免费电话
QQ联系
先学习,后交费
TOP
您好,您想咨询哪门课程呢?
关于我们
机构简介
官方资讯
地理位置
联系我们
0513-91107100
周一至周六     8:30-21:00
微信扫我送教程
手机端访问
南通科迅教育信息咨询有限公司     苏ICP备15009282号     联系地址:江苏省南通市人民中路23-6号新亚大厦三楼             法律顾问:江苏瑞慈律师事务所     Copyright 2008-