java设计模式之抽象工厂模式(创建型模式)

 

package com.createtype.desginpatterns.facotry.abstractfactory;
// DAO工厂  
//定义DAO工厂接口与实现(利用java反射机制生产出你需要的DAO如:userDAO,roleDao)
abstract class AbstractDaoFactory {  
    public static AbstractDaoFactory getInstance(String classname) {  
        AbstractDaoFactory dao = null;  
        try {  
            dao = (AbstractDaoFactory) Class.forName(classname).newInstance();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return dao;  
    }  
  
    abstract IuserDao getuserdao();  
  
    abstract IroleDao getroledao();  
}  
  
// Oralce工厂  
class OracleFactory extends AbstractDaoFactory {  
    public IroleDao getroledao() {  
        return new OracleroleDao();  
    }  
    public IuserDao getuserdao() {  
        return new UserDaoImp();  
    }  
}  
  
// MySql工厂  
class MysqlFactory extends AbstractDaoFactory {  
    public IroleDao getroledao() {  
        return new MySqlroleDAO();  
    }  
    public IuserDao getuserdao() {  
        return new MySqluserDao();  
    }  
}  

package com.createtype.desginpatterns.facotry.abstractfactory;
//定义配置文件
//配置文件可以定义到XML中去(好处:修改配置项之后不需要对JAVA文件进行编译.)
class Config {  
    // Oralce  
    static final String ORALCE = "org.abc.OracleFactory";  
  
    static final String MYSQL = "org.abc.MysqlFactory";  
}  

package com.createtype.desginpatterns.facotry.abstractfactory;

// 角色表DAO接口  
//1.首先定义相关接口(与平常的做法没什么区别)
interface IroleDao {
	void insert();

	void update();
}

// 用户表DAO接口
interface IuserDao {
	void find();

	void delete();
}

package com.createtype.desginpatterns.facotry.abstractfactory;

// 用户表Oralce数据库DAO  
//不同的数据库有不同的SQL语句所以实现时必须分数据库来实现
//这里增加了一套DAO的实现 (与平时有所不同,如果有10个数据库就要加上10种不同的实现,比较麻烦呀
class UserDaoImp implements IuserDao {
	public void delete() {
		System.out.println("Oralce 删除用户表数据");
	}

	public void find() {
		System.out.println("Oralce 查询用户表数据");
	}
}

// 用户表MySql数据库DAO
class MySqluserDao implements IuserDao {
	public void delete() {
		System.out.println("MySql 删除用户数据");
	}

	public void find() {
		System.out.println("MySql 查询用户数据");
	}
}

// 角色表Oracle数据库DAO
class OracleroleDao implements IroleDao {
	public void insert() {
		System.out.println("Oralce 对角色表插入数据");
	}

	public void update() {
		System.out.println("Oracle 对角色表更新数据");
	}
}

// 角色表MySql数据库DAO
class MySqlroleDAO implements IroleDao {
	public void insert() {
		System.out.println("MySql 对角色表插入数据");
	}

	public void update() {
		System.out.println("Mysql 对角色表更新数据");
	}
}

package com.createtype.desginpatterns.facotry.abstractfactory;
/**
 *  总结:
	使用条件：一系列接口有一系列的实现
	如上IuserDao、IroleDao等一系列的接口，他们可以有一系列的实现(Oracle方式、MySql方式)
	OracleuserDao、OracleroleDao、MySqluserDao、MySqlroleDAO
	组成元素(以上面例子)
	一系列接口：IuserDao、IroleDao
	一系列实现：Oracle系列、MySql系列
	系列工厂类：Oracle系列工厂类、MySql系列工厂类(必须继承抽象工厂类)
	抽象工厂类：DaoFactory
	简单工厂模式也是一个应用很广泛的模式，但是可扩展性没有工厂方法模式高。
 */
/**
 * 工厂方法与抽象工厂的区别：
 * 工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。   

简单工厂模式：
    
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
 */
public class Test {  
    public static void main(String[] args) {  
        AbstractDaoFactory.getInstance(Config.ORALCE).getroledao().insert();  
        AbstractDaoFactory.getInstance(Config.MYSQL).getroledao().insert();  
    }  
  
}