【设计模式】【第一章】【支付场景】【策略模式 + 工厂模式 + 门面模式 + 单例模式】

Java 设计模式实战:工厂模式、单例模式到策略模式 在复杂业务系统的演进过程中,设计模式是解决代码臃肿、提升可维护性的关键武器。本文将以电商系统为背景,通过实际代码演示工厂模式、单例模式和策略模式的落地应用,揭示如何用设计模式写出高扩展性的 Java 代码。 阅读详情

创建design-demo项目

项目代码:https://gitee.com/java_wxid/java_wxid/tree/master/demo/design-demo
项目结构如下(示例):
在这里插入图片描述

修改pom.xml

代码如下(示例):

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>


    <groupId>com.example</groupId>
    <artifactId>design-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>design-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.statemachine</groupId>
            <artifactId>spring-statemachine-core</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

传统模式开发

创建PayController

代码如下(示例):

package com.example.designdemo.controller;

import com.example.designdemo.pojo.PayBody;
import com.example.designdemo.service.PayService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:26
 * @Description:
 */
@RestController
@RequestMapping("/pay")
public class PayController {

    @Autowired
    private PayService payService;

    @PostMapping("/dopay")
    public Boolean dopay(@RequestBody PayBody payBody){
        return payService.pay(payBody);
    }

}

创建PayService

代码如下(示例):

package com.example.designdemo.service;

import com.example.designdemo.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:28
 * @Description:
 */

public interface PayService {


    Boolean pay(PayBody payBody);
}

创建PayServiceImpl

代码如下(示例):

package com.example.designdemo.service.impl;

import com.example.designdemo.handler.PayHandler;
import com.example.designdemo.pojo.PayBody;
import com.example.designdemo.service.PayService;
import org.springframework.stereotype.Service;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:29
 * @Description:
 */
@Service
public class PayServiceImpl implements PayService {


    @Override
    public Boolean pay(PayBody payBody) {
        //付款逻辑
        boolean flag = false;
        int type = payBody.getType();
        if (type == 0) {
            //支付宝支付逻辑
            flag = PayHandler.zfbpay(payBody);
        }else if(type == 1){
            //微信支付逻辑
            flag = PayHandler.wxbpay(payBody);
        }else if(type == 2){
            //银行卡支付逻辑
            flag = PayHandler.bankbpay(payBody);
        }else {
            throw new UnsupportedOperationException("unsupport type,please choose o,1,2 ");
        }

        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;
    }
}

创建PayBody

代码如下(示例):

package com.example.designdemo.pojo;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:29
 * @Description: 属性的类型这里都是简写,实战项目肯定不会写这么粗糙,这里主要是写设计模式相关,细节就不抠了。
 */

public class PayBody {
    //账号
    private String account;
    //支付类型
    private int type;
    //产品信息
    private String product;
    //金额
    private int amcount;

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public String getProduct() {
        return product;
    }

    public void setProduct(String product) {
        this.product = product;
    }

    public int getAmcount() {
        return amcount;
    }

    public void setAmcount(int amcount) {
        this.amcount = amcount;
    }
}

创建PayHandler

代码如下(示例):

package com.example.designdemo.handler;

import com.example.designdemo.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:42
 * @Description:
 */
@Component
public class PayHandler {


    public static boolean zfbpay(PayBody payBody) {
        //详细调用支付宝提供的第三方接口
        //........................
        return true;
    }

    public static boolean wxbpay(PayBody payBody) {
        //详细调用支付宝提供的第三方接口
        //........................
        return true;
    }

    public static boolean bankbpay(PayBody payBody) {
        //详细调用支付宝提供的第三方接口
        //........................
        return true;
    }
}

传统模式开发总结

正常这段代码逻辑是没什么问题的,初中级这么写也没什么毛病。
但是对于高级开发而言,就需要思考它的一个扩展性,封装性了,这里举个例子:
假设PayServiceImpl.pay是由你来写的,PayHandler.zfbpay、PayHandler.wxbpay、PayHandler.bankbpay是由另外一个同事来写的,并且以jar包的形式集成到你的项目中,提供给你调用的。

弊端:

  • PayServiceImpl.pay作为业务的调用端,需要掌握的信息比较多,需要知道PayHandler.zfbpay、PayHandler.wxbpay、PayHandler.bankbpay的接口入参和返回参数。
  • 调用方式比较繁琐,每个支付方式都要有一个方法调用,我们有更简洁的方式提供,比如传入参数PayHandler.pay(0 or 1 or 2)代表不同的支付方式
  • if else过多,不够优雅
  • 不太好扩展,只要引入一个新的支付方式,PayHandler那边新添加一个方法,那么PayServiceImpl.pay的代码就需要改动,对业务层的代码进行了修改,任何的代码改动都有可能导致之前的业务逻辑产生问题,比如代码合并覆盖,不小心多加了个字母等等,所以我们希望对业务层的代码能不做改动就尽量别去动业务层的代码
  • 接口不好迁移,假设后面架构师搭好了一套新的框架,需要把支付相关的接口迁移过去,这个时候就得把代码一块一块的迁移,调用逻辑全得看一遍,不能整个包复制粘贴过去,然后微调一下就实现接口迁移,比较费时。

后面我们一步一步进行改造,最终的目标就是解决上述的问题

引入策略模式

首先对上述代码进行改造,先引入策略模式

对PayServiceImpl进行改造

代码如下(示例):

package com.example.designdemo.service.impl;

import com.example.designdemo.context.PayContext;
import com.example.designdemo.handler.PayHandler;
import com.example.designdemo.inter.BankPayStrategy;
import com.example.designdemo.inter.WxPayStrategy;
import com.example.designdemo.inter.ZfbPayStrategy;
import com.example.designdemo.pojo.PayBody;
import com.example.designdemo.service.PayService;
import org.springframework.stereotype.Service;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:29
 * @Description:
 */
@Service
public class PayServiceImpl implements PayService {


    @Override
    public Boolean pay(PayBody payBody) {
/*        //传统模式开发支付逻辑
        boolean flag = false;
        int type = payBody.getType();
        if (type == 0) {
            //支付宝支付逻辑
            flag = PayHandler.zfbpay(payBody);
        }else if(type == 1){
            //微信支付逻辑
            flag = PayHandler.wxpay(payBody);
        }else if(type == 2){
            //银行卡支付逻辑
            flag = PayHandler.bankbpay(payBody);
        }else {
            throw new UnsupportedOperationException("unsupport type,please choose o,1,2 ");
        }

        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;*/

        //引入策略模式开发支付逻辑
        boolean flag = false;
        int type = payBody.getType();
        if (type == 0) {
            //支付宝支付逻辑
            flag = new PayContext(new ZfbPayStrategy()).execute(payBody);
        }else if(type == 1){
            //微信支付逻辑
            flag = new PayContext(new WxPayStrategy()).execute(payBody);
        }else if(type == 2){
            //银行卡支付逻辑
            flag = new PayContext(new BankPayStrategy()).execute(payBody);
        }else {
            throw new UnsupportedOperationException("unsupport type,please choose o,1,2 ");
        }

        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;
    }
}

创建PayContext

代码如下(示例):

package com.example.designdemo.context;

import com.example.designdemo.inter.PayStrategy;
import com.example.designdemo.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:30
 * @Description: 起到承上启下的作用
 */

public class PayContext {

    private PayStrategy payStrategy;

    public PayContext(PayStrategy payStrategy){
        this.payStrategy = payStrategy;
    }

    public Boolean execute(PayBody payBody){
        return this.payStrategy.pay(payBody);
    }

}

创建PayStrategy

代码如下(示例):

package com.example.designdemo.inter;

import com.example.designdemo.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:23
 * @Description: 引入策略模式
 */

public interface PayStrategy {

    //未来顶PayHandler里面的三个
    Boolean pay(PayBody payBody);

}

创建BankPayStrategy

代码如下(示例):

package com.example.designdemo.inter;

import com.example.designdemo.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:25
 * @Description: 替换掉PayHandler.bankpay
 */

public class BankPayStrategy implements PayStrategy{


    @Override
    public Boolean pay(PayBody payBody) {
        //支付细节省略
        return true;
    }
}

创建WxPayStrategy

代码如下(示例):

package com.example.designdemo.inter;

import com.example.designdemo.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:25
 * @Description: 替换掉PayHandler.wxpay
 */

public class WxPayStrategy implements PayStrategy{


    @Override
    public Boolean pay(PayBody payBody) {
        //支付细节省略
        return true;
    }
}

创建ZfbPayStrategy

代码如下(示例):

package com.example.designdemo.inter;

import com.example.designdemo.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:25
 * @Description: 替换掉PayHandler.zfbpay
 */

public class ZfbPayStrategy implements PayStrategy{


    @Override
    public Boolean pay(PayBody payBody) {
        //支付细节省略
        return true;
    }
}

引入策略模式总结

弊端:

  • if else过多,不够优雅
  • 策略类数量增多,每个策略都是一个类,复用的可能性比较小,类数量增加了
  • 所以的策略类都需要对外暴露,调用方需要知道有哪些策略才可以决定使用哪个策略,封装性得不到保证。
  • 只要引入一个新的支付方式,就要创建一个XXXPayStrategy的策略类实现PayStrategy接口,PayServiceImpl.pay的代码还是需要改动,对业务层的代码进行了修改,任何的代码改动都有可能导致之前的业务逻辑产生问题,比如代码合并覆盖,不小心多加了个字母等等,所以我们希望对业务层的代码能不做改动就尽量别去动业务层的代码
  • 接口不好迁移,假设后面架构师搭好了一套新的框架,需要把支付相关的接口迁移过去,这个时候就得把代码一块一块的迁移,调用逻辑全得看一遍,不能整个包复制粘贴过去,然后微调一下就实现接口迁移,比较费时。
    优点:
  • 策略可以自由切换,只要实现了抽象策略,就可以自由的切换选择策略
  • 扩展性提升,在系统中添加一个策略,只需要添加一个策略类,实现抽象的策略接口就可以了,其他不作修改

引入工厂模式

创建pay目录

创建PayContext

代码如下(示例):

package com.example.designdemo.pay.context;

import com.example.designdemo.pay.pojo.PayBody;
import com.example.designdemo.pay.strategy.PayStrategy;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:30
 * @Description: 起到承上启下的作用
 */

public class PayContext {

    private PayStrategy payStrategy;

    public PayContext(PayStrategy payStrategy){
        this.payStrategy = payStrategy;
    }

    public Boolean execute(PayBody payBody){
        return this.payStrategy.pay(payBody);
    }

}

创建StrategyFactory

代码如下(示例):

package com.example.designdemo.pay.factory;

import com.example.designdemo.pay.strategy.PayStrategy;
import com.example.designdemo.pay.strategyEnum.StrategyEnum;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:53
 * @Description: 策略工厂 工厂类依靠策略枚举返回策略类 后面都不需要修改了,因为它是一个无状态的
 */

public class StrategyFactory {

    public static PayStrategy getPayStrategy(StrategyEnum strategyEnum){
        PayStrategy payStrategy = null;
        try {
            payStrategy = (PayStrategy)Class.forName(strategyEnum.getValue()).newInstance();
        } catch (Exception e) {
            //异常信息打印
        }
        return payStrategy;
    }

}

创建PayBody

代码如下(示例):

package com.example.designdemo.pay.pojo;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:29
 * @Description: 属性的类型这里都是简写,实战项目肯定不会写这么粗糙,这里主要是写设计模式相关,细节就不抠了。
 */

public class PayBody {
    //账号
    private String account;
    //支付类型
    private int type;
    //产品信息
    private String product;
    //金额
    private int amcount;

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public String getProduct() {
        return product;
    }

    public void setProduct(String product) {
        this.product = product;
    }

    public int getAmcount() {
        return amcount;
    }

    public void setAmcount(int amcount) {
        this.amcount = amcount;
    }
}

创建PayStrategy

代码如下(示例):

package com.example.designdemo.pay.strategy;


import com.example.designdemo.pay.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:23
 * @Description: 引入策略模式
 */

public interface PayStrategy {

    //未来顶PayHandler里面的三个
    Boolean pay(PayBody payBody);

}

创建BankPayStrategy

代码如下(示例):

package com.example.designdemo.pay.strategy;

import com.example.designdemo.pay.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:25
 * @Description: 替换掉PayHandler.bankpay
 */

public class BankPayStrategy implements PayStrategy {


    @Override
    public Boolean pay(PayBody payBody) {
        //支付细节省略
        return true;
    }
}

创建WxPayStrategy

代码如下(示例):

package com.example.designdemo.pay.strategy;

import com.example.designdemo.pay.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:25
 * @Description: 替换掉PayHandler.wxpay
 */

public class WxPayStrategy implements PayStrategy {


    @Override
    public Boolean pay(PayBody payBody) {
        //支付细节省略
        return true;
    }
}

创建ZfbPayStrategy

代码如下(示例):

package com.example.designdemo.pay.strategy;

import com.example.designdemo.pay.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:25
 * @Description: 替换掉PayHandler.zfbpay
 */

public class ZfbPayStrategy implements PayStrategy {


    @Override
    public Boolean pay(PayBody payBody) {
        //支付细节省略
        return true;
    }
}

创建StrategyEnum

代码如下(示例):

package com.example.designdemo.pay.strategyEnum;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:56
 * @Description: 准备使用反射
 */

public enum StrategyEnum {

    ZfbPayStrategy("com.example.designdemo.pay.strategy.ZfbPayStrategy"),
    WxPayStrategy("com.example.designdemo.pay.strategy.WxPayStrategy"),
    BankPayStrategy("com.example.designdemo.pay.strategy.BankPayStrategy");

    String value = "";

    StrategyEnum(String value){
        this.value = value;
    }

    public String getValue(){
        return this.value;
    }
}

改造PayServiceImpl

代码如下(示例):

package com.example.designdemo.service.impl;

//import com.example.designdemo.context.PayContext;
//import com.example.designdemo.handler.PayHandler;
//import com.example.designdemo.inter.BankPayStrategy;
//import com.example.designdemo.inter.WxPayStrategy;
//import com.example.designdemo.inter.ZfbPayStrategy;
//import com.example.designdemo.pojo.PayBody;
import com.example.designdemo.pay.context.PayContext;
import com.example.designdemo.pay.factory.StrategyFactory;
import com.example.designdemo.pay.strategyEnum.StrategyEnum;

import com.example.designdemo.pay.pojo.PayBody;
import com.example.designdemo.service.PayService;
import org.springframework.stereotype.Service;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:29
 * @Description:
 */
@Service
public class PayServiceImpl implements PayService {


    @Override
    public Boolean pay(PayBody payBody) {
/*        //传统模式开发支付逻辑
        boolean flag = false;
        int type = payBody.getType();
        if (type == 0) {
            //支付宝支付逻辑
            flag = PayHandler.zfbpay(payBody);
        }else if(type == 1){
            //微信支付逻辑
            flag = PayHandler.wxpay(payBody);
        }else if(type == 2){
            //银行卡支付逻辑
            flag = PayHandler.bankbpay(payBody);
        }else {
            throw new UnsupportedOperationException("unsupport type,please choose o,1,2 ");
        }

        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;*/

/*        //引入策略模式开发支付逻辑
        boolean flag = false;
        int type = payBody.getType();
        if (type == 0) {
            //支付宝支付逻辑
            flag = new PayContext(new ZfbPayStrategy()).execute(payBody);
        }else if(type == 1){
            //微信支付逻辑
            flag = new PayContext(new WxPayStrategy()).execute(payBody);
        }else if(type == 2){
            //银行卡支付逻辑
            flag = new PayContext(new BankPayStrategy()).execute(payBody);
        }else {
            throw new UnsupportedOperationException("unsupport type,please choose o,1,2 ");
        }

        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;*/

        //引入工厂模式开发支付逻辑
        boolean flag = false;
        int type = payBody.getType();
        if (type == 0) {
            //支付宝支付逻辑
            flag = new PayContext(StrategyFactory.getPayStrategy(StrategyEnum.ZfbPayStrategy)).execute(payBody);
        }else if(type == 1){
            //微信支付逻辑
            flag = new PayContext(StrategyFactory.getPayStrategy(StrategyEnum.WxPayStrategy)).execute(payBody);
        }else if(type == 2){
            //银行卡支付逻辑
            flag = new PayContext(StrategyFactory.getPayStrategy(StrategyEnum.BankPayStrategy)).execute(payBody);
        }else {
            throw new UnsupportedOperationException("unsupport type,please choose o,1,2 ");
        }

        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;
    }
}


改造PayService

代码如下(示例):

package com.example.designdemo.service;

//import com.example.designdemo.pojo.PayBody;

import com.example.designdemo.pay.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:28
 * @Description:
 */

public interface PayService {


    Boolean pay(PayBody payBody);
}

改造PayController

代码如下(示例):

package com.example.designdemo.controller;

//import com.example.designdemo.pojo.PayBody;
import com.example.designdemo.pay.pojo.PayBody;
import com.example.designdemo.service.PayService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:26
 * @Description:
 */
@RestController
@RequestMapping("/pay")
public class PayController {

    @Autowired
    private PayService payService;

    @PostMapping("/dopay")
    public Boolean dopay(@RequestBody PayBody payBody){
        return payService.pay(payBody);
    }

}

引入策略模式 + 工厂模式总结

缺点:

  • 有点金玉其内败絮其外的意思,业务层调用还是那么烂
    优点:
  • 内部封装的特别好,全部封装到pay目录下,没有依赖外部,可以直接打包
  • 方便迁移接口,扩展性好,所有逻辑都封装在pay目录下面,可以直接整个pay目录复制到其他下面实现迁移

引入门面模式

创建StrategyFacade

代码如下(示例):

package com.example.designdemo.pay.facade;

import com.example.designdemo.pay.context.PayContext;
import com.example.designdemo.pay.strategy.PayStrategy;
import com.example.designdemo.pay.factory.StrategyFactory;
import com.example.designdemo.pay.pojo.PayBody;
import com.example.designdemo.pay.strategyEnum.StrategyEnum;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 11:27
 * @Description: 门面模式,最终只暴露门面即可,门面就是我们的超级封装
 */

public class StrategyFacade {

    public static Boolean pay(PayBody payBody){
        //获取策略枚举
        StrategyEnum strategyEnum = getStrategyEnum(payBody.getType());
        //获取策略对象
        PayStrategy payStrategy = StrategyFactory.getPayStrategy(strategyEnum);
        //生成策略上下文
        PayContext payContext = new PayContext(payStrategy);
        //进行付款
        Boolean execute = payContext.execute(payBody);
        return execute;
    }

    private static StrategyEnum getStrategyEnum(int type) {
        switch (type){
            case 0:
                return StrategyEnum.ZfbPayStrategy;
            case 1:
                return StrategyEnum.WxPayStrategy;
            case 2:
                return StrategyEnum.BankPayStrategy;
            default:
                return null;
        }
    }

}

改造PayServiceImpl

代码如下(示例):

package com.example.designdemo.service.impl;

//import com.example.designdemo.context.PayContext;
//import com.example.designdemo.handler.PayHandler;
//import com.example.designdemo.inter.BankPayStrategy;
//import com.example.designdemo.inter.WxPayStrategy;
//import com.example.designdemo.inter.ZfbPayStrategy;
//import com.example.designdemo.pojo.PayBody;
import com.example.designdemo.pay.context.PayContext;
import com.example.designdemo.pay.facade.StrategyFacade;
import com.example.designdemo.pay.factory.StrategyFactory;
import com.example.designdemo.pay.strategyEnum.StrategyEnum;

import com.example.designdemo.pay.pojo.PayBody;
import com.example.designdemo.service.PayService;
import org.springframework.stereotype.Service;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:29
 * @Description:
 */
@Service
public class PayServiceImpl implements PayService {


    @Override
    public Boolean pay(PayBody payBody) {
/*        //传统模式开发支付逻辑
        boolean flag = false;
        int type = payBody.getType();
        if (type == 0) {
            //支付宝支付逻辑
            flag = PayHandler.zfbpay(payBody);
        }else if(type == 1){
            //微信支付逻辑
            flag = PayHandler.wxpay(payBody);
        }else if(type == 2){
            //银行卡支付逻辑
            flag = PayHandler.bankbpay(payBody);
        }else {
            throw new UnsupportedOperationException("unsupport type,please choose o,1,2 ");
        }

        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;*/

/*        //引入策略模式开发支付逻辑
        boolean flag = false;
        int type = payBody.getType();
        if (type == 0) {
            //支付宝支付逻辑
            flag = new PayContext(new ZfbPayStrategy()).execute(payBody);
        }else if(type == 1){
            //微信支付逻辑
            flag = new PayContext(new WxPayStrategy()).execute(payBody);
        }else if(type == 2){
            //银行卡支付逻辑
            flag = new PayContext(new BankPayStrategy()).execute(payBody);
        }else {
            throw new UnsupportedOperationException("unsupport type,please choose o,1,2 ");
        }

        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;*/

/*        //引入工厂模式开发支付逻辑
        boolean flag = false;
        int type = payBody.getType();
        if (type == 0) {
            //支付宝支付逻辑
            flag = new PayContext(StrategyFactory.getPayStrategy(StrategyEnum.ZfbPayStrategy)).execute(payBody);
        }else if(type == 1){
            //微信支付逻辑
            flag = new PayContext(StrategyFactory.getPayStrategy(StrategyEnum.WxPayStrategy)).execute(payBody);
        }else if(type == 2){
            //银行卡支付逻辑
            flag = new PayContext(StrategyFactory.getPayStrategy(StrategyEnum.BankPayStrategy)).execute(payBody);
        }else {
            throw new UnsupportedOperationException("unsupport type,please choose o,1,2 ");
        }

        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;*/

        //引入门面模式开发支付逻辑
        Boolean flag = StrategyFacade.pay(payBody);
        if (flag) {
            //支付成功走后续逻辑
        }
        return flag;
    }
}

策略模式 + 工厂模式 + 门面模式总结

优点:

  • 将来我们删除或者增加或者修改任何关于付款的模块,无需改动service。
  • 不会对调用层产生任何代码的改动。
  • 调用层使用我们的pay 模块,无需关心实现的逻辑,只需要将入参传给我们的pay模块即可。
  • 避免使用多重条件判断,扩展性,封装性,灵活性,安全性良好,简洁,易维护,易迁移
    缺点:
  • 策略类变多
  • 需要修改门面角色代码
  • StrategyFactory.getPayStrategy每次调用都需要进行一次反射,需要优化调整。

引入单例模式

对StrategyFactory进行调整

代码如下(示例):

package com.example.designdemo.pay.factory;

import com.example.designdemo.pay.strategy.PayStrategy;
import com.example.designdemo.pay.strategyEnum.StrategyEnum;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:53
 * @Description: 策略工厂 工厂类依靠策略枚举返回策略类 后面都不需要修改了,因为它是一个无状态的 使用饿汉单例模式创建
 */

public class StrategyFactory {

    private static final Map<String, PayStrategy> strategyMaps = new ConcurrentHashMap();

    public static PayStrategy getPayStrategy(StrategyEnum strategyEnum){
        PayStrategy payStrategy = strategyMaps.get(strategyEnum.getValue());
        try {
            payStrategy = (PayStrategy) Class.forName(strategyEnum.getValue()).newInstance();
            strategyMaps.put(strategyEnum.getValue(), payStrategy);
        } catch (Exception e) {
            //异常信息打印
        }
        return payStrategy;
    }

}

这里没有使用传统的单例模式,我需要在StrategyFactory里面获取PayStrategy所有的类型,所以这里面使用了一个map进行存储,同时为了保证线程安全使用ConcurrentHashMap保证线程安全。

传统的单例模式:
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
单例模式的优点:

  • 内存中只有一个实例,减少内存开支,避免对象频繁创建、销毁
  • 一个对象的产生需要比较多的资源,比如读取配置,依赖其他对象等等,使用单例模式只生成一个实例,可以在应用启动的时候直接产生一个单例对象,然后用永久驻留内存的方式来解决性能问题,减少性能开销。
  • 避免对资源多重占用,比如一个写文件动作,由于只有一个实例存在内存中,避免对同一个资源文件同时写操作。
  • 可以设置系统全局访问点,优化共享资源访问,比如可以设计一个单例类,负责所有数据表的映射。

引入单例模式,解决了策略模式 + 工厂模式 + 门面模式中StrategyFactory.getPayStrategy每次调用都需要进行一次反射创建对象。

最后我们的项目结构如下(示例):(仅展开的类有用到)

在这里插入图片描述

工厂模式与策略模式的较量 工厂模式是一种创建型设计模式,它定义了一个用于创建对象的接口,让子类决定实例化哪一个类。换句话说,工厂模式将对象的创建过程抽象化,使得客户端不必直接依赖于具体的类。这种设计极大地降低了系统的耦合性,增强了代码的灵活性和可维护性。需要创建的对象具有复杂的创建过程,涉及多个步骤或组件的组合。系统需要根据不同的条件或配置,创建不同类型的对象。客户端不需要知道具体类的内部实现,只关心如何获取一个合适的对象。工厂模式的经典应用包括Java中的类的获取实例方法、数据库连接池的管理等。 阅读详情

相关推荐

《C++设计模式》策略模式

介绍了C++模式的策略模式

zwh1298454060的博客 1764

Java软件设计模式精讲

内容简介: 设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。 本课程内容定位学习设计原则,学习设计模式的基础。在实际开发过程中,并不是一定要求所有代码都遵循设计原则,我们要考虑人力、时间、成本、质量,不是刻意追求完美,要在适当的场景遵循设计原则,体现的是一种平衡取舍,帮助我们设计出更加优雅的代码结构。本章将详细介绍开闭原则(OCP)、依赖倒置原则(DIP)、单一职责原则(SRP)、接口隔离原则(ISP)、迪米特法则(LoD)、里氏替换原则(LSP)、合成复用原则(CARP)的具体内容。 为什么需要学习这门课程? 你在日常的开发中,会不会也遇到过同样的问题。系统出现问题,不知道问题究竟出在什么位置;当遇到产品需求,总是对代码缝缝补补,不能很快的去解决。而且平时工作中,总喜欢把代码堆在一起,出现问题时,不知道如何下手,工作效率很低,而且自己的能力也得不到提升。而这些都源于一个问题,那就是软件设计没做好。这门课能帮助你很好的认识设计模式,让你的能力得到提升。课程大纲: 为了让大家快速系统了解设计模式知识全貌,我为您总结了思维导图,帮您梳理学习重点,建议收藏!

java23种设计模式-策略模式

策略模式是一种行为型设计模式,定义一系列算法,将每个算法封装起来,并使它们可以互相替换。该模式让算法的变化独立于使用它的客户端。

专注后端开发 1370

支付系统设计

支付系统的设计是一个复杂的过程,需要考虑许多因素,如易用性、安全性、性能、可扩展性等。通过理解支付系统的基本架构和各个组成部分的设计考虑,我们可以设计出一个既安全又高效的支付系统。

果酱 の 博客 970

支付系统中的设计模式01:初始需求

现在,不管是买菜、买票、交电费还是电商网购,都已经离不开支付系统了。而且在目前的互联网应用中,不管是开发什么类型的系统,也几乎都会对接(第三方)支付系统实现订单付款。所以,了解支付系统是如何设计和运行的就显得很有必要了。而且,支付系统如果做得很耐撕,那么再去做其他的业务系统的话,技术层面能遇到的挑战就比较少了。

分享专业、有用、有趣的技术、产品、运营和管理知识。 799

一文了解ECU软件刷写的2种方法:Bootloader刷写和调试器刷写

分为刷写前、刷写中和刷写后三个阶段,如下示意:下面我们来详细了解一下Bootloader收到外部请求后开始刷写的三个阶段1)刷写前进行刷写的准备,一是确保刷写阶段总线通信的稳定性,二是避免刷写阶段出现非预期的故障,三是读取车辆数据供刷写前的一些检查等,如下所示:首先进行会话控制,通过功能寻址方式进入扩展会话模式,为后面的信息访问及其他指令做准备;然后检查刷写的前提条件,通过物理寻址方式发送历程控制请求。比如车确实处于静止状态,供电电压稳定等条件下才允许刷写;

menghuyouyou的博客 5792

Java设计模式-策略模式(支付业务的优化)

Java设计模式-策略模式

weixin_46421224的博客 1890

手把手教你用Microsoft AEC Challenge数据集训练自己的回声消除模型(附完整代码)

本文详细介绍了如何使用Microsoft AEC Challenge数据集训练专业的回声消除模型,包括环境准备、数据清洗、模型架构设计、训练流程和实际部署注意事项。通过完整的代码示例和实战指南,帮助开发者快速掌握AEC技术,提升语音通信系统的回声消除效果。

weixin_27697385的博客 461

使用设计模式解决支付问题

模拟微信、支付宝等多个渠道在不同支付模式下APP、Native、JSAPI、H5等组合,体现出桥接模式在这类场景中的合理运用。简化了冗余的代码开发与判断,给后续需求迭代更新增加了很好的扩展性,且满足单一原则和开闭原则,让代码更清晰易于维护和拓展。......

学习学习学习 2761

【硬件开源实战】STM32G070RBT6开发板从设计到避坑全解析

本文全面解析了STM32G070RBT6开发板从硬件设计到避坑的实战经验。详细介绍了电源设计、时钟电路、PCB布局等关键环节,分享了成本控制、焊接测试、软件开发和外设驱动的实用技巧,帮助开发者高效完成项目开发。

weixin_26897585的博客 246

Linux【实战】—— LAMP环境搭建 & 部署网站

由LinuxApacheMySQLPHP组成的一个web网络平台。

2201_75935630的博客 4981

人人都会设计模式:策略模式

该图片由daschorsch在Pixabay上发布 你好,我是看山。 本文收录在《一个架构师的职业素养》专栏,日拱一卒,功不唐捐。 定义 策略模式,英文全称是 Strategy Design Pattern。在 GoF 的《设计模式》一书中,它是这样定义的: Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary in..

沉潜飞动 6578

chromium通信系统-ipcz系统(二)-ipcz系统代码实现-同Node通信

在chromium通信系统-mojo系统(一)-ipcz系统基本概念一文中我们介绍了ipcz的基本概念。 本章我们来通过代码分析它的实现。 handle系统 为了不对上层api暴露太多细节,实现解耦,也方便于传输,ipcz系统使用handle表示一个对象,handle类似于文件描述符,用IpczHandle类型表示ipcz系统内的一个对象。一个可以用IpczHandle 句柄表示的对象必须是APIObject子类。APIObject数据结构如下 class APIObject : public RefCou

woai110120130的专栏 1775

一文整合工厂模式、模板模式、策略模式

其实这几个设计模式我们在平常开发中非常容易使用,也可能你一直在使用就是没有留意而已。

weixin_43741322的博客 3796

PCL点云八叉树体素中心下采样,体素包含点索引提取

基于PCL octree实现点云八叉树计算,支持提取体素中心点进行点云下采样;根据任一点坐标,可以得到其在八叉树中的位置,输出对应体素内其余点的坐标或者索引

qq_48694523的博客 463

【AI面试】 Python 的装饰器

Python装饰器是一种高阶函数,用于在不修改原函数代码的情况下增强其功能。它通过@语法糖接收目标函数作为参数,并返回一个包含额外逻辑(如日志、缓存、权限验证等)的新函数。装饰器的核心价值在于代码复用和解耦,符合开闭原则,典型应用包括性能分析、权限控制等场景。例如,@timer_decorator可自动为函数添加耗时统计功能。本质上,@decorator等价于func = decorator(func),实际调用的是装饰器返回的包装函数。进阶技巧包括使用@functools.wraps保留原函数元信息。装饰

钱多多先森 187

深入解析工厂模式与策略模式的结合:从外卖平台折扣谈起

其实在很多的开发设计中,将工厂模式和策略模式的综合使用的案例是很多的,而且解决的实际问题也一样很多,本次对基本的简单工厂模式和策略模式做简单介绍,重点放在两者结合后的具体应用上做分析和讲解。

曾经“等你生日那天”都遥远得像未来,如今却可欢愉的挥手说“下个十年见” 7万+

一文读懂 SAP ERP / SAP S/4HANA 里的 Price List:概念、配置、定价流程与可运行 ABAP 示例

SAP ERP/S4HANA中的Price List解析 本文系统阐述了SAP定价体系中Price List的核心概念和实现机制。Price List并非独立的价目表,而是通过条件技术(条件类型、访问序列、条件记录)与Price List Type(PLTYP)共同作用的定价维度。文章详细说明了: Price List本质上是客户主数据中的PLTYP字段,作为定价查找键使用 定价流程中条件访问序列如何利用PLTYP查找特定价格 S4HANA与ECC版本在价格维护入口的差异 实际业务中如何通过不同PLTYP实

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 663

枚举+工厂+策略模式---多方式支付

枚举+工厂+策略模式

WYH1233211234567的博客 3212

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

设计模式之策略模式

java程序的设计原则 6大原则: 单一职责:一个类和方法只做一件事。 开闭:对修改关闭,对扩展开发。 里氏替换:子类可扩展新方法,但不可修改父类已有方法(父类已提供了具体实现的方法)。 依赖倒置:依赖于抽象,而非具体实现,即面向接口编程(如方法参数,类属性使用接口声明,这样可接收任何子类)。 接口隔离:使用多个隔离的接口定义抽象,降低耦合。 最少知道/迪米特:降低类之间的依赖,聚合,组合等。 1:策略设计模式 策略设计模式一般使用的场景是,多种可互相替代的同类行为,在具体运行过程中根据不同情况,选择其中

wang0907的博客 8546

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

工厂模式和策略模式区别

策略模式和‌工厂模式的主要区别在于它们的目的、结构、适用场景以及客户端与模式的关系。‌策略模式‌是一种行为型设计模式,旨在定义一系列算法,并将每个算法封装起来,使它们可以互换。工厂模式‌是一种创建型设计模式,提供了一种创建对象的接口,而不是直接实例化对象。

A_aspectJ的博客 2039

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

项目中使用到的设计模式有哪些?都应用在什么场景?策略模式的缺点是什么?

本文系统梳理了23种设计模式,分为创建型、结构型和行为型三大类。重点解析了7种高频面试设计模式(策略、单例、工厂、责任链、代理、模板方法、观察者),包含典型应用场景、生活类比和代码示例。特别分析了策略模式的4大缺点及优化方案,建议采用工厂模式+注册机制来避免策略膨胀问题。推荐面试时优先掌握策略等7种核心模式,强调"项目实践+结构解析+代码演示+生活类比"的叙述逻辑。最后提供了设计模式分类脑图,帮助建立结构化记忆体系。全文以实用为导向,聚焦面试高频考点和工程实践中的典型解决方案。

chenxuefeng_accp的专栏 2486

设计模式-工厂模式和策略模式的区别

工厂模式关注的是创建过程,而策略模式关注的是行为或算法的变化。它们可以在不同的设计中单独使用,也可以结合使用以实现更复杂的功能。工厂模式:通过创建工厂类,将对象实例化的责任转移到工厂。当我们不知道需要实例化哪个类时,会使用工厂模式。它隐藏了对象实例化的复杂性。策略模式:允许在执行时选择不同算法或操作。当我们需要动态地改变对象的行为或者算法时,会使用策略模式。这使得算法可以独立于使用它的客户端而变化。

技术日常 1701

设计模式结合场景(1)——支付场景(策略+工厂+模板)

面试官:你们项目的支付场景用了哪些设计模式,为什么要这么做?一、背景 二、方案三、UML类图 四、代码实现 4.1 Payment——支付接口 4.2 Alipay、WeChatPay——支付具体策略 4.3 PaymentFactory——支付工厂4.4 PaymentTemplate——抽象模板4.5 WeChat、AlipayTemplate——具体模板4.6 test 五、总结

让~学习~成为一种习惯(橡 皮 人の技术博客) 2671

从工厂模式到策略模式:设计模式的进阶使用技巧

工厂模式(Factory Pattern)是一种创建型设计模式,旨在通过定义一个创建对象的接口,让子类决定实例化哪一个类。这样,工厂方法将对象的创建过程从客户端代码中抽离出来,从而提高系统的灵活性和可维护性。策略模式(Strategy Pattern)是一种行为型设计模式,它定义了一系列算法,并将每种算法封装到独立的策略类中,使得这些算法可以互相替换。这种模式让算法的变化独立于使用算法的客户,避免了代码中出现大量的条件语句,提升了代码的灵活性和可维护性。在实际开发中,工厂模式和策略模式是非常常用的设计模式。

2401_85639015的博客 1581

策略模式与工厂模式的黄金组合:从设计到实战

策略模式和工厂模式是软件开发中最常用的两种设计模式,当它们结合使用时,能产生1+1>2的效果。本文将通过实际案例,阐述这两种模式的协同应用,让代码架构更优雅、可维护性更强。

llwszx的博客 2125
上一篇: 【java_wxid项目】【第十二章】【Swagger集成】
下一篇: 【设计模式】【第二章】【业务投放场景】【责任链模式】
Java程序员廖志伟
Java程序员廖志伟 优质创作者: Java技术领域 优质创作者: Java技术领域 领域专家: 后端开发技术领域 领域专家: 后端开发技术领域
博客等级 码龄8年 2万+粉丝 1902原创
评论 6
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java程序员廖志伟

赏我包辣条呗

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值