设计模式之单例模式

最新推荐文章于 2023-05-10 10:56:03 发布
最新推荐文章于 2023-05-10 10:56:03 发布
阅读量401 收藏 5
点赞数
分类专栏： 设计模式 文章标签： 设计模式 单例模式 双重检查 线程安全单例模式 反射打破单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TOP__ONE/article/details/116306174
版权

单例设计模式介绍

         所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例， 并且该类只提供一个取得其对象实例的方法(静态方法)。

         比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。

单例模式注意事项和细节说明

 

  1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
  3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)

单例模式有八种方式：

  1. 饿汉式(静态常量)
  2. 饿汉式（静态代码块）
  3. 懒汉式(线程不安全)
  4. 懒汉式(线程安全，同步方法)
  5. 懒汉式(线程不安全，同步代码块)
  6. 双重检查
  7. 静态内部类
  8. 枚举

下面详细分别介绍每一种单例模式

一、饿汉式（静态常量）
  1)构造器私有化 (防止 new )
  2)类的内部创建对象
  3)向外暴露一个静态的公共方法。getInstance

package com.king.signle;

/**
 * @date 2021/4/30 上午9:23
 * 饿汉式(静态常量)
 * 1)构造器私有化 (防止 new )
 * 2)类的内部创建对象
 * 3)向外暴露一个静态的公共方法。getInstance
 *
 *
 * 优缺点说明：
 * 1)优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
 * 2)缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
 * 3)这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法， 但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果
 *
 * 结论：这种单例模式可用，可能造成内存浪费
 *
 */
public class SingleOne {
    /**
     * 2)类的内部创建对象
     */
    private final static SingleOne instance = new SingleOne();

    /**
     * 构造器私有化
     */
    private SingleOne(){}

    /**
     * 3)向外暴露一个静态的公共方法。getInstance
     * @return
     */
    private static SingleOne getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        SingleOne instance = SingleOne.getInstance();
        SingleOne instance1 = SingleOne.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

优缺点说明：
 1)优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
 2)缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
 3)这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法， 但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果
  结论：这种单例模式可用，可能造成内存浪费

二、饿汉式（静态代码块）

/**
 * @date 2021/4/30 上午9:23
 * 2)饿汉式（静态代码块）
 *
 * 优缺点说明：
 *
 * 1)这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
 * 2)结论：这种单例模式可用，但是可能造成内存浪费
 */
public class SingleTwo {
    private static SingleTwo instance;

    /**
     * 构造器私有化
     */
    private SingleTwo() {
    }

    static {
        instance = new SingleTwo();
    }

    private static SingleTwo getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        SingleTwo instance = SingleTwo.getInstance();
        SingleTwo instance1 = SingleTwo.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

优缺点：

1)这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
 2)结论：这种单例模式可用，但是可能造成内存浪费

三、懒汉式（线程不安全）

/**
 * @author 王东阳
 * @date 2021/4/30 上午9:23
 * 3)懒汉式(线程不安全)
 *
 * 优缺点说明：
 * 1)起到了 Lazy Loading 的效果，但是只能在单线程下使用。
 * 2)如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
 * 3)结论：在实际开发中，不要使用这种方式.
 */
public class SingleThree {
    private static SingleThree instance;

    /**
     * 构造器私有化
     */
    private SingleThree() {
    }

    /**
     * 提供一个静态的公有方法，当使用到该方法时，才去创建 instance
     * 即懒汉式
     * @return
     */
    private static SingleThree getInstance() {
        if(instance ==null){
            instance = new SingleThree();
        }
        return instance;
    }

    public static void main(String[] args) {
        SingleThree instance = SingleThree.getInstance();
        SingleThree instance1 = SingleThree.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

优缺点说明：
 1)起到了 Lazy Loading 的效果，但是只能在单线程下使用。
 2)如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
 3)结论：在实际开发中，不要使用这种方式.

四、懒汉式（线程安全，同步方法）

/**
 * @date 2021/4/30 上午9:23
 * 4)懒汉式(线程安全，同步方法)
 *
 * 优缺点说明：
 * 1)解决了线程安全问题
 * 2)效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。
 *   而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低
 * 3)结论：在实际开发中，不推荐使用这种方式
 */
public class SingleFour {
    private static SingleFour instance;

    /**
     * 构造器私有化
     */
    private SingleFour() {
    }

    /**
     * 提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
     * 即懒汉式
     * @return
     */
    private static synchronized SingleFour getInstance() {
        if(instance ==null){
            instance = new SingleFour();
        }
        return instance;
    }

    public static void main(String[] args) {
        SingleFour instance = SingleFour.getInstance();
        SingleFour instance1 = SingleFour.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

优缺点说明：
  1)解决了线程安全问题
  2)效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。
    而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低
  3)结论：在实际开发中，不推荐使用这种方式

五、懒汉式（线程不安全，同步代码块）

/**
 * @author 王东阳
 * @date 2021/4/30 上午9:23
 * 5)懒汉式(线程不安全，同步代码块) 基本不适用
 * <p>
 * 优缺点说明：
 * 1)这种方式，体意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的的代码块
 * 2)但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，
 *   假如一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例
 * 3)结论:在实际开发中，不能使用这种方式
 */
public class SingleFive {
    private static SingleFive instance;

    /**
     * 构造器私有化
     */
    private SingleFive() {
    }

    /**
     * 提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
     * 即懒汉式
     *
     * @return
     */
    private static SingleFive getInstance() {
        if (instance == null) {
            synchronized (SingleFive.class) {
                instance = new SingleFive();
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        SingleFive instance = SingleFive.getInstance();
        SingleFive instance1 = SingleFive.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

优缺点说明：
 1)这种方式，体意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的的代码块
 2)但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，
    假如一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例
 3)结论:在实际开发中，不能使用这种方式

六、双重检查（dcl  dobule check lock）

/**
 * @date 2021/4/30 上午9:23
 * 5)双重检查
 * <p>
 * 优缺点说明：
 * 1)Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
 * 2)这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步.
 * 3)线程安全；延迟加载；效率较高
 * 4)结论：在实际开发中，推荐使用这种单例设计模式
 */
public class SingleSix {
    /**
     * 添加volatile来禁止指令重排
     */
    private volatile static SingleSix instance;

    /**
     * 构造器私有化
     */
    private SingleSix() {
    }

    /**
     * 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
     * 同时保证了效率, 推荐使用
     *
     * @return
     */
    private static SingleSix getInstance() {
        if (instance == null) {
            synchronized (SingleSix.class) {
                if (instance == null) {
                    instance = new SingleSix();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        SingleSix instance = SingleSix.getInstance();
        SingleSix instance1 = SingleSix.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

优缺点说明：  

  1)Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
  2)这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步.
  3)线程安全；延迟加载；效率较高
  4)结论：在实际开发中，推荐使用这种单例设计模式

七、静态内部类

/**
 * @date 2021/4/30 上午9:23
 * 5)静态内部类 静态内部类完成 推荐使用
 * <p>
 * 优缺点说明：
 * 1)这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
 * 2)静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
 * 3)类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
 * 4)优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
 * 5)结论：推荐使用.
 */
public class SingleSeven {
    /**
     * 构造器私有化
     */
    private SingleSeven() {
    }

    /**
     * 写一个静态内部类,该类中有一个静态属性 Singleton
     */
    private static class SingleSevenInstance{
        private static final SingleSeven INSTANCE = new SingleSeven();

    }

    /**
     * 提供一个静态的公有方法，直接返回 SingleSevenInstance.INSTANCE
     * @return
     */
    private static SingleSeven getInstance() {
        return SingleSevenInstance.INSTANCE;
    }


    public static void main(String[] args) {
        SingleSeven instance = SingleSeven.getInstance();
        SingleSeven instance1 = SingleSeven.getInstance();
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

优缺点说明：
 1)这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
 2)静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
 3)类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
 4)优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
 5)结论：推荐使用.

八、枚举方式

/**
 * @date 2021/4/30 上午10:10
 * 8）枚举
 * 使用枚举，可以实现单例, 推荐
 *
 *优缺点说明：
 * 1)这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
 * 2)这种方式是 Effective Java 作者 Josh Bloch  提倡的方式
 * 3)结论：推荐使用
 */
public enum SingleEight {
    INSTANCE;

    public static void main(String[] args) {
        SingleEight instance = SingleEight.INSTANCE;
        SingleEight instance1 = SingleEight.INSTANCE;
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

优缺点说明：
1)这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
2)这种方式是 Effective Java 作者 Josh Bloch  提倡的方式
3)结论：推荐使用

单例模式在 JDK  应用的源码分析

我们 JDK 中，java.lang.Runtime 就是经典的单例模式(饿汉式)

 

关于反射打破单例模式：

单例模式三要素：

1、构造方法私有化；2、实例化的变量引用私有化；3、获取实例的方法共有。

为什么反射会打破单例模式？

因为在单例模式中的构造器是私有的，在Singleton类外部是不能随便调用的，但是通过反射就不一定了，通过这段代码constructor.setAccessible(true)便可以得到构造器的访问权。

来完成对象的初始化，就会打破单例模式

 public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class objectClass = Singleton.class;
        Constructor constructor = objectClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton instance = Singleton.getInstance();
        Singleton newInstance = (Singleton) constructor.newInstance();

        System.out.println(instance);
        System.out.println(newInstance);
        System.out.println(instance == newInstance);
    }

我们如何应对呢？

即便是通过反射来创建实例，也是调用类中的构造器来实现的，所以我们可以在构造器中做文章。
改造Singleton类中的私有构造器如下：

public class Singleton{
    private Singleton(){
        if(Inner.instance != null){
            throw new RuntimeException("单例模式禁止反射创建实例！");
        }
    }

    public static Singleton getInstance(){
        return Inner.instance;
    }

    private static class Inner{
        private static final Singleton instance = new Singleton();
    }
}

但是枚举模式的单例模式就已经不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。也能防止通过反射来打破单例模式

因此，枚举模式，已经成为单例模式最佳的方法了：单元素的枚举类型已经成为实现Singleton的最佳方法

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

TOP__ONE
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
JAVA设计模式之单例模式
09-22
JAVA设计模式之单例模式。 一篇文章带你快速了解！
设计模式之——单例模式
最新发布
很高兴你能看到这里
06-19 2118
更酷的是，创建对象的职责和管理单例的职责被拆分在两个不同的方法中，这两个方法组合起来才具有单例模式的威力。你学到了吗，少年？
单例模式（单例设计模式）详解
热门推荐
GJ_007的博客
03-31 4万+
在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。 单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程
单例设计模式(8种)
weixin_49329785的博客
08-04 1088
/* * 单例设计模式： * 1.所谓的单例设计模式，就是采用一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。 * * 2.如何实现？ * 饿汉式 vs 懒汉式 * 3.区分饿汉式和懒汉式 * 饿汉式：（创建时就已经存在对象） * 坏处：对象加载时间过长。 * 好处：饿汉式是线程安全的。 * 懒汉式： * 好处：延迟对象的创建 * 目前写法的坏处：线程不安全。---->到多线程内容时，在修改 * */ public class Si.
单例设计模式
qq_48157004的博客
05-28 2709
单例例模式便是创建型设计模式的一种，它确保某一个类在系统中只有一个实例，并自行实例化，同时向外部提供获取这个唯一实例的接口。单例设计模式主要有以下三个特点：1、只能有一个实例。2、必须自己创建自己的唯一实例。3、必须给所有其他对象提供这一实例。缺点： 以空间换时间，在实例化时就创建，灵活性不高，空间使用率不高。优点：在类加载过程中便会创建。由此带来的好处是Java的类加载机制本身为我们保证了实例化过程的线程安全性。
设计模式之单例模式（七种方法超详细）
weixin_63834061的博客
04-22 3548
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，也就是说不能使用new关键字来创建对象。
研磨设计模式之单例模式
02-27
 单例模式（Singleton）1 场景问题1.1 读取配置文件的内容考虑这样一个应用，读取配置文件的内容。很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的...
PHP设计模式之单例模式定义与用法分析
01-03
单例模式（Singleton Pattern 单件模式或单元素模式），是常见的一种设计模式，它有三个特点 1．只能有一个实例 2．必须自行创建这个实例 3．必须给其他对象提供这一实例 下面用PHP代码实现一下 <?PHP /** *...
C++设计模式之单例模式
09-04
主要介绍了C++设计模式之单例模式,本文同时给出了4种单例模式的实现代码,需要的朋友可以参考下
单例模式
weixin_44333359的博客
04-27 130
一.简介 单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。 单例模式的实现主要通过一下三要素： 1.提供私有的静态属性。 2.**定义一个私有化的构造方法。**这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例； 3.提供一个公共的静态方法。当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持...
23种设计模式中的单例模式（Singleton Pattern）
小威的博客
05-10 2万+
本篇文章将23种设计模式中的单例设计模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
java设计模式之单例模式
weixin_44991304的博客
03-16 574
这里写自定义目录标题单例设计模式介绍单例模式应用场景单例设计模式八种方式1.1 饿汉式(静态常量)1.2 饿汉式（静态代码块）1.3懒汉式(线程不安全)1.4懒汉式(线程安全，同步方法)创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 单例设计模式介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并
设计模式--单例模式详解
想着百万年薪努力的小赵
04-13 2297
单例模式的定义 单例模式(Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如，公司CEO、部门经理等。J2EE标准中的ServletContext，ServletContextConfig等、Spring框架应用中的ApplicationContext、数据库的连接池等也都是单例形式。 饿汉式单例模式 饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没 出
设计模式之单例模式（通俗易懂，超详细）
良猿啊
07-15 2397
1 什么是单例模式 单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例） ——《百度百科》 简单来说单例模式就是指在内存中只会创建且仅创建一次对象的设计模式，当程序中其他地方需要使用到该对象的相同功能时，都会调用创建好的这一个，不会再额外创建实例，这样做的好处就是避免过多的创建相同作用的对象使得内存浪费。 2 单例模式分类 在单例模式中主要分为两类，分别是懒汉式和饿汉式 懒汉式：在程
设计模式——单例模式
qq_51114283的博客
07-11 2176
创建型模式——单例模式
设计模式之单例模式详解（附应用举例实现）
pursuit的博客
04-22 4603
设计模式之单例模式详解（附应用举例实现），包含三种实现单例模式的方法
php语言设计模式之单例模式educoder
03-16
单例模式是一种常用的设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在PHP中，可以通过定义一个私有的构造函数和一个静态的getInstance方法来实现单例模式。在getInstance方法中，如果类的实例不存在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值