工厂模式

what

Define an interface for creating an object,but let subclasses decide which class to

instantiate.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 ）

why

产品类的实现如何变化，调用者都不需要关心，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不要发生变化，降低模块间的耦合，利于代码的扩展。

工厂方法模式是典型的解耦框架。 高层模块值需要知道产品的抽象类， 其他的实现类都不用关心。

how

抽象产品类

public abstract class Product {
// 产品类的公共方法
public void method1() {
// 业务逻辑处理
}
// 抽象方法
public abstract void method2();
}

具体产品类
public class ConcreteProduct1 extends Product {
public void method2() {
//业务逻辑处理
}
}

public class ConcreteProduct2 extends Product {
public void method2() {
//业务逻辑处理
}
}

抽象工厂

public abstract class Creator {
/*
* 创建一个产品对象， 其输入参数类型可以自 行设置
* 通常为String、 Enum、 Class等， 当然也可以为空
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}

具体工厂

public class ConcreteCreator extends Creator {
public <T extends Product> T createProduct(Class<T> c) {
Product product=null;
try {
product = (Product) Class.forName(c.getName( )).newInstance( );
} catch (Exception e) {
//异常处理
}
return (T)product;
}
}

场景类

public class Client {
public static void main( String[] args) {
Creator creator = new ConcreteCreator();
Product product = creator.createProduct(ConcreteProduct1.class);
/*
* 继续业务处理
*/
}
}

比如创建DAO时可以在properties文件中写好对应DAO的路径（如mysql或oracle的实现）那样在更换不同的数据库时高层代码就不用修改

private DAOFactory() {
prop = new Properties();
try {
prop.load(DAOFactory.class.getClassLoader().getResourceAsStream(
"manager/utils/db.properties"));
} catch (IOException e) {
e.printStackTrace();
}
}

public <T extends BaseDAO> T createDAO(Class<T> clazz) {
try {
String name = clazz.getName();
String className = prop.getProperty("name")
return (T) Class.forName(className).newInstance();
} catch (Exception e) {
e.printStackTrace(); throw new RuntimeException(e);
}
}

extension

1.缩小为简单工厂模式

public class HumanFactory {
public static <T extends Human> T createHuman(Class<T> c) {
//定义一个生产出的人种
Human human=null;
try {
//产生一个人种
human = (Human)Class.forName( c.getName()).newInstance();
} catch (Exception e) {
System.out.println( "人种生成错误！ ") ;
}
return (T)human;
}
}

2.升级为多个工厂类

public abstract class AbstractHumanFactory {
public abstract Human createHuman();
}

public class BlackHumanFactory extends AbstractHumanFactory {
public Human createHuman() {
return new BlackHuman() ;
}
}

public class YellowHumanFactory extends AbstractHumanFactory {
public Human createHuman() {
return new YellowHuman();
}
}

public class whiteHumanFactory extends AbstractHumanFactory {
public Human createHuman() {
return new WhiteHuman();
}
}

在复杂的应用中一般采用多工厂的方法， 然后再增加一个协调类， 避免调用者与各个子工厂交流， 协调类的作用是封装子工厂类， 对高层模块提供统一的访问接口

3.
替代单例模式

public class Singleton {
//不允许通过new产生一个对象
private Singleton() {
}
public void doSomething() {
//业务处理
}
}

public class SingletonFactory {
private static Singleton singleton;
static{
try {
Class cl= Class.forName( Singleton.class.getName());
//获得无参构造
Constructor constructor=cl.getDeclaredConstructor();
//设置无参构造是可访问的
constructor.setAccessible(true) ;
//产生一个实例对象
singleton = (Singleton) constructor.newInstance();
} catch ( Exception e) {
//异常处理
}
}
public static Singleton getSingleton() {
return singleton;
}
}

4.
延迟初始化

public class ProductFactory {
private static final Map<String, Product> prMap = new HashMap();
public static synchronized Product createProduct(String type) throws Exception{
Product product =null;
//如果Map中已经有这个对象
if(prMap.containsKey(type)) {
product = prMap.get(type);
} else{
if( type.equals("Product1")) {
product = new ConcreteProduct1();
} else{
product = new ConcreteProduct2();
}
//同时把对象放到缓存容器中
prMap.put( type, product);
}
return product;
}
}

ProductFactory负责产品类对象的创建工作，并且通过prMap变量产生一个缓存，对需要再次被重用的对象保留