java里json传值怎么传

Java中JSON传值的完整指南

在Java开发中，JSON（JavaScript Object Notation）因其轻量级、易读性和跨语言特性，已成为前后端数据交互的主流格式，无论是RESTful API的请求响应，还是微服务间的数据传递，都离不开JSON传值，本文将详细介绍Java中JSON传值的实现方式，包括常用库的选择、对象与JSON的转换、复杂场景处理及最佳实践。

为什么选择JSON传值？

JSON是一种键值对（Key-Value）结构的数据格式，与XML相比，JSON更简洁，解析效率更高，且天然支持JavaScript（前端可直接使用JSON.parse()和JSON.stringify()处理），在Java中,通过JSON传值可以实现：

• 前后端分离：后端返回JSON数据,前端直接解析并渲染页面；
• 跨服务通信：微服务架构中，服务间通过HTTP+JSON传递结构化数据；
• 配置存储：将复杂配置（如嵌套对象、数组）以JSON格式存储,便于动态读取。

Java中处理JSON的常用库

Java生态中有多个成熟的JSON处理库,以下是主流选择及对比：

推荐选择：

• 新项目优先用Jackson（与Spring生态深度集成）；
• 若需简单处理或Google生态项目，可选Gson；
• 避免使用Fastjson旧版（1.2.68以下）,安全风险较高。

核心操作：对象与JSON的相互转换

JSON传值的核心是将Java对象序列化为JSON字符串（序列化），或将JSON字符串反序列化为Java对象（反序列化），下面以最常用的Jackson和Gson为例,演示具体操作。

使用Jackson实现转换

（1）添加依赖

Maven项目中添加Jackson核心依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

（2）序列化：Java对象 → JSON字符串

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
// 1. 定义Java对象（POJO）
class User {
    private String name;
    private int age;
    private String[] hobbies;
    // 无参构造器（反序列化时需要）
    public User() {}
    // 有参构造器
    public User(String name, int age, String[] hobbies) {
        this.name = name;
        this.age = age;
        this.hobbies = hobbies;
    }
    // Getter/Setter（Jackson通过反射访问属性）
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String[] getHobbies() { return hobbies; }
    public void setHobbies(String[] hobbies) { this.hobbies = hobbies; }
    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + ", hobbies=" + Arrays.toString(hobbies) + "}";
    }
}
public class JacksonDemo {
    public static void main(String[] args) throws JsonProcessingException {
        // 2. 创建ObjectMapper实例（线程安全，可复用）
        ObjectMapper objectMapper = new ObjectMapper();
        // 3. 构造Java对象
        User user = new User("张三", 25, new String[]{"篮球", "编程"});
        // 4. 序列化为JSON字符串
        String jsonString = objectMapper.writeValueAsString(user);
        System.out.println("序列化结果: " + jsonString);
        // 输出: {"name":"张三","age":25,"hobbies":["篮球","编程"]}
    }
}

（3）反序列化：JSON字符串 → Java对象

// 继续使用上面的User类和ObjectMapper
public class JacksonDemo {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonString = "{\"name\":\"李四\",\"age\":30,\"hobbies\":\"阅读,旅行\"}";
        // 反序列化为User对象
        User user = objectMapper.readValue(jsonString, User.class);
        System.out.println("反序列化结果: " + user);
        // 输出: User{name='李四', age=30, hobbies=[阅读, 旅行]}
    }
}

使用Gson实现转换

（1）添加依赖

Maven项目中添加Gson依赖：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

（2）序列化与反序列化

import com.google.gson.Gson;
// 同样使用上面的User类
public class GsonDemo {
    public static void main(String[] args) {
        // 1. 创建Gson实例（线程安全，可复用）
        Gson gson = new Gson();
        // 2. 构造Java对象
        User user = new User("王五", 28, new String[]{"音乐", "摄影"});
        // 3. 序列化为JSON字符串
        String jsonString = gson.toJson(user);
        System.out.println("序列化结果: " + jsonString);
        // 输出: {"name":"王五","age":28,"hobbies":["音乐","摄影"]}
        // 4. 反序列化为User对象
        String jsonStr = "{\"name\":\"赵六\",\"age\":35,\"hobbies\":\"游泳,健身\"}";
        User deserializedUser = gson.fromJson(jsonStr, User.class);
        System.out.println("反序列化结果: " + deserializedUser);
        // 输出: User{name='赵六', age=35, hobbies=[游泳, 健身]}
    }
}

处理复杂场景

（1）嵌套对象转换

class Address {
    private String city;
    private String street;
    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }
    // Getter/Setter...
}
class Person {
    private String name;
    private Address address; // 嵌套对象
    // 构造器、Getter/Setter...
}
// Jackson处理嵌套对象
ObjectMapper mapper = new ObjectMapper();
Person person = new Person("张三", new Address("北京", "朝阳区"));
String json = mapper.writeValueAsString(person);
// 输出: {"name":"张三","address":{"city":"北京","street":"朝阳区"}}

（2）集合/数组转换

// List转JSON
List<User> userList = Arrays.asList(
    new User("user1", 20, new String[]{"游戏"}),
    new User("user2", 22, new String[]{"动漫"})
);
String jsonArray = mapper.writeValueAsString(userList);
// 输出: [{"name":"user1","age":20,...},{"name":"user2","age":22,...}]
// JSON转List
List<User> list = mapper.readValue(jsonArray, new TypeReference<List<User>>() {});

（3）日期格式处理

默认情况下，Jackson会将日期序列化为时间戳（如1704067200000）,可通过注解自定义格式：

class Event {
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 指定日期格式
    private LocalDateTime startTime;
    // Getter/Setter...
}
// 输出: {"startTime":"2024-01-01 12:00:00"}

（4）忽略字段

class User {
    @JsonIgnore // 忽略此字段，序列化/反序列化时均不包含
    private String password;
    @JsonProperty("user_name") // 序列化/反序列化时映射为"user_name"
    private String name;
}

实际应用场景示例

前后端交互：Spring Boot接收JSON请求

后端通过@RequestBody注解接收前端发送的JSON数据,并返回JSON响应：

import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/users")
public class UserController {
    // 接收JSON并反序列化为User对象
    @PostMapping
    public String createUser(@RequestBody User