手写SpringBoot开发框架

最新推荐文章于 2024-05-30 11:48:38 发布
最新推荐文章于 2024-05-30 11:48:38 发布
阅读量995 收藏 27
点赞数 24
分类专栏： 手写框架篇 文章标签： spring boot java tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74199893/article/details/138295378
版权

运行环境

JDK ：17
IntelliJ IDEA ： 2022.3
Tomcat：9.0.60（内嵌）

手写目标

  1. 手写模拟SpringBoot启动过程
  2. 手写模拟SpringBoot条件注解功能
  3. 手写模拟SpringBoot自动配置功能

项目结构

项目类继承关系

在这里插入图片描述

springboot模块：

在这里插入图片描述
com.juechen.springboot：表示springboot框架的源码实现。
META-INF.services：SPI机制。

user模块：

在这里插入图片描述
com.juechen.user.controller：Controller层业务逻辑代码
com.juechen.user.service：Service层业务逻辑代码

项目流程

整体SpringBoot启动逻辑是这样的：

  1. 创建一个AnnotationConfigWebApplicationContext容器
  2. 解析MyApplication类，然后进行扫描
  3. 通过getWebServer方法从Spring容器中获取WebServer类型的Bean
  4. 调用WebServer对象的start方法
  5. 实现SPI机制

pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Handwriting-SpringBoot</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>springboot</module>
        <module>user</module>
    </modules>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

springboot的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>Handwriting-SpringBoot</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>springboot</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.18</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-core</artifactId>
            <version>9.0.60</version>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

user的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>Handwriting-SpringBoot</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>user</artifactId>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springboot</artifactId>
            <version>1.0-SNAPSHOT</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.tomcat.embed</groupId>
                    <artifactId>tomcat-embed-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-server</artifactId>
            <version>9.4.43.v20210629</version>
        </dependency>
    </dependencies>

</project>

springboot模块

com.juechen.springboot包：

JuechenSpringApplication类：实现启动逻辑

package com.juechen.springboot;

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;


import java.util.Map;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: 实现启动逻辑
 * @Version: 1.0
 **/
public class JuechenSpringApplication {

    //在run方法中，我们要实现的逻辑如下：
    //1. 创建一个Spring容器
    //2. 创建Tomcat对象
    //3. 生成DispatcherServlet对象，并且和前面创建出来的Spring容器进行绑定
    //4. 将DispatcherServlet添加到Tomcat中
    //5. 启动Tomcat
    public static void run(Class clazz) {

        // 创建一个Spring容器
        // Spring容器创建完之后，容器内部就拥有了UserController这个Bean
        AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
        applicationContext.register(clazz);
        applicationContext.refresh();

        WebServer webServer = getWebServer(applicationContext);
        webServer.start();
    }

    private static WebServer getWebServer(WebApplicationContext applicationContext) {

        // 判断到底该返回TomcatWebServer还是JettyWebServer
        Map<String, WebServer> beansOfType = applicationContext.getBeansOfType(WebServer.class);
        if (beansOfType.isEmpty()) {
            throw new NullPointerException();
        }

        if (beansOfType.size() > 1) {
            throw new IllegalStateException();
        }

        // 返回唯一的一个
        return beansOfType.values().stream().findFirst().get();
    }

}

我们创建的是一个AnnotationConfigWebApplicationContext容器，并且把run方法传入进来的class作为容器的配置类，比如在MyApplication的run方法中，我们就是把MyApplication.class传入到了run方法中，最终MyApplication就是所创建出来的Spring容器的配置类，并且由于MyApplication类上有@JuechenSpringBootApplication注解，而@JuechenSpringBootApplication注解的定义上又存在@ComponentScan注解，所以AnnotationConfigWebApplicationContext容器在执行refresh时，就会解析MyApplication这个配置类，从而发现定义了@ComponentScan注解，也就知道了要进行扫描，只不过扫描路径为空，而AnnotationConfigWebApplicationContext容器会处理这种情况，如果扫描路径会空，则会将MyApplication所在的包路径做为扫描路径，从而就会扫描到UserService和UserController(user模块)。

JuechenSpringBootApplication注解：自定义@XxxSpringBootApplication，这个注解是加在应用启动类上的，也就是main方法所在的类

package com.juechen.springboot;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Configuration
@ComponentScan  // 扫描路径为：com.juechen.user 不是com.juechen.springboot
@Import(AutoConfigurationImportSelector.class)
public @interface JuechenSpringBootApplication {
}

WebServer接口：实现Tomcat和Jetty切换的接口

package com.juechen.springboot;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: TODO
 * @Version: 1.0
 **/
public interface WebServer {

    public void start();

}

TomcatWebServer类：用的是Embed-Tomcat，也就是内嵌的Tomcat，真正的SpringBoot中也用的是内嵌的Tomcat

package com.juechen.springboot;

import org.apache.catalina.*;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.core.StandardEngine;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.startup.Tomcat;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: Tomcat
 * @Version: 1.0
 **/
public class TomcatWebServer implements WebServer{
    @Override
    public void start() {
        System.out.println("启动Tomcat~~~");
    }

    public static void startTomcat(WebApplicationContext applicationContext){

        Tomcat tomcat = new Tomcat();

        Server server = tomcat.getServer();
        Service service = server.findService("Tomcat");

        Connector connector = new Connector();
        
        // 配置了Tomcat绑定的端口为8081
        connector.setPort(8081);

        Engine engine = new StandardEngine();
        engine.setDefaultHost("localhost");

        Host host = new StandardHost();
        host.setName("localhost");

        String contextPath = "";
        Context context = new StandardContext();
        context.setPath(contextPath);
        context.addLifecycleListener(new Tomcat.FixContextListener());

        host.addChild(context);
        engine.addChild(host);

        service.setContainer(engine);
        service.addConnector(connector);

		// 在构造DispatcherServlet对象时，
		// 传入了一个ApplicationContext对象，也就是一个Spring容器
        tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet(applicationContext));
        context.addServletMappingDecoded("/*", "dispatcher");

        try {
            tomcat.start();
        } catch (LifecycleException e) {
            e.printStackTrace();
        }

    }
}

JettyWebServer类：

package com.juechen.springboot;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: Jetty
 * @Version: 1.0
 **/
public class JettyWebServer implements WebServer{
    @Override
    public void start() {
        System.out.println("启动Jetty~~~");
    }
}

JuechenConditionalOnClass注解：模拟实现条件注解

package com.juechen.springboot;

import org.springframework.context.annotation.Conditional;

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

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Conditional(JuechenCondition.class)
public @interface JuechenConditionalOnClass {

    String value();
}

JuechenCondition类：条件注解的实现类

package com.juechen.springboot;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Map;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: 条件注解的实现类
 * @Version: 1.0
 **/
public class JuechenCondition implements Condition {

    /**
     * 具体逻辑为，拿到@JuechenConditionalOnClass中的value属性，
     * 然后用类加载器进行加载，如果加载到了所指定的这个类，那就表示符合条件，
     * 如果加载不到，则表示不符合条件。
     * @param context
     * @param metadata
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {

        // 从注解元数据中获取JuechenConditionalOnClass注解的属性值
        Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(JuechenConditionalOnClass.class.getName());
        // 获取注解中指定的类名
        String className = (String) annotationAttributes.get("value");
        try {
            // 尝试加载指定的类，如果成功则表明类路径上存在该类
            context.getClassLoader().loadClass(className);
            return true;
        } catch (ClassNotFoundException e) {
            // 如果类加载失败，则返回false
            return false;
        }
    }
}

有了条件注解，我们就可以来使用它了。

WebServiceAutoConfiguration类：自动配置类

package com.juechen.springboot;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: 自动配置类
 * @Version: 1.0
 **/
@Configuration
public class WebServiceAutoConfiguration implements AutoConfiguration{

    @Bean
    @JuechenConditionalOnClass("org.apache.catalina.startup.Tomcat")
    public TomcatWebServer tomcatWebServer(){
        return new TomcatWebServer();
    }

    @Bean
    @JuechenConditionalOnClass("org.eclipse.jetty.server.Server")
    public JettyWebServer jettyWebServer(){
        return new JettyWebServer();
    }
}
  • 这样，我们就只需要在getWebServer方法中去判断到底该返回TomcatWebServer还是JettyWebServer。(JuechenSpringBootApplication中的getWebServer方法)

AutoConfigurationImportSelector类：批量导入

package com.juechen.springboot;

import org.springframework.context.annotation.DeferredImportSelector;
import org.springframework.core.type.AnnotationMetadata;

import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: 批量导入
 * @Version: 1.0
 **/
public class AutoConfigurationImportSelector implements DeferredImportSelector {

    /**
     * 从服务加载器中选择并导入所有自动配置类的名称。
     *
     * @param importingClassMetadata 引入类的元数据，此处未使用但必须存在以符合接口要求。
     * @return String[] 包含所有自动配置类名称的数组。
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 加载所有AutoConfiguration类型的实现
        ServiceLoader<AutoConfiguration> serviceLoader = ServiceLoader.load(AutoConfiguration.class);

        List<String> list = new ArrayList<>();
        // 遍历加载到的自动配置类，将它们的类名添加到列表中
        for (AutoConfiguration autoConfiguration : serviceLoader) {
            list.add(autoConfiguration.getClass().getName());
        }

        // 将类名列表转换为字符串数组并返回
        return list.toArray(new String[0]);
    }

}

AutoConfiguration类

package com.juechen.springboot;

public interface AutoConfiguration {
}

META-INF

spring.factories文件：

com.juechen.springboot.WebServiceAutoConfiguration

user模块

com.juechen.user包：

MyApplication类：SpringBoot启动类

package com.juechen.user;

import com.juechen.springboot.JuechenSpringApplication;
import com.juechen.springboot.JuechenSpringBootApplication;
import com.juechen.springboot.WebServiceAutoConfiguration;
import org.springframework.context.annotation.Import;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: 启动类
 * @Version: 1.0
 **/
@JuechenSpringBootApplication
@Import(WebServiceAutoConfiguration.class)
public class MyApplication {

    public static void main(String[] args) {
        JuechenSpringApplication.run(MyApplication.class);
    }
}

com.juechen.user.controller包：

UserController类：

package com.juechen.user.controller;

import com.juechen.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: TODO
 * @Version: 1.0
 **/
@RestController
public class UserController {

    @Autowired
    private UserService userService;


    @GetMapping("test")
    public String test(){
        return userService.test();
    }
}

com.juechen.user.service包：

UserService类：

package com.juechen.user.service;

import org.springframework.stereotype.Component;

/**
 * @Author: Juechen
 * @Date: 2024/4/28
 * @Description: TODO
 * @Version: 1.0
 **/
@Component
public class UserService {

    public String test(){
        return "juechen";
    }
}

总结

到此，我们实现了一个简单版本的SpringBoot，因为SpringBoot首先是基于Spring的，而且提供的功能也更加强大，希望大家都自己去动手实现一遍，加油！！！

玦尘、
关注
  • 24
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 核心流程
qq_55624813的博客
09-14 971
通过手写模拟实现一个Spring Boot，让大家能以非常简单的方式就能知道Spring Boot大概是如何工作的。然后定义相关的Controller和Service:因为我们模拟实现的是SpringBoot，而不是SpringMVC，所以我直接在user包下定义了UserController和UserService，最终我希望能运行MyApplication中的main方法，就直接启动了项目，并能在浏览器中正常的访问到UserController中的某个方法。
纯手写SpringBoot框架
魔法革1996
11-21 375
1. 性能优化 1.1 组件自动扫描带来的问题 默认情况下，我们会使用 @SpringBootApplication 注解来自动获取应用的配置信息，但这样也会给应用带来一些副作用。使用这个注解后，会触发自动配置（ auto-configuration ）和 组件扫描 （ component scanning ），这跟使用 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 三个注解的作用是一样的。这样做给开发带来方便的同时，也会有三方面的影响
手写SpringBoot框架
longzhutengyue的博客
03-12 474
通过手写模拟一个简单Spring Boot框架，来熟悉Spring Boot大概是如何工作的。分为以下4个方面1、手写模拟SpringBoot启动过程2、手写模拟SpringBoot条件注解功能3、手写模拟SpringBoot自动配置功能4、SpringBoot整合Tomcat底层源码分析废话不多说，直接上代码。
纯手写springboot2.0框架及分析
qq_36594703的博客
08-01 1935
1.springboot是一个快速整合第三方常用开发框架，简化XML，完全采用注解化，内置HTTP服务器，最终以java程序运行。 2.重点三部分：快速整合第三方框架、完全无配置文件（注解方式）、内置http服务器。 （1）快速整合第三方框架，原理maven子父依赖关系，相当于需要整合的环境的jar封装好依赖信息 （2）完全无配置文件（采用注解化） 如何初始化？没有web.xml那么tom...
尝试手写一个框架（六）手写一套SpringBoot框架，加深对SpringBoot框架得理解
歪桃的博客
08-19 8980
利用maven集成、内置tomcat、以及Spring相关的功能，自己构建了一个集成框架，从而加深SpringBoot的工作原理
01.手写SpringBoot源码
qq_36831305的博客
06-15 135
手写SpringBoot
学习SpringBoot源码之手写一个简易版SpringBoot
xjx666666的博客
12-06 1718
很多人和我一样可能都想知道我们开发用的SpringB底层原理是什么，怎么运行的，但奈何自己能力不足读不懂源码，下面我们通过手写一个SpringBoot来了解一下SpringBoot大概原理是什么，怎么运行的。（此文是学习图灵周瑜老师手写SpringBoot的学习笔记）。PS： 下文中Xjx为本人名字缩写，读者可以自行更改为自己的名字缩写，这样整个写完还是挺有成就感的，建议改为自己名字缩写哦首先我们创建出一个项目，然后再这个项目下面创建两个模块：首先，SpringBoot是基于的Spring，所以我们手写Sp
自定义手写SpringBoot框架（带使用案例）
冰生于水的博客
10-19 2095
过了个年，现在才想起来写博客，废话不多说，先谈一下开发环境与实现概况： 开发环境： 使用JDK11，IDEA2018，Mysql8.0，gradle5.0； 实现概况： 提供了Spring、SpringMVC、Mybatis、Log4j（半成品）可供选择的组件，均是自定义的，详情可以参见我的上一篇博客《自定义手写SSM框架2.0（带小案例）》； 内嵌了tomcat8.5容器，web...
Java手写dubbo框架
热门推荐
congge
09-24 1万+
Java模拟实现dubbo框架
SpringBoot整合Swagger
09-27
API文档变成了前后端开发人员联系的纽带，变得越来越重要，swagger就是一款让你更好的书写API文档的框架，而且swagger可以完全模拟http请求，入参出参和实际情况差别几乎为零。 　没有API文档工具之前，大家都是...
Springboot+MyBatis企业级RESTful API开发项目实战/java视频教程
06-18
就是想学习SpringBoot开发 能学到什么 从0开发一个类似企业级项目 学会能做出市面上90%通用API 快速增加1到2年实际开发经验 刚毕业学完后能找到满意的工作 已经工作学完后最高涨薪30% 课程信息 全课程目前是82章，...
基于 SpringBoot 的 SSM前后端分离的家政服务管理系统+源代码+文档说明
11-28
- 无需手写SQL，使用Mybatis-generator作为持久层orm框架。 - 使用travis完成自动构建、测试、推送镜像实现高度自动化。 - 开箱即用，没有复杂的业务，是学习拓展的不二之选。 ## 目的 > 随着互联网行业的发展，...
JAVA体系实战项目-SpringBoot+Thymeleaf+Mybatis+Maven+Oracle综合性电商项目
03-18
采用SpringBoot+Thymeleaf+Mybatis+Maven+Oracle构建环境，开发工具使用SpringToolSuite(STS内置Tomcat服务器)。涉及的主要技术包括:springBoot框架与Thymeleaf模板引擎前后台交互，部分功能使用js/jquery/ajax实现...
模仿知乎做的SpringBoot问答社交网站项目，爬虫进行数据填充.zip
01-11
模仿知乎做的SpringBoot问答社交网站项目，项目技术点SpringBoot+Mybatis+Mysql+redis+solr+velocity+python爬虫进行数据填充，项目亮点有手写异步消息框架、敏感词过滤等 软件开发设计：应用软件开发、系统软件开发...
Spring Boot发送HTML邮件时如何设置模板？
最新发布
qianke369的博客
05-30 647
Spring Boot发送HTML邮件是一种简单而有效的方式，可以让邮件内容更具吸引力和可读性。AokSend，API/SMTP接口融合Spring Boot，HTML邮件绚丽呈现，让您的营销信息更生动、更吸引人！
Spring Boot中如何查询PGSQL分表后的数据
番茄Salad
05-28 507
数据库用的pgsql，在表数据超过100w条的时候执行定时任务进行了分表，分表后表名命名为原的表名后面拼接时间，如原表名是card_device_trajectory_info，分表后拼接时间后得到card_device_trajectory_info_20240503，然后分表后把原来的表重置为空。这样就把100w条数据放到了card_device_trajectory_info_20240503里面，card_device_trajectory_info重置空，以此类推。
Java高级---Spring Boot---1引言
B6665X的博客
05-28 639
​ Spring Boot是一个开源的Java框架，由Pivotal团队（现在是VMware的一部分）开发，它是Spring框架的一个模块，旨在。IMPORTANT]Spring Boot的核心目标是让开发者尽可能快速地运行和开发新的Spring项目。自动配置内嵌的HTTP服务器基于Java的配置可执行的JAR​Spring Boot通过提供简化的配置和快速启动的特性，帮助开发者专注于业务逻辑的实现，而不是花费大量时间在环境搭建和配置上，从而提高开发效率和应用程序的质量。
<手写springboot>课程目标
05-25
《手写SpringBoot》课程的目标是让学生深入理解SpringBoot框架的实现原理和核心功能，掌握使用SpringBoot开发Web应用的方法和技巧。通过本课程的学习，学生将能够熟练掌握SpringBoot框架的核心原理和设计思想，掌握SpringBoot应用的开发流程和调试技巧，了解SpringBoot的常用组件和技术栈，以及掌握如何使用SpringBoot构建高可用、高性能的Web应用。同时，本课程还将重点讲解SpringBoot在企业级应用开发中的应用场景和实践经验，帮助学生更好地应对真实项目中的开发需求和挑战。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值