Java中DAO的实现

时间 2019-11-17

标签 java dao 实现栏目 Java 繁體版

原文原文链接

J2EE 开发人员使用数据访问对象(Data Access Object DAO)设计模式，以便将低级别的数据访问逻辑与高级别的业务逻辑分离。实现 DAO 模式涉及比编写数据访问代码更多的内容。在本文中，Java 开发人员 Sean C. Sullivan 讨论了 DAO 编程中三个经常被忽略的方面：事务界定、异常处理和日志记录。html

图 1 显示了应用程序和数据源之间的关系：

图 1. 应用程序和数据源
java

在整个应用程序中使用数据访问对象(DAO)使咱们能够将底层数据访问逻辑与业务逻辑分离开来。咱们构建了为每个数据源提供 CRUD (建立、读取、更新、删除)操做的 DAO 类。

在本文中，我将为您介绍构建更好的 DAO 类的 DAO 实现策略和技术。更确切地说，我将讨论日志、异常处理和事务界定。您将学到如何将这三者结合到本身的 DAO 类中。本文假定您熟悉 JDBC API、SQL 和关系数据库编程。

咱们将以对 DAO 设计模式和数据访问对象的概述开始。

DAO基础

DAO 模式是标准 J2EE 设计模式之一。开发人员用这种模式将底层数据访问操做与高层业务逻辑分离开。一个典型的 DAO 实现有如下组件：

一个 DAO 工厂类
一个 DAO 接口
一个实现了 DAO 接口的具体类
数据传输对象(有时称为值对象)

具体的 DAO 类包含访问特定数据源的数据的逻辑。在下面一节中您将学习设计和实现数据访问对象的技术。

事务界定程序员

关于 DAO 要记住的重要一点是它们是事务性对象。由 DAO 所执行的每个操做 -- 如建立、更新或者删除数据 -- 都与一个事务相关联。所以，事务界定的概念就变得特别重要了。

事务界定是定义事务边界的方式。J2EE 规范描述了两种事务界定的模型：编程式(programmatic)和声明式(declarative)。表 1 分析了这两种模型：

表 1. 两种事务界定的模型

声明式事务界定	编程式事务界定
程序员用 EJB 部署描述符声明事务属性。	程序员负责编写事务逻辑。
运行时环境(EJB 容器)用这些属性自动管理事务。	应用程序经过一个 API 控制事务。

咱们将侧重于编程式事务界定。

设计考虑

如前所述，DAO 是事务性对象。一个典型的 DAO 执行像建立、更新和删除这样的事务性操做。在设计 DAO 时，首先要问本身如下问题：

事务要如何开始？
事务应如何结束？
哪个对象将负责开始一个事务？
哪个对象将负责结束一个事务？
DAO 是否要负责事务的开始和结束？
应用程序是否须要经过多个 DAO 访问数据？
事务涉及到一个 DAO 仍是多个 DAO？
一个 DAO 是否调用另外一个 DAO 的方法？

了解上述问题的答案将有助于您选择最适合的 DAO 的事务界定策略。在 DAO 中有两种主要的界定事务的策略。一种方式是让 DAO 负责界定事务，另外一种将事务界定交给调用这个 DAO 方法的对象处理。若是选择了前一种方式，那么就将事务代码嵌入到 DAO 中。若是选择后一种方式，那么事务界定代码就是在 DAO 类外面。咱们将使用简单的代码示例帮助您更好理解每一种方式是如何工做的。

清单 1 显示了一个有两种数据操做的 DAO：建立和更新：

清单 1. DAO 方法

sql

public void createWarehouseProfile(WHProfile profile);
public void updateWarehouseStatus(WHIdentifier id, StatusInfo status);

清单 2 显示了一个简单的事务。事务界定在 DAO 类外面。注意在这个例子中调用者是如何在一个事务中结合多个 DAO 操做的。

清单 2. 调用者管理的事务

数据库

tx.begin(); // start the transaction

dao.createWarehouseProfile(profile);

dao.updateWarehouseStatus(id1, status1);

dao.updateWarehouseStatus(id2, status2);

tx.commit(); // end the transaction

这种事务界定策略对于须要在一个事务中访问多个 DAO 的应用程序特别有用。

能够用 JDBC API 或者 Java 事务 API(Java Transaction API JTA)实现事务界定。 JDBC 事务界定比 JTA 事务界定要简单，可是 JTA 提供了更多的灵活性。在下面一节中我将更深刻地分析事务界定的机制。

用 JDBC 进行事务界定

JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式：自动提交和手工提交。 java.sql.Connection 提供了如下控制事务的方法：

public void setAutoCommit(boolean)
public boolean getAutoCommit()
public void commit()
public void rollback()

清单 3 显示了如何用 JDBC API 界定一个事务：

清单 3. 用 JDBC API 进行事务界定

apache

      import java.sql.*;
      import javax.sql.*;
      // ...
      DataSource ds = obtainDataSource();
      Connection conn = ds.getConnection();
      conn.setAutoCommit(false);
      // ...
      pstmt = conn.prepareStatement("UPDATE MOVIES ...");
      pstmt.setString(1, "The Great Escape");
      pstmt.executeUpdate();
      // ...
      conn.commit();
      // ...

使用 JDBC 事务界定时，您能够将多个 SQL 语句结合到一个事务中。JDBC 事务的一个缺点是事务的范围局限于一个数据库链接。一个 JDBC 事务不能跨越多个数据库。在下面，咱们将看一下如何用 JTA 进行事务界定。由于 JTA 不像 JDBC 那样有名，因此咱们首先作一个简介。

JTA简介

Java 事务 API(JTA) 及其同门兄弟 Java 事务服务(Java Transaction Service JTS)为 J2EE 平台提供了分布式事务服务。一个分布式的事务涉及一个事务管理器和一个或者多个资源管理器。一个资源管理器是任何类型的持久性的数据存储。事务管理器负责协调全部事务参与者之间的通讯。事务管理器与资源管理器之间的关系如图 2 所示：

图 2. 一个事务管理器和资源管理器
编程

JTA 事务比 JDBC 事务功能更强。JDBC 事务局限为一个数据库链接，而 JTA 事务能够有多个参与者。全部下列 Java 平台组件均可以参与 JTA 事务：

JDBC 链接
JDO PersistenceManager 对象
JMS 队列
JMS 主题
企业 JavaBeans
符合 J2EE 链接体系结构(J2EE Connector Architecture)规范的资源适配器

使用 JTA 的事务界定

要用 JTA 进行事务界定，应用程序要调用 javax.transaction.UserTransaction 接口中的方法。清单 4 显示了对 UserTransaction 对象的典型 JNDI 查询：

清单 4. 一个对 UserTransaction 对象的 JDNI 查询设计模式

      import javax.transaction.*;
       import javax.naming.*;
      // ...
      InitialContext ctx = new InitialContext();
      Object txObj = ctx.lookup("java:comp/UserTransaction");
      UserTransaction utx = (UserTransaction) txObj;

当应用程序找到了 UserTransaction 对象后，就能够开始事务了，如清单 5 所示：

清单 5. 用 JTA 开始一个事务服务器

     utx.begin();
      // ...
      DataSource ds = obtainXADataSource();
      Connection conn = ds.getConnection();
      pstmt = conn.prepareStatement("UPDATE MOVIES ...");
      pstmt.setString(1, "Spinal Tap");
      pstmt.executeUpdate();
      // ...
      utx.commit();
      // ...

当应用程序调用 commit() 时，事务管理器用一个两阶段的提交协议结束事务。

控制事务的 JTA 方法

javax.transaction.UserTransaction 接口提供了如下事务控制方法：

public void begin()
public void commit()
public void rollback()
public int getStatus()
public void setRollbackOnly()
public void setTransactionTimeout(int)

应用程序调用 begin() 开始事务。应用程序调用 commit() 或者 rollback() 结束事务。

使用 JTA 和 JDBC

开发人员一般在 DAO 类中用 JDBC 进行底层数据操做。若是计划用 JTA 界定事务，那么就须要有一个实现 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 接口的 JDBC 驱动程序。一个实现了这些接口的驱动程序将能够参与 JTA 事务。一个 XADataSource 对象就是一个 XAConnection 对象的工厂。 XAConnection s 是参与 JTA 事务的 JDBC 链接。

您将须要用应用服务器的管理工具设置 XADataSource 。从应用服务器和 JDBC 驱动程序的文档中能够了解到相关的指导。

J2EE 应用程序用 JNDI 查询数据源。一旦应用程序找到了数据源对象，它就调用 javax.sql.DataSource.getConnection() 以得到到数据库的链接。

XA 链接与非 XA 链接不一样。必定要记住 XA 链接参与了 JTA 事务。这意味着 XA 链接不支持 JDBC 的自动提交功能。同时，应用程序必定不要对 XA 链接调用 java.sql.Connection.commit() 或者 java.sql.Connection.rollback() 。相反，应用程序应该使用 UserTransaction.begin()、 UserTransaction.commit() 和 serTransaction.rollback() 。

选择最好的方式

咱们讨论了如何用 JDBC 和 JTA 界定事务。每一种方式都有其优势，您须要决定哪种最适合于您的应用程序。

在最近的许多项目中，咱们小组是用 JDBC API 进事务界定来构建 DAO 类的。这些 DAO 类能够总结以下：

事务界定代码嵌入在 DAO 类中。
DAO 类使用 JDBC API 进行事务界定。
调用者不能界定事务。
事务范围局限于单个 JDBC 链接。

JDBC 事务并不老是适合复杂的企业应用程序。若是您的事务要跨越多个 DAO 或者多个数据库，那么下列实现策略也许更合适：

事务用 JTA 界定。
事务界定代码从 DAO 中分离出来。
调用者负责界定事务。
DAO 加入一个全局事务。

JDBC 方式因为其简单性而具备吸引力，JTA　方式提供了更大的灵活性。您所选择的实现将取决于应用程序的特定需求。

日志记录和 DAO

一个良好实现的 DAO 类将使用日志记录来捕捉有关其运行时行为的细节。您能够选择记录异常、配置信息、链接状态、JDBC 驱动程序元数据、或者查询参数。日志对于开发的全部阶段都颇有用。我常常在开发时、测试时和生产中分析应用程序日志。

在本节，我将展现一个显示如何将 Jakarta Commons Logging 加入到 DAO 中的代码示例。在这以前，让咱们回顾一下一些基本知识。

选择日志库

许多开发人员使用一种原始格式进行日志记录： System.out.println 和 System.err.println 。 Println 语句速度快且使用方便，可是它们没有提供全功能的日志记录系统所具备的功能。表 2 列出了 Java 平台的日志库：

表 2. Java 平台的日志库

日志库	开放源代码？	URL
java.util.logging	不是	[url]http://java.sun.com/j2se/[/url]
Jakarta Log4j	是	[url]http://jakarta.apache.org/log4j/[/url]
Jakarta Commons Logging	是	[url]http://jakarta.apache.org/commons/logging.html[/url]

Jakarta Commons Logging 能够与 java.util.logging 或者 Jakarta Log4j 一同使用。Commons Logging 是一个日志抽象层，它隔离了应用程序与底层日志实现。使用 Commons Logging，您能够经过改变配置文件更换底层日志实现。Commons Logging 在 Jakarta Struts 1.1 和 Jakarta HttpClient 2.0 中使用。

一个日志记录示例

清单 7 显示了如何在 DAO 类中使用 Jakarta Commons Logging：

清单 7. DAO 类中的 Jakarta Commons Logging分布式

import org.apache.commons.logging.*;
class DocumentDAOImpl implements DocumentDAO
{
      static private final Log log = LogFactory.getLog(DocumentDAOImpl.class);
      public void deleteDocument(String id)
      {
          // ...
          log.debug("deleting document: " + id);
          // ...
          try
          {
              // ... data operations ...
          }
          catch (SomeException ex)
          {
              log.error("Unable to delete document", ex);
              // ... handle the exception ...
	}
      }
}

日志记录是全部任务关键型应用程序的重要部分。若是在 DAO 中遇到故障，那么日志一般能够提供判断出错位置的最好信息。将日志加入到 DAO 能够保证您有机会进行调试和故障排除。

DAO 中的异常处理

咱们讨论过了事务界定和日志，如今对于如何在数据访问对象上应用它们有了更深刻的理解。咱们的第三个和最后一个讨论议题是异常处理。听从几个简单的异常处理指导可使您的 DAO 更容易使用、更健壮及更易于维护。

在实现 DAO 模式时，考虑如下问题：

DAO 的公共接口中的方法是否抛出检查过的异常？
若是是的话，抛出何种检查过的异常？
在 DAO 实现类中如何处理异常？

在使用 DAO 模式的过程当中，咱们的小组开发了一些处理异常的原则。听从这些原则能够极大地改进您的 DAO：

DAO 方法应该抛出有意义的异常。
DAO 方法不该该抛出 java.lang.Exception 。 java.lang.Exception 太通常化了。它不传递关于底层问题的任何信息。
DAO 方法不该该抛出 java.sql.SQLException 。SQLException 是一个低级别的 JDBC 异常。一个 DAO 应该力争封装 JDBC 而不是将 JDBC 公开给应用程序的其他部分。
只有在能够合理地预期调用者能够处理异常时，DAO 接口中的方法才应该抛出检查过的异常。若是调用者不能以有意义的方式处理这个异常，那么考虑抛出一个未检查的(运行时)异常。
若是数据访问代码捕获了一个异常，不要忽略它。忽略捕获的异常的 DAO 是很难进行故障诊断的。
使用连接的异常将低级别的异常转化为高级别的异常。
考虑定义标准 DAO 异常类。Spring Framework 提供了很好的一套预约义的 DAO 异常类。

实现实例： MovieDAO[ daoexamples.sourceforge.net上下载 MovieDAO 源代码]

MovieDAO 是一个展现本文中讨论的全部技术的 DAO：事务界定、日志和异常处理。 MovieDAO 源代码。代码分为三个包：

daoexamples.exception
daoexamples.movie
daoexamples.moviedemo

DAO 模式的这个实现包含下面列出的类和接口：

daoexamples.movie.MovieDAOFactory
daoexamples.movie.MovieDAO
daoexamples.movie.MovieDAOImpl
daoexamples.movie.MovieDAOImplJTA
daoexamples.movie.Movie
daoexamples.movie.MovieImpl
daoexamples.movie.MovieNotFoundException
daoexamples.movie.MovieUtil

MovieDAO 接口定义了 DAO 的数据操做。这个接口有五个方法，以下所示：

public Movie findMovieById(String id)
public java.util.Collection findMoviesByYear(String year)
public void deleteMovie(String id)
public Movie createMovie(String rating, String year, String, title)
public void updateMovie(String id, String rating, String year, String title)

daoexamples.movie 包包含 MovieDAO 接口的两个实现。每个实现使用一种不一样的方式进行事务界定，如表 3 所示：

表 3. MovieDAO 实现

	MovieDAOImpl	MovieDAOImplJTA
实现 MovieDAO 接口?	是	是
经过 JNDI 得到 DataSource？	是	是
从 DataSource 得到 java.sql.Connection 对象？	是	是
DAO 在内部界定事务？	是	否
使用 JDBC 事务？	是	否
使用一个 XA DataSource？	否	是
参与 JTA 事务？	否	是

MovieDAO 演示应用程序

这个演示应用程序是一个名为 daoexamples.moviedemo.DemoServlet 的 servlet 类。 DemoServlet 使用这两个 Movie DAO 查询和更新表中的电影数据。

这个 servlet 展现了如何将支持 JTA 的 MovieDAO 和 Java 消息服务(Java Message Service)结合到一个事务中，如清单 8 所示。

清单 8. 将 MovieDAO 和 JMS 代码结合到一个事务中

	UserTransaction utx = MovieUtil.getUserTransaction();
	utx.begin();
	batman = dao.createMovie("R",
			"2008",
			"Batman Reloaded");
	publisher = new MessagePublisher();
	publisher.publishTextMessage("I'll be back");
	dao.updateMovie(topgun.getId(),
			"PG-13",
			topgun.getReleaseYear(),
			topgun.getTitle());
	dao.deleteMovie(legallyblonde.getId());
	utx.commit();

要运行这个演示应用程序，须要在应用服务器上配置一个 XA 数据源和一个非 XA 数据源。而后，部署 daoexamples.ear 文件。这个应用程序能够在任何兼容 J2EE 1.3 的应用服务器上运行。

结束语

正如本文所展现的，实现 DAO 模式须要作比编写低级别的数据访问代码更多的工做。如今，经过选择一个适合您的应用程序的事务界定策略、经过在 DAO 类中加入日志记录，以及经过听从几项简单的异常处理原则，您能够构建更好的 DAO。