抽象工厂模式(java)

工厂模式在项目中是常常用到的,有人说只有大项目才会用到,小项目是体会不出来.其实使用设计模式与项目的大小没有实质性的联系.设计模式是经验的总结而不是衡量项目大小的标准.

以开发项目的DAO层为例,在项目中客户的需求是常常变动的,临时更换数据库的需求也是常常发生的,那我们要如何解决跨数据库的功能,这里就要使用到抽象工厂模式了.工厂模式常常用于创建多系列化的对象(如Orale系列,MySql系列)

1.首先定义相关接口(与平常的做法没什么区别)

// 角色表DAO接口
interface IroleDao {
	void insert();

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

	void delete();
}

 2.不同的数据库有不同的SQL语句所以实现时必须分数据库来实现

// 用户表Oralce数据库DAO
class OracleuserDao 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 对角色表更新数据");
	}
}

这里增加了一套DAO的实现 (与平时有所不同,如果有10个数据库就要加上10种不同的实现,比较麻烦呀)

3.定义DAO工厂接口与实现(利用java反射机制生产出你需要的DAO如:userDAO,roleDao)

// DAO工厂
abstract class DaoFactory {
	public static DaoFactory getInstance(String classname) {
		DaoFactory dao = null;
		try {
			dao = (DaoFactory) Class.forName(classname).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dao;
	}

	abstract IuserDao getuserdao();

	abstract IroleDao getroledao();
}

// Oralce工厂
class OracleFactory extends DaoFactory {
	public IroleDao getroledao() {
		return new OracleroleDao();
	}
	public IuserDao getuserdao() {
		return new OracleuserDao();
	}
}

// MySql工厂
class MysqlFactory extends DaoFactory {
	public IroleDao getroledao() {
		return new MySqlroleDAO();
	}
	public IuserDao getuserdao() {
		return new MySqluserDao();
	}
}

  

4. 定义配置文件

class Config {
	// Oralce
	static final String ORALCE = "org.abc.OracleFactory";

	static final String MYSQL = "org.abc.MysqlFactory";
}

 

 配置文件可以定义到XML中去(好处:修改配置项之后不需要对JAVA文件进行编译.)

5.测试你的输出的DAO

public class Dao {
	public static void main(String[] args) {
		DaoFactory.getInstance(Config.ORALCE).getroledao().insert();
		DaoFactory.getInstance(Config.MYSQL).getroledao().insert();
	}

}

  

总结

使用条件:一系列接口有一系列的实现
如上IuserDao、IroleDao等一系列的接口,他们可以有一系列的实现(Oracle方式、MySql方式)

OracleuserDao、OracleroleDao、MySqluserDao、MySqlroleDAO
组成元素(以上面例子)
一系列接口:IuserDao、IroleDao
一系列实现:Oracle系列、MySql系列
系列工厂类:Oracle系列工厂类、MySql系列工厂类(必须继承抽象工厂类)
抽象工厂类:DaoFactory

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
抽象工厂模式是一种创建型设计模式,它提供了一种创建一系列相关或相互依赖对象的接口,而无需指定具体实现类。该模式通过定义一个抽象工厂接口,然后在具体的工厂类中实现该接口,从而创建不同类型的对象。 在Java中,抽象工厂模式通常由以下几个角色组成: 1. 抽象工厂(Abstract Factory):定义了创建一系列产品对象的接口,它包含多个创建产品的抽象方法。 2. 具体工厂(Concrete Factory):实现了抽象工厂接口,负责创建具体的产品对象。 3. 抽象产品(Abstract Product):定义了产品对象的接口,可以是一个抽象类或接口。 4. 具体产品(Concrete Product):实现了抽象产品接口,是具体工厂创建的对象。 下面是一个简单的抽象工厂模式的示例代码: ```java // 抽象产品A interface ProductA { void operationA(); } // 具体产品A1 class ConcreteProductA1 implements ProductA { @Override public void operationA() { System.out.println("具体产品A1的操作"); } } // 具体产品A2 class ConcreteProductA2 implements ProductA { @Override public void operationA() { System.out.println("具体产品A2的操作"); } } // 抽象产品B interface ProductB { void operationB(); } // 具体产品B1 class ConcreteProductB1 implements ProductB { @Override public void operationB() { System.out.println("具体产品B1的操作"); } } // 具体产品B2 class ConcreteProductB2 implements ProductB { @Override public void operationB() { System.out.println("具体产品B2的操作"); } } // 抽象工厂 interface AbstractFactory { ProductA createProductA(); ProductB createProductB(); } // 具体工厂1 class ConcreteFactory1 implements AbstractFactory { @Override public ProductA createProductA() { return new ConcreteProductA1(); } @Override public ProductB createProductB() { return new ConcreteProductB1(); } } // 具体工厂2 class ConcreteFactory2 implements AbstractFactory { @Override public ProductA createProductA() { return new ConcreteProductA2(); } @Override public ProductB createProductB() { return new ConcreteProductB2(); } } // 客户端代码 public class Client { public static void main(String[] args) { AbstractFactory factory1 = new ConcreteFactory1(); ProductA productA1 = factory1.createProductA(); ProductB productB1 = factory1.createProductB(); productA1.operationA(); productB1.operationB(); AbstractFactory factory2 = new ConcreteFactory2(); ProductA productA2 = factory2.createProductA(); ProductB productB2 = factory2.createProductB(); productA2.operationA(); productB2.operationB(); } } ``` 在上述示例中,抽象工厂接口`AbstractFactory`定义了创建产品A和产品B的方法。具体工厂`ConcreteFactory1`和`ConcreteFactory2`分别实现了抽象工厂接口,负责创建具体的产品对象。抽象产品接口`ProductA`和`ProductB`定义了产品对象的操作方法,具体产品类`ConcreteProductA1`、`ConcreteProductA2`、`ConcreteProductB1`和`ConcreteProductB2`实现了抽象产品接口。 通过使用抽象工厂模式,客户端可以通过抽象工厂接口来创建一系列相关的产品对象,而无需关心具体的产品实现类。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值