【Spring基础之IOC】Spring IOC创建bean的几种方式

最新推荐文章于 2023-06-01 23:05:29 发布
最新推荐文章于 2023-06-01 23:05:29 发布
阅读量520 收藏 1
点赞数 1
分类专栏： Java相关 文章标签： java spring junit
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xwl137487622/article/details/128162555
版权

【Spring基础之IOC】Spring IOC创建bean的几种方式

这里写目录标题

一. 简介:

Spring是一个轻量开源级别的框架。
Spring的出现是为了解决企业级业务逻辑层面和其它层面之间的耦合。
Spring是一个基于IOC和AOP的框架，这两者是spring中最核心的功能。
			AOP: 面向切面编程，对代码层面进行增强，如spring事务
			IOC:  控制反转，避免过于复杂的对象创建，基于依赖倒置原则引入的一种设计思想。
			DI:  依赖注入，IOC的具体实现。
			容器: 负责集中化管理bean。

二.注册/创建bean的几种方式。

准备工作:
1.创建新的maven项目:在这里插入图片描述
在这里插入图片描述
2.引入相关的maven依赖

   <!-- 引入spring相关的依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!-- junit测试相关的依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

由于spring-context内部已经依赖了spring-beans，spring-core， spring-expression， spring-jcl 等相关jar包，所以只需要暂时引入spring-context包即可。

(一).基于纯xml创建bean的方式。

使用 XML 配置,可以让 bean 定义分布在多个 XML 文件上,这种方法直观优雅清晰明显. 通常,每个单独的 XML 配置文件代表架构中的一个逻辑层或模块. 这种配置方式在spring2.5之前非常常用。

实体类与测试类:

public class Student {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


public class Test {

    @org.junit.Test
    public void test01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring-ioc.xml");
        Student bean = context.getBean(Student.class);
        System.out.println(bean);
    }
}

xml配置:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean class="spring.ioc.Student" id="student"></bean>
</beans>

输出结果:
在这里插入图片描述

(二).基于xml的componentScan加上注解的方式

Spring 2.5 支持基于注解的元数据配置，通过配置componentScan来扫描标注了@Controller @Service @Repository @Component的类，将这些类注册成bean组件。

 @Controller
//@Service
//@Repository
//@Component
public class StudentController {
    @Value("李雷")
    private String name;

    public void say(){
        System.out.println("My name is " + name);
    }
   }

public class Test {
    @org.junit.Test
    public void test02(){
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring-ioc.xml");
        StudentController bean = context.getBean(StudentController.class);
        bean.say();
    }
}

xml配置:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="spring.ioc"></context:component-scan>
</beans>

测试:
在这里插入图片描述

(三).基于javaConfig(@Configuration)+ @Bean的方式注册bean

从 Spring 3.0 开始, 由 Spring JavaConfig 项目提供的功能已经成为 Spring 核心框架的一部分. 因此,你可以使用 Java 配置来代替 XML 配置定义外部 bean . 要使用这些新功能,请参阅 @Configuration, @Bean, @Import, 和 @DependsOn 注解.

Spring 的 Bean (至少一个) 由容器来管理,基于 XML 的元数据配置将这些 bean 配置为 元素.并放置于 元素内部. 基于 Java 的配置通常是使用 @Configuration 注解过的类中,在它的方法上使用 @Bean 注解.

这些 bean 定义会对应到构成应用程序的实际对象. 通常你会定义服务层对象,数据访问对象(DAOs) ,表示对象(如Struts Action 的实例),基础对象(如 Hibernate 的 SessionFactories, JMS Queues,) . 通常,不会在容器中配置细粒度的 domain 对象,因为创建和加载 domain 对象通常是 DAO 和业务逻辑的职责. 但是,你可以使用 Spring 与 AspectJ 集成独立于 IoC 容器来创建的对象,请参阅 Spring 使用 AspectJ 进行依赖注入 domain 对象.

通常在项目中使用到第三方的bean时，常常会使用这种方式，这种方式可以人工干预创建bean的过程，给开发带来了一定的便利性。

@Configuration
public class JavaConfigApp {
    @Bean
    public Student student(){
        return new Student();
    }
}


public class Student {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

测试:


public class Test {
    @org.junit.Test
    public void test03(){
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfigApp.class);
        Student bean = context.getBean(Student.class);
        System.out.println(bean);
    }

}

结果:
在这里插入图片描述

(四). 通过实现FactoryBean 来注册bean。

FactoryBean区别于BeanFacotory，它也是一个bean，通过getObject方法来手动创建真实的bean。实现BeanFactory接口需要实现三个方法。
getObject(): 自定义创建bean的方法。
getObjectType(): 注册返回bean的类型。
getSingleton(): 是否为单例bean。

public class Teacher {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
     @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}


@Component
public class TeacherBeanFactory implements FactoryBean<Teacher> {

    public Teacher getObject() throws Exception {
        Teacher t = new Teacher();
        t.setName("小明");
        return t;
    }

    public Class<?> getObjectType() {
        return Teacher.class;
    }

    public boolean isSingleton() {
        return true;
    }
}


@Configuration
@ComponentScan(basePackages = "spring.ioc")
public class JavaConfigApp {
}

测试:

 @org.junit.Test
    public void test05(){
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfigApp.class);
        Teacher bean = (Teacher) context.getBean("teacherBeanFactory");
        TeacherBeanFactory bean1 = (TeacherBeanFactory) context.getBean("&teacherBeanFactory");
        System.out.println(bean);
        System.out.println(bean1);
    }

结果:
在这里插入图片描述

重点注意: 如果根据注解标注类名首字母小写来获取bean，context.getBean(“teacherBeanFactory”)，这样获取到的是getObject创建的bean，如果需要获取原型bean，那么需要通过&teacherBeanFactory
方式，context.getBean(“&teacherBeanFactory”)。

(五).通过JavaConfig的(@Configuration) + @ComponentScan + 注解的方式注册bean

@Configuration
@ComponentScan(basePackages = "spring.ioc")
public class JavaConfigApp {

}

@Controller
//@Service
//@Repository
//@Component
public class StudentController {
    @Value("李雷")
    private String name;

    public void say(){
        System.out.println("My name is " + name);
    }
    }

测试:

    @org.junit.Test
    public void test04(){
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfigApp.class);
        StudentController bean = context.getBean(StudentController.class);
        System.out.println(bean);
    }

结果:
在这里插入图片描述

(六).通过@Configuration + @Import注解的方式创建bean

可以在@Configuration配置类中使用 @Import 注解直接导入需要注册成bean的类。这种方式不能人工干预bean的创建， 并且这种方式注册的bean名字并不是类名首字母小写，所以获取bean的时候需要使用类的全限定名或者根据类型获取 , 在需要注册成bean的类上不需要标注任何注解。

@Configuration
@Import(Teacher.class)
public class JavaConfigApp {
}


public class Teacher {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试:

public class Test {
//基于@Import + 需要注册的组件
    @org.junit.Test
    public void test06(){
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfigApp.class);
        for (String beanDefinitionName : context.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        Teacher bean = context.getBean(Teacher.class);
        System.out.println(bean);


         bean = (Teacher) context.getBean("spring.ioc.Teacher");
        System.out.println(bean);
    }
 }

结果:
在这里插入图片描述

(七).通过@Configuration配置类中的@Import + ImportSelector方式注册多个bean实例。

这种方式比较起上一种方式来说更加方便，可以同时注册多个bean的实例，同样的不需要在@Import引入的组件类中加任何注解，同时获取bean的时候，需要根据类的全限定名或者类型获取，不能直接使用类的首字母小写进行获取。

@Configuration
@Import(TeacherImportSelector.class)
public class JavaConfigApp {
}



public class TeacherImportSelector  implements ImportSelector {
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"spring.ioc.Teacher", Student.class.getName()};
    }
}

测试:

 //基于@Import + ImportSelector注册多个bean实例
    @org.junit.Test
    public void test07(){
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfigApp.class);
        for (String beanDefinitionName : context.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        //根据类型获取
        Teacher teacher = context.getBean(Teacher.class);
        System.out.println(teacher);
        Student student =  context.getBean(Student.class);
        System.out.println(student);

        Teacher teacher1 = (Teacher) context.getBean("spring.ioc.Teacher");
        System.out.println(teacher1);
        Student student1 = (Student) context.getBean("spring.ioc.Student");
        System.out.println(student1);


        Teacher teacher2 = context.getBean("teacher", Teacher.class);
        System.out.println(teacher2);
        Student student2 =  context.getBean("student", Student.class);
        System.out.println(student2);
    }

结果:
在这里插入图片描述
根据类名首字母小写是无法获取bean的。

(八). 通过@Configuration + @Import + ImportBeanDefinitionRegistrar来注册bean

这种方式需要自己实现ImportBeanDefinitionRegistrar类，并复写registerBeanDefinitions()方法，相比前两种更加的灵活，可以在生产bean之前对bean的一些属性做一系列的修改，比如作用域，bean的名字，自动注入的模式等 ， 最后通过registry.registerBeanDefinition()将bean定义放到beanDefinitionMap中统一管理。


@Configuration
@Import({TeacherBeanDefinetionRegistry.class})
public class JavaConfigApp {
}




public class TeacherBeanDefinetionRegistry implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        String name = Teacher.class.getName();
        beanDefinition.setBeanClass(Teacher.class);
        beanDefinition.setBeanClassName(name);
        beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
        registry.registerBeanDefinition(name, beanDefinition);

        RootBeanDefinition bd = new RootBeanDefinition(Student.class);
        bd.setScope(BeanDefinition.SCOPE_SINGLETON);
        registry.registerBeanDefinition("student", bd);
    }
}



public class Student {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}




public class Teacher {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试:

  //基于@Import + ImportBeanDefinitionRegistrar来手动注册
    @org.junit.Test
    public void test08(){
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfigApp.class);
        for (String beanDefinitionName : context.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        //根据名字获取
        Teacher teacher = context.getBean(Teacher.class.getName(), Teacher.class);
        System.out.println(teacher);
        Student student =  context.getBean("student" ,Student.class);
        System.out.println(student);

        //根据类型获取
        Teacher teacher1 = context.getBean(Teacher.class);
        System.out.println(teacher1);
        Student student1 =  context.getBean(Student.class);
        System.out.println(teacher1);
    }

结果:
在这里插入图片描述

(九). 通过@ComponentScan + BeanDefinitionRegistryPostProcessor来注册bean

实现了该结构就有注册和获取Bean定义的能力，初始化ioc容器的过程中，会多次调用实现了BeanDefinitionRegistryPostProcessor
接口的postProcessBeanDefinitionRegistry()方法注册到容器之中。
所以在这里只需要将BeanDefinitionRegistryPostProcessor想办法注
册成bean即可。

1.可以使用@Import 直接将其注册成bean
2.可以使用@ComponentScan + 注解的方式将其注册成bean

@Configuration
@ComponentScan(basePackages = "spring.ioc")
//@Import(TeacherBeanDefinitionRegistryPostProcessor.class)
public class JavaConfigApp {
}



public class Teacher {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}



@Component
public class TeacherBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        beanDefinitionRegistry.registerBeanDefinition("teacher", new RootBeanDefinition(Teacher.class));
    }

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

    }
}

测试:

 @org.junit.Test
    public void test09(){
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfigApp.class);
        System.out.println(context.getBean("teacher", Teacher.class));
    }

结果:

在这里插入图片描述

(十). 通过@ComponentScan + BeanFactoryPostProcessor来完成bean的注册。

通过结构类型关系图可以看出，BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor，BeanDefinitionRegistryPostProcessor有注册bean的功能，然而BeanFactoryPostProcessor拥有修改bean的功能。
1、 BeanDefinitionRegistryPostProcessor：侧重于bean的注册。
2、 BeanFactoryPostProcessor：侧重于对已经注册的bean的属性进行修改,但是可以通过将方法内部的ConfigurableListableBeanFactory向下转型，实现BeanDefinitionRegistry有注册功能的DefaultListableBeanFactory 

@Component
public class TeacherBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
      DefaultListableBeanFactory factory = (DefaultListableBeanFactory) configurableListableBeanFactory;
      factory.registerBeanDefinition("teacher", new RootBeanDefinition(Teacher.class));
    }
}


@Configuration
@ComponentScan(basePackages = "spring.ioc")
public class JavaConfigApp {
}


public class Teacher {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试：

public class Test {
@org.junit.Test
    public void test09(){
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfigApp.class);
        System.out.println(context.getBean("teacher", Teacher.class));
    }
}

结果:
在这里插入图片描述

总的来说，创建bean的方式有很多种，对于实际应用往往使用比较多的就是javaConfig方式的@Import导入组件，其它的方式并不常用，可以在适当的时候择优选择。

Dog•Li
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
将Bean交给Spring容器管理有几种方式？
m0_73311735的博客
10-12 1307
前两种方式，大家用的可能比较多，也是平时开发中必须要知道的，@Import注解用的可能不是特别多了，但是也是非常重要的，在进行Spring扩展时经常会用到，它经常搭配自定义注解进行使用，然后往容器中导入一个配置文件。他是所有Spring Bean的容器根接口，给Spring 的容器定义一套规范，给IOC容器提供了一套完整的规范，比如我们常用到的getBean方法等。方法，然后将我们要导入的类的全限定名写在里面即可，实现起来也是非常简单。注解的源码中，说的已经很清楚了，感兴趣的可以看下，我们实现一个。
Spring——IOC容器启动及Bean生成流程
共勉
11-24 1035
Spring 5.3.9 版本，看看IOC容器启动到底做了些什么事，看看BeanDefination是怎么变成Bean的，Bean生成流程中到底有多少隐藏的拓展接口
Spring小记——IOC操作Bean管理【注入属性（1）】
最新发布
TCDHanyongpeng的博客
06-01 197
控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理使用IOC目的：为了耦合度降低bean管理指的是两个操作4. Spring创建对象5. Spring注入属性。
Spring中给IoC容器注入bean的几种方法(二)
u012559967的专栏
05-07 266
Spring中给IoC容器注入bean的几种方法(二)
SpringIOC之@Bean 等注解的实现原理
Coder_Boy_的博客
02-06 1371
我们了解到@Component注解（及其派生注解）标注的 Class 类都会被解析成 BeanDefinition（Bean 的“前身”）然后实例化为早期Bean，再进行Bean的属性注入，最后会被初始化成完整Bean对象(如果需要代理则会创建Bean代理对象)。而@Bean注解不是@Component的派生注解，且用于标注方法，使用方法名作为BeanName，返回值作为Bean，那么Spring 中是如何解析@Bean注解的呢？
简单实现SpringIoC的bean的创建和自动注入
Gzz130704的博客
04-14 481
我们知道，Spring容器创建好bean对象后，会将其放入到IoC容器的缓存池中，这里我们通过定义一个静态Map<Class, Object>集合的方式，保存创建出来的bean实例对象。第四步： 在类AnnotationApplicationContext中创建一个带参构造函数，传入要扫描的包路径，程序扫描参数中指定包及其子包里面所有类中的@MyComponent注解，并将注解所标注的类通过反射进行实例化。第五步：IoC和DI的基本功能完成后，创建service和dao的接口及实现类，并标注自定义注解。
Spring为IOC容器注入Bean的五种方式详解
08-25
Spring为IOC容器注入Bean的五种方式详解 Spring 框架中，IOC（Inverse of Control，控制反转）容器是核心组件之一，用于管理 Bean 的生命周期。在 Spring 中，IOC 容器可以通过五种方式来注入 Bean，本文将对这五...
spring在IoC容器中装配Bean详解
08-28
在 Spring 框架中，IoC 容器是 Bean 的容器，负责创建、管理和装配 Bean。在本文中，我们将详细介绍 Spring 在 IoC 容器中装配 Bean 的过程。 一、Spring 配置概述 Spring 配置概述分为三部分：基于 XML 的配置、...
Spring创建IOC容器的方式解析
08-25
本文将深入探讨两种创建Spring IOC容器的主要方式。 1. **直接得到IOC容器对象** Spring提供了多种类型的`ApplicationContext`实现，如`ClassPathXmlApplicationContext`和`FileSystemXmlApplicationContext`，...
基于springioc bean 的几个属性介绍
08-29
基于Spring IOC Bean 的几个属性介绍 在 Spring 框架中，Bean 是一个...这些基于 Spring IOC Bean 的几个属性可以帮助开发者更好地控制 Bean 对象的创建、生命周期和行为，可以提高应用程序的性能、灵活性和可维护性。
详解Spring框架---IOC装配Bean
08-31
IOC（Inversion of Control，控制反转）是Spring框架的核心理念之一，它将Bean的创建、管理和依赖关系从应用程序中分离出来，使得应用程序更加灵活、可维护和可扩展。 在Spring框架中，Bean是应用程序的核心组件，...
spring创建bean的方式
weixin_63001822的博客
05-23 686
各种定义bean的方式
IOC 配置 bean 方式
qq_48010634的博客
01-03 261
IOC 配置 bean 方式
SpringIOC
weixin_43573186的博客
05-24 128
SpringIOC以及bean 一、什么是IoC？ 控制反转，是面向对象编程中的一种设计原则，降低代码之间的耦合度。其中最重要的方式为依赖注入（DI），通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所以来的对象的引用传递给它。 二、IOC的原理 IOC底层原理就是java反射。给定一个字符串就能传一个实例，利用set方法对实例的依赖进行注入； 关于java反射在前面的文章已经学习过了，如何创建一个对象并执行这个对象的方法。 在springIOC中，我们只需要在配置文件中给定一个类
javaConfig配置bean
qq_45864838的博客
11-01 635
1.用@ComponentScan("com.he.pojo")去扫描 @Configuration @ComponentScan("com.he.pojo") public class HeConfig { } @Component("b") public class Book { @Value("java") private String name; @Value("800") private int size; @Override pub..
Spring相关——IOC、Bean、注解
qq_37772958的博客
09-26 458
bean
spring框架中bean和IoC的理解
Best_love_ZY的博客
03-10 1028
Bean是Spring框架中最核心的两个概念之一（另一个是面向切面编程AOP）。 是否正确理解 Bean 对于掌握和高效使用 Spring 框架至关重要。 1、Define Spring官方文档定义： In Spring, the objects that form the backbone of your application and that are managed by th...
理解什么是 spring IOC和Bean ？
weixin_41324527的博客
04-03 1307
IoC 全称为 Inversion of Control，翻译为 “控制反转” 所谓 IOC ，就是由 Spring IOC 容器来负责对象的生命周期和对象之间的关系. 在没有引入 IoC 的时候，被注入的对象直接依赖于被依赖的对象，有了 IoC 后，两者及其他们的关系都是通过 Ioc Service Provider 来统一管理维护的。被注入的对象需要什么，直接跟 IoC Service Pro...
Spring核心技术（一）——IoC容器和Bean简介
weixin_30642561的博客
05-06 332
IoC容器和Bean简介 这章包括了Spring框架对于IoC规则的实现。Ioc也同DI(依赖注入)。而对象是通过构造函数，工厂方法，或者一些Set方法来定义对象之间的依赖的。容器在创建这些Bean对象的时候同时就会注入这些依赖。这个过程是根本上的反转了，不再由Bean本身来控制实例化和定位依赖，而是通过服务定位来控制这个过程，也是IoC（控制反转）的由来。 org.spr...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值