抽象工厂模式

clq9761

浏览: 592519 次
性别:
来自: 福建

最近访客更多访客>>

kelly_zsl

林祥纤

Torero

muerzi

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

设计模式

Access Oracle

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提
供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

与工厂方法模式的区别：
抽象工厂模式：
       1.多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
       2.一个抽象工厂类，可以派生出多个具体的工厂类。
       3.每个具体工厂类可以创建多个具体产品类的实例。
工厂方法模式：

       1.一个抽象产品类，可以派生出多个具体产品类。
       2.一个抽象工厂类，可以派生出多个具体工厂类。
       3.每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂就像工厂，而工厂方法则像是工厂的一种产品生产线

抽象工厂模式实例：

/**
 * 用户类
 */
public class User {
	private String id;
	private String name;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}	
}

/**
 * 用户接口
 */
public interface IUser {	
	
	public void insertUser(User user);
	
	public User getUser(String id);

}

/**
 * 用于访问Access的User。
 */
public class UserAccess implements IUser {

	public User getUser(String id) {
		System.out.println("在Access中根据ID得到User表一条记录。");		
		return null;
	}

	public void insertUser(User user) {
		System.out.println("在Access中给User表添加一条记录。");
	}
}

/**
 * 用于访问SqlServer的User。
 */
public class UserSqlServer implements IUser {

	public User getUser(String id) {
		System.out.println("在SqlServer中根据ID得到User表一条记录。");		
		return null;
	}

	public void insertUser(User user) {
		System.out.println("在SqlServer中给User表添加一条记录。");
	}
}

/**
 * 部门类
 */
public class Department {
	private String id;
	private String name;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}	
}

/**
 * 部门接口
 */
public interface IDepartment {	
	
	public void insertDepartment(Department department);
	
	public Department getDepartment(String id);

}

/**
 * 用于访问Access的Department。
 */
public class DepartmentAccess implements IDepartment {

	public Department getDepartment(String id) {
		System.out.println("在Access中根据ID得到Department表一条记录。");
		return null;
	}

	public void insertDepartment(Department department) {		
		System.out.println("在Access中给Department表添加一条记录。");

	}
}

/**
 * 用于访问SqlServer的Department。
 */
public class DepartmentSqlServer implements IDepartment {

	public Department getDepartment(String id) {
		System.out.println("在SqlServer中根据ID得到Department表一条记录。");		
		return null;
	}

	public void insertDepartment(Department department) {
		System.out.println("在SqlServer中给Department表添加一条记录。");
	}

}

/**
 * 定义一个创建访问User表和部门表对象的抽象的工厂接口
 */
public interface IFactory {
	
	// 创建用户
	public IUser createUser();
	
	// 创建部门
	public IDepartment createDepartment();

}

/**
 * 实现IFactory接口，实例化AccessUser和AccessDepartment。
 */
public class FactoryAccess implements IFactory{

	public IDepartment createDepartment() {
		return new DepartmentAccess();
	}

	public IUser createUser() {
		return new UserAccess();
	}
}

/**
 * 实现IFactory接口，实例化SqlServerUser和SqlServerDepartment。
 */
public class FactorySqlServer implements IFactory{

	public IDepartment createDepartment() {
		return new DepartmentSqlServer();
	}

	public IUser createUser() {
		return new UserSqlServer();
	}
}

public class Main {
	
	public static void main(String[] args) {
		
		// 用户
		User user = new User();
		// 部门
		Department department = new Department();
		
		// 访问SqlServer数据库（访问Access只要改为new FactoryAccess()).
		IFactory factory = new FactorySqlServer();
		
		// 操作用户表
		IUser iu = factory.createUser();
		iu.insertUser(user);
		iu.getUser("1");
		
		// 操作部门表
		IDepartment id = factory.createDepartment();
		id.insertDepartment(department);
		id.getDepartment("1");
	}
}

用简单工厂改进抽象工厂:抛弃了IFactory,FactorySqlServer,FactoryAccess三个工厂类.

不足之处：如果需要增加Oracle数据库，应需要在每个方法的switch中添加case处理。

/**
 * 数据库枚举类
 */
public enum DataBaseEnum {		
	SqlServer,Access;		
}

public class DataAccess {
	
	// 数据库名称（可替换成Access)
	private static final DataBaseEnum dataBase = DataBaseEnum.SqlServer;
	
	
	// 根据不同的数据库操作用户表
	public static IUser createUser(){
		IUser iUser = null;		
		// 由于DB的事先设置，此处可根据选择实例化出相应的对象
		switch(dataBase){
			case SqlServer:
				iUser = new UserSqlServer();
				break;
			case Access:
				iUser = new UserAccess();
				break;			
		}		
		return iUser;		
	}
	
	// 根据不同的数据库操作部门表
	public static IDepartment createDepartment(){
		IDepartment iDepartment = null;		
		// 由于DB的事先设置，此处可根据选择实例化出相应的对象
		switch(dataBase){
			case SqlServer:
				iDepartment = new DepartmentSqlServer();
				break;
			case Access:
				iDepartment = new DepartmentAccess();
				break;			
		}		
		return iDepartment;
	}
}

简单工厂类的改进：采用反射机制解决简单工厂中switch分支添加case处理的修改变动。

也可采用配置文件和反射技术进行改进。

public class DataAccessReflect {
	
	// 此处可改为AccessUser(访问Access数据库)或OracleUser(访问oracle数据库)
	private static final String userClassName = "com.design." +
						"factory.abstractFactory.UserSqlServer";
	private static final String departClassName = "com.design." +
						"factory.abstractFactory.DepartmentSqlServer";	
	
	// 根据不同的数据库操作用户表
	public static IUser createUser(){
		IUser iUser = null;
		try {			
			// 利用反射实例化指定的对象
			iUser = (IUser)Class.forName(userClassName).newInstance();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return iUser;		
	}	
	// 根据不同的数据库操作部门表
	public static IDepartment createDepartment(){
		IDepartment iDepartment = null;		
		try {			
			// 利用反射实例化指定的对象
			iDepartment = (IDepartment)Class
						  .forName(departClassName).newInstance();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return iDepartment;
	}
}

public class Main {
	public static void main(String[] args) {
		// 用户
		User user = new User();
		// 部门
		Department department = new Department();	
		
		// 操作用户表(直接得到实际的数据库访问实例，而不存在任何依赖)
		IUser iu = DataAccess.createUser();
		iu.insertUser(user);
		iu.getUser("1");
		
		// 操作部门表(直接得到实际的数据库访问实例，而不存在任何依赖)
		IDepartment id = DataAccess.createDepartment();
		id.insertDepartment(department);
		id.getDepartment("1");
		
		//**************改进后的反射机制调用*********************
		IUser iuReflect = DataAccessReflect.createUser();
		iuReflect.insertUser(user);
		iuReflect.getUser("1");
		
		// 操作部门表(直接得到实际的数据库访问实例，而不存在任何依赖)
		IDepartment idReflect = DataAccessReflect.createDepartment();
		idReflect.insertDepartment(department);
		idReflect.getDepartment("1");
	}
}