Spring IoC&DI

于 2024-07-21 13:33:24 发布
阅读量444 收藏 8
点赞数 12
分类专栏： Spring 文章标签： spring mybatis mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74859835/article/details/140478283
版权

一，Spring IoC&DI 的定义

我们知道Spring是一个开源框架，简单来说就是一个包含众多工具的IoC容器。容器都知道是用来装东西的，那么什么是IoC？IoC是Spring的核心思想之一，在上一篇SpringMVC的博客中也使用到了，即类的注解，比如@RestController，@Controller注解，它们就表示将这个对象交给Spring管理，Spring框架启动时就会加载该类，把对象交给Spring管理，就是IoC思想。

1.1 IoC——控制反转

IoC，全称 Inversion of Control（控制反转），就是将控制权反转，再进一步来说就是将获得依赖对象的过程反转。IoC思想的主要目的就是降低代码的耦合度。比如说，做一件事，要先做...，再做...，最后做,,,，每一个操作要依赖于前一个操作，而Spring IoC容器就是用来管理这些操作，使我们不必关心前一个操作是否完成，而是只关注于本身的实现。

举个例子，如果不使用IoC思想：

public class demo1 {
    public static void main(String[] args) {
        Car car = new Car();
    }
    static class Car{
        private  Framework framework;
        public Car(){
            framework = new Framework();
            System.out.println("初始化car");
        }
    }

    static class Framework{
        private Bottom bottom;
        public Framework(){
            bottom = new Bottom();
            System.out.println("初始化framework");
        }
    }

    static class Bottom{
        public Bottom(){
            System.out.println("初始化bottom");
        }
    }
}

如果我们要改变bottom的大小，就需要把所有的代码都修改，即代码耦合度太高：

public class demo1 {
    public static void main(String[] args) {
        int size = 100;
        Car car = new Car(size);
    }
    static class Car{
        private  Framework framework;
        public Car(int size){
            framework = new Framework(size);
            System.out.println("初始化car");
        }
    }

    static class Framework{
        private Bottom bottom;
        public Framework(int size){
            bottom = new Bottom(size);
            System.out.println("初始化framework");
        }
    }

    static class Bottom{
        public Bottom(int size){
            System.out.println("初始化bottom");
        }
    }
}

1.2 DI——依赖注入

依赖注入就是实现控制反转的一种方式，我们不在每一个类中自己创建需要依赖的类，而是通过传递参数的形式来获得依赖的类（这里指自己实现，Spring中有专门的注解来帮我们实现，下面会讲），这种获得依赖的方式就称为DI（依赖注入），这样就实现了程序的解耦。

举个例子，将上述程序使用DI的方式实现：

public class demo1 {
    public static void main(String[] args) {
        int size = 100;
        Bottom bottom = new Bottom(size);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
    }
    static class Car{
        private Framework framework;
        public Car(Framework framework){
            this.framework = framework;
            System.out.println("初始化car");
        }
    }

    static class Framework{
        private Bottom bottom;
        public Framework(Bottom bottom){
            this.bottom = bottom;
            System.out.println("初始化framework");
        }
    }

    static class Bottom{
        private int size;
        public Bottom(int size){
            System.out.println("初始化bottom");
        }
    }
}

这样写的话，之后底层类无论如何变化，整个调用链都不用做出任何改变，这样就实现了代码之间的解耦。

1.3 IoC容器的优势

  • 原本代码中类的创建顺序是：Car -> Framework -> Bottom
  • 使用DI后代码中类的创建顺序是：Bottom -> Framework -> Car

可以发现改进后的代码，它创建类的顺序是反的，也是我们之前说的控制权发生了反转，不再是使用法对象创建并控制依赖对象了，而是把依赖对象注入到当前对象中，依赖对象的控制权不再由当前类控制了，这样的话无论依赖类发生任何改变，当前类都是不受影响的，这就是为什么我们将其称之为"控制反转"，这也是IoC的实现思想。

这里我们就彻底了解了上面所说的IoC思想，那么这里的IoC容器究竟有什么作用呢？

Bottom bottom = new Bottom(size);
Framework framework = new Framework(bottom);
Car car = new Car(framework);

上述代码就是IoC容器所做的工作，也就是说我们将需要使用的资源交给不使用资源的第三方管理，这可以带来很多好处：

  1. 实现了资源的集中管理：IoC容器会帮我们管理一些对象，当我们需要使用时，直接去IoC容器中取就行了
  2. 创建实例时不需要了解其中的细节，降低了耦合度

二，IoC 详解

既然Spring是一个IoC（控制反转）容器，作为容器，那么它就具备两个基本功能：存储，获取。Spring容器管理的主要是对象，这些对象，我们称之为"Bean"，我们将这些对象交给Spring管理，我们程序只要告诉Spring，哪些存，以及如何从Spring中取出对象。

2.1 Bean的存储

要把某个对象交给IoC容器管理，需要在类或方法上添加一个注解：

  • 类注解：@Controller、@Service、@Repository、@Component、@Configuration
  • 方法注解：@Bean

接下来分别来看

2.1.1 @Controller（控制器存储）

@Controller//将对象存储到Spring容器中
public class UserController {
    public void run(){
        System.out.println("UserController running...");
    }
}

为了观察这个对象是否存储到Spring中，我们需要从Spring中获取对象，代码如下：

@SpringBootApplication
public class JavaEeSpringIoCApplication {

    public static void main(String[] args) {
        //获取Spring上下文
        ApplicationContext context = SpringApplication.run(JavaEeSpringIoCApplication.class, args);
        //获取对象
        UserController userController = context.getBean(UserController.class);
        //使用对象
        userController.run();
    }
}

这里出现了一个Spring上下文，上下文就是指当前的运行环境，我们可以把它当作一个容器，容器中存储的就是当前的运行环境。

观察运行结果，发现成功从Spring中获取到UserController对象，并执行了它的run方法：

2.1.2 获取Bean的方式

上述代码是根据类型来查找对象，如果Spring容器中，同一个类存在多个Bean（即对象）的话，我们就需要通过其他方式获取，这里介绍三种常用的方法：

public interface BeanFactory {
    //以上省略...

    //根据bean的名称获取bean
    Object getBean(String var1) throws BeansException;
    
    //根据bean的名称和类型获取bean
    <T> T getBean(String var1, Class<T> var2) throws BeansException;
  
    //根据类型获取bean
    <T> T getBean(Class<T> var1) throws BeansException;

    //以下省略...
}

前两种方法都涉及到根据名称来获取对象，那么bean的名称是什么呢？Spring bean是Spring框架再运行时管理的对象，Spring会给管理的对象取一个名字，根据Bean的名称就可以获取到对应的对象。它的底层代码是这样的：

    //如果name前两个字符是大写，那么直接返回name
    //否则将name的第一个字符小写后，返回name
    public static String decapitalize(String name) {
        if (name == null || name.length() == 0) {
            return name;
        }
        if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
                        Character.isUpperCase(name.charAt(0))){
            return name;
        }
        char chars[] = name.toCharArray();
        chars[0] = Character.toLowerCase(chars[0]);
        return new String(chars);
    }

演示一下上述三种方法：

@SpringBootApplication
public class JavaEeSpringIoCApplication {

    public static void main(String[] args) {
        //获取Spring上下文
        ApplicationContext context = SpringApplication.run(JavaEeSpringIoCApplication.class, args);
        //获取对象
        UserController userController1 = (UserController) context.getBean("userController");
        UserController userController2 = context.getBean("userController", UserController.class);
        UserController userController3 = context.getBean(UserController.class);
        //使用对象
        System.out.println(userController1);
        System.out.println(userController2);
        System.out.println(userController3);
    }
}

2.1.3 @Service（服务存储）

@Service
public class UserService {
    public void run(){
        System.out.println("userService run...");
    }
}

获取该对象：

@SpringBootApplication
public class JavaEeSpringIoCApplication {

    public static void main(String[] args) {
        //获取Spring上下文
        ApplicationContext context = SpringApplication.run(JavaEeSpringIoCApplication.class, args);
        //获取对象
        UserService userService = context.getBean(UserService.class);
        //使用对象
        userService.run();
    }
}

2.1.4 @Repository（仓库存储）

@Repository
public class UserRepository {
    public void run(){
        System.out.println("UserRepository run...");
    }
}

获取该对象：

@SpringBootApplication
public class JavaEeSpringIoCApplication {

    public static void main(String[] args) {
        //获取Spring上下文
        ApplicationContext context = SpringApplication.run(JavaEeSpringIoCApplication.class, args);
        //获取对象
        UserRepository userRepository = context.getBean(UserRepository.class);
        //使用对象
        userRepository.run();
    }
}

2.1.5 @Component（组件存储）

@Component
public class UserComponent {
    public void run(){
        System.out.println("UserComponent run...");
    }
}

2.1.6 @Configuration（配置存储）

@Configuration
public class UserConfiguration {
    public void run(){
        System.out.println("UserConfiguration run...");
    }
}

获取与上面的做法一样，这里就不做过多的赘述。

2.2 五大注释的区别与作用

之所以有这么多注释就是为了让程序员区分被该注释的类的用途：

  • @Controller：控制层，接收请求，对请求进行处理，并进行响应
  • @Service：业务逻辑层，处理具体的业务逻辑
  • @Repository：数据访问层，也称为持久层，负责访问数据库的操作
  • @Configuration：配置层，处理项目中的一些配置

通过源码来看一下类注解之间的关系：

//@Component源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
    String value() default "";
}

//@Repository源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

//@Configuration源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";

    boolean proxyBeanMethods() default true;
}

//@Controller源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

//@Service源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

可以发现@Controller / @Service / @Repository / @Configuration这些注解中都有一个@Component注解，说明它们本身就属于@Component的子类，@Component 是⼀个元注解，也就是说可以注解其他类注解，如 @Controller , @Service , @Repository 等. 这些注解被称为 @Component 的衍⽣注解，@Component也是Spring能够自动识别并管理类的实例的原因。

下图可以看出它们之间的关系

2.3 方法注释@Bean

为什么还需要有一个方法注释？

  1. 如果要使用第三方库中的类，就没法自主添加类注释
  2. 一个类可能会创建多个对象，使用类注释无法实现

2.3.1 定义一个对象

@Component
public class UserBean {
    @Bean
    public User user(){
        User user = new User(18,"zhangsan");
        return user;
    }
}

注意：@Bean注解必须搭配类注解一起使用！！！，不然不会存储到Spring容器中

2.3.2 定义多个对象

@Component
public class UserBean {
    @Bean
    public User user1(){
        User user = new User(18,"zhangsan");
        return user;
    }
    @Bean
    public User user2(){
        User user = new User(10,"lisi");
        return user;
    }
}

当一个类出现多个对象时，我们就不能使用类来获取对象，不然会出现下面的报错：

这时就必须要通过它们的名字来获取对象，注意@Bean注释定义的对象，默认名称就是方法名，不需要额外去判断修改，我们可以通过名称获取：

当然我们也可以通过name属性来重命名：

@Component
public class UserBean {
    @Bean({"UserInfo"})//可以取多个名称
    public User user(){
        User user = new User(18,"zhangsan");
        return user;
    }
}

2.4 扫描路径

想要将对象交给Spring管理，不仅需要添加类注解，方法注解，还需要让这些类在Spring的扫描路径下。

这时我们可以通过@ComponentScan()注解来配置Spring的扫描路径：

注：{}中可以配置多个路径

三，DI详解

在Spring中，我们可以使用@Autowired注解来完成依赖注入的操作，Spring提供了三种方式：

  • 属性注入
  • 构造方法注入
  • Setter注入

3.1 属性注入

注入多个对象时，每个对象都要添加@Autowired注解

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @Autowired 
    private UserConfiguration userConfiguration

    public void run(){
        userService.run();
        System.out.println("UserController running...");
    }
}

3.2 构造方法注入

当只有一个构造方法，@Autowired注解可以不加

@Controller
public class UserController {
    private UserService userService;
    @Autowired
    public UserController(UserService userService){
        this.userService = userService;
    }
    public void run(){
        userService.run();
        System.out.println("UserController running...");
    }
}

当有多个构造方法，如果有@Autowired注解，那么就会调用有注解的那个；如果没有@Autowired注解，那么就会默认调用无参的构造方法。

@Controller
public class UserController {
    private UserService userService;
    private UserRepository userRepository;
    public UserController(){}
    public UserController(UserService userService){
        this.userService = userService;
    }
    @Autowired
    public UserController(UserService userService, UserRepository userRepository){
        this.userService = userService;
        this.userRepository = userRepository;
    }
    public void run(){
        userService.run();
        userRepository.run();
        System.out.println("UserController running...");
    }
}

3.3 Setter注入

@Controller(value = "u1")//可以通过value属性重命名
public class UserController {
    private UserService userService;
    private UserRepository userRepository;
    @Autowired
    public void setUserService(UserService userService){
        this.userService = userService;
    }
    @Autowired
    public void setUserRepository(UserRepository userRepository){
        this.userRepository = userRepository;
    }

    public void run(){
        userService.run();
        userRepository.run();
        System.out.println("UserController running...");
    }
}

3.4 @Autowired存在的问题

@Autowired注解会先根据类来查找需要注入的对象，如果该类有多个对象，就会根据名称来选择注入的对象，但是不推荐这种用法（因为在公司中一个项目通常是由多个人完成，默认变量名的修改不会影响业务的实现）：

为了避免上述做法，Spring提供了以下几种解决方法：@Primarily，@Qualifier，@Resource

  • @Primarily：可以在其中一个bean上添加@Primary注解，以指示Spring容器在存在多个候选者时应该优先考虑哪一个bean。如果有且仅有一个bean被标记为@Primary，则Spring将使用该bean进行注入。
  • @Component
public class UserBean {
    @Bean
    @Primary
    public User user1(){
        User user = new User(18,"zhangsan");
        return user;
    }
    @Bean
    public User user2(){
        User user = new User(10,"lisi");
        return user;
    }
}
  • @Qualifier：如果@Primary不足以解决问题（例如，如果有多个@Primary标记的bean，或者想基于不同的条件注入不同的bean），可以使用@Qualifier注解来明确指定要注入的bean的名称。@Qualifier可以与@Autowired一起使用，或者与@Bean方法一起使用在配置类中
  • @Repository
public class UserRepository {
    @Autowired
    @Qualifier("user1")
    private User user;
    public void run(){
        System.out.println("UserRepository run...");
    }
}

  • @Resource：是按照bean的名称进⾏注⼊，通过name属性指定要注⼊的bean的名称。

  • @Repository
public class UserRepository {
    @Resource(name = "user1")
    private User user;
    public void run(){
        System.out.println(user);
        System.out.println("UserRepository run...");
    }
}

四，常见面试题

4.1 三种注入方式的优缺点

1.属性注入

  • 优点：简洁方便
  • 缺点：只能在IoC容器中使用；不能注入一个final修饰的属性

2.构造方法注入：

  • 优点：可以注入final修饰的属性；通用性好，是JDK支持的，可以任用于其他框架；注入对象不会被修改；依赖对象在使⽤前⼀定会被完全初始化，因为构造方法在类加载阶段就会执行
  • 缺点：代码比较繁琐

3.Setter注入：

  • 优点：方便在类实例之后, 重新对该对象进行配置或者注入
  • 缺点：不能注入一个Final修饰的属性；注入对象可能会被改变, 因为setter方法可能会被多次调用, 就有被修改的风险

4.2 @Autowired与@Resource的区别

  • @Autowired 是spring框架提供的注解，⽽@Resource是JDK提供的注解
  • @Autowired 默认是按照类型注入，⽽@Resource是按照名称注入. 相比于 @Autowired 来说，@Resource 支持更多的参数设置，例如 name 设置，根据名称获取 Bean。

4.3  ApplicationContext与BeanFactory

  • BeanFactory 提供了基础的访问容器的能力，ApplicationContext是BeanFactory的子类，继承了BeanFactory的所有功能之外，还有独特的功能，比如：支持国际化，支持资源访问。
  • ApplicationContext是一次性加载并初始化所有Bean对象，而BeanFactory是用到哪个才去加载哪个，所以BeanFactory比ApplicationContext更加轻量。（空间换时间）
一叶祇秋
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
笔记28-JAVAEE之Spring IoC&DI
01-25
JAVAEE之Spring IoC&DI Spring IoC(Inversion of Control，即控制反转)是Spring框架的核心机制之一，它提供了一种解耦合的方式，使得应用程序的各个组件之间能够松散耦合，提高了系统的灵活性和可维护性。 在传统...
day-Spring IoC & DI.md
10-15
day-Spring IoC & DI.md
Spring IOC&DI
zhuge_long的专栏
05-31 1036
Resource注解与@Autowired注解的作用是一样的，都是用来为bean对象注入值的，唯一的区别是@Resource注解要根据实例化的bean名称为bean对象注入值。@Resource(name = “userDaoImpl2”)//name属性设置注入对象的属性名，如果属性名和name注入的名称一致的，name可以不赋值。Spring5.0开始，倡导以注解方式完成对象的管理，如果对象无法使用注解，就将对象交给spring的配置统一管理，而不再推荐使用xml配置的方式！
javaee Spring IoC&DI
m0_46652188的博客
05-02 691
IOC: 原来上层依赖下层,下层改变,上层也要大量的修改,不好.所以上层中拿着下层的对象,下层改变不影响上层. DI: 上层持有下层对象,每次都要new,依赖传递下去,new一个上层对象,结果可能要依赖几十个对象.太麻烦,所以spring帮我们做了控制反转,new你要的对象就行,其他的不用你管.它的实现就是:你要一个car,在创建car的时候发现car需要依赖框架frame,好,再创建一个frame,啊,创建frame需要底盘?行,给你创建个底盘,创建底盘时发现还需要轮胎,好再给你new 轮胎.new轮胎的
详解Spring IoC&DI（一）
Romised的博客
05-29 922
什么是IoC、IoC应用场景（案例分析）、传统程序开发、问题分析、解决方案、IoC 优势、DI概念、IoC详解、Bean的存储、@Controller（控制器存储），各类注解的使用
【JavaEE 进阶（三）】Spring IoC&DI
weixin_69049913的博客
06-05 2026
本篇文章将介绍Spring IOC的概念和Spring DI的概念，以及 IOC和 DI的实现
Spring IOC和DI实现原理及实例解析
08-19
Spring IOC和DI实现原理及实例解析 Spring IOC（Inversion of Control，控制反转）是Spring框架的基础，它简单地说就是创建对象由以前的程序员调用new构造方法，变成了交由Spring创建对象。DI（Dependency Inject，...
springIOC和DI
05-08
什么是spring，spring核心，spring优点，spring体系结构， 入门案例，DI基础，核心API，文档内附代码
SpringIOC DI循环依赖实例详解
08-24
SpringIOC DI 循环依赖实例详解 SpringIOC 是一个基于依赖注入（Dependency Injection，简称 DI）的容器，用于管理 Bean 的生命周期。 DI 循环依赖是指在 Bean 初始化过程中出现的循环依赖问题，即一个 Bean 依赖于...
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 245
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
Spring3(代理模式 Spring1案例补充 Aop 面试题)
qq_52897007的博客
07-17 1178
为其他对象提供一种代理以控制对这个对象的访问。
手写简易版Spring IOC容器02【学习】
weixin_44794897的博客
07-19 458
其中applyPropertyValues用于从beanDefinition中读取属性的配置信息然后通过BeanUtil(hutool-all中提供的类)为其赋值@Overridetry {// 创建bean实例Class<?if (null!break;// 设置属性值try {// 从beanDefinition中获取property通过Resource获取文件流。
Spring-使用
weixin_61094678的博客
07-17 299
众所周知，Spring是一个包含了众多工具的IoC容器。既然是容器就必然包含两个最基本的功能：将对象存储到容器中，从容器中将对象取出来故本篇文章 将讲述如何在Spring中，如何创建，存储，获取并使用Bean对象。
SpringMVC-拦截器
时间如瑾 代码如诗
07-16 2733
Spring MVC 中的拦截器（Interceptor）是一种强大的机制，用于拦截请求和响应。它允许开发者在请求处理的不同阶段执行预处理和后处理操作，比如日志记录、权限检查、国际化等。
SpringBoot-LangChain4j核心源码分析
最新发布
Box_clf的博客
07-20 497
如果有对当前的aiService定义添加tool工具, 那么会tool工具调用对应的大模型function calling的api, 这样模型会知道何时才会去调用系统内部的工具类.注解用于导入其他的配置类，使得这些配置类中的bean定义可以被当前配置类所在的Spring容器中识别和管理。循环调用ai模型, 根据模型反馈需要调用的工具链并将结果告诉模型, 最后根据模型的response返回最终的执行结果给用户。 根据实际的配置信息构建对应的aiService的bean对象。
Springcloud （一站式微服务架构的解决方案）
great_sz的博客
07-16 210
上课内容，期待日后学会了能看到这些图片，呜呜呜
springboot助农管理系统lw源码调试讲解
u014445459的博客
07-19 574
在系统将要投入使用前，需要进行的一个必不可少的工作环节就是系统测试。测试人员通过系统测试工作，验证在系统的使用过程中，界面环境是否整洁友好，用户账号信息是否安全可靠，性能方面是否稳定健壮，功能方面是否符合用户需要等。系统测试不仅需要找出系统运行中会出现的问题，还需要分析产生这些问题的原因，并且找到解决这些问题的方法[21]。系统测试主要分为黑盒测试和白盒测试[22]。黑盒测试即功能测试，其主要是站在使用者的角度对系统进行测试。
SpringBoot使用开发环境的application.properties
培根芝士的专栏
07-16 420
在Spring Boot项目中，application.properties 或 application.yml 文件是用于配置应用程序外部属性的重要文件。这些文件允许定制你的应用，而无需更改代码。根据不同的运行环境，可以通过创建以application-{profile}.properties格式命名的文件来定义不同环境的配置，其中{profile}是环境标识，如test（测试）、dev（开发）、prod（生产）等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一叶祇秋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值