Spring Bean的生命周期和钩子接口

最新推荐文章于 2024-08-21 00:01:33 发布
最新推荐文章于 2024-08-21 00:01:33 发布
阅读量765 收藏 2
点赞数
分类专栏： Spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kusedexingfu/article/details/117197766
版权

Spring Bean的生命周期流程如下图：

Spring Bean生命周期代码验证

下面我们来通过代码来验证下：

public class SpringBean implements BeanNameAware,
                                    BeanFactoryAware,
                                    ApplicationContextAware,
                                            InitializingBean, DisposableBean {

    @Autowired
    private void setOwnBeanFactory(BeanFactory beanFactory) {
        System.out.println("填充属性");
    }

    public SpringBean() {
        System.out.println("实例化");
    }

    /**
     * BeanNameAware
     * @param name
     */
    @Override
    public void setBeanName(String name) {
        System.out.println("调用BeanNameAware.setBeanName():" + name);
    }

    /**
     * BeanFactoryAware
     * @param beanFactory
     * @throws BeansException
     */
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("调用BeanFactoryAware.setBeanFactory()");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("调用ApplicationContextAware.setApplicationContext()");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("调用InitializingBean.afterPropertiesSet()");
    }

    @PostConstruct
    private void init() {
        System.out.println("调用@PostConstruct自定义初始化方法");
    }

    public void initMethod() {
        System.out.println("调用配置的initMethod自定义初始化方法");
    }

    @PreDestroy
    public void destory(){
        System.out.println("销毁:调用@PreDestroy自定义销毁方法");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("销毁:调用DisposableBean.destroy()");
    }

    public void destoryMethod() {
        System.out.println("销毁:调用配置的destoryMethod");
    }
}

下面是BeanPostProcessor的实现类

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("springBean")) {
            System.out.println("调用BeanPostProcessor.postProcessBeforeInitialization(),beanName:" + beanName);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("springBean")) {
            System.out.println("调用BeanPostProcessor.postProcessAfterInitialization(),beanName:" + beanName);
        }
        return bean;
    }
}

配置该类

    @Bean(initMethod = "initMethod", destroyMethod = "destoryMethod")
    public SpringBean springBean() {
        return new SpringBean();
    }

启动程序后，控制台打印如下：

关闭程序，控制台打印如下：

那么我们上面实现的Spring的这一系列接口：BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean 有什么作用呢？

钩子接口

以上提到的实现的Spring接口是Spring提供的扩展接口，官方将这些接口称之为钩子，这些钩子会在特定的时间被回调，以此来增强 Spring 功能，众多优秀的框架也是通过扩展这些接口，来实现自身特定的功能，如 SpringBoot、mybatis 等。

Aware系列接口

Aware 从字面意思理解就是“知道”、“感知”的意思，是用来获取 Spring 内部对象的接口。Aware 自身是一个顶级接口，它有一系列子接口，在一个 Bean 中实现这些子接口并重写里面的 set 方法后，Spring 容器启动时，就会回调该 set 方法，而相应的对象会通过方法参数传递进去。我们以其中的 ApplicationContextAware 接口为例。

大部分 Aware 系列接口都有一个规律，它们以对象名称为前缀，获取的就是该对象，所以 ApplicationContextAware 获取的对象是 ApplicationContext 。

public interface ApplicationContextAware extends Aware {

	void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
}

 比如，我们想在非Spring Bean的环境下获取Spring容器中的bean，我们可以通过如下方式获取

@Component
public class SpringContextUtil implements ApplicationContextAware {

    /**
     * 上下文对象实例
     */
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContextUtil.applicationContext = applicationContext;
    }

    /**
     * 通过class获取Bean.
     *
     * @param clazz
     * @param       <T>
     * @return
     */
    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    
}

在 Spring 启动过程中，会回调 setApplicationContext 方法，并传入 ApplicationContext 对象，之后就可对该对象进行操作。其它系列的 Aware 接口也是如此使用。

以下是几种常用的 Aware 接口：

  • BeanFactoryAware：获取 BeanFactory 对象，它是基础的容器接口。
  • BeanNameAware：获取 Bean 的名称。
  • EnvironmentAware：获取 Environment 对象，它表示整个的运行时环境，可以设置和获取配置属性。
  • ApplicationEventPublisherAware：获取 ApplicationEventPublisher 对象，它是用来发布事件的。
  • ResourceLoaderAware：获取 ResourceLoader 对象，它是获取资源的工具。

InitializingBean

InitializingBean接口如下：

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

它只有一个afterPropertiesSet方法，当一个 Bean 实现该接口时，在 Bean 的初始化阶段（设置完属性之后），会回调 afterPropertiesSet 方法。我它和@PostConstruct，还有通过@Bean设置initMethod的作用是一样的。

BeanPostProcessor

BeanPostProcessor 和 InitializingBean 有点类似，也是可以在 Bean 的生命周期执行自定义操作，一般称之为 Bean 的后置处理器，不同的是，
BeanPostProcessor 可以在 Bean 初始化前、后执行自定义操作，且针对的目标也不同，InitializingBean 针对的是实现 InitializingBean 接口的 Bean，而 BeanPostProcessor 针对的是所有的 Bean

public interface BeanPostProcessor {

	// Bean 初始化前调用
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	// Bean 初始化后调用
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

所有的 Bean 在初始化前、后都会回调接口中的 postProcessBeforeInitialization 和 postProcessAfterInitialization 方法，入参是当前正在初始化的 Bean 对象和 BeanName。

在上面我们演示Spring生命周期的代码中 MyBeanPostProcessor类中的方法如果没有

if (beanName.equals("springBean")) {}

这个判断，会打印很多Spring内部的Bean。

BeanPostProcessor 使用场景其实非常多，因为它可以获取正在初始化的 Bean 对象，然后可以依据该 Bean 对象做一些定制化的操作，如：判断该 Bean 是否为某个特定对象、获取 Bean 的注解元数据等。

BeanFactoryPostProcessor

BeanFactoryPostProcessor 是 Bean 工厂的后置处理器，一般用来修改上下文中的 BeanDefinition，修改 Bean 的属性值。

public interface BeanFactoryPostProcessor {

    // 入参是一个 Bean 工厂：ConfigurableListableBeanFactory。该方法执行时，所有 BeanDefinition 都已被加载，但还未实例化 Bean。
    // 可以对其进行覆盖或添加属性，甚至可以用于初始化 Bean。
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

Spring的BeanPostProcessor和BeanFactoryPostProcessor区别

Spring高级进阶：BeanFactoryPostProcessor

ImportSelector

可以参考：Spring Boot之ImportSelector

ImportSelector 是一个较为重要的扩展接口，通过该接口可动态的返回需要被容器管理的类，不过一般用来返回外部的配置类。可在标注 @Configuration 注解的类中，通过 @Import 导入 ImportSelector 来使用。

public interface ImportSelector {

	// 方法入参是注解的元数据对象，返回值是类的全路径名数组
	String[] selectImports(AnnotationMetadata importingClassMetadata);
}

selectImports 方法返回的是类的全路径名。

自定义 ImportSelector：

public class TestImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        
        if (importingClassMetadata.hasAnnotation("")) {
            // 判断是否包含某个注解
        }
        
        // 返回 Test 的全路径名，Test 会被放入到 Spring 容器中
        return new String[]{"com.loong.diveinspringboot.test.Test"};
    }
}

selectImports 方法中可以针对通过 AnnotationMetadata 对象进行逻辑判断，AnnotationMetadata 存储的是注解元数据信息，根据这些信息可以动态的返回需要被容器管理的类名称。

定义的 Test 类：

public class Test {
    public void hello() {
        System.out.println("Test -- hello");
    }
}

这里，我们没有对 Test 标注 @Component 注解，所以，Test 不会自动加入到 Spring 容器中。

@SpringBootApplication
@Import(TestImportSelector.class)
public class Main {
    public static void main(String[] args) {
        SpringApplication springApplication = new SpringApplication();
        ConfigurableApplicationContext run = springApplication.run(Main.class);
        Test bean = run.getBean(Test.class);
        bean.hello();
    }
}

之后通过 @Import 导入自定义的 TestImportSelector ，前面也说过，@Import 一般配合 @Configuration 使用，而 @SpringBootApplication 中包含了 @Configuration 注解。之后，通过 getBean 方法从容器中获取 Test 对象，并调用 hello 方法。最终，结果正确输出。

6、ImportBeanDefinitionRegistrar

Spring Boot通过ImportBeanDefinitionRegistrar动态注入Bean

该接口和 ImportSelector 类似，也是配合 @Import 使用，不过 ImportBeanDefinitionRegistrar 更为直接一点，它可以直接把 Bean 注册到容器中。

public interface ImportBeanDefinitionRegistrar {

	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
}

入参除了注解元数据对象 AnnotationMetadata 外，还多了一个 BeanDefinitionRegistry 对象，该对象定义了关于 BeanDefinition 的一系列的操作，如：注册、移除、查询等。

自定义 ImportBeanDefinitionRegistrar：

public class TestRegistrar implements ImportBeanDefinitionRegistrar {
    // 一般通过 AnnotationMetadata 进行业务判断，然后通过 BeanDefinitionRegistry 直接注册 Bean
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        RootBeanDefinition beanDefinition = new RootBeanDefinition(Test.class);
        beanDefinition.setLazyInit(true);
        registry.registerBeanDefinition(Test.class.getName(), beanDefinition);
    }
}

这里，主要通过 BeanDefinitionRegistry 手动注册 Test 类的 BeanDefinition，并设置懒加载属性。

ImportSelector 和 ImportBeanDefinitionRegistrar 是实现 @Enable 模式注解的核心接口，而 @Enable 模式注解在 Spring、SpringBoot、SpringCloud 中被大量使用，其依靠这些注解来实现各种功能及特性，是较为重要的扩展接口。

值得注意的是，SpringBoot 外部化配置、自动装配特性就是通过 @Enable 注解配合 ImportSelector 和 ImportBeanDefinitionRegistrar 接口来实现的。

FactoryBean

FactoryBean的作用

FactoryBean 也是一种 Bean，不同于普通的 Bean，它是用来创建 Bean 实例的，属于工厂 Bean，不过它和普通的创建不同，它提供了更为灵活的方式，其实现有点类似于设计模式中的工厂模式和修饰器模式。

Spring 框架内置了许多 FactoryBean 的实现，它们在很多应用如(Spring的AOP、ORM、事务管理)及与其它第三框架(ehCache)集成时都有体现。

public interface FactoryBean<T> {
	// 该方法会返回该 FactoryBean “生产”的对象实例，我们需要实现该方法以给出自己的对象实例化逻辑
	T getObject() throws Exception;

	// Bean的类型
	Class<?> getObjectType();

	// 是否是单例
	default boolean isSingleton() {
		return true;
	}
}

自定义 FactoryBean:

@Component
public class TestFactoryBean implements FactoryBean<Test> {
    @Override
    public Test getObject() throws Exception {

        // 这里可以灵活的创建 Bean，如：代理、修饰

        return new Test();
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }
}

Test 类：

public class Test {
    public void hello() {
        System.out.println("Test -- hello");
    }
}

启动类：

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        SpringApplication springApplication = new SpringApplication();
        ConfigurableApplicationContext run = springApplication.run(Main.class);
        Test bean = (Test) run.getBean("testFactoryBean");
        bean.hello();
    }
}

输出：

2020-02-27 23:16:00.334  INFO 32234 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2020-02-27 23:16:00.338  INFO 32234 --- [           main] com.loong.diveinspringboot.test.Main     : Started Main in 3.782 seconds (JVM running for 4.187)
Test -- hello

可以看到，启动类中 getBean 的参数是 testFactoryBean ，从这可以看出，当容器中的 Bean 实现了 FactoryBean 后，通过 getBean(String BeanName) 获取到的 Bean 对象并不是 FactoryBean 的实现类对象，而是这个实现类中的 getObject() 方法返回的对象。如果想获取 FactoryBean 的实现类，需通过这种方式：getBean(&BeanName)，在 BeanName 之前加上&。

ApplicationListener

ApplicationListener 是 Spring 实现事件机制的核心接口，属于观察者设计模式，一般配合 ApplicationEvent 使用。在 Spring 容器启动过程中，会在相应的阶段通过 ApplicationContext 发布 ApplicationEvent 事件，之后所有的 ApplicationListener 会被回调，根据事件类型，执行不同的操作。

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {

	void onApplicationEvent(E event);
}

在 onApplicationEvent 方法中，通过 instanceof 判断 event 的事件类型。

自定义 ApplicationListener：

@Component
public class TestApplicationListener implements ApplicationListener {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof TestApplicationEvent) {
            TestApplicationEvent testApplicationEvent = (TestApplicationEvent) event;
            System.out.println(testApplicationEvent.getName());
        }
    }
}

当自定义的 TestApplicationListener 被回调时，判断当前发布的事件类型是否是自定义的 TestApplicationEvent，如果是则输出事件名称。

自定义 TestApplicationEvent：

public class TestApplicationEvent extends ApplicationEvent {

    private String name;

    public TestApplicationEvent(Object source, String name) {
        super(source);
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

启动类：

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        SpringApplication springApplication = new SpringApplication();
        ConfigurableApplicationContext run = springApplication.run(Main.class);
        run.publishEvent(new TestApplicationEvent(new Main(),"Test 事件"));
    }
}

通过 ApplicationContext 发布 TestApplicationEvent 事件。当然也可以在业务代码中通过 ApplicationContextAware 获取 ApplicationContext 发布事件。

结果：

2020-02-27 08:37:10.972  INFO 30984 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2020-02-27 08:37:11.026  INFO 30984 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2020-02-27 08:37:11.029  INFO 30984 --- [           main] com.loong.diveinspringboot.test.Main     : Started Main in 3.922 seconds (JVM running for 4.367)
Test 事件

ApplicationListener 也被 SpringBoot 进行扩展，来实现自身特定的事件机制。

 

参考链接：https://www.cnblogs.com/loongk/p/12375708.html

kusedexingfu
关注
专栏目录
Bean 生命周期 钩子
姜希成的博客
11-15 287
创建 ➡ 初始化 ➡ 销毁 创建 构造方法 初始化 postProcessBeforeInitialization() @PostConstruct InitializingBean接口的afterPropertiesSet @Bean的 initMethod postProcessAfterInitialization() 销毁 @PreDestroy DisposableBean接口的 destroy @Bean的 destroyMethod 运行示例 第一行是构造方法打印的 ...
Spring之Spring Bean生命周期
weixin_66277385的博客
03-23 490
生命周期 1.什么是生命周期呢？ 当前组件在创建到销毁经历的一系列过程，称之为生命周期 2.生命周期的分为几个阶段？每个阶段有哪些钩子函数？ 生命周期分为3个阶段，这三个阶段分别是： 初始化 、 运行中 、 销毁 什么是Bean 首先，我们来看看Spring官方文档对于Bean的定义： 在 Spring 中，构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。bean 是由 Spring IoC 容器实例化、组装和管理的对象。否则，bean 只是应用程序中...
Spring中与Bean相关的接口
07-29
NULL 博文链接：https://justsee.iteye.com/blog/814516
在Spring Bean 生命周期中加入钩子函数
小伍的程序之路
11-13 1158
1 前言 提供一个控制反转功能是 Spring框架的核心功能之一。 Spring 在其应用程序上下文中组织并 并管理这些beans的生命周期。 在本教程中，我们将研究这些 bean 的生命周期以及我们如何加入这些钩子函数。 代码示例 他的文章附有 GitHub 上的工作代码示例。 2 什么是 Spring Bean？ 让我们从基础开始。 在创建、编排和销毁方面受 Spring 的 ApplicationContext控制的每个对象都称为 Spring Bean。 定义 Spring bean 最常见的方
科普文：Java基础Spring系列之【spring钩子函数汇总以及Spring Bean 的生命周期】
最新发布
为无为，事无事，味无味。
08-21 622
Spring作为当前Java最流行、最强大的轻量级框架，受到了程序员的热烈欢迎。准确的了解Spring Bean的生命周期是非常必要的。我们通常使用ApplicationContext作为Spring容器。这里，我们讲的也是 ApplicationContext中Bean的生命周期。而实际上BeanFactory也是差不多的，只不过处理器需要手动注册。
spring提供的关于bean生命周期的接口
Java_fenxiang的博客
06-05 1517
先看一张图：spring4.x 企业实战spring版本：4.3.171、bean自身的生命周期接口1.1、实现 InitializingBean、DisposableBean 接口这2个接口，会要求你实现2个方法@Component public class BeanSelf implements InitializingBean, DisposableBean { @Override ...
Spring Bean工厂的接口
Cloud-Future的博客
03-21 546
1、BeanFactory接口 Spring中的BeanFactory是bean工厂的顶级接口，它定义了bean工厂的基本职能。具有方法如下： 2、AutowireCapableBeanFactory接口 AutowireCapableBeanFactory接口是BeanFactory的子接口，它扩展了BeanFactory的功能，使bean工厂对bean具有自动注入的功能。在这个...
Spring Bean的生命周期(一图流+详细说明)
热门推荐
马赛琦的博客
10-20 1万+
在我的博客阅读本文 1. 前言 Spring是一个IOC（Inversion of Control，控制反转）容器框架，拥有DI（Dependency Injection，依赖注入），DL（Dependency Lookup，依赖查找 等功能。 认为一个IOC框架最基本要有以下功能： 配置解析 对象创建 对象生命周期管理 本文基于Spring-5.2.2.RELEASE版本进行论述，为了简明扼要，在展示部分代码的时候省略了一些细节。 Spring Bean的生命周期总结因为没有一个正式的文档，因此是.
结合spring的一些钩子函数，看bean的生命周期
Fighting
12-19 647
本次用了spring的这些接口： 接口名 实现接口方法 BeanFactoryAware setBeanFactory() BeanNameAware setBeanName() InitializingBean afterPropertiesSet() DisposableBean destroy() BeanFact...
Spring Bean生命周期详解与示例
最后，BeanPostProcessor是一种用于Bean生命周期钩子的接口，它提供了一系列预初始化和后初始化的方法，如preInitialization()和postInitialization()。开发者可以利用这些钩子在Bean实例化前后执行自定义逻辑，例如...
Spring-IOC bean 生命周期之 Lifecycle 钩子
weixin_30849591的博客
09-10 124
Lifecycle callbacks Initialization callbacks、Destruction callbacks 要与容器的bean生命周期管理交互,即容器在启动后和容器在销毁前对每个bean执行操作，有如下三种方法: 1.实现Spring框架的InitializingBean和DisposableBean接口。容器为前者调用afterPropertiesSet()方法，...
详解常用的Spring Bean扩展接口
08-30
本篇文章主要介绍了一些常用的Spring Bean扩展接口以及它们的简单用法，具有很好的参考价值。下面跟着小编一起来看下吧
详解Spring中接口的bean是如何注入的
08-19
主要介绍了详解Spring中接口的bean是如何注入的的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
spring InitializingBean 接口 与 BeanNameAware 接口
一个执着的程序员
08-01 4795
最近工作需要得到sping中的每个事物需要执行的sql，称机会简单研究了一下spring的事务，项目中管理事务比较简单，用TransactionTemplate，就直接以TransactionTemplate为入口开始学习。 TransactionTemplate的源码如下： public class TransactionTemplate extends DefaultTransaction
spring的钩子_Spring ApplicationContext 的生命周期钩子探究
weixin_36366239的博客
01-17 198
Spring 提供了多种方法实现 Bean 在初始化和销毁时的回调：JSR-250 标准提供了一对注解 @PostConstruct 和 @PreDestroy，用于在类中标识某方法为生命周期钩子。实现了 InitializingBean 接口，可以在 afterPropertiesSet() 方法里做初始化之后的任务。实现了 DisposableBean 接口，可以在 destroy() 方法里...
深入理解Spring（一）BeanDefinition接口
科蒙D的博客
09-10 354
写在前言： 本内容是自学过程中进行的重点内容记录，用到的图片，术语来源于网络博客、视频术语、书本当中。个人只是自我的理解和总结归纳。https://blog.csdn.net/java_lyvee/article/details/102633067 一、JavaBean和SpringBean的区别 SpringBean是通过Spring容器来初始化的对象，SpringBean具有Spring的生命周期，但SpringBean一定是JavaBean，但JavaBean不一定是SpringBean，Jav
Spring 中bean 生命周期过程中的各种接口
sushuiyuzhou的专栏
09-09 1534
Spring 中bean 的生命周期短暂吗? 在spring中，从BeanFactory或ApplicationContext取得的实例为Singleton，也就是预设为每一个Bean的别名只能维持一个实例，而不是每次都产生一个新的对象使用Singleton模式产生单一实例，对单线程的程序说并不会有什么问题，但对于多线程的程序，就必须注意安全(Thread-safe)的议题，防止多个线程同时存取共享资源所引发的数据不同步问题。 然而在spring中 可以设定每次从BeanFactory或Applicat
【spring】bean的生命周期
王佑辉的博客
03-16 350
6.如果bean实现了ApplicationContextAware接口，spring将调用setApplicationContext()方法，将bean所在的应用上下文的引用传入。5.如果bean实现了BeanFactoryAware接口，spirng将调用setBeanFactory()方法，将BeanFactory容器实例传入。4.如果bean实现了BeanNameAware接口，spring将bean的ID传递给setBean-Name()方法。2.spring对bean进行实例化。
spring容器启动就获得实现指定接口的beanMap
mid120的博客
12-26 1372
package cn.baozun.crm.listener; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import org.springframework.context.ApplicationListener; import org.springframew
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值