详解Spring框架的AOP功能,附源码

Spring AOP源码解读 aop 是什么 AOP (Aspect-Oriented Programming,面向切面编程),可以说是 OOP 的补充和完善。OOP 引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候,OOP 则显得无能为力。OOP 允许你定义从上到下的关系,但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码,如安全性、异常处理和透明的持续性也是如此。这种散布 阅读详情

Spring的两大核心功能是IOC和AOP。当我们使用Spring的AOP功能时是很方便的。只需要进行下面的配置即可。

Copy@Component
@Aspect
public class MyAspect {

//PointCut匹配的方法必须是Spring中bean的方法
//Pointcut可以有下列方式来定义或者通过&& || 和!的方式进行组合.
//下面定义的这些切入点就可以通过&& ||组合

private static Logger logger = LoggerFactory.getLogger(MyAspect.class);

//*:代表方法的返回值可以是任何类型
//整个表达式匹配controller包下面任何的的echo方法,方法入参乐意是任意
@Pointcut("execution(* com.csx.demo.spring.boot.controller.*.echo(..))")
public void pointCut1(){}

@Before("pointCut1()")
public void befor(){
    logger.info("前置通知vvvv...");
    logger.info("我要做些事情...");
}
}

然后再开启注解

Copy//自动选择合适的AOP代理
//传统xml这样配置:<aop:aspectj-autoproxy/>

//exposeProxy = true属性设置成true,意思是将动态生成的代理类expose到AopContext的ThreadLocal线程
//可以通过AopContext.currentProxy();获取到生成的动态代理类。

//proxyTargetClass属性设置动态代理使用JDK动态代理还是使用CGlib代理,设置成true是使用CGlib代理,false的话是使用JDK动态代理

//注意:如果使用Spring Boot的话,下面的配置可以不需要。AopAutoConfiguration这个自动配置类中已经自动开启了AOP
//默认使用CGLIB动态代理,Spring Boot配置的优先级高于下面的配置

@Configuration
@EnableAspectJAutoProxy(exposeProxy = true,proxyTargetClass = false)
public class AopConfig {

}

通上面的配置,当我们调用controller包下面的任何类的echo方法时就会触发前置通知。其实这个说法不是很准确。因为我们调用的类已经不是我们自己写的类了。而是Spring框架通过动态代理生成的类。

稍微了解一点Spring AOP的同学都会知道Spring的AOP是通过动态代理实现的。那Spring是怎么生成动态代理类,并将Advice织入代理类的呢?整个流程是怎样的呢?下面就分析下Spring生成动态代理类的过程。

需要说明下的是,本博客旨在梳理整个AOP动态代理的过程,细节方面需要大家自己去看。

@EnableAspectJAutoProxy干了些啥

如果让你从头开始研究下AOP的原理,你是不是一头雾水,根本不知道从何入手。但其实看Spring的代码有个小技巧:如果你要研究一个功能,可以从开启这个功能的Enable注解开始看。Spring的很多功能都是通过Enable注解开启的,所以这些注解肯定和这些功能相关。

那么这边我们可以从@EnableAspectJAutoProxy这个注解开始着手,看下这个注解做了些什么操作。

Copy@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
    //设置为true的话就一直使用cglib动态代理
    //设置为false的话,对于接口使用jdk动态代理,对于类使用cglib代理
	boolean proxyTargetClass() default false;
	boolean exposeProxy() default false;
}

看到上面的@Impoer注解,我们很自然就会想到去看AspectJAutoProxyRegistrar这个类。

Copy//AspectJAutoProxyRegistrar源代码
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     * 主要作用也就是注册AnnotationAwareAspectJAutoProxyCreator
     */
    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //注册AnnotationAwareAspectJAutoProxyCreator的BeanDefinition
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            //给上面注册的BeanDefinition中添加两个属相proxyTargetClass和exposeProxy
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }

}

我们可以看到上面的类中也没干什么特别的事情,就注册了一个BeanDefinition。如果我们点进去看下
AnnotationAwareAspectJAutoProxyCreator这个类的源代码会发现这个类竟然实现了
InstantiationAwareBeanPostProcessor这个接口。熟悉Spring尿性的朋友会敏锐的感觉到Spring可能是在
postProcessBeforeInstantiation或者
postProcessAfterInstantiation这些方法中对Bean进行动态代理的。

“大胆假设,小心求证”,让我们带着这个猜想去看看
AnnotationAwareAspectJAutoProxyCreator到底干了些什么?

AnnotationAwareAspectJAutoProxyCreator生成动态代理类

Copy@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    Object cacheKey = getCacheKey(beanClass, beanName);

    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }
    // 一般不指定CustomTargetSource,所以不会进入这段代码,所以关键代码在
    // postProcessAfterInitialization中
    // Create proxy here if we have a custom TargetSource.
    // Suppresses unnecessary default instantiation of the target bean:
    // The TargetSource will handle target instances in a custom fashion.
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }
    return null;
}

下面是创建动态代理类的关键代码。

Copy@Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                //这边是创建代码类的关键代码
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }
Copyprotected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // Create proxy if we have advice.
        //获取当前Bean配置的advice,这步是关键
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            //创建代理
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

层层dedug进去我们能看到下面这段代码,我们口中常说的JDK动态代理和Cglib动态代理就是在这边生成的。

Copypublic class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                //生成JDK动态代理
                return new JdkDynamicAopProxy(config);
            }
            //生成Cglib动态代理
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }
    /**
     * Determine whether the supplied {@link AdvisedSupport} has only the
     * {@link org.springframework.aop.SpringProxy} interface specified
     * (or no proxy interfaces specified at all).
     */
    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
        Class<?>[] ifcs = config.getProxiedInterfaces();
        return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
    }

到此,我们已经简单分析了Spring动态代理类的生成流程。

PS:关于
InstantiationAwareBeanPostProcessor接口和BeanPostProcessor接口大家可以自行了解下,这两个接口是Spring中非常重要的接口。看懂了这两个接口,Spring很多“神秘”的功能你就能理解了。

简单总结

通过上面分析,其实我们发现如果不去看AOP动态代理类生成的细节的话,整个Spring AOP的流程还是挺简单的:

  • @EnableAspectJAutoProxy注解通过AopConfigUtils这个工具类注册AnnotationAwareAspectJAutoProxyCreator这个类,这个类实现了InstantiationAwareBeanPostProcessor接口,所以会在Bean实例化前后对Bean做一系列额外的操作;
  • AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInitialization中会找出所有和当前Bean相关的Advice,如果找到就创建相应的动态代理类,如果找不到就不生成,返回原始类。

所以整个大流程就这么简单。

一些重要类:

  • @EnableAspectJAutoProxy;
  • AspectJAutoProxyRegistrar:注册AnnotationAwareAspectJAutoProxyCreator
  • AnnotationAwareAspectJAutoProxyCreator:AOP动态代理自动生成的处理类,其他类似的类有AspectJAwareAdvisorAutoProxyCreator和InfrastructureAdvisorAutoProxyCreator等;
  • AopConfigUtils:AOP配置工具类
  • ProxyFactory:代理工厂
  • AopProxy接口:常见实现类ObjenesisCglibAopProxy、JdkDynamicAopProxy

而这些的学习当然不是只看源码就能整明白,肯定有辅助的呀


书籍

除了spring之外,我还整理了一些其他的资料,一并送给大家

需要这些文档资料,关注+转发后,私信“资料”即可查看获取方式

视频:

Spring一百集出于篇幅原因,只展示一部分

需要这些资料,关注+转发后,私信“资料”查看获取方式

 

深度剖析Spring AOP源码,图文详解,小白也能看明白。 AOP 的全称是 “Aspect Oriented Programming”,即⾯向切⾯编程。在 AOP 的思想⾥⾯,周边功能(⽐如性能统计,⽇志,事务管理等)被定义为切⾯,核⼼功能和切⾯功能分别独 ⽴进⾏开发,然后把核⼼功能和切⾯功能“编织”在⼀起,这就叫 AOP。AOP 能够将那些与业务⽆关,却为业务模块所共同调⽤的逻辑封装起来,便于减少系统的重复代码,降低模块间的 耦合度,并有利于未来的可拓展性和可维护性。我们再⼩节⼀下,⽂章先介绍了什么是 AOP,以及 AOP 的原理和示例。 阅读详情

相关推荐

Spring源码——AOP

前言 内容主要参考自《Spring源码深度解析》一书,算是读书笔记或是原书的补充。进入正文后可能会引来各种不适,毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第七章的部分,依照书中内容以及个人理解对Spring源码进行了注释,详见Github仓库:https://github.com/MrSorrow/spring-framework 正式进入正文前,强烈推荐先阅读文末参考阅读第一篇:关于 S...

等一杯咖啡的博客 2822

spring 动态代理_详解Spring框架的AOP功能,附源码

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言,绝大部分Java应用都可以从Spring◆目的:解决企业应用开发的复杂性◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能◆范围:任何Java应用Spring是一个...

weixin_39758494的博客 98

Spring的aop源码分析

Spring的aop源码解析

qq_43418737的博客 1672

Spring源码深度解析(AOP功能源码解析)

前言: 有关于Spring,我们最常用的两个功能就是IOC和AOP,前几篇文章从源码级别介绍了Spring容器如何为我们生成bean及bean之间的依赖关系 下面我们接着来看AOP的源码实现。 有关于AOP,我们在面试中也被无数次问到,AOP是什么?AOP有什么作用与优势?AOP在项目中是如何用到的? 这些还都是比较简单的,有些可能会问你AOP的实现是...

恐龙弟旺仔的博客 3万+

io_uring vs epoll ,谁在网络编程领域更胜一筹?

简介:从定量分析的角度,通过量化 io_uring 和 epoll 两种编程框架下的相关操作的耗时,来分析二者的性能差异。 本文作者:王小光,「高性能存储技术SIG」核心成员。 背景 io_uring 在传统存储 io 场景已经证明其价值,但 io_uring 不仅支持传统存储 io,也支持网络 io。io_uring 社区有众多的开发者尝试将 io_uring 用于网络应用。我们之前也在《你认为 io_uring 只适用于存储 IO?大错特错!》中也探索过 io_uring 在网络场景的应用及其

阿里云云栖号 3037

VirtualBox虚拟机拖放文件总失败?手把手教你配置双向拖放与共享文件夹(Ubuntu版)

本文详细指导如何在VirtualBox的Ubuntu虚拟机中配置高效的数据交换方案。核心是安装VirtualBox Guest Additions,并在此基础上开启双向拖放与共享粘贴板功能,同时建立稳定的共享文件夹,彻底解决主机与虚拟机间文件传输失败的问题,构建无缝的跨系统工作环境。

weixin_29245767的博客 232

spring AOP详解

AOP(Aspect Orient Programming)是一种设计思想,是软件设计领域中的面向切面编程,它是面向对象编程(OOP)的一种补充和完善;

是程序喵呀 4204

用Python+NumPy手把手实现分数阶傅里叶变换(FRFT),搞定线性调频信号分析

本文详细介绍了如何使用Python和NumPy实现分数阶傅里叶变换(FRFT),特别针对线性调频信号(Chirp信号)分析。通过从零开始的代码实现和可视化案例,展示了FRFT在时变信号处理中的强大能力,帮助工程师和研究人员高效分析频率随时间变化的信号。

weixin_29062823的博客 219

Spring框架AOP学习总结(下)

文章目录1、 AOP 的概述1、1 为什么学习 AOP1、2 AOP底层实现: 代理机制(了解)2、 Spring 的基于 AspectJ 的 AOP 开发(XML 的方式)2.1 AOP 的开发中的相关术语:2.2 Spring 使用 AspectJ 进行 AOP 的开发入门(XML 的方式):2.2.1 引入相应的 jar 包2.2.2 引入 Spring 的配置文件2.2.3 编写目标类...

宜春 1万+

TransUnet官方代码训练自己数据集(彩色RGB3通道图像的分割)

官方代码:https://github.com/Beckschen/TransUNet 目的:训练5个类别的汽车部件分割任务(测试在另一篇博客中) 实现效果: 1. github下载代码,并解压。 项目里的文件可能跟你下载的不一样,不急后面会讲到! 2. 配置数据集(尽最大努力还原官方数据集的格式)。 通常自己手上的数据集分images和labels文件夹,分别存放着原始图像和对应的mask图像,如下图所示; mask图像中的像素有0,1,2,3,4 分别代表背景,车身,轮子,车灯,窗户,一共五个

qq_37652891的博客 5万+

基于点云数据的统计滤波算法改进

随着三维视觉和点云处理技术的发展,点云数据在机器人、自动驾驶、增强现实等领域得到了广泛应用。而点云数据中常常包含着各种噪声和异常点,这些噪声和异常点会影响后续的数据处理和分析任务。因此,对点云数据进行滤波处理是必不可少的一步。在点云滤波算法中,统计滤波(Statistical Filtering)是一种常见且有效的方法。它通过对点云数据进行统计分析,将噪声和异常点剔除或修复,从而得到更为准确和可靠的点云数据。本文将介绍一种改进的统计滤波算法,并提供相应的源代码实现。

QfcaLinux的博客 293

Spring AOP 源码解读

name: spring-aop-source title: Spring AOP 源码解析 date: 2020-03-25 15:03:38 tags: spring-aop-source categories: 文章目录前言本文使用的调试代码IOC 容器管理 AOP 实例ProxyFactory 详解基于注解的 Spring AOP 源码分析闲聊 InstantiationAwareBeanPostProcessor小结 之前写过 IOC 的源码分析,那篇文章真的有点长,看完需要点耐心。很多读者希.

孤刺 4074

使用 MATLAB/Simulink 构建一个 基于神经网络控制的单相并网逆变器系统

单相并网逆变器广泛应用于户用光伏小型储能和电动汽车V2G等场景。其核心控制目标是实现高质量的并网电流,即电流与电网电压同频同相(单位功率因数),且总谐波畸变率 (THD)极低。非线性因素:电力电子器件的开关死区非线性电感寄生参数。参数不确定性:滤波器元件(L, C)的老化温漂。电网扰动:电压谐波频率波动不平衡。模型依赖性:PI、PR等控制依赖于精确的系统模型,模型失配导致性能下降。动态响应:在光照突变(光伏)或负载突变(储能)下,需快速、无超调地响应。

xiaoheshang_123的博客 274

从源码解读Spring的AOP

概念 IOC和AOP作为Spring的两大核心,如果你接触过Spring框架,那就一定需要了解这两个核心部分的工作原理。IOC控制反转(或者说依赖注入)的部分已经在我的从源码解读Spring的IOC文章中有介绍,这篇文章主要来讲解AOP面向切面编程的原理 AOP,即Aspect Oriented Programming,面向切面编程,关于什么是面向切面编程,为了避免喧宾夺主,我在这里不进行过多的探...

Ekmr的博客 4504

【AI·FDE】第9篇:FDE 的未来——从人 FDE 到 AI FDE 到自助化,价值迁向哪里

系列文章 | 2026年9月这是【AI·FDE】系列的终章。前面 8 篇把 FDE 的起源、能力、方法论、产品化、转型路径、工具化都讲透了。我们用一条"三段式演变弧线"来回答——从手工作坊,到平台化,再到自助化。

求知若渴、虚心若愚 68

【前端基础篇】HTML5 + CSS3 入门知识

,HTML5和CSS3核心知识

前端知识分享喵 2982

深入理解 Spring AOP 源码分析(附源码分析)

Spring AOP 是一个非常常见的概念,使用了 Spring 的项目大多数也都用了 Spring AOP 的功能,比如我们常见的日志统计、事务管理等,AOP 的全称是 “Aspect Oriented Programming”,也是我们常说的⾯向切⾯编程,那你真的了解 Spring AOP 的原理吗?

weixin_42118323的博客 2351

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

Spring源码之AOP实现

Spring源码之AOP

qq_38706652的博客 2784

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

Spring框架之AOP详解

Spring AOP 详解,并实现demo

qq_45515347的博客 2262

Spring源码之AOP分析

本文我们开始讲解Spring中的AOP原理和源码,我们前面手写了AOP的实现,了解和自己实现AOP应该要具备的内容,我们先回顾下,这对我们理解Spring的AOP是非常有帮助的。

小兔子的博客 1149

Spring AOP源码详细解析

一 . 以下是bean的初始化过程: 注意: 先明白beanPostProcessor的作用,才能够明白aop的加载时机 在bean实例化完成之前和完成之后分别会自动BeanPostProcessor接口的postProcessBeforeInitialization和postProcessAfterInitialization方法。 二: 介绍一些Spring Aop中一些核心类,大致分为三类: advisorCreator,继承 spring ioc的扩展接口 beanPos...

pengjianglilive的专栏 3678

Spring AOP源码分析

目录 1、AOP是什么 2、AOP 的作用及其优势 3、AOP 的底层实现 3.1 JDK动态代理: 3.2 CGLIB动态代理 4、AOP相关概念 5、AOP运行流程图 6、AOP源码解析 6.1 源码解析须知 6.2 注册自动代理创建器 6.3 触发后置处理器 6.4 创建Proxy过程分析 6.5 代理回调增强 6.6 增强器执行 6.7 增强器执行顺序 7、源码总结 1、AOP是什么 AOP 为 Aspect Oriented Programming ..

长沙老码农 2448

Spring框架AOP源码分析

Spring框架AOP源码分析 1.写在前面 做java开发的不可能不适用spring框架,我们都知道spring框架的两个基础功能就是Ioc和aop,相比来说Ioc会应用的更广泛一些,但aop同样重要,今天就来详细分析一下spring的aop的实现原理,会深入spring源码级别,对于spring不太熟悉的同学来说可能有点难,没有办法,分析源码就是这样,需要对框架有一定的应用经验并且比较熟悉原理,毕竟一个成熟的框架,特别是像spring这样的java技术栈统治级的框架。如果想学习spring的基本功能推荐

ChirsPaul3的博客 339

【Spring AOP 源码解析】彻底搞懂 AOP 是如何执行的

Spring 在真正的通过反射去执行实际调用的方法之前,会有一个名为 **`intercept()`** 的方法,执行一些拦截的逻辑;我们构造的这些切面方法实际上就是在这部分中执行的;Spring 在创建 Bean 的时候会根据 AOP 注解生成一个由一组 interceptor 组成的链式结构,然后在调用实际方法之前,通过循环的方式按照顺序去执行这些 interceptor 中的代码,这样就在合适的时机去执行了合适的代码。

kkq的博客 1366

深入剖析Spring框架核心源码:从IoC容器到AOP实现原理

通过对Spring核心源码的剖析,我们不仅能解决日常开发中遇到的疑难杂症(如Bean不生效、事务不回滚等),更能深刻理解其背后“约定优于配置”、“通过扩展点开放”等优秀设计哲学。理解设计模式: 在Spring源码中,工厂模式、模板方法、单例、代理、责任链等模式无处不在,是学习设计模式的绝佳范本。善用扩展点: 理解等扩展点,是进行Spring高级定制和二次开发的基础。关注最新动态。

ql191035的博客 1679
上一篇: 史上对Docker容器解析最全的实战文档
下一篇: 腾讯大牛手肛一文教你如何使用 Shiro 框架
Java斗帝之路
博客等级 码龄7年 2392粉丝 687原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值