Spring中AOP实现；代理模式

最新推荐文章于 2024-10-12 13:05:12 发布
最新推荐文章于 2024-10-12 13:05:12 发布
阅读量609 收藏 15
点赞数 14
文章标签： spring 代理模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72637723/article/details/141791228
版权

一，介绍代理模式：

        1.代理模式 设计模式的一种，解决某一类问题的产生 分为：

                             静态代理

                            动态代理【JDK动态代理、CGLIB动态代理】

        2.代理模式的角色

                 （1）.抽象对象(抽象父类或接口):需要完成的功能

                 （2）.被代理对象:隐藏起来的对象

                 （3）.代理对象:暴露给其他人的对象,访问被代理对象通过代理对象进行访问

        3.代理模式案例:我们找中介租房 1.抽象对象: 租房 2.被代理对象:房东 3.代理对象:中介(做了额外事情,包房东保护起来) 4.调用者:我们

        4.代理模式的好处 ：

                （1）.被代理对象可以专注完成自己的业务(房东安心的做自己的事情即可，不用管理其他的事情)

                 （2）.保护了被代理对象(房东对象比较的安全)

                 （3）.增强了代码的扩展性

        5.静态代理缺点: .随着房东/被代理对像的增多，中介的压力就会越来越大，体现到代码上就是代码越来越臃肿

        6，实现静态代理的步骤

                      （1）， 创建抽象对象: Zufang接口

public interface Zufang {
	/*
 	 * 需要完成的事情
	 */
	void zufang();
}

                        （2）创建被代理对象Fangdong

public class Fangdong implements Zufang {
	public void zufang() {
		System.out.println("出租五环科技园C座c01");
	}
}

                          （3）创建代理对象Zhongjie

public class Zhongjie implements Zufang {
	//房东人:张三
	private Fangdong fangdong = new Fangdong();
	@Override
	public void zufang() {
		System.out.println("收房东的中介费");
		fangdong.zufang();
		System.out.println("收我们的中介费");
	}
}

                        （4）创建调用者Women

public class Women {    public static void main(String[] args) {        //小王        Zhongjie zhongjie = new Zhongjie();        zhongjie.zufang();    }}

二，实现AOP：第一阶段的静态代理

1.创建接口UserService

void add() throw Exception;
void delet() throw Exception;

2.创建接口实现类UserServiceImpl

public void add() throw Exception{
    check();
    System.out.println("添加成功");
    log();
}
public  void  check(){
    System.out.println("权限检查");
}
public  void  log(){
    System.out.println("日志记录");
}

3.编写测试方法

 ApplicationContext app=new ClassPathXmlApplicationContext("applicationTest.xml");
 UserService UserService=(UserService)app.getBean("UserService");
 UserService.add();

4.存在问题：

第一阶段的静态代理，在UserServiceImpl实现类中业务代码严重的与横切性代码耦合在一起了。

解决办法：将横切性代码提取出来，与业务代码 分开存放。

三，实现AOP：第二阶段的静态代理

1.创建一个静态代理类：

public class UserServiceProxy implement UserService{
    private UserServiceImpl usi;//静态代理，指明代理的是谁。
    public UserServiceProxy(UserServiceImpl userServiceImpl){
        this.usi=userServiceImpl;   
    }
    public void add() throw Exception{
        check();
        usi.add();
        log();
    }
    
    public  void  check(){
        System.out.println("权限检查");
    }
    
    public  void  log(){
        System.out.println("日志记录");
    }
​
}

com.jr.proxy 包下创建创建UserServiceProxy类 实现跟UserServiceImpl类一样的接口

2.实现类UserServiceImpl代码改动

public void add() throw Exception{  
    System.out.println("添加成功");
}

3.存在问题：

        第二阶段的静态代理，将UserServiceImpl实现类中的横切性代码提取出来 放到代理类里，在代理类里做整合。

        那么一个service接口就要写一个代理类，如果Service接口特别多的话，程序中将多出非常多的代理类。

        解决办法：需要一个代理类，能代理所有实现接口的实现类。这就需要下面的动态代理

四：AOP实现：第三阶段：动态代理实现AOP

1，动态代理简介：

        （1）.动态代理的分类：

                 JDK动态代理---代理拥有接口的实现类

                 cglib动态代理---代理拥有父类的子类

        （2）.动态代理:

                         底层是根据反射实现的.

                         只要给代理对象传递被代理对象,直接调用被代理对象中方法

         （3）.动态代理中动态含义：

                        代理类可以代理任意类型对象.(被代理对象必须实现了指定接口)

2，JDK动态代理实现AOP

创建动态代理类：

//使用动态代理时需要实现InvocationHandler,因为在调用者中通过接口调用方法时知道需要执行哪个方法
public class JDKProxy implements InvocationHandler {
​
    private Object targetObject;//代理的目标对象       
    
    //产生代理对象：
    public Object createProxyInstance(Object targetObject){
        this.targetObject=targetObject;
/**
 * 参数一     ClassLoader   类加载器
 * 参数二：   Interfaces  接口类型
 * 参数三：   InvocationHandler  代理对象
 * */
         return Proxy.newProxyInstance(
            this.targetObject.getclass().getClassLoader(),
            this.targetObject.getclass().getInterfaces(),
            this);
    }
    
     /*
     * 三个参数
     *      1.proxy：就是代理对象本身
     *      2.method：代理对象调用的方法，被封装为的对象。简单说 谁在运行调用，这个method就是谁。
     *      3.args：代理对象调用方法时，传递的实际参数
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        check();
        Object invoke = method.invoke(this.targetObject, args);
        log();
        return invoke;
    }
​
    public  void  check(){
        System.out.println("权限检查");
    }
    
    public  void  log(){
        System.out.println("日志记录");
    }
​
}

 底层代码实现

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h) throws IllegalArgumentException{
​
// 浅克隆一份接口的class文件数组，数组是另一块内存空间；但数组里面的class还是同一个class，都是指向同一块内存地址
final Class<?>[] intfs = interfaces.clone();
​
// 查找或生成指定的代理类class文件，下面在说这个方法
Class<?> cl = getProxyClass0(loader, intfs);
​
// 获取代理class的有参构造方法(参数就是InvocationHandler接口)
final Constructor<?> cons = cl.getConstructor(constructorParams);
​
final InvocationHandler ih = h;
// 此处判断构造方法是否是公开权限，如果不是则设置访问权限
if (!Modifier.isPublic(cl.getModifiers())) {
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            cons.setAccessible(true);
            return null;
        }
    });
}
​
// 反射实例化代理对象
return cons.newInstance(new Object[]{h});
}

创建测试类：​

    @Test
    public void show2(){
        //1.加载Spring的核心配置文件
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        JDKProxy jdkProxy=applicationContext.getBean("proxy",JDKProxy.class);
        
            //给UserBiz接口创建临时代理对象userBiz
        UserBiz userBiz=(UserBiz) jdkProxy.getTargetObj(new UserBizImpl());
            //----invoke方法是核心代理逻辑思想，代理对象调用的所有方法都会触发该方法执行---
        userBiz.add();
    }
      

存在问题：

        JDK动态代理的产生必须要实现对应的接口的，如果没有对应的接口，这个时候代理对象就没有办法产生。

 3，CGLIB动态代理实现AOP

创建父类

public abstract  class UserSuper {
​
   public  abstract   void add();
}

创建子类

public class UserSub extends UserSuper{
    public void add(){
        System.out.println("添加成功！");    
    }
}

创建动态代理类

        使用Enhancer类中的create方法 2.create方法的参数： Class：字节码 ：它是用于指定被代理对象的字节码。 Callback：用于提供增强的代码， 它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。 此接口的实现类都是谁用谁写。我们一般写的都是该接口的子接口实现类：MethodInterceptor

public class CGLibProxy implements MethodInterceptor{ //拦截器
​
    private Object targetObject;//代理的目标对象   
    
    //产生代理对象：
    public Object createProxyInstance(Object targetObject){
        this.targetObject=targetObject;
         Enhancer  en=new Enhancer();//该类用于生成子类的代理对象
         en.setSuperclass(this.targetObject.class);//被代理对象的字节码。
         en.setCallback(this); //指定回收对象
         return en.create();
    }
​
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        check(); 
        Object o1 = methodProxy.invokeSuper(o, objects);
        log();
        return o1;
    }
    
    public  void  check(){
        System.out.println("权限检查");
    }
    
    public  void  log(){
        System.out.println("日志记录");
    }
}

创建测试类

 CGLBProxy cglbProxy=new CGLBProxy();
        UserBiz userBiz=(UserBiz) cglbProxy.createProxyInstance(new UserBizImpl());
        userBiz.upd();

存在问题：

        横切行代码最好还是存放在一个单独的类里面去，然后借助动态代理，在作用在代理类对象上。

        Spring提供了两种切面声明方式，实际工作中我们可以选择其中一种： ​ A) 基于XML配置方式声明切面 ​ B) 基于注解方式声明切面

五：第四阶段：基于XML配置方式声明切面

1.添加依赖

  <dependencies>
        <!--进行junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
​
        <!--依赖于commons-logging日志管理 -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
​
        <!--提供了框架的基本组成部分,包括IOC 和 DI-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
​
        <!-- 提供了BeanFactory-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
​
        <!--上下文配置对象，提供一个框架式的对象访问方式-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
​
        <!--提供了强大的表达式语言-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
​
<!-- ====注解式声明切面  -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.1</version>
        </dependency>
 </dependencies>

2.定义切面类：

public class Advice {
  
    public void check(){
        System.out.println("权限检查");
    }

    public void log(){
        System.out.println("日志记录");
    }
}

3.编写业务代码：

public interface UserService {
    void add() throws Exception;
    void delete() throws Exception;
}
public class UserServiceImpl implements UserService {
    public void add() throws Exception {
        System.out.println("添加User成功");
    }

    public void delete() throws Exception {
        System.out.println("删除User成功");
    }
}

4.编写applicationContext.xml配置文件

===引入一个命名空间： aop

  xmlns:aop="http://www.springframework.org/schema/aop"      
       
       http://www.springframework.org/schema/aop
	   http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
    <!--创建业务实现类对象 -->
    <bean id="usi" class="com.jr.aop.aspectj.UserServiceImpl"/>

    <!--创建切面类对象 -->
    <bean id="advice" class="com.jr.aop.aspectj.Advice"/>

    <!-- <aop:config proxy-target-class="true"> 
    		如果这样配置则是强制使用CGLIB方式进行代理
            不写或者设置为false默认使用 ： jdk方式进行代理  
            不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。-->
<aop:config>
   <aop:aspect ref="advice">
      <!--定义切点： -->
      <aop:pointcut id="addpointcut" expression="execution(* com.jr.aop.aspectj.UserServiceImpl.add*(..))"/>
      <!--定义通知 -->
      <aop:before method="check" pointcut-ref="addpointcut"/>
      <aop:after method="log" pointcut="execution(* com.jr.aop.aspectj.UserServiceImpl.add*(..))"/>
     
      
   </aop:aspect>

</aop:config>

5.编写测试代码：

    @Test
    public void test5() throws Exception {

        ApplicationContext app=new ClassPathXmlApplicationContext("applicationAOP.xml");
       	UserService userService=(UserService)app.getBean("usi");
        userService.add();
        userService.delete();
    }

运行结果： 权限检查 添加User成功 日志记录 删除User成功

六：第四阶段：基于注解方式声明切面

1.添加依赖

  <dependencies>
        <!--进行junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
​
        <!--依赖于commons-logging日志管理 -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
​
        <!--提供了框架的基本组成部分,包括IOC 和 DI-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
​
        <!-- 提供了BeanFactory-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
​
        <!--上下文配置对象，提供一个框架式的对象访问方式-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
​
        <!--提供了强大的表达式语言-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
​
<!-- ====注解式声明切面  -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.1</version>
        </dependency>
 </dependencies>  

2.定义切面类：

@Aspect
@Component
public class Advice {
​
    @Before("execution(* com.jr.aop.aspectj.UserServiceImpl.add*(..))")
    public void check(){
        System.out.println("权限检查");
    }
​
    @After("execution(* com.jr.aop.aspectj.UserServiceImpl.add*(..))")
    public void log(){
        System.out.println("日志记录");
    }
​
}

3.编写业务代码：

public interface UserService {
    void add() throws Exception;
    void delete() throws Exception;
}
@Service
public class UserServiceImpl implements UserService {
    public void add() throws Exception {
        System.out.println("添加User成功");
    }
​
    public void delete() throws Exception {
        System.out.println("删除User成功");
    }
}

4.编写applicationContext.xml配置文件

===引入两个命名空间：context 和 aop

    xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.3.xsd
       
        <!-- 扫描指定路径，自动注入注解-->
    <context:component-scan base-package="com.jr"/>
        <!--自动为spring容器中那些配置@aspectJ切面的bean创建代理，
        有一个proxy-target-class属性，默认为false 那么标准的JDK 基于接口的代理将起作用。
        不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。-->
    <aop:aspectj-autoproxy/>

5.编写测试代码：

   @Test
    public void test5() throws Exception {
​
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationAOP.xml");
        UserService userService=(UserService)app.getBean("userServiceImpl");
        userService.add();
        userService.delete();
    }
 
 运行结果：
        权限检查
        添加User成功
        日志记录
        删除User成功
攻城狮幼崽
关注
Spring基于代理类的AOP实现
余木尘的博客
10-17 749
文章目录动态代理JDK动态代理CDLIB代理 动态代理 AOP中的代理就是由AOP实现框架动态生成的一个对象，该对象可以作为目标对象使用。 spring中的AOP代理，可以是JDK动态代理，也可以是CGlib代理 JDK动态代理 JDK动态代理是通过java.lang.reflect.Proxy类来实现的，我们可以调用Proxy类的newProxyInstance()方法来创建代理对象 注意：JD...
反射实现 AOP 动态代理模式(Spring AOP 的实现原理）
08-26
代理对象在调用方法时会触发InvocationHandler的invoke()方法，从而可以在这个方法中实现对方法调用的拦截。JDK动态代理要求被代理类必须实现一个接口，代理类会实现相同的接口。 Spring框架中的AOP模块使用了动态...
Spring框架学习05-基于传统代理类的Aop实现
石光辉的博客
05-14 222
Spring框架学习07——基于传统代理类的AOP实现 在Spring中默认使用JDK动态代理实现AOP编程，使用org.springframework.aop.framework.ProxyFactoryBean创建代理是Spring AOP 实现的最基本方式。 1、通知类型 根据Spring中通知在目标类方法中的连接点位置，通知可以分为6种类型： （1）环绕通知 环绕通知（org.aopall...
关于Spring使用代理模式进行AOP实现
cuitldlsn的博客
03-28 869
AOP实现方式之利用Proxy代理 我们的aop可以说是Spring中的一个非常具有特色的东西了，非常流行的实现是利用proxy实现代理对象，但是这种操作其实也有两种不同的实现方法，一种是利用jdk的代理，另外一种是利用cglib这种第三方的包进行的。 jdk代理 jdk的代理是有一些限制的，它只能面向接口进行代理。我们来看一个例子 import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import
Spring AOP 原理——代理模式
m0_60462557的博客
08-10 968
代理模式, 也叫委托模式。该模式是为其他对象提供⼀种代理以控制对这个对象的访问。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。
Spring的AOP之代理模式
长安不及十里的博客
08-03 5092
关于两者之间的性能的话，网上有人对于不通版本的jdk进行测试，经过多次试验，测试结果大致是这样的，在1.6和1.7的时候，JDK动态代理的速度要比CGLib动态代理的速度要慢，但是并没有教科书上的10倍差距，在JDK1.8的时候，JDK动态代理的速度已经比CGLib动态代理的速度快很多了，但是JDK动态代理和CGLIB动态代理的适用场景还是不一样的哈！动态代理生成的代理类通常是在运行时通过字节码生成技术生成的，因此在创建代理对象时，需要一个 ClassLoader 来加载这个新生成的代理类。
Spring的AOP （代理模式）
weixin_47514459的博客
09-15 2745
静态代理 什么是静态代理？ 代理三要素 静态代理特点 静态代理实现（模拟出租房子） 创建共同父类接口 创建房东 创建代理（通过构造器传递行参（目标）） 测试租房 动态代理 动态代理特点 Jdk动态代理 newProxyInstance方法 创建接口父类（如果目标对象没有接口实现，则不能通过JDK动态代理生成代理对象） 创建房东（目标类） 创建代理类 测试类 CGLIB代理 CGLIB代理实现
反射实现 AOP 动态代理模式(Spring AOP 的实现 原理) - Java 例子 -
05-30
Spring框架是Java中实现AOP的一个流行工具，它通过动态代理机制实现了这一功能。本文将深入探讨Spring AOP的实现原理，以及如何使用反射来实现动态代理模式。 首先，我们需要了解AOP的基本概念。AOP的核心思想是切...
Java Spring代理模式AOP-IOC分析
10-01
在Spring框架中，AOP是通过使用代理模式来实现的。 五、IOC（Inversion of Control） IOC是一种软件设计模式，旨在将对象的创建和管理从应用程序中分离出来。在Spring框架中，IOC容器负责创建和管理对象，并提供了...
spring之AOP（动态代理）
09-06
在Spring中，AOP主要通过两种动态代理技术实现：JDK动态代理和CGLIB动态代理。 首先，让我们详细了解一下JDK动态代理。JDK动态代理基于Java的接口实现，它适用于目标对象实现了至少一个接口的情况。在运行时，JDK...
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态代理。 JDK 动态代理是基于接口的，它要求被代理的目标对象必须实现至少一个接口。Spring 使用 `java.lang.reflect.Proxy`...
springboot实战学习（12）(优化更新用户基本信息接口)(Validation实体参数校验)
岁岁岁平安的博客
10-09 954
本篇博客主要是对用户模块的更新用户基本信息接口的代码的一个小优化（实体参数校验）。其中用到了Spring Validation参数校验框架提供的一些注解（如@NotNull、@NotEmpty、@Email、@Validated）去完成实体类对象的参数校验以及完成了功能的测试...
Springboot api http并发测试请求
nsa65223的专栏
10-11 230
【代码】Springboot api http并发测试请求。
Spring Security OAuth2.0认证授权
mry6的博客
10-09 242
Spring Security OAuth2.0认证授权目录基本概念基于Session的认证方式Spring-Security快速上手Spring-Security应用详解分布式系统认证方案OAuth2.0Spring-Security实现分布式系统授权 目录 基本概念 基于Session的认证方式 Spring-Security快速上手 Spring-Security应用详解 分布式系统认证方案 OAuth2.0 Spring-Security实现分布式系统授权
教师工作量|基于springBoot的教师工作量管理系统设计与实现(附项目源码+论文+数据库）
提供各种学习资源及帮助
10-10 808
传统信息的管理大部分依赖于管理人员的手工登记与管理，然而，随着近些年信息技术的迅猛发展，让许多比较老套的信息管理模式进行了更新迭代，教师信息因为其管理内容繁杂，管理数量繁多导致手工进行处理不能满足广大用户的需求，因此就应运而生出相应的教师工作量管理系统。本教师工作量管理系统分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理公告信息以及公告的租赁信息，能够与用户进行相互交流等操作，用户可以查看教师信息，可以查看公告以及查看管理员回复信息等操作。
Spring相关知识补充
m0_73067372的博客
10-07 1293
4. 不同类中的方法在使用了@Bean注解向spring中注入对象，并且重命名起了相同的名字，这个时候容器中只能存储一个同名的Bean对象，可以使用@Order()注解，来指定哪个类里面的方法先执行，那么Spring容器中也就保存了谁。3. 对同一类中多个方法返回的对象Bean重命名了相同的名字，程序执行的时候，由上而下，只会将第一个方法返回的Bean存储到Spring中，之后的相同名称的Bean就不会存储到Spring中了，容器会忽略掉。所以我们是不能直接通过getBean方法来获取到User对象的。
SpringBoot环境下购物推荐网站的高效开发策略
最新发布
2401_85702623的博客
10-12 862
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。任务：消除软件故障，保证程序的可靠运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值