工厂方法模式(Factory Method Pattern
)又称为工厂模式,也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式,它属于类创建型模式。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
工厂方法模式包含如下角色:
Product
:抽象产品ConcreteProduct
:具体产品Factory
:抽象工厂ConcreteFactory
:具体工厂首先,是抽象的产品类和具体的产品类:
/**
* 抽象产品类
* Created by blinkfox on 16-6-29.
*/
public abstract class Product {
/**
* 产品类的公共方法
*/
public void method1() {
System.out.println("这是产品类的公共方法");
}
/**
* 抽象方法
*/
public abstract void method2();
}
/**
* 具体产品类1
* Created by blinkfox on 16-6-29.
*/
public class ConcreteProduct1 extends Product {
@Override
public void method2() {
System.out.println("ConcreteProduct1的method2方法");
}
}
/**
* 具体产品类2
* Created by blinkfox on 16-6-29.
*/
public class ConcreteProduct2 extends Product {
@Override
public void method2() {
System.out.println("ConcreteProduct2的method2方法");
}
}
然后,是抽象的工厂类和具体的工厂类:
/**
* 抽象的工厂类
* Created by blinkfox on 16-6-29.
*/
public abstract class Factory {
/**
* 运用了Java中的泛型和反射技术,生成某种具体的产品
* 其输入类型可以自行设置
* @param c
* @param <T>
* @return
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}
/**
* 具体生产产品的工厂类
* Created by blinkfox on 16-6-29.
*/
public class ConcreteFactory extends Factory {
/**
* 运用了Java中的泛型和反射技术,生成某种具体的产品
* 其输入类型可以自行设置
* @param c
* @param <T>
* @return
*/
@Override
public <T extends Product> T createProduct(Class<T> c) {
Product product = null;
try {
product = (Product) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
System.out.println("生产产品出错");
e.printStackTrace();
}
return (T) product;
}
}
最后,是客户端场景类:
/**
* 工厂方法模式客户端场景类
* Created by blinkfox on 16-6-29.
*/
public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
Product product1 = factory.createProduct(ConcreteProduct1.class);
product1.method1();
product1.method2();
Product product2 = factory.createProduct(ConcreteProduct2.class);
product2.method1();
product2.method2();
}
}
在工厂方法模式中,核心的工厂类不再负责所有产品的创建,而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口,而不负责哪一个产品类被实例化这种细节,这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
工厂方法模式的优点:
工厂方法模式的缺点:
在以下情况下可以使用工厂方法模式:
工厂方法模式有很多扩展,而且与其他模式结合使用威力更大,下面介绍4种常用扩展。
我们这样考虑一个问题:一个模块仅需要一个工厂类,没有必要把它产生出来,使用静态的方法就可以了。因此去掉工厂类中继承的抽象类,把方法改成静态即可。通用代码如下:
/**
* 简单工厂模式中的工厂类
* Created by blinkfox on 16-6-29.
*/
public class SimpleFactory {
/**
* 运用了Java中的泛型和反射技术,生成某种具体的产品
* 其输入类型可以自行设置
* @param c
* @param <T>
* @return
*/
public static <T extends Product> T createProduct(Class<T> c) {
Product product = null;
try {
product = (Product) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
System.out.println("生产产品出错");
e.printStackTrace();
}
return (T) product;
}
}
/**
* 简单工厂模式客户端场景类
* Created by blinkfox on 16-6-29.
*/
public class SimpleClient {
public static void main(String[] args) {
Product product1 = SimpleFactory.createProduct(ConcreteProduct1.class);
product1.method1();
product1.method2();
Product product2 = SimpleFactory.createProduct(ConcreteProduct2.class);
product2.method1();
product2.method2();
}
}
运行结果没有发生变化,但是类图简单了,调用者也比较简单,简单工厂模式是工厂方法模式的弱化,也叫做静态工厂模式。其缺点是工厂类的扩展比较困难,不符合“开闭原则”,但它仍然是一个非常实用的设计模式。
当我们在一个比较复杂的项目时,经常会遇到初始化一个对象很耗费精力的情况,所有的产品类都放到一个工厂方法中进行初始化会使代码结构不清晰。为了让结构清晰,我们就为每类产品定义一个创造者,然后由调用者自己去选择与哪个工厂方法关联。多工厂模式的通用代码如下:
多工厂模式的抽象工厂类:
/**
* 生成多个产品的抽象工厂类
* Created by blinkfox on 16-7-2.
*/
public abstract class MultiFactory {
/**
* 生成某种产品的方法
* @return
*/
public abstract Product createProduct();
}
第一种产品的创建工厂实现:
/**
* 生成产品1的具体工厂类1
* Created by blinkfox on 16-7-2.
*/
public class ConcreteFactory1 extends MultiFactory {
/**
* 生成产品1的方法
* @return
*/
@Override
public Product createProduct() {
return new ConcreteProduct1();
}
}
第二种产品的创建工厂实现:
/**
* 生成产品2的具体工厂类2
* Created by blinkfox on 16-7-2.
*/
public class ConcreteFactory2 extends MultiFactory {
/**
* 生成产品2的方法
* @return
*/
@Override
public Product createProduct() {
return new ConcreteProduct2();
}
}
多工厂模式的客户端场景类
/**
* 多工厂方法模式客户端场景类
* Created by blinkfox on 16-7-2.
*/
public class MultiClient {
public static void main(String[] args) {
Product concreteProduct1 = (new ConcreteFactory1()).createProduct();
concreteProduct1.method1();
concreteProduct1.method2();
Product concreteProduct2 = (new ConcreteFactory2()).createProduct();
concreteProduct1.method1();
concreteProduct1.method2();
}
}
单例模式的核心要求就是在内存中只有一个对象,通过工厂方法模式也可以只在内存中生成一个对象,从而实现单例的功能。
下面是单例类,其中定义了一个private的无参构造函数,目的是不允许通过new的方式创建对象,代码如下:
/**
* 工厂方法模式中的单例类
* Created by blinkfox on 16-7-4.
*/
public class Singleton {
/**
* 私有化构造方法,不允许new产生一个对象
*/
private Singleton() {}
/**
* 工厂方法模式中的单例模式业务方法
*/
public void doSomething() {
System.out.println("工厂方法模式中的单例模式方法。。。");
}
}
以上单例类中不能通过正常的渠道建立一个对象,那单例的工厂类中如何建立一个单例对象呢?答案是通过反射方式创建,单例工厂类的代码如下:
/**
* 生成单例的工厂类
* Created by blinkfox on 16-7-4.
*/
public class SingletonFactory {
private static Singleton singleton;
static {
try {
Class c = Class.forName(Singleton.class.getName());
// 获得无参构造
Constructor constructor = c.getDeclaredConstructor();
// 设置无参构造是可访问的
constructor.setAccessible(true);
// 产生一个实例对象
singleton = (Singleton) constructor.newInstance();
} catch (Exception e) {
e.printStackTrace();
System.out.println("生成单例的工厂类方法中生成单例出错");zuihou
}
}
public static Singleton getSingleton() {
return singleton;
}
}
最后是工厂方法单例模式的客户端场景类:
/**
* 工厂方法单例模式客户端场景类
* Created by blinkfox on 16-7-4.
*/
public class SingleClient {
public static void main(String[] args) {
Singleton singleton = SingletonFactory.getSingleton();
singleton.doSomething();
}
}
何为延迟初始化?一个对象被消费完毕后,并不立即释放,工厂类保持其初始状态,等待再次使用。延迟初始化是工厂模式的一个扩展应用,其通用代码如下:
/**
* 延迟加载的工厂类
* Created by blinkfox on 16-7-4.
*/
public class LazyFactory {
private static final Map<String, Product> lazyMap = new HashMap<String, Product>();
public static synchronized Product createProduct(String type) {
Product product = null;
// 如果map中已经有这个对象,则直接取出该对象即可,否则创建并放在缓存容器中
if (lazyMap.containsKey(type)) {
return lazyMap.get(type);
}
// 根据类型创建具体的产品对象
if ("product1".equals(type)) {
product = new ConcreteProduct1();
} else {
product = new ConcreteProduct2();
}
// 同时把对象放到缓存容器中
lazyMap.put("type", product);
return product;
}
}
上面即为延迟加载的工厂类。代码比较简单,通过定义一个map
容器来容纳所有产生的对象,如果在map
容器中已经有的对象,则直接取出返回;如果没有,则根据需要的类型产生一个对象并放入到map
容器中,以便下次调用。
延迟加载的工厂模式客户端场景类代码如下:
/**
* 延迟加载的工厂模式客户端场景类
* Created by blinkfox on 16-7-4.
*/
public class LazyClient {
public static void main(String[] args) {
Product product1 = LazyFactory.createProduct("product1");
Product product11 = LazyFactory.createProduct("product1");
}
}