2、升级为多个工厂类

当我们在做一个比较复杂的项目时，经常会遇到初始化一个对象很耗费精力的情况，所有的产品类都放到一个工厂方法中进行初始化会使代码结构很不清晰（这里的初始化不仅仅是指代new，初始化包括new一个对象，并为对象设置一定的初始值）。例如：一个产品类具有

5个具体实现，每个类的初始化都不相同，如果写在一个工厂方法中，势必会导致该方法无比巨大，如果遇到这种情况该如何处理呢？

考虑到需要结构清晰，因此我们为每个产品定义一个创造者，然后由调用者自己去选择与哪个工厂方法关联。还是以女娲造人为例，每个

每个人种都有一个固定的八卦炉，分别造出黑色人种、白色人种、黄色人种。

修改后的类图为：

每个人种（具体的产品类）都对应了一个创建者，每个创建者都独立负责创建对应的产品对象

程序代码：

代码没有发生改变的程序：

// 多工厂模式中的Human接口publicinterfaceHuman {
// 每个人种的皮肤都有相应的颜色publicvoidgetColor();
// 只要是人类就都是会说话的publicvoidtalk();
}

// 多工厂模式中的黄色人种类publicclassYellowHumanimplementsHuman {
@OverridepublicvoidgetColor() {
System.out.println("黄种人的肤色是黄色的");
    }
@Overridepublicvoidtalk() {
System.out.println("黄种人：古老的东方有一条龙");
    }
}

// 多工厂模式中的白色人种类publicclassWhiteHumanimplementsHuman {
@OverridepublicvoidgetColor() {
System.out.println("白种人的肤色肯定是白色的");
    }
@Overridepublicvoidtalk() {
System.out.println("白种人：有汰渍，没污渍！汰渍，专业漂白100年");
    }
}

// 多工厂模式中的黑色人种类publicclassBlackHumanimplementsHuman {
@OverridepublicvoidgetColor() {
System.out.println("黑色人种的肤色当然是黑色的");
    }
@Overridepublicvoidtalk() {
System.out.println("黑种人：我们为黑人牙膏代言");
    }
}

代码发生改变的程序：

// 多工厂模式的抽象工厂类
public abstract class AbstractHumanFactory {
    public abstract Human createHuman();
 }

注意：抽象方法中已经不需要再传递相关的参数了，因为每一个具体的工厂都已经安排非常明确自己的职责：创建自己负责的产品类对象

// 多工厂模式中的黑色人种的创建工厂实现publicclassBlackHumanFactoryextendsAbstractHumanFactory {
@OverridepublicHumancreateHuman() {
returnnewBlackHuman();
    }
}

// 多工厂模式中的黄色人种的创建工厂实现publicclassYellowHumanFactoryextendsAbstractHumanFactory {
@OverridepublicHumancreateHuman() {
returnnewYellowHuman();
    }
}

// 多工厂模式中的白色人种的创建工厂实现publicclassWhiteHumanFactoryextendsAbstractHumanFactory {
@OverridepublicHumancreateHuman() {
returnnewWhiteHuman();
    }
}

以上三个具体的创建工厂都非常简单，但是如果一个系统比较复杂时工厂类也会相应对地变得复杂

// 多工厂模式中的场景类——女娲类publicclassNvWa {
publicstaticvoidmain(String[] args) {
// 女娲第一次造人，火候不足，于是白色人种产生了System.out.println("<---- 造出的第一批人是白种人 ---->");
// 发生变化的代码HumanwhiteHuman= (newWhiteHumanFactory()).createHuman();
System.out.println("-- 获取白色人种的肤色 --");
whiteHuman.getColor();
System.out.println("-- 让我们听听白色人种想说什么 --");
whiteHuman.talk();
// 女娲第二次开始造人，烧制时间过长出现了黑人System.out.println("<---- 造出的第二批人是黑种人 ---->");
// 发生变化的代码HumanblackHuman= (newBlackHumanFactory()).createHuman();
System.out.println("-- 获取黑色人种的肤色 --");
blackHuman.getColor();
System.out.println("-- 让我们听听黑色人种想说什么 --");
blackHuman.talk();
// 女娲第三次造人吸取了前两次的教训，这次烧制成功了System.out.println("<---- 造出的第三批人是黄种人 ---->");
// 发生变化的代码HumanyellowHuman= (newYellowHumanFactory()).createHuman();
System.out.println("-- 获取黄色人种的肤色 --");
yellowHuman.getColor();
System.out.println("-- 让我们听听黄色人种想说什么 --");
yellowHuman.talk();
    }
}

运行结果

可以发现运行结果与之前的结果仍然相同。每一个产品类都对应了一个创建类，好处就是创建类的职责清晰，而且结构简单，但是给可扩展性和可维护性带来了一定的影响。不妨我们这样想一想，如果要扩展一个产品类，就需要建立一个相应的工厂类，这样就增加了扩展的难度。因为工厂类和产品类的数量相同你那个，维护时就需要考虑到两个对象间的关系。

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

3、替代单例模式

单例模式的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内存中生产一个对象

类图：

代码实现：

单例类：

publicclassSingleton {
// 不允许通过new产生一个对象privateSingleton(){
    }
publicvoiddoSomething(){
// 业务处理    }
}

Singleton保证不能通过正常的渠道建立一个对象，那SingletonFactory生产单例类的对象可以通过反射来创建

生产单例的工厂类：

publicclassSingletonFactory {
privatestaticSingletonsingleton;
static {
try {
Classc=Class.forName(Singleton.class.getName());
// 获得无参构造Constructorconstructor=c.getDeclaredConstructor();
// 开启private访问权限，设置无参构造是可以访问的constructor.setAccessible(true);
// 产生一个实例对象singleton= (Singleton)constructor.newInstance();
        } catch (Exceptione) {
// 异常处理        }
    }
}

通过获得类构造器，然后设置访问权限，生成一个对象，接着提供外部访问，保证内存中的对象唯一。以上通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以产生一个单例构造器，只要满足所有产生单例的类的构造方法都是private类型的，就可以通过扩展该框架，只要输入一个类型就可以获得唯一的一个实例。

4、延迟初始化

延迟初始化：

一个对象被消费完毕后，并不立刻释放，工厂类保持其初始状态，等待再次被使用。

类图解析：

ProductFactory负责产品类对象的创建工作，并且通过prMap变量产生一个缓存，对需要再次被重复使用的对象保留。
Product和ConcreteProduct与之前的通用代码中的抽象产品类和具体产品类一致，负责定义产品的共性，实现对事物最抽象的定义和定义该类型产品的具体内容。

代码实现：

抽象产品类：

publicabstractclassProduct1 {
// 产品类的公共方法publicvoidmethod(){
// 具体的业务处理    }
// 抽象方法publicabstractvoidmethod1();
}

publicabstractclassProduct2 {
// 产品类的公共方法publicvoidmethod(){
// 具体的业务处理    }
// 抽象方法publicabstractvoidmethod2();
}

具体产品类：

publicclassConcreteProduct1extendsProduct1 {
@Overridepublicvoidmethod1() {
// 具体的业务处理    }
}

publicclassConcreteProduct2extendsProduct2 {
@Overridepublicvoidmethod2() {
// 具体的业务处理    }
}

延迟加载工厂类：

publicclassProductFactory {
privatestaticfinalMap<String, Product>prMap=newHashMap<>();
publicstaticsynchronizedProductcreateProduct(Stringtype) throwsException{
Productproduct=null;
// 如果Map中已经有这个对象if (prMap.containsKey(type)){
product=prMap.get(type);
        } else {
if (type.equals("Product1")){
product=newConcreteProduct1();
            } else {
product=newConcreteProduct2();
            }
// 同时把对象放到缓存容器中prMap.put(type,product);
        }
returnproduct;
    }
}

通过定义一个Map容器，容纳所有产生的对象，如果在Map容器中已经有的对象，则直接取出返回；如果没有，则根据需要的类型产生一个对象并放入Map容器中，以方便下次调用。

如果限制某一个产品类最大实例化的数量，可以通过判断 Map中已有的对象的数量来实现，这样处理是非常有意义的，例如JDBCl连接数据库，都会要求设置MaxConnections最大连接数量，该数量就是内存中最大实例化的数量。延迟加载还可以使用在对象初始化比较复杂的情况下，例如硬件的访问，设计多方面的交互时可以通过延迟加载来降低对象的产生和销毁带来的复杂性。