设计模式-04 工厂模式、模版模式

于 2019-07-23 20:37:21 发布
阅读量891 收藏
点赞数
分类专栏： 设计模式 文章标签： 工厂模式 模板模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_31463999/article/details/97031684
版权
本文详细介绍了设计模式中的工厂模式和模板模式。工厂模式用于解耦对象的创建与使用，降低了代码重复，提高了代码的可维护性。在Spring框架中，工厂模式有广泛应用。模板模式则定义了算法的骨架，允许子类在不改变算法结构的情况下重定义特定步骤。文章通过代码示例展示了模板方法的实现，并对比了策略模式与模板模式的区别。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

1.工厂模式

  • 工厂模式是为了解耦：把对象的创建和使用的过程分开。就是Class A 想调用Class B,那么只是调用B的方法，而至于B的实例化，就交给工厂类。
  • 工厂模式可以降低代码重复。如果创建B过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。可以把这些创建对象B的代码放到工厂里统一管理。既减少了重复代码，也方便以后对B的维护。
  • 工厂模式可以减少错误，因为工厂管理了对象的创建逻辑，使用者不需要知道具体的创建过程，只管使用即可，减少了使用者因为创建逻辑导致的错误。

工厂模式可以分为简单工厂、工厂方法、抽象工厂、静态工厂模式

@Component
public interface PaymentService {

    public void pay();
}

public class AliPaySercice implements PaymentService {
    @Override
    public void pay() {
        System.out.println("阿里支付对象...");
    }
}

public class WeChatService implements PaymentService {
    @Override
    public void pay() {
        System.out.println("微信支付对象...");
    }
}

//工厂
class PayMentFactory {

    public static PaymentService getPaymentService(String payType) {
        PaymentService paymentService = null;
        switch (payType) {
            case "ali_pay":
                paymentService = new AliPaySercice();
                break;
            case "wechat_pay":
                paymentService = new WeChatService();
                break;
        }
        return paymentService;
    }
}

1.1 Spring框架中工厂模式

[外链图片转存失败(img-iTowZUhm-1563885280721)(http://note.youdao.com/yws/res/28166/840EA719EED74D2BB84BB77E4F68B1DE)]
在这里插入图片描述

1.2 工厂模式优缺点

  • 优点：

    • 代码结构简单。
    • 获取产品的过程更加简单。
    • 满足了开闭原则，即对拓展开放，对修改关闭。

  • 缺点：

    • 拓展较繁琐，要拓展时，需同时改动抽象工厂和工厂实现类。

2.模版模式

2.1 什么是模版方法

  • 定义了一个操作中的算法的骨架，而将部分步骤的实现在子类中完成。
    模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
  • 模板方法模式是所有模式中最为常见的几个模式之一，是基于继承的代码复用的基本技术，没有关联关系。 因此，在模板方法模式的类结构图中，只有继承关系。

2.2 代码实现

在这里插入图片描述

2.2.1 添加依赖

<!-- sprinboot web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

2.2.2 启动类

@SpringBootApplication
public class AppTemplate {
    public static void main(String[] args) {
        SpringApplication.run(AppTemplate.class);
    }
}

2.2.3 抽象类

@Slf4j
public abstract class AbstractPayCallbackTemplate {


    /**
     * 定义共同行为的骨架
     *
     * @return
     */
    public String asyncCallBack() {
        // 1.验证参数和验证签名
        Map<String, String> verifySignature = verifySignature();
        // 2.日志收集 相同
        payLog(verifySignature);
        // 3. 获取验证签名状态
        String analysisCode = verifySignature.get("analysisCode");
        if (!analysisCode.equals("200")) {
            return resultFail();
        }
        // 3.更改数据库状态同时返回不同支付结果
        return asyncService(verifySignature);

    }

    /**
     * 使用多线程异步写入日志
     *
     * @param verifySignature
     */
    public void payLog(Map<String, String> verifySignature) {
        log.info("第二步骤 写入数据库....verifySignature:{}", verifySignature);
    }

    /**
     * 验证参数...
     *
     * @return
     */
    protected abstract Map<String, String> verifySignature();

    /**
     * 执行修改订单状态和返回不用的结果..
     *
     * @param verifySignature
     * @return
     */
    protected abstract String asyncService(Map<String, String> verifySignature);

    /**
     * 返回失败结果
     *
     * @return
     */
    protected abstract String resultFail();

    /**
     * 返回成功结果
     *
     * @return
     */
    protected abstract String resultSuccess();

}

2.2.4 实现类

@Slf4j
@Component
public class AliPayCallbackTemplate extends AbstractPayCallbackTemplate {
    @Override
    protected Map<String, String> verifySignature() {
        //>>>>假设一下为阿里pay回调报文>>>>>>>>>>>>>>>>
        log.info(">>>>>第一步 解析支付宝据报文.....verifySignature()");
        Map<String, String> verifySignature = new HashMap<>();
        verifySignature.put("price", "888");
        verifySignature.put("orderDes", "支付宝描述");
        // 支付状态为1表示为成功....
        verifySignature.put("aliPayMentStatus", "1");
        verifySignature.put("aliPayOrderNumber", "201910101011");
        //>>>>假设一下为阿里pay回调报文结束>>>>>>>>>>>>>>>>

        // 解析报文是否成功 或者验证签名成功返回 200 为成功..
        verifySignature.put("analysisCode", "200");
        return verifySignature;

    }

    @Override
    protected String asyncService(Map<String, String> verifySignature) {
        log.info(">>>>>第三步 支付宝支付 asyncService()verifySignatureMap:{}", verifySignature);
        String paymentStatus = verifySignature.get("aliPayMentStatus");
        if (paymentStatus.equals("1")) {
            String aliPayOrderNumber = verifySignature.get("aliPayOrderNumber");
            log.info(">>>>orderNumber:{aliPayOrderNumber},已经支付成功 修改订单状态为已经支付...");
        }

        return resultSuccess();
    }

    @Override
    protected String resultFail() {
        return "fail";
    }

    @Override
    protected String resultSuccess() {
        return "success";
    }
}


@Slf4j
@Component
public class UnionPayCallbackTemplate extends AbstractPayCallbackTemplate {
    @Override
    protected Map<String, String> verifySignature() {
        //>>>>假设一下为银联回调报文>>>>>>>>>>>>>>>>
        log.info(">>>>>第一步 解析银联据报文.....verifySignature()");
        Map<String, String> verifySignature = new HashMap<>();
        verifySignature.put("price", "9999");
        verifySignature.put("orderDes", "银联描述");
        // 支付状态为1表示为成功....
        verifySignature.put("unionPayMentStatus", "1");
        verifySignature.put("unionPayOrderNumber", "201910101011");
        //>>>>假设一下为银联回调报文结束>>>>>>>>>>>>>>>>

        // 解析报文是否成功 或者验证签名成功返回 200 为成功..
        verifySignature.put("analysisCode", "200");
        return verifySignature;

    }

    @Override
    protected String asyncService(Map<String, String> verifySignature) {
        log.info(">>>>>第三步 银联回调  asyncService()verifySignatureMap:{}", verifySignature);
        String paymentStatus = verifySignature.get("unionPayMentStatus");
        if (paymentStatus.equals("1")) {
            String aliPayOrderNumber = verifySignature.get("aliPayOrderNumber");
            log.info(">>>>orderNumber:{aliPayOrderNumber},已经支付成功 修改订单状态为已经支付...");
        }

        return resultSuccess();
    }

    @Override
    protected String resultFail() {
        return "fail";
    }

    @Override
    protected String resultSuccess() {
        return "ok";
    }
}

2.2.5 工厂

public class TemplateFactory {

    /**
     * 使用工厂模式获取模版
     *
     * @param templateId
     * @return
     */
    public static AbstractPayCallbackTemplate getPayCallbackTemplate(String templateId) {
        AbstractPayCallbackTemplate payCallbackTemplate = (AbstractPayCallbackTemplate) SpringUtils.getBean(templateId);
        return payCallbackTemplate;
    }
}

2.2.6 controller

@RestController
public class TemplateController {
    /**
     * 支付回调
     * @return
     */
    @RequestMapping("/asyncCallBack")
    public String asyncCallBack(String templateId) {
        AbstractPayCallbackTemplate payCallbackTemplate = TemplateFactory.getPayCallbackTemplate(templateId);
        // 使用模版方法模式 执行共同的骨架
        return payCallbackTemplate.asyncCallBack();
    }
}

2.2.7 测试

在这里插入图片描述
在这里插入图片描述

2.3 模式模式优缺点

  • 优点

模板方法模式通过把不变的行为搬移到超类，去除了子类中的重复代码。子类实现算法的某些细节，有助于算法的扩展。通过一个父类调用子类实现的操作，通过子类扩展增加新的行为，符合“开放-封闭原则”。

  • 缺点

每个不同的实现都需要定义一个子类，这会导致类的个数的增加，设计更加抽象。

  • 适用场景

在某些类的算法中，用了相同的方法，造成代码的重复。控制子类扩展，子类必须遵守算法规则。servlet-doGet()/doPost()

2.4 策略模式与模版方法模式的区别

  • 策略是算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
  • 模板方法模式在一个方法中定义一个算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

源代码托管

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值