学习设计模式——工厂方法

这里要先感谢《研磨设计模式》一书的作者，在讲述IoC/DI(控制反转/依赖注入)的时候深入浅出，让我有了清晰的理解，谢谢。

关于IoC/DI

依赖注入：应用程序依赖容器创建并注入它所需要的外部资源

控制反转：容器控制应用程序，有容器反向地向应用程序注入其所需要的外部资源

有效的分离了对象和所需要的外部资源，松耦合，有利于复用

适用于：

让父类在不知道具体实现的情况下，完成自身功能的调用，将具体的实现延迟到子类来实现。

子类通常是做选择来实现产品对象，而非直接实现功能。

优点：

良好的封装性，代码结构清晰——平行化代码结构，有什么样的产品对象就有什么样的产品工厂。或者由带参数的总工厂来生成所有的产品对象。

扩展性非常强——只需要适当的修改具体工厂类或者扩展一个工厂类，就可以实现变化。

可以屏蔽具体的产品类。

典型的解耦模式。

缺点：

具体产品对象和工厂方法的耦合。（关于这点个人认为是理所应当的，不算缺点，毕竟总有类是耦合的，在子类中耦合是解耦父类的一种途径，符合里氏替换原则）

产品类：

public interface Product {
void doSomething();
}

public class ProductA implements Product {
//这里私有没有特别的意思，就是不想被外界直接new
private ProductA(){
}
public void doSomething() {
System.out.println("it's ProductA");
}
}

public class ProductB implements Product {
private ProductB(){
}
public void doSomething() {
System.out.println("it's ProductB");
}
}

工厂类：

public abstract class Factory {
//这个就是工厂方法，是该模式的核心
public abstract Product createProduct();

//这里通过访问工厂的方法来调用具体产品的方法
//这样产品被封装的很好，而且扩展很强
public void doSomething() {
Product p = createProduct();
if(p!=null){
p.doSomething();
}
}
}

public class FactoryA extends Factory {
public Product createProduct() {
try {
Constructor<?> c = Class.forName(ProductA.class.getName()).getDeclaredConstructor();
c.setAccessible(true);
return (Product) c.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}

客户端：

public class Client {
public static void main(String[] args) {
Factory a = new FactoryA();
a.doSomething();
}
}

结果：

it’s ProductA

扩展：

生成单例的工厂类：

public class SingletonFactory {
private static final Map<String, Object> objectMap = new HashMap<String, Object>();

public synchronized static <T> T createSingleton(Class<T> c) {
T t = null;
String className = c.getName();
try {
if (!objectMap.containsKey(className)) {
Class<?> c1 = Class.forName(className);
Constructor<?> constructor = c1.getDeclaredConstructor();
constructor.setAccessible(true);
t = (T) constructor.newInstance();
objectMap.put(className, t);
}
} catch (Exception e) {
e.printStackTrace();
}
return (T) objectMap.get(className);
}

public static void main(String[] args) {
Product productA1 = SingletonFactory.createSingleton(ProductA.class);
System.out.println(productA1);
Product productB1 = SingletonFactory.createSingleton(ProductB.class);
System.out.println(productB1);

Product productA2 = SingletonFactory.createSingleton(ProductA.class);
System.out.println(productA2);
Product productB2 = SingletonFactory.createSingleton(ProductB.class);
System.out.println(productB2);
}
}