Spring(二)

最新推荐文章于 2024-07-08 18:16:19 发布
最新推荐文章于 2024-07-08 18:16:19 发布
阅读量655 收藏
点赞数
文章标签： spring bean string class interface encoding
 

来自：http://blog.csdn.net/yuchen2008/archive/2007/05/27/1627226.aspx

Spring（二）

依赖注入的三种方式:

1.基于接口注入

2.构造方法注入

3.set注入

 

基于接口注入:

只要实现制定的接口,那么便创建对象,类似于标示接口,比如说:servlet的pagecontext等,只要实现了servlet接口,那么pagecontext,request,response,ServletContext等就会创建

 

构造方法注入:

顾名思义,通过构造方法注入对象的属性,这种方式不常用

 

Set注入:

通过set方法注入对象信息,这个用的最多

 

ApplicationContext:

通常使用ClassPathXmlApplicationContext这个类来代替XmlBeanFactory

 

FileResource:

得到资源文件(xml)的另一种方式:绝对路径方式,一般使用的不多

 

综合例子(依赖注入and ClassPathXmlApplicationContext):

程序目标:测试构造方法注入和set注入

Model接口:

package yuchen.immit.constructimmit;

 

public interface Model {

     public String supportData();

}

 

view接口:

package yuchen.immit.constructimmit;

 

public interface View {

     public void render();

}

 

ModelImp实现类:

package yuchen.immit.constructimmit;

 

public class ModelImp implements Model {

 

     //set注入

     private String ownerName;

     private double balance;

     //构造方法注入

     private String city;

     public ModelImp(String city){

          this.city=city;

     }

     public String supportData() {

          // TODO Auto-generated method stub

          return "model : /n"+"ownerName :"+this.ownerName+

          "/n balance :"+this.balance+"/n city:"+city;

     }

     public double getBalance() {

          return balance;

     }

     public void setBalance(double balance) {

          this.balance = balance;

     }

     public String getOwnerName() {

          return ownerName;

     }

     public void setOwnerName(String ownerName) {

          this.ownerName = ownerName;

     }

 

}

 

ViewImp:

package yuchen.immit.constructimmit;

 

public class ViewImp implements View {

 

     private Model model;

     private Model model2;//构造方法注入

     public ViewImp(Model model2){

          this.model2=model2;

     }

     public void render() {

          // TODO Auto-generated method stub

//       String rst=model2.supportData();构造注入的ModelImp对象

          String rst=model.supportData();

          System.out.println(rst);

     }

     public Model getModel() {

          return model;

     }

     public void setModel(Model model) {

          this.model = model;

     }

 

}

 

beans.xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

"http://www.springframework.org/dtd/spring-beans.dtd" >

<beans>

     <bean id="model" class="yuchen.immit.constructimmit.ModelImp">

          <constructor-arg >

                <value>北京</value>

          </constructor-arg>

          <property name="ownerName">

                <value>yuchen</value>

          </property>

          <property name="balance">

                <value>1000.67</value>

          </property>

     </bean>

    

     <bean id="view" class="yuchen.immit.constructimmit.ViewImp">

          <constructor-arg>

                <ref bean="model"></ref>

          </constructor-arg>

          <property name="model">

                <ref bean="model"></ref>

          </property>

     </bean>

</beans>

 

Test:

package yuchen.immit.constructimmit;

 

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.core.io.ClassPathResource;

 

public class Test {

 

     /**

      * @param args

      */

     public static void main(String[] args) {

          // TODO Auto-generated method stub

//       ClassPathResource resource=new ClassPathResource

("yuchen/immit/constructimmit/beans.xml");

//       XmlBeanFactory factory=new XmlBeanFactory(resource);

          ClassPathXmlApplicationContext factory=new

ClassPathXmlApplicationContext("yuchen/immit/constructimmit/beans.xml");

          View view=(View) factory.getBean("view");

          view.render();

     }

 

}

 

Ioc依赖注入的特点:

1.对spring没有依赖性,程序不依赖于spring指定的Api

2.bean都是单例的,除非在bean的属性修改

3.支持基本类型,引用类型和集合类型

 

接口:

package yuchen.ioccharacteristic;

 

public interface IocCharacteristic {

     public void display();

}

 

 

实现类:

package yuchen.ioccharacteristic;

 

import java.util.Map;

 

public class IocCharacteristicImp implements IocCharacteristic {

 

     private Map map;

     public void display() {

          // TODO Auto-generated method stub

          System.out.println("display"+this.map);

     }

     public Map getMap() {

          return map;

     }

     public void setMap(Map map) {

          this.map = map;

     }

    

}

 

beans.xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >

<beans>

     <bean id="ioc" class="yuchen.ioccharacteristic.IocCharacteristicImp" singleton="false">

          <property name="map">

                <map>

                      <entry key="1">

                           <value>yuchen</value>

                      </entry>

                      <entry key="2">

                           <value>liu</value>

                      </entry>

                      <entry key="3">

                           <value>li</value>

                      </entry>

                </map>

          </property>

     </bean>

</beans>

 

Test:

package yuchen.ioccharacteristic;

 

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class Test {

 

     public static void main(String[] args) {

          // TODO Auto-generated method stub

          ClassPathXmlApplicationContext factory=new ClassPathXmlApplicationContext ("yuchen/ioccharacteristic/beans.xml");

          IocCharacteristic ic=(IocCharacteristic) factory.getBean("ioc");

          IocCharacteristic ic2=(IocCharacteristic) factory.getBean("ioc");

          //默认情况下都是单例模式,除非修改beans.xml bean 属性:singleton="false"

          System.out.println(ic==ic2);

          ic.display();

     }

 

}

 

Bean的创建:

1.工厂类创建:A.静态方法 B.new 工厂类

2.XmlBeanFactory:当getBean的时候创建bean实例

3.ClassPathXmlApplicationContext:当new这个对象后,就将资源中的bean读入到内存

 

程序目标:

一个类的属性的值通过一个工厂类的方法得到,这个工厂类有两个方法,一个是静态的,一个是成员方法,测试工厂类的使用

 

接口:

package yuchen.factory;

 

public interface Factory {

     public void display();

}

 

实现类:

package yuchen.factory;

 

public class FactoryImp implements Factory {

 

     public String name;

     public void display() {

          // TODO Auto-generated method stub

          System.out.println(name);

     }

     public String getName() {

          return name;

     }

     public void setName(String name) {

          this.name = name;

     }

    

}

 

工厂类:

package yuchen.factory;

//工厂类:一个静态,一个动态

public class GetNameFactory {

     public static String createName(String s){

          if(s.equals("yuchen")){

                return "yuchen";

          }else if(s.equals("liu")){

                return "liu";

          }

          return null;

         

     }

     public String newName(String s){

          if(s.equals("yuchen")){

                return "yuchen";

          }else if(s.equals("liu")){

                return "liu";

          }

          return null;

         

     }

}

 

beans.xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

"http://www.springframework.org/dtd/spring-beans.dtd" >

<beans>

     <bean id="fac" class="yuchen.factory.FactoryImp">

          <property name="name">

                <ref bean="name"></ref>

          </property>

     </bean>

    

     <bean id="name1" class="yuchen.factory.GetNameFactory" factory-

method="createName">

          <constructor-arg>

                <value>yuchen</value>

          </constructor-arg>

     </bean>

    

     <bean id="getnamefactory" class="yuchen.factory.GetNameFactory" />

     <bean id="name" factory-bean="getnamefactory" factory-

method="newName">

          <constructor-arg>

                <value>liu</value>

          </constructor-arg>

     </bean>

</beans>

 

Test:

package yuchen.factory;

/*

 * 知识点:使用工厂类的方法,给其他类的属性设置值

 * 语法:beans.xml:静态方法:

 * <bean id="getnamefactory" class="yuchen.factory.GetNameFactory" />

 * 成员方法:

 * <bean id="name" factory-bean="getnamefactory" factory-method="newName">

          <constructor-arg>

                <value>liu</value>

          </constructor-arg>

     </bean>

     使用该工厂的类:

     <property name="name">

                <ref bean="name"></ref>

     </property>

 */

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class Test {

     public static void main(String [] args){

          ClassPathXmlApplicationContext factory=new

ClassPathXmlApplicationContext("yuchen/factory/beans.xml");

          Factory f=(Factory) factory.getBean("fac");

          f.display();

     }

}

 

继承属性:<bean Parent>

若干个bean,共有一个属性,使用继承

A类:a,b属性已经set或通过构造方法(属性a,属性b)设置好

B类:也有a,b同名属性

那么在beans.xml中使用<bean Parent>,B 继承 A就可以了,不用在xml中从新设置

 

抽象属性:<bean abstract="true|false">

不能得到该类的实例

 

自动装配bean:

自动设置依赖关系:例如:A类持有B类的引用,引用属性名字和xml中的B类的id名字相同,那么会自动装配好

autowire="byName|byType|constructor"

byName:属性—id 推荐

byType:找类名匹配,存在问题,当一个类多次出现会报错

constructor:根据构造方法类型匹配

 

依赖检查:dependency-check="all"

检查所有的set方法是否都被调用了,例如:如果有属性缺少set方法,那么会报异常

 

生命周期方法定制:

两种方式:1.使用bean属性 2.实现接口(不推荐,框架侵入性强:依赖API)

在构造方法和依赖注入set后调用init

 

综合实例(继承属性, 自动装配bean, 依赖检查,生命周期方法定制):

A接口:

package yuchen.beansp;

 

public interface A {

     public void display();

}

 

B接口:

package yuchen.beansp;

 

public interface B {

     public void dispaly();

}

 

A实现类:

package yuchen.beansp;

 

public class AImp implements A {

     private String name;

     private int age;

     public AImp(String name) {

          super();

          this.name = name;

     }

     public int getAge() {

          return age;

     }

     public void setAge(int age) {

          this.age = age;

     }

     public String getName() {

          return name;

     }

     public void display() {

          // TODO Auto-generated method stub

          System.out.println("Aimp: /n");

          System.out.println(this.name+":"+this.age);

     }

    

}

 

B实现类:

package yuchen.beansp;

 

public class BImp implements B {

     private A a;

     private String name;

     private int age;

     public BImp(String name) {

          super();

          this.name = name;

     }

     public int getAge() {

          return age;

     }

     public void setAge(int age) {

          this.age = age;

     }

     public void dispaly() {

          // TODO Auto-generated method stub

          System.out.println("Bimp: /n");

          System.out.println(this.name+":"+this.age);

          a.display();

     }

     public void setA(A a) {

          this.a = a;

     }

     public void init(){

          System.out.println("init....");

     }

     public void destroy(){

          System.out.println("destroy....");

     }

    

}

 

beans.xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >

<beans>

     <bean id="a" class="yuchen.beansp.AImp">

          <constructor-arg>

                <value>yuchen</value>

          </constructor-arg>

          <property name="age">

                <value>24</value>

          </property>

     </bean>

    

     <bean id="b" class="yuchen.beansp.BImp" autowire="byName" parent="a" dependency-check="all" init-method="init" destroy-method="destroy" >

         

     </bean>

</beans>

 

Test:

package yuchen.beansp;

 

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class Test {

 

     /**

      * @param args

      */

     public static void main(String[] args) {

          // TODO Auto-generated method stub

          ClassPathXmlApplicationContext factory=new ClassPathXmlApplicationContext("yuchen/beansp/beans.xml");

          B bb=(B) factory.getBean("b");

          A aa=(A) factory.getBean("a");

          aa.display();

          bb.dispaly();

     }

 

}

 

获得当前bean的bean工厂对象和bean的实例名字(beans.xml中<bean id=””>):

Bean类必须实现BeanFactoryAware接口

注意:不能使用依赖检查了,因为这个接口的方法不要求有set方法

 

Bean类必须实现BeanNameAware接口

注意:不能使用依赖检查了,因为这个接口的方法不要求有set方法

 

接口:

package yuchen.factoryandname;

 

public interface Bird {

 

}

 

实现类:

package yuchen.factoryandname;

 

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.BeanFactoryAware;

import org.springframework.beans.factory.BeanNameAware;

 

public class CaiBird implements Bird ,BeanFactoryAware,BeanNameAware{

     private String color;

 

     public String getColor() {

          return color;

     }

 

     public void setColor(String color) {

          this.color = color;

     }

 

     public void setBeanFactory(BeanFactory arg0) throws BeansException {

          // TODO Auto-generated method stub

          System.out.println("当前bean的bean工厂");

     }

 

     public void setBeanName(String arg0) {

          // TODO Auto-generated method stub

          System.out.println(arg0+":"+this.color);

     }

    

}

 

xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >

<beans>

     <bean id="bird" class="yuchen.factoryandname.CaiBird">

          <property name="color">

                <value>红色</value>

          </property>

     </bean>

</beans>

 

Test:

package yuchen.factoryandname;

 

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class Test {

 

     public static void main(String[] args) {

          // TODO Auto-generated method stub

          ClassPathXmlApplicationContext factory=new ClassPathXmlApplicationContext ("yuchen/factoryandname/beans.xml");

          Bird bb=(Bird) factory.getBean("bird");

     }

 

}

 

以上内容为bean工厂部分

 

AppLicationContext

基本概念:

1.什么是ApplicationContext?有什么用?

2.和bean工厂的区别?

3.后续处理器

 

什么是ApplicationContext?有什么用?

是bean工厂的升级,增强了功能,例如国际化等

通过这个类可以得到bean对象

 

和bean工厂的区别?

功能更多

当实例这个对象的时候,该对象就会将资源中的bean实例存储到内存中

 

后续处理器:

BeanPostProcessor

作用:可以在使用该实例前增加一些处理操作

 

程序目标:

接口:

package yuchen.beanpostprocessor;

 

public interface A {

     public void display();

}

 

实现类:

package yuchen.beanpostprocessor;

 

public class AImp implements A {

     private String name;

 

     public String getName() {

          return name;

     }

 

     public void setName(String name) {

          this.name = name;

     }

    

     public void display(){

          System.out.println(this.name);

     }

}

 

后续处理器:

package yuchen.beanpostprocessor;

 

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.config.BeanPostProcessor;

 

public class UpperNamePostProcessor implements BeanPostProcessor{

 

     public Object postProcessAfterInitialization(Object bean, String id) throws BeansException {

          // TODO Auto-generated method stub

          if(bean instanceof AImp){

                AImp aimp=(AImp)bean;

                aimp.setName(aimp.getName().toUpperCase());

          }

          return bean;

     }

 

     public Object postProcessBeforeInitialization(Object arg0, String arg1) throws BeansException {

          // TODO Auto-generated method stub

          return arg0;

     }

    

}

 

xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >

<beans>

     <bean id="a" class="yuchen.beanpostprocessor.AImp">

          <property name="name">

                <value>yuchen</value>

          </property>

     </bean>

    

     <bean class="yuchen.beanpostprocessor.UpperNamePostProcessor">

         

     </bean>

</beans>

 

Test:

package yuchen.beanpostprocessor;

 

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class Test {

 

     /**

      * @param args

      */

     public static void main(String[] args) {

          // TODO Auto-generated method stub

          ClassPathXmlApplicationContext factory=new ClassPathXmlApplicationContext("yuchen/beanpostprocessor/beans.xml");

          A aa=(A) factory.getBean("a");

          aa.display();

     }

 

} 

sara
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring security原理和机制 | Spring Boot 35
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
Spring常见面试题总结（超详细回答）
张维鹏的博客
07-08 90万+
1、Spring是什么? Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML的配置、基于注解的配置、基于Java的配置。 主要由以下几个模块组成： Spring Core：核心类库，提供IOC服务； Spring Context：提...
Spring一些基础问题整理
热门推荐
张彦峰的博客
04-07 169万+
Spring相关高频面试题整理
Spring（一）
m0_46547635的博客
01-10 146
spring
Spring源码深度解析第二版
11-15
Spring源码深度解析第二版 Spring是一款广泛应用于Java企业级应用程序的开源框架，旨在简化Java应用程序的开发和部署。Spring框架的核心主要包括了IoC容器、AOP、MVC框架等模块。 第1章 Spring整体架构和环境搭建 ...
Spring试题二
03-18
美斯坦福在线考试系统,网页版的考试题,可检测Spring知识点的掌握,自动更改试题打分.
spring二级缓存
05-27
在配置Spring二级缓存时，我们需要完成以下步骤： 1. **添加依赖**：首先，确保项目中包含EhCache的相关库，包括`ehcache-core`或`ehcache-spring-annotations`。如果使用Maven，可以在pom.xml文件中添加对应的依赖...
SpringCloud第二季脑图.rar
05-30
"SpringCloud第二季脑图.rar"很可能包含周阳老师关于SpringCloud的系统性学习路径和关键概念的图表化表示，这对于理解和掌握SpringCloud的架构和组件非常有帮助。 1. **Spring Cloud Eureka**：Eureka是服务注册与...
spring 3.2.19
02-12
Spring 框架是Java开发中的一个...对于希望深入理解Spring框架工作原理或者进行二次开发的开发者来说，这是一个宝贵的资源。在使用这个版本时，建议阅读官方文档，结合实际项目需求，充分利用Spring提供的强大功能。
springboot基于Java的超市进销存系统+ LW+ PPT+源码+讲解
u014445459的博客
07-06 667
操作的多样性也变高了。由此可见，本系统在操作上是可行的。软件测试的方法有好几种，但目前主要采用的是包括以功能为主要测试方向的黑盒测试以及以逻辑为主要测试方向的白盒测试，这是两种不同的测试方法，针对的测试侧重点不同，本课题根据实际需求情况，选择以功能为主要的黑盒测试方法，同时测试是要遵循一定的规则来执行的，一个测试要执行其执行的依据一般是由测试用例来规定的，而测试用例一般是依据需求或说明书来综合制定的，测试在硬件出厂前是十分重要的一个过程，本课题由于时间和精力的关系，选择以实现的功能作为测试要点来进行测试。
SpringBoot AOP切入点表达式
生产队的驴
07-05 243
在AOP中可以通过@Around注解来定义 切入点表达式来控制被监控的方法。匹配 com.example.service 包中的任何类的 save 方法，且方法参数为 java.lang.String 类型。
springboot项目多模块工程==1搭建
溪
07-06 275
idea springboot 项目多模块工程搭建配置
学习springMVC
weixin_45621552的博客
07-03 522
JSR全称为 Java Specification Requests，表示 Java 规范提案。JSR-303是 Java 为 Java Bean 数据合法性校验提供的标准框架，它定义了一套可标注在成员变量，属性方法上的校验注解。Hibernate Validatior提供了这套标准的实现。-- 最新7.0.1.Final --> </ dependency >-- 最新7.0.1.Final --> </ dependency ></
【SpringBoot3】结合 gRpc 实现远程服务调用
最新发布
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
07-08 699
gRPC（Google Remote Procedure Call，Google远程过程调用）是一个现代开源高性能远程过程调用(RPC)框架，可以在任何环境中运行。它由Google开发，旨在帮助开发人员更轻松地构建分布式应用，特别是当代码可能在不同地方运行的时候。 gRPC是一个高性能、开源和通用的RPC框架，它基于HTTP/2设计，并支持多种编程语言和平台。 随着其开源和广泛应用，gRPC已成为云原生计算基金会(CNCF)的一个孵化项目，被大量组织和企业采用。
基于Java+SpringMvc+Vue技术智慧校园系统设计与实现--60页及以上论文参考
mr_lili_111的博客
07-05 706
Java是一种面向对象的编程语言，目前由美国Oracle公司开发。自1995年上线以来，已经广泛应用于Web开发、桌面应用开发等多个领域。Java语言的特点包括：1、面向对象：Java提供了类、接口和继承等面向对象的特性，支持单继承和多接口继承，以及动态绑定。2、分布式：Java支持Internet应用的开发，提供了网络应用编程接口(java.net)，支持RMI(远程方法激活)机制，适合开发分布式应用。3、健壮性：Java的强类型机制、异常处理、垃圾自动收集等特性保证了程序的健壮性。
Spring相关面试题（四）
m0_73179389的博客
07-06 475
接口实现XML配置注解实现。
构建安全稳定的应用：SpringSecurity实用指南
zhugedali_的博客
07-04 697
它涵盖了认证（Authentication）、授权（Authorization）、防止常见的安全攻击等多个方面，适用于各种类型的应用，包括 Web 应用、RESTful 服务、微服务等。- 生成认证对象：认证成功后，创建包含用户信息、角色和权限的 Authentication 对象，并存储在安全上下文中。- 加载用户角色和权限：除了基本的用户信息，还包括用户所拥有的角色和权限。- 认证请求处理：根据配置的认证方式，对用户提交的认证信息进行验证。
springboot封装请求参数json的源码解析
g3230863的博客
07-04 241
springboot封装请求参数json的源码解析
spring二级缓存三级缓存
10-18
Spring框架中的二级缓存和三级缓存都是用来提高应用程序性能的。其中，二级缓存是在SessionFactory级别上的缓存，而三级缓存是在SessionFactoryBuilder级别上的缓存。 二级缓存是Hibernate提供的一种缓存机制，它可以将查询结果缓存到内存中，以便下次查询时可以直接从缓存中获取数据，而不必再次查询数据库。二级缓存可以提高应用程序的性能，减少数据库的访问次数，但也会带来一些问题，比如数据不一致等。 Spring框架中的三级缓存是指在SessionFactoryBuilder级别上的缓存，它可以将SessionFactoryBuilder对象缓存到内存中，以便下次创建SessionFactory时可以直接从缓存中获取对象，而不必再次创建。三级缓存可以提高应用程序的性能，减少对象创建的时间和资源消耗。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值