Spring高级49讲-第五讲：BeanFactory后处理器

最新推荐文章于 2024-07-08 18:16:19 发布
最新推荐文章于 2024-07-08 18:16:19 发布
阅读量232 收藏 1
点赞数
分类专栏： spring高级49讲 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52574640/article/details/124899467
版权

第五讲：BeanFactory后处理器

学习目标

1.BeanFactory后处理器的作用：为BeanFactory提供扩展功能

2.常见的BeanFactory后处理器

准备工作

主类

package com.itheima.a5;

import com.itheima.a5.mapper.Mapper1;
import com.itheima.a5.mapper.Mapper2;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

import java.io.IOException;

/*
    BeanFactory 后处理器的作用
 */
public class A05 {
    private static final Logger log = LoggerFactory.getLogger(A05.class);

    public static void main(String[] args) throws IOException {

        // ⬇️GenericApplicationContext 是一个【干净】的容器
        GenericApplicationContext context = new GenericApplicationContext();
        //注册了一个config的bean
        context.registerBean("config", Config.class);
      
      
        // ⬇️初始化容器
        context.refresh();

        for (String name : context.getBeanDefinitionNames()) {
            System.out.println(name);
        }


        // ⬇️销毁容器
        context.close();


    }
}

配置类

package com.itheima.a5;

import com.alibaba.druid.pool.DruidDataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
@ComponentScan("com.itheima.a5.component")
public class Config {
    @Bean
    public Bean1 bean1() {
        return new Bean1();
    }

    @Bean    //mybatis的sql服务器工厂类
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }
    //初始化方法
    @Bean(initMethod = "init")
    public DruidDataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }


}

package com.itheima.a5.component;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
public class Bean1 {

    private static final Logger log = LoggerFactory.getLogger(Bean2.class);

    public Bean1() {
        log.debug("我被 Spring 管理啦");
    }
}

package com.itheima.a5.component;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
public class Bean2 {

    private static final Logger log = LoggerFactory.getLogger(Bean2.class);

    public Bean2() {
        log.debug("我被 Spring 管理啦");
    }
}
这样执行主方法
得到结果是 config

 

      主要原因是我们没有添加BeanFactory的后处理器 无法识别@Configuration  @ComponentScan @Bean @Componet等注解

一、BeanFactory后处理器-ConfigurationClassPostProcessor（进行解析@Bean @Configuration @ComponetScan等）

 

二、MapperScannerConfigurer  解析@Mapper注解  

功能相当于mybatis的一个@MapperScan注解

加入两个类

package com.itheima.a5.mapper;


import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface Mapper1 {
}


package com.itheima.a5.mapper;


import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface Mapper2 {
}

三、工厂后处理器模拟实现-组件扫描  @Component注解

1.先通过注解的工具类找到@Component注解中的包名

2.通过这个容器的通配符类扫描到该包下的所有类

这里bean2 bean3是有@Component注解的 bean4是没有的

3.查找这些类中是否加入@Component注解

如果判断是Conponent的派生注解    @Service  @Controller等使用

 

 4.筛选出这些类中是否加入@Component注解及其派生类的注解

然后通过或者bean的名字和bean的信息 将其加载到beanFactory中

 

实现了没有使用beanFactory的后处理器也扫描到了bean2和bean3

四、工厂后处理器模拟实现-组件扫描  @Bean注解

package com.itheima.a5;

import com.alibaba.druid.pool.DruidDataSource;
import com.itheima.a5.component.Bean2;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
@ComponentScan("com.itheima.a5.component")
public class Config {

    private Bean2 bean2() {
        return new Bean2();
    }
    @Bean
    public Bean1 bean1() {
        return new Bean1();
    }

    @Bean    //mybatis的sql服务器工厂类
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }
    //初始化方法
    @Bean(initMethod = "init")
    public DruidDataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }


}

package com.itheima.a5;

import com.itheima.a5.mapper.Mapper1;
import com.itheima.a5.mapper.Mapper2;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.type.MethodMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Set;

/*
    BeanFactory 后处理器的作用
 */
public class A05 {
    private static final Logger log = LoggerFactory.getLogger(A05.class);

    public static void main(String[] args) throws IOException {

        // ⬇️GenericApplicationContext 是一个【干净】的容器
        GenericApplicationContext context = new GenericApplicationContext();
        //注册了一个config的bean
        context.registerBean("config", Config.class);

        CachingMetadataReaderFactory factory=new CachingMetadataReaderFactory();
        //读取Config类的元信息
        MetadataReader reader = factory.getMetadataReader(new ClassPathResource("com/itheima/a5/Config.class"));
        //读取被@Bean修饰的方法信息
        Set<MethodMetadata> annotatedMethods = reader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
        for (MethodMetadata metadata : annotatedMethods) {
            System.out.println(metadata);
        }
        // ⬇️初始化容器
        context.refresh();
        for (String name : context.getBeanDefinitionNames()) {
            System.out.println(name);
        }


        // ⬇️销毁容器
        context.close();

     
    }
}

 结果为

 

package com.itheima.a5;

import com.itheima.a5.mapper.Mapper1;
import com.itheima.a5.mapper.Mapper2;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.type.MethodMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Set;

/*
    BeanFactory 后处理器的作用
 */
public class A05 {
    private static final Logger log = LoggerFactory.getLogger(A05.class);

    public static void main(String[] args) throws IOException {

        // ⬇️GenericApplicationContext 是一个【干净】的容器
        GenericApplicationContext context = new GenericApplicationContext();
        //注册了一个config的bean
        context.registerBean("config", Config.class);

        CachingMetadataReaderFactory factory=new CachingMetadataReaderFactory();
        //读取Config类的元信息
        MetadataReader reader = factory.getMetadataReader(new ClassPathResource("com/itheima/a5/Config.class"));
        //读取被@Bean修饰的方法信息
        Set<MethodMetadata> annotatedMethods = reader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
        for (MethodMetadata metadata : annotatedMethods) {
            System.out.println(metadata);
            BeanDefinitionBuilder builder =BeanDefinitionBuilder.genericBeanDefinition();
            //将这些@Bean修饰的方法  加入到congfig类中
            builder.setFactoryMethodOnBean(metadata.getMethodName(),"config");
            //自动装配
            builder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
            AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
            context.getDefaultListableBeanFactory().registerBeanDefinition(metadata.getMethodName(),beanDefinition);
        }
        // ⬇️初始化容器
        context.refresh();
        for (String name : context.getBeanDefinitionNames()) {
            System.out.println(name);
        }


        // ⬇️销毁容器
        context.close();

        /*
            学到了什么
                a. @ComponentScan, @Bean, @Mapper 等注解的解析属于核心容器(即 BeanFactory)的扩展功能
                b. 这些扩展功能由不同的 BeanFactory 后处理器来完成, 其实主要就是补充了一些 bean 定义
         */
    }
}

 

得到结果我们发现是没有 初始化的 我么要进行设置才行

 

 

 

五、工厂后处理器模拟实现-组件扫描  @Mapper注解

最基本的原理是

//    @Bean
//    public MapperFactoryBean <Mapper1> mapper1(SqlSessionFactory sqlSessionFactory){
//        MapperFactoryBean< Mapper1> factory=new MapperFactoryBean<>(Mapper1.class);
//        factory.setSqlSessionFactory(sqlSessionFactory);
//        return  factory;
//    }

但是这种的缺点是 要一个一个的写，因此我们写一个扫描包下所以的接口

package com.itheima.a5;

import org.mybatis.spring.mapper.MapperFactoryBean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;

import java.io.IOException;

public class MapperPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanFactory) throws BeansException {
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        try {
            //通过路径 得到资源数组
            Resource[] resources = resolver.getResources("classpath:com/itheima/a5/mapper/**/*.class");
            //创建注解声明名字的生产者的对象
            AnnotationBeanNameGenerator beanNameGenerator=new AnnotationBeanNameGenerator();
            //获取元信息的
            CachingMetadataReaderFactory metadataReaderFactory=new CachingMetadataReaderFactory();
            for (Resource resource : resources) {
                //获取资源中的元信息
                MetadataReader reader = metadataReaderFactory.getMetadataReader(resource);
                //资源中的类的元信息
                ClassMetadata classMetadata = reader.getClassMetadata();
                //判断是否是接口
                if (classMetadata.isInterface()) {
                    //获得bean的表示  即蓝图
                    AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.
                            genericBeanDefinition(MapperFactoryBean.class).
                            addConstructorArgValue(classMetadata.getClassName())
                            .setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE).getBeanDefinition();
                    //这里不能用上面的beanDefiition来获取名称  因为上面描述的bean 产生的MapperFactoryBean的名称
                    //因此这里新创建了一个beanDefinition1  ，利用的是接口名称的bean
                    AbstractBeanDefinition beanDefinition1 = BeanDefinitionBuilder.genericBeanDefinition(classMetadata.getClassName()).getBeanDefinition();
                    String s = beanNameGenerator.generateBeanName(beanDefinition1, beanFactory);
                    beanFactory.registerBeanDefinition(s,beanDefinition);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}

最后得到了mapper1和mapper2

总结

     学到了什么

 a. @ComponentScan, @Bean, @Mapper 等注解的解析属于核心容器(即 BeanFactory)的扩展功能

 b. 这些扩展功能由不同的 BeanFactory 后处理器来完成, 其实主要就是补充了一些 bean 定义

Tokey_W
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Context内部知识：第1部分-刷新
04-05
在Java Spring框架中，Spring Context，也称为ApplicationContext，是核心组件之一，它为Spring应用程序提供了上下文环境。本文将深入探讨Spring Context的刷新过程，帮助开发者理解这一关键功能的内部工作原理。 ...
Spring原理学习（三）BeanFactory后处理器
小鲁蛋的博客
11-03 545
ComponentScan, @Bean, @Mapper 等注解的解析属于核心容器（即 BeanFactory）的扩展功能这些扩展功能由不同的 BeanFactory 后处理器来完成，其实主要就是补充了一些 bean 定义。
【第五讲】BeanFactory 后处理器
disguiseR
08-09 506
实现BeanFactoryPostProcessor两处修改}try {// 模拟@ComponentScan ComponentScan componentScan = AnnotationUtils . findAnnotation(Config . class , ComponentScan . class);= null) {
spring源码-3.beanFactory后处理器
mazhen1991的博客
08-31 1324
上一节我们已经讲完了beanFactory是如何初始化，并且是如何将需要注入到容器中的bean的beanDefinition注册到beanFactory中的。这一节我们再来看一下beanFactory的后处理器是如何运行的。 这里从初始化完beanFactory到beanFactory的后处理器的执行有三步： beanFactory的准备工作 自定义方法对beanFactory中的后处理器在执行...
Spring——BeanFactory的后置处理器
zl13101758272的博客
07-11 1121
文章目录BeanFactory的后置处理器1. BeanFactory的后置处理器是什么？2. BeanFactory的后置处理器分类3. BeanFactory的后置处理器使用3.1 BeanDefinitionRegistryPostProcessor 带注册功能的3.2 BeanFactoryPostProcessor 不带注册功能的4. BeanFactory的后置处理器IOC加载顺序。4.1 Spring自带的BeanFactory的后置处理器。4.2 自定义的BeanFactory的后置处理器。
Spring之BeanFactory后置处理器
tututuyang的博客
07-26 771
Spring之BeanFactory后置处理器 写在前面 BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作 BeanFactoryPostProcessor => BeanFactory后置处理器 在beanFactory标准初始化之后调用 所有的bean定义已经保存加载到beanFactory，bean实例对象还没有创建出来的时候执行 demo测试 在看源码之前，先写个demo测试一下 自定义一个MyBeanFactoryPostProce
第二十章 Spring 应用上下文生命周期（ApplicationContext Lifecycle）1
08-04
在Spring框架中，ApplicationContext是应用的核心，它管理着所有Bean的生命周期。本章将深入探讨Spring应用上下文的生命周期，从启动准备阶段到关闭阶段，包括各个关键步骤和相关组件的作用。 1. **Spring 应用上...
Spring in Action(第2版)中文版
04-09
第5章使用数据库 5.1spring的数据访问哲学 5.1.1了解spring数据访问的异常体系 5.1.2数据访问的模板化 5.1.3使用dao支持类 5.2配置数据源 5.2.1使用jndi数据源 5.2.2使用数据源连接池 5.2.3基于jdbc驱动的...
spring源码深度解析(包含所有spring源码，带全部的注释以及案例，很适合入门级)
07-16
5. **MVC**：Spring MVC是Spring提供的Web应用开发框架，它包含处理器映射、视图解析、模型-视图-控制器模式的实现。关键类如`DispatcherServlet`、`HandlerMapping`和`ModelAndView`。 6. **Spring Boot**：Spring...
Spring in Action(第二版 中文高清版).part2
03-16
第5章 使用数据库 5.1 Spring的数据访问哲学 5.1.1 了解Spring数据访问的异常体系 5.1.2 数据访问的模板化 5.1.3 使用DAO支持类 5.2 配置数据源 5.2.1 使用JNDI数据源 5.2.2 使用数据源连接池 5.2.3 基于...
【Spring学习24】容器扩展点：后置处理器BeanFactoryPostProcessor
程序老兵的博客
04-06 4749
上篇说到的BeanPostProcessor(Bean后置处理器)常用在对bean内部的值进行修改；实现Bean的动态代理等。 BeanFactoryPostProcessor和BeanPostProcessor都是spring初始化bean时对外暴露的扩展点。但它们有什么区别呢？ 由《理解Bean生命周期》的图可知：BeanFactoryPostProcessor是生命周期中最早被调用的，远远
Spring5学习笔记05--BeanFactory后处理器
qingqingxiangyang的博客
09-07 176
BeanFactory 后处理器的作用： 为 BeanFactory 提供扩展 ，分析 ConfigurationClassPostProcessor 后处理器
Spring BeanFactory后置处理器详解之配置类解析过程
JAVA技术爱好者
11-09 962
Spring BeanFactory后置处理器详解之配置类解析过程BeanFactoryPostProcessor实现方式BeanFactory后置处理器源码分析invokeBeanFactoryPostProcessors分析 BeanFactoryPostProcessor BeanFactoryPostProcessor是spring的一大核心，也是一个扩展点之一，spring的配置类扫描解析就是使用了BeanFactoryPostProcessor来实现的；spring中的两大扩展点之一就是Bean
bean的后处理器和beanfactory的后处理器、Aware和InitializingBean、初始化和销毁
运气不好努力来凑
05-24 939
bean的后处理器和beanfactory的后处理器、Aware和InitializingBean、初始化和销毁
BeanFactoryPostProcessor后置处理器
python15397的博客
06-26 214
在springboot出现之前，spring一般都是通过读取我们编写的xml文件来创建Bean的，在标签中我们需要定义Bean的类型以及属性等有关于描述Bean的信息，BeanFactory就是通过这些信息来定义一个Bean的，在Bean初始化的过程中，Bean的属性都会被赋予对应类型的默认值，比如，String类型属性默认值就是null，一般引用类型的默认值都是null。那有没有办法不让Bean的某个属性不去默认值而取我们自定义的值呢？答案是BeanFactoryPostProcessor后置...
springboot基于Java的超市进销存系统+ LW+ PPT+源码+讲解
u014445459的博客
07-06 647
操作的多样性也变高了。由此可见，本系统在操作上是可行的。软件测试的方法有好几种，但目前主要采用的是包括以功能为主要测试方向的黑盒测试以及以逻辑为主要测试方向的白盒测试，这是两种不同的测试方法，针对的测试侧重点不同，本课题根据实际需求情况，选择以功能为主要的黑盒测试方法，同时测试是要遵循一定的规则来执行的，一个测试要执行其执行的依据一般是由测试用例来规定的，而测试用例一般是依据需求或说明书来综合制定的，测试在硬件出厂前是十分重要的一个过程，本课题由于时间和精力的关系，选择以实现的功能作为测试要点来进行测试。
学习springMVC
weixin_45621552的博客
07-03 512
JSR全称为 Java Specification Requests，表示 Java 规范提案。JSR-303是 Java 为 Java Bean 数据合法性校验提供的标准框架，它定义了一套可标注在成员变量，属性方法上的校验注解。Hibernate Validatior提供了这套标准的实现。-- 最新7.0.1.Final --> </ dependency >-- 最新7.0.1.Final --> </ dependency ></
基于Java+SpringMvc+Vue技术智慧校园系统设计与实现--60页及以上论文参考
mr_lili_111的博客
07-05 680
Java是一种面向对象的编程语言，目前由美国Oracle公司开发。自1995年上线以来，已经广泛应用于Web开发、桌面应用开发等多个领域。Java语言的特点包括：1、面向对象：Java提供了类、接口和继承等面向对象的特性，支持单继承和多接口继承，以及动态绑定。2、分布式：Java支持Internet应用的开发，提供了网络应用编程接口(java.net)，支持RMI(远程方法激活)机制，适合开发分布式应用。3、健壮性：Java的强类型机制、异常处理、垃圾自动收集等特性保证了程序的健壮性。
【SpringBoot3】结合 gRpc 实现远程服务调用
最新发布
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
07-08 450
gRPC（Google Remote Procedure Call，Google远程过程调用）是一个现代开源高性能远程过程调用(RPC)框架，可以在任何环境中运行。它由Google开发，旨在帮助开发人员更轻松地构建分布式应用，特别是当代码可能在不同地方运行的时候。 gRPC是一个高性能、开源和通用的RPC框架，它基于HTTP/2设计，并支持多种编程语言和平台。 随着其开源和广泛应用，gRPC已成为云原生计算基金会(CNCF)的一个孵化项目，被大量组织和企业采用。
spring第二天.pdf
04-22
2. ApplicationContext家族接口：ApplicationContext是BeanFactory的高级版本，提供了更多的企业级服务，如国际化、事件发布、消息来源解析等。它是Spring框架中非常重要的接口，通常在实际应用中被广泛使用。 3. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值