策略模式-项目中的使用

最新推荐文章于 2024-05-08 10:58:27 发布
最新推荐文章于 2024-05-08 10:58:27 发布
阅读量710 收藏 2
点赞数
分类专栏： 设计模式 文章标签： 设计模式 策略模式 项目中使用策略模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_lihongmin/article/details/102871439
版权

设计模式-总览icon-default.png?t=LBL2https://mp.csdn.net/mp_blog/creation/editor/122202507目录

1、背景介绍

2、使用策略加工厂的实现方式

3、使用策略加枚举的调用方式

在项目进行重构的时候，会发现有很多的判断，或者枚举类型的处理。则策略模式应该是比较好的方式，基于上一篇博客所述， 策略模式使其可以理解为Java的多态实现（父类引用指向不同实现的子类对象），就Spring的DispatcherServlet的九大件的默认配置，使用的则相应于是一个事先定义好规则的Map，根据不同的key或者不同的value。 但其实，在项目中进行使用的时候，发现单一的使用策略模式并不能解决问题，或者说很鸡肋。除非情况比较复杂时，策略模式和 工厂模式呀，代理呀等混合进行使用。下面是一次项目代码的重构。刚开始想的很简单，但是后面发现自己却写不好，所以触动很大。觉得还记录一下。

1、背景介绍

订单系统中根据不同类型（枚举），会调用支付系统提供的不同微服务接口，但是都会返回相同的结果对象。但是呢并不像简单的Map一样一个key对应一个value，即一个或者多个枚举会调用一个Feign方法。

支付类型枚举类如下：

public enum PaymentType {
   
    PAY_ON_DELIVERY(1, "货到付款"),

    ALIPAY(21, "支付宝"),

    WECHAT(22, "微信"),

    OFFLINE(0, "线下退款"),

    POS(23,"POS机"),

    RECHARGE_PAY(24,"预存挂账"),

    BANK_TRANSFER(25,"银行转账"),

    CREDIT(26,"赊账结算"),

    CASH(40,"现金"),

    SYNTHESIZE(41,"混合支付"),

    CITIC(42, "全付通"),

    CREDIT_PAY(43, "授信挂账"),

    ONLINE_PAY(44, "在线支付"),

    PLATFORM_COLLECTION(45, "平台代收"),

    OTHER_PAY(46, "其他支付");
}

调用如下：

// 原来的调用方式
PaymentRespVo paymentRespVo = storePay(reqVo.getStoreId(), reqVo.getAuthCode(), reqVo.getIp(), reqVo.getShopOrderPaymentVos(), order, reqVo.getAdminVoInDto());

// 使用策略加工厂的调用方式
PaymentRespVo paymentRespVo = PaymentStrategyFactory.create(order.getPaymentType())
.getPaymentRespVO(order, reqVo);

// 使用策略加枚举的调用方式
PaymentRespVo paymentRespVo = PaymentStrategy.doGet(order, reqVo, paymentFeignClient);

原来的写法如下：

private PaymentRespVo storePay(Long storeId, String authCode, String ip, List<ShopOrderPaymentVo> vos, Order order, AdminVoInDto adminVoInDto) {
        SystemAsserts.isTrue(order.isPayableInStore(), "该订单无法继续支付:订单状态不合法");
        logger.info("门店支付:订单id:{}, 订单编码:{}, 支付方式:{}", order.getId(), order.getOrderCode(), order.getPaymentType());
        PaymentRespVo paymentRespVo;
        if (Objects.equals(order.getPaymentType(), PaymentType.CITIC)) {
            PayAdminVoInDto payAdminVoInDto = PayAdminVoInDtoBuilder.createBuilder(adminVoInDto).build();
            CiticPayRequest request = CiticPayRequest.builder()
                    .orderVo(PaymentOrderVoBuilder.createBuilder(order).setShopOrderPaymentVos(Lists.transform(vos, new ShopOrderPayment2PShopOrderPaymentVo())).builder()).authCode(authCode).ip(ip).storeId(storeId)
                    .adminVoInDto(payAdminVoInDto).build();
            logger.info("门店发起全付通支付:{}", JSON.toJSONString(request));
            paymentRespVo = paymentFeignClient.citicMicroPay(request);
        } else if (Objects.equals(order.getPaymentType(), PaymentType.CASH)
                || Objects.equals(order.getPaymentType(), PaymentType.RECHARGE_PAY)
                || Objects.equals(order.getPaymentType(), PaymentType.POS)
                || Objects.equals(order.getPaymentType(), PaymentType.BANK_TRANSFER)
                || Objects.equals(order.getPaymentType(), PaymentType.ALIPAY)
                || Objects.equals(order.getPaymentType(), PaymentType.WECHAT)
                || Objects.equals(order.getPaymentType(), PaymentType.CREDIT_PAY)
                || Objects.equals(order.getPaymentType(), PaymentType.OTHER_PAY)) {
            // 现金、挂账支付、POS、银行转账、支付宝、微信、授信挂账
            BackendPayReqVo backendPayReqVo = BackendPayReqVo.builder()
                    .orderId(order.getId())
                    .orderVo(PaymentOrderVoBuilder.createBuilder(order).builder())
                    .shopOrderPaymentVos(Lists.transform(vos, new ShopOrderPayment2PShopOrderPaymentVo())).build();
            logger.info("门店发起后台支付:{}", JSON.toJSONString(backendPayReqVo));
            paymentRespVo = paymentFeignClient.backendPay(backendPayReqVo);
        } else if (Objects.equals(order.getPaymentType(), PaymentType.SYNTHESIZE)) {
            PayAdminVoInDto payAdminVoInDto = PayAdminVoInDtoBuilder.createBuilder(adminVoInDto).build();
            SynthesizePayReqVo reqVo = new SynthesizePayReqVo();
            reqVo.setStoreId(storeId);
            reqVo.setAuthCode(authCode);
            reqVo.setIp(ip);
            reqVo.setAdminVoInDto(payAdminVoInDto);
            reqVo.setOrderVo(PaymentOrderVoBuilder.createBuilder(order).builder());
            reqVo.setOrderId(order.getId());
            reqVo.setShopOrderPaymentVos(Lists.transform(vos, new ShopOrderPayment2PShopOrderPaymentVo()));
            logger.info("门店发起混合支付:{}", JSON.toJSONString(reqVo));
            paymentRespVo = paymentFeignClient.synthesizePay(reqVo);
        } else {
            throw new DepotNextDoorException(500, "无效的支付方式");
        }
        return paymentRespVo;
    }

按照原来使用模仿Spring DispatcherServlet 中策略模式的方式，在项目里写过使用一个 HashMap在静态代码块中初始化key、value值。 但是现在发现这并不是单纯的一个key对应一个value的情况。 于是想到了Spring（apache common也有）中有一个MultiValueMap类型的Map（一个key对应多个值），发现也不是这种情况，但是还好apache common还有一个 MultiKeyMap类型的Map（多个key对应同一个value）。

2、使用策略加工厂的实现方式

1）、抽象一个支付方式的调用接口：

public interface PaymentGet {

    PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo);
}

2）、抽象实现，（注入其余子类都要用到的 远程调用feign的bean）

@Service
@Builder
@Data
public abstract class AbstractPaymentGet implements PaymentGet {

    @Autowired
    private PaymentFeignClient paymentFeignClient;

    public AbstractPaymentGet() {
    }

    protected PaymentFeignClient getPaymentFeignClient() {
        return paymentFeignClient;
    }

    @Override
    public abstract PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo);
}

3）、不同类型的实现

@Slf4j
public class BackendPay extends AbstractPaymentGet {

    @Override
    public PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo) {
        BackendPayReqVo backendPayReqVo = BackendPayReqVo.builder()
                .orderId(order.getId())
                .orderVo(PaymentOrderVoBuilder.createBuilder(order).builder())
                .shopOrderPaymentVos(Lists.transform(reqVo.getShopOrderPaymentVos(), new ShopOrderPayment2PShopOrderPaymentVo())).build();
        log.info("门店发起后台支付:{}", JSON.toJSONString(backendPayReqVo));
        return getPaymentFeignClient().backendPay(backendPayReqVo);
    }
}
@Slf4j
public class CiticMicroPay extends AbstractPaymentGet {

    @Override
    public PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo) {
        PayAdminVoInDto payAdminVoInDto = PayAdminVoInDtoBuilder.createBuilder(reqVo.getAdminVoInDto()).build();
        CiticPayRequest request = CiticPayRequest.builder()
                .orderVo(PaymentOrderVoBuilder.createBuilder(order).setShopOrderPaymentVos(Lists.transform(reqVo.getShopOrderPaymentVos(), new ShopOrderPayment2PShopOrderPaymentVo())).builder())
                .authCode(reqVo.getAuthCode()).ip(reqVo.getIp()).storeId(reqVo.getStoreId())
                .adminVoInDto(payAdminVoInDto).build();
        log.info("门店发起全付通支付:{}", JSON.toJSONString(request));
        return getPaymentFeignClient().citicMicroPay(request);
    }
}
@Slf4j
public class SynthesizePay extends AbstractPaymentGet {

    @Override
    public PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo) {
        PayAdminVoInDto payAdminVoInDto = PayAdminVoInDtoBuilder.createBuilder(reqVo.getAdminVoInDto()).build();
        SynthesizePayReqVo request = new SynthesizePayReqVo();
        request.setStoreId(reqVo.getStoreId());
        request.setAuthCode(reqVo.getAuthCode());
        request.setIp(reqVo.getIp());
        request.setAdminVoInDto(payAdminVoInDto);
        request.setOrderVo(PaymentOrderVoBuilder.createBuilder(order).builder());
        request.setOrderId(order.getId());
        request.setShopOrderPaymentVos(Lists.transform(reqVo.getShopOrderPaymentVos(), new ShopOrderPayment2PShopOrderPaymentVo()));
        log.info("门店发起混合支付:{}", JSON.toJSONString(request));
        return getPaymentFeignClient().synthesizePay(request);
    }
}

4）、最好需要初始化调用的工具地方，即Context（上一篇博客）

public class PaymentStrategyFactory {

    private static final MultiKeyMap<PaymentType, String> strategies = new MultiKeyMap<>();

    static {
        strategies.put(new MultiKey<>(new PaymentType[]{CITIC}),
                "BackendPay");
        strategies.put(new MultiKey<>(new PaymentType[]{CASH,
                        RECHARGE_PAY, POS,
                        BANK_TRANSFER, ALIPAY,
                        WECHAT, CREDIT_PAY, OTHER_PAY}),
                "CiticMicroPay");
        strategies.put(new MultiKey<>(new PaymentType[]{SYNTHESIZE}),
                "SynthesizePay");
    }
    
    public static PaymentGet create(PaymentType paymentType) {

        String impl = strategies.get(paymentType);
        try {
            if (impl == null) {
                throw new DepotNextDoorException(500, "无效的支付方式");
            }
            return (PaymentGet)Class.forName(impl).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

}

5）、调用方式如上写的：

PaymentRespVo paymentRespVo = PaymentStrategyFactory.create(order.getPaymentType())
.getPaymentRespVO(order, reqVo);

思考：第一种实现方式做完之后，发现为了重构一段代码，并且这种后续应该不怎么会进行扩展的。却引入了好多的类，反而变得更复杂了。这应该不是其他人也想看到了，但是这种应该是比较适合每一个实现类都有很多实现方法的时候应该比较好（类似抽象工厂模式）。所以想到了枚举类的抽象方法，果然值用了两个类就解决了，并且也很清晰的结构。并且调用远程feign的bean也不想再注入，反正都要传两个参数了还不如直接传三个，如下：

3、使用策略加枚举的调用方式

1）、配置策略和触发方法

public class PaymentStrategy {

    /**
     *  策略配置
     */
    private static final MultiKeyMap<PaymentType, PaymentStrategyEnum> strategies = new MultiKeyMap<>();

    static {
        strategies.put(new MultiKey<>(new PaymentType[]{CITIC}),
                PaymentStrategyEnum.CITIC_MICRO_PAY);

        strategies.put(new MultiKey<>(new PaymentType[]{CASH,
                        RECHARGE_PAY, POS,
                        BANK_TRANSFER, ALIPAY,
                        WECHAT, CREDIT_PAY, OTHER_PAY}),
                PaymentStrategyEnum.BACKEND_PAY);

        strategies.put(new MultiKey<>(new PaymentType[]{SYNTHESIZE}),
                PaymentStrategyEnum.SYNTHESIZE_PAY);

        strategies.put(new MultiKey<>(null),
                PaymentStrategyEnum.OTHER_PAY);
    }

    /**
     *  获取远程数据
     *
     * @param order 订单
     * @param reqVo 请求
     * @param paymentFeignClient 支付feign
     * @return 支付数据
     */
    public static PaymentRespVo doGet(Order order, ConfirmOrderCreateReqVo reqVo,
        PaymentFeignClient paymentFeignClient) {

        return strategies.get(order.getPaymentType()).getPaymentRespVO(order, reqVo, paymentFeignClient);
    }
}

2）、实现方法（放到枚举内）

@Slf4j
public enum PaymentStrategyEnum {

    BACKEND_PAY {
        @Override
        public PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo, PaymentFeignClient paymentFeignClient) {
            BackendPayReqVo backendPayReqVo = BackendPayReqVo.builder()
                    .orderId(order.getId())
                    .orderVo(PaymentOrderVoBuilder.createBuilder(order).builder())
                    .shopOrderPaymentVos(Lists.transform(reqVo.getShopOrderPaymentVos(), new ShopOrderPayment2PShopOrderPaymentVo())).build();
            log.info("门店发起后台支付:{}", JSON.toJSONString(backendPayReqVo));
            return paymentFeignClient.backendPay(backendPayReqVo);
        }
    },
    CITIC_MICRO_PAY {
        @Override
        public PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo, PaymentFeignClient paymentFeignClient) {
            PayAdminVoInDto payAdminVoInDto = PayAdminVoInDtoBuilder.createBuilder(reqVo.getAdminVoInDto()).build();
            CiticPayRequest request = CiticPayRequest.builder()
                    .orderVo(PaymentOrderVoBuilder.createBuilder(order).setShopOrderPaymentVos(Lists.transform(reqVo.getShopOrderPaymentVos(), new ShopOrderPayment2PShopOrderPaymentVo())).builder())
                    .authCode(reqVo.getAuthCode()).ip(reqVo.getIp()).storeId(reqVo.getStoreId())
                    .adminVoInDto(payAdminVoInDto).build();
            log.info("门店发起全付通支付:{}", JSON.toJSONString(request));
            return paymentFeignClient.citicMicroPay(request);
        }
    },
    SYNTHESIZE_PAY {
        @Override
        public PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo, PaymentFeignClient paymentFeignClient) {
            PayAdminVoInDto payAdminVoInDto = PayAdminVoInDtoBuilder.createBuilder(reqVo.getAdminVoInDto()).build();
            SynthesizePayReqVo request = new SynthesizePayReqVo();
            request.setStoreId(reqVo.getStoreId());
            request.setAuthCode(reqVo.getAuthCode());
            request.setIp(reqVo.getIp());
            request.setAdminVoInDto(payAdminVoInDto);
            request.setOrderVo(PaymentOrderVoBuilder.createBuilder(order).builder());
            request.setOrderId(order.getId());
            request.setShopOrderPaymentVos(Lists.transform(reqVo.getShopOrderPaymentVos(), new ShopOrderPayment2PShopOrderPaymentVo()));
            log.info("门店发起混合支付:{}", JSON.toJSONString(request));
            return paymentFeignClient.synthesizePay(request);
        }
    },
    OTHER_PAY {
        @Override
        public PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo, PaymentFeignClient paymentFeignClient) {
            throw new DepotNextDoorException(500, "无效的支付方式");
        }
    };

    public abstract PaymentRespVo getPaymentRespVO(Order order, ConfirmOrderCreateReqVo reqVo, PaymentFeignClient paymentFeignClient);
}

3）、调用方式

PaymentRespVo paymentRespVo = PaymentStrategy.doGet(order, reqVo, paymentFeignClient);

最好感觉清爽多了，应该是比较好的结果了。设计模式，我还是觉得多看看源码怎么写的，还有自己项目中多去用用就理解了，反正这不就是别人理解总结的经验嘛。欢迎大家有好的方式，多讨论。

it_lihongmin
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
策略模式在实际项目中的应用二
10-10
策略模式在实际项目中的应用二，该测试demo为普通项目，导入build path一下lib目录下的jar包，然后运行测试类即可在控制台看到测试结果
策略模式在实际项目中的应用一
10-10
策略模式在实际项目中的应用一，该项目为普通项目，导入运行测试类即在控制台查看结果。
策略模式+工厂模式结合使用
u013998466的博客
05-12 2582
策略模式与工厂模式结合使用 定义 策略模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。 工厂模式：定义一个用于创建产品的接口，由子类决定生产什么产品。 缺点 策略模式：暴露了策略类，每次使用策略都要new 工厂模式： ...
策略模式介绍、使用（项目中如何使用策略模式）
最新发布
weixin_45500957的博客
05-08 416
策略模式是一种行为型设计模式，它允许在运行时选择算法的行为。这种模式定义了一系列的算法，将每个算法封装起来，并且使它们可以互相替换。策略模式使得算法可以独立于客户端而变化，也让算法的变化不会影响到使用算法的客户端。策略模式通常涉及以下几个角色：环境类持有一个对策略对象的引用，并且可以通过策略对象执行具体的算法。通常是客户端直接使用的对象。策略接口或抽象类，定义了一系列算法族，其中声明了算法的抽象方法。实现了策略接口的具体算法，是策略模式中的各个算法的具体实现。
Springboot参数校验
fall_hat的博客
05-06 184
使用如@NotBlank等注解 @Data public class UserLoginReqVO { @NotBlank(message = "手机号不能为空") private String phone; @NotBlank(message = "密码不能为空") private String password; } 在controller层方法的请...
sql笔记
qq_38853322的博客
04-28 196
当前时间与某个时间相差在某个区间结果取int值 DATEDIFF(CURDATE(),**_time)BETWEEN #{开始区间} AND #{reqVo.FinishOverdueDay} sql在xml文件中遍历集合 List<PerfectNotCreditCloudSellerRespVo> cloudSellerNoCreditFromAccount(@Param(...
Spring 常用注解：
li12244的博客
05-12 333
Spring 常用注解：
关于策略模式在项目中的应用场景及具体实现
qq_51421082的博客
01-29 370
下面说一下具体场景，当你的系统要对接多个系统的时候，想要根据不同的入参来调用不同的实现方法，并且想要支持可以继续集成系统的前提下对源代码的业务逻辑不改变的前提下，可以随意的进行多系统的接入。在刚接触设计模式时，在视频中的理论总会学了就忘，原因就是没有具体的应用场景，导致没有理解到其中的原理。第二步写一个接口，这里的接口是一个通用的对外接口，这里可以定义统一的入参规范和要求。运行结果（（当入参是json.put("datasource","One")））第三步写一个上面接口的实现类，具体的业务逻辑接入。
大话模式源代码-02策略模式
07-22
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，我们经常遇到需要根据不同的条件或...同时，这些案例也可以帮助你更好地将策略模式应用于自己的项目中，提升软件设计的灵活性和可扩展性。
详解SpringBoot结合策略模式实战套路
08-25
在本文中，我们将详细介绍如何使用策略模式在SpringBoot项目中实现业务逻辑处理。 策略模式的定义 策略模式是一种行为设计模式，它允许开发者定义一些策略族，分别封装起来，每一个策略中的算法具有一定的独立性，...
php设计模式－策略模式－例题学习
03-23
在这个文件中，我们可以看到策略模式的动态切换，即在游戏过程中根据需要改变玩家的策略。 策略模式的核心思想是封装不同的行为（策略）到单独的类中，使得这些行为可以在运行时互换。这提供了灵活性，使代码更易于...
策略模式在项目中的使用
qq_32434535的博客
07-04 296
策略模式在项目中的使用
接口幂等性
求道问术
04-24 1162
定义 对接口的n次请求的响应是一致的，响应结果与请求次数无关 考虑重复请求对数据的影响，对请求方的影响，对用户的影响 关键就是考虑数据的唯一性和响应的唯一性 场景 接口重复请求 接口超时重试 消息重复消费 实现/代码逻辑 增加操作 说明： 对数据有唯一性要求，则不允许出现重复数据，n次请求只有首次请求增加成功，后续请求是重复请求 方式： 代码逻辑：增加前先查找，不存在则增加，存在则响应已存在 删除操作 说明： 删除必须加上limit，已知delete tableName将删除整个表的数据 方式： 代码逻辑：
一、策略模式的使用
一个刚入行的新人猿
03-06 948
策略模式的使用
策略模式的多种使用方式
旷野历程
04-14 641
在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。
策略模式的介绍和简单使用
记录学习的博客
01-05 1773
策略模式的简单介绍； springboot里，elasticsearch的builder使用策略模式的小栗子。
【学习笔记】设计模式-策略模式(Strategy)
五条的博客
09-12 108
文章目录0 设计模式1 策略模式2 实现思路2.1 Comparable实现思路2.2 Comparator实现思路3 需要的类3.1 Comparable需要的类3.2 Comparator需要的类4 具体实现4.1 Comparable具体实现4.1.1 定义Comparable接口4.1.2 Comparable接口的实现类4.1.3 测试类4.2 Comparator具体实现4.2.1 比较的实体类4.2.2 Comparator接口4.2.3 Comparator接口实现类4.2.4 Sorter
策略模式详解
wh柒八九的博客
07-02 283
本文来说下策略模式 文章目录概述 概述 定义一系列算法或者行为，将每一个算法或者行为封装起来，并让它们可以相互替换。 今天给大家分享的是策略模式，具体内容大纲如下： 解决：使用 if…else 所带来的复杂和难以维护。 ...
策略模式的使用
人生的尽头是孤独
04-22 824
策略模式
java 策略模式在项目中的具体使用
05-30
策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使得算法可以独立于使用它们的客户端而变化。 在 Java 语言中，策略模式通常由一个抽象策略接口和多个具体策略实现类组成。使用策略模式的具体步骤如下： 1. 定义一个抽象策略接口，该接口定义了一个或多个算法方法。 2. 定义多个具体策略实现类，分别实现抽象策略接口中定义的算法方法。 3. 在客户端中定义一个策略对象，该对象包含一个具体策略实现类的引用。 4. 在需要使用算法时，调用策略对象的算法方法即可，而不需要关心具体算法的实现细节。 在实际项目中，策略模式通常用于实现业务逻辑中的算法选择、排序、过滤等操作，以及一些可替换的行为。例如，一个电商网站需要根据用户购买金额的不同，给予不同的优惠策略，这个优惠策略就可以使用策略模式来实现。同时，策略模式也可以与工厂模式等其他模式一起使用，来实现更加灵活的设计。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值