设计模式之工厂模式

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、抽象工厂模式解决增加产品族的问题，但对于增减新的产品无能为力。