实现DAO设计模式

 

                                                      实现DAO 设计模式

                        为DAO实现工厂类的策略

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

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

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

                        代码说明：

                        以下代码举例说明了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
                        方法. 然后再按模式和以上步骤来定义具体的类.