实现DAO 设计模式

最新推荐文章于 2025-10-02 15:05:37 发布

原创最新推荐文章于 2025-10-02 15:05:37 发布 · 423 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dao #设计模式 #数据库 #sybase #string #object

实现DAO 设计模式

为DAO实现工厂类的策略

1 采用工厂方法设计模式
如果一个DAO 工厂只为一个数据库的实现,(比如ORACLE)而创建很多的DAO的时候,实现该策略时,我们考虑采用工厂方法设计模式. 假设该工厂类创建了CustomerDAO, AccountDAO, OrderDAO 等一些对象。

2 使用抽象工厂设计模式:

如果考虑为三种不同类型的数据库来实现这个策略,我们可以考虑采用抽象工厂设计模式. 假设. 这个工厂创建了CustomerDAO, AccountDAO, OrderDAO的一系列的DAO, 该策略运用了在抽象工厂中产生的工厂类中的工厂方法p实现.

代码说明：

以下代码举例说明了DAO设计模式的具体实现:
我们以使用抽象工厂的设计模式来对付多种类型数据库为例,在以下的例子中只具体列
出CLOUDSCAPE 数据库类型的DAO设计模式的具体实现,其他类型数据库DAO设计模式的实
现大同小异.

1 // Abstract class DAO Factory
public abstract class DAOFactory {

// List of DAO types supported by the factory
public static final int CLOUDSCAPE = 1;
public static final int ORACLE = 2;
public static final int SYBASE = 3;
...

// There will be a method for each DAO that can be
// created. The concrete factories will have to // implement these methods.
// 所有实现该抽象工厂的工厂类中必须有的方法,用这些方法来创建具体的DAO类.
public abstract CustomerDAO getCustomerDAO();
public abstract AccountDAO getAccountDAO();
public abstract OrderDAO getOrderDAO();

//该抽象类的静态方法,用他来创建其他具体的DAO工厂类
public static DAOFactory getDAOFactory(
     int whichFactory) {
    switch (whichFactory) {
     case CLOUDSCAPE:
        return new CloudscapeDAOFactory();
     case ORACLE:
        return new OracleDAOFactory();
     case SYBASE:
        return new SybaseDAOFactory();
        ...
     default:

         return null;
   }
}
}

2 以下是Cloudscape DAO FACTORY 类的实现,在他里面实现了该类型数据库的连接,以及实现了他所继承的抽象工厂类中所必须实现的那些方法,在这些方法中创建具体的DAO对象.

// Cloudscape concrete DAO Factory implementation
import java.sql.*;

public class CloudscapeDAOFactory extends DAOFactory {

public static final String DRIVER= "COM.cloudscape.core.RmiJdbcDriver";
public static final String DBURL= "jdbc:cloudscape:rmi://localhost:1099/CoreJ2EEDB";

// method to create Cloudscape connections
//建立Cloudscape 连接
public static Connection createConnection() {
   // Use DRIVER and DBURL to create a connection
   // Recommend connection pool implementation/usage
}
//创建 CustomerDAO 对象当然返回的是一个该类实现的接口,他的好处就是实现了实现细节的隐蔽.
public CustomerDAO getCustomerDAO() {
   // CloudscapeCustomerDAO implements CustomerDAO
   return new CloudscapeCustomerDAO();
}
//创建 AccountDAO 对象当然返回的是一个该类实现的接口,他的好处就是实现了实现细节的隐蔽.
public AccountDAO getAccountDAO() {
   // CloudscapeAccountDAO implements AccountDAO
   return new CloudscapeAccountDAO();
}
//创建 OrderDAO 对象当然返回的是一个该类实现的接口,他的好处就是实现了实现细节的隐蔽.

public OrderDAO getOrderDAO() {
// CloudscapeOrderDAO implements OrderDAO
return new CloudscapeOrderDAO();
}
...
}

3 以下代码就是具体DAO类实现的接口也就是CloudscapeCustomerDAO()实现的接口: CustomerDAO .在该接口中定义了所有的业务方法.

// Interface that all CustomerDAOs must support
public interface CustomerDAO {

public int insertCustomer(...);
public boolean deleteCustomer(...);
public Customer findCustomer(...);
public boolean updateCustomer(...);
public RowSet selectCustomersRS(...);
public Collection selectCustomersTO(...);
... }

4 以下CloudscapeCustomerDAO类实现的具体业务细节和数据操作细节, 他是要向客户
数据端隐蔽的.

import java.sql.*;
public class CloudscapeCustomerDAO implements    CustomerDAO {
public CloudscapeCustomerDAO() {
   // initialization }
// The following methods can use
// CloudscapeDAOFactory.createConnection() // to get a connection as required
public int insertCustomer(...) {
   // Implement insert customer here.
   // Return newly created customer number
   // or a -1 on error
}
public boolean deleteCustomer(...) {
   // Implement delete customer here
   // Return true on success, false on failure
}
public Customer findCustomer(...) {
   // Implement find a customer here using supplied
   // argument values as search criteria
   // Return a Transfer Object if found,
   // return null on error or if not found
}
public boolean updateCustomer(...) {
   // implement update record here using data
   // from the customerData Transfer Object
   // Return true on success, false on failure or
   // error
}
public RowSet selectCustomersRS(...) {
   // implement search customers here using the
   // supplied criteria.
   // Return a RowSet. }
public Collection selectCustomersTO(...) {
   // implement search customers here using the
   // supplied criteria.
   // Alternatively, implement to return a Collection    // of Transfer Objects.
}
...
}

5 下面的代码是数据客户端向DAO中传输数据的, 他其实就是一个JAVABEAN;

public class Customer implements java.io.Serializable {
// member variables
int CustomerNumber;
String name;
String streetAddress;
String city;
...

// getter and setter methods...
...
}
6 最后就是客户数据端对这个设计的应用:
...
// create the required DAO Factory

DAOFactory cloudscapeFactory = DAOFactory.getDAOFactory(DAOFactory.DAOCLOUDSCAPE);

// Create a DAO
CustomerDAO custDAO = cloudscapeFactory.getCustomerDAO();

// create a new customer
int newCustNo = custDAO.insertCustomer(...);

// Find a customer object. Get the Transfer Object.

Customer cust = custDAO.findCustomer(...);
// modify the values in the Transfer Object.

cust.setAddress(...);
cust.setEmail(...);

// update the customer object using the DAO
custDAO.updateCustomer(cust);

// delete a customer object
custDAO.deleteCustomer(...);

// select all customers in the same city Customer criteria=new Customer();
criteria.setCity("New York");

Collection customersList = custDAO.selectCustomersTO(criteria);
// returns customersList - collection of Customer
// Transfer Objects. iterate through this collection to
// get values.

言而简之，以下6步完成该模式的实现：

1 创建一个抽象工厂类,他包含两个重要的部分: 第一部分是一些抽象方法,这些方法是所有实现该抽象工厂的具体工厂类所必须实现的. 第二部分就是一个静态方法,该方法来创建一个具体类型数据源的工厂对象,比如文中的CloudscapeDAOFactory().

2 然后,分别创建各个类型数据源的工厂类,(本文以CloudscapeDAOFactory为例).在这个工厂类中里面也有两个重要组成部分: 第一部分就是实现在他继承的那个抽象工厂类中的左右抽象方法,在该方法中创建具体的DAO对象(这些对象的类在第4不具体定义实现),本文中三个方法分别创建了3个具体的DAO对象,当然为了实现细节的隐蔽,这些方法返
回的是这些具体DAO类门实现的接口(这些接口在第3步实现).

3 定义具体DAO类的接口,并在接口中定义所有的业务方法,和数据操作方法.

4 定义具体的DAO类,在这个类中才是实际的业务方法,和数据的操作的实现.

5 定义数据传输对象,他是用来在客户端和DAO之间传递数据的,他其实就是一个JAVABEAN.

6 完成以上5步之后我们就可以在数据客户端使用以上由DAO设计模式定义好的各个类了

以上6步大家在编程的时需具体体会,一般来说,数据库中的一个表就可以对应一个数据
传递类也就是在第4步中定义的那个类,类中的属性就是表中的字段,然后加上相应的
GET,SET 方法. 然后再按模式和以上步骤来定义具体的类.