（三）Spring关键接口之工厂相关接口

原创 于 2020-06-22 15:05:12 发布 · 500 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #spring #ioc

本文深入探讨Spring框架中Bean的生命周期，详细讲解了FactoryBean、InitializingBean、BeanFactoryAware、BeanPostProcessor、BeanFactoryPostProcessor等关键接口的源码及调用流程，帮助读者理解Bean的创建、初始化及自定义处理过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

1.FactoryBean接口

2.InitializingBean接口

3.BeanFactoryAware接口

4.BeanPostProcessor接口

5.BeanFactoryPostProcessor接口及其子类接口

5.1 BeanFactoryPostProcessor接口

5.2 BeanDefinitionRegistryPostProcessor接口

5.3 接口的调用方法链

6.AutowireCapableBeanFactory接口

7.SmartInitializingSingleton接口

本系列一共四篇，其它三篇传送门：

1.FactoryBean接口

接口源码如下：

public interface FactoryBean<T> {
   @Nullable
   T getObject() throws Exception;
   @Nullable
   Class<?> getObjectType();
   default boolean isSingleton() {
      return true;
   }
}

接口说明：这个接口如字面意思，工厂Bean，意思即为它是一个工厂类型的Bean，管理的是某一个类型Bean的工厂，和BeanFactory作为Spring容器核心的所有Bean工厂有着巨大的差别。如Mybatis集成Spring中，SqlSessionFactory有个工厂Bean为SqlSessionFactoryBean，这个类作用即为管理SqlSessionFactory这一类型的工厂Bean，只生产SqlSessionFactory。

2.InitializingBean接口

接口源码如下：

public interface InitializingBean {
   void afterPropertiesSet() throws Exception;
}

接口说明：该接口是在调用BeanPostProcessor的方法Before之后，在调用After方法之前，具体作用为在Bean实例化并且将属性赋完值之后进行特定的处理，如某个Bean需要在其成员属性赋值后利用某些属性进行某种初始化的操作（如Mybatis和Spring集成便是利用了这个接口来帮助实例化Mybatis的SqlSessionFactory，从而完成集成）。

调用方法链如下：

public abstract class AbstractApplicationContext 
        extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    public void refresh() throws BeansException, IllegalStateException {
        ...
        // 初始化所有非延迟加载的单例类
        finishBeanFactoryInitialization(beanFactory);
        ...
    }
    protected void finishBeanFactoryInitialization(
            ConfigurableListableBeanFactory beanFactory) {
        ...
        beanFactory.preInstantiateSingletons();
    }
}
public class DefaultListableBeanFactory 
        extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry,
        Serializable {
    @Override
    public void preInstantiateSingletons() throws BeansException {
        ...
        for (String beanName : beanNames) {
           RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
           ...
           getBean(beanName);
           ...
       }
        ...
    }
}
public abstract class AbstractBeanFactory 
        extends FactoryBeanRegistrySupport 
        implements ConfigurableBeanFactory {
    @Override
    public Object getBean(String name) throws BeansException {
       return doGetBean(name, null, null, false);
    }
    protected <T> T doGetBean(final String name, 
            @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) 
                    throws BeansException {
        if (sharedInstance != null && args == null) {
            ...
        } else {
            ...
            if (mbd.isSingleton()) {
               sharedInstance = getSingleton(beanName, () -> {
                   return createBean(beanName, mbd, args);
               }
            }
            ...
        }
        ...
    }
public class DefaultSingletonBeanRegistry 
        extends SimpleAliasRegistry implements SingletonBeanRegistry {
    public Object getSingleton(String beanName, 
            ObjectFactory<?> singletonFactory) {
        ...
        singletonObject = singletonFactory.getObject();
        ...
    }
}
public abstract class AbstractAutowireCapableBeanFactory 
        extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, 
            @Nullable Object[] args) {
        ...
        try {
           Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        }
       ...
    }
    protected Object doCreateBean(final String beanName, 
            final RootBeanDefinition mbd, final @Nullable Object[] args)
                    throws BeanCreationException {
        ...
        try {
           populateBean(beanName, mbd, instanceWrapper);
           exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        ...
    }
    protected Object initializeBean(final String beanName, 
            final Object bean, @Nullable RootBeanDefinition mbd) {
        ...
        try {
           invokeInitMethods(beanName, wrappedBean, mbd);
        }
        ...
    }
    protected void invokeInitMethods(String beanName, final Object bean, 
            @Nullable RootBeanDefinition mbd) throws Throwable {
        ...
        if (System.getSecurityManager() != null) {
           try {
              AccessController.doPrivileged(
                      (PrivilegedExceptionAction<Object>) () -> {
                 ((InitializingBean) bean).afterPropertiesSet();
                 return null;
              }, getAccessControlContext());
           }
           catch (PrivilegedActionException pae) {
              throw pae.getException();
           }
        }
        else {
           ((InitializingBean) bean).afterPropertiesSet();
        }
        ...
    }
}

3.BeanFactoryAware接口

接口源码如下：

public interface BeanFactoryAware extends Aware {
   void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}

接口说明：类似于ApplicationContextAware接口，只是该接口的参数是beanFactory，而另外一个接口的参数是applicationContext，其次其调用路径也不太一样，BeanFactoryAware接口将会在ApplicationContextAware之前调用，因为ApplicationContextAware是在BeanPostProcessor接口的postProcessBeforeInitialization方法中被调用的，而BeanFactoryAware是在initializeBean方法中一进去就调用的。

其调用链如下：

public abstract class AbstractApplicationContext 
        extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    public void refresh() throws BeansException, IllegalStateException {
        ...
        // 初始化所有非延迟加载的单例类
        finishBeanFactoryInitialization(beanFactory);
        ...
    }
    protected void finishBeanFactoryInitialization(
            ConfigurableListableBeanFactory beanFactory) {
        ...
        beanFactory.preInstantiateSingletons();
    }
}
public class DefaultListableBeanFactory 
        extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry,
        Serializable {
    @Override
    public void preInstantiateSingletons() throws BeansException {
        ...
        for (String beanName : beanNames) {
           RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
           ...
           getBean(beanName);
           ...
       }
        ...
    }
}
public abstract class AbstractBeanFactory 
        extends FactoryBeanRegistrySupport 
        implements ConfigurableBeanFactory {
    @Override
    public Object getBean(String name) throws BeansException {
       return doGetBean(name, null, null, false);
    }
    protected <T> T doGetBean(final String name, 
            @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) 
                    throws BeansException {
        if (sharedInstance != null && args == null) {
            ...
        } else {
            ...
            if (mbd.isSingleton()) {
               sharedInstance = getSingleton(beanName, () -> {
                   return createBean(beanName, mbd, args);
               }
            }
            ...
        }
        ...
    }
public class DefaultSingletonBeanRegistry 
        extends SimpleAliasRegistry implements SingletonBeanRegistry {
    public Object getSingleton(String beanName, 
            ObjectFactory<?> singletonFactory) {
        ...
        singletonObject = singletonFactory.getObject();
        ...
    }
}
public abstract class AbstractAutowireCapableBeanFactory 
        extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, 
            @Nullable Object[] args) {
        ...
        try {
           Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        }
       ...
    }
    protected Object doCreateBean(final String beanName, 
            final RootBeanDefinition mbd, final @Nullable Object[] args)
                    throws BeanCreationException {
        ...
        try {
           populateBean(beanName, mbd, instanceWrapper);
           exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        ...
    }
    protected Object initializeBean(final String beanName, 
            final Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
           AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
              invokeAwareMethods(beanName, bean);
              return null;
           }, getAccessControlContext());
        }
        else {
           invokeAwareMethods(beanName, bean);
        }
        ...
    }
    private void invokeAwareMethods(final String beanName, 
            final Object bean) {
       if (bean instanceof Aware) {
          if (bean instanceof BeanNameAware) {
             ((BeanNameAware) bean).setBeanName(beanName);
          }
          if (bean instanceof BeanClassLoaderAware) {
             ClassLoader bcl = getBeanClassLoader();
             if (bcl != null) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
             }
          }
          if (bean instanceof BeanFactoryAware) {
             ((BeanFactoryAware) bean)
                 .setBeanFactory(AbstractAutowireCapableBeanFactory.this);
          }
       }
    }
}

特别说明：只介绍了BeanFactoryAware，其它两个接口不怎么用，因此便不做介绍。

4.BeanPostProcessor接口

接口源码如下：

public interface BeanPostProcessor {
   @Nullable
   default Object postProcessBeforeInitialization(Object bean, 
           String beanName) throws BeansException {
      return bean;
   }
   @Nullable
   default Object postProcessAfterInitialization(Object bean, 
           String beanName) throws BeansException {
      return bean;
   }
}

接口说明：该接口的作用是在bean对象实例化之前和实例化之后对bean对象进行自定义逻辑处理操作。如我们生成某个bean之后需要对这一类的bean进行代理，那么就可以实现该接口，并且在postProcessAfterInitialization()方法中加入自定义代理的逻辑，将bean变成代理对象。其实际应用例子则是Spring-AOP包中的AbstractAdvisingBeanPostProcessor类，就是将实例化之后的bean进一步用代理对象封装。

其调用链如下：

public abstract class AbstractApplicationContext 
        extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    public void refresh() throws BeansException, IllegalStateException {
        ...
        // 初始化所有非延迟加载的单例类
        finishBeanFactoryInitialization(beanFactory);
        ...
    }
    protected void finishBeanFactoryInitialization(
            ConfigurableListableBeanFactory beanFactory) {
        ...
        beanFactory.preInstantiateSingletons();
    }
}
public class DefaultListableBeanFactory 
        extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry,
        Serializable {
    @Override
    public void preInstantiateSingletons() throws BeansException {
        ...
        for (String beanName : beanNames) {
           RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
           ...
           getBean(beanName);
           ...
       }
        ...
    }
}
public abstract class AbstractBeanFactory 
        extends FactoryBeanRegistrySupport 
        implements ConfigurableBeanFactory {
    @Override
    public Object getBean(String name) throws BeansException {
       return doGetBean(name, null, null, false);
    }
    protected <T> T doGetBean(final String name, 
            @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) 
                    throws BeansException {
        if (sharedInstance != null && args == null) {
            ...
        } else {
            ...
            if (mbd.isSingleton()) {
               sharedInstance = getSingleton(beanName, () -> {
                   return createBean(beanName, mbd, args);
               }
            }
            ...
        }
        ...
    }
public class DefaultSingletonBeanRegistry 
        extends SimpleAliasRegistry implements SingletonBeanRegistry {
    public Object getSingleton(String beanName, 
            ObjectFactory<?> singletonFactory) {
        ...
        singletonObject = singletonFactory.getObject();
        ...
    }
}
public abstract class AbstractAutowireCapableBeanFactory 
        extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, 
            @Nullable Object[] args) {
        ...
        try {
           Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        }
       ...
    }
    protected Object doCreateBean(final String beanName, 
            final RootBeanDefinition mbd, final @Nullable Object[] args)
                    throws BeanCreationException {
        ...
        try {
           populateBean(beanName, mbd, instanceWrapper);
           exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        ...
    }
    protected Object initializeBean(final String beanName, 
            final Object bean, @Nullable RootBeanDefinition mbd) {
        ...
        if (mbd == null || !mbd.isSynthetic()) {
           wrappedBean = 
                   applyBeanPostProcessorsBeforeInitialization(wrappedBean,
                           beanName);
        }
        ...
    }
    public Object applyBeanPostProcessorsBeforeInitialization(
            Object existingBean, String beanName)
            throws BeansException {
       ...
       for (BeanPostProcessor processor : getBeanPostProcessors()) {
          Object current = processor
                  .postProcessBeforeInitialization(result, beanName);
          ...
       }
    }
    public Object postProcessBeforeInitialization(final Object bean, 
            String beanName) throws BeansException {
        ...
        if (mbd == null || !mbd.isSynthetic()) {
           wrappedBean = 
                   applyBeanPostProcessorsBeforeInitialization(wrappedBean,
                           beanName);
        }
        ...
        if (mbd == null || !mbd.isSynthetic()) {
           wrappedBean = 
                   applyBeanPostProcessorsAfterInitialization(wrappedBean,
                           beanName);
        }
        ...
    }
    @Override
    public Object applyBeanPostProcessorsBeforeInitialization(
            Object existingBean, String beanName) throws BeansException {
       Object result = existingBean;
       for (BeanPostProcessor processor : getBeanPostProcessors()) {
          Object current = processor
                  .postProcessBeforeInitialization(result, beanName);
          if (current == null) {
             return result;
          }
          result = current;
       }
       return result;
    }
    @Override
    public Object applyBeanPostProcessorsAfterInitialization(
            Object existingBean, String beanName) throws BeansException {
       Object result = existingBean;
       for (BeanPostProcessor processor : getBeanPostProcessors()) {
          Object current = processor
                  .postProcessAfterInitialization(result, beanName);
          if (current == null) {
             return result;
          }
          result = current;
       }
       return result;
    }
}

5.BeanFactoryPostProcessor接口及其子类接口

5.1 BeanFactoryPostProcessor接口

接口源码如下：

public interface BeanFactoryPostProcessor {
   void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
           throws BeansException;
}

接口说明：参数只支持ConfigurableListableBeanFactory及其子类，功能为对BeanDefinition进行额外的定制处理，最常见的便是对@Configuration中的@Bean和@Impoart等注解进行处理的ConfigurationClassPostProcessor类，会将其中被注解注释的方法等Bean定义进行额外的封装解析处理。

5.2 BeanDefinitionRegistryPostProcessor接口

接口源码如下：

public interface BeanDefinitionRegistryPostProcessor 
        extends BeanFactoryPostProcessor {
   void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 
           throws BeansException;
}

接口说明：该接口继承了BeanFactoryPostProcessor接口，其父接口使用有一定的局限性，便是参数只支持beanFactory，但是不支持Spring的注册中心BeanDefinitionRegistry，因此便诞生了这个接口来完善这个缺点，同时也可以实现灵活性。上面所说的ConfigurationClassPostProcessor类实现的便是这个接口，支持beanFactory和registry。

5.3 接口的调用方法链

调用方法链大致源码如下：

public abstract class AbstractApplicationContext 
        extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    @Override
    public void refresh() throws BeansException, IllegalStateException {
        ...
        invokeBeanFactoryPostProcessors(beanFactory);
        ...
    }
    protected void invokeBeanFactoryPostProcessors(
            ConfigurableListableBeanFactory beanFactory) {
       PostProcessorRegistrationDelegate
               .invokeBeanFactoryPostProcessors(beanFactory, 
                       getBeanFactoryPostProcessors());
       ...
    }
}
final class PostProcessorRegistrationDelegate {
    public static void invokeBeanFactoryPostProcessors(
            ConfigurableListableBeanFactory beanFactory, 
            List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        ...
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = 
                    (BeanDefinitionRegistry) beanFactory;
            List<BeanFactoryPostProcessor> regularPostProcessors = 
                    new ArrayList<>();
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = 
                    new ArrayList<>();
            
            for (BeanFactoryPostProcessor postProcessor : 
                    beanFactoryPostProcessors) {
               if (postProcessor instanceof 
                       BeanDefinitionRegistryPostProcessor) {
                  BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor)postProcessor;
                  registryProcessor
                          .postProcessBeanDefinitionRegistry(registry);
                  registryProcessors.add(registryProcessor);
               }
               else {
                  regularPostProcessors.add(postProcessor);
               }
            }
            ...
            invokeBeanDefinitionRegistryPostProcessors(
                    currentRegistryProcessors, registry);
            ...
            invokeBeanFactoryPostProcessors(registryProcessors, 
                    beanFactory);
            ...
        } else {
            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, 
                    beanFactory);
        }
        ...
    }
    private static void invokeBeanDefinitionRegistryPostProcessors(
            Collection<? extends BeanDefinitionRegistryPostProcessor> 
                    postProcessors, BeanDefinitionRegistry registry) {
       for (BeanDefinitionRegistryPostProcessor postProcessor : 
               postProcessors) {
          postProcessor.postProcessBeanDefinitionRegistry(registry);
       }
    }
    private static void invokeBeanFactoryPostProcessors(
            Collection<? extends BeanFactoryPostProcessor> postProcessors, 
            ConfigurableListableBeanFactory beanFactory) {
        for (BeanFactoryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanFactory(beanFactory);
        }
    }
}

特别说明：在invokeBeanFactoryPostProcessors方法中多次调用了BeanFactoryPostProcessor接口方法的使用者invokeBeanFactoryPostProcessors方法，但是并未标记出来，有兴趣的可以看一下源码，领会一下参数beanFactoryPostProcessors和beanFactory中的PostProcessor以及实现了接口PriorityOrdered和Ordered的实现调用先后顺序。

6.AutowireCapableBeanFactory接口

接口源码如下：

public interface AutowireCapableBeanFactory extends BeanFactory {
   int AUTOWIRE_NO = 0;
   int AUTOWIRE_BY_NAME = 1;
   int AUTOWIRE_BY_TYPE = 2;
   int AUTOWIRE_CONSTRUCTOR = 3;
   @Deprecated
   int AUTOWIRE_AUTODETECT = 4;
   String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";
   
   <T> T createBean(Class<T> beanClass) throws BeansException;
   void autowireBean(Object existingBean) throws BeansException;
   Object configureBean(Object existingBean, String beanName) 
           throws BeansException;
           
   Object createBean(Class<?> beanClass, int autowireMode, 
           boolean dependencyCheck) throws BeansException;
   Object autowire(Class<?> beanClass, int autowireMode, 
           boolean dependencyCheck) throws BeansException;
   void autowireBeanProperties(Object existingBean, int autowireMode, 
           boolean dependencyCheck) throws BeansException;
   void applyBeanPropertyValues(Object existingBean, String beanName) 
           throws BeansException;
   Object initializeBean(Object existingBean, String beanName) 
           throws BeansException;
   Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, 
           String beanName)
         throws BeansException;
   Object applyBeanPostProcessorsAfterInitialization(Object existingBean, 
           String beanName)
         throws BeansException;
   void destroyBean(Object existingBean);
}

该接口一共分为三类接口，但现在我们只介绍两类接口：

  1. 用于创建和填充外部bean实例的典型方法：createBean、autowireBean和configureBean；
  2. 用于对bean生命周期进行细粒度控制的专门方法：上述代码中除去上面三个方法剩余的方法。

接下来详细介绍一下这个接口的部分方法：

第一种：用于创建和填充外部bean实例的典型方法

  • <T> T createBean(Class<T> beanClass)：该方法的作用便是只需要给定一个beanClass，指定需要创建bean的类型，则直接创建一个实例化好的bean；
  • void autowireBean(Object existingBean)：通过应用实例化后回调和bean属性处理后来填充给定的bean实例(例如，对于注释驱动的注入)，具体表现为创建被@Autowired注解注释的类成员变量；

第二种：用于对bean生命周期进行细粒度控制的专门方法

  • void applyBeanPropertyValues(Object existingBean, String beanName)：设置bean所存在的各种成员变量属性；
  • Object initializeBean(Object existingBean, String beanName)：开始实例化bean；
  • Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)：在实例化bean之前进行一些特殊的前置处理，其中会调用BeanPostProcessor接口的postProcessBeforeInitialization()方法；
  • Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)：在实例化bean之后进行一些特殊的后置处理，其中会调用BeanPostProcessor接口的postProcessAfterInitialization()方法。

7.SmartInitializingSingleton接口

接口源码如下：

public interface SmartInitializingSingleton {
   void afterSingletonsInstantiated();
}

接口说明：从其接口方法名字便能够看出来这个方法是在单例对象被Spring实例化之后被调用。这个接口一般使用得少，Spring官方对于这个接口的使用率远远低于PostProcessor那一系列接口，但Spring的思想便是为了给开发者提供更多的选择性，至于如何使用便看个人了。比较著名的集成可能也就WebSocket吧，有兴趣可以去看下。

其调用方法链如下：

public abstract class AbstractApplicationContext 
        extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    @Override
    public void refresh() throws BeansException, IllegalStateException {
        ...
        finishBeanFactoryInitialization(beanFactory);
        ...
    }
    protected void finishBeanFactoryInitialization(
            ConfigurableListableBeanFactory beanFactory) {
        ...
        beanFactory.preInstantiateSingletons();
    }
}
public class DefaultListableBeanFactory 
        extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, 
                BeanDefinitionRegistry, Serializable {
    @Override
    public void preInstantiateSingletons() throws BeansException {
        ...
        for (String beanName : beanNames) {
           Object singletonInstance = getSingleton(beanName);
           if (singletonInstance instanceof SmartInitializingSingleton) {
              final SmartInitializingSingleton smartSingleton = 
                      (SmartInitializingSingleton) singletonInstance;
              if (System.getSecurityManager() != null) {
                 AccessController.doPrivileged((PrivilegedAction<Object>) 
                 () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                 }, getAccessControlContext());
              }
              else {
                 smartSingleton.afterSingletonsInstantiated();
              }
           }
        }
    }
}

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值