SpringIoc 实现原理

已于 2022-12-02 14:56:33 修改
阅读量905 收藏 5
点赞数 1
分类专栏： java springboot 文章标签： java spring jvm
于 2020-11-10 22:31:08 首次发布
原文链接：https://blog.csdn.net/zhangcongyi420/article/details/89419715
版权

什么是SpringIOC

spring ioc指的是控制反转，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。交由Spring容器统一进行管理，从而实现松耦合

“控制反转”，不是什么技术，而是一种设计思想。

在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：
●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

●为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

IOC实现原理

使用反射机制+XML技术

理解了这些基本概念后，我们通过一个简单的示意图来简单描述一下整个流程，
在这里插入图片描述
从示意图可以看出，当web容器启动的时候，spring的全局bean的管理器会去xml配置文件中扫描的包下面获取到所有的类，并根据你使用的注解，进行对应的封装，封装到全局的bean容器中进行管理，一旦容器初始化完毕，beanID以及bean实例化的类对象信息就全部存在了，现在我们需要在某个service里面调用另一个bean的某个方法的时候，我们只需要依赖注入进来另一个bean的Id即可，调用的时候，spring会去初始化完成的bean容器中获取即可，如果存在就把依赖的bean的类的实例化对象返回给你，你就可以调用依赖的bean的相关方法或属性等；

下面通过实例代码来模拟一下整个IOC的原理和执行流程，
1、demo结构如下，
在这里插入图片描述
2、pom依赖文件，这里只需要spring的基本依赖即可，

<properties>

		<spring.version>5.1.2.RELEASE</spring.version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>1.6.1</version>
		</dependency>

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


		<!-- https://mvnrepository.com/artifact/cglib/cglib -->
		<dependency>
			<groupId>cglib</groupId>
			<artifactId>cglib</artifactId>
			<version>3.2.10</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
		<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.5.2</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.40</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
		<dependency>
			<groupId>dom4j</groupId>
			<artifactId>dom4j</artifactId>
			<version>1.6.1</version>
		</dependency>

	</dependencies>

4、模拟spring的bean容器类，想必使用过spring框架在进行整合测试的时候，都使用到下面这段代码，这段代码的作用其实就是模拟在spring启动加载的时候，通过这个类去初始化一个bean 的容器管理类，所有的bean的信息解析和保存都会在这个类里面进行，下面我们写一个这样的类来还原一下这个过程，

SelfPathXmlApplicationContext app = new SelfPathXmlApplicationContext("com.congge.service.impl");

自定义spring的bean容器类，

/**

自定义bean管理器
@author asus
*/
public class SelfPathXmlApplicationContext {
private String packageName;

// 封装所有的bean容器
private ConcurrentHashMap<String, Object> beans = null;

/**
 * 该类被创建出来的时候加载
 * @param packageName
 * @throws Exception
 */
public SelfPathXmlApplicationContext(String packageName) throws Exception {
	beans = new ConcurrentHashMap<String, Object>();
	this.packageName = packageName;
	initBeans();
	initEntryField();
}

/**
 * 初始化bean的实例对象的所有属性
 * @throws Exception
 */
private void initEntryField() throws Exception {
	// 1.遍历所有的bean容器对象
	for (Entry<String, Object> entry : beans.entrySet()) {
		// 2.判断属性上面是否有加注解
		Object bean = entry.getValue();
		attriAssign(bean);
	}
}

/**
 * 根据beanId获取bean名称
 * @param beanId
 * @return
 * @throws Exception
 */
public Object getBean(String beanId) throws Exception {
	if (StringUtils.isEmpty(beanId)) {
		throw new Exception("beanId参数不能为空");
	}
	// 1.从spring容器获取bean
	Object object = beans.get(beanId);
	// attriAssign(object);
	return object;
}

/**
 * 获取扫描包下面的所有bean
 */
private void initBeans() throws Exception {
	// 1.使用java的反射机制扫包,[获取当前包下所有的类]
	List<Class<?>> classes = ClassParseUtil.getClasses(packageName);
	// 2、判断类上面是否存在注入的bean的注解
	ConcurrentHashMap<String, Object> classExisAnnotation = findClassExisAnnotation(classes);
	if (classExisAnnotation == null || classExisAnnotation.isEmpty()) {
		throw new Exception("该包下没有任何类加上注解");
	}

}

/**
 * 判断类上是否存在注入自定义的bean的注解
 * @param classes
 * @return
 * @throws Exception
 */
public ConcurrentHashMap<String, Object> findClassExisAnnotation(List<Class<?>> classes) throws Exception {
	for (Class<?> classInfo : classes) {
		// 判断类上是否有注解 [获取自定义的service注解]
		SelfService annotation = classInfo.getAnnotation(SelfService.class);
		if (annotation != null) {
			// 获取当前类的类名
			String className = classInfo.getSimpleName();
			String beanId = toLowerCaseFirstOne(className);
			Object newInstance = newInstance(classInfo);
			beans.put(beanId, newInstance);
		}

	}
	return beans;
}

// 首字母转小写
public static String toLowerCaseFirstOne(String s) {
	if (Character.isLowerCase(s.charAt(0)))
		return s;
	else
		return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
}

/**
 * 通过class名称获取类的实例化对象
 * @param classInfo
 * @return
 * @throws ClassNotFoundException
 * @throws InstantiationException
 * @throws IllegalAccessException
 */
public Object newInstance(Class<?> classInfo)
		throws ClassNotFoundException, InstantiationException, IllegalAccessException {
	return classInfo.newInstance();
}

/**
 * 依赖注入注解原理
 * @param object
 * @throws Exception
 */
public void attriAssign(Object object) throws Exception {

	// 1.使用反射机制,获取当前类的所有属性
	Class<? extends Object> classInfo = object.getClass();
	Field[] declaredFields = classInfo.getDeclaredFields();

	// 2.判断当前类属性是否存在注解
	for (Field field : declaredFields) {
		SelfAutowired extResource = field.getAnnotation(SelfAutowired.class);
		if (extResource != null) {
			// 获取属性名称
			String beanId = field.getName();
			Object bean = getBean(beanId);
			if (bean != null) {
				// 3.默认使用属性名称，查找bean容器对象 1参数 当前对象 2参数给属性赋值
				field.setAccessible(true); // 允许访问私有属性
				field.set(object, bean);
			}
		}
	}

}

当这个类被初始化的时候，通过构造函数里面的两个方法，通过外部传入指定的包名，解析该包下面的所有类和相关注解，其实现原理主要是使用了反射，
在这里插入图片描述

通过一个工具类获取到了所有的类的实例化集合后，我们对这个集合进行遍历，具体的执行方法可以看findClassExisAnnotation 这个方法，

在findClassExisAnnotation这个方法里面，可以看到，我们使用自定义的注解去到这个实例类对象去匹配，如果匹配到了相应的注解，就把这个bean封装到全局的集合中，这里使用了concurrentHashMap进行封装，
在这里插入图片描述
这一步完成之后，包含了自定义注解[@Service]的相关类对象就存在了内存集合中了，如果在web容器启动完毕之后，使用自己的bean的时候就可以直接通过getBean这个方法去容器里面直接获取就可以了，通过这个方法就可以拿到当前beanId对应的类的实例化对象，可以使用里面的相关方法，
但是到这里并没有完事啊，假如在我们某个标注了@Service的类里面有下面这样的注解，即依赖了其他的某个bean,比如，在我们的userService类里面依赖了orderService，就形成了所谓的依赖注入，
在这里插入图片描述
同样，依赖注入也是通过上面相同的方式，在initBean()方法结束之后立即执行，我们来看看这个方法，
在这里插入图片描述
在initEntryField（）这个方法里，要做的事情就是遍历上述初始化好的所有bean，然后再去每个bean的实例对象中解析并封装属性相关的对应信息，下面看一下initEntryField（）这个方法，
在这里插入图片描述
通过这个方法，就可以将某个bean中依赖的其他bean信息进行封装，

/**
	 * 依赖注入注解实现原理
	 * @param object
	 * @throws Exception
	 */
	public void attriAssign(Object object) throws Exception {

		// 1.使用反射机制,获取当前类的所有属性
		Class<? extends Object> classInfo = object.getClass();
		Field[] declaredFields = classInfo.getDeclaredFields();

		// 2.判断当前类属性是否存在注解
		for (Field field : declaredFields) {
			SelfAutowired extResource = field.getAnnotation(SelfAutowired.class);
			if (extResource != null) {
				// 获取属性名称
				String beanId = field.getName();
				Object bean = getBean(beanId);
				if (bean != null) {
					// 3.默认使用属性名称，查找bean容器对象 1参数 当前对象 2参数给属性赋值
					field.setAccessible(true); // 允许访问私有属性
					field.set(object, bean);
				}
			}
		}

	}

最后我们写一个测试类来验证一下，直接运行下面的main函数，

public class Test1 {

	public static void main(String[] args) throws Exception {
		
		SelfPathXmlApplicationContext app = new SelfPathXmlApplicationContext("com.congge.service.impl");
		UserServiceImpl userServiceImpl = (UserServiceImpl) app.getBean("userServiceImpl");
		String result = userServiceImpl.add();
		System.out.println("获取到了orderService的执行结果是 : " + result);
		System.out.println("当前的bean的实例对象是: " + userServiceImpl);
	}

}

可以看到我们自定义的bean容器已经生效了，
在这里插入图片描述
ClassParseUtil 工具类

package com.congge.utils;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class ClassParseUtil {

    /**
     * 取得某个接口下所有实现这个接口的类
     */
    public static List<Class> getAllClassByInterface(Class c) {
        List<Class> returnClassList = null;

        if (c.isInterface()) {
            // 获取当前的包名
            String packageName = c.getPackage().getName();
            // 获取当前包下以及子包下所以的类
            List<Class<?>> allClass = getClasses(packageName);
            if (allClass != null) {
                returnClassList = new ArrayList<Class>();
                for (Class classes : allClass) {
                    // 判断是否是同一个接口
                    if (c.isAssignableFrom(classes)) {
                        // 本身不加入进去
                        if (!c.equals(classes)) {
                            returnClassList.add(classes);
                        }
                    }
                }
            }
        }

        return returnClassList;
    }

    /*
     * 取得某一类所在包的所有类名 不含迭代
     */
    public static String[] getPackageAllClassName(String classLocation, String packageName) {
        // 将packageName分解
        String[] packagePathSplit = packageName.split("[.]");
        String realClassLocation = classLocation;
        int packageLength = packagePathSplit.length;
        for (int i = 0; i < packageLength; i++) {
            realClassLocation = realClassLocation + File.separator + packagePathSplit[i];
        }
        File packeageDir = new File(realClassLocation);
        if (packeageDir.isDirectory()) {
            String[] allClassName = packeageDir.list();
            return allClassName;
        }
        return null;
    }

    /**
     * 从包package中获取所有的Class
     *
     * @param packageName
     * @return
     */
    public static List<Class<?>> getClasses(String packageName) {

        // 第一个class类的集合
        List<Class<?>> classes = new ArrayList<Class<?>>();
        // 是否循环迭代
        boolean recursive = true;
        // 获取包的名字 并进行替换
        String packageDirName = packageName.replace('.', '/');
        // 定义一个枚举的集合 并进行循环来处理这个目录下的things
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            // 循环迭代下去
            while (dirs.hasMoreElements()) {
                // 获取下一个元素
                URL url = dirs.nextElement();
                // 得到协议的名称
                String protocol = url.getProtocol();
                // 如果是以文件的形式保存在服务器上
                if ("file".equals(protocol)) {
                    // 获取包的物理路径
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    // 以文件的方式扫描整个包下的文件 并添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                } else if ("jar".equals(protocol)) {
                    // 如果是jar包文件
                    // 定义一个JarFile
                    JarFile jar;
                    try {
                        // 获取jar
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        // 从此jar包 得到一个枚举类
                        Enumeration<JarEntry> entries = jar.entries();
                        // 同样的进行循环迭代
                        while (entries.hasMoreElements()) {
                            // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 如果是以/开头的
                            if (name.charAt(0) == '/') {
                                // 获取后面的字符串
                                name = name.substring(1);
                            }
                            // 如果前半部分和定义的包名相同
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                // 如果以"/"结尾 是一个包
                                if (idx != -1) {
                                    // 获取包名 把"/"替换成"."
                                    packageName = name.substring(0, idx).replace('/', '.');
                                }
                                // 如果可以迭代下去 并且是一个包
                                if ((idx != -1) || recursive) {
                                    // 如果是一个.class文件 而且不是目录
                                    if (name.endsWith(".class") && !entry.isDirectory()) {
                                        // 去掉后面的".class" 获取真正的类名
                                        String className = name.substring(packageName.length() + 1, name.length() - 6);
                                        try {
                                            // 添加到classes
                                            classes.add(Class.forName(packageName + '.' + className));
                                        } catch (ClassNotFoundException e) {
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return classes;
    }

    /**
     * 以文件的形式来获取包下的所有Class
     *
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
                                                        List<Class<?>> classes) {
        // 获取此包的目录 建立一个File
        File dir = new File(packagePath);
        // 如果不存在或者 也不是目录就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }
        // 如果存在 就获取包下的所有文件 包括目录
        File[] dirfiles = dir.listFiles(new FileFilter() {
            // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
            public boolean accept(File file) {
                return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
            }
        });
        // 循环所有文件
        for (File file : dirfiles) {
            // 如果是目录 则继续扫描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
                        classes);
            } else {
                // 如果是java类文件 去掉后面的.class 只留下类名
                String className = file.getName().substring(0, file.getName().length() - 6);
                try {
                    // 添加到集合中去
                    classes.add(Class.forName(packageName + '.' + className));
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

以上便是整个IOC以及依赖注入的基本实现原理，最后感谢观看！

江湖人称黑哥
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring——IOC底层原理
qq_50233116的博客
11-02 3931
IOC底层原理、IOC接口（BeanFanctory）、IOC操作Bean管理（基于XML）相关介绍
Spring：SpringIoC大致流程
最新发布
2401_83330354的博客
03-31 981
​ 父类AbstractApplicationContext的构造方法​ setConfigLocations()方法​ 接下来，我们进入核心方法refresh()。​ 我们重点看序号2和序号11，其他有兴趣可以自己点进去看看。​ obtainFreshBeanFactory()方法​​ 跟进refreshBeanFactory()方法，在AbstractRefreshableApplicationContext类中可以找到refreshBeanFactory()这个方法​ createBeanFactor
如何使用Spring.io快速开始一个项目
m0_53329013的博客
06-29 426
SpringBoot是在Spring框架上又封装了一层的框架，如果是一些简单的项目，我们可以直接使用，不需要了解太多深层的原理。，包含一系列的依赖，使得开发者仅对自己需要的部分进行完全的部署控制。Spring IO 是100%开源、可靠和模块化的。然后你就获得了一个项目压缩包，解压后导入编译器，配置好maven和数据库就可以开始写代码了。Spring IO是可集成的，构建现代化应用的版本平台。它是一个模块化的、企业级。说人话就是，直接给你打好主要依赖，生成项目框架，开包即用。2、选择想要的java版本。
依赖注入（DI）和控制反转（IoC）的理解
Joker_Lie的博客
02-04 897
本文转自：https://blog.csdn.net/bestone0213/article/details/47424255 ​ 学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及...
Spring IOC原理
约会远行的专栏
03-09 5089
Spring中的IoC的实现原理就是工厂模式加反射机制。 IOC机制 作用：将类的创建和依赖关系写在配置文件里，由配置文件注入，实现了松耦合。简而言之，将对象创建过程的职责赋予容器，通过容器管理对象的生老病死， 将对象创建过程从编译时延期到运行时，即通过配置进行加载，这样一来就解决了不用编译后期选择具体实现，其实就是面向对象的核心理念，针对接口编程。IOC是个factory加上依赖管理，系...
springIoc实现原理
04-20
spring ioc指的是控制反转，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。交由Spring容器统一进行管理，从而实现松耦合
Spring IOC实现原理demo
03-10
Spring容器的原理 其实就是通过解析xml文件 通过反射创建出我们所需要的bean 再将这些bean挨个放到集合中 然后对外提供一个getBean 方法 以便我们获得这bean
简单实现Spring的IOC原理详解
08-28
主要介绍了简单实现Spring的IOC原理详解，具有一定借鉴价值，需要的朋友可以参考下。
Spring框架系列(7) - Spring IOC实现原理详解之IOC初始化流程.doc
07-13
Spring 框架系列（7）- Spring IOC 实现原理详解之 IOC 初始化流程 本文将详细解释 Spring 框架中的 IOC（Inversion of Control，控制反转）实现原理之 IOC 初始化流程。IOC 是一种软件设计模式，用于将软件系统中...
Spring框架系列(8) - Spring IOC实现原理详解之Bean实例化(生命周期,循环依赖等).doc
07-09
Spring 框架系列（8）- Spring IOC 实现原理详解之 Bean 实例化（生命周期、循环依赖等） 本文主要研究 Spring 框架中 Bean 的实例化过程，包括 Bean 的生命周期和循环依赖问题的解决方案。在 Spring 框架中，Bean ...
start.spring.io.zip
07-07
偷懒的话直接下载。 也可以自行直接拉取源文件编译 git clone https://github.com/spring-io/start.spring.io cd start.spring.io mvnw clean package -Dmaven.test.skip=true target 文件下两个jar 用*-exec.jar 可以直接java -jar -Dserver.port=8080 start-site.jar 运行
SpringIOC原理实现
12-04
以excel导入为例子，看看springIoc是什么原理，如何自己写一个
Spring IOC和DI实现原理及实例解析
08-19
主要介绍了Spring IOC和DI实现原理及实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring IO 平台参考指南
专注
06-26 6095
Spirng IO Platform 1.1.2.RELEASE 参考文档
Spring 依赖注入(DI)、控制反转(IOC)
m0_64899073的博客
02-15 308
依赖注入 每个基于应用程序的 java 都有几个对象，由这些对象一起工作来呈现出终端用户所看到的工作的应用程序。当编写一个复杂的 Java 应用程序时，应用程序类应该尽可能独立于其他 Java 类来增加这些类重用的可能性，并且在做单元测试时，测试独立于其他类的独立性。依赖注入（或有时称为布线）有助于把这些类粘合在一起，同时保持他们独立。 注入方式 基于属性注入 基于 setter 方法注入 基于构造器注入 属性注入 通过属性注入的方式非常常用，这个应该是大家比较熟悉的一种方式： @Ser..
Spring IoC简述
weixin_63898309的博客
12-21 313
Spring IoC 简述
Spring之IOC实现原理
qq_41891244的博客
09-18 39
1. 首先委托BeanDefinitionDelegate类的parseBeanDefinitionElement方法进行元素解析，返回BeanDefinitionHolder类型的实例bdHolder，经过这个方法后，bdHolder实例已经包含我们配置文件中配置的各种属性了，例如class、name、id、alias之类的属性。2. 当返回的bdHolder不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行解析。，为此，要采用在系统属性里添加。这张方式是读取不到的，因为。
Spring零基础入门到精通 --- IOC基础容器
shuai_h的博客
03-25 1370
Spring零基础入门到精通
spring ioc实现原理
08-24
- *1* [springIoc实现原理](https://download.csdn.net/download/zhangcongyi420/11131211)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值