如何使JSON对象保持有序？及Java文件Getter/Setter赋值技术问询

1. How to Achieve Ordered JSON Objects? #

By default, JSON objects are unordered per the official JSON specification—but if you need to preserve key order (e.g., for API contract consistency), here are practical solutions for Java:

Using Jackson #

• Annotation-based explicit ordering: Add @JsonPropertyOrder to your POJO to define the exact serialization order of properties:

  @JsonPropertyOrder({"boId", "name", "factory", "status", "issued", "team", "type", "buildId"})
  public class BuildOrder {
      private String boId;
      private String name;
      // Rest of your fields...
  }
  

• LinkedHashMap for dynamic structures: If you’re building JSON dynamically (not from a POJO), use LinkedHashMap instead of HashMap—it maintains insertion order, which Jackson will respect when serializing to JSON:

  Map<String, Object> orderedJson = new LinkedHashMap<>();
  orderedJson.put("boId", etsBuildOrder.getBoId());
  orderedJson.put("name", etsBuildOrder.getName());
  // Add other entries in your desired sequence
  ObjectMapper mapper = new ObjectMapper();
  String orderedJsonString = mapper.writeValueAsString(orderedJson);
  

Using Gson #

Gson typically serializes POJO fields in the order they’re declared in the class (with default reflection-based serialization). For strict control, you can also use LinkedHashMap for dynamic maps, or create a custom TypeAdapter for complex ordering rules.

Key Note #

Keep in mind that some frontend JSON parsers may reorder keys internally, so confirm with your frontend team if backend-enforced ordering is actually necessary before investing time into it.

2. Getter/Setter Implementation & Property Copy Optimization #

Looking at your code snippet, manually copying properties between objects works but is verbose and error-prone for large classes. Here’s how to streamline this:

Simplify Getter/Setter Creation #

Stop writing boilerplate getter/setter code manually! Use Lombok, a Java library that generates these methods at compile time. Just add the @Data annotation to your class:

import lombok.Data;

@Data
public class BuildOrder {
    private String boId;
    private String name;
    private String factory;
    private String status;
    private boolean issued;
    private String team;
    private String type;
    private String buildId;
    // No need to write getBoId(), setBoId(), etc.—Lombok handles all of it
}

@Data also generates toString(), equals(), and hashCode() methods automatically, which is a handy bonus.

Optimize Property Copy Logic #

Instead of calling setX() for every field, use a library to handle bulk property copying:

Option 1: Spring BeanUtils

If you’re using Spring, BeanUtils.copyProperties() is a quick way to copy matching fields:

if (etsBuildOrder != null) {
    BeanUtils.copyProperties(etsBuildOrder, buildOrder);
    // Manually handle mismatched field names (like buildRequestId → buildId)
    buildOrder.setBuildId(etsBuildOrder.getBuildRequestId());
}

Note: This uses reflection, so it’s slightly slower than manual code—but for most use cases, the performance impact is negligible.

Option 2: MapStruct (Type-Safe & Fast)

For better performance and type safety, use MapStruct. It generates compile-time mapping code (no reflection) and lets you define custom mappings easily:

1. Add the MapStruct dependency to your project
2. Create a mapper interface:

   import org.mapstruct.Mapper;
   import org.mapstruct.Mapping;
   
   @Mapper
   public interface BuildOrderMapper {
       BuildOrderMapper INSTANCE = Mappers.getMapper(BuildOrderMapper.class);
   
       // Map buildRequestId from EtsBuildOrder to buildId in BuildOrder
       @Mapping(source = "buildRequestId", target = "buildId")
       BuildOrder toBuildOrder(EtsBuildOrder etsBuildOrder);
   }
   

3. Use it in your code:

   if (etsBuildOrder != null) {
       buildOrder = BuildOrderMapper.INSTANCE.toBuildOrder(etsBuildOrder);
   }
   

MapStruct is ideal for complex mappings and avoids runtime errors that can occur with reflection-based tools.

内容的提问来源于stack exchange，提问作者Fabian Raj