03-Spring面向切面编程

最新推荐文章于 2023-10-07 08:00:00 发布
最新推荐文章于 2023-10-07 08:00:00 发布
阅读量96 收藏
点赞数
分类专栏： Java EE Java 文章标签： java spring spring 5 aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LuKeliyy/article/details/115055127
版权
Java 同时被 2 个专栏收录
20 篇文章 0 订阅
订阅专栏
Java EE
14 篇文章 0 订阅
订阅专栏

1. AOP简介

参考资料

官网链接： https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#aop

参考翻译：https://www.docs4dev.com/docs/zh/spring-framework/5.1.3.RELEASE/reference/core.html#aop

1.1 什么是AOP

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的补充，是软件开发中的一个重要的技术，同时也是Spring框架中的核心内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的 耦合度降低 ，提高程序的可重用性，同时提高了开发的效率。

1.2 AOP的作用及其优势

  • 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强。
  • 优势：减少重复代码，提高开发效率，并且便于维护。

1.3 AOP的底层实现

AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

1.4 AOP 的动态代理技术

常用的动态代理技术

JDK 代理 : 基于接口的动态代理技术

CGLIB 代理：基于父类的动态代理技术

1.4.1 代理模式中的类和接口

package com.xuetang9.spring.demo.aop;

/**
 * 定义一个目标接口
 */
public interface TargetInterface {
    /**
     * 目标接口中的方法
     */
    void method();
}

package com.xuetang9.spring.demo.aop;

/**
 * 定义一个目标对象的类型
 */
public class Target implements TargetInterface {
    
    @Override
    public void method() {
        System.out.println("执行method方法...");
    }
}

1.4.1 JDK静态代理

package com.xuetang9.spring.demo.aop;

/**
 * 静态的代理对象
 */
public class StaticProxy implements TargetInterface {
    /**
     * 被代理的对象
     */
    private TargetInterface target;

    public StaticProxy(TargetInterface target) {
        this.target = target;
    }

    @Override
    public void method() {
        System.out.println("前置增强代码....");
        target.method();
        System.out.println("后置增强代码....");
    }
}

package com.xuetang9.spring.demo.aop;
import org.junit.Test;
import static org.junit.Assert.*;
public class StaticProxyTest {

    @Test
    public void testStaticDynamicProxy() {
        // 创建目标对象
        Target target = new Target();
        // 创建代理对象
        TargetInterface proxy = new StaticProxy(target);
        // 调用代理后的方法
        proxy.method();
    }
}

1.4.2 JDK动态代理

package com.xuetang9.spring.demo.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class JdkDynamic implements InvocationHandler {
    /**
     * 被代理的对象
     */
    private Object target;

    public JdkDynamic(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置增强代码....");
        // 使用反射执行被代理的方法
        Object result = method.invoke(target, args);
        System.out.println("后置增强代码....");
        return result;
    }
}

package com.xuetang9.spring.demo.aop;
import org.junit.Test;
import java.lang.reflect.Proxy;
import static org.junit.Assert.*;

public class JdkDynamicTest {
    @Test
    public void testJDKDynamicProxy() {
        // 创建目标对象
        Target target = new Target();
        // 创建增强功能的对象
        JdkDynamic jdkDynamicProxy = new JdkDynamic(target);
        // 创建代理对象
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                // 类加载器
                target.getClass().getClassLoader(),
                // 代理的接口
                target.getClass().getInterfaces(),
                // 代理后增强的功能
                jdkDynamicProxy
        );
        // 调用代理后的方法
        proxy.method();
    }
}

1.4.3 CGLIB动态代理

package com.xuetang9.spring.demo.aop;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class CglibDynamic implements MethodInterceptor {
    /**
     * 被代理的对象
     */
    private Object target;

    public CglibDynamic(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("前置增强代码....");
        // 使用反射执行被代理的方法
        Object result = method.invoke(target, objects);
        System.out.println("后置增强代码....");
        return result;
    }
}

package com.xuetang9.spring.demo.aop;
import org.junit.Test;
import org.springframework.cglib.proxy.Enhancer;
import static org.junit.Assert.*;

public class CglibDynamicTest {

    @Test
    public void testCGLIBDynamicProxy() {
        // 创建目标对象
        Target target = new Target();
        // 创建增强的功能类
        CglibDynamic cglibDynamic = new CglibDynamic(target);
        // 创建增强器
        Enhancer enhancer = new Enhancer();
        // 设置增强器代理的父类
        enhancer.setSuperclass(Target.class);
        // 设置增强器的扩展功能
        enhancer.setCallback(cglibDynamic);
        // 创建代理对象
        Target proxy = (Target) enhancer.create();
        // 调用代理后的方法
        proxy.method();
    }
}

1.4.4 动态代理的扩展

动态代理都是通过 继承或实现接口，进行方法重写完成。

继承的子类或实现接口子类都由工具创建，而不是我们自己实现。

简化了子类的书写。

1.5 AOP相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法功能增强。

术语解释
Target目标对象，指需要被代理的对象
Proxy代理对象，最终代理后的对象
JoinPoint连接点，程序执行中的特定位置。通常指被代理类中的方法。
Pointcut切入点，通常指需要对哪些连接点进行拦截的定义。
Advice通知/建议，通常指拦截到指定方法后需要处理的事情。
Aspect切面，由切点和通知组成
Weaving织入，将切点与通知/建议结合的过程

在这里插入图片描述

2. Spring AOP的实现

2.1 切点表达式

用来匹配需要代理的方法，以便于拦截代理

表达式语法：execution( [修饰符] 返回值类型 包名.类名.方法名( 参数类型列表 ) )

  • 访问修饰符可以省略
  • 返回值类型、包名、类名、方法名可以使用星号 * 代表任意
  • 包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
  • 参数类型列表：多个用逗号隔开，可以使用两个点 .. 表示任意个数和类型的参数列表
示例说明
execution( public * *(…) )执行任何公共方法
execution(* set*(…))名称以set 开头的任何方法的执行
execution(* com.xuetang9.service.UserService.*(…))执行UserService接口定义的任何方法
execution(* com.xuetang9.service.* .*(…))执行service包中定义的任何方法
execution(* com.xuetang9.service… *. *(…))执行service包或其子包中定义的任何方法

2.2 通知的类型

名称标签注解说明
前置建议<aop:before>@Before运行在一个连接点之前，但是不能阻止连接点运行。
后置运行建议<aop:after-returning>@AfterReturning运行在连接点之后，并且正常结束不抛出异常。
后置异常建议<aop:after-throwing>@AfterThrowing运行在连接点出现异常之后。
后置建议<aop:after>@After不管连接点是否出现异常都会运行。
环绕建议<aop:around>@Around环绕一个连接点运行，可处理上面所有的操作。

2.3 基于XML方式的实现

官方参考： https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#aop-schema

参考翻译(5.5)：https://www.docs4dev.com/docs/zh/spring-framework/5.1.3.RELEASE/reference/core.html#aop

2.3.1 导入aspectjweaver的坐标

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

2.3.2 书写AOP的增强通知类

package com.xuetang9.spring.demo.aop;


public class AdviceAop {

    public void methodBefore(){
        System.out.println("执行之前...");
    }

    public void methodAfterReturning(){
        System.out.println("方法执行返回结果之后...");
    }

    public void methodAfterThrowing(){
        System.out.println("方法执行出现异常之后...");
    }

    public void methodAfterFinally(){
        System.out.println("方法执行之后...");
    }

    public void methodAround(){
        System.out.println("环绕增强...");
    }
}

2.3.3 在XML中手动配置AOP的代理

<!--配置功能增强通知类-->
<bean id="adviceAop" class="com.xuetang9.spring.demo.aop.AdviceAop"></bean>

<!--配置AOP-->
<aop:config>
    <!--配置一个具体的切面织入-->
    <aop:aspect ref="adviceAop">
        <!--配置切点-->
        <aop:pointcut id="methodPointcut" expression="execution(* com.xuetang9.spring.demo..*.*(..))"/>
        <!--配置切点通知-->
        <aop:before method="methodBefore" pointcut-ref="methodPointcut"/>
        <aop:after-returning method="methodAfterReturning" pointcut-ref="methodPointcut"/>
        <aop:after-throwing method="methodAfterThrowing" pointcut-ref="methodPointcut"/>
        <aop:after method="methodAfterFinally" pointcut-ref="methodPointcut"/>
        <aop:around method="methodAround" pointcut-ref="methodPointcut"/>
    </aop:aspect>
</aop:config>

2.3.4 书写单元测试

package com.xuetang9.spring.demo.aop;
import com.xuetang9.spring.demo.config.AppConfig;
import com.xuetang9.spring.demo.dao.SectionDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.junit.Assert.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-aop.xml")
public class AdviceAopTest {

    @Autowired
    private SectionDao sectionDao;

    @Test
    public void test(){
        sectionDao.selectAll();
    }
}

2.4 基于注解+配置方式的实现

2.4.1 导入aspectjweaver的坐标

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

2.4.2 书写AOP的增强通知类

package com.xuetang9.spring.demo.aop;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;


@Component
@Aspect
public class AdviceAop {

    @Before("execution(* com.xuetang9.spring.demo.dao..*.*(..))")
    public void methodBefore(){
        System.out.println("执行之前...");
    }

    @AfterReturning("execution(* com.xuetang9.spring.demo.dao..*.*(..))")
    public void methodAfterReturning(){
        System.out.println("方法执行返回结果之后...");
    }

    @AfterThrowing("execution(* com.xuetang9.spring.demo.dao..*.*(..))")
    public void methodAfterThrowing(){
        System.out.println("方法执行出现异常之后...");
    }

    @After("execution(* com.xuetang9.spring.demo.dao..*.*(..))")
    public void methodAfterFinally(){
        System.out.println("方法执行之后...");
    }

    @Around("execution(* com.xuetang9.spring.demo.dao..*.*(..))")
    public void methodAround(){
        System.out.println("环绕增强...");
    }
}

package com.xuetang9.spring.demo.aop;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class AdviceAop {

    /**
     * 定义通用的切点
     */
    @Pointcut("execution(* com.xuetang9.spring.demo.dao..*.*(..))")
    public void joinPoint() {}

    @Before("joinPoint()")
    public void methodBefore() {
        System.out.println("执行之前...");
    }

    @AfterReturning("joinPoint()")
    public void methodAfterReturning() {
        System.out.println("方法执行返回结果之后...");
    }

    @AfterThrowing("joinPoint()")
    public void methodAfterThrowing() {
        System.out.println("方法执行出现异常之后...");
    }

    @After("joinPoint()")
    public void methodAfterFinally() {
        System.out.println("方法执行之后...");
    }

    @Around("joinPoint()")
    public void methodAround() {
        System.out.println("环绕增强...");
    }
}

2.4.3 在XML中配置自动代理

<aop:aspectj-autoproxy proxy-target-class="true"/>
  • proxy-target-class ：默认值为false
    • false：使用JDK动态代理。
    • true：使用CGLIB动态代理。

2.4.4 书写单元测试

package com.xuetang9.spring.demo.aop;
import com.xuetang9.spring.demo.config.AppConfig;
import com.xuetang9.spring.demo.dao.SectionDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.junit.Assert.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-aop.xml")
public class AdviceAopTest {

    @Autowired
    private SectionDao sectionDao;

    @Test
    public void test(){
        sectionDao.selectAll();
    }
}

2.5 纯注解方式的实现

2.5.1 导入aspectjweaver的坐标

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

2.5.2 书写AOP的增强通知类

package com.xuetang9.spring.demo.aop;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class AdviceAop {

    /**
     * 定义通用的切点
     */
    @Pointcut("execution(* com.xuetang9.spring.demo.dao..*.*(..))")
    public void joinPoint() {}

    @Before("joinPoint()")
    public void methodBefore() {
        System.out.println("执行之前...");
    }

    @AfterReturning("joinPoint()")
    public void methodAfterReturning() {
        System.out.println("方法执行返回结果之后...");
    }

    @AfterThrowing("joinPoint()")
    public void methodAfterThrowing() {
        System.out.println("方法执行出现异常之后...");
    }

    @After("joinPoint()")
    public void methodAfterFinally() {
        System.out.println("方法执行之后...");
    }

    @Around("joinPoint()")
    public void methodAround() {
        System.out.println("环绕增强...");
    }
}

2.5.3 书写注解配置类启用自动代理

在配置上使用注解 @EnableAspectJAutoProxy 开启自动代理

package com.xuetang9.spring.demo.config;
import org.springframework.context.annotation.*;

/**
 * 用来替代Spring的XMl配置文件
 */
@Configuration
@ComponentScan("com.xuetang9.spring.demo")
@EnableAspectJAutoProxy
public class AppConfig {

}

2.5.4 书写单元测试

package com.xuetang9.spring.demo.aop;
import com.xuetang9.spring.demo.config.AppConfig;
import com.xuetang9.spring.demo.dao.SectionDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.junit.Assert.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {AppConfig.class})
public class AdviceAopTest {

    @Autowired
    private SectionDao sectionDao;

    @Test
    public void test(){
        sectionDao.selectAll();
    }
}

import com.xuetang9.spring.demo.config.AppConfig;
import com.xuetang9.spring.demo.dao.SectionDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.junit.Assert.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {AppConfig.class})
public class AdviceAopTest {

    @Autowired
    private SectionDao sectionDao;

    @Test
    public void test(){
        sectionDao.selectAll();
    }
}
a听闻
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3514
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
SpringBoot-AOP面向切面编程-实战
ZhAoYaJ的博客
01-05 2167
SpringBoot集成AOP之列文虎克
Aspect注解依赖引入（记录）
jzyang_16的博客
12-30 1990
<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-s.
spring aop aspect注解的使用。
小刘的博客
03-01 280
切面方面的jar包 <!-- Spring AOP 切面 模块 --> <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop --> <dependency> <groupId>org....
【翠花学Maven】Maven详解
热门推荐
m0_57082679的博客
05-05 2万+
Maven的作用和定义 定义： Maven是一个跨平台的项目管理工具，是Apache组织中的一个颇为成功的开源项目。Maven主要服务基于java的项目构建，项目信息管理和依赖管理。 作用： 1.Maven可以创建项目。 2.Maven可以引入依赖的jar包。 在Maven中有一个核心的概念--仓库，分为本地仓库和远程仓库。远程仓库又分为中央仓库，私服和其他仓库。 仓库具体了解： 如图所示:在美国有一个中央仓库，我可以创建一个本地仓库获取中央仓库的项目模板和依赖jar，在我每次创建项目的时候
spring6-AOP面向切面编程
m0_62946761的博客
10-07 6984
aop是面向切面编程，本质上是一种代理模式，而代理模式又分为静态代理和动态代理。 静态代理以Aspect J为代表，指的是预编译代理，也即编译时增强，在编译时将代理逻辑织入目标类编译得到的Java字节码文件中，当运行时产生的对象就是增强过后的对象了 动态代理以spring AOP为代表，spring AOP 可以使用JDK动态代理或者CGLIB动态代理实现。
Spring-AOP面向切面编程
caijigskg的博客
04-06 1590
AOP面向切面编程，基于动态代理的，可以使用jdk，cglib两种代理方式 AOP就是动态代理的规范化，把动态代理的实现步骤方式都定义好了，让开发人员用一种统一的方式，使用动态代理 AOP(Aspect Orient Programming),面向切面编程，面向切面编程是从动态角度考虑程序运行过程。 AOP底层就是采用动态代理模式实现的，采用了两种代理：jdk的动态代理与cglib的动态代理。 怎么理解面向切面编程？ 1.需要在分析项目功能时，找出切面。 2.合理安排切面的执行位置，(在目标方法
15.Spring 面向切面编程
qq_41775769的博客
09-09 973
Spring 面向切面编程 AOP 是 Spring 框架除了 IOC 之外的另一个核心概念。   AOP：Aspect Oriented Programming，意为面向切面编程。这是一个新的概念，但是我们知道 Java 是面向对象编程(OOP：Object Oriented Programming)的，指将所有的一切都看作对象，通过对象与对象之间相互作用来解决问题。AOP 是对 OOP 的一个补充，是在另外一个维度抽象出来的对象，具体是指程序在运行时，动态地将非业务代码切入业务代码中，从而实现代码的
【Spring】面向切面编程详解（AOP）
未来可以改变
10-18 5867
①AOP（Aspect Oriented Program）即面向切面编程。我们先回顾以下三层架构，三层架构式垂直架构，即一层对另一层提供服务，不能越级访问，分级进行运作。上述架构是垂直分布的，而面向切面则是一个切面：②到底是什么切面呢？就是把各种类中冗余的代码提取出来，在需要用的时候就横向切入，就像一个切面一样。到底是什么冗余代码呢？事务处理、异常处理等等！突然来一大堆听不懂。③举个栗子：比如说事务控制，在我们的业务中，虽然查询是最多的，但是添加、修改、删除也不少。
SpringAop面向切面编程使用详解
qq_44749491的博客
11-22 5370
一文学会SpringAop的使用
16.2 Spring框架-AOP面向切面编程
最新发布
04-12
16.2 Spring框架-AOP面向切面编程
CH03-AOP面向切面编程.pptx
12-28
AOP(Aspect Oriented Programming)：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP是对OOP的补充，是软件开发中的一个热点，也是Spring框架中的一个重要内容。 利用AOP...
Spring 面向切面编程AOP实现详解
08-25
主要介绍了Spring 面向切面编程AOP实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring AOP面向切面编程实现原理方法详解
08-18
主要介绍了Spring AOP面向切面编程实现原理方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring-AOP面向切面编程所需jar包.zip
06-22
该压缩包包含--学习笔记(05):轻松搞定Spring全家桶(初识篇)-面向切片编程AOP：--系列博客中新需要的三个jar包。包括spring-aspects-5.2.7.RELEASE.jar和spring-aop-5.2.7.RELEASE.jar和...
Java操作PDF,在PDF模板中插入表格
听闻
01-11 2305
<dependency> <groupId>com.itextpdf</groupId> <artifactId>itextpdf</artifactId> <version>5.5.11</version> </dependency> <dependency> ...
Swagger3使用
听闻
04-13 975
Swagger3使用 参考连接：https://github.com/springfox/springfox swagger2，上传文件有bug,不能实现多文件单字段上传，而且封装到对象里面的文件字段也不能上传文件，swagger3修正了该BUG，并且Swagger3.0简化了配置 1 项目中添加依赖 <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-boot-
MyBaitsPlus
听闻
04-13 811
MyBatis-Plus 1. 什么是MyBatis-Plus 官网链接：https://mybatis.plus/ 版本发布历史：https://github.com/baomidou/mybatis-plus/blob/3.0/CHANGELOG.md 1.1 简介 MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率
01-Sring简介及配置
听闻
03-16 576
1. Spring概述（理解） 1.1 Spring是什么 “Spring”在不同的场景中表示不同的内容。它可以用来表示Spring Framework项目本身，是所有Spring项目的基础。Spring框架和Spring项目系列通常简称为“ Spring”。 其核心基础为IoC（Inversion of Control：控制反转）容器和AOP（Aspect Oriented Programming：面向切面编程）。 1.2 Spring项目 官方网址：https://spring.io/ 从配置
spring 面向切面编程
07-29
面向切面编程（Aspect-Oriented Programming，AOP）是一种编程范式，它允许开发者通过将横切关注点（Cross-Cutting Concerns）从核心业务逻辑中分离出来，以模块化的方式来处理它们。在Spring框架中，AOP是一个重要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值