工厂模式是设计模式中较简单的模式,但在项目的开发过程中会常常用到它。下面分析下工厂模式,提出一种在项目中比较可行的工厂方法的实现。同时,结合单例模式,构建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();
}
}
目录结构