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

雨点打透心脏的1/2处 2021-11-26 08:50 385阅读 0赞

### 文章目录 ###

*  1.工厂模式
 *   *  1.1 Spring框架中工厂模式
     *  1.2 工厂模式优缺点
 *  2.模版模式
 *   *  2.1 什么是模版方法
     *  2.2 代码实现
     *   *  2.2.1 添加依赖
         *  2.2.2 启动类
         *  2.2.3 抽象类
         *  2.2.4 实现类
         *  2.2.5 工厂
         *  2.2.6 controller
         *  2.2.7 测试
     *  2.3 模式模式优缺点
     *  2.4 策略模式与模版方法模式的区别
     *  源代码托管

# 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)\]][img-iTowZUhm-1563885280721_http_note.youdao.com_yws_res_28166_840EA719EED74D2BB84BB77E4F68B1DE]  
![在这里插入图片描述][20190723203541127.png]

## 1.2 工厂模式优缺点 ##

*  优点：
    
     *  代码结构简单。
     *  获取产品的过程更加简单。
     *  满足了开闭原则，即对拓展开放，对修改关闭。
 *  缺点：
    
     *  拓展较繁琐，要拓展时，需同时改动抽象工厂和工厂实现类。

# 2.模版模式 #

## 2.1 什么是模版方法 ##

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

## 2.2 代码实现 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDYzOTk5_size_16_color_FFFFFF_t_70]

### 2.2.1 添加依赖 ###

<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 测试 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDYzOTk5_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDYzOTk5_size_16_color_FFFFFF_t_70 2]

## 2.3 模式模式优缺点 ##

*  优点

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

*  缺点

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

*  适用场景

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

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

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

## [源代码托管][Link 1] ##

[img-iTowZUhm-1563885280721_http_note.youdao.com_yws_res_28166_840EA719EED74D2BB84BB77E4F68B1DE]: /images/20211126/c76ac74224f74a7f9790dbed7b51e117.png
[20190723203541127.png]: /images/20211126/d011a22e4d1747f6ac4edf0a8e937d49.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDYzOTk5_size_16_color_FFFFFF_t_70]: /images/20211126/e401f32cfced4cf1a272c2c61773775c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDYzOTk5_size_16_color_FFFFFF_t_70 1]: /images/20211126/de2e543578a3449fad62fbadab9549d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDYzOTk5_size_16_color_FFFFFF_t_70 2]: /images/20211126/7bc310d8998043d69f60d256d35c83a8.png
[Link 1]: https://gitee.com/itmyx/designpatterns-demo