工厂模式与DAO模式

原创

gaojiewyh 2009-08-28 18:12:15 博主文章分类：设计模式 ©著作权

文章标签 properties 单例 dao 反射机制 io流 文章分类 后端开发

©著作权归作者所有：来自51CTO博客作者gaojiewyh的原创作品，请联系作者获取转载授权，否则将追究法律责任

工厂模式是设计模式中较简单的模式，但在项目的开发过程中会常常用到它。下面分析下工厂模式，提出一种在项目中比较可行的工厂方法的实现。同时，结合单例模式，构建DAO设计模式。

工厂模式

1、工厂模式的组成

简单工厂模式又叫静态工厂模式，顾名思义，它是用来实例化目标类的静态类。它由三种角色组成：

抽象产品角色（Product）：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

具体产品角色（Concert Product）：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

工厂类角色（Creator）：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

2、工厂模式UML图

3、简单代码的实现

interface Fruit{
                public void grow();
                public void eat();
}

pulbic class Apple implements Fruit{
                public void grow(){
                                System.out.println("苹果在生长...");
                }
                public void eat(){
                                System.out.println("吃苹果...");
                }
}

public class Orange implements Fruit{
                public void grow(){
                                System.out.println("橘子在生长...");
                }
                public void eat(){
                                System.out.println("吃橘子...");
                }
}

pulbic class Factory{
                public static Fruit getFruit(String name){
                                Fruit f = null;
                                if ("apple".equal(name)){
                                                f = new Apple();
                                }else if (("orange".equal(name)){        ){
                                                f = new Orange();
                                }
                                return f;
                }
}

public class Clinet{
                public static void main(String args[]){
                                Fruit f = Factory.getFruit(“apple”);
                                f.grow();
                }
}

从开闭原则上来分析下简单工厂模式。当增加了一种水果时候，只要符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。那么对于产品部分来说，它是符合开闭原则的——对扩展开放、对修改关闭；但是工厂部分好像不太理想，因为每增加一一种水果，都要在工厂类中增加相应的商业逻辑和判断逻辑，这显然是违背开闭原则的。

为了符合开闭原则，同时考虑以后代码的维护性，我们采用java的反射机制及propertie综合应用，使得配置与程序分离，程序的修改只与配置文件有关，某一部分的修改不影响其他程序。

4、改造后的代码

/**
* @author gao_jie
*
*/
public interface Fruit {
        public void grow();
        public void eat();
}

public class Apple implements Fruit {
  /* (non-Javadoc)
    * @see com.cvicse.Ifactory.Fruit#grow()
    */
  public void grow() {
    System.out.println("苹果在生长...");
  }
  /* (non-Javadoc)
    * @see com.cvicse.Ifactory.Fruit#eat()
    */
  public void eat() {
    System.out.println("吃苹果...");
  }
}

public class Orange implements Fruit {
  /* (non-Javadoc)
    * @see com.cvicse.Ifactory.Fruit#grow()
    */
  public void grow() {
    System.out.println("橘子在生长...");
  }

  /* (non-Javadoc)
    * @see com.cvicse.Ifactory.Fruit#eat()
    */
  public void eat() {
    System.out.println("吃橘子...");
  }
}

public class Banana implements Fruit {
  /* (non-Javadoc)
    * @see com.cvicse.Ifactory.Fruit#grow()
    */
  public void grow() {
    System.out.println("香蕉在生长...");
  }

  /* (non-Javadoc)
    * @see com.cvicse.Ifactory.Fruit#eat()
    */
  public void eat() {
    System.out.println("吃香蕉...");
  }
}

public class FruitFactory {
  public static Fruit getFruit(String className) {
    Fruit f = null;
    try {
      // 采用类的反射机制生成实例
      f = (Fruit) Class.forName(className).newInstance();
    } catch (Exception e) {
      throw new ExceptionInInitializerError(e);
    }
    return f;
  }
}

/**
* @author gao_jie
*
*/
public class PropertyOperate {

  private Properties pro = null;

  public PropertyOperate() {
    this.pro = new Properties();
    this.load();
  }

  // 设置一个返回方法
  public Properties getPro() {
    return this.pro;
  }
  // 加载配置文件内容
  private void load() {
    try {
      // 文件流输入方式
      InputStream file = this.getClass().getClassLoader()
          .getResourceAsStream("classInfor.properties");
      pro.load(file);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

classInfor.properties

apple=com.cvicse.factory.Apple
orange=com.cvicse.factory.Orange
banana=com.cvicse.factory.Banana

/**
* @author gao_jie
*
*/
public class Client {

  /**
    * @param args
    */
  public static void main(String[] args) {
    // 获取文件名字路径
    Properties p = new PropertyOperate().getPro();
    // 进一步扩展，现在可以由用户自己输入要使用的类型
    Fruit f = FruitFactory.getFruit(p.getProperty(args[0]));
    f.grow();
  }
}

DAO模式

DAO设计模式是在项目开发过程中一个常见的设计模式，我们将在随后的文章中具体讲解，现在只贴出具体实现代码，以供参考。

典型实现代码

package com.cvice.dao;

public interface UserDAO {
  public void insert();  //插入操作
  public void delet();  //删除操作
}

package com.cvicse.dao.impl;

import com.cvice.dao.UserDAO;

/**
* @author Administrator
*
*/
public class UserDAOImpl implements UserDAO{

  public void delet() {
    // TODO Auto-generated method stub
    System.out.println("删除记录成功");
  }

  public void insert() {
    // TODO Auto-generated method stub
    System.out.println("插入记录成功");
  }
}

package com.cvice.dao;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
* @author Administrator
*
*/

public class DaoFactory {

  private static UserDAO userDao = null;//DAO层用户接口对象
  private static DaoFactory instance = new DaoFactory();
  private static Properties pro;//配置文件对象

  private DaoFactory() {
    try {
      //初始化配置文件
      pro = new Properties();
      //采用类加载器方法读取配置文件信息到字节流对象，采用类加载灵活，不用写死
      InputStream inputStream = DaoFactory.class.getClassLoader()
          .getResourceAsStream("db.properties");
      //加载字节流对象
      pro.load(inputStream);
    } catch (IOException e) {
      throw new ExceptionInInitializerError(e);
    }
  }

  /**
    * 单例模式获取唯一实例
    * @return
    */
  public static DaoFactory getInstance() {
    return instance;
  }

  /**
    * 根据配置文件的名字获取类的名字，采用反射机制获取其对象
    * @param Key
    * @return
    */
  public UserDAO getUserDAO(String Key) {
    try {
      String className=(String) pro.get(Key);
      userDao = (UserDAO) Class.forName(className).newInstance();
    } catch (InstantiationException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IllegalAccessException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (ClassNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    return userDao;
  }
}

package com.cvicse.Test;

import com.cvice.dao.DaoFactory;
import com.cvice.dao.UserDAO;

/**
* @author Administrator
*
*/
public class DAOTest {

  /**
    * @param args
    */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    UserDAO userDao=DaoFactory.getInstance().getUserDAO("userDao");
    userDao.delet();
  }

}