Fastjson详解

已于 2025-05-14 18:41:22 修改
阅读量961 收藏 29
点赞数 26
文章标签： json spring boot
于 2025-04-16 08:46:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yk_dflkg/article/details/147264533
版权

文章目录

1. Fastjson简介

Fastjson是阿里巴巴开发的一个Java库，用于将Java对象转换为JSON格式，也可以将JSON字符串转换为Java对象。Fastjson具有以下特点：

  • 高性能：比其他JSON库（如Gson、Jackson）更快
  • 简单易用：API设计简洁直观
  • 无需依赖其他库：零依赖
  • 支持泛型：完整支持Java泛型
  • 支持多种数据格式：支持普通JSON格式和二进制JSON格式

2. 在Spring Boot项目中引入Fastjson

2.1 Maven依赖

在pom.xml文件中添加以下依赖：

<!-- Fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.32</version> <!-- 建议使用最新稳定版本 -->
</dependency>

2.2 Gradle依赖

在build.gradle文件中添加以下依赖：

implementation 'com.alibaba:fastjson:2.0.32' // 建议使用最新稳定版本

2.3 在Spring Boot中配置Fastjson作为默认JSON转换器

创建一个配置类，用于将Fastjson设置为Spring Boot的默认JSON转换器：

package com.example.config;

import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

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

@Configuration
public class FastJsonConfig implements WebMvcConfigurer {
    
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        // 创建Fastjson消息转换器
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        
        // 创建Fastjson配置对象
        com.alibaba.fastjson.support.config.FastJsonConfig config = new com.alibaba.fastjson.support.config.FastJsonConfig();
        
        // 设置序列化特性
        config.setSerializerFeatures(
            // 输出null值字段
            SerializerFeature.WriteMapNullValue,
            // 将Date类型转换为ISO-8601格式的日期
            SerializerFeature.WriteDateUseDateFormat,
            // 禁用循环引用检测
            SerializerFeature.DisableCircularReferenceDetect
        );
        
        // 设置支持的媒体类型
        List<MediaType> supportedMediaTypes = new ArrayList<>();
        supportedMediaTypes.add(MediaType.APPLICATION_JSON);
        supportedMediaTypes.add(MediaType.APPLICATION_ATOM_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_FORM_URLENCODED);
        supportedMediaTypes.add(MediaType.APPLICATION_OCTET_STREAM);
        supportedMediaTypes.add(MediaType.APPLICATION_PDF);
        supportedMediaTypes.add(MediaType.APPLICATION_RSS_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_XHTML_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_XML);
        supportedMediaTypes.add(MediaType.IMAGE_GIF);
        supportedMediaTypes.add(MediaType.IMAGE_JPEG);
        supportedMediaTypes.add(MediaType.IMAGE_PNG);
        supportedMediaTypes.add(MediaType.TEXT_EVENT_STREAM);
        supportedMediaTypes.add(MediaType.TEXT_HTML);
        supportedMediaTypes.add(MediaType.TEXT_MARKDOWN);
        supportedMediaTypes.add(MediaType.TEXT_PLAIN);
        supportedMediaTypes.add(MediaType.TEXT_XML);
        converter.setSupportedMediaTypes(supportedMediaTypes);
        
        // 将配置应用于转换器
        converter.setFastJsonConfig(config);
        
        // 将转换器添加到转换器列表中
        converters.add(0, converter); // 将Fastjson转换器放在首位
    }
}

3. Fastjson基本用法

3.1 Java对象转JSON字符串（序列化）

import com.alibaba.fastjson.JSON;

// 创建一个简单的用户类
public class User {
    private Long id;
    private String name;
    private int age;
    
    // 构造函数、getter和setter方法略
    
    public User(Long id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    
    // getter和setter方法...
}

// 使用Fastjson将对象转换为JSON字符串
User user = new User(1L, "张三", 25);
String jsonString = JSON.toJSONString(user);
System.out.println(jsonString);
// 输出: {"age":25,"id":1,"name":"张三"}

3.2 JSON字符串转Java对象（反序列化）

// 定义JSON字符串
String jsonString = "{\"age\":30,\"id\":2,\"name\":\"李四\"}";

// 使用Fastjson将JSON字符串转换为Java对象
User user = JSON.parseObject(jsonString, User.class);
System.out.println(user.getId() + ", " + user.getName() + ", " + user.getAge());
// 输出: 2, 李四, 30

3.3 Java集合与JSON数组的转换

// List<User>转JSON字符串
List<User> userList = new ArrayList<>();
userList.add(new User(1L, "张三", 25));
userList.add(new User(2L, "李四", 30));
userList.add(new User(3L, "王五", 35));

String jsonArrayString = JSON.toJSONString(userList);
System.out.println(jsonArrayString);
// 输出: [{"age":25,"id":1,"name":"张三"},{"age":30,"id":2,"name":"李四"},{"age":35,"id":3,"name":"王五"}]

// JSON字符串转List<User>
List<User> parsedUserList = JSON.parseArray(jsonArrayString, User.class);
for (User u : parsedUserList) {
    System.out.println(u.getId() + ", " + u.getName() + ", " + u.getAge());
}

3.4 复杂对象的转换

// 定义部门类
public class Department {
    private Long id;
    private String name;
    private List<User> users;
    
    // 构造函数、getter和setter方法略
    
    public Department(Long id, String name, List<User> users) {
        this.id = id;
        this.name = name;
        this.users = users;
    }
    
    // getter和setter方法...
}

// 创建复杂对象
List<User> users = new ArrayList<>();
users.add(new User(1L, "张三", 25));
users.add(new User(2L, "李四", 30));

Department department = new Department(1L, "技术部", users);

// 序列化
String jsonString = JSON.toJSONString(department);
System.out.println(jsonString);
// 输出: {"id":1,"name":"技术部","users":[{"age":25,"id":1,"name":"张三"},{"age":30,"id":2,"name":"李四"}]}

// 反序列化
Department parsedDepartment = JSON.parseObject(jsonString, Department.class);
System.out.println(parsedDepartment.getName());
System.out.println(parsedDepartment.getUsers().size());

4. 高级特性

4.1 SerializeFilter的使用

Fastjson提供了多种过滤器，用于在序列化过程中自定义字段的处理方式。

4.1.1 PropertyPreFilter（属性预过滤器）

用于在序列化前过滤属性：

import com.alibaba.fastjson.serializer.SimplePropertyPreFilter;

// 创建一个只包含id和name字段的过滤器
SimplePropertyPreFilter filter = new SimplePropertyPreFilter(User.class, "id", "name");
User user = new User(1L, "张三", 25);

String jsonString = JSON.toJSONString(user, filter);
System.out.println(jsonString);
// 输出: {"id":1,"name":"张三"}  (age字段被过滤掉)
4.1.2 PropertyFilter（属性过滤器）

根据属性名和属性值进行过滤：

import com.alibaba.fastjson.serializer.PropertyFilter;

PropertyFilter ageFilter = (object, name, value) -> {
    // 过滤掉age小于30的用户
    if (name.equals("age") && value instanceof Integer && (Integer) value < 30) {
        return false;
    }
    return true;
};

List<User> users = new ArrayList<>();
users.add(new User(1L, "张三", 25));
users.add(new User(2L, "李四", 30));
users.add(new User(3L, "王五", 35));

String jsonString = JSON.toJSONString(users, ageFilter);
System.out.println(jsonString);
// 只有年龄>=30的用户会被完整序列化
4.1.3 NameFilter（名称过滤器）

修改属性名称：

import com.alibaba.fastjson.serializer.NameFilter;

NameFilter nameFilter = (object, name, value) -> {
    // 将属性名转换为大写
    return name.toUpperCase();
};

User user = new User(1L, "张三", 25);
String jsonString = JSON.toJSONString(user, nameFilter);
System.out.println(jsonString);
// 输出: {"AGE":25,"ID":1,"NAME":"张三"}
4.1.4 ValueFilter（值过滤器）

修改属性值：

import com.alibaba.fastjson.serializer.ValueFilter;

ValueFilter valueFilter = (object, name, value) -> {
    if (name.equals("name")) {
        return "***"; // 隐藏用户名
    }
    return value;
};

User user = new User(1L, "张三", 25);
String jsonString = JSON.toJSONString(user, valueFilter);
System.out.println(jsonString);
// 输出: {"age":25,"id":1,"name":"***"}

4.2 注解的使用

Fastjson提供了多种注解，用于控制对象序列化和反序列化的行为。

4.2.1 @JSONField注解

控制字段的序列化和反序列化行为：

import com.alibaba.fastjson.annotation.JSONField;

public class User {
    @JSONField(name = "user_id") // 修改JSON中的字段名
    private Long id;
    
    @JSONField(serialize = false) // 不序列化该字段
    private String password;
    
    @JSONField(format = "yyyy-MM-dd") // 日期格式化
    private Date birthday;
    
    @JSONField(ordinal = 1) // 控制序列化的顺序
    private String name;
    
    @JSONField(ordinal = 2)
    private int age;
    
    // 构造函数、getter和setter方法略
}

// 使用
User user = new User();
user.setId(1L);
user.setName("张三");
user.setAge(25);
user.setPassword("123456"); // 该字段不会被序列化
user.setBirthday(new Date());

String jsonString = JSON.toJSONString(user);
System.out.println(jsonString);
// 输出: {"name":"张三","age":25,"birthday":"2023-06-15","user_id":1}
4.2.2 @JSONType注解

控制类的序列化和反序列化行为：

import com.alibaba.fastjson.annotation.JSONType;

@JSONType(includes = {"id", "name"}, orders = {"name", "id"})
public class User {
    private Long id;
    private String name;
    private int age; // 将被忽略
    
    // 构造函数、getter和setter方法略
}

// 使用
User user = new User(1L, "张三", 25);
String jsonString = JSON.toJSONString(user);
System.out.println(jsonString);
// 输出: {"name":"张三","id":1}  (age字段被忽略)

4.3 SerializerFeature的使用

Fastjson提供了多种序列化特性，用于控制序列化过程：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

User user = new User(1L, "张三", 25);
user.setBirthday(null); // 空日期字段

// 使用多种序列化特性
String jsonString = JSON.toJSONString(user, 
    SerializerFeature.WriteMapNullValue, // 输出值为null的字段
    SerializerFeature.WriteNullStringAsEmpty, // 将null字符串输出为空字符串
    SerializerFeature.PrettyFormat // 格式化JSON输出
);
System.out.println(jsonString);

常用的SerializerFeature包括：

  • WriteMapNullValue：输出值为null的字段
  • WriteNullStringAsEmpty：将null字符串输出为空字符串""
  • WriteNullNumberAsZero：将null数字输出为0
  • WriteNullListAsEmpty：将null列表输出为[]
  • WriteNullBooleanAsFalse：将null布尔值输出为false
  • PrettyFormat：格式化JSON输出，便于阅读
  • WriteClassName：序列化时写入类名
  • DisableCircularReferenceDetect：禁用循环引用检测
  • WriteDateUseDateFormat：日期格式化输出

5. 在Spring Boot中使用Fastjson的实例

5.1 创建一个RESTful API

package com.example.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.example.model.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    // 获取所有用户
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }

    // 获取单个用户
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id);
    }

    // 创建用户
    @PostMapping
    public User createUser(@RequestBody String jsonString) {
        // 使用Fastjson解析请求体
        User user = JSON.parseObject(jsonString, User.class);
        return userService.save(user);
    }

    // 更新用户
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody String jsonString) {
        // 使用Fastjson解析请求体
        JSONObject jsonObject = JSON.parseObject(jsonString);
        
        User user = userService.findById(id);
        
        // 更新用户信息
        if (jsonObject.containsKey("name")) {
            user.setName(jsonObject.getString("name"));
        }
        
        if (jsonObject.containsKey("age")) {
            user.setAge(jsonObject.getIntValue("age"));
        }
        
        return userService.save(user);
    }

    // 删除用户
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteById(id);
    }
}

5.2 处理复杂JSON

@PostMapping("/complex")
public String handleComplexJson(@RequestBody String jsonString) {
    // 将JSON字符串解析为JSONObject
    JSONObject jsonObject = JSON.parseObject(jsonString);
    
    // 访问顶层属性
    String name = jsonObject.getString("name");
    
    // 访问嵌套对象
    JSONObject address = jsonObject.getJSONObject("address");
    String city = address.getString("city");
    
    // 访问数组
    JSONArray skills = jsonObject.getJSONArray("skills");
    for (int i = 0; i < skills.size(); i++) {
        String skill = skills.getString(i);
        // 处理每个技能...
    }
    
    // 构造响应
    JSONObject response = new JSONObject();
    response.put("status", "success");
    response.put("message", "处理了 " + name + " 来自 " + city + " 的复杂JSON数据");
    
    return response.toJSONString();
}

5.3 处理动态JSON

@PostMapping("/dynamic")
public String handleDynamicJson(@RequestBody String jsonString) {
    // 将JSON字符串解析为JSONObject
    JSONObject jsonObject = JSON.parseObject(jsonString);
    
    // 获取所有键
    Set<String> keys = jsonObject.keySet();
    
    JSONObject response = new JSONObject();
    for (String key : keys) {
        Object value = jsonObject.get(key);
        
        // 根据值的类型进行不同的处理
        if (value instanceof String) {
            response.put(key + "_processed", "字符串: " + value);
        } else if (value instanceof Integer) {
            response.put(key + "_processed", "整数: " + ((Integer) value * 2));
        } else if (value instanceof JSONObject) {
            response.put(key + "_processed", "对象包含 " + ((JSONObject) value).size() + " 个属性");
        } else if (value instanceof JSONArray) {
            response.put(key + "_processed", "数组包含 " + ((JSONArray) value).size() + " 个元素");
        }
    }
    
    return response.toJSONString();
}

6. Fastjson的性能优化

6.1 使用ASM进行优化

Fastjson默认使用ASM（一种字节码操作和分析框架）来生成序列化和反序列化代码，这比反射更快。但需要确保在类路径中包含ASM依赖：

<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm</artifactId>
    <version>9.1</version>
</dependency>

6.2 启用/禁用特性以提高性能

某些SerializerFeature会影响性能，具体取决于您的使用场景：

// 禁用循环引用检测以提高性能
String jsonString = JSON.toJSONString(complexObject, SerializerFeature.DisableCircularReferenceDetect);

// 禁用快速匹配模式，可能在某些情况下提高性能
JSON.DEFAULT_PARSER_FEATURE &= ~Feature.SupportAutoType.getMask();

6.3 使用缓存

对于频繁使用的对象，可以使用SerializeConfig缓存：

// 创建全局SerializeConfig实例
SerializeConfig serializeConfig = new SerializeConfig();

// 自定义序列化器
serializeConfig.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd"));

// 在多次序列化中复用该配置
String json1 = JSON.toJSONString(obj1, serializeConfig);
String json2 = JSON.toJSONString(obj2, serializeConfig);

7. 安全最佳实践

7.1 避免使用autotype功能

Fastjson的autotype功能允许在JSON中包含类型信息，但这可能导致远程代码执行漏洞。建议禁用此功能：

// 全局禁用autotype
ParserConfig.getGlobalInstance().setSafeMode(true);

7.2 使用最新版本

Fastjson历史上有多个安全漏洞，请确保使用最新稳定版本。

7.3 白名单机制

如果必须使用autotype功能，请使用白名单：

ParserConfig.getGlobalInstance().addAccept("com.your.package.name.");

8. 常见问题及解决方案

8.1 循环引用问题

当对象之间存在循环引用时，Fastjson默认会检测并处理，但这会影响性能：

// 禁用循环引用检测
String jsonString = JSON.toJSONString(obj, SerializerFeature.DisableCircularReferenceDetect);

// 或者重构对象模型以避免循环引用

8.2 大数处理

处理BigDecimal和BigInteger时的精度问题：

// 启用BigDecimal的原生类型处理
String jsonString = JSON.toJSONString(obj, SerializerFeature.WriteBigDecimalAsPlain);

8.3 日期格式化

自定义日期格式：

// 全局设置
JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd";

// 或者使用注解
@JSONField(format = "yyyy-MM-dd HH:mm:ss")
private Date createTime;

// 或者在序列化时指定
String jsonString = JSON.toJSONString(obj, SerializerFeature.WriteDateUseDateFormat);

8.4 处理未知属性

当JSON中包含Java对象没有的属性时：

// 创建反序列化特性
Feature[] features = {Feature.IgnoreNotMatch};

// 使用特性进行反序列化
User user = JSON.parseObject(jsonString, User.class, features);

9. 与其他JSON库的比较

9.1 Fastjson vs Jackson

  • Fastjson通常性能更高，但Jackson生态系统更丰富
  • Jackson在Spring Boot中是默认的JSON处理库
  • Fastjson API更简单，而Jackson更灵活

9.2 Fastjson vs Gson

  • Fastjson通常性能更高
  • Gson设计更优雅，更符合Java习惯
  • Fastjson功能更丰富，但Gson更稳定

9.3 性能比较

在大多数性能测试中，Fastjson的序列化和反序列化速度通常优于Jackson和Gson，特别是对于大型对象。

10. 总结与最佳实践

10.1 总结

Fastjson是一个高性能、功能丰富的JSON处理库，特别适合对性能有较高要求的应用。它提供了简单易用的API，丰富的注解和过滤器，以及多种性能优化选项。

10.2 最佳实践

  • 始终使用最新稳定版本
  • 对于安全敏感的应用，禁用autotype功能
  • 利用注解和过滤器自定义序列化行为
  • 考虑使用SerializeConfig和ParseConfig缓存提高性能
  • 根据具体需求选择合适的SerializerFeature
  • 为复杂对象创建专用的序列化和反序列化器
  • 在性能关键的应用中，使用DisableCircularReferenceDetect特性
  • 充分测试各种边缘情况，如null值、空集合、特殊字符等
Json学习总结（5）——阿里巴巴开源库 Fastjson详解
科技D人生
07-08 3720
一、前言 JSON，全称：JavaScript Object Notation，作为一个常见的轻量级的数据交换格式，应该在一个程序员的开发生涯中是常接触的。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。Java是面向对象的语言，所以我们更多的在项目中是以对象的形式处理业务的，但是在传输的时候我们却要将对象转换为 ...
fastJSON文档
08-07
fastjson类库相关文档（fastjson文档）
Fastjson介绍
wutongyu344的专栏
03-05 3万+
简介 Fastjson是一个Java语言编写的高性能功能完善的JSON库。 高性能 fastjson采用独创的算法，将parse的速度提升到极致，超过所有json库，包括曾经号称最快的jackson。并且还超越了google的二进制协议protocol buf。 支持标准 Fastjson完全支持http://json.org的标准，也是官方网站收录的参考实现之一
fastjson
huangmingcsdn的博客
05-14 133
//依赖 implementation 'com.alibaba:fastjson:1.2.68' //解析单个json数据 String text = "{\"date\":\"2020-05-14 14:35:02\",\"name\":\"123\"}"; Bean bean= JSON.parseObject(text,Bean.class); //解析多个json数据 String text = "[{...},{...},...]"; String text0 = JSON.parseAr
fastJson
weixin_43400432的博客
08-04 520
Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。导入依赖fastjsonx.x.x输出结果为：[{“AGE”:15,},{“AGE”:20,}]还可以自定义输出，并控制字段的排序，日期显示格式，序列化标记等。以上代码列出了基本参数类别，并使用了@JSONField注解，以便实现自定义转换。format 参数用于格式化date属性。...
Fastjson
qq_35091353的博客
08-15 686
1、简介 1.1 Fastjson 简介 Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。 Fastjson 可以操作任何 Java 对象，即使是一些预先存在的没有源码的对象。 Fastjson 源码地址：https://github.com/alibaba/fastjson Fastjson 中文 Wiki：https://github.com/alibaba/fastjson/wiki/Quick-Start
一文搞定—FastJson详解 与 使用
最新发布
边走、边悟、迟早变好
08-23 1万+
提供服务器端、安卓客户端两种解析工具，性能表现较好。提供了 toJSONString() 和 parseObject() 方法来将 Java 对象与 JSON 相互转换。调用toJSONString方 法即可将对象转换成 JSON 字符串，parseObject 方法则反过来将 JSON 字符串转换成对象。允许转换预先存在的无法修改的对象（只有class、无源代码）。Java泛型的广泛支持。允许对象的自定义表示、允许自定义序列化类。
fastjson详解
m0_67392409的博客
08-01 3028
在前后端数据传输交互中,经常会遇到字符串(String)与json,XML等格式相互转换与解析，其中json以跨语言，跨前后端的优点在开发中被频繁使用，基本上可以说是标准的数据交换格式。fastjson是一个java语言编写的高性能且功能完善的JSON库，它采用一种“假定有序快速匹配”的算法，把JSONParse的性能提升到了极致。它的接口简单易用，已经被广泛使用在缓存序列化，协议交互，Web输出等各种应用场景中。FastJson是啊里巴巴的的开源库，用于对JSON格式的数据进行解析和打包。...
FastJson详解
qq_41359998的博客
04-11 2604
FastJson详解 fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。 fastjson 的 pom依赖！ <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</a
FastJson
放下键盘
08-28 762
笔记
FastJson--阿里巴巴公司开源的速度最快的Json和对象转换工具
On my way
07-07 661
这是关于FastJson的一个使用Demo，在Java环境下验证的 class User{ private int id; private String name; public int getId() { return id; } public void setId(int id) { this.id = id;
FastJSON
jlcheerful的博客
01-06 334
笔记
Json详解以及fastjson使用教程
热门推荐
srj1095530512的博客
09-08 22万+
Json是一种轻量级的数据交换格式，采用一种“键：值”对的文本格式来存储和表示数据，在系统交换数据过程中常常被使用，是一种理想的数据交换语言。在使用Java做Web开发时，不可避免的会遇到Json的使用。下面我们就简单讲一下Json的使用以及fastjson.jar包的使用。 一：JSON形式与语法 1.1：JSON对象 我们先来看以下数据： { "ID": 1001, "name"...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

全栈凯哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值