Question

我的代码如下所示：

public interface BaseDAO{
// marker interface
}

public interface CustomerDAO extends BaseDAO{
public void createCustomer();
public void deleteCustomer();
public Customer getCustomer(int id);
// etc
}

public abstract class DAOFactory {
public BaseDAO getCustomerDAO();
public static DAOFactory getInstance(){
  if(system.getProperty("allowtest").equals("yes")) {
  return new TestDAOFactory();
  }
  else return new ProdDAOFactory();
}

public class TestDAOFactory extends DAOFactory{
public BaseDAO getCustomerDAO() {
  return new TestCustomerDAO(); // this is a concrete implementation
  //that extends CustomerDAO
  //and this implementation has dummy code on methods
}

public class ProdDAOFactory extends DAOFactory {
public BaseDAO getCustomerDAO() {
  return new ProdCustomerDAO(); // this implementation would have 
  // code that would connect to the database and do some stuff..
}
}

现在，我知道这段代码闻起来有很多原因。但是，这段代码也在这里： http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html，请参阅9.8

我打算这样做： 1）根据环境（系统属性）在运行时切换我的DAO实现。 2）使用java泛型，这样我就可以避免类型转换...... 例如，做这样的事情：

CustomerDAO dao = factory.getCustomerDAO();
dao.getCustomer();

相反：

CustomerDAO dao = (CustomerDAO) factory.getCustomerDAO();
dao.getCustomer();

请您提出意见和建议。

Answer 1

您应该像这样定义工厂：

public abstract class DAOFactory<DAO extends BaseDAO> {
public DAO getCustomerDAO();
public static <DAO extends BaseDAO> DAOFactory<DAO> getInstance(Class<DAO> typeToken){
  // instantiate the the proper factory by using the typeToken.
  if(system.getProperty("allowtest").equals("yes")) {
  return new TestDAOFactory();
  }
  else return new ProdDAOFactory();
}

getInstance应返回正确类型的DAOFactory。

工厂变量的类型为：

DAOFactory<CustomerDAO> factory = DAOFactory<CustomerDAO>.getInstance(CustomerDAO.class);

并且将正确输入用法：

CustomerDAO dao = factory.getCustomerDAO();
dao.getCustomer();

唯一的问题可能是getInstance方法中需要的强制转换。

Answer 2

有一堆文章详细说明了你的需求：

Generic DAO Pattern With JDK 5.0
Generic Data Access Objects（与上述相同）
Don't repeat the DAO（使用Spring，但原则相同）
Java 1.5 Generic DAO（再次春天）

请注意，与您的示例不同，DAOFactory的方法没有理由不返回实际的子类（即CustomerDAO getCustomerDAO()）。此外，使用通用DAO的主要好处是使实体类型“通用化”，因此您不必从load()/get()/find()和类似方法进行强制转换。

Answer 3

您的示例并未证明需要BaseDAO，并且没有理由不应声明DAOFactory.getCustomerDAO()返回CustomerDAO。所以，我并不认为那里需要仿制药。但是，请考虑以下事项：

interface DataAccess<T> {
  void store(T entity);
  T lookup(Serialiable identifier);
  void delete(Serializable identifier);
  Collection<? extends T> find(Criteria query);
}

abstract class DataAccessFactory {
  abstract DataAccess<T> getDataAccess(Class<T> clz);
  static DataAccessFactory getInstance() {
    ...
  }
}

我在几个项目中使用过类似这样的方法，编写一个适用于模型中每个实体的DAO非常好。弱点是“发现者”方法。有一些巧妙的方法，JPA即将开展的工作是标准化“Criteria”API，但目前通常最容易公开底层持久性机制的标准。

Answer 4

当我使用工厂时，我通常使用instanceof来确定对象的真实类型。例如：

CustomerDAO dao;
if (factory.getCustomerDAO() instanceof CustomerDAO) {
   dao = factory.getCustomerDAO();
}
dao.getCustomer();

这对我来说似乎更干净，特别是如果factory.getCustomerDAO（）没有返回任何接近CustomerDAO的东西（由于实现的变化）。

只是我的两分钱。

java中使用泛型的工厂方法模式，如何？

4 个答案: