使用JPA将对象列表作为单列JSON存储的教程

本教程详细介绍了如何在spring boot和jpa应用中，将一个对象列表（json数组）高效地存储到数据库的单个列中，而非分散到多个列或单独的表中。核心解决方案是利用jpa的`attributeconverter`机制，结合jackson库实现对象列表与json字符串之间的双向转换，从而灵活地处理复杂数据结构，满足特定存储需求。

在现代应用开发中，经常需要将复杂的嵌套数据结构（例如对象列表）存储到关系型数据库中。虽然JPA提供了@Embeddable和@ElementCollection等注解来处理嵌入式对象或集合，但它们通常会将数据展开成多个列或存储到单独的表中。当需求是将整个对象列表作为一个JSON字符串存储在主表的单个列中时，这些标准JPA注解就不再适用。此时，JPA的AttributeConverter机制便成为理想的解决方案。

理解问题：为什么标准JPA注解不适用？

原始问题中尝试使用@Embeddable注解来处理Sensors[]数组，并期望它能以JSON形式存储在单个列中。然而，@Embeddable注解通常用于将一个类的属性嵌入到另一个实体类中，这些属性会直接映射到主表的相应列。如果@Embeddable类是一个集合类型（如数组或列表），JPA会尝试将其映射到多个独立的列（对于数组的每个元素），或者在结合@ElementCollection时映射到一个单独的关联表。这与将整个集合序列化为单个JSON字符串的需求相悖，从而导致类型转换错误。

解决方案：使用JPA AttributeConverter

AttributeConverter是JPA 2.1引入的一个强大特性，它允许开发者自定义实体属性类型与数据库列类型之间的转换逻辑。通过实现这个接口，我们可以将复杂的Java对象（如List）在存储到数据库时序列化为简单的字符串（JSON），并在从数据库读取时反序列化回Java对象。

1. 定义 Sensors 类

首先，我们需要确保Sensors类是一个普通的Java类，不再需要@Embeddable注解，因为它的序列化和反序列化将由我们自定义的转换器处理，而不是JPA的嵌入式对象机制。

public class Sensors {
    private String amplitudos;
    private Double displacement;
    private String frequencies;
    private Integer sensorId;

    public Sensors() {
    }

    public Sensors(String amplitudos, Double displacement, String frequencies, Integer sensorId) {
        this.amplitudos = amplitudos;
        this.displacement = displacement;
        this.frequencies = frequencies;
        this.sensorId = sensorId;
    }

    // Getters and Setters
    public String getAmplitudos() {
        return amplitudos;
    }

    public void setAmplitudos(String amplitudos) {
        this.amplitudos = amplitudos;
    }

    public Double getDisplacement() {
        return displacement;
    }

    public void setDisplacement(Double displacement) {
        return displacement;
    }

    public String getFrequencies() {
        return frequencies;
    }

    public void setFrequencies(String frequencies) {
        this.frequencies = frequencies;
    }

    public Integer getSensorId() {
        return sensorId;
    }

    public void setSensorId(Integer sensorId) {
        this.sensorId = sensorId;
    }
}

2. 实现自定义 AttributeConverter

接下来，创建一个实现AttributeConverter接口的类。在这个例子中，ENTITY_ATTRIBUTE_TYPE是List，DATABASE_COLUMN_TYPE是String。我们将使用Jackson库来处理JSON的序列化和反序列化。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;

import java.io.IOException;
import java.util.List;
import java.util.Collections; // 导入 Collections

@Converter
public class SensorsConverter implements AttributeConverter, String> {

    private final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 将实体属性（List）转换为数据库列类型（String JSON）
     * @param sensors 要转换的Sensors列表
     * @return 转换后的JSON字符串
     */
    @Override
    public String convertToDatabaseColumn(List sensors) {
        if (sensors == null) {
            return null;
        }
        try {
            return objectMapper.writeValueAsString(sensors);
        } catch (JsonProcessingException e) {
            // 生产环境中应记录日志并抛出更具体的运行时异常
            throw new IllegalArgumentException("Error converting List to JSON string", e);
        }
    }

    /**
     * 将数据库列类型（String JSON）转换为实体属性（List）
     * @param sensorsJSON 数据库中的JSON字符串
     * @return 转换后的Sensors列表
     */
    @Override
    public List convertToEntityAttribute(String sensorsJSON) {
        if (sensorsJSON == null || sensorsJSON.trim().isEmpty()) {
            return Collections.emptyList(); // 返回空列表而不是null
        }
        try {
            return objectMapper.readValue(sensorsJSON, new TypeReference>() {});
        } catch (IOException e) {
            // 生产环境中应记录日志并抛出更具体的运行时异常
            throw new IllegalArgumentException("Error converting JSON string to List", e);
        }
    }
}

注意：

• @Converter注解标记这个类是一个JPA转换器。
• convertToDatabaseColumn方法负责将Java对象（List）序列化为JSON字符串。
• convertToEntityAttribute方法负责将JSON字符串反序列化回Java对象（List）。
• 在实际应用中，应添加更健壮的异常处理和日志记录。对于空值处理，convertToEntityAttribute返回Collections.emptyList()通常比返回null更安全，可以避免后续的NullPointerException。

3. 在实体类中使用转换器

最后，在Sensor实体类中，将sensors字段的类型从Sensors[]改为List，并使用@Convert注解指定我们刚刚创建的SensorsConverter。

AI Time Machine

使用AI创建穿越历史的超逼真的头像

下载

import jakarta.persistence.*;
import java.io.Serializable;
import java.sql.Timestamp;
import java.util.List; // 使用 List 代替数组

@Entity
@Table(name = "SENSOR")
public class Sensor implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    @Column(name = "TIMERECEIVED")
    private Timestamp timereceived;

    // 使用 @Convert 注解指定自定义转换器
    // 数据库列类型为 VARCHAR2/CLOB，Java实体属性类型为 List
    @Column(name = "SENSORS", columnDefinition = "CLOB") // 或 VARCHAR2(4000) 根据实际JSON大小调整
    @Convert(converter = SensorsConverter.class)
    private List sensors; // 类型改为 List

    @Column(name = "LOC")
    private String location;

    public Sensor() {
    }

    public Sensor(Timestamp timereceived, List sensors, String location) {
        this.timereceived = timereceived;
        this.sensors = sensors;
        this.location = location;
    }

    // Getters and Setters
    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public Timestamp getTimereceived() {
        return timereceived;
    }

    public void setTimereceived(Timestamp timereceived) {
        this.timereceived = timereceived;
    }

    public List getSensors() { // 返回类型也改为 List
        return sensors;
    }

    public void setSensors(List sensors) { // 参数类型也改为 List
        this.sensors = sensors;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }
}

注意：

• @Column(name = "SENSORS", columnDefinition = "CLOB")：这里我们显式地指定了数据库列的类型为CLOB（字符大对象），以确保能够存储较长的JSON字符串。如果JSON字符串较短，也可以使用VARCHAR2(N)，其中N是足够大的长度。一些现代数据库（如PostgreSQL、Oracle 12c+、MySQL 5.7+）也支持原生JSON数据类型，如果使用这些数据库，可以考虑将columnDefinition设置为相应的JSON类型，例如JSON。

4. 控制器和JSON体

控制器和服务层代码基本无需修改，因为转换器在JPA层自动处理了List与String之间的映射。

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SensorController {

    private final SensorRepository sensorRepository; // 假设有一个 SensorRepository

    public SensorController(SensorRepository sensorRepository) {
        this.sensorRepository = sensorRepository;
    }

    @PostMapping("/sendData")
    public ResponseEntity sendData(@RequestBody Sensor sensor) {
        Sensor newSensor = sensorRepository.save(sensor);
        System.out.println("Saved Sensor: " + newSensor.getId());
        // 可以打印出 newSensor.getSensors() 来验证是否正确反序列化
        System.out.println("Sensors data: " + newSensor.getSensors());
        return ResponseEntity.ok("Sensor received and saved successfully");
    }
}

客户端发送的JSON请求体保持不变：

{
    "timereceived": "2022-11-29T12:04:42.166",
    "sensors": [
        {
            "amplitudos": "a1#a2#a3#a4",
            "displacement": 0.002,
            "frequencies": "f1#f2#f3#f4",
            "sensorid": 1
        },
        {
            "amplitudos": "a1#a2#a3#a4",
            "displacement": 0.002,
            "frequencies": "f1#f2#f3#f4",
            "sensorid": 2
        }
    ],
    "location": "lokasi"
}

当这个JSON体到达Spring Boot控制器时，Jackson会自动将其中的sensors数组映射到Sensor实体中的List字段。然后，当JPA尝试将Sensor实体保存到数据库时，SensorsConverter会自动将List转换为JSON字符串，存储到数据库的SENSORS列。反之，从数据库读取时，也会自动将JSON字符串转换回List。

注意事项与最佳实践

1. 数据库列类型选择：
   • 对于较小的JSON数据，VARCHAR2(N)（Oracle）、VARCHAR(N)（MySQL/PostgreSQL）可能足够。
   • 对于不确定长度或可能很大的JSON数据，推荐使用CLOB（Oracle）、TEXT（PostgreSQL）、LONGTEXT（MySQL）等大文本类型。
   • 如果数据库支持原生JSON数据类型（如PostgreSQL的JSONB，Oracle的JSON类型，MySQL的JSON），优先考虑使用这些类型，它们通常提供更好的查询和索引性能。
2. 错误处理：在AttributeConverter中，序列化和反序列化过程可能会抛出JsonProcessingException或IOException。应捕获这些异常，并根据业务需求进行日志记录或抛出自定义的运行时异常，以便更好地诊断问题。
3. 性能考虑：
   • 频繁地序列化和反序列化大型JSON字符串可能会带来一定的性能开销。
   • 如果需要对JSON内部的数据进行复杂查询，直接将JSON存储为字符串可能不是最高效的方式。考虑使用数据库的原生JSON查询功能，或将关键字段抽取为独立列。
4. Schema演进：JSON数据的灵活性意味着其内部结构可以随时变化。但这也给应用带来了挑战，特别是当旧的JSON数据与新的Java对象结构不兼容时。需要有策略来处理JSON结构的演进，例如版本控制或数据迁移脚本。
5. 依赖管理：确保项目中包含了Jackson库的依赖，例如：

   
       com.fasterxml.jackson.core
       jackson-databind
       2.15.2 
   

总结

通过使用JPA的AttributeConverter，我们可以优雅地解决将对象列表作为JSON字符串存储到数据库单个列的需求。这种方法提供了极大的灵活性，允许开发者在不牺牲JPA便利性的前提下，处理复杂的非结构化或半结构化数据。理解何时以及如何使用AttributeConverter是构建健壮且灵活的Spring Boot数据持久化层的关键技能之一。