浅浅地封装一层 JDBC-阿里云开发者社区

写在数据库重构前面的话——说说我之前认识的数据库

数据库向来是个“老大难”问题。好的数据库设计与好的数据库程序密切相关，一个逻辑清楚、管理维护方便的程序往往离不开优秀的数据库表设计。本人之前就是基础不牢，对这个问题认识不够，忽视了数据库表设计，导致了后来程序层（ASP/JSP）怎么写都不顺当——好生烦恼！究其原因，就是把关系型的数据库的问题简单化、想当然。如今是该正视问题的时候了！

首先我最开始接触的是 FoxBase，那时是在学校的数据库课程上，还有学校日常的考勤工作，我也有幸参与了，都是用 FoxBase/FoxPro 进行管理的。现在语法已经忘光了，感觉那时候学得容易，也直观。学校里也开了一课 Access，但老师讲得敷衍（确实如此，不是我不尊重老师）。

后来自学 ASP，也涉及到 SQL。于是简单学习了一下 SELECT/UPDATE/INSERT INTO 等这样的操作语句。因为是自学，没有经过数据库理论系统的学习。我们知道，数据库尤其是关系型数据库是一门独立的学科，在计算机课程中显得十分重要。这门课除 SQL 操作语句之外，其中相当于知识点都是偏理论和数学的，例如关系代数、范式等。我惧怕这些知识，因此也没有经过扎实的学习，而是参考了一个简单 ASP 新闻发布系统，参考了里面 Access 的设计。不得不说，我可作为一个反面例子，说明这样求学的心态是如何浮躁的。

有一点还记得的，就是学会了 SQL Join 语句之后，好像立刻获得什么重大成就那样子，马上兴奋异常。不过确实感觉到了 Join 的强大，可以做以前做不了的很多事情——窃以为，这就是“自学”的好处吧，容易获得成就感，哪怕是一点一滴的，且自我感觉良好。

后学我花时间在语言方面比较多，也没怎么关注数据库。倒是接触 Java/Hibernate 之际了解了什么是 ORM，知道啥是“阻抗不匹配”。

在了 ROR 框架的时候，发现其所使用 ActiveRecord 不错，感觉理解起来挺容易。于是尝试自己写 ActiveRecord 的实现，还是用 ASP/Jscript 的。后来归纳总结，所谓 ActiveRecord 属于数据库模式中的一种，所谓 belongsTo、hasMany 无非就是原来的“一对多”、“多对一”之类的，没有跳出数据库的“五指山”——而那时的我盲目跟风，只知其一不知其二。

再后来业界“NoSQL”的蹿红，使得我更有理由“鄙视”关系型数据库，觉得反正用不用 MySQL、SQL Server 都可以——唉，无知呐。

ORM 会给人一种错觉：使人觉得数据库的问题可以在语言层面得到解决。我为此开始了“孜孜不倦”尝试，从 ASP 到 JSP，总以为可以封装好 SQL。然而，我却不是赞成使用 Hibernate 这些框架，甚至轻视！感觉其中无非就是 SQL 语句的拼凑——要不我自己来吧！我甚至到了一种地步，把面向对象的“继承”生搬硬套到表设计中！那，当然是要“闹笑话”的——唉！

“表设计很重要”，这是我一个写后台的同事说的。我的表那么多冗余、设计的那么不自然，——为什么我还能不以为然、还能容忍这种情况存在？难道 Java 层面就可以把 SQL 完全搞定？？

总之，我一再反思，希望找出问题的根源。

目标

请注意：该文章已过时，请留意最新版本，相关资源在下一节《Bigfoot 数据库 CRUD 举例》。

众所周知，通过 JDBC 我们可以向数据库询问和写入数据（增、删、改、查）。但直接使用 JDBC 开发效率不高，于是我们想想怎么封装一层吧！

大目标：轻量级，使数据库操作更简单、更顺手、更纯粹！

目标有大必有小。小的具体目标如下：

使用 Tomcat 自带的数据库连接池 JDBC Pool。
提倡先写 SQL，看是否 OK，再封装。实际上，无论什么业务，都是产生 SQL 然后交给 JDBC 执行的，所以 SQL 是最终的“编译”结果。
封装是什么封装方法？这是一种半自动化 ORM，既非手工的 SQL 字符串拼凑，而是提供一种简单的方法维护 SQL。不用写直接写 SQL，而是 Java + SQL。
即使封装 SQL 语句，也不要过渡封装。
采用 Map 为记录载体
与 JS 引擎 Rhino 无缝对接，用 JS 定义一些方法
抛弃 Java POJO，以 JS 定义实体，适合前后台所使用

缺点是：一、通用性不会很强，只限于当前框架所使用，约定的关系较多，耦合紧；二、当前只针对 MySQL/SQLite。

基础模块

之所以有这个基础模块，其实是排除了 DAO（Data Access Object）所剩余的 SQL 包下面的内容。关于 DAO 模块，后面会论述。

Base

Base 围绕下面几个常见的问题而设，也就是把一些共性的特征给抽象出来，是底层的类。Base 是一个抽象类（Abstract Class），虽然他们之间没有必然的关联关系，但还是形成了这个类，属于“自底向上”的设计。使用这个抽象类有下面介绍的 Reader、Writer。

具体流程参见最新源码：http://code.taobao.org/p/bigfoot_v2/src/java/com/ajaxjs/framework/sql/Base.java。

一言蔽之，Connection 对象，每个数据库首先都得创建这个对象——所以是必须的；TableName，不言而喻，怎么能不知道表名?；id 是指列名具体是什么？id 还是 uid，要说清楚；最后的资源释放操作，是关于 Connection、ResultSet 和 Statement 的。于是围绕上述几点，有下面的方法。

这些字段均是 getter/setter。Conn 就特殊点，因为初始化数据库连接对象提供了若干重载方法，适应不同场合。针对 Conn 还有释放资源的方法。

Result

具体流程参见最新源码：http://code.taobao.org/p/bigfoot_v2/src/java/com/ajaxjs/framework/sql/Result.java。

数据，可定义为有意义的实体，它涉及事物的存在形式——通常不止一种形式，在数据库里是一种形式，在 Java 程序里是一种形式，在接口层面又是另外一种形式。针对查询操作，应该有专门的类保存数据的不同形式，有 JSON、Map 和 Map[]，还有记录操作过的 SQL 语句，保存起来在日志文件中。Result 对象没有使用 getter/setter，而是直接使用对象的属性。结构如下。

/**
 * 查询结果
 * @author Frank Cheung
 */
public class Result {
	/**
	 * 返回前端的 JSON 字符串
	 */
	public String json = null;
	
	/**
	 * 结果集合，复数，如果单数则是 jsArr.get(0)
	 */
	public NativeArray jsArr = null;
	
	/**
	 * 执行过查询的那个 SQL 语句。可用于追溯
	 */
	public String sqlStatement = null;
	
	/**
	 * 已转换为 Map 的结果，如果复数则是 null
	 */
	public Map<String, Object> result  = null;
	
	/**
	 * 已转换为 Map 结果集合，如果单数则是 null
	 */
	public Map<String, Object>[] results = null;
	
	/**
	 * 查询耗时
	 */
	public Date queryTime = null;
}

该类的设计充分符合了为方便 JSON 接口输出的原则（故内部也是用 Rhino 遍历 ResutSet，直接返回 JSON）。接口每次请求完毕，都会读取 Result.json 的结果。如果要在 Java 中作业务逻辑处理，则读取 Result.result/results 即可。

SQL

具体流程参见最新源码：http://code.taobao.org/p/bigfoot_v2/src/java/com/ajaxjs/framework/sql/Sql.java。
单元测试：http://code.taobao.org/p/bigfoot_v2/src/java/com/ajaxjs/framework/sql/test/SqlTest.java。

这是对 SQL 字符串语句的封装。我曾经为这个模块想到过的名字“SQL 编译器”，虽然有点贴切，但未免口气太大，与实际情况有点不符，想想这个名字还是算了。我的目标是这样的：应该是一种“半自动化 ORM”，既非手工的 SQL 字符串拼凑，而是提供一种简单的方法维护 SQL。不用写直接写 SQL，而是 Java + SQL。不是想代替 SQL，SQL 的作用仍非常重要的，此处只是用一种简单的方法封装 SQL 操作，不用直接写 SQL 那么辛苦。

这个类的作用有点类似于 QueryRunner。

实际成果究竟怎么样？不妨先看看调用的例子，感觉下如何。

例子如下（摘自单元测试）。

String sqlStr;
Sql sql = new Sql();
sql.setTableName("User");
sql.setSql("SELECT * FROM " + sql.getTableName());
sqlStr = sql.query();
assertEquals("SELECT * FROM User", sqlStr);
assertEquals(sqlStr, sql.query()); // 没有其他条件，此时 应是一致的，

// 排序
sql.setOrderBy(String.format(" ORDER BY %s.id DESC", sql.getTableName()));
sqlStr = sql.query();
assertEquals("SELECT * FROM User ORDER BY User.id DESC", sqlStr);

// 需要分页的
sql.isPage  = true;
sql.setLimit(3, 9);
sqlStr = sql.query();
assertEquals("SELECT * FROM User ORDER BY User.id DESC LIMIT 3, 9", sqlStr);

// WHERE 条件查询
sql.addWhere("id = 1000");
sql.addWhere("isAdmin = true");
sqlStr = sql.query();		
assertEquals("SELECT * FROM User WHERE (id = 1000 AND isAdmin = true) ORDER BY User.id DESC LIMIT 3, 9", sqlStr);

sql.addWhere_OR("name = 'Jack'");
sql.addWhere_OR("name = 'Mike'");
sqlStr = sql.query();
assertEquals("SELECT * FROM User WHERE (id = 1000 AND isAdmin = true) AND (name = 'Jack' OR name = 'Mike') ORDER BY User.id DESC LIMIT 3, 9", sqlStr);

// 求结果总数
sqlStr = sql.findRowCountSql();
assertEquals("SELECT COUNT(User.uid) AS count FROM User WHERE (id = 1000 AND isAdmin = true) AND (name = 'Jack' OR name = 'Mike')", sqlStr);
System.out.println(sqlStr);

如例子所示，SQL 类做的事情很简单。而且我规定 SQL 类只是返回 String 类型的 SQL 语句，皆是字符串的操作和输入、输出，不涉及的数据库执行等的其他问题，目的是令其专注。

当前封装了 SQL 语句以下查询的功能：

WHERE
LIMIT
ORDER BY
Query Total AS Int

此外，还有写操作的部分有待完善。

Data Access Object

DAO 实际上是一个接口，详情如下：

import java.sql.Connection;
import com.ajaxjs.sql.Result;
import com.ajaxjs.sql.Sql;

public interface DAO {
    public Connection getConn();
    public void setConn(Connection conn);
    public Result query(String sql, boolean isSolo);
    public int queryAsInt(String sql);
    public Result findById(Sql sqlInstance, String id);
    public Result findList(Sql sqlInstance, Integer start, Integer limit);
    public int executeUpdate(String sql);
    public int create(Map<String, Object> pair);
    public int update(Map<String, Object> pair, String id);
    public boolean delete(String uid);
}

DAO 的目的是为其他层提供访问数据库的服务。程序员无须知道其内部细节，就可以轻松调用数据库。

具体流程参见最新源码：http://code.taobao.org/p/bigfoot_v2/src/java/com/ajaxjs/framework/sql/dao/DAO.java。

然而 DAO 内部是复杂的，代码层面是被划分为多个类的，有 Base、Reader、Writer。Base 就是前文提到过的抽象类。它们之间是逐层继承的。最终由 Writer 实现了 DAO 接口。从 DAO 往 Writer、Reader 看，是“自顶向下设计（from Up to Button design）”，也就是了实现了一大块的功能块，然后抽出哪些需要的形成一个接口，这样的设计比较灵活，显示了多态的威力，也比较吻合我的初衷。

值得一提的是，Reader 和 Writer 可以分别单独使用。

Reader

Reader 为只读的数据库访问类。

具体流程参见最新源码：http://code.taobao.org/p/bigfoot_v2/src/java/com/ajaxjs/framework/sql/dao/Reader.java。
单元测试：http://code.taobao.org/p/bigfoot_v2/src/java/com/ajaxjs/framework/sql/test/WriterTest.java。

query()

public Result query(String sql, boolean isSolo); 是通用方法，参数是 SELECT 语句，isSolo 是 boolean 参数，说明返回的结果是否单数。单行记录的是单数的意思，多数的意思就是多行记录。返回的结果保持 Result.result（单数）/ Result.results（多数）中。

例子如下（摘自单元测试）。

String sql = "SELECT * FROM news";

Reader reader = new Reader(conn); // conn 是数据库连接对象
Map<String, Object>[] list = reader.query(sql, false).results;
assertNotNull(list);
assertNotNull("总数：", list.length);

int total = reader.queryAsInt("SELECT COUNT(name) AS total FROM " + tableName);
assertNotNull("总数：", total);

query() 方法内部就是封装了一些异常和是否有结果的判断，还有就是 Statement、ResultSet 对象的资源释放，并进行适当的类型转换。

findById()

public Result findById(Sql sql, String id) 对 query() 简单封装，SQL 语句的变化就是在后面加上 WHERE id = xxx，这是单数的查询。要求传入 Sql 对象和 id 参数。

WHERE id = xxx 中 id 列名是允许指定的。

例子如下（摘自单元测试）。

Sql sql = new Sql();
sql.setTableName(tableName);
Reader reader = new Reader(conn);
Result result = reader.findById(sql, "49d09367-8678-4ecb-8921-d24320e11f96");

assertNotNull(result.result);
assertEquals(result.result.get("name"), "fooo");

System.out.println(result.json);

findList()

public Result findList(Sql sql, Integer start, Integer limit) 读取列表（设置排序、是否需要分页）。如果不需要分页传入第二、第三个参数 null 即可。

例子如下（摘自单元测试）。

Sql sql = new Sql();
sql.setTableName(tableName);
Reader reader = new Reader(conn);
Result result = reader.findList(sql, null, null);

assertNotNull(result.results);
//		assertEquals(result.results[0].get("name"), "fooo");

System.out.println(result.json);

findlList() 结合 Sql 进行操作。如果纯粹 SQL 字符串输入，建议使用 query() 方法（没有分页特性，自己处理）。

Writer

Writer 为写入的数据库访问类，大体可分为 create 和 update 两项操作。

具体流程参见最新源码：http://code.taobao.org/p/bigfoot_v2/src/java/com/ajaxjs/framework/sql/dao/Writer.java。
单元测试：http://code.taobao.org/p/bigfoot_v2/src/java/com/ajaxjs/framework/sql/test/WriterTest.java。

执行 SQL 语句

简单的执行 create/update 操作，没什么好说的。

例子如下（摘自单元测试）。

Writer writer = new Writer(conn);

int newlyId = writer.create("INSERT INTO news (name) VALUES ('hihi')");
String msg = "插入一条新纪录（pure sql）";
System.out.println(msg + newlyId);

assertNotNull(msg, newlyId);

newlyId 是影响的行数或者新建记录的 id。

输入 Map/String[] pair/String[] columns、values

这时候必须输入要操作的表名。

例子如下（摘自单元测试）。

Writer writer = new Writer(conn);
writer.setTableName("news"); // 必须设置表名

Map<String, Object> pair = new HashMap<String, Object>();
pair.put("uid",  java.util.UUID.randomUUID().toString());
pair.put("name", "fooo");

String msg = "插入一条新纪录（Map 载体）";
int newlyId = writer.create(pair);
System.out.println(msg + newlyId);

assertNotNull(msg, newlyId);

也可以不同形式的 String[] pair/String[] columns、values。

例子如下（摘自单元测试）。

@Test
public void createByArray(){
	Writer writer = new Writer(conn);
	writer.setTableName(ReaderTest.tableName);
	
	String[] pair = new String[]{
		"name=bar", "content=my content"
	};
	
	String msg = "插入一条新纪录（String[] pair）";
	int newlyId = writer.create(pair);
	System.out.println(msg + newlyId);
	
	assertNotNull(msg, newlyId);
}

@Test
public void createByArrayCol_Val(){
	Writer writer = new Writer(conn);
	writer.setTableName(ReaderTest.tableName);
	
	String[] columns = new String[]{
		"name", "content"
	}, values = new String[]{
		"foo", "your content"
	};
	
	String msg = "插入一条新纪录（String[] columns, values）";
	int newlyId = writer.create(columns, values);
	System.out.println(msg + newlyId);
	
	assertNotNull(msg, newlyId);
}

Writer 满足了以下需求：

传入 Map，生产 Update/INSERT 语句
传入 Request，生成 Update/INSERT 语句
普通 SQL 语句，执行 JDBC executeUpdate()
INSERT 返回新增 id

设计 Writer 的时候考虑了一下几点，一、Statement 和 PreparedStatement 写法太不一样，要兼容的话太麻烦。干脆直接使用 PreparedStatement。仅保留 Statment 用于简单的 SQL 执行；二、有不同类型、不同结构的参数传入，种类繁复，最后通通转换为 Map<String, Object> 处理，不管传入的是什么类型的数据，数组还是 Map<String, String>[]。

例子如下（摘自单元测试）。

@Test
public void updateByMap(){
	Writer writer = new Writer(conn);
	writer.setTableName(ReaderTest.tableName);
	
	Map<String, Object> pair = new HashMap<String, Object>();
	pair.put("uid",  java.util.UUID.randomUUID().toString());
	pair.put("name", "fooo");
	
	String msg = "更新一条新纪录（Map 载体）";
	int newlyId = writer.update(pair, "49d09367-8678-4ecb-8921-d24320e11f96");
	System.out.println(msg + newlyId);
	
	assertNotNull(msg, newlyId);
}

@Test
public void updateByArray(){
	Writer writer = new Writer(conn);
	writer.setTableName(ReaderTest.tableName);
	
	String[] pair = new String[]{
		"name=bar", "content=my content"
	};
	
	String msg = "插入一条新纪录（String[] pair）";
	int newlyId = writer.update(pair, "49d09367-8678-4ecb-8921-d24320e11f96");
	System.out.println(msg + newlyId);
	
	assertNotNull(msg, newlyId);
}

@Test
public void updateByArrayCol_Val(){
	Writer writer = new Writer(conn);
	writer.setTableName(ReaderTest.tableName);
	
	String[] columns = new String[]{
		"name", "content"
	}, values = new String[]{
		"foo", "your content"
	};
	
	String msg = "插入一条新纪录（String[] columns, values）";
	int newlyId = writer.update(columns, values, "e83b3561-dcd9-45b6-a8a9-bc149c35f3eb");
	System.out.println(msg + newlyId);
	
	assertNotNull(msg, newlyId);
}

删除记录

删除就显得简单多了。

Writer writer = new Writer(conn);
writer.setTableName(ReaderTest.tableName);

String uuid = java.util.UUID.randomUUID().toString();
Map<String, Object> pair = new HashMap<String, Object>();
pair.put("uid",  uuid);
pair.put("name", "fooo");

String msg = "插入一条新纪录（Map 载体）";
int newlyId = writer.create(pair);
assertNotNull(msg, newlyId);

assertEquals(true, writer.delete(uuid));

至此，SQL 这一大模块的介绍，就到此暂告一段落了。

再计一个数据库工具类（以废弃）

源码：

https://code.google.com/p/naturaljs/source/browse/trunk/java/src/ajaxjs/sql/DAO.java

一、数据库连接

先说说构造器。

/**
 * 连接数据库。
 * @param jdbcConn 数据库连接对象
 */
public DAO(Connection jdbcConn){
	this.jdbcConn = jdbcConn;
	checkIfNull();
}

/**
 * 连接数据库（使用连接池）
 * @param path 连接池的路径
 */
public DAO(String path){
	this.jdbcConn = getConn(path);
	checkIfNull();
}

开发者可以直接传入一个 Connection 类型的对象，或者 String。String 代表是什么呢？是连接池的路径。本框架通过 TOMCAT 7 连接池获取数据库连接，不需要其他第三方的 jar，使用起来比较方便、简单。于是 Strting path 是 META-INF 目录下 Content.xml 配置文件的连接路径，可以是 SQLite、MySQL 任意的 Tomcat 7 支持的连接池。详见 getConn(String path) 方法。

/**
 * 创建数据库连接对象（通过 TOMCAT 7 连接池 获取数据库连接）
 * @param path Context.xml 配置文件中路径
 * @return
 */
public static Connection getConn(String path){
	Connection conn = null;
	
	try{
		javax.naming.Context envContext  = (javax.naming.Context)new javax.naming.InitialContext().lookup("java:/comp/env"); 
		javax.sql.DataSource ds = (javax.sql.DataSource)envContext.lookup(path); 
//			 简写方式
//			javax.sql.DataSource ds = (javax.sql.DataSource)new javax.naming.InitialContext().lookup("java:/comp/env/jdbc/derby"); 
		
		conn = ds.getConnection(); 
		
		System.out.println("数据库连接成功：" + conn);
	}catch(SQLException e){
		System.out.println("数据库连接失败！"); 
		e.printStackTrace();
	}catch (javax.naming.NamingException e) {
		System.out.println("读取数据源的配置文件失败，请检查 Tomcat 连接池配置"); 
		e.printStackTrace();
	}
	
	return conn;
}

当然，框架中还保留传统的 JDBC 连接方式，如 jdbc:mysql://linux-db-bjzwNew2.xincache.cn:3306/net25923067?user=net22963167&password=2crFxx0n0x。下面是重载方法。

/**
 * 创建数据库连接对象（传统方式）
 * @param driver e.g "com.mysql.jdbc.Driver"
 * @param jdbcUrl e.g "jdbc:mysql://linux-db-bjzwNew2.xincache.cn:3306/net25923067?user=net22963167&password=2crFxx0n0x"
 * @param props
 * @return
 */
public static Connection getConn(String driver, String jdbcUrl, java.util.Properties props){
	Connection conn = null;
	
	try {
		Class.forName(driver);
	} catch (ClassNotFoundException e) {
		System.out.println("创建数据库连接失败，请检查是否安装对应的 Driver"); 
		e.printStackTrace();
	}
	
	try {
		if(props == null){
			conn = DriverManager.getConnection(jdbcUrl);
		}else{
			conn = DriverManager.getConnection(jdbcUrl, props);
		}
		System.out.println("数据库连接成功：" + conn);
	} catch (SQLException e) {
		System.out.println("数据库连接失败！"); 
		e.printStackTrace();
	}
	
	return conn;
}

关闭数据库连接也有两个重载的方法。

/**
 * 关闭数据库连接
 */
public void closeConnection(Connection jdbcConn){
	try {
		jdbcConn.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

/**
 * 关闭数据库连接
 */
public void closeConnection(){
	try {
		this.jdbcConn.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

开发者需要手动关闭数据库连接。

查询操作

查询无非返回期待的数据和特定的类型。这里考虑几种使用情况：一、查询 ResultSet；二、任意的查询操作（传入回调）；三、查询总记录路数（即 SQL Count() 函数），分别如下方法签名。

/**
 * SQL 的 SELECT 查询，返回 RS 结果集合
 * @param sql
 * @return
 */
public ResultSet query(String sql);

/**
 * 支持回调的查询
 * @param sql
 * @param cb
 * @return
 */
public Object query(String sql, Callback cb);

/**
 * 用于记录总数的返回
 * @param sql
 * @param isCount
 * @return
 */
public int query(String sql, boolean isCount);

它们都调用这个真实的方法。

/**
 * SQL 的 SELECT 查询，既返回 RS 结果集合，也可以返回 SELECT COUNT(id) AS total 的总数。
 * 这是读操作的查询。
 * @param {String} sql SELECT语句
 * @param {Booelan} isCount 是否返回总数
 * @returns {Object} 可变返回值，既可是 RS 结果集，也可以是 int 总数，使用强类型转换获取真实类型。
 */
public Object query(String sql, boolean isCount, Callback cb){
	Object arr = null;
	Statement statement = null;
	ResultSet resultset = null;
			
	System.out.println("将要查询的 SQL 为:" + sql);
	
	try{
		statement = jdbcConn.createStatement();
		resultset = statement.executeQuery(sql);
		
		if(isCount){
			arr = resultset.isBeforeFirst() ? resultset.getInt(1) : null;
			// cover to js number, but it doesn't work here.
//				arr = jsEngine.call("Number", arr);
		}else{
			// 如果没有符合的记录，返回 null 
			if(resultset.isBeforeFirst() && cb != null){
				//arr = jsEngine.call("getValue", resultset);
				cb.doIt(resultset);
			}
		}
		
		if(isCount == false && cb == null){
			// 返回 resultset
			arr = resultset;
		}
		
//			System.out.println("查询成功！:::");
	}catch(Throwable e){
		System.out.println("查询失败！:::" + sql);
		e.printStackTrace();
	}finally{
		if(isCount == false && cb == null){
			// 返回 resultset 不要释放 resultset
			release(statement, null);
		}else release(statement, resultset);
	}
	
	return arr;
}

/**
 * SQL 的 SELECT 查询，返回 RS 结果集合（List类型）
 * @param connection
 * @param sql
 * @return
 */
public List<Map<String, String>> queryAsList(String sql);

其中，回调的方法是强大、灵活的方法。现在很多接口都是 JSON 接口，为此，可以把解析 JSON 的逻辑写进这个 Callback 中。

/**
 * 返回 JSON 格式数据
 * @param sql
 * @param jsEngine
 * @return
 */
public Object queryAsJSON(String sql, final JsRuntime jsEngine){
	this.query(sql, false, new Callback(){
		public Object doIt(ResultSet resultset){
			getJSON_List(jsEngine.call("getValue", resultset));
			return null;
		}
	});
	return JSON_arr;
}

此处使用了 Rhino JS 引擎直接序列化的 ResultSet 对象。

写操作

数据库的写操作比较简单，考虑返回的情况主要有以下两种：一、创建 ok，返回新纪录的 id；二、修改 ok，返回影响的行数；这点我已经 SQL 语句的不同作出了识别，返回的是 int。

/**
 * 这是写操作的查询。
 * @param {String} sql
 * @returns {Number} 返回影响的行数
 */
public int executeUpdate(String sql){
	Statement statement = null;
	int rowNumber = 0;
			
	System.out.println("将要执行写操作， SQL 为:" + sql);
	try{
		statement = jdbcConn.createStatement();
		rowNumber = statement.executeUpdate(sql);
		
		if(sql.contains("INSERT INTO")){
			// 创建新纪录，返回id
			ResultSet rs =statement.getGeneratedKeys();
            if (rs.next()) {  
            	rowNumber = rs.getInt(1);   
//		                System.out.println("数据主键：" + id);   
            } 
		}
		
//			System.out.println("写操作成功！:::");
	}catch(Throwable e){
		System.out.println("写操作失败！:::" + sql);
		System.out.println(e.toString());
		
		e.printStackTrace();
	}finally{
		release(statement, null);
	}
	
	return rowNumber;
}

写操作远比查询简单，而且在一个方法中兼顾了 UPDATE 或 INSERT INTO 的操作。

释放资源

最后是释放 statement 对象和 ResultSet 对象资源，以免不及时释放带来内存占用过多的问题。这里，我特意设计其为一个通用的静态方法，无论查询的、还是写的方法，都可以通用。并且，更重要的是，不需要像 Connection 那样手动释放资源（您不需要手动执行 release() 这个方法），一切由框架为您代劳。这也是我设计该 DAO 的目标之一。

/**
 * 是否数据库资源
 * @param statement
 * @param resultset
 */
private static void release(Statement statement, ResultSet resultset){
	if(statement != null)
		try {
			statement.close();
		} catch (SQLException e) {}
	
	if(resultset != null)
		try {
			resultset.close();
		} catch (SQLException e) {}
}

附：经典的 JDBC 访问数据库方法

String sql = "SELECT * FROM User WHERE name = ?";
java.sql.Connection jdbcConn = ajaxjs.sql.DAO.getConn("jdbc/mysql_deploy");
java.sql.PreparedStatement statement = null;
java.sql.ResultSet rs = null;
String password = null;

try {
	statement = jdbcConn.prepareStatement(sql);
	statement.setString(1, UserName);
	System.out.println("开始查询数据库");
	rs = statement.executeQuery();
	if(rs.first()){
		
		// 有此用户，获取其密码
		password = rs.getString("password");
		// 保存登录用户信息
		User.put("name", rs.getString("name"));
		User.put("id", ((Integer)rs.getInt("id")).toString());
		
		System.out.println("数据库获取用户信息成功！" + rs.getString("name"));
		return password;
	}else{
		// 没有此用户
		throw new NullPointerException("没有此用户：" + UserName);
	}
} catch (SQLException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	return null;
} catch (NullPointerException e){
	e.printStackTrace();
	throw e;
}finally{
	try {
		statement.close();
		rs.close();
		jdbcConn.close();
	} catch (SQLException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

参见：

一个通用的DAO接口及其Hibernate3实现

Bigfoot 数据库 CRUD 举例

概述

Bigfoot DAO 旨在实现数据库的 CRUD 操作，目的是使用起来小巧、灵活、方便。使用 Bigfoot DAO 很简单，分三步实现。
第一步：建立数据库连接，框架支持两种数据库连接方式

通过硬编码指定 JDBC Url
通过 Tomcat 自带的数据库连接池产生 DataSource，进而获取 Connection 对象

如非测试，推荐使用第二种方法。

第二步：在以下选项中决定适合 CRUD 的组合，大多数情况下，推荐使用 UUID 主键、非事务和使用 PrepareStatement

boolean isTransactionEnable; // 是否启用事务
boolean isUsingPreparedStatment; // 是否使用 PreparedStatment
boolean isRETURN_GENERATED_KEYS; // insert 是否返回自增 id
boolean isQueryAsSingle = true; // 如果 query() 只返回一条记录，则自动转化为但单独记录

第三步：创建 DBAccessImpl 对象，调用其方法

DBAccessImpl 实现了 DBAccess 接口，该接口目的为 CRUD 而生。

Result<Record> queryOne(String sql); // 查询单笔记录
Result<PureList> queryList(QueryRunner qr); // 查询多行记录
Result<PureList> queryList(String sql); // 查询多行记录
Result<PagedList> queryList(QueryRunner qr, int start, int limit); // 查询多行记录并分页
Result<CreateAction> insert(String tablename, IRecord data); // 插入记录，data 是 Map 的封装
Result<UpdateAction> update(String tablename, IRecord data, String uid);// 更新记录，data 是 Map 的封装
boolean delete(String tablename, String uid);// 指定表名和 id，删除一条记录

下面应用举例。

举例

查询单行、多行记录

DBAccess dao = new DBAccessImpl(conn);
Result<Record> oneResult = dao.queryOne("SELECT * FROM news WHERE uid = 100");// 可以是任意复杂的查询语句
Result<PureList> listResult = dao.queryList("SELECT * FROM news");

Result 是结果集对象，其中泛型 Record 表示单个实体，PureList 表示列表，但是就是普通结构的列表。

查询的实质是将任意查询结果 ResultSet 转化成 List<Map>。框架内提供了一个将每一条记录转换成一个 Map 对象的方法，通过循环语句将任意的查询结果 ResultSet 转换成 List<Map>类型的变量。

查询单行、多行记录，使用 QueryRunner

QueryRunner 是 SQL 语句字符串拼凑工具类，采用链式查询结构。

DBAccess dao = new DBAccessImpl(conn);
Result<PureList> result;
result = dao.queryList(new QueryRunner().select("uid").from("news"));
assertNotNull(result);
result = dao.queryList(new QueryRunner().select("uid").from("news").limit(0,  3));
assertNotNull(result);
result = dao.queryList(new QueryRunner().select("uid").from("news").limit(0,  3).orderBy("uid", "desc"));
System.out.println(result.json); // 返回 json
assertNotNull(result);

如上所示，演示了 SQL 的分页和排序功能，并直接提供 JSON 返回的能力。

插入一条记录

DBAccessImpl dao = new DBAccessImpl(conn);
dao.setUsingPreparedStatment(true);
MapHelper<String, IValue> map = new MapHelper<>();
map.put("uid", new Value(12345));
map.put("name", new Value("Roooss"));
dao.insert("news", map);

IRecord 是封装过 Map 的自定义类型，实现类为 MapHelper。只有键名等于表的字段名的数据才会插入到表中。

更新一条记录

DBAccessImpl dao = new DBAccessImpl(conn);
dao.setUsingPreparedStatment(true);
MapHelper<String, IValue> map = new MapHelper<>();
map.put("name", new Value("jack"));
dao.update("news", map, "12345");

插入或更新一组记录
请查询 public SaveAction save(String[] sqls, IRecord[] data) throws SQLException 文档，这里不再赘述了。

删除记录

DBAccessImpl dao = new DBAccessImpl(conn);
boolean isDeleted = dao.delete("news", "1000"); // 表名、 uid

约定

归纳一些基本的约定

在 Map 变量（也就是封装过的 IRecord 类型）中，只有键名等于表的字段名的数据才会插入到表中。
若无结果集，不返回零长度 List 对象,而是返回 null
若无单个记录，不返回零长度 Map 对象，而是返回 null
零长度字符串存入数据库中将保存为 null
DAO 通常会捕获了 SQLException 异常，不需要用户处理异常。

一点小技巧

最后，就是介绍大家一个我在框架内比较偷懒的办法。不论是查询，还是插入、更新记录，均使用 HashMap 对象作为一条记录的载体。这个 HashMap 对象的键名是表中的字段名，或是字段的别名，键值为字段值，键值的类型是字段所对应的 JDBC API 的 Java 类。针对数据库的操作，如：插入、更新、删除、查询，该方法会将所传递的 Map 型参数转化成 SQL 语句的组成部分，自动生成完整的标准的 SQL 语句，供 JDBC AP I调用。

实际上，Map 这种方法一般封装过 JDBC 的库多少都会支持的，并不是什么鲜为人知的秘密啦～

浅浅地封装一层 JDBC

写在数据库重构前面的话——说说我之前认识的数据库

目标

基础模块

Base

Result

SQL

Data Access Object

Reader

Writer

再计一个数据库工具类（以废弃）

一、数据库连接

查询操作

写操作

释放资源

附：经典的 JDBC 访问数据库方法

Bigfoot 数据库 CRUD 举例

概述

举例

约定

一点小技巧

热门文章

最新文章

相关课程

相关电子书

相关实验场景