设计模式之工厂模式

1、核心本质：

-实例化对象，用工厂方法代替new操作。

-将选择实现类、创建对象统一管理和控制，从而将调用者跟我们的实现类解耦。

2、应用场景

-JDK中Calendar的getInstance方法

-JDBC中Connection对象的获取

-Hibernate中SessionFactory创建Session

-spring中IOC容器创建管理bean对象

-XML解析时的DocumentBuilderFactory创建解析器对象

-反射中Class对象的newInstance()

3、优点

实现了创建者和调用者的分离。

4、分类

-简单工厂模式
-工厂方法模式
-抽象工厂模式

5、代码示例

问题引出：这里用一个射击游戏做例子，CF中有各种不同的枪械，我们如何创造出不同的枪械呢？

普通方法：

/**
* 抽象接口：武器
* @author ly1
*
*/
public interface Weapon {
void shot();
}

/**
* 武器实现类：AK
* @author ly1
*
*/
public class AK implements Weapon{

@Override
public void shot() {
System.out.println("AK后坐力大...");
}

}

/**
* 武器实现类：M4
* @author ly1
*
*/
public class M4 implements Weapon{

@Override
public void shot() {
System.out.println("M4后坐力小...");
}

}

/**
* 客户端调用
* @author ly1
*
*/
public class Client {
public static void main(String[] args) {
Weapon w1 = new AK();
Weapon w2 = new M4();

w1.shot();
w2.shot();
}
}

普通方法不使用工厂类，使得调用类与每个类之间耦合很高。

简单工厂模式：

/**
* 抽象接口：武器
* @author ly1
*
*/
public interface Weapon {
void shot();
}

/**
* 武器实现类：AK
* @author ly1
*
*/
public class AK implements Weapon{

@Override
public void shot() {
System.out.println("AK后坐力大...");
}

}

/**
* 武器实现类：M4
* @author ly1
*
*/
public class M4 implements Weapon{

@Override
public void shot() {
System.out.println("M4后坐力小...");
}

}

/**
* 武器工厂类
* @author ly1
*
*/
public class WeaponFactory {

public static Weapon create(String type){
if(type.equals("M4")){
return new M4();
}else if(type.equals("AK")){
return new AK();
}else{
return null;
}
}
}

/**
* 客户端调用
* @author ly1
*
*/
public class Client {
public static void main(String[] args) {
Weapon w1 = WeaponFactory.create("AK");
Weapon w2 = WeaponFactory.create("M4");

w1.shot();
w2.shot();
}
}

简单工厂模式，在普通模式的基础上增加了工厂类，实现了创建者与调用者的分离。生产枪械集中在工厂类中完成，调用者只需通过传参完成类的创建，如果增加一种枪械，直接增加一个Weapon实现类，修改工厂类中少量代码就行了。

工厂方法模式：

/**
* 抽象接口：武器
* @author ly1
*
*/
public interface Weapon {
void shot();
}

/**
* 武器实现类：AK
* @author ly1
*
*/
public class AK implements Weapon{

@Override
public void shot() {
System.out.println("AK后坐力大...");
}

}

/**
* 武器实现类：M4
* @author ly1
*
*/
public class M4 implements Weapon{

@Override
public void shot() {
System.out.println("M4后坐力小...");
}

}

/**
* 抽象工厂接口
* @author ly1
*
*/
public interface WeaponFactory {
Weapon createWeapon();
}

/**
* 工厂的实现类：AK工厂
* @author ly1
*
*/
public class AKFactory implements WeaponFactory{

@Override
public Weapon createWeapon() {
return new AK();
}

}

/**
* 工厂的实现类：M4工厂
* @author ly1
*
*/
public class M4Factory implements WeaponFactory{

@Override
public Weapon createWeapon() {
return new M4();
}

}

/**
* 客户端调用
* @author ly1
*
*/
public class Client {
public static void main(String[] args) {
Weapon w1 = new AKFactory().createWeapon();
Weapon w2 = new M4Factory().createWeapon();

w1.shot();
w2.shot();
}
}

工厂方法模式符合面向对象的OCP（Open-Closed Principle，开闭原则），可以看做简单工厂模式的升级版。当增加一种新枪械的时候，不用修改已有的代码，直接增加一个Weapon实现类和一个WeaponFactory实现类即可。当然，也造成了类的数量的膨胀和调用的复杂性，随着枪械种类的增加，类的数量急剧增加，复杂度也随之增加。

抽象工厂模式：

问题变化：生产的不光有武器，还有角色、道具，然后有几种系列（即后面提到的产品族，也就是前面几种产品的组合），比如说为高端玩家生产高端武器系列，为低端玩家生产低端武器系列。

/**
* 武器抽象接口
* @author ly1
*
*/
public interface Weapon {
void shot();
}

/**
* 武器实现类：AK
* @author ly1
*
*/
class AK implements Weapon{

@Override
public void shot() {
System.out.println("AK威力大...");
}

}

/**
* 武器实现类：M4
* @author ly1
*
*/
class M4 implements Weapon{

@Override
public void shot() {
System.out.println("M4威力小...");
}

}

/**
* 角色抽象接口
* @author ly1
*
*/
public interface Role {
void property();
}

/**
* 角色实现类：赛斯
* @author ly1
*
*/
class Sise implements Role{

@Override
public void property() {
System.out.println("我是赛斯，没有特殊属性！");
}

}

/**
* 角色实现类：潘多拉
* @author ly1
*
*/
class Pandora implements Role{

@Override
public void property() {
System.out.println("我是潘多拉，身体娇小，不易被击中！");
}

}

/**
* 装备抽象接口
* @author ly1
*
*/
public interface Equipment {
void property();
}

/**
* 装备实现类：防弹衣
* @author ly1
*
*/
class Bulletproof implements Equipment{

@Override
public void property() {
System.out.println("防弹衣减小伤害...");
}

}

/**
* 装备实现类：普通衣服
* @author ly1
*
*/
class CommonClothes implements Equipment{

@Override
public void property() {
System.out.println("普通衣服无任何效果...");
}

}

/**
* 系列产品生产的抽象工厂
* @author ly1
*
*/
public interface Factory {
Weapon createWeapon();
Role createRole();
Equipment createEquipment();
}

/**
* 高端玩家系列产品生产工厂
* @author ly1
*
*/
public class GoodPlayerFactory implements Factory{

@Override
public Weapon createWeapon() {
return new AK();
}

@Override
public Role createRole() {
return new Pandora();
}

@Override
public Equipment createEquipment() {
return new Bulletproof();
}

}

/**
* 低端玩家系列产品生产工厂
* @author ly1
*
*/
public class BadPlayerFactory implements Factory{

@Override
public Weapon createWeapon() {
return new M4();
}

@Override
public Role createRole() {
return new Sise();
}

@Override
public Equipment createEquipment() {
return new CommonClothes();
}

}

/**
* 客户端调用
* @author ly1
*
*/
public class Client {
public static void main(String[] args) {
Factory good = new GoodPlayerFactory();
Weapon w = good.createWeapon();
Role r = good.createRole();
Equipment e = good.createEquipment();
w.shot();
r.property();
e.property();
}
}

抽象工厂可以说是解决另一种新问题，即解决产品族问题，也就是不同产品类型之间组合的问题，比如增加一种中端玩家产品系列，使用AK武器、赛斯角色、防弹衣，直接增加一个工厂实现类就可以了。但是如果增加一种产品的话，就无能为力了，比如增加一个近身武器产品（即近身武器接口），有两种近身武器斧头和小刀（即两个实现类），高端玩家配备斧头，低端玩家配备小刀，那么所有的工厂类都得修改。

6、分析

1）简单工厂模式：

a、简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。

b、对于增加新产品无能为力!不修改代码的话，是无法扩展的。

2）工厂方法模式：

a、为了避免简单工厂模式的缺点，不完全满足OCP。

b、工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

3）抽象工厂模式：

a、用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

b、抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

7、总结

a、简单工厂和工厂方法相比，简单工厂模式用的较多。对于我们普通 的项目来说，修改少量代码是可以接受的，而且将创建类放在一个工厂类中完成；而虽然工厂方法模式遵循面向对象设计原则，但会增加复杂度，并且导致类的数量膨胀。

b、抽象工厂模式解决增加产品族的问题，但对于增减新的产品无能为力。