设计模式实战：工厂模式让你的代码飞起来！

已于 2024-09-13 17:50:31 修改
阅读量1.1k 收藏 10
点赞数 13
分类专栏： JAVA实现设计模式 文章标签： 简单工厂模式 工厂方法模式 抽象工厂模式 java 设计模式 后端 工厂模式
于 2024-09-10 14:32:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44732500/article/details/142097254
版权

🎯 设计模式专栏，持续更新中， 欢迎订阅：JAVA实现设计模式
🛠️ 希望小伙伴们一键三连，有问题私信都会回复，或者在评论区直接发言

Java实现工厂模式

文章目录

1. 概念

定义：工厂模式（Factory Pattern）是一种创建型设计模式，定义了一个创建对象的接口，但由子类来决定实例化哪个具体类。
使用场景：
需要生成复杂对象，但不希望客户端依赖这些对象的具体类时。
当多个类具有相似功能，但只在某些细节上有区别时，工厂模式能够统一这些不同点。

2. 工厂模式的三种实现方式

通常有三种实现方式：简单工厂模式、工厂方法模式、抽象工厂模式。

举个生活中的例子：假设你有一个家具公司，你可以生产两种风格的家具——现代风格和维多利亚风格，每种风格都有沙发、椅子等家具

2.1 简单工厂模式

简单工厂将所有创建产品的逻辑集中在一个工厂类中。我们可以基于家具厂的案例，使用简单工厂模式来实现家具的创建。
在这里插入图片描述

概念：简单工厂模式由一个工厂类根据传入的参数，决定创建哪一种产品对象。它不属于23种经典的设计模式，但经常作为工厂模式的基础。

1.定义产品接口
// 椅子接口
interface Chair {
    void create();
}

// 沙发接口
interface Sofa {
    void create();
}
2. 实现具体产品类

分别实现现代风格和维多利亚风格的椅子和沙发。

// 现代风格的椅子
class ModernChair implements Chair {
    @Override
    public void create() {
        System.out.println("创建了一张现代风格的椅子");
    }
}

// 维多利亚风格的椅子
class VictorianChair implements Chair {
    @Override
    public void create() {
        System.out.println("创建了一张维多利亚风格的椅子");
    }
}

// 现代风格的沙发
class ModernSofa implements Sofa {
    @Override
    public void create() {
        System.out.println("创建了一张现代风格的沙发");
    }
}

// 维多利亚风格的沙发
class VictorianSofa implements Sofa {
    @Override
    public void create() {
        System.out.println("创建了一张维多利亚风格的沙发");
    }
}
3. 实现简单工厂类

这里我们创建一个工厂类 FurnitureFactory，它根据传入的参数来创建不同类型的家具。

// 简单家具工厂类
class FurnitureFactory {
    // 静态方法，根据产品类型创建相应的家具
    public static Chair createChair(String type) {
        if (type.equalsIgnoreCase("modern")) {
            return new ModernChair();
        } else if (type.equalsIgnoreCase("victorian")) {
            return new VictorianChair();
        } else {
            throw new IllegalArgumentException("未知的椅子类型: " + type);
        }
    }

    public static Sofa createSofa(String type) {
        if (type.equalsIgnoreCase("modern")) {
            return new ModernSofa();
        } else if (type.equalsIgnoreCase("victorian")) {
            return new VictorianSofa();
        } else {
            throw new IllegalArgumentException("未知的沙发类型: " + type);
        }
    }
}
4. 客户端代码

客户端可以通过 FurnitureFactory 提供的静态方法创建产品。

public class FurnitureShop {
    public static void main(String[] args) {
        // 客户希望购买一张现代风格的椅子
        Chair chair = FurnitureFactory.createChair("modern");
        chair.create();

        // 客户希望购买一张维多利亚风格的沙发
        Sofa sofa = FurnitureFactory.createSofa("victorian");
        sofa.create();
    }
}
5.运行结果
创建了一张现代风格的椅子
创建了一张维多利亚风格的沙发

代码分析

  1. 简单工厂类 FurnitureFactory：工厂类提供了两个静态方法 createChair 和 createSofa，通过传入的参数决定要创建的具体产品。简单工厂的核心思想就是将对象的创建逻辑集中在一个地方。
  2. 具体产品类：具体产品类如 ModernChair 和 VictorianChair 分别实现了 Chair 接口，提供了具体的产品行为。
  3. 客户端：客户端通过工厂方法调用相应的产品，无需了解产品的具体实现细节。

优缺点

优点：

  • 简化了客户端代码：客户端不需要直接创建对象，只需通过工厂来获取产品。
  • 集中管理产品创建逻辑：所有创建逻辑都集中在一个工厂类中，便于维护和修改。

缺点：

  • 工厂类的职责较重：随着产品类型的增加，工厂类会变得越来越复杂，违反了单一职责原则。
  • 可扩展性差：如果要添加新的产品类型，工厂类需要修改，不符合开闭原则。

通过简单工厂模式，我们将所有的创建逻辑集中到了 FurnitureFactory 中，并且通过参数化的方式控制创建不同的产品。这适合于产品种类较少且变化不频繁的情况。

2.2 工厂方法模式

概念：工厂方法模式是一种创建型设计模式，它将对象的创建过程推迟到子类中处理，使得客户端不直接依赖于具体产品类。每个具体工厂都会负责创建一种具体产品，这样就符合开闭原则，并且提供了更好的扩展性。

在上面的家具厂案例中，我们可以通过工厂方法模式来为不同的家具（如椅子和沙发）创建不同的工厂。每个工厂只负责创建一种产品。
在这里插入图片描述

1. 定义产品接口

首先，我们依然保留 Chair 和 Sofa 接口，定义它们的 create() 方法。

// 椅子接口
interface Chair {
    void create();
}

// 沙发接口
interface Sofa {
    void create();
}
2. 实现具体产品类

分别实现现代风格和维多利亚风格的椅子和沙发。

// 现代风格的椅子
class ModernChair implements Chair {
    @Override
    public void create() {
        System.out.println("创建了一张现代风格的椅子");
    }
}

// 维多利亚风格的椅子
class VictorianChair implements Chair {
    @Override
    public void create() {
        System.out.println("创建了一张维多利亚风格的椅子");
    }
}

// 现代风格的沙发
class ModernSofa implements Sofa {
    @Override
    public void create() {
        System.out.println("创建了一张现代风格的沙发");
    }
}

// 维多利亚风格的沙发
class VictorianSofa implements Sofa {
    @Override
    public void create() {
        System.out.println("创建了一张维多利亚风格的沙发");
    }
}
3. 创建工厂接口

工厂方法模式的核心思想是，每个具体工厂负责创建一种产品，因此我们需要为每种产品创建不同的工厂接口

// 椅子工厂接口
interface ChairFactory {
    Chair createChair();
}

// 沙发工厂接口
interface SofaFactory {
    Sofa createSofa();
}
4. 实现具体工厂类

我们为现代风格和维多利亚风格的家具分别实现不同的工厂类，每个工厂只负责创建一种风格的产品。

// 现代风格椅子工厂
class ModernChairFactory implements ChairFactory {
    @Override
    public Chair createChair() {
        return new ModernChair();
    }
}

// 维多利亚风格椅子工厂
class VictorianChairFactory implements ChairFactory {
    @Override
    public Chair createChair() {
        return new VictorianChair();
    }
}

// 现代风格沙发工厂
class ModernSofaFactory implements SofaFactory {
    @Override
    public Sofa createSofa() {
        return new ModernSofa();
    }
}

// 维多利亚风格沙发工厂
class VictorianSofaFactory implements SofaFactory {
    @Override
    public Sofa createSofa() {
        return new VictorianSofa();
    }
}
5. 客户端代码

客户端不直接创建产品，而是通过具体工厂创建产品。

public class FurnitureShop {
    public static void main(String[] args) {
        // 客户希望购买一张现代风格的椅子
        ChairFactory chairFactory = new ModernChairFactory();
        Chair chair = chairFactory.createChair();
        chair.create();

        // 客户希望购买一张维多利亚风格的沙发
        SofaFactory sofaFactory = new VictorianSofaFactory();
        Sofa sofa = sofaFactory.createSofa();
        sofa.create();
    }
}
6. 运行结果
创建了一张现代风格的椅子
创建了一张维多利亚风格的沙发

代码分析

  1. 工厂接口 ChairFactory 和 SofaFactory：每个产品（椅子和沙发）有各自的工厂接口，它们定义了创建产品的方法。
  2. 具体工厂类：如 ModernChairFactory 和 VictorianSofaFactory，这些类实现了相应的工厂接口，并负责创建具体产品。
  3. 客户端：客户端通过具体工厂创建产品，而不直接依赖于产品类。这样可以通过工厂接口动态选择要创建的产品，而无需修改客户端代码。

优缺点

优点：

  • 符合开闭原则：可以轻松扩展新的工厂和产品，而不影响现有代码。
  • 简化客户端代码：客户端只依赖工厂接口，不关心具体的产品类，解耦了对象创建的过程。
  • 更好的扩展性：每增加一种新的产品，只需添加对应的工厂类，不需要修改已有的工厂逻辑。

缺点：

  • 增加了类的数量：每增加一种产品或风格，都需要新建一个工厂类，可能会导致类的数量较多。

通过工厂方法模式，我们将对象的创建过程推迟到了具体工厂中，使得代码更易于扩展，客户端代码也更加简洁。

2.3 抽象工厂模式

概念：抽象工厂模式是一种创建型设计模式，它通过为创建一系列相关或依赖对象提供一个接口，而无需指定它们的具体类。

举个生活中的例子：假设你有一个家具公司，你可以生产两种风格的家具——现代风格和维多利亚风格，每种风格都有沙发、椅子等家具。这时，抽象工厂模式就是一个合适的设计选择。
在这里插入图片描述

1. 创建家具的抽象产品接口
// 椅子接口
interface Chair {
    void create();
}

// 沙发接口
interface Sofa {
    void create();
}
2. 创建具体产品类

分别实现现代风格和维多利亚风格的椅子和沙发。

// 现代风格的椅子
class ModernChair implements Chair {
    @Override
    public void create() {
        System.out.println("创建了一张现代风格的椅子");
    }
}

// 维多利亚风格的椅子
class VictorianChair implements Chair {
    @Override
    public void create() {
        System.out.println("创建了一张维多利亚风格的椅子");
    }
}

// 现代风格的沙发
class ModernSofa implements Sofa {
    @Override
    public void create() {
        System.out.println("创建了一张现代风格的沙发");
    }
}

// 维多利亚风格的沙发
class VictorianSofa implements Sofa {
    @Override
    public void create() {
        System.out.println("创建了一张维多利亚风格的沙发");
    }
}
3.创建抽象工厂类

将 FurnitureFactory 设计为一个抽象类，定义抽象方法用于创建产品。

// 抽象家具工厂类
abstract class FurnitureFactory {
    public abstract Chair createChair();
    public abstract Sofa createSofa();
}
4. 实现具体的工厂类
// 现代风格家具工厂
class ModernFurnitureFactory extends FurnitureFactory {
    @Override
    public Chair createChair() {
        return new ModernChair();
    }

    @Override
    public Sofa createSofa() {
        return new ModernSofa();
    }
}

// 维多利亚风格家具工厂
class VictorianFurnitureFactory extends FurnitureFactory {
    @Override
    public Chair createChair() {
        return new VictorianChair();
    }

    @Override
    public Sofa createSofa() {
        return new VictorianSofa();
    }
}
5. 客户端代码

客户端依然可以通过工厂类来创建不同风格的家具。

public class FurnitureShop {
    private Chair chair;
    private Sofa sofa;

    public FurnitureShop(FurnitureFactory factory) {
        chair = factory.createChair();
        sofa = factory.createSofa();
    }

    public void showFurniture() {
        chair.create();
        sofa.create();
    }

    public static void main(String[] args) {
        // 客户希望购买一套现代风格的家具
        FurnitureFactory modernFactory = new ModernFurnitureFactory();
        FurnitureShop modernShop = new FurnitureShop(modernFactory);
        modernShop.showFurniture();

        System.out.println("----------------------------");

        // 客户希望购买一套维多利亚风格的家具
        FurnitureFactory victorianFactory = new VictorianFurnitureFactory();
        FurnitureShop victorianShop = new FurnitureShop(victorianFactory);
        victorianShop.showFurniture();
    }
}
6. 运行结果
创建了一张现代风格的椅子
创建了一张现代风格的沙发
----------------------------
创建了一张维多利亚风格的椅子
创建了一张维多利亚风格的沙发

代码分析

  1. 抽象工厂类 FurnitureFactory：我们使用抽象类而不是接口来定义工厂类，并在其中定义了两个抽象方法 createChair() 和 createSofa()，让子类负责具体实现。
  2. 具体工厂类 ModernFurnitureFactory 和 VictorianFurnitureFactory：每个具体工厂继承了抽象工厂 FurnitureFactory，并实现了创建产品的具体方法。
  3. 客户端代码：客户端使用具体工厂来获取产品实例，通过工厂调用生成椅子和沙发。

优缺点

优点：

  • 可以为子类提供部分默认实现（虽然这个例子中没有使用）。如果工厂类有一些通用的功能可以在多个具体工厂中复用，那么抽象类会更加方便。

  • 提供了创建一组相关产品的接口，符合高内聚低耦合原则。

  • 扩展性好，增加新的产品族时只需增加新的工厂和产品类。

缺点：

  • 当需要增加新的产品等级结构时，所有的工厂类都需要修改。
  • Java 的单继承限制仍然存在，如果具体工厂类已经继承了其他类，就无法再继承 FurnitureFactory。

3. 三种方式的优缺点对比总结

  • 简单工厂模式：

    • 适合简单场景，但不符合开闭原则。
    • 工厂类承担了过多的职责，耦合度较高。

  • 工厂方法模式：

    • 符合开闭原则和单一职责原则，适合扩展性强的场景。
    • 需要为每个产品创建相应的工厂，可能造成类爆炸。

  • 抽象工厂模式：

    • 适合产品族的扩展，提供高灵活性。
    • 实现复杂，增加新的产品等级时，修改成本较高。

4.SpringBoot中工厂模式实战

项目中有一个登录的需求，有手机号码登录和用户名登录两种方式，这里就可以使用工厂模式进行实现，避免了以往ifelse的弊端，提成高逼格，哈哈

接口和实现：

public interface UserLoginService {

    AuthUser login(LoginBo loginBo);
}

@Service
public class PhoneLoginServiceImpl implements UserLoginService {
    @Override
    public AuthUser login(LoginBo loginBo) {
        System.out.println("phone login");
        AuthUser authUser = new AuthUser();
        authUser.setId("1");
        authUser.setName("zhangsan");
        authUser.setPassword("123456");
        return authUser;
    }

}

@Service
public class UsernameLoginServiceImpl implements UserLoginService {
    @Override
    public AuthUser login(LoginBo loginBo) {
        System.out.println("username login");
        AuthUser authUser = new AuthUser();
        authUser.setId("1");
        authUser.setName("username");
        authUser.setPassword("123456");
        return authUser;
    }

}

工厂类：

@Component
public class LoginFactory implements ApplicationContextAware {

    private Map<String, UserLoginService> LOGIN_TYPE_MAP = new HashMap<>();

    /**
     * 初始化不同登录类型处理类
     *
     * @param applicationContext
     * @throws BeansException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        LOGIN_TYPE_MAP.put(AuthConstant.PHONE_MESSAGE_CODE, applicationContext.getBean(PhoneLoginServiceImpl.class));
        LOGIN_TYPE_MAP.put(AuthConstant.USERNAME_PASSWORD, applicationContext.getBean(UsernameLoginServiceImpl.class));
    }

    public UserLoginService getInstance(String loginType) {
        return LOGIN_TYPE_MAP.get(loginType);
    }

}

public class AuthConstant {
    String USERNAME_PASSWORD = "USERNAME_PASSWORD";
    String PHONE_MESSAGE_CODE = "PHONE_MESSAGE_CODE";
}

测试：

@RestController
public class BasicController {

    @Autowired
    private LoginFactory loginFactory;

    @PostMapping("/logintest")
    void login(@RequestBody  LoginBo loginBo){
        UserLoginService userLoginService = loginFactory.getInstance(loginBo.getLoginType());
        userLoginService.login(loginBo);
    }

}

5. 结论

工厂模式在实际开发中非常常见，不同场景下选择合适的模式尤为重要。在需要生成大量复杂对象时，工厂方法模式和抽象工厂模式是非常好的选择；而对于简单的对象生成需求，简单工厂模式足以应对。

coffee_baby
关注
专栏目录
Java设计模式之工厂模式
微笑听雨
07-31 2577
工厂模式（Factory Pattern）是创建型设计模式之一，旨在提供一个创建对象的接口，而不是直接通过 `new` 关键字来实例化对象。工厂模式在提高代码的可维护性、可扩展性和灵活性方面具有显著优势。
C/C++学习路线总结与分享
热门推荐
dvlinker的技术专栏
10-07 8万+
C/C++学习路线总结与分享
Java设计模式 - 工厂模式（简单工厂，工厂方法，抽象工厂）
探长々
08-25 1229
工厂模式：工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式,工厂模式在Java程序中可以说是随处可见。
Java中的简单工厂模式
07-31 1665
Java中的简单工厂模式 http://www.blogjava.net/jzgl-ever/archive/2008/07/26/217704.html <!--<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"xmlns:dc="http://purl.org/dc/elements/1.
Java工厂模式
jmen6的专栏
01-09 1447
 Java工厂模式 Java工厂模式看了这么多关于工厂模式的讲解，还是觉得这篇文章讲的好理解，贴出来和大家分享分享。 一、引子              话说十年前，有一个****户，他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪，还雇了司机为他开车。不过，****户坐车时总是怪怪的：上Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上Audi说“开奥迪车！”。你一
java设计模式之工厂模式(Factory)
natee的专栏
08-04 2290
转至：http://blog.csai.cn/user1/25929/archives/2009/35622.html原著：和水柔石 （还没看太懂:)） 一、引子话说十年前，有一个爆发户，他家有三辆汽车（Benz（奔驰）、Bmw（宝马）、Audi（奥迪）看来这人比较爱国，没有日本车），还雇了司机为他开车。不过，爆发户坐车时总是这样：上Benz
Java 简单工厂
梓鸿
12-12 98
Java 简单工厂 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象...
四个版本飞机大战 代码 录像 PPT讲解.rar
07-01
总结起来，这个资源包是一个全面的学习材料，涵盖了游戏开发中的关键要素，包括关卡设计、代码实现、设计模式的应用以及教学辅助材料。无论是对于希望深入学习游戏编程的初学者，还是想要提升自己在游戏开发领域专业...
转载：23种设计模式整理（很全）
qq_46120580的博客
04-24 1479
23 种设计模式汇集 目录 文章目录23 种设计模式汇集目录设计模式引言学习 GoF 设计模式的重要性建筑和软件中模式之异同设计模式之 Singleton(单态)模式实战书籍《Java 实用系统开发指南》单态定义:设计模式之 Factory工厂模式定义*:*提供创建对象的接口*.* 为何使用*?*工厂模式中有: 工厂方法*(Factory Method)* 抽象工厂*(Abstract Factory).*设计模式之 Builder设计模式之 Prototype(原型)设计模式之 Adapter(适配器)设
优惠券的工厂与策略模式实现方案
xuhss_com的博客
06-11 441
真正开发中使用最频繁的模式基本就是【策略】和【工厂】这个两个模式。按照"国际惯例"先引入些模式的概念和示例。(示例参考Head First，但是力求比它讲的简洁且清晰)之后在详细讲解优惠券的设计和模式应用。所有面向对象入门的时候都是以人、动物为示例。讲解什么是【继承】等相关概念。这个是符合直觉的。但是在实际应用中，继承用到的地方有限，它有它的问题，它是一种【强耦合】方式，一般使用【策略模式】【装饰模式】代替继承。以鸭子动物设计为例，讲解继承方式存在哪些问题：所有鸭子都有quack和swim能力，所以超类实现
【 Qt 的“前世”与“今生”】Qt 的起源 | Qt 的发展历程 | 为什么选择 Qt | Qt 的授权模式 | Qt 版本选择 | Qt Widgets和QML | Qt 程序发布
最新发布
dvlinker的技术专栏
12-03 2万+
【 Qt 的“前世”与“今生”】Qt 的起源 | Qt 的发展历程 | 为什么选择 Qt | Qt 的授权模式 | Qt 版本选择 | Qt Widgets和QML | Qt 程序发布
工厂模式（简单工厂，普通工厂，抽象工厂）代码java
02-13
这是代码，介绍请查看以下博客地址： http://www.cnblogs.com/homg/p/3548110.html代码乱码请使用utf-8编码。
java 工厂类
zust6314的专栏
05-05 537
简单工厂模式需要由以下角色组成： 　　　　　　接口                         接口的实现类（简单工厂模式里面的具体产品角色）                         工厂 注意对比以下三个实例的不同 实例１： package org.jzkangta.factorydemo01; //定义接口 interface Car{     pub
Java简单工厂模式
effine
09-10 3307
简单工厂模式，又称静态工厂模式，
java工厂类_Java 工厂模式
weixin_42524401的博客
02-19 325
工厂模式是一种创建模式，因为此模式提供了更好的方法来创建对象。在工厂模式中，我们创建对象而不将创建逻辑暴露给客户端。例子在以下部分中，我们将展示如何使用工厂模式创建对象。由工厂模式创建的对象将是形状对象，如圆形，矩形。首先，我们设计一个接口来表示Shape。public interface Shape {void draw();}然后我们创建实现接口的具体类。以下代码用于Rectangle.jav...
java的工厂类_Java中的工厂模式
weixin_29174141的博客
02-18 341
设计模式遵循原则开闭原则：对扩展开放，对修改关闭里氏代换原则：只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被覆用。而衍生类也能够在基类的基础上增加新的行为依赖倒转原则：开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体接口隔离原则：使用多个隔离的接口来降低耦合度迪米特法原则：最少知道原则。一个实体应该尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立合成复用原则...
工厂类——java理解
qq_41832361的博客
03-21 2859
问题：客户端直接与具体产品交互 解决方法：将客户端产生商品的行为（new对象）提取到一个新的类中->工厂类 具体代码如下： import java.util.Scanner; interface Computer {//抽象产品族 void printComputer(); } class MacbookPr...
工厂类 java_设计模式之工厂模式（java）
weixin_29887021的博客
02-20 91
工厂模式的定义为：Define an interface for creating an object ，but let subclass decide which class to instantiate，Factory Methods lets a class defer instantiation to subclass.(定义一个用于创建对象的接口，让其子类决定实例化哪一个类，工厂方法使...
java工厂类_Java工厂模式应用
weixin_35999303的博客
02-19 288
之前在项目中遇到这样一种情景：代码中有一个共用的任务处理模块，不同的数据会通过唯一键(任务名称和key fields)全部存入公共任务表里，然后在同步模块通过任务名称去获取相应的任务进行同步处理。在存入公共任务表之前，不同的任务线都会进行各自的逻辑处理，而且基本上不存在共用的代码，所以在这里考虑建一个工厂类，由Spring注入一个Map，String对应的各个任务的名称，interface对应的是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

coffee_baby

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值