应用最广泛的工厂模式

工厂

事例：

某公司下有多条生产线，都是生产鸭脖。但鸭脖有酱香的，有麻辣的，有五香的，有原味的。每条生产线生产一种鸭脖，而鸭脖又对应不同味道即不同商标。对于忙碌的领导来说，他需要知道所有生产线吗和所有鸭脖吗？那样的话要记录的事也太多了，越来越多的生产线和鸭脖味道就会越来越复杂。对应在程序中也是如此，领导只需要关心有生产线生产鸭脖，鸭脖有味道就可以了。用得最多的模式，工厂模式来表述上面事例。

抽象工厂和抽象产品

基于面向对象的思想，首先定义一个生产线接口，它有一个实现生产鸭脖的方法。再定义一个鸭脖接口，它有一个味道的方法。

public interface IProductLineFactory{    IDuckNeck createDuckNeck();}public interface IDuckNeck{    void taste();}

实际工厂和实际产品

我们假设要找产原味鸭脖的生产线生产原味鸭脖。

public class NormalProductLineFactory implements IProductLineFactory{    @Override    public IDuckNeck createDuckNeck(){        return new NormalTasteDuckNeck();    }}public class NormalTasteDuckNeck implements IDuckNeck {    @Override    public void taste(){        System.out.printls("这里是原味鸭脖哦");     }}

然后我们想要获取看看鸭脖味道：

public class Test{    public static void main(String[] args){        IProductLineFactory factory=new NormalProductLineFactory();        IDuckNeck duckneck=factory.createDuckNeck();        duckneck.taste();    }}

这里几个角色也很简单，主要四大模块：

• 抽象工厂：这就是工厂方法的核心
• 具体工厂：实现具体的业务逻辑，生产具体的产品。
• 抽象产品：产品的父类，描述产品该有的行为。
• 具体产品：抽象产品具体产品的对象，实现具体行为。

要找另外的生产线生产另外味道的鸭脖，也可以轻而易举的就执行了。对于领导只需要知道生产线生产鸭脖，鸭脖有自己的味道就可以了。如果想得到麻辣味鸭脖，只需要更改工厂实现逻辑即可，返回麻辣味鸭脖就可以了。

当然这种方式，我们需要创建更多的工厂具体类，所以也是挺麻烦的，通常我们可以通过自己喜欢的方式来不重复创建工厂类：

实际使用工厂方式

反射创建

public interface IProductLineFactory{    /**     * 抽象工厂方法     * @param clz 产品对象类型     * @return 具体产品对象     */    <T extends IDuckNeck> T createDuckNeck(Class<T> clz);}

对于具体工厂类，我们可以通过反射获取类的实例：

public class ConcreteFactory implements IProductLineFactory{    public <T extends IDuckNeck> T createDuckNeck(Class<T> clz){        IDuckNeck duckneck;        try{            duckneck=(IDuckNeck)Class.forName(clz.getName()).newInstance();        }catch(Exception e){        }        return duckneck;    }}

再来看下测试：

public class Test{    public static void main(String[] args){        IProductLineFactory factory=new ConcreteFactory();        IDuckNeck duckneck=factory.createDuckNeck(NormalTasteDuckNeck.class);        duckneck.taste();    }}

这是一种方式，通过反射就不用反复创建具体工厂了，当然反射效率稍微要低一点，所以还是可以有其他方式实现。

实现方式看具体业务逻辑需求，如果工厂只有一个，可以直接用静态工厂，来去掉抽象工厂类。

静态工厂：

public class ConcreteFactory{    public static IDuckNeck createDuckNeck(){        return new NormalTasteDuckNeck();    }}

静态工厂是工厂方式的一种弱化，就直接简化掉了抽象工厂类，如果产品类型不是很多，还可以在抽象工厂类中加入Type类型，来做一个switch取出直接产品类型。

抽象工厂

事例

夏天来了，我们都爱喝饮料，比如某快线和某矿泉水。某快线由饮料部分是乳白色。而矿泉水是透明色，某快线盖子是橙色，矿泉水盖子是白色。身体部分均由软塑料瓶组成。

那么换到我们代码世界中来，不就对应了可替换模块不同实现和实现下组成部分的不同，将组成部分抽象,将每一个组成部分看作一个产品。

抽象工厂

• 先定义一个抽象饮料:

public abstract class DrinkFactory{    /**     * 生产液体     * return 液体部分     */    public abstract ILiquid createLiquid();    /**     * 生产盖子     * return 盖子部分     */    public abstract ICap createCap();    /**     * 生产瓶子     * 因为两个产品瓶子一样，所以可以Up Method 到父类中，如果子类需要改变则自己重写就好     */    protect void createBottle(){        System.out.println("瓶身是熟料瓶身");    }}

• 液体相关类

public interface ILiquid{    void liquid();}public class TransparencyLiquid implements ILiquid{    @Override    public void liquid(){        System.out.println("透明液体");    }}public class LacteLiquid implements ILiquid{    @Override    public void liquid(){        System.out.println("乳白色液体");    }}

• 盖子相关类

public interface ICap{    void cap();}public class OrangeCap implements ICap{    @Override    public void cap(){        System.out.println("橙色盖子");    }}public class WhiteCap implements ICap{    @Override    public void cap(){        System.out.println("白色盖子");    }}

声明完了之后，具体工厂就出来了：

• 具体工厂类：

public class XXQX extends DrinkFactory{    /**     * 生产液体     * return 液体部分     */    @Override    public ILiquid createLiquid(){        return new LacteLiquid();    }    /**     * 生产盖子     * return 盖子部分     */    @Override    public ICap createCap(){        return new OrangeCap();    }}public class XXMineralWater extends DrinkFactory{    /**     * 生产液体     * return 液体部分     */    @Override    public ILiquid createLiquid(){        return new TransparencyLiquid();    }    /**     * 生产盖子     * return 盖子部分     */    @Override    public ICap createCap(){        return new WhiteCap();    }}

测试：

public class Test{    public static void main(String[] args){        DrinkFactory factoryMineralWater=new XXMineralWater();        factoryMineralWater.createLiquid().liquid();        factoryMineralWater.createCap().cap();        factoryMineralWater.createBottle();        System.out.println("-------");        DrinkFactory factoryQX=new XXQX();        factoryQX.createLiquid().liquid();        factoryQX.createCap().cap();        factoryQX.createBottle();    }}

就这样就把一个饮料给拆分了，组成部分也为产品，我们也可以抽象出来，当其他饮料需要用到的时候可以直接使用，扩展性更好了。

这里用的抽象类，有一个好处就是提升了公共部分，重构的时候，往往会用到此方式，UP Method。就像这里的瓶身

总结

例子1是鸭脖，例子2是饮料，其都是工厂生产产品，而产品具体实现交由产品自己实现。在项目中是一个可替换模块（工厂），对应行为也可替换（产品），但实现不同，将组成部分抽象。

工厂模式是完全符合设计原则的，依赖与抽象的架构，将具体操作交由对应的子类完成，有非常好的扩展性。很多一些使扩展性好的设计模式，比如策略，状态等也都能看到工厂模式的影子。工厂模式不愧为应用最广泛的设计模式