设计模式之工厂模式

摘要：缺点需要慎重考虑是否增加工厂类进行管理，因为会增加代码的复杂度使用场景工厂模式是创建型模式的一种，其实就等价于对象，但是否将对象改造成工厂模式，使我们需要衡量的。

最近北京天气越来越冷了，同在北京的小伙伴大家注意保暖。不扯废话了，让我们直接进入到工厂模式的学习.

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。

优点：良好的封装性，代码结构清晰，扩展性非常强。屏蔽产品类，产品的实际创建在工厂类中，产品类的实现如何变化，调用者都不需要关心，只要关心产品的接口即可。

缺点:需要慎重考虑是否增加工厂类进行管理，因为会增加代码的复杂度

工厂模式是创建型模式的一种，其实就等价于new对象，但是否将new对象改造成工厂模式，使我们需要衡量的。工厂模式是一个非常灵活的框架设计，比如我们使用的jdbc，数据库分为oracle和mysql，这些都是产品类，若我们新增一种数据库，只需要增加其产品类就行，符合开闭原则。

//所有英雄的父类
public abstract class Hero {

    public void fromGame() {
        System.out.println("i am come from lol");
    }
    //英雄类型
    abstract void typeOf();
    //英雄特点
    abstract void feature();
}

public class Mage extends Hero {
    @Override
    void typeOf() {
        System.out.println("我是法师");
    }

    @Override
    void feature() {
        System.out.println("我的法术伤害很爆炸");
    }
}

public class Tank extends Hero {
    @Override
    void typeOf() {
        System.out.println("我是坦克");
    }

    @Override
    void feature() {
        System.out.println("我很肉，我抗性很高");
    }
}

public class Assassin extends Hero {
    @Override
    void typeOf() {
        System.out.println("我是刺客");
    }

    @Override
    void feature() {
        System.out.println("我瞬间伤害很爆炸");
    }
}

就先定义三种类型英雄，其他省略,毕竟我们是学设计模式不是打游戏的....

//抽象工厂，定义创建英雄方法
public abstract class AbstractFactory {

    abstract T createHero(Class clazz) throws ClassNotFoundException, IllegalAccessException, InstantiationException;
}

//工厂真正的实现类
public class Factory extends AbstractFactory {
    @Override
     T createHero(Class clazz) {
        Hero hero = null;
        try {
            hero = (Hero) Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("class文件有问题");
        }
        return (T) hero;
    }
}

//测试类
public class Client {

    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        AbstractFactory factory = new Factory();
        Hero hero = factory.createHero(Mage.class);
        Hero hero2 = factory.createHero(Assassin.class);
        Hero hero3 = factory.createHero(Tank.class);

        hero.fromGame();hero.typeOf();hero.feature();
        hero2.fromGame();hero2.typeOf();hero2.feature();
        hero3.fromGame();hero3.typeOf();hero3.feature();
    }
}
测试结果：
i am come from lol
我是法师
我的法术伤害很爆炸
i am come from lol
我是刺客
我瞬间伤害很爆炸
i am come from lol
我是坦克
我很肉，我抗性很高

这就是最常见的工厂模式，一定会有小伙伴说你少定义了adc和support。我们现在来思考一下，在这个基础框架上如何将adc和support加进去。其实我们只需要定义adc和support类，让其继承于hero，工厂类什么都不用改，测试类或高层模块就可以直接使用，是不是很流弊....

简单工厂模式

假如一个模块仅需要一个工厂类，基于这样的业务，我们根本没必要在测试类或高层模块中将工厂类给生产出来，使用其静态方法就好了。应该去除抽象工厂类，修改工厂实现类为静态方法即可.代码示例:

public class Factory  {
     static   T createHero(Class clazz) {
        Hero hero = null;
        try {
            hero = (Hero) Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("class文件有问题");
        }
        return (T) hero;
    }
}

public class Client {

    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        Hero hero = Factory.createHero(Mage.class);
        Hero hero2 = Factory.createHero(Assassin.class);
        Hero hero3 = Factory.createHero(Tank.class);

        hero.fromGame();hero.typeOf();hero.feature();
        hero2.fromGame();hero2.typeOf();hero2.feature();
        hero3.fromGame();hero3.typeOf();hero3.feature();
    }
}

运行结果不会有任何变化，我们的uml类图也会变得简单，调用者也就是测试类或者项目中的高层模块调用起来也会简单，其缺点就是工厂类扩展比较麻烦，不符合开闭原则。

多个工厂类

原来的工厂负责所有类型英雄的创建，职责有点太多了。多个工厂类顾名思义就是对工厂类进行拆分，使其符合单一职责原则。当我们遇到一个非常复杂的项目时，产品类会有很多，并且在我们获得一个产品类很可能都需要对其初始化，不同的产品类会有不同的实现，假如都写在一个工厂类里，会出现很长很长的if/else或者swtich之类得判断语句，这种代码是有毒的！假如你的代码中有类似代码，就应该考虑下能不能给重构了.
UML图:

public abstract class AbstractFactory {

    abstract Hero createHero();
}

public class AssassianFactory extends AbstractFactory {

    @Override
    Hero createHero() {
        return new Assassin();
    }
}

public class TankFactory extends AbstractFactory {

    @Override
    Hero createHero() {
        return new Tank();
    }
}

public class MageFactory extends AbstractFactory {

    @Override
    Hero createHero() {
        return new Mage();
    }
}

public class Client {

    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        Hero mageHero = new MageFactory().createHero();
        Hero tankHero = new TankFactory().createHero();
        Hero assassinHero = new AssassianFactory().createHero();
    }
}

每一个产品类都对应了一个工厂，好处就是职责清晰，结构简单。坏处就是我们扩展新的产品时，需要额外扩展一个工厂类，增加了扩展的难度

延迟初始化

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

public class HeroFactory {
    private static final Map heroMap = new HashMap<>();

    public static synchronized Hero createHero(String type) {
        Hero hero = null;
        if (heroMap.containsKey(type)) {
            return heroMap.get(type);
        } else {
            if (type.equals("mage")) {
                hero = new Mage();
            } else if (type.equals("tank")) {
                hero = new Tank();
            } else {
                hero = new Assassin();
            }
            heroMap.put(type, hero);
        }
        return hero;
    }

}

我们定义了一个静态常量heroMap,在内存中对工厂创建的对象进行延迟化，方便下次调用。同时也非常方便扩展，比如我们在玩英雄联盟，知道双方英雄不会超过10个，可以根据map的长度，判断内存中最多的hero实例数。

工厂模式是一个很常见很优秀的设计模式，我们应该多思考工厂方法如何应用，而且工厂模式和原型模式单例模式结合起来会用更多神奇的设计！不用着急，我们慢慢来...