[DP]简单工厂，工厂方法和抽象工厂方法

最新推荐文章于 2016-08-08 17:23:23 发布

HeapStackk

最新推荐文章于 2016-08-08 17:23:23 发布

阅读量774

点赞数 1

分类专栏： dp Spring 设计模式文章标签： Spring dp 设计模式

本文链接：https://blog.csdn.net/heapstackk/article/details/52135828

版权

Spring 同时被 3 个专栏收录

18 篇文章 0 订阅

订阅专栏

9 篇文章 0 订阅

订阅专栏

设计模式

8 篇文章 0 订阅

订阅专栏

现在有请KFG快餐负责人登场，好的，我们的CEO需要做一些决策了

A：我们要在中国开我们的第一家店，这个店需要能够做薯条，汉堡。

B: 我选择死亡。GG,您的游戏到此结束，你没有理想，只是一条咸鱼。

我相信你们都会选择A:

首先我们得有点东西要卖，比如说薯条汉堡了啊。

abstract class Food {
	abstract public String getName();
}

class Chip extends Food {
	private String name = "Chip";

	@Override
	public String getName() {
		return name;
	}

}

class Hamburger extends Food {
	private String name = "Hamburger";

	@Override
	public String getName() {
		return name;
	}
}

好的，既然我们定制好了菜单，我们就可以开店了

enum FoodType {
	CHIP, HAMBURGER
}

class KFGStore {
	public static Food cookFood(FoodType type) {
		switch (type) {
		case CHIP:
			return new Chip();
		case HAMBURGER:
			return new Hamburger();
		default:
			return null;
		}
	}
}

开张大吉，坐等顾客。

class Customer {
	private static String[] remarks = { 
			"taste not so bad, i like it.", 
			"damn bad, it smells like expired.",
			"yummy,yummy." 
			};

	public FoodType makeOrder() {
		FoodType[] types = FoodType.values();
		int type = (int) (Math.random() * 100 % types.length);
		return types[type];
	}

	public void eatFood(Food food) {
		String remark = remarks[(int) (Math.random() * 100 % remarks.length)];
		System.out.println(food.getName() + "," + remark);
	}
}

顾客进来点餐吃饭了：

public class AbstractFactory {
	public static void main(String[] args) {
		Customer c = new Customer();
		Food f = KFGStore.cookFood(c.makeOrder());
		c.eatfodd(f);

	}
}

我们来分析一下上述简单工厂模型：

1.静态工厂方法cookFood是静态的，所以是不能被子类所继承的，所以就不能被扩展。

2.不用Customer自己去new出来食物，降低耦合。

3.因为是静态方法产生新的产品，那么假如我们需要增加一些食物，那么就需要更改工厂类的源代码。这违背了开闭原则：软件实体应当对扩展开放，对修改关闭。

4.我们看到制作各种食物都是在一个工厂方法内，根据订单选择食物的逻辑也是在工厂方法内的，这样的耦合程度非常高，所以可以考虑将业务逻辑选择移除。

简单工厂的组成：

1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

至此，你的KFG快餐店已经开业成功，并且在用户中获得良好的反响，但是这已然不够，我们的顾客表示，这些东西吃不饱，我们需要一些炸鸡。

作为我们 KGF餐饮店的负责人，你现在有两个选择：

A:顾客是上帝，顾客的要求尽量去满足，好的，我们在订单中加入炸鸡。

B:去他妈的顾客，店是老子开的，老子做什么你们就得吃什么。GG,欢迎再次挑战餐厅游戏。

好的，很高兴你能在此选择A,但是修改源代码实则是很烦，不如我们再多开条产品线吧。我们可以有专门做汉堡的，有专门做薯条的，专门做炸鸡的产品线。

这听起来很不错的说，这样我就不用烦心菜单扩展了。

工厂方法模式组成：

抽象工厂接口只有一个create方法，所有的客户所需要的具体产品，全部由子类延迟实例化。一个具体工厂只产生一个具体的产品。

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

1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

这个时候我们需要一个抽象的工厂类，来规定子类的行为，以及方便与扩展。

abstract class KFGFoodLine {
	abstract public Food cookFood();
}

好的，然后我们需要扩展成三条产品线，薯条产品线，汉堡产品线，炸鸡产品线。

class ChipFoodLine extends KFGFoodLine {
	@Override
	public Food cookFood() {
		return new Chip();
	}
}

class HambergerFoodLine extends KFGFoodLine {
	@Override
	public Food cookFood() {
		return new Hamburger();
	}
}

class ChickenFoodLine extends KFGFoodLine {
	@Override
	public Food cookFood() {
		return new Chicken();
	}
}

对于Customer类并没有多大改变，顾客只要下单和消费产品就可以了。

但是我们可以将食品线中的根据订单制作食物的业务逻辑外移。这样就可以方便与扩展，不用去修改食品线中的工厂方法来产生更多的订单了。

public class AbstractFactory {
	public static void main(String[] args) {
		KFGFoodLine chipFoodLine = new ChipFoodLine();
		KFGFoodLine hamberherFoodLine = new HambergerFoodLine();
		KFGFoodLine chickenFoodLine = new ChickenFoodLine();
		Customer c = new Customer();
		FoodType type = c.makeOrder();
		Food f = null;
		switch (type) {
		case CHIP:
			f = chipFoodLine.cookFood();
			break;
		case HAMBURGER:
			f = hamberherFoodLine.cookFood();
			break;
		case CHICKEN:
			f = chickenFoodLine.cookFood();
			break;
		default:
			break;
		}
		c.EatFodd(f);
	}
}

好的，这很有利于我们增加菜单，扩展产品的种类，一个工厂专注于一个产品类。

您的顾客为上帝的理念成功让您的食品店称霸当地，您成为了当地的快餐零售业的模范人物。

但是您的理想紧紧只是想当一个地方的土皇帝，还是想走出去，称霸全球呢。您需要面临的决策：

A:我们的业务蒸蒸日上，钱多到没处花了，开几家连锁吧，我们要去开别的地方的连锁店。然后赚更多的钱，让每一个地方都有我们的产品。

B:管他呢，反正我们现在已经是这片苞米地的王了。GG,您的食品店因为其他的连锁店(因为他们品牌大，名气大，口碑好，所以顾客都选择)的进入而业务紧缩，不久就关门。请大侠重新来过。

如果你仍然选择A,那么恭喜你，你很快就能称霸整个中华了。也就能学到本部分最后一个单元的内容：抽象工厂设计模式。

我们的食品连锁店是开在南京的，但是我们下一步需要去北京扩展业务。假设现在产品种类已经固定，你可能会照搬现有的店，但是那的口味和我们这里的口味不一样：南京地方风味的薯条，汉堡，炸鸡，北京地方风味的薯条，汉堡，炸鸡。

好的这样咋们由多处了三条产品线。但是如果我们要开往全国各地，那么产品线就会不受节制的膨胀了。

好的。这样我们可以考虑一个问题，既然南京只做，南京风味的所有汉堡，北京只做北京地方的所有汉堡，那么我们是不是可以按照地区划分我们的食品线职能，南京的食品线，这次要做南京风味的薯片，汉堡，炸鸡。北京的食品线，要做北京风味的薯片，汉堡，炸鸡了。

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

这一次，我们的抽象工厂类大概是这样的：

抽象工厂模式的各个角色（和工厂方法一样）：
1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。

interface KGFFoodLine {
	public Food cookChip();

	public Food cookHamberger();

	public Food cookChicken();
}

实现工厂类是这样的：

class BeijingFoodLine implements KGFFoodLine {

	@Override
	public Food cookChip() {
		return new Chip("Beijing Chip");
	}

	@Override
	public Food cookHamberger() {
		return new Hamburger("Beijing Hamberger");
	}

	@Override
	public Food cookChicken() {
		return new Chicken("Beijing Chicken");
	}
}

class NanjingFoodLine implements KGFFoodLine {
	@Override
	public Food cookChip() {
		return new Chip("Nanjing Chip");
	}

	@Override
	public Food cookHamberger() {
		return new Hamburger("Nanjing Hamberger");
	}

	@Override
	public Food cookChicken() {
		return new Chicken("Nanjing Hamberger");
	}
}

现在我们来开张了：

public class AbstractFactory {
	public static void main(String[] args) {
		// 这次我们在南京 应该吃到南京的特色薯条，汉堡和炸鸡。
		KGFFoodLine foodLine = new NanjingFoodLine();
		Customer c = new Customer();
		c.eatFood(foodLine.cookChip());
		c.eatFood(foodLine.cookHamberger());
		c.eatFood(foodLine.cookChicken());
	}
}

关于工厂方法和抽象工厂方法的区别：

工厂方法：用来生产同一等级结构中的固定产品。（支持增加任意产品),我们只要不断的开辟产品线了就行了。

抽象工厂：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族），每一个工厂，只生产该工厂系列的产品。

总结来说工厂方法和抽象工厂方法：一个是真的工厂，生产各种个样的产品，而抽象工厂则更像是产品线，只生产一个系列的产品。如果需要替换部分产品，那么使用工厂方法吧，如果要整个产品线都换掉，那么就使用抽象工厂设计模式。

这两种方式的侧重纬度不同。一个侧重于产品种类，一个侧重于产品系列。

打个比方吧：

我们是苹果直接供货商，我们只生产苹果手机，但是我们生产苹果手机的各个配件，然后可以组装成一个完整的苹果的手机。

我们是苹果的外包，我们同时也接受三星的供货要求，我们既要生产苹果的配件，也要生产三星的配件，但是你随便各个部分找个零件能不能组装厂三星的手机或者是苹果的手机这个要看你运气了。我们什么都生产。

这里我们再看看spring中的工厂模式：

BeanFactory接口：

public interface BeanFactory {

	String FACTORY_BEAN_PREFIX = "&";

	Object getBean(String name) throws BeansException;

	<T> T getBean(String name, Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	boolean containsBean(String name);

	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

	Class<?> getType(String name) throws NoSuchBeanDefinitionException;

	String[] getAliases(String name);

}

我们BeanFactory只定义了getBean()这个接口，我们知道Spring 只要写进配置注册了的bean 不管你是什么类型，都可以制造出来，才不管搭不搭配呢。所以这里应该是采用了工厂方法的设计模式。值得一提的是该借口定义了一个常量FACTORY_BEAN_PREFIX ＝ "&", 其实就是说我们如果手动定义了一个工厂产生bean，那么如果要获得该工厂的实例，那么我么需要使用前缀 "&"符号就可以了。