dubbo spi 原理解析

最新推荐文章于 2024-09-22 16:05:08 发布
最新推荐文章于 2024-09-22 16:05:08 发布
阅读量351 收藏
点赞数
文章标签： java dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20417529/article/details/114582515
版权

一、spi 使用

创建spi 接口及对应实现

package apache.dubbo.test.spi;
import org.apache.dubbo.common.extension.SPI;
@SPI
public interface SpiInterface {
    void method();
}


public class SpiInterfaceImpl implements SpiInterface {
    @Override
    public void method() {
        System.out.println(this.getClass().getName());
    }
}

 在META-INFO/dubbo中声明审批配置，创建与spi接口类名相同的文件apache.dubbo.test.spi.SpiInterface，在文档内编辑

my=apache.dubbo.test.spi.SpiInterfaceImpl

使用 SPI

ExtensionLoader<SpiInterface> extensionLoader = ExtensionLoader.getExtensionLoader(SpiInterface.class);
        SpiInterface spiInstance = extensionLoader.getExtension("my");
        spiInstance.method();

二、原理解析

public class ExtensionLoader<T> {
    //loader 缓存
    private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<>(64);

    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        // ...
        return (ExtensionLoader<T>) EXTENSION_LOADERS.computeIfAbsent(type, k -> new ExtensionLoader<T>(type));
    }

    // 获取实例
    public T getExtension(String name) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        // 注解中配置的默认实现
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        // 从缓存获取
        final Holder<Object> holder = getOrCreateHolder(name);
        Object instance = holder.get();
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    //创建实例
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }
    
    // 创建实例
    private T createExtension(String name) {
        //获取class对象
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                //实例化
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            //注入set方法
            injectExtension(instance);
            //包装类
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            //如果有包装类，对对象进行包装
            if (CollectionUtils.isNotEmpty(wrapperClasses)) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            //执行init
            initExtension(instance);
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                    type + ") couldn't be instantiated: " + t.getMessage(), t);
        }
    }

    // 获取审批配置
    /**
     * 获取全量的class配置
     * @return
     */
    private Map<String, Class<?>> getExtensionClasses() {
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    // 解析META-INFO下的配置文件
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }

    /**
     * synchronized in getExtensionClasses
     * */
    private Map<String, Class<?>> loadExtensionClasses() {
        cacheDefaultExtensionName();

        Map<String, Class<?>> extensionClasses = new HashMap<>();
        // 从对应文件路径下加载文件 [META-INF/services/,META-INF/dubbo/,internal/]
        for (LoadingStrategy strategy : strategies) {
            loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(), strategy.excludedPackages());
            loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"), strategy.preferExtensionClassLoader(), strategy.excludedPackages());
        }

        return extensionClasses;
    }
}

三、Adaptive

Dubbo Spi 提供获取适配对象的代理适配器的api，dubbo中大量使用了该方法，实现动态的调用

ExtensionLoader<SpiInterface> extensionLoader = ExtensionLoader.getExtensionLoader(SpiInterface.class);
        SpiInterface spiInstance = extensionLoader.getAdaptiveExtension();

动态适配器对象有两种创建方式

1 Adaptive 类，用户自定义

    用户创建一个类继承SPI接口，添加@Adaptive注解，用户自己实现对象的配逻辑

@Adaptive
public class SpiIoc implements SpiInterface {
    @Override
    public void method(URL url) {
        // 适配逻辑
    }
}

2 Adaptive方法，dubbo自动创建

SPI接口方法被 @Adaptive标记，参数列表总必须带有org.apache.dubbo.common.URL，或者参数对象里有对象包含获取URL对象的get方法，针对这些方法，dubbo会为其创建代理方法

@SPI
public interface SpiInterface {
    @Adaptive("my") // 如果注解value是protocol，通过url的协议名称进行适配；否则通过url同名的parameter适配
    void method(URL url);
}

 

源码实现

public class ExtensionLoader<T> {
    // ...
    //nb  该方法是实际生成的是一个代理适配器，根据spi 类型去调用对应的类
    public T getAdaptiveExtension() {
        // 缓存
        Object instance = cachedAdaptiveInstance.get();
        if (instance == null) {
            if (createAdaptiveInstanceError != null) {
                throw new IllegalStateException("Failed to create adaptive instance: " +
                        createAdaptiveInstanceError.toString(),
                        createAdaptiveInstanceError);
            }

            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        // 创建
                        instance = createAdaptiveExtension();
                        cachedAdaptiveInstance.set(instance);
                    } catch (Throwable t) {
                        createAdaptiveInstanceError = t;
                        throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
                    }
                }
            }
        }

        return (T) instance;
    }

    private T createAdaptiveExtension() {
        try {
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }

    private Class<?> getAdaptiveExtensionClass() {
        getExtensionClasses();
        // 有Adaptive类 在之前加载SPI配置文件时已经初始化
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        // 通过javassist自动创建代理类
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

    private Class<?> createAdaptiveExtensionClass() {
        // 生成代理类的代码
        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
        ClassLoader classLoader = findClassLoader();
        org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }

}

下面是代码生成器的源码 

public class AdaptiveClassCodeGenerator {

    /**
     * 生成代码
     * generate and return class code
     */
    public String generate() {
        // no need to generate adaptive class since there's no adaptive method found.
        // 必须带有@Adaptive的方法
        if (!hasAdaptiveMethod()) {
            throw new IllegalStateException("No adaptive method exist on extension " + type.getName() + ", refuse to create the adaptive class!");
        }

        StringBuilder code = new StringBuilder();
        code.append(generatePackageInfo());
        code.append(generateImports());
        code.append(generateClassDeclaration());
        // 组装代理方法
        Method[] methods = type.getMethods();
        for (Method method : methods) {
            code.append(generateMethod(method));
        }
        code.append("}");

        if (logger.isDebugEnabled()) {
            logger.debug(code.toString());
        }
        return code.toString();
    }

     /**
     * 创建代理方法的代码
     * generate method declaration
     */
    private String generateMethod(Method method) {
        String methodReturnType = method.getReturnType().getCanonicalName();
        String methodName = method.getName();
        // 方法内容
        String methodContent = generateMethodContent(method);
        String methodArgs = generateMethodArguments(method);
        String methodThrows = generateMethodThrows(method);
        return String.format(CODE_METHOD_DECLARATION, methodReturnType, methodName, methodArgs, methodThrows, methodContent);
    }

    /**
     * 生成代理方法
     * generate method content
     */
    private String generateMethodContent(Method method) {
        Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
        StringBuilder code = new StringBuilder(512);
        // 非Adaptive方法，代理方法直接抛异常
        if (adaptiveAnnotation == null) {
            return generateUnsupported(method);
        } else {
            // 查找方法参数里的 URL
            int urlTypeIndex = getUrlTypeIndex(method);
            // found parameter in URL type
            if (urlTypeIndex != -1) {
                // Null Point check
                code.append(generateUrlNullCheck(urlTypeIndex));
            } else {
                // did not find parameter in URL type
                // 查找参数里的对象包含的 URL
                code.append(generateUrlAssignmentIndirectly(method));
            }

            //方法中@Adaptive 的value
            String[] value = getMethodAdaptiveValue(adaptiveAnnotation);

            boolean hasInvocation = hasInvocationArgument(method);
            // 组装org.apache.dubbo.rpc.Invocation 参数中指定的method
            code.append(generateInvocationArgumentNullCheck(method));
            // 组装要代理的Extension的ExtName,看是去url的parameter还是Protocol
            // value=protocol代表取url的protocol名称，其他值代表取url中相对应的parameter的值
            code.append(generateExtNameAssignment(value, hasInvocation));
            // check extName == null?
            code.append(generateExtNameNullCheck(value));
            // 组装通过SPI获取对应的Extension
            code.append(generateExtensionAssignment());

            // return statement
            code.append(generateReturnAndInvocation(method));
        }

        return code.toString();
    }
    
    // 没有从SPI接口方法里找到参数URL,遍历参数,从参数的下级去找URL
    private String generateUrlAssignmentIndirectly(Method method) {
        Class<?>[] pts = method.getParameterTypes();

        Map<String, Integer> getterReturnUrl = new HashMap<>();
        // find URL getter method
        for (int i = 0; i < pts.length; ++i) {
            for (Method m : pts[i].getMethods()) {
                String name = m.getName();
                if ((name.startsWith("get") || name.length() > 3)
                        && Modifier.isPublic(m.getModifiers())
                        && !Modifier.isStatic(m.getModifiers())
                        && m.getParameterTypes().length == 0
                        && m.getReturnType() == URL.class) {
                    getterReturnUrl.put(name, i);
                }
            }
        }

        if (getterReturnUrl.size() <= 0) {
            // getter method not found, throw
            throw new IllegalStateException("Failed to create adaptive class for interface " + type.getName()
                    + ": not found url parameter or url attribute in parameters of method " + method.getName());
        }

        Integer index = getterReturnUrl.get("getUrl");
        if (index != null) {
            return generateGetUrlNullCheck(index, pts[index], "getUrl");
        } else {
            Map.Entry<String, Integer> entry = getterReturnUrl.entrySet().iterator().next();
            return generateGetUrlNullCheck(entry.getValue(), pts[entry.getValue()], entry.getKey());
        }
    }

}

最终dubbo找到生成的代码如下，实际是返回了一个代理对象，通过接口参数里的URL中的信息对SPI进行适配

package apache.dubbo.test.spi;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class SpiInterface$Adaptive2 implements apache.dubbo.test.spi.SpiInterface {
    public void method(org.apache.dubbo.common.URL arg0)  {
        if (arg0 == null) throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg0;
        String extName = url.getParameter("my");
        if(extName == null) throw new IllegalStateException("Failed to get extension (apache.dubbo.test.spi.SpiInterface) name from url (" + url.toString() + ") use keys([my])");
        apache.dubbo.test.spi.SpiInterface extension = (apache.dubbo.test.spi.SpiInterface)ExtensionLoader.getExtensionLoader(apache.dubbo.test.spi.SpiInterface.class).getExtension(extName);
        extension.method(arg0);
    }
}

具体适配逻辑由于接口参数不同或者注解Adaptive的value不同实现稍有区别，但核心都是通过url的参数或者协议指定extName，在通过SPI返回对应的Extension

四、自动包装

    之前提到在创建实例时会有一个自动包装的过程

// 创建实例
    private T createExtension(String name) {
        //获取class对象
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                //实例化
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            //注入set方法
            injectExtension(instance);
            //包装类
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            //如果有包装类，对对象进行包装
            if (CollectionUtils.isNotEmpty(wrapperClasses)) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            //执行init
            initExtension(instance);
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                    type + ") couldn't be instantiated: " + t.getMessage(), t);
        }
    }

如果有包装，是返回一个包装类的实例

包装类的判断通过检查SPI实现类是否包含参数是该SPI接口的构造函数，逻辑如下

private void cacheWrapperClass(Class<?> clazz) {
        if (cachedWrapperClasses == null) {
            cachedWrapperClasses = new ConcurrentHashSet<>();
        }
        cachedWrapperClasses.add(clazz);
    }

    /**
     * test if clazz is a wrapper class
     * <p>
     * which has Constructor with given class type as its only argument
     */
    private boolean isWrapperClass(Class<?> clazz) {
        try {
            //判断条件 带有参数的public构造器  且 构造器入参是需要包装的SPI接口
            clazz.getConstructor(type);
            return true;
        } catch (NoSuchMethodException e) {
            return false;
        }
    }

使用可以使用该功能实现AOP的操作

实现包装逻辑

public class SpiInterfaceWrapper implements SpiInterface {
    private SpiInterface spiInterface;

    public SpiInterfaceWrapper(SpiInterface spiInterface) {
        this.spiInterface = spiInterface;
    }

    @Override
    public void method(URL url) {
        System.out.println("wrapper do");
        spiInterface.method(url);
        System.out.println("wrapper after");
    }
}

在META-INFO配置中添加该SPI实现

my=apache.dubbo.test.spi.SpiInterfaceImpl
spiIoc=apache.dubbo.test.spi.SpiIoc
wrapper=apache.dubbo.test.spi.SpiInterfaceWrapper

这样最终获取到的SPI实例将会实现自动包装

sixo
关注
Dubbo的SPI原理
HealerJean梦想博客
07-16 840
前言 Github：https://github.com/HealerJean 博客：http://blog.healerjean.com SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。 正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI
Java中的Spi以及Dubbo中的Spi机制解析
m0_51464746的博客
02-16 637
SPI 全称为 Service Provider Interface，是一种服务发现机制。本质是由将接口的实现类的全限定名配置在文件当中，由服务加载，这样可以在运行时，动态的为接口加载实现类。 举个例子，我们在用JDBC连接数据库时，创建连接就能直接获取到Mysql或者Oracle，Java时如何调用到相对应的驱动呢？ 我们将连接数据库看作一个扩展点，其他数据都是该点的实现，当我们需要连接相对应的的数据库时，Spi会帮助我们发现有哪些实现并加载。 一、J...
dubbo01-spi
老猿说说专栏
10-12 144
为什么要设计adaptive？注解在类上和注解在方法上的区别？ adaptive设计的目的是为了识别固定已知类和扩展未知类。 1.注解在类上：代表人工实现，实现一个装饰类（设计模式中的装饰模式），它主要作用于固定已知类， 目前整个系统只有2个，AdaptiveCompiler、AdaptiveExtensionFactory。 a.为什么AdaptiveCompiler这个类是固定已知的？因为整个...
dubbo的原理和知识
最新发布
乡村非主流2020的博客
09-22 748
当服务的提供者提供了一种接口的实现之后，需要在Classpath下的META-INF/dubbo/（或META-INF/services/，用于兼容Java SPI）目录中创建一个以服务接口命名的文件，此文件记录了该接口的具体实现类。综上所述，Dubbo通过注册中心实现服务的注册与发现，通过负载均衡策略选择服务提供者，通过网络通信实现服务调用，通过监控中心收集监控数据，并通过扩展机制支持服务的自定义和扩展。需要注意的是，Netty的零拷贝机制是在用户态实现的，而微内核架构通常是在操作系统内核层面讨论的。
dubbo的spi原理
zhutianrong520的博客
06-15 477
1.简介 SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。不过，Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足需求。在 Dub
Dubbo之SPI原理详解
weixin_34060741的博客
12-08 152
2019独角兽企业重金招聘Python工程师标准>>> ...
Dubbo SPI实现原理
diy_os的专栏
09-17 405
Dubbo 并未使用 Java 原生的 SPI 机制,而是对其进行了增强,使其能够更好的满足需求,在 Dubbo 中，SPI 是一个非常重要的模块。基于 SPI,我们可以很容易的对 Dubbo 进行拓展. 本篇文章通过示例说明,先 download 代码，然后在 ``demo-dubbo --》 dubbo-demo-api --》 dubbo-demo-api-provider` 下新建类: @...
dubbo spi可扩展机制源码解析
12-24
下面我们将深入剖析Dubbo SPI的源码，了解其实现原理。 首先，我们要理解SPI的核心概念：接口、实现类和服务发现。在Java世界中，SPI允许开发者定义一个接口，然后提供多个实现该接口的类，系统在运行时会自动发现...
Dubbo SPI机制解析：多协议服务暴露
本文主要探讨的是Dubbo服务的多协议暴露特性，以及其核心组件——Dubbo微内核基于SPI（Service Provider Interface）的实现原理。" 在Dubbo中，同一服务可以被暴露为多种协议，以满足不同场景的需求。例如，`<dubbo...
深入解析Dubbo SPI的设计原理与实现
资源摘要信息:"Dubbo SPI机制详细解析" 一、Dubbo SPI概述 Apache Dubbo是一个高性能、轻量级的Java RPC框架，它在内部使用了SPI（Service Provider Interface，服务提供接口）机制来加载各种扩展点。Dubbo的SPI...
Dubbo SPI机制解析：实现动态服务发现与加载
"Dubbo基本功能与SPI机制详解" Dubbo是一个高性能、轻量级的开源Java RPC框架，它提供了丰富的监控、服务发现、负载均衡等功能，极大地提升了分布式系统开发的效率。本文将主要探讨Dubbo的基本功能以及其核心机制...
dubbo之SPI解析
qfc8930858的博客
07-16 129
一 概述 Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); 这种类型的代码来获取一个接口的代理类，比如我这里贴的代码反馈的了一个Protocol接口的代理实现。仔细翻看dubbo中的源码，Protocol接口的实现类有很多种，...
三、dubbo的SPI机制原理
wangle965235568的博客
07-19 474
一、JAVA的SPI机制 1、简介 SPI 全称 Service Provider Interface，是 Java 提供的一套用来被第三方实现或 者扩展的 API，它可以用来启用框架扩展和替换组件 可以看到，SPI 的本质，其实是帮助程序，为某个特定的接口寻找它的实 现类。而且哪些实现类的会加载，是个动态过程(不是提前预定好的)。 有点类似 IOC 的思想，就是将装配的控制权移到程序之外，在模块化设 计中这个机制尤其重要。所以 SPI 的核心思想就是解耦。 常见例子： 数据库驱动加载接口实现类的加载，
dubbo-源码阅读之dubboSpi实现原理
08-01 144
dubboSPI实现思想跟javaspi的思想差不多javaspi是ServiceLoad而dubbo自己写的是ExtensionLoader SPI接口定义 @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) public @interface SPI { St...
dubbo原理之dubbo SPI
LengWJ、的博客
12-26 266
本节目的：Dubbo SPI是dubbo所有扩展机制的核心，所以非常之重要！！所以为了让大家全面的了解dubbo SPI机制，见见结合dubbo源码以及官网，整理了dubbo spi机制。以及对比Java原生的spi，dubbo spi的其他特性。本章所有案例代码已经上传https://github.com/lengweijian/dubbo.git . lazy的小伙伴儿可以自行下载调试。 1、...
Dubbo系列4：SPI原理
纵横千里 捭阖四方 的专栏
04-12 143
1.什么是Java的SPI 就是将接口的实现类都写在一个默认的配置文件里，然后Java会自动加载该文件，然后创建出对应的对象，和Spring的bean配置实现了一样的功能。其实这个也是IOC和AOP一样的功能。不过这个是由Java的类装载器来做的，而Spring是自己做的。 装逼点说法是 ：SPI 全称为 (Service Provider Interface) ,是JDK内置的一种服务提供发现机制。 一个服务(Service)通常指的是已知的接口或者抽象类，服务提供方就是对这个接口或者抽象类的实现，然后按
Dubbo笔记衍生篇②：Dubbo SPI 原理
猫吻鱼的博客
03-15 3510
一、前言 Dubbo 为每一个功能点提供了一个SPI 扩展接口。而为了为了不加载不使用SPI 实例，Dubbo通过适配器模式和动态编译技术，加载指定的SPI 实现。 二、Dubbo适配器原理 二、动态编译 众所周知，Java 程序想要运行首先需要将Java源代码编译成字节码文件，然后JVM把字节码文件加载到内存创建Class 对象后，使用Class对象创建实例。 正常情况下，我们是将所有源文件编译为字节码文件，然后由JVM统一加载，而动态编译则是在JVM进程运行时把源文件编译为字节码文件，然后使用字节码文件
Dubbo的Spi机制实现原理
weixin_46300935的博客
05-14 304
1.简介 SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口加载实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。不过，Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足需求。在 Du
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值