简单工厂模式——概述及应用

       最近在学习设计模式，被大家经常提及的应该就是工厂模式了，查阅了相关资料，发现之前理解的工厂模式其实是只是简单工厂模式，在正式介绍设计模式中的工厂模式之前，这篇博客先对简单工厂模式做了介绍。

       简单工厂模式的实质是指更加传入工厂类的参数，动态创建某一具体的产品类。它主要包含三个角色：

       （1）工厂角色

       （2）抽象产品角色

       （3）具体产品角色

       其优点是：可以根据外界传入参数明确创建哪个对象，而不必知道对象是如何创建和组织的，使其和外界的直接接触分离开来，各司其职，增加新的产品时也不需要修改调用端的代码，有利于整个软件体系的优化。在一些产品比较明确、产品个数不算多的情况下，使用简单工厂还是挺有优势的。

       缺点是：全部的创建逻辑集中在了一个工厂里面，当增加新的产品时，需要修改工厂里的代码，这违反了设计模式中的“开闭原则”，而且当产品类别比较多的时候，工厂类的代码会变得臃肿，不美观，容易出错，不利于扩展和维护。

       简单工厂其实不是一种设计模式，可以理解成我们的编程习惯，开发中使用还是比较广泛的。

       开发中经常遇到一些操作的处理，如何让这些操作集中管理又使调用方避免直接创建具体的操作类呢，这里我们就能用到简单工厂模式了，下面来看具体的实例。

       首先我们看下操作类管理的类图：

下面来看看其具体的实现，首先定义抽象产品 BaseOperation 和具体产品（CancelOP、DeleteOP、...）：

package com.dz.pattern.simplefactorypattern.operation;

import com.dz.pattern.simplefactorypattern.entity.StateContent;

/**
 * Created by Dz on 2019/3/17.
 */
public abstract class BaseOperation {
    private StateContent stateContent;

    public StateContent getStateContent() {
        return stateContent;
    }

    public void setStateContent(StateContent stateContent) {
        this.stateContent = stateContent;
    }

    public abstract void onExecute();
}

package com.dz.pattern.simplefactorypattern.operation;

/**
 * Created by Dz on 2019/3/17.
 */

public class CancelOP extends BaseOperation {

    public void onExecute() {
        long keyId = this.getStateContent().getKeyId();
        System.out.println("CancelOP Execute, keyId = " + keyId);
    }
}

package com.dz.pattern.simplefactorypattern.operation;

/**
 * Created by Dz on 2019/3/17.
 */

public class DeleteOP extends BaseOperation {
    public void onExecute() {
        long keyId = this.getStateContent().getKeyId();
        System.out.println("DeleteOP Execute, keyId = " + keyId);
    }
}

具体的工厂类实现如下：

package com.dz.pattern.simplefactorypattern;

import com.dz.pattern.simplefactorypattern.entity.StateContent;
import com.dz.pattern.simplefactorypattern.operation.BaseOperation;
import com.dz.pattern.simplefactorypattern.operation.CancelOP;
import com.dz.pattern.simplefactorypattern.operation.DeleteOP;

/**
 * Created by Dz on 2019/3/17.
 */
public class SimpleOperationFactory {
    public BaseOperation createOperation(StateContent sc) {
        BaseOperation operation = null;
        switch (sc.getOperation()) {
            case CancelOP:
                operation = new CancelOP();
                operation.setStateContent(sc);
                break;
            case DeleteOP:
                operation = new DeleteOP();
                operation.setStateContent(sc);
                break;
        }
        return operation;
    }
}

定义一个操作类的统一入口：

package com.dz.pattern.simplefactorypattern;

import com.dz.pattern.simplefactorypattern.entity.StateContent;
import com.dz.pattern.simplefactorypattern.enumeration.OperationEnum;
import com.dz.pattern.simplefactorypattern.operation.BaseOperation;

/**
 * Created by Dz on 2019/3/17.
 */
public class OperationSet {
    SimpleOperationFactory simpleOperationFactory =new SimpleOperationFactory();

    public void executeOperation(long keyId, OperationEnum operationEnum){
        StateContent stateContent = new StateContent();
        stateContent.setKeyId(keyId);
        stateContent.setOperation(operationEnum);
        BaseOperation baseOperation = simpleOperationFactory.createOperation(stateContent);
        baseOperation.onExecute();
    }
}

在实现的过程中还使用到了两个辅助类：

StateContent：上下文参数类，便于后面具体的操作实现

OperationEnum：操作枚举类，用于枚举具体的操作，可以有效的防止传参时输入错误

package com.dz.pattern.simplefactorypattern.entity;

import com.dz.pattern.simplefactorypattern.enumeration.OperationEnum;

/**
 * Created by Dz on 2019/3/17.
 */
public class StateContent {
    private long keyId;

    private OperationEnum operation;

    public long getKeyId() {
        return keyId;
    }

    public void setKeyId(long keyId) {
        this.keyId = keyId;
    }

    public OperationEnum getOperation() {
        return operation;
    }

    public void setOperation(OperationEnum operation) {
        this.operation = operation;
    }
}

package com.dz.pattern.simplefactorypattern.enumeration;

/**
 * Created by Dz on 2019/3/17.
 */
public enum OperationEnum {
    CancelOP,
    DeleteOP
}

 最后测试这个简单工厂：

package com.dz.pattern.simplefactorypattern;

import com.dz.pattern.simplefactorypattern.entity.StateContent;
import com.dz.pattern.simplefactorypattern.enumeration.OperationEnum;

/**
 * Created by Dz on 2019/3/17.
 */
public class OperationDemo {
    public static void main(String[] args) {
        OperationSet operationSet = new OperationSet();

        operationSet.executeOperation(100,OperationEnum.CancelOP);

        operationSet.executeOperation(100,OperationEnum.DeleteOP);

    }
}

 输出如下：

CancelOP Execute, keyId = 100
DeleteOP Execute, keyId = 100

简单工厂模式一般又被称为静态工厂模式，主要是因为在创建具体对象的时候使用的是静态方法，所以被称为静态工厂模式。上文中没有使用，要是想使用的话可修改 OperationFactory 类的方法 createOperation，如下：

public class OperationFactory {

    public static BaseOperation createOperation(StateContent sc) {
        BaseOperation operation = null;
        switch (sc.getOperation()) {
            case CancelOP:
                operation = new CancelOP();
                operation.setStateContent(sc);
                break;
            case DeleteOP:
                operation = new DeleteOP();
                operation.setStateContent(sc);
                break;
        }
        return operation;
    }
}

同时修改调用的地方：

public class OperationDemo {

    public static void main(String[] args) {
//        OperationFactory operationFactory = new OperationFactory();

        StateContent sc = new StateContent();
        sc.setKeyId(100);
        sc.setOperation(OperationEnum.CancelOP);
        BaseOperation baseOperation = OperationFactory.createOperation(sc);
        baseOperation.onExecute();

        sc.setOperation(OperationEnum.DeleteOP);
        baseOperation = OperationFactory.createOperation(sc);
        baseOperation.onExecute();

    }
}