Spring6--手写简易IOC容器

已于 2024-05-10 13:32:13 修改
阅读量457 收藏 9
点赞数 7
分类专栏： JAVA框架 文章标签： spring java 后端
于 2024-02-28 20:55:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czy940115/article/details/136355879
版权

  • 控制反转（IOC）：控制反转是一种思想，即将对象的创建权力和对象与对象之间的关系交出去，给第三方容器负责
  • 依赖注入（DI）：实现了控制反转的思想。
  • Bean管理：Bean对象的创建，以及Bean对象中属性的赋值（或者叫Bean对象之间关系的维护）。      

步骤：

1.搭建子模块

2.准备测试需要的bean

3.定义注解

4.定义bean容器接口

5.编写注解bean容器接口实现

6.编写扫描bean逻辑

7.java类标识Bean注解

8.测试Bean加载

9.依赖注入

10.依赖注入实现

1.搭建Spring6模块

 使用IDEA大家Spring6的模块，便于实现IOC思想并完成打包。

 

2.准备测试需要的bean

 为实现后的产品准备验证测试工具：

  1. 添加依赖
  2. 创建UserDao接口以及创建UserDaoImpl实现
  3. 创建UserService接口以及创建UserServiceImpl实现类
1.添加依赖 -- 测试所需依赖
<dependencies>
    <!--junit5测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.3.1</version>
    </dependency>
</dependencies>
2.准备测试接口以及实现类
package com.czy.spring.test.service;

/**
 * ClassName: UserService
 * Package: com.czy.spring6.test.service
 * Description:
 *
 * @Author Chen Ziyun
 * @Version 1.0
 */
public interface UserService {
    public void out();
}

package com.czy.spring.test.service.impl;

import com.czy.spring.core.annotation.Bean;
import com.czy.spring.test.dao.UserDao;
import com.czy.spring.test.service.UserService;

/**
 * ClassName: UserServiceImpl
 * Package: com.czy.spring6.test.service.impl
 * Description:
 *
 * @Author Chen Ziyun
 * @Version 1.0
 */
@Bean
public class UserServiceImpl implements UserService {
    private UserDao userDao;

    @Override
    public void out() {
        // userDao.print();
        System.out.println("Service层执行结束");
    }
}
package com.czy.spring.test.dao;

/**
 * ClassName: UserDao
 * Package: com.czy.spring6.test.dao
 * Description:
 *
 * @Author Chen Ziyun
 * @Version 1.0
 */
public interface UserDao {
    public void print();
}
package com.czy.spring.test.dao.impl;

import com.czy.spring.core.annotation.Bean;
import com.czy.spring.test.dao.UserDao;

/**
 * ClassName: UserDaoImpl
 * Package: com.czy.spring6.test.dao.impl
 * Description:
 *
 * @Author Chen Ziyun
 * @Version 1.0
 */
@Bean
public class UserDaoImpl implements UserDao {
    @Override
    public void print() {
        System.out.println("Dao层执行结束");
    }
}

3.定义注解

 通过注解的形式加载Bean与实现依赖注入

 Bean注解：

package com.czy.spring.core.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * ClassName: Bean
 * Package: com.czy.spring.core.annotation
 * Description:
 *  通过注解的形式加载bean与实现依赖注入
 * @Author Chen Ziyun
 * @Version 1.0
 */
@Target(ElementType.TYPE)// 注解作用范围
@Retention(RetentionPolicy.RUNTIME)//注解的生命周期
public @interface Bean {
}

 依赖注入注解：

package com.czy.spring.core.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * ClassName: Di
 * Package: com.czy.spring.core.annotation
 * Description:
 *  依赖注入注解
 * @Author Chen Ziyun
 * @Version 1.0
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Di {
}

4.定义bean容器接口

 与Spring6中的ApplicationContext功能类似，即相当于BeanFactory的子接口

package com.czy.spring.core;

/**
 * ClassName: ApplocationContext
 * Package: com.czy.spring.core
 * Description:
 *
 * @Author Chen Ziyun
 * @Version 1.0
 */
public interface ApplicationContext {
    Object getBean(Class clazz);
}

5.编写注解bean容器接口实现

 AnnotationApplicationContext基于注解扫描bean

package com.czy.spring;

import com.czy.spring.core.ApplicationContext;
import java.util.HashMap;
import java.util.Map;

/**
 * ClassName: AnnotationApplicationContext
 * Package: com.atczy.annotation
 * Description:
 *  初始化该对象时，获取所有的具备Bean注释的类，将其封装到beanFactory的Map容器当中，初始化
 * @Author Ziyun Chen
 * @Create 2024/2/28 18:36
 * @Version 1.0  
 */
public class AnnotationApplicationContext implements ApplicationContext {
    private static Map<Class, Object> beanFactory = new HashMap<>();// 存储bean的容器

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 根据包扫描加载bean
     *  创建有参构造，传递包路径，设置包扫描规则
     *  当前包及其子包，那个类有@Bean注解，把这个类通过反射实例化
     */
    public AnnotationApplicationContext(String basePackage){
       
    }
}

6.编写扫描bean逻辑

 通过构造方法传入包的base路径，扫描被@Bean注解的java对象 ---- 加载Bean,获取所有的具备Bean注释的类，将其封装到beanFactory的Map容器当中

  1. 查看当前文件夹是否是空文件夹？是-返回，否-查看当前文件夹下的所有文件
  2. 遍历当前文件夹下的所有文件
  3. 当前文件是否是文件夹？是-递归，否-查看当前文件
  4. 查看当前class文件是否有Bean注解：是 -- 将非接口类的实例放入Map中；否 -- 直接跳过
package com.czy.spring;

import com.czy.spring.core.ApplicationContext;
import com.czy.spring.core.annotation.Bean;
import com.czy.spring.core.annotation.Di;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * ClassName: AnnotationApplicationContext
 * Package: com.atczy.annotation
 * Description:
 *  初始化该对象时，获取所有的具备Bean注释的类，将其封装到beanFactory的Map容器当中，初始化
 * @Author Ziyun Chen
 * @Create 2024/2/28 18:36
 * @Version 1.0  
 */
public class AnnotationApplicationContext implements ApplicationContext {
    private static Map<Class, Object> beanFactory = new HashMap<>();// 存储bean的容器
    private static String rootPath;

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 根据包扫描加载bean
     *  创建有参构造，传递包路径，设置包扫描规则
     *  当前包及其子包，那个类有@Bean注解，把这个类通过反射实例化
     */
    public AnnotationApplicationContext(String basePackage){
        // 1.获取该包的绝对路径
        String packagePath = basePackage.replaceAll("\\.", "\\\\");
        try {
            Enumeration<URL> urls =
                    Thread.currentThread().getContextClassLoader().getResources(packagePath);

            while (urls.hasMoreElements()){
                URL url = urls.nextElement();
                String filePath = URLDecoder.decode(url.getFile(), "utf-8");
                rootPath = filePath.substring(0, filePath.length()-packagePath.length());// 获取跟路径

                // 加载Bean,获取所有的具备Bean注释的类，将其封装到beanFactory的Map容器当中
                loadBean(new File(filePath));
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private static void loadBean(File file) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 1.查看当前文件夹是否是空文件夹？是-返回，否-查看当前文件夹下的所有文件
        if (!file.exists()){
            return;
        }
        if (file.isDirectory()){
            // 2.遍历当前文件夹下的所有文件
            File[] files = file.listFiles();
            if (files == null || files.length == 0){
                return;
            }
            for (File childFile :  files){
                // 3.当前文件是否是文件夹？是-递归，否-查看当前文件
                if (childFile.isDirectory()){
                    loadBean(childFile);
                }else {
                    // 4.查看当前class文件是否有Bean注解
                    // 4.1 通过文件名获取全类名，第一步把绝对路径去掉
                    String pathWithClass = childFile.getAbsolutePath().substring(rootPath.length()-1);
                    // 选中class文件
                    if (pathWithClass.contains(".class")){
                        // 将路径中的/转化为.,把.class去掉 -- 获取class的全类名
                        String fullName = pathWithClass.replaceAll("\\\\", "\\.").
                                replace(".class", "");
                        // 4.2 是否有Bean注解，
                        Class<?> clazz = Class.forName(fullName);

                        // 将非接口类的实例放入Map中
                        if (!clazz.isInterface()){
                            Bean annotation = clazz.getAnnotation(Bean.class);
                            if (annotation != null){
                                // 实例化该对象
                                Object instance = clazz.getDeclaredConstructor().newInstance();
                                if (clazz.getInterfaces().length > 0){
                                    // 判断是否有Implement接口 是-以该接口为clazz传入Map中
                                    beanFactory.put(clazz.getInterfaces()[0], instance);
                                }else {
                                    // 否-以该类为clazz传入Map
                                    beanFactory.put(clazz, instance);
                                }

                            }
                        }
                    }

                }


            }
        }

    }
}

7.java类标识Bean注解

 

8.测试Bean加载

package com.czy.spring;

import com.czy.spring.core.ApplicationContext;
import com.czy.spring.test.service.UserService;
import org.junit.jupiter.api.Test;

/**
 * ClassName: SpringIocTest
 * Package: com.czy.spring
 * Description:
 *
 * @Author Chen Ziyun
 * @Version 1.0
 */
public class SpringIocTest {
    @Test
    public void testIoc(){
        ApplicationContext applicationContext = new AnnotationApplicationContext("com.czy.spring.test");

        UserService userService = (UserService) applicationContext.getBean(UserService.class);

        userService.out();
        System.out.println("run success");
    }
}

 

以上，对象的创建功能已经实现了，但是对于对象之间的关系管理需要进一步实现。即依赖的注入（Di）。 

9.依赖注入

 在创建UserService的过程中，需要完成依赖的注入，此时，依赖注入功能还没有实现，userDao是个空对象，其中的方法都无法调用

10.依赖注入实现

需要对实现类进行扫描，查看其是否具备依赖注入相关的注解，并进行对象的创建 --- 实例化

对象在beanFactory的map集合中

  1. 遍历beanFactory的map集合
  2. 获取map的value值，每个属性获取到
  3. 遍历得到每个对象属性数组，得到每个属性
  4. 判断属性上面是否有@Di注解
  5. 如果有@Di注解，把对象进行设置（注入）
package com.atczy.annotation;

import com.czy.spring.core.ApplicationContext;
import com.czy.spring.core.annotation.Bean;
import com.czy.spring.core.annotation.Di;
import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.logging.Filter;

/**
 * ClassName: AnnotationApplicationContext
 * Package: com.atczy.annotation
 * Description:
 *  初始化该对象时，获取所有的具备Bean注释的类，将其封装到beanFactory的Map容器当中，初始化
 * @Author Ziyun Chen
 * @Create 2024/2/28 18:36
 * @Version 1.0  
 */
public class AnnotationApplicationContext implements ApplicationContext {
    private static Map<Class, Object> beanFactory = new HashMap<>();// 存储bean的容器
    private static String rootPath;

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 根据包扫描加载bean
     *  创建有参构造，传递包路径，设置包扫描规则
     *  当前包及其子包，那个类有@Bean注解，把这个类通过反射实例化
     */
    public AnnotationApplicationContext(String basePackage){
        // 1.获取该包的绝对路径
        String packagePath = basePackage.replaceAll("\\.", "\\\\");
        try {
            Enumeration<URL> urls =
                    Thread.currentThread().getContextClassLoader().getResources(packagePath);

            while (urls.hasMoreElements()){
                URL url = urls.nextElement();
                String filePath = URLDecoder.decode(url.getFile(), "utf-8");
                rootPath = filePath.substring(0, filePath.length()-packagePath.length());// 获取跟路径

                // 加载Bean,获取所有的具备Bean注释的类，将其封装到beanFactory的Map容器当中
                loadBean(new File(filePath));

                // 加载Di
                loadDi();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private static void loadBean(File file) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 1.查看当前文件夹是否是空文件夹？是-返回，否-查看当前文件夹下的所有文件
        if (!file.exists()){
            return;
        }
        if (file.isDirectory()){
            // 2.遍历当前文件夹下的所有文件
            File[] files = file.listFiles();
            if (files == null || files.length == 0){
                return;
            }
            for (File childFile :  files){
                // 3.当前文件是否是文件夹？是-递归，否-查看当前文件
                if (childFile.isDirectory()){
                    loadBean(childFile);
                }else {
                    // 4.查看当前class文件是否有Bean注解
                    // 4.1 通过文件名获取全类名，第一步把绝对路径去掉
                    String pathWithClass = childFile.getAbsolutePath().substring(rootPath.length()-1);
                    // 选中class文件
                    if (pathWithClass.contains(".class")){
                        // 将路径中的/转化为.,把.class去掉 -- 获取class的全类名
                        String fullName = pathWithClass.replaceAll("\\\\", "\\.").
                                replace(".class", "");
                        // 4.2 是否有Bean注解，
                        Class<?> clazz = Class.forName(fullName);

                        // 将非接口类的实例放入Map中
                        if (!clazz.isInterface()){
                            Bean annotation = clazz.getAnnotation(Bean.class);
                            if (annotation != null){
                                // 实例化该对象
                                Object instance = clazz.getDeclaredConstructor().newInstance();
                                if (clazz.getInterfaces().length > 0){
                                    // 判断是否有Implement接口 是-以该接口为clazz传入Map中
                                    beanFactory.put(clazz.getInterfaces()[0], instance);
                                }else {
                                    // 否-以该类为clazz传入Map
                                    beanFactory.put(clazz, instance);
                                }

                            }
                        }
                    }

                }


            }
        }

    }

    private void loadDi() throws IllegalAccessException {
        // 实例化对象在beanFactory的map集合中
        // 1.遍历beanFactory的map集合
        Set<Map.Entry<Class, Object>> entries = beanFactory.entrySet();
        for (Map.Entry<Class, Object> entry : entries){
            // 2.获取map的value值，每个属性获取到
            Object obj = entry.getValue();
            Class<?> clazz = obj.getClass();
            Field[] declaredFields = clazz.getDeclaredFields();

            // 3.遍历得到每个对象属性数组，得到每个属性
            for (Field field : declaredFields){
                //4.判断属性上面是否有@Di注解
                Di annotation = field.getAnnotation(Di.class);
                if (annotation != null){
                    // 5.如果有@Di注解，把对象进行设置（注入）
                    field.setAccessible(true);
                    field.set(obj, beanFactory.get(field.getType()));
                }

            }
        }

    }
}
陈紫云
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring5 框架 ---- IOC容器 ---- 代码
09-10
Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- ...
Spring--手写一个简易的IoC容器，附思路原理
q1472750149的博客
11-18 1204
依赖注入 DI（Dependecy Injection） 一个Java对象依赖别的对象，一种依赖关系，如service依赖dao,只声明对象不赋值均为null，通过注入自动装配对象实例 控制反转 IoC（Inversion of Control） 不需要控制所有依赖和装配的进行，有容器会自动进行装配 下面的案例，简单的实现IoC容器，可帮助理解依赖注入和控制反转 （在这个demo中是基于maven搭建的，使用了springframework的Autowired，但不重要，自己生成一个注解替.
手写MiniSpring--- IOC
weixin_38214514的博客
12-14 1112
最近学习极客时间上的课程，记录一下。
手写Spring框架---IOC容器&依赖注入实现
汤键的博客
04-25 742
手写Spring框架---IOC容器&依赖注入实现
Spring学习及手写简易IOC容器
wjs15050的博客
08-20 208
通过反射实现简易IOC容器
Spring框架-IoC容器
11-13
Spring-IoC容器
Java-Spring-SpringIoC容器-SpringIoC的学习
10-11
Java-Spring-SpringIoC容器-SpringIoC的学习 SpringIoC容器的学习笔记 主要介绍了IoC容器工作原理以及如何配置IoC容器 通过标签和注解配置容器
【框架源码篇 01】Spring源码-手写IOC
10-21
【框架源码篇 01】Spring源码-手写IOC
maven-spring-ioc
08-07
spring IoC， 使用配置文件方式配置Bean的实例化和依赖注入
基于springboot实现智慧图书管理系统项目【项目源码+论文说明】
ybigbear2的博客
05-09 780
本课题研发的智慧图书管理系统，就是提供图书借阅信息处理的解决方案，它可以短时间处理完信息，并且只需要使用者动动鼠标和键盘就能获取自己需要的信息，并且这些信息都有专门的存储设备，而且数据的备份和迁移都可以设定为无人值守，从人力角度和信息处理角度以及信息安全角度，智慧图书管理系统是完胜传统纸质操作的，所以智慧图书管理系统就是如此的值得信赖。图4.1即为设计的管理员功能结构，管理员权限操作的功能包括对注册读者信息的管理，对图书，对图书留言，对图书借阅记录，对论坛帖子等信息的管理。
毕业就业信息|基于Springboot＋vue的毕业就业信息管理系统的设计与实现(源码+数据库+文档)
伟庭的博客
05-07 1059
毕业就业信息管理系统在对开发工具的选择上也很慎重，为了便于开发实现，选择的开发工具为Eclipse，选择的数据库工具为Mysql。以此搭建开发环境实现毕业就业信息管理系统的功能。其中管理员管理用户，新闻公告。毕业就业信息管理系统是一款运用软件开发技术设计实现的应用系统，在信息处理上可以达到快速的目的，不管是针对数据添加，数据维护和统计，以及数据查询等处理要求，毕业就业信息管理系统都可以轻松应对。关键词：毕业就业信息管理系统；SpringBoot框架，系统分析，数据库设计。
Spring之Bean生命周期源码解析
dzend的专栏
05-08 937
在Spring框架中，Bean的生命周期是非常重要的，它涉及到Bean的创建、初始化、销毁等过程。通过对Spring之Bean生命周期源码的解析，我们可以更好地理解Spring容器是如何管理Bean的生命周期的。
Spring Security
程序员碎像的博客
05-08 1079
/ 默认URL路径跳转到/login, 此url为spring security所提供@Override// 当用户访问根路径时，将会被重定向到登录页面@Bean// 这里返回一个PasswordEncoder实例，用于密码编码。// 在实际应用中，应该使用BCryptPasswordEncoder来对密码进行加密。// 下面这行代码是用于测试的，它不对密码进行加密，这在生产环境中是不安全的。@Bean。
【SpringBoot】解锁后端测试新境界：学习Mockito与MockMvc的单元测试魔法
墩墩分墩
05-08 444
**所谓的mock就是创建一个`类的虚拟对象`，在测试环境中，`用来替换掉真实的对象`，以达到2个目的：** - 验证这个对象的某些方法的调用情况，调用了多少次，参数是什么等等 - 指定这个对象的某些方法的行为，返回特定的值，或者是执行特定的动作
【全面介绍下Spring】
最新发布
2301_81357485的博客
05-11 597
Spring框架提供了用于构建Web应用程序的多个模块，如Spring MVC、Spring WebFlux和Spring Web Services。Spring使用IoC容器来管理应用组件之间的依赖关系，通过IoC，开发人员可以将对象的创建和组装转移给Spring容器来管理，从而降低了组件之间的耦合。🌈总之，Spring框架为Java应用程序开发提供了丰富的功能和强大的扩展性，它通过提供模块化的解决方案和简化开发流程，帮助开发人员更高效地构建高质量的企业级应用程序。
org.springframework.jdbc.BadSqlGrammarException
weixin_46176940的博客
05-11 195
Cause: java.sql.SQLSyntaxErrorException: Table 'web.emp' doesn't exist
Spring Bean的线程安全问题
qq_51967234的博客
05-08 510
就是没有实例变量的对象，不能保存数据，是不变类，是线程安全的。但无状态会话bean 并非没有状态，如果它有自己的属性（变量），那么这些变量就会受到所有调用它的用户的影响，这是在实际应用中必须注意的。，每次获取都会创建一个新的 bean 实例，不管对于有状态的bean和无状态的bean，都不存在线程安全问题，但如果变量是静态的，那就会有线程不安全问题。无状态的bean不会有线程安全问题，但对于有状态的bean会有线程安全问题，可以用（threadlocal，改作用域，避免定义可变的成员变量）来解决。
springboot项目打包部署
Relievedz的博客
05-11 323
springboot打包的前提条件jdk必须17以后不然本地运行不来（我用的jdk是22）6、java -jar 文件名 出现这个画面就是运行成功了。2、打开项目的maven-项目名-package。4、打开项目文件会出现一个jar的文件。查看自己电脑jdk版本可以参考（1、idea配置打包文件。5、在这个页面cmd。
Spring-IOC
11-13
Spring-IOC是Spring框架的核心部分之一，它是一种设计模式，全称为Inversion of Control（控制反转）。它通过将对象的创建、依赖关系的管理和对象的生命周期交给Spring容器来实现，从而降低了组件之间的耦合度，提高了代码的可重用性和可维护性。Spring-IOC的实现主要依靠Spring容器，Spring容器是Spring框架的核心，它负责创建、管理和装配Bean对象，其中Bean是Spring框架中最基本的组件。 Spring-IOC的实现主要有两种方式：BeanFactory和ApplicationContext。其中，BeanFactory是Spring-IOC的基本实现，而ApplicationContext是BeanFactory的子接口，提供了更多高级特性。ApplicationContext是Spring框架中最常用的IOC容器，它除了提供BeanFactory的所有功能外，还提供了更多的企业级特性，例如AOP、事务管理、国际化、事件传播等。 下面是一个简单的Spring-IOC的例子，假设我们有一个UserService接口和一个UserServiceImpl实现类，我们可以通过Spring-IOC容器来创建和管理UserServiceImpl对象： 1.定义UserService接口和UserServiceImpl实现类 ```java public interface UserService { void addUser(User user); } @Service public class UserServiceImpl implements UserService { @Override public void addUser(User user) { // 添加用户的具体实现 } } ``` 2.在Spring配置文件中配置UserService实例 ```xml <bean id="userService" class="com.example.service.UserServiceImpl"/> ``` 3.在代码中获取UserService实例并使用 ```java ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserService userService = context.getBean("userService", UserService.class); User user = new User(); userService.addUser(user); ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值