深入理解Spring Boot中的Fastjson

  • 开发
  • 16

目录

  1. Fastjson简介
  2. Spring Boot中集成Fastjson
  3. Fastjson的基本用法
  4. Fastjson的进阶用法
  5. 实际应用场景
  6. 安全性注意事项
  7. 总结

Fastjson简介

Fastjson是由阿里巴巴开发的一个高性能JSON库，其设计目标是高效地解析、生成和操作JSON数据。Fastjson具有以下优点：

  • 速度快：与其他JSON库相比，Fastjson的解析和序列化速度更快。
  • 易用性高：提供了简洁明了的API，方便开发者使用。
  • 功能强大：支持丰富的JSON操作功能，包括JSON对象的嵌套、复杂类型的解析等。

Spring Boot中集成Fastjson

添加依赖

在Spring Boot项目中集成Fastjson，首先需要在pom.xml文件中添加Fastjson的依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>

配置Fastjson

接下来，需要配置Spring Boot使用Fastjson作为默认的JSON解析器。可以通过以下几步实现：

  1. 创建一个配置类，配置Fastjson的序列化特性：
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.converter.HttpMessageConverter;

import java.util.List;

@Configuration
public class FastjsonConfig {

    @Bean
    public HttpMessageConverters fastJsonHttpMessageConverters() {
        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(
                SerializerFeature.PrettyFormat,
                SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteDateUseDateFormat
        );
        fastConverter.setFastJsonConfig(fastJsonConfig);
        HttpMessageConverter<?> converter = fastConverter;
        return new HttpMessageConverters(converter);
    }
}
  1. 在application.properties或application.yml中配置Spring Boot使用Fastjson：
spring.mvc.converters.preferred-json-mapper=fastjson

Fastjson的基本用法

对象与JSON字符串的相互转换

Fastjson提供了非常简便的方法来进行Java对象与JSON字符串之间的相互转换。以下是一些基本用法示例：

import com.alibaba.fastjson.JSON;

public class FastjsonExample {
    public static void main(String[] args) {
        // Java对象转JSON字符串
        User user = new User("John", 30);
        String jsonString = JSON.toJSONString(user);
        System.out.println(jsonString);

        // JSON字符串转Java对象
        User parsedUser = JSON.parseObject(jsonString, User.class);
        System.out.println(parsedUser.getName());
    }
}

class User {
    private String name;
    private int age;

    // 构造函数、getter和setter方法
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

JSON解析

Fastjson还可以方便地解析JSON字符串为JSON对象或者JSON数组：

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

public class JsonParsingExample {
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"John\",\"age\":30}";
        
        // 解析JSON字符串为JSONObject
        JSONObject jsonObject = JSON.parseObject(jsonString);
        System.out.println(jsonObject.getString("name"));

        // 解析JSON数组字符串为JSONArray
        String jsonArrayString = "[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]";
        JSONArray jsonArray = JSON.parseArray(jsonArrayString);
        System.out.println(jsonArray.getJSONObject(1).getString("name"));
    }
}

Fastjson的进阶用法

序列化与反序列化

Fastjson提供了丰富的序列化和反序列化选项，可以满足不同的需求。例如，可以使用SerializerFeature来定制序列化行为：

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

public class SerializationExample {
    public static void main(String[] args) {
        User user = new User("John", 30);

        // 序列化时写入null值
        String jsonString = JSON.toJSONString(user, SerializerFeature.WriteMapNullValue);
        System.out.println(jsonString);

        // 序列化时格式化输出
        String prettyJsonString = JSON.toJSONString(user, SerializerFeature.PrettyFormat);
        System.out.println(prettyJsonString);
    }
}

自定义序列化和反序列化

有时需要对某些字段进行特殊处理，可以通过自定义序列化器和反序列化器来实现：

import com.alibaba.fastjson.annotation.JSONField;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.ObjectSerializer;
import com.alibaba.fastjson.serializer.SerializeWriter;

import java.io.IOException;
import java.lang.reflect.Type;

public class CustomSerializationExample {
    public static void main(String[] args) {
        User user = new User("John", 30, "123-456-7890");

        // 序列化时自定义处理phone字段
        String jsonString = JSON.toJSONString(user);
        System.out.println(jsonString);

        // 反序列化时自定义处理phone字段
        User parsedUser = JSON.parseObject(jsonString, User.class);
        System.out.println(parsedUser.getPhone());
    }
}

class User {
    private String name;
    private int age;
    @JSONField(serializeUsing = PhoneSerializer.class, deserializeUsing = PhoneDeserializer.class)
    private String phone;

    // 构造函数、getter和setter方法
    public User(String name, int age, String phone) {
        this.name = name;
        this.age = age;
        this.phone = phone;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getPhone() {
        return phone;
    }
}

class PhoneSerializer implements ObjectSerializer {
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
        SerializeWriter out = serializer.out;
        String phone = (String) object;
        out.writeString(phone.replace("-", ""));
    }
}

class PhoneDeserializer implements com.alibaba.fastjson.parser.deserializer.ObjectDeserializer {
    @Override
    public <T> T deserialze(com.alibaba.fastjson.parser.DefaultJSONParser parser, Type type, Object fieldName) {
        String phone = parser.parseObject(String.class);
        return (T) phone.replaceAll("(\\d{3})(\\d{3})(\\d{4})", "$1-$2-$3");
    }

    @Override
    public int getFastMatchToken() {
        return 0;
    }
}

处理日期格式

处理日期格式时，Fastjson提供了多种选项，可以自定义日期的序列化和反序列化格式：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.annotation.JSONField;

import java.util.Date;

public class DateFormatExample {
    public static void main(String[] args) {
        Event event = new Event("Meeting", new Date());

        // 序列化时使用自定义日期格式
        String jsonString = JSON.toJSONString(event);
        System.out.println(jsonString);

        // 反序列化时使用自定义日期格式
        Event parsedEvent = JSON.parseObject(jsonString, Event.class);
        System.out.println(parsedEvent.getDate());
    }
}

class Event {


    private String name;
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    private Date date;

    // 构造函数、getter和setter方法
    public Event(String name, Date date) {
        this.name = name;
        this.date = date;
    }

    public String getName() {
        return name;
    }

    public Date getDate() {
        return date;
    }
}

实际应用场景

统一返回结果

在Spring Boot项目中，可以通过自定义返回结果的格式，使得API的返回更加一致和规范。例如，可以使用Fastjson来统一返回结果：

import com.alibaba.fastjson.JSON;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class ApiController {

    @GetMapping("/user")
    public String getUser() {
        User user = new User("John", 30);
        return JSON.toJSONString(new ApiResponse<>(200, "Success", user));
    }
}

class ApiResponse<T> {
    private int code;
    private String message;
    private T data;

    // 构造函数、getter和setter方法
    public ApiResponse(int code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }

    public T getData() {
        return data;
    }
}

多层嵌套对象的解析

在实际项目中，往往会遇到多层嵌套的JSON对象，Fastjson同样可以轻松处理：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

public class NestedJsonExample {
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"Company\",\"employees\":[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]}";

        // 解析嵌套的JSON对象
        JSONObject jsonObject = JSON.parseObject(jsonString);
        System.out.println(jsonObject.getString("name"));

        // 解析嵌套的JSON数组
        JSONArray employees = jsonObject.getJSONArray("employees");
        for (int i = 0; i < employees.size(); i++) {
            JSONObject employee = employees.getJSONObject(i);
            System.out.println(employee.getString("name"));
        }
    }
}

安全性注意事项

使用Fastjson时，需要注意一些安全性问题，例如防范反序列化漏洞。建议在使用Fastjson时遵循以下安全措施：

  1. 升级到最新版本：Fastjson会定期修复已知的安全漏洞，保持库的最新版本可以避免已知的问题。
  2. 禁用AutoType：通过禁用AutoType可以防止反序列化时的远程代码执行漏洞：
import com.alibaba.fastjson.parser.ParserConfig;

public class SecurityExample {
    public static void main(String[] args) {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(false);
    }
}
  1. 使用白名单：如果确实需要使用AutoType，可以配置白名单来限制可反序列化的类：
import com.alibaba.fastjson.parser.ParserConfig;

public class WhitelistExample {
    public static void main(String[] args) {
        ParserConfig.getGlobalInstance().addAccept("com.yourpackage.");
    }
}

总结

本文详细介绍了在Spring Boot项目中如何使用Fastjson，包括其基本用法和进阶技巧，并通过一些实际应用场景展示了Fastjson的强大功能。同时，也强调了使用Fastjson时的安全注意事项。希望通过本文的介绍，读者能够更好地理解和使用Fastjson，为自己的项目带来更高的效率和安全性。如果你有任何问题或建议，欢迎在评论区留言讨论。

阅读全部

相关推荐

  1. 深入理解Spring Boot中的Fastjson

    2024-07-23 05:22:02       17 阅读

  3. 深入理解springboot

    2024-07-23 05:22:02       94 阅读

  4. 深入理解Golang中的goroutine 池

    2024-07-23 05:22:02       53 阅读

  5. 深入理解 Rust 中的元编程

    2024-07-23 05:22:02       53 阅读

  6. 深入理解 golang 中的反射机制

    2024-07-23 05:22:02       49 阅读

  8. 深入理解Golang中的Options模式

    2024-07-23 05:22:02       46 阅读

  10. 深入理解Flutter中的ValueNotifier

    2024-07-23 05:22:02       33 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-07-23 05:22:02       52 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-07-23 05:22:02       54 阅读

  9. 在Django里面运行非项目文件

    2024-07-23 05:22:02       45 阅读

  19. Python语言-面向对象

    2024-07-23 05:22:02       55 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-07-23 05:22:02       50 阅读

热门阅读

  3. 【Golang 面试基础题】每日 5 题（四）

    2024-07-23 05:22:02       16 阅读

  14. vue中预览视频，word，pdf，xlsx

    2024-07-23 05:22:02       16 阅读
  15. service

    service

    2024-07-23 05:22:02      14 阅读

  17. vue3 页面引入组件

    2024-07-23 05:22:02       17 阅读

  20. NotebookApp Error unpacking user from cookie

    2024-07-23 05:22:02       15 阅读

  27. PHP基础语法（三）

    2024-07-23 05:22:02       19 阅读