工厂模式与DAO模式工厂模式与DAO模式

工厂模式与DAO模式

博客分类：

设计模式

DAO 设计模式 Apple F# UML

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

工厂模式

1、工厂模式的组成

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

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

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

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

2、工厂模式UML图

3、简单代码的实现

     Java代码    
     
   
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;      
        }      
}    

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

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

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

4、改造后的代码

     Java代码    
     
   
/** 
 * @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设计模式是在项目开发过程中一个常见的设计模式，我们将在随后的文章中具体讲解，现在只贴出具体实现代码，以供参考。

典型实现代码

     Java代码    
     
   
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();  
    }  
  
}  

目录结构