徒手撸设计模式-抽象工厂模式

2022-07-06 17:49 hikoukay 阅读(26) 评论(0) 编辑收藏举报

概念

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

参考链接: https://www.runoob.com/design-pattern/abstract-factory-pattern.html

代码案例

公共类

枚举类

public final class StFlag {
    public StFlag() {
    }

    /**
     * 性别:0-男,1-女
     */
    public static final String SEX_FLAG_0="0";
    public static final String SEX_FLAG_1="1";

    /**
     * 操作类型:A-新增,D-删除,U-更新
     */
    public static final String OPTION_A="A";
    public static final String OPTION_D="D";
    public static final String OPTION_U="U";
    /**
     * 策略模式变量
     */
    public static final String FEE_MODEL="feeModel_";
    /**
     * 汽车
     */
    public static final String CAR="CAR";
    /**
     * 自行车
     */
    public static final String BICYCLE="BICYCLE";
    /**
     * 火车
     */
    public static final String TRAIN="TRAIN";
    /**
     * 黑色
     */
    public static final String BLACK="BLACK";
    /**
     * 蓝色
     */
    public static final String BLUE="BLUE";
    /**
     * 红色
     */
    public static final String RED="RED";
    /**
     * 车子工厂
     */
    public static final String CARS="CARS";
    /**
     * 刷漆工厂
     */
    public static final String PAINTING="PAINTING";

}

请求入参

@Data
public class RequestStudentModel implements Serializable {
    /**
     * 操作类型
     */
    private String option;

    /**
     * id
     */
    private Integer id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 性别
     */
    private String sex;

    /**
     * 身高
     */
    private String height;

    /**
     * 爱好
     */
    private String hobby;
    /**
     * 工厂类型
     */
    private String factoryType;
    /**
     * 颜色集合
     */
    private String[] colourTypeArr;
    /**
     * 车子集合
     */
    private String[] carsTypeArr;
}

出参

/**
 * 响应结果类
 */
@Data
@ToString
public class ResponseModel implements Serializable {
    //消息
    private String message;
    //状态码
    private int messageCode;
    //结果
    private Object result;

    public ResponseModel(String message, int messageCode, Object result) {
        this.message = message;
        this.messageCode = messageCode;
        this.result = result;
    }

    public ResponseModel() {
    }
}

创建两个接口

刷漆接口

/**
 * 刷漆接口
 */
public interface BrushPainting {
    /**
     * 生产方法
     * @return
     */
    String brush();
}

制造接口

/**
 * 制造接口
 */
public interface CarsManufacture {
    /**
     * 生产方法
     * @return
     */
    String product();
}

创建一个抽象工厂

/**
 * 抽象工厂
 */
public abstract class AbstractFactory {
    /**
     * 制造车子
     * @param carType
     * @return
     */
    public abstract CarsManufacture getManufacture(String carType);

    /**
     * 刷漆
     * @param caloreType
     * @return
     */
    public abstract BrushPainting getBrushPainting(String caloreType);
}

创建三个喷漆实现类

刷红漆

@Slf4j
public class Red implements BrushPainting {
    /**
     *
     * @return
     */
    @Override
    public String brush() {
        log.info("刷红漆");
        return "红漆";
    }
}

刷黑漆

@Slf4j
public class Black implements BrushPainting {
    /**
     *
     * @return
     */
    @Override
    public String brush() {
        log.info("刷黑漆");
        return "黑漆";
    }
}

刷蓝漆

@Slf4j
public class Blue implements BrushPainting {
    /**
     *
     * @return
     */
    @Override
    public String brush() {
        log.info("刷蓝漆");
        return "蓝漆";
    }
}

创建三个制造实现类

自行车

@Slf4j
public class Bicycle implements CarsManufacture {
    /**
     * 生产自行车
     */
    @Override
    public String product() {
        log.info("生产出一辆自行车");
        return "自行车";
    }
}

汽车

@Slf4j
public class Car implements CarsManufacture {
    /**
     * 生产汽车
     * @return
     */
    @Override
    public String product() {
        log.info("生产出一辆汽车");
        return "汽车";
    }
}

火车

@Slf4j
public class Train implements CarsManufacture {
    /**
     * 生产火车
     * @return
     */
    @Override
    public String product() {
        log.info("生产出一辆火车");
        return "火车";
    }
}

创建制造工厂-继承抽象工厂

/**
 * 制造工厂
 */
@Slf4j
public class CarFactory extends AbstractFactory {
    /**
     * 制造车子
     * @param carType
     * @return
     */
    @Override
    public CarsManufacture getManufacture(String carType){
        if (StringUtils.isEmpty(carType)){
            return  null;
        }
        if (StFlag.CAR.equals(carType)){
            log.info("汽车制造厂");
            return new Car();
        }else if (StFlag.BICYCLE.equals(carType)){
            log.info("自行车制造厂");
            return new Bicycle();
        }else if (StFlag.TRAIN.equals(carType)){
            log.info("火车制造厂");
            return new Train();
        }
        return null;
    }

    /**
     *  刷漆
     * @param caloreType
     * @return
     */
    @Override
    public BrushPainting getBrushPainting(String caloreType) {
        return null;
    }
}

创建喷漆工厂-继承抽象工厂

/**
 * 喷漆工厂
 */
@Slf4j
public class PaintingFactory extends AbstractFactory{
    /**
     * 制造车子
     * @param carType
     * @return
     */
    @Override
    public CarsManufacture getManufacture(String carType) {
        return null;
    }

    /**
     *  刷漆
     * @param caloreType
     * @return
     */
    @Override
    public BrushPainting getBrushPainting(String caloreType){
        if (StringUtils.isEmpty(caloreType)){
            return  null;
        }
        if (StFlag.RED.equals(caloreType)){
            log.info("红漆工厂");
            return new Red();
        }else if (StFlag.BLACK.equals(caloreType)){
            log.info("黑漆工厂");
            return new Black();
        }else if (StFlag.BLUE.equals(caloreType)){
            log.info("蓝漆工厂");
            return new Blue();
        }
        return null;
    }
}

创建工厂生产者

/**
 * 工厂生产者
 */
public class FactoryProducr {
    public static AbstractFactory getFactory(String factoryType){
        if (factoryType.equals(StFlag.CARS)){
            return new CarFactory();
        }else if (factoryType.equals(StFlag.PAINTING)){
            return new PaintingFactory();
        }else {
            return null;
        }
    }
}

测试类

/**
 * 设计模式控制器
 */
@RestController
@RequestMapping("/designPattern")
@Slf4j
public class DesignController {
    /**
     * 抽象工厂模式
     * @param studentEntity
     * @return
     */
    @PostMapping("/abstractFactoryProduct")
    public  ResponseModel abstractFactoryProduct(@RequestBody RequestStudentModel studentEntity){
        String factoryType = studentEntity.getFactoryType();
        //获取车子集合
        String[] carsArr = studentEntity.getCarsTypeArr();
        //获取颜色集合
        String[] colourArr = studentEntity.getColourTypeArr();
        AbstractFactory abstractFactoryactory = FactoryProducr.getFactory(factoryType);
        if (StringUtils.isEmpty(factoryType) || null ==abstractFactoryactory){
            return new ResponseModel("请输入正确的工厂类型", 500, null);
        }
        List list = new ArrayList();
        //遍历生产车子
        if (!CollectionUtils.isEmpty(Arrays.asList(carsArr))){
            log.info("============开始生产车子================");
            for (String car : carsArr) {
                CarsManufacture manufacture = abstractFactoryactory.getManufacture(car);
                list.add(manufacture.product());
            }
            log.info("============生产车子完成================");

        }
        //遍历喷漆
        if (!CollectionUtils.isEmpty(Arrays.asList(colourArr))){
            log.info("============开始喷漆================");
            for (String colour : colourArr) {
                BrushPainting brushPainting = abstractFactoryactory.getBrushPainting(colour);
                list.add(brushPainting.brush());
            }
            log.info("============喷漆完成================");
        }
        return new ResponseModel("生产成功", 200, list);
    }
}

测试案例

创建车子工厂-生成车子

2022-06-15 23:25:46.155 INFO  ============开始生产车子================ 【http-nio-8081-exec-3】【DesignController:153】
2022-06-15 23:25:46.160 INFO  汽车制造厂 【http-nio-8081-exec-3】【CarFactory:25】
2022-06-15 23:25:46.160 INFO  生产出一辆汽车 【http-nio-8081-exec-3】【Car:14】
2022-06-15 23:25:46.161 INFO  自行车制造厂 【http-nio-8081-exec-3】【CarFactory:28】
2022-06-15 23:25:46.162 INFO  生产出一辆自行车 【http-nio-8081-exec-3】【Bicycle:14】
2022-06-15 23:25:46.164 INFO  火车制造厂 【http-nio-8081-exec-3】【CarFactory:31】
2022-06-15 23:25:46.164 INFO  生产出一辆火车 【http-nio-8081-exec-3】【Train:14】
2022-06-15 23:25:46.164 INFO  ============生产车子完成================ 【http-nio-8081-exec-3】【DesignController:158】

创建喷漆工厂-喷漆

2022-06-15 23:32:29.455 INFO  ============开始喷漆================ 【http-nio-8081-exec-8】【DesignController:163】
2022-06-15 23:32:29.455 INFO  红漆工厂 【http-nio-8081-exec-8】【PaintingFactory:35】
2022-06-15 23:32:29.456 INFO  刷红漆 【http-nio-8081-exec-8】【Red:14】
2022-06-15 23:32:29.456 INFO  黑漆工厂 【http-nio-8081-exec-8】【PaintingFactory:38】
2022-06-15 23:32:29.456 INFO  刷黑漆 【http-nio-8081-exec-8】【Black:14】
2022-06-15 23:32:29.456 INFO  蓝漆工厂 【http-nio-8081-exec-8】【PaintingFactory:41】
2022-06-15 23:32:29.456 INFO  刷蓝漆 【http-nio-8081-exec-8】【Blue:14】
2022-06-15 23:32:29.457 INFO  ============喷漆完成================ 【http-nio-8081-exec-8】【DesignController:168】

刷新页面返回顶部

hikoukay