java架构学习——23. SpringIOC与AOP

最新推荐文章于 2022-07-25 23:54:12 发布
最新推荐文章于 2022-07-25 23:54:12 发布
阅读量128 收藏
点赞数 1
分类专栏： java架构学习 文章标签： springIOC springAOP spring的作用域
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmq_fly/article/details/84890821
版权

本篇博文主要包含：

  • springIOC（控制反转）
  • DI（依赖注入）
  • AOP（切面编程）
    -Spring的环境搭建
  • spring作用域
    -singleton：表示一个容器对应一个bean
    -prototype：每一次请求都会产生一个新的bean实例
    -request：每一次HTTP请求都会产生一个新的bean
    -session：针对每一次HTTP请求都会产生一个新的bean
  • 作用域的配置
    -xml 方式配置
    -注解方式配置
  • SpringIOC 容器
    -容器创建对象的方式
    -依赖注入的方式
    -注解版本使用
  • 注解方式实现AOP编程
    -使用注解
    -使用xml方式配置

一、Spring的概述

  1. springIOC（控制反转）
    所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。
    由Ioc容器来控制了外部资源获取（不只是对象包括比如文件等），由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

  2. DI（依赖注入）
    IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。

  3. AOP（切面编程）

二、Spring的环境搭建

  1. 引入架包依赖
		<!-- 引入Spring-AOP等相关Jar -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>3.0.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>3.0.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>3.0.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>3.0.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>1.8.9</version>
		</dependency>
		<dependency>
		    <groupId>org.aspectj</groupId>
		    <artifactId>aspectjweaver</artifactId>
		    <version>1.8.9</version>
		    </dependency>
		<dependency>
			<groupId>cglib</groupId>
			<artifactId>cglib</artifactId>
			<version>2.1_2</version>
		</dependency>
  1. 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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">	
	<bean id="userEntity" class="com.spring.UserEntity" />
	<!--  扫包 -->
	<context:component-scan base-package="com.spring"></context:component-scan>
	<!--  开启事物注解权限 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy> 
</beans>
  1. 需要交给Spring管理注入类
package com.spring;

public class UserEntity {
	
	private String name;
	
	private Integer age;

	public String getName() {
		return name;
	}

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

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "UserEntity [name=" + name + ", age=" + age + "]";
	}

}
  1. 测试类
package com.spring;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
		UserEntity userEntity = (UserEntity) applicationContext.getBean("userEntity");
		userEntity.setName("ly");
		userEntity.setAge(18);
		System.out.println(userEntity);
	}
}

运行结果：
在这里插入图片描述

三、spring作用域
spring Ioc创建模式默认为单例模式（可以使用无参构造函数验证），单例是线程不安全的。

  1. singleton
    当一个bean的 作用域设置为singleton, 那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。换言之，当把 一个bean定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都 将返回被缓存的对象实例，这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的，单例设计模式表示一个ClassLoader中 只有一个class存在，而这里的singleton则表示一个容器对应一个bean，也就是说当一个bean被标识为singleton时 候，spring的IOC容器中只会存在一个该bean。

  2. prototype
    prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的 getBean()方法）都会产生一个新的bean实例，相当与一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。 清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的职责。（让Spring容器释放被singleton作用域bean占用资源的一种可行方式是，通过使用 bean的后置处理器，该处理器持有要被清除的bean的引用。）

  3. request
    request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效。

  4. session
    session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效。

  5. 作用域的配置
    5.1 xml 方式配置

    <!-- 无参构造函数的方式 -->
	<bean id="userEntity" class="com.spring.UserEntity"  scope="singleton"/>
	<!-- 有参构造函数的方式 -->
	<bean id="userEntity3" class="com.spring.UserEntity" >
		<constructor-arg name="name" value="lucy"></constructor-arg>
		<constructor-arg name="age" value="20"></constructor-arg>
	</bean>

5.2 注解方式配置

@Scope(@Scope(ConfigurableListableBeanFactory.SCOPE_SINGLETON))
public class UserEntity {
	
	private String name;
	
	private Integer age;

	public String getName() {
		return name;
	}

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

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "UserEntity [name=" + name + ", age=" + age + "]";
	}

}

四、SpringIOC 容器
SpringIOC容器，是spring核心内容。
作用： 创建对象 ； 处理对象的依赖关系。

  1. 容器创建对象的几种方式
    1） 调用无参数构造器
    2） 带参数构造器
    3） 工厂创建对象
    工厂类，静态方法创建对象
    工厂类，非静态方法创建对象

  2. 依赖注入的几种方式
    1） 通过构造函数
    2） 通过set方法给属性注入值
    3） p名称空间
    4） 注解

  3. 注解版本使用
    注解方式可以简化spring的IOC容器的配置。
    使用注解步骤：

1）先引入context名称空间

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

2）开启注解扫描

<context:component-scan base-package="com.spring"></context:component-scan>

3）使用注解
通过注解的方式，把对象加入ioc容器。
创建对象以及处理对象依赖关系，相关的注解：

@Component     指定把一个对象加入IOC容器
@Repository    作用同@Component； 在持久层使用
@Service       作用同@Component； 在业务逻辑层使用
@Controller    作用同@Component； 在控制层使用 
@Resource      属性注入

总结：
1） 使用注解，可以简化配置，且可以把对象加入IOC容器,及处理依赖关系(DI)
2） 注解可以和XML配置一起使用。
4. 实现AOP编程
4.a 使用注解

@Aspect									指定一个类为切面类		
@Pointcut("execution(* com.spring..*(..))")  指定切入点表达式

@Before("pointCut_()")					前置通知: 目标方法之前执行
@After("pointCut_()")					后置通知：目标方法之后执行（始终执行）
@AfterReturning("pointCut_()")	    返回后通知： 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()")			异常通知:  出现异常时候执行
@Around("pointCut_()")					环绕通知： 环绕目标方法执行

4.1 开启事物注解权限

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4.2 代码实现
切面类springAop：

//指定一个类为切面类
@Aspect
//注入Spring IOC容器
@Component
public class springAop {
	
	//定义切入点
	@Pointcut("execution(* com.spring..*(..))")
    public void performance() {

    }
	
	//前置通知: 目标方法之前执行
	@Before("performance()")
	public void begin() {
		System.out.println("前置通知");
	}
	
	//后置通知：目标方法之后执行（始终执行）
	@After("performance()")
	public void commit() {
		System.out.println("后置通知");
	}
	
	// 返回后通知： 执行方法结束前执行(异常不执行)
	@AfterReturning("performance()")
	public void afterReturning() {
		System.out.println("运行通知");
	}
	
	//异常通知:  出现异常时候执行
	@AfterThrowing("performance()")
	public void afterThrowing() {
		System.out.println("异常通知");
	}
	
	//环绕通知： 环绕目标方法执行
	@Around("performance()")
	public void around(ProceedingJoinPoint pjp) throws Throwable {
       System.out.println("我是环绕通知-前");
    // HttpServletRequest request =((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest(); 
       String methodName = pjp.getSignature().getName();
       System.out.println("aop===方法名："+methodName);
       pjp.proceed();
       String className = pjp.getTarget().getClass().getName();
       System.out.println("aop===类名："+className);
       System.out.println("我是环绕通知-后");
	}
}

测试类：

public class SpringTest {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
		UserService userService = (UserService) applicationContext.getBean("userService");
		userService.add();
	}
}

运行结果：
在这里插入图片描述
4.b 使用xml方式配置
4.1） 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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">	
        
	<context:component-scan base-package="com.spring"></context:component-scan>
	<!-- 切面类 -->
	<bean id="aop" class="com.spring.springAopXml"></bean>
	
	<!-- Aop配置 -->
	<aop:config>
		<!-- 定义一个切入点表达式： 拦截哪些方法 -->
		<aop:pointcut expression="execution(* com.spring..*(..))" id="pt"/>
		<!-- 切面 -->
		<aop:aspect ref="aop">
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pt"/>
			<!-- 前置通知： 在目标方法调用前执行 -->
			<aop:before method="begin" pointcut-ref="pt"/>
			<!-- 后置通知： -->
			<aop:after method="after" pointcut-ref="pt"/>
			<!-- 返回后通知 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pt"/>
			<!-- 异常通知 -->
			<aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
		</aop:aspect>
	</aop:config>
	
</beans>

4.2）切面类springAopXml：

public class springAopXml {
	
	public springAopXml() {
		super();
	}

	//前置通知: 目标方法之前执行
	public void begin() {
		System.out.println("前置通知");
	}
	
	//后置通知：目标方法之后执行（始终执行）
	public void after() {
		System.out.println("后置通知");
	}
	
	// 返回后通知： 执行方法结束前执行(异常不执行)
	public void afterReturning() {
		System.out.println("运行通知");
	}
	
	//异常通知:  出现异常时候执行
	public void afterThrowing() {
		System.out.println("异常通知");
	}
	
	//环绕通知： 环绕目标方法执行
	public void around(ProceedingJoinPoint pjp) throws Throwable {
       System.out.println("我是环绕通知-前");
      // HttpServletRequest request =((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest(); 
       String methodName = pjp.getSignature().getName();
       System.out.println("===方法名："+methodName);
       pjp.proceed();
       String className = pjp.getTarget().getClass().getName();
       System.out.println("===类名："+className);
       System.out.println("我是环绕通知-后");
	}
}

4.3）测试类

public class SpringTest {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
		UserService userService = (UserService) applicationContext.getBean("userService");
		userService.add();
	}
}

运行结果：
在这里插入图片描述

wmq_fly
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
helloAop.zip 内含spring ioc,aop例子
01-14
内含spring ioc,aop例子，了解IOC，AOP原理
Spring学习总结——Spring实现IoC的多种方式
m0_68850571的博客
04-19 3092
一、Spring框架概述 1.1、资源 1.2、Spring历史 1.3、框架特征与功能 1.4、Spring组成 1.5、Spring Boot与Spring Cloud 二、IoC基础 三、使用XML配置的方式实现IOC 3.1、使用无参构造方法创建对象 3.2、使用有参构造方法创建对象 3.3、通过属性赋值 3.4、对象引用 3.5、对象作用域 3.6、延迟初始化bean 四、使用Spring注解配置IOC 4.1、修改BookDAO 4.2
Spring IoC和AOP的实现原理解析
weixin_41979002的博客
07-27 280
文章目录前言概述IoCSpring IoC底层原理IOC的简单模拟实现AOPSpring AOP底层原理代理模式动态代理JDK代理模式CGLib代理模式Spring两种代理方式 前言 本编文章主要参考了两位博主的博文，原文链接如下 概念的原文链接：https://www.cnblogs.com/swordfall/p/12880809.html 示例的原文链接：https://www.jianshu.com/p/78ba8bafb90a 概述 Spring核心概念为IoC和AOP。 IoC Spring I
BeanPostProcessor——连接Spring IOC和AOP的桥梁
weixin_33743661的博客
06-20 190
讲解思路：BBP怎么用 —— 先学会怎么用，再去看原理BBP的触发时机 —— 在整个Spring Bean初始化流程中的位置BBP自己又是什么时候被创建的？BBP是如何连接IOC和AOP的？怎么用BeanPostProcessor，直译过来，就是“对象后处理器”， 那么这个“后”，是指什么之后呢？试试便知。我们先写一个对象，Bean4BBP（ 本文的所有代码，可到 Github 上下载 ）：@Co...
SSM框架——1.spring的下载、安装与测试
白菜小皮艇的博客
01-21 1030
spring 开放源代码的JavaEE框架，Rod Johnson发起 Spring架构图 Spring 5.3.3 API文档 1.新建项目 新建javaProject/javaWeb工程 导入jar包 下载Spring的jar包地址： 1+7（1是spring中jar要用到的jar包） 7 spring的jar包 创建实体类 实现序列化接口 bean的约束（id和name除命名规则差异，使用效果无异）（写上完整包名） 属性赋值 ApplicationContext获取bean对象 找
Spring——以IOC、AOP为核心的轻量级框架
胖虎虎
07-25 1014
​Spring是于2003年兴起的一个轻量级的Java开发框架，它是为了解决企业应用开发的复杂性而创建的。spring的核心是控制反转（IOC）和面向切面编程（AOP）。Spring是可以在JavaSE/EE中使用的轻量级开源框架。​Spring的主要作用就是为代码“解耦”，降低代码间的耦合度。就是让对象和对象（模块和模块）之间关系不是使用代码关联，而是通过配置来说明。即在Spring中说明对象（模块）的关系。//无参构造方法是为spring提供创建对象。............
Spring IOC和AOP代码与笔记整理
12-07
彻底学会Spring的IOC和AOP——理论+实操，参考：https://blog.csdn.net/qq_39735940/article/details/121754987
java SSH框架架构学习_笔记.struts,spring,hibernate. IOC,AOP,JDBC,编写个留言管理系统网站
01-24
java SSH框架架构学习_笔记.zip java SSH框架架构学习_笔记.struts,spring,hibernate. IOC,AOP,JDBC,编写个留言管理系统网站
Spring IOC和aop的原理及实例详解
08-25
主要介绍了Spring IOC和aop的原理及实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringIOC和AOP原理设计模式
01-27
在接触Spring的过程中，听到最多的无非两个名词，一个是控制反转一个是依赖注入。实际这是一个意思，控制反转代表原来由程序本身去控制对象之间的依赖关系的这种格局被反转了，通过第三方容器（IOC）去完成控制这些...
java架构学习——17. 表单重复提交&防止模拟请求&跨域解决方案&XSS攻击
wmq_fly的博客
02-15 719
一、http长连接与短连接 在HTTP/1.0中，默认使用的是短连接。也就是说，浏览器和服务器每进行一次HTTP操作，就建立一次连接，但任务结束就中断连接。如果客户端浏览器访问的某个HTML或其他类型的 Web页中包含有其他的Web资源，如JavaScript文件、图像文件、CSS文件等；当浏览器每遇到这样一个Web资源，就会建立一个HTTP会话。 但从 HTTP/1.1起，默认使用长连接，用以保...
java架构学习——15. Cookie与Session实现原理&外网映射工具的使用
wmq_fly的博客
02-15 455
一、Web开发入门 1、软件的结构 C/S (Client - Server 客户端-服务器端) 典型应用：QQ软件 ，飞秋，红蜘蛛。 特点： 1）必须下载特定的客户端程序。 2）服务器端升级，客户端升级。 B/S （Broswer -Server 浏览器端- 服务器端） 典型应用： 腾讯官方（www.qq.com） 163新闻网站， 蚂蚁课堂官网（俗称：网站） 特点： 1）不需要安装特定的...
java架构学习——13. 垃圾回收机制算法分析&使用Jmeter压力测试工具
wmq_fly的博客
02-14 343
一、基本概念 什么是垃圾回收机制？ 垃圾回收机制不定时，向堆内存清理不可达对象。 手动GC回收 代码演示： public class GcDemo { public static void main(String[] args) { GcDemo gc = new GcDemo(); //将对象设置为不可达，垃圾回收机制将对其进行回收 gc = null; //手动...
java架构学习——12. JVM参数调优配置
wmq_fly的博客
02-14 289
一、 自动内存管理机制 Java虚拟机原理 所谓虚拟机，就是一台虚拟的机器。他是一款软件，用来执行一系列虚拟计算指令，大体上虚拟机可以分为 系统虚拟机和程序虚拟机， 大名鼎鼎的Visual Box、Vmare就属于系统虚拟机，他们完全是对物理计算的仿真，提供了一个可以运行完整操作系统的软件平台。 程序虚拟机典型代码就是Java虚拟机，它专门为执行单个计算程序而计算，在Java虚拟机中执行的指令我...
java架构学习——4. java并发包&信号量&并发队列
wmq_fly的博客
02-12 270
一、同步容器类 Vector与ArrayList区别： ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插...
java架构学习——11. Netty高级
wmq_fly的博客
02-14 253
一、TCP粘包、拆包问题解决方案 什么是粘包/拆包 一个完整的业务可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这个就是TCP的拆包和封包问题。 下面可以看一张图，是客户端向服务端发送包： 1.） 第一种情况，Data1和Data2都分开发送到了Server端，没有产生粘包和拆包的情况。 2.）第二种情况，Data1和Data2数据粘在了一起，打成了一个大...
java架构学习——5. 线程池原理剖析&锁的深度化
wmq_fly的博客
02-12 252
一、线程池 什么是线程池 Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序 都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗...
java架构学习——16. 深入理解Http协议&反盗链技术&使用时间戳解决浏览器缓存
wmq_fly的博客
02-15 245
一、深入理解Http协议 1、什么是http协议 对浏览器客户端和服务器端之间数据传输的格式规范。 2、http协议内容 2.1 请求（浏览器-》服务器） Accept: text/html,image/* - - 浏览器接受的数据类型 Accept-Charset: ISO-8859-1 - - 浏览器接受的编码格式 Accept-Encoding: gzip,compre...
java架构学习——28. SpringBoot高级
wmq_fly的博客
02-19 220
一、springboot整合多数据源 项目目录： 数据库目录： 建表语句： CREATE TABLE `users` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(40) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, `age` int...
Spring IOC 与 AOP
最新发布
04-25
Spring IOC(Inversion of Control) 是一种设计模式，它使用依赖注入的方式来实现对象之间的解耦。在IOC容器中，所有的对象都由容器来创建，并且对象之间的依赖关系由容器进行维护，这样可以将应用程序中各个部分解耦...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值