Java设计模式--工厂方法模式&模拟工厂模式

概念

工厂模式就是实例化对象，用工厂方法来代替new操作，工厂模式包括工厂方法模式和抽象工厂模式，抽象工厂模式是工厂方法模式的拓展。

意图

工厂模式的意图就是定义一个接口来创建对象，但是让子类来决定哪些类需要被实例化，也就是说工厂方法把实例化的工作推迟到子类中去实现。

适用场景

• 有一组类似的对象需要创建
• 在编码时不能预见需要创建哪种类的实例
• 系统需要考虑扩展性，不应该依赖于产品类实例如何被创建、组合和表达的细节

在软件中经常面临着对象的创建工作，由于需求的变化，这个对象可能会随之发生变化，但它却拥有比较稳定的接口。为此，我们需要提供一种封装机制来隔离出这个易变对象的变化，从而保持系统中其他依赖该对象的对象不随着需求变化而变化。所以我们要让代码设计的尽量松耦合，一个对象的依赖对象的变化与本身无关，并且具体产品与客户端剥离，责任分割。

工厂方法模式代码实现

根据我们的类图，我们可以得到我们需要定义好一些接口以及实现类。
HairInterface.java

package com.xjh.factory;
/**
 * 发型接口
 * @author Gin
 *
 */
public interface HairInterface {
	
	//实现发型
	public void draw();
}

LeftHair.java

package com.xjh.factory;
/**
 * 左偏分发型
 * @author Gin
 *
 */
public class LeftHair implements HairInterface {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("左偏分发型");
	}

}

RightHair.java

package com.xjh.factory;
/**
 * 右偏分发型
 * @author Gin
 *
 */
public class RightHair implements HairInterface {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("右偏分发型");
	}

}

客户端Test.java

package com.xjh.factory;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HairInterface left = new LeftHair();
		left.draw();
	}

}

其实在这里我们就发现了我们还是想要一个实例就要自己手动new出一个，这是不符合的，所以我们就要开始定义工厂类了，通过工厂类来管理发型。
所以我们创建出一个工厂类，然后返回HairInterface的实例，对于这个我们很当然的想到了通过switch来根据key来返回对象。
HairFactory.java

package com.xjh.factory;
/**
 * 发型工厂
 * @author Gin
 *
 */
public class HairFactory {

	/**
	 * 根据类型来创建对象
	 */
	public HairInterface getHair(String key) {
		switch(key){
			case "left":
				return new LeftHair();
			case "right":
				return new RightHair();
		}
		return null;
	}
}

然后我们只要传入参数就可以得到实例，这样我们就把获得实例分离开来了。
Test.java

package com.xjh.factory;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HairFactory factory = new HairFactory();
		HairInterface left = factory.getHair("left");
		left.draw();
	}

}

但是我们可以发现使用switch的时候，如果我们需要增加一个类就有需要添加一个key，并且来编写相关代码。所以我们就要使用到反射，通过类名来获取实例。
HairFactory.java

/**
 * 根据类名来创建对象
 */
public HairInterface getHairByClass(String className) {
	try {
		HairInterface hair = (HairInterface) Class.forName(className).newInstance();
		return hair;
	} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return null;
}

我们直接传入完整的类名就好了。

package com.xjh.factory;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HairFactory factory = new HairFactory();
		HairInterface left = factory.getHairByClass("com.xjh.factory.LeftHair");
		left.draw();
	}

}

当然输入包名我们会很不习惯，所以我们可以使用Java中的properties文件来进行映射，这样我们就只要像上面一样输入简称就好了。
type.properties

left=com.xjh.factory.LeftHair
right=com.xjh.factory.RightHair

然后我们就要有读取properties文件的类，其实就是将properties文件中的内容映射到map中去。
PropertiesReader.java

package com.xjh.factory;

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class PropertiesReader {
	private static Map<String,String> map = null;
	
	PropertiesReader(){}
	
    public static Map<String,String> getProperties(){
        if(map == null){
            map = new HashMap<>();
            Properties properties = new Properties();
            InputStream in = PropertiesReader.class.getResourceAsStream("type.properties");
            try {
                properties.load(in);
                Enumeration en = properties.propertyNames();
                while (en.hasMoreElements()){
                    String key = (String) en.nextElement();
                    String value = properties.getProperty(key);
                    map.put(key,value);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return map;
    }
}

HairFactory.java
我们获取Key的值，然后根据key到map中找到对应的包名，以后我们就只要编写一个实体类，然后在type.properties中加入一条key与之对应的包名，就可以了，不需要修改其他代码，这样就降低了代码的耦合度。

/**
 * 根据类名的key来创建对象
 */
public HairInterface getHairByClassKey(String key) {
	try {
		Map<String,String> map = new PropertiesReader().getProperties();
		HairInterface hair = (HairInterface) Class.forName(map.get(key)).newInstance();
		return hair;
	} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return null;
}

Test.java
这样我们就直接输入key就可以了。

HairFactory factory = new HairFactory();
HairInterface left = factory.getHairByClassKey("left");
left.draw();

模拟工厂模式实现

根据类图中的流程，我们要有男女两个接口，已方便拓展相应的系列，创建不同系列的男女，然后再根据系列的不同增加工厂，然后在客户端调用该工厂就好了。
Boy.java

package com.xjh.factory;
/**
 * 男孩
 * @author Gin
 *
 */
public interface Boy {

	public void drawMan();
}

Girl.java

package com.xjh.factory;
/**
 * 女孩
 * @author Gin
 *
 */
public interface Girl {

	public void drawWomen();
}

HNBoy.java

package com.xjh.factory;
/**
 * 新年男孩
 * @author Gin
 *
 */
public class HNBoy implements Boy {

	@Override
	public void drawMan() {
		// TODO Auto-generated method stub
		System.out.println("新年男孩");
	}

}

HNGirl.java

package com.xjh.factory;
/**
 * 新年女孩
 * @author Gin
 *
 */
public class HNGirl implements Girl {

	@Override
	public void drawWomen() {
		// TODO Auto-generated method stub
		System.out.println("新年女孩");
	}

}

MCBoy.java

package com.xjh.factory;
/**
 * 圣诞男孩
 * @author Gin
 *
 */
public class MCBoy implements Boy {

	@Override
	public void drawMan() {
		// TODO Auto-generated method stub
		System.out.println("圣诞男孩");
	}

}

MCGirl.java

package com.xjh.factory;
/**
 * 圣诞女孩
 * @author Gin
 *
 */
public class MCGirl implements Girl {

	@Override
	public void drawWomen() {
		// TODO Auto-generated method stub
		System.out.println("圣诞女孩");
	}

}

HNFctory.java

package com.xjh.factory;
/**
 * 新年系列工厂
 * @author Gin
 *
 */
public class HNFctory implements PersonFactory {

	@Override
	public Boy getBoy() {
		// TODO Auto-generated method stub
		return new HNBoy();
	}

	@Override
	public Girl getGirl() {
		// TODO Auto-generated method stub
		return new HNGirl();
	}

}

MCFctory.java

package com.xjh.factory;
/**
 * 圣诞系列工厂
 * @author Gin
 *
 */
public class MCFctory implements PersonFactory {

	@Override
	public Boy getBoy() {
		// TODO Auto-generated method stub
		return new MCBoy();
	}

	@Override
	public Girl getGirl() {
		// TODO Auto-generated method stub
		return new MCGirl();
	}

}

然后我们在客户端进行调用就好了，方法和工厂模式差不多。
Test.java

package com.xjh.factory;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		PersonFactory factory = new MCFactory();
		Boy boy = factory.getBoy();
		boy.drawMan();
	}

}

对比

• 工厂模式是一种极端情况的抽象工厂模式，而抽象工厂模式可以看成是工厂模式的推广
• 工厂模式可以用来创建一个产品的等级结构，而抽象工厂模式是用来创建多个产品的等级结构
• 工厂模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类

总结

工厂模式有什么用：

• 系统可以在不修改具体工厂角色的情况下引进新的产品
• 客户端不必关心对象如何创建，明确了职责
• 更好的理解面向对象的原则：面向接口编程，而不要面向实现编程

工厂模式适用场景：

• 一个系统应当不依赖于产品类实例被创建，组成和表示的细节。这对于所有形态的工厂模式都是重要的
• 该系统的产品要有至少一个的产品族
• 工厂模式的约束：同属于同一个产品族的产品是设计成在一起使用的
• 不同的产品以一系列的接口的面貌出现，从而使得系统不依赖于接口实现的细节