spring学习笔记

最新推荐文章于 2024-08-24 14:38:34 发布
最新推荐文章于 2024-08-24 14:38:34 发布
阅读量105 收藏
点赞数
分类专栏： java 文章标签： spring java ioc 依赖注入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43587190/article/details/117371391
版权

Spring相关API

体系结构
Spring的API体系异常庞大，我们现在只关注两个BeanFactory和ApplicationContext

BeanFactory

BeanFactory是IOC的核心接口，他定义了IOC的基本功能。

ApplicationContext

ApplicationContext代表应用上下文对象 ，可以获得springIOC容器中的Bean对象

ApplicationContext和 BeanFactory 的区别？

//使用ClassPathXmlApplicationContext 获取spring上下文对象，借助上下文对象可以获取到IOC容器中的bean对象，它再加载配置文件的同时就创建了bean对象到容器中
 ApplicationContext applicationContext = new   ClassPathXmlApplicationContext("applicationContext.xml");

//使用上下文对象从IOC容器中获取bean
 IUserDao userDao = (IUserDao) applicationContext .getBean("userDao");


 //核心接口  这一步不会创建bean对象  存到容器中的
BeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

//getBean的时候 才正真的创建bean对象
IUserDao userDao = (IUserDao) xmlBeanFactory.getBean("userDao");

从上面代码来说
ApplicationContext 在加载核心配置文件 的时候就去创建了bean对象到容器
BeanFactory 是真正在getBean的时候才去创建bean对象

ApplicationContext常用的实现类

  1. ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件 推荐使用这种。
  2. FileSystemXmlApplicationContext 它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
  3. AnnotationConfigApplicationContext 当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

常用方法

// 根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。 
Object getBean(String name);

//根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。
<T> T getBean(Class<T> requiredType); 

//根据Bean的id和类型获得Bean实例，解决容器中相同类型Bean有多个情况。 
<T> T getBean(String name,Class<T> requiredType);

Spring配置文件

Bean标签的基本配置

 <!--
 	bean标签：在spring配置文件中配置 userDaoImpl
    id:Bean实例在spring容器中的唯一标识，使用过程中根据这个id才能在spring中找到我们需要的Bean
    class:Bean的全限定名（spring底层采用反射来生成该类的实例，所以必须要放该类的全限定名）
    -->
<bean id = "唯一标识" class="类的全路径名"></bean>
<!--
	默认情况下它是调用类中的无参构造函数进行对象创建，如果没有无参构造函数则不能创建对象
-->

Bean标签的范围配置

  <bean id="" class="" scope="作用范围"></bean>

scope属性指对象的作用范围，取值如下：

取值范围说明
singleton默认值，单例的
prototype多例的
requestWEB项目中，Spring创建一个Bean的对象，将对象存入到request域中
sessionWEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global sessionWEB项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession 相当于 session
 	/**
     * <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl" scope="singleton" ></bean>
     * 测试 scope为singleton的情况下 bean的创建情况
     */
    @Test
    public void test03(){

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        //userDao1
        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao1);

        //userDao2
        IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao2);
    }

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


    /**
     * <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl" scope="prototype" ></bean>
     * 测试 scope为prototype的情况下 bean的创建情况
     */
    @Test
    public void test04(){

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        //userDao1
        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao1);

        //userDao2
        IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao2);
    }

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

1.当scope的取值为singleton时
			Bean的实例化个数：1个
			Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean的实例
			Bean的生命周期：
				对象创建：当容器加载，创建容器时，对象就被加载了
				对象运行：只要容器在，对象一直活着
				对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2.当scope的取值为prototype时
			Bean的实例化个数：多个
			Bean的实例化时机：当调用getBean()方法时实例化Bean
			Bean的生命周期：
				对象创建：当使用对象时，对象就被加载了
				对象运行：只要对象在使用中，对象一直活着
				对象销毁：当对象长时间不用时，被Java的垃圾回收器回收

bean声明周期配置

bean id="" class="" scope="" init-method="" destroy-method=""></bean> 

* init-method：指定类中的初始化方法名称 

* destroy-method：指定类中销毁方法名称

Bean实例化三种方式

  • 无参构造方法实例化
  • 工厂静态方法实例化
  • 工厂普通方法实例化

无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>

工厂静态方法实例化

依赖的jar包中有个A类，A类中有个静态方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

public class StaticFactoryBean { 

	public static UserDao createUserDao(){ 
		return new UserDaoImpl(); 
	} 
}

<bean id="userDao" class="com.lagou.factory.StaticFactoryBean" factory-method="createUserDao" />

工厂普通方法实例化

依赖的jar包中有个A类，A类中有个普通方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

public class DynamicFactoryBean{ 

	public UserDao createUserDao(){ 
		return new UserDaoImpl(); 
	} 
}

<bean id="dynamicFactoryBean" class="com.lagou.factory.DynamicFactoryBean"/> 
<bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao"/>

Bean依赖注入概述

依赖注入 DI（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。
在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

Bean依赖注入方式

构造方法

public class UserServiceImpl implements UserService { 

private UserDao userDao; 

public UserServiceImpl(UserDao userDao) { 
	this.userDao = userDao; 
}

@Override public void save() { 
		userDao.save(); 
	} 
}

配置Spring容器调用有参构造时进行注入

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl"> 
<!--<	<constructor-arg index="0" type="com.lagou.dao.UserDao" ref="userDao"/> - ->
	<constructor-arg name="userDao" ref="userDao"/> </bean>

set方法

public class UserServiceImpl implements UserService { 

private UserDao userDao; 

public void setUserDao(UserDao userDao) { 
	this.userDao = userDao;
}

@Override public void save() { 
		userDao.save(); 
	} 
}

配置Spring容器调用set方法进行注入

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl"> 
	<property name="userDao" ref="userDao"/>

P命名空间注入

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中，如下：
首先，需要引入P命名空间：

xmlns:p="http://www.springframework.org/schema/p"

其次，需要修改注入方式：

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

Bean依赖注入的数据类型

注入数据的三种数据类型
1. 普通数据类型
2. 引用数据类型
3. 集合数据类型

public class User { 
	private String username; 
	private String age; 
	
	public void setUsername(String username) { 
		this.username = username; 
	}
	
	public void setAge(String age) { 
		this.age = age; 
	} 
}

<bean id="user" class="com.lagou.domain.User"> 
	<property name="username" value="jack"/> 
	<property name="age" value="18"/> 
</bean>

注入集合数据类型
1）List集合注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
    private List<Object> list;
    
    public void setList(List<Object> list) {
        this.list = list;
    }
 }   

    <!--进行list集合数据类型的注入-->
        <property name="list">
            <list>
                <value>aaa</value>
                <ref bean="user"></ref>
            </list>
        </property>

2）Set集合注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
    private Set<Object> set;
    
     public void setSet(Set<Object> set) {
        this.set = set;
    }
 }   

    <!--进行set集合数据类型的注入-->
        <property name="set">
            <set>
                <value>bbb</value>
                <ref bean="user"></ref>
            </set>
        </property>

3）Array数组注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
   private Object[] array;
    
      public void setArray(Object[] array) {
        this.array = array;
    }
}

   <!--进行array数组数据类型的注入-->
        <property name="array">
            <array>
                <value>ccc</value>
                <ref bean="user"></ref>
            </array>
        </property>

4）Map集合注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
 private Map<String,Object> map;
    
   public void setMap(Map<String, Object> map) {
        this.map = map;
    }
}

    <!--进行map集合数据类型的注入-->
        <property name="map">
            <map>
                <entry key="k1" value="ddd"></entry>
                <entry key="k2" value-ref="user"></entry>
            </map>
        </property>

5）Properties配置注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
private Properties properties;
    
   public void setProperties(Properties properties) {
        this.properties = properties;
    }
}

    <!--进行map集合数据类型的注入-->
        <!--进行properties数据类型的注入-->
        <property name="properties">
            <props>
                <prop key="k1">v1</prop>
                <prop key="k2">v2</prop>
                <prop key="k3">v3</prop>
            </props>
        </property>

配置文件模块化

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，也就是所谓的配置文件模块化。

1）并列的多个配置文件

ApplicationContext act = new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");

2）主从配置文件

<import resource="applicationContext-xxx.xml"/>

注意：

  • 同一个xml中不能出现相同名称的bean,如果出现会报错
  • 多个xml如果出现相同名称的bean，不会报错，但是后加载的会覆盖前加载的bean

DbUtils是什么？

DbUtils是Apache的一款用于简化Dao代码的工具类，它底层封装了JDBC技术。

核心对象

QueryRunner queryRunner = new QueryRunner(DataSource dataSource);

核心方法

//执行增、删、改语句
int update(); 

//执行查询语句 ResultSetHandler<T> 这是一个接口，主要作用是将数据库返回的记录封装到实体对象
T query();

抽取jdbc配置文件
applicationContext.xml加载jdbc.properties配置文件获得连接信息。
首先，需要引入context命名空间和约束路径：

* 命名空间： 
* xmlns:context="http://www.springframework.org/schema/context" 

* 约束路径： 
* http://www.springframework.org/schema/context 
* http://www.springframework.org/schema/context/spring-context.xsd

context:property-placeholder

<context:property-placeholder location="classpath:jdbc.properties"

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> 
	<property name="driverClassName" value="${jdbc.driver}"></property> 
	<property name="url" value="${jdbc.url}"></property> 
	<property name="username" value="${jdbc.username}"></property> 
	<property name="password" value="${jdbc.password}"></property>
 </bean>
/>

Spring注解开发

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。
Spring常用注解主要是替代 的配置

注解说明
@Component使用在类上用于实例化Bean
@Controller使用在web层类上用于实例化Bean
@Service使用在service层类上用于实例化Bean
@Repository使用在dao层类上用于实例化Bean
@Autowired使用在字段上用于根据类型依赖注入
@Qualifier结合@Autowired一起使用,根据名称进行依赖注入
@Resource相当于@Autowired+@Qualifier，按照名称进行注入
@Value注入普通属性
@Scope标注Bean的作用范围

说明：
JDK11以后完全移除了javax扩展导致不能使用@resource注解

需要maven引入依赖 
<dependency> 
	<groupId>javax.annotation</groupId> 
	<artifactId>javax.annotation-api</artifactId> 
	<version>1.3.2</version> 
</dependency>

注意
使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。

<!--注解的组件扫描--> <context:component-scan base-package="com.lagou"></context:component-scan>

1）Bean实例化（IOC）
使用@Compont或@Repository标识UserDaoImpl需要Spring进行实例化。

// @Component(value = "userDao") 
@Repository // 如果没有写value属性值，Bean的id为：类名首字母小写 
public class UserDaoImpl implements UserDao { 
}

2）属性依赖注入（DI）
使用@Autowired或者@Autowired+@Qulifier或者@Resource进行userDao的注入

@Autowired private UserDao userDao; 

// <property name="userDao" ref="userDaoImpl"/> 
// @Autowired 
// @Qualifier("userDaoImpl") 
// @Resource(name = "userDaoImpl")

3）@Value
使用@Value进行字符串的注入，结合SPEL表达式获得配置参数

@Value("注入普通数据") 
private String str; 

@Value("${jdbc.driver}") 
private String driver;

4）@Scope
使用@Scope标注Bean的范围

@Service 
@Scope("singleton") 
public class UserServiceImpl implements UserService {
}

使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：

* 非自定义的Bean的配置：<bean>

* 加载properties文件的配置：<context:property-placeholder>

* 组件扫描的配置：<context:component-scan>

* 引入其他文件：<import>
注解说明
@Configuration用于指定当前类是一个Spring 配置类，当创建容器时会从该类上加载注解
@Bean使用在方法上，标注将该方法的返回值存储到 Spring 容器中
@PropertySource用于加载 properties 文件中的配置
@ComponentScan用于指定 Spring 在初始化容器时要扫描的包
@Import用于导入其他配置类

Spring核心配置类

@Configuration 
@ComponentScan("com.lagou") 
@Import(DataSourceConfig.class) 
public class SpringConfig { 

	@Bean("queryRunner") 
	public QueryRunner getQueryRunner(@Autowired DataSource dataSource) { 
		return new QueryRunner(dataSource); 
		} 
}

数据库配置信息类

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfig {
@Value("${jdbc.driver}") 
private String driver; 

@Value("${jdbc.url}") 
private String url; 

@Value("${jdbc.username}") 
private String username; 

@Value("${jdbc.password}") 
private String password;

@Bean("dataSource") 
public DataSource getDataSource() { 
	DruidDataSource dataSource = new DruidDataSource(); 
	dataSource.setDriverClassName(driver);
	dataSource.setUrl(url); 
	dataSource.setUsername(username); 
	dataSource.setPassword(password); 
	return dataSource;
} 
}

Spring整合Junit

普通Junit测试问题
在普通的测试类中，需要开发者手动加载配置文件并创建Spring容器，然后通过Spring相关API获得Bean实例；如果不这么做，那么无法从容器中获得对象。

  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        //userDao1
        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao1);

我们可以让SpringJunit负责创建Spring容器来简化这个操作，开发者可以直接在测试类注入Bean实
例；但是需要将配置文件的名称告诉它。

  1. 导入spring集成Junit的坐标
  2. 使用@Runwith注解替换原来的运行器
  3. 使用@ContextConfiguration指定配置文件或配置类
  4. 使用@Autowired注入需要测试的对象
  5. 创建测试方法进行测试

2）使用@Runwith注解替换原来的运行器

@RunWith(SpringJUnit4ClassRunner.class) 
public class SpringJunitTest { }

3）使用@ContextConfiguration指定配置文件或配置类

@RunWith(SpringJUnit4ClassRunner.class) 
//@ContextConfiguration(value = {"classpath:applicationContext.xml"}) 加载spring 核心配置文件 
@ContextConfiguration(classes = {SpringConfig.class}) // 加载spring核心配置类 
public class SpringJunitTest { }
FS370
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring详解-------依赖注入的三种方式实例详解
qq_40941100的博客
03-02 1万+
1、什么是依赖注入 DI (Dependency Injection)：依赖注入是指在 Spring IOC 容器创建对象的过程中，将所 依赖的对象通过配置进行注入。我们可以通过依赖注入的方式来降低对象间的耦合度。 在软件工程中，对象之间的耦合度就是对象之间的依赖性。对象之间的耦合越高，维护 成本越高，因此对象的设计应使对象之间的耦合越小越好。 1.1类的关系 继承 实现 依赖 关联 聚合 组合 1.1.1 依赖关系（Dependen...
IOC配置（xml格式）二
凉茶铺的博客
02-19 590
介绍了IoC文件的配置参数。
Spring常用的三种注入方式
weixin_42265148的博客
03-08 195
Spring通过DI（依赖注入）实现IOC（控制反转），常用的注入方式主要有三种：构造方法注入，setter注入，基于注解的注入。 构造方法注入 先简单看一下测试项目的结构，用maven构建的，四个包： entity：存储实体，里面只有一个User类 dao：数据访问，一个接口，两个实现类 service：服务层，一个接口，一个实现类，实现类依赖于IUserDao test：测试包 在sp...
Spring基础学习笔记（五）
qq_37438795的博客
12-23 387
目录   dao-service-action依赖注入（三层小整合）       User       UserDao       UserService       UserAction       配置文件（bean.xml）       MainTest（测试类） 运行结果 容易出现的问题    空指针异常 dao-service-action依赖注入（三层小整合） ...
spring属性的配置注入和注解注入
cxxxgo的博客
03-17 552
spring属性的配置注入 三种简单属性的配置注入 1、se方式注入 一个User对象，想通过set方法注入，那么在User中我们首先要提供set方法 然后在Spring配置文件中做如下配置： 代码测试： ApplicationContext context = new ClassPathXmlApplicationContext(""); 通过上下文获取管理bean的实例 测试结果： 张三 2、构造方法注入 有一个User1，User1中有一个变量叫做username，我希望通过构造方法给它注入值，
javaSpring学习笔记
03-12
“Java Spring学习笔记”是一份宝贵的资源，专门为想要学习和掌握Java Spring框架的开发者而设计。这份学习笔记提供了详细而系统的教程和实践指南，帮助初学者快速入门，并带领已经有一定经验的开发者深入理解和应用...
spring 学习笔记
05-08
下面将根据“spring 学习笔记”的主题，对Spring框架进行深入的探讨。 一、依赖注入（DI） 依赖注入是Spring的核心功能，它允许对象之间的依赖关系在运行时动态地管理和配置，而不是在代码中硬编码。这样可以提高...
Spring学习笔记 自我总结
11-02
spring学习笔记
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
spring的配置文件-applicationContext.xml
热门推荐
一路向北
08-28 1万+
1.<beans>标签是spring的配置文件的根标签，其包含相关的命名空间，用于约束子标签的标识 <?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:aop="http://www.s
spring的配置说明和属性抽取 ref注入属性及parent属性继承，实例1
weixin_46377527的博客
02-27 496
实体类 package indi.yxq.spring.entity; public class User { private Integer user_id; private String user_name; public User() { System.out.println("User类构造方法"); } public void setUser_id(Integer use...
java springboot 集成activeMQ（保姆级别教程）
m0_50641264的博客
08-23 137
java springboot 集成activeMQ（保姆级别教程）
SpringBoot整合MQ
最新发布
weixin_55772633的博客
08-24 404
springboot整合ActiveMQ提供了JmsMessagingTemplate对象作为客户端操作消息队列操作ActiveMQ需要配置ActiveMQ服务器地址，默认端口61616企业开发时通常使用监听器来处理消息队列中的消息，设置监听器使用注解@JmsListener配置jms的pub-sub-domain属性可以在点对点模型和发布订阅模型间切换消息模型。
Spring 中AbstractApplicationContext
小湘西的博客
08-20 844
是 Spring Framework 中的一个抽象类，位于包中。它带有一系列的实现，主要用于为 Spring 的应用上下文提供基本的功能。所有的 Spring 应用上下文实现（如等）通常都直接或间接地扩展该类。
用基础项目来理解spring的作用
weixin_64922330的博客
08-20 576
用基础项目来理解spring的作用
Java--SpringBoot工厂模式
qq_56438516的博客
08-20 874
Spring Boot是一个基于Spring框架的快速开发框架，它提供了许多便利的功能来简化企业级应用的开发。在Spring Boot中，工厂模式是一种常用的设计模式，它用于创建对象，但是不需要指定将要创建的具体类。工厂模式隐藏了实例化对象的具体细节，并且允许系统在不修改客户端代码的情况下引入新的类。
SpringBoot 注解指南
weixin_51582215的博客
08-23 537
基于 SpringBoot 平台开发的项目数不胜数，与常规的基于Spring开发的项目最大的不同之处，SpringBoot 里面提供了大量的注解用于快速开发，而且非常简单，基本可以做到开箱即用！那 SpringBoot 为开发者提供了多少注解呢？我们该如何使用？通常用于修饰controller层的组件，由控制器负责将用户发来的URL请求转发到对应的服务接口，通常还需要配合注解使用。提供路由信息，负责URL到Controller中具体函数的映射，当用于方法上时，可以指定请求协议，比如GETPOSTPUT。
linux使用nginx部署springboot + vue分离项目
技术分享
08-20 105
linux使用nginx部署springboot + vue分离项目。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值