设计模式（1）简单工厂模式

一、介绍：

1、定义：简单工厂模式又叫做静态工厂方法模式，是由一个工厂对象决定创建出哪一种产品类的实例。

2、结构组成：

（1）Factory：工厂类，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法

        createProduct()可以被外界直接调用，创建所需的产品对象。
（2）Product：抽象的产品类。
（3）ProductA，ProductB：具体的产品实现类。

最后Client客户端,调用工厂类的createProduct()方法来创建产品实例。

//产品抽象类
public abstract class Product {
    public abstract void run();
}

//具体产品实现类
public class ProductA extends Product {
    @Override
    public void run() {
        System.out.println("这是A产品");
    }
}



public class ProductB extends Product {
    @Override
    public void run() {
        System.out.println("这是B产品");
    }
}


//工厂类
public class ProductFactory {
    /**
     * 工厂的静态创建对象方法
     *
     * @param productName 产品名称
     * @return Product抽象类的子类实例
     */
    public static Product createProduct(String productName) {
        Product product = null;
        switch (productName) {
            case "A":
                product = new ProductA();
                break;
            case "B":
                product = new ProductB();
                break;
        }
        return product;
    }
}


//客户端
public class Test {
    public static void main(String[] args) {
        // 通过Product工厂创建一个实例对象出来
        Product product = ProductFactory.createProduct("B");
        // 执行新实例对象的run方法
        product.run();
    }
}

3、代码实现：有三种写法：

（1）普通工厂写法 ：工厂类需要new

ProductFactory  factory  = new ProductFactory();
Product product = factory.createProduct("B");
product .run();

（2）多个工厂方法写法：防止传参出错不能正确创建对象，工厂类中不接受参数了而是写多个方法创建不同的对象 

public class ProductFactory {
    
    public Product createProductA(String productName) {
        return new  ProductA(); 
    }

  public Product createProductB(String productName) {
        return new  ProductB(); 
    }
}

（3） 静态工厂写法：工厂类不需要new，也不接受参数，这是常见的写法。

public class ProductFactory {
    
    public static Product createProductA(String productName) {
        return new  ProductA(); 
    }

  public static Product createProductB(String productName) {
        return new  ProductB(); 
    }
}


客户端：
Product productA = factory.createProductA();
product .run();

二、demo：

1、现有一个任务task，有任务类型（TXT_TO_MYSQL、MYSQL_TO_TXT、MONGO_TO_TXT），需要根据不同的任务类型去处理业务逻辑。如果不使用设计模式，原始的写法会是大段的if...else/switch：

if("TXT_TO_MYSQL".equals(type)){
 ...........
}

if("MYSQL_TO_TXT".equals(type)){

...........

}

if("MONGO_TO_TXT".equals(type)){

...........

}
...........

采用简单工厂模式优化后的写法：

 父类：

/**
 * kettle任务
 */
public class KettleTask {

     /**
      * 节点参数
      */
     private Map<String, String> params;

     /**
      *
      * part参数
      */
     private  ElTask elTask;

     public KettleTask(){

     }

     public KettleTask(Map<String, String> params,ElTask elTask){
          this.params = params;
          this.elTask = elTask;
     }

    /**省略所有get和set方法**/


     //执行逻辑，子类各自实现
     public ElTask run() throws Exception {
          return null;
     }
}

  实现子类：

public class Mongo2TxtTask extends    KettleTask{

    public Mongo2TxtTask() {
    }

    public Mongo2TxtTask(Map<String, String> params, ElTask elTask) {
        super(params, elTask);
    }

    @Override
    public ElTask run() throws Exception {
        Map<String, String> params = this.getParams();
        ElTask elTask = this.getElTask();
        String partParams = elTask.getParams();
        ......
        ......
        KettleResult result = KettleUtil.runMongoTotxt(params);
        elTask.setStatus(ProcessResult.SUCCESS.toString());
        elTask.setResult(result.toString());
        return elTask;
    }
}

public class Mysql2TxtTask extends    KettleTask{

    public Mysql2TxtTask() {
    }

    public Mysql2TxtTask(Map<String, String> params, ElTask elTask) {
        super(params, elTask);
    }

    @Override
    public ElTask run() throws Exception {
        Map<String, String> params = this.getParams();
        ElTask elTask = this.getElTask();
        String partParams = elTask.getParams();
        String dataBase = params.get("dataBase");
        ......
        .......
        KettleResult result = KettleUtil.runMysqlToTxtTemplateKtr(params);
        elTask.setStatus(ProcessResult.SUCCESS.toString());
        elTask.setResult(result.toString());
        return elTask;
    }
}

public class Txt2MysqlTask  extends    KettleTask{

    private  Logger logger = LoggerFactory
            .getLogger(Txt2MysqlTask.class);

    public Txt2MysqlTask() {
        super();
    }

    public Txt2MysqlTask(Map<String, String> params, ElTask elTask) {
        super(params, elTask);
    }

    @Override
    public ElTask run() throws Exception {
        Map<String, String> params = this.getParams();
        ElTask elTask = this.getElTask();
        .......
        .......
        KettleResult result = KettleUtil.runTxtToMysqlTemplateKtr(params);
        elTask.setStatus(ProcessResult.SUCCESS.toString());
        elTask.setResult(result.toString());
        return elTask;
    }
}

  工厂类：

public class KettleTaskFactory {

    public static KettleTask getKettleTask(String stepType, Map<String, String> params, ElTask elTask) {
        KettleTask kettleTask = null;
        switch (stepType){
            case "TXT_TO_MYSQL":
                kettleTask = new Txt2MysqlTask(params,elTask);
                break;
            case "MYSQL_TO_TXT":
                kettleTask = new Mysql2TxtTask(params,elTask);
                break;
            case "MONGO_TO_TXT":
                kettleTask = new Mongo2TxtTask(params,elTask);
                break;
            default:
                break;
        }
        return kettleTask;
    }
}

  调用处：

KettleTask kettleTask = KettleTaskFactory.getKettleTask(step.getStepType(),params,elTask);
elTask = kettleTask.run();
return elTask;

2、

public PageInfo<ImportData> pageList(ImportDataQuery query) {
        PageHelper.startPage(query.getPage(), query.getPageSize(), true);
        List<ImportData> result = new ArrayList<>();
        Integer importType = query.getImportType();
        if("1".equals(importType)){
            //项目表1
            result = project1Mapper.select(query);
        }else if("2".equals(importType)){
            //项目表2
            result = project2Mapper.select(query);
        }
        return new PageInfo<>(result);
    }

result在不同的type中内容会保留子类的字段值。其中，两个mapper都是一样的：

List<ImportData> select(@Param("query") ImportDataQuery query);

<resultMap id="BaseResultMap" 
 type="com.xxx.Project1">
    <id column="id" jdbcType="INTEGER" property="id" />
    <result column="prov_name" jdbcType="VARCHAR" property="provName" />
    <result column="status" jdbcType="TINYINT" property="status" />
  </resultMap> 

 <select id="select"  resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from project_one
    where status = #{query.status}
    order by id
  </select>

 实体类：

public class ImportData {
 
}

public class Project1 extends ImportData{

private String name;
}

public class Project2 extends ImportData{

 private String provName;
}