Java-处理对象的本地化字段

我有几个使用Json导入的A类对象。每个字段有2个字段

Several Objects (of Class A)
  - field-1
  - field-2

在程序中-更改字段的值。然后返回这些对象以及更新的字段

在程序中-我们需要为每个对象“创建并跟踪”几个“临时”字段-例如

Several Objects (of Class A)
  - field-1
  - field-2
  - Temp-field-3
  - Temp-field-4

跑步之后。对象将与原始字段（即字段1和字段2）一起发回

类A-正由多个程序使用，因此我们无法将“Temp”字段添加到类定义本身

现在-我将Class-A的对象（2个字段）映射到Class-B的对象（有4个字段-包括临时字段；程序本地）。在运行结束时，使用B类相应对象的字段值更新A类对象

有更好的方法吗？

是一种轻量级数据交换格式。

，因此没有变量定义，也没有处理其中数据的方法

您所描述的是，您希望读取初始值，然后修改它，然后保存它们。。。这些更改似乎适合在程序内部完成，然后根据需要存储输出。执行此操作的方式在很大程度上取决于您的需要

如果您只有一台机器执行所有需要的操作，然后让

a类JSON

保存这两个字段，然后执行所有操作，然后再次将它们作为

a类JSON

输出，而不使用

B类JSON

但是，如果中间文件很重要，那么使用

classebjson

是一个好方法

如果可以，请说明最适合您需要的条件。否则，我们只能猜测您想要什么，从而展示我们对它的看法。

是一种轻量级数据交换格式。

，因此没有变量定义，也没有在其中处理数据的方法

您所描述的是，您希望读取初始值，然后修改它，然后保存它们。。。这些更改似乎适合在程序内部完成，然后根据需要存储输出。执行此操作的方式在很大程度上取决于您的需要

如果您只有一台机器执行所有需要的操作，然后让

a类JSON

保存这两个字段，然后执行所有操作，然后再次将它们作为

a类JSON

输出，而不使用

B类JSON

但是，如果中间文件很重要，那么使用

classebjson

是一个好方法

---

如果可以，请说明最适合您需要的条件。否则，我们只能猜测您想要什么，从而展示我们对它的看法。

如果您的代码有特定的需求，最好将该需求隔离并内部化，而不是污染类空间

您可以通过在想要跟踪临时值的类中保留

映射来实现这一点。地图的关键点是要处理的对象。映射的值包含临时值

当您不再需要临时值时，请调用
map.remove（obj）
如果您的代码有特殊需要，最好将该需要隔离并内部化，而不是污染类空间

您可以通过在想要跟踪临时值的类中保留
映射来实现这一点。地图的关键点是要处理的对象。映射的值包含临时值

当您不再需要临时值时，请调用
map.remove（obj）
我不太明白您想做什么，但我希望这有助于：
abstract class A{
    int a;
    int b;
    public void update(){
        changeA();
        changeB();
    }
    protected abstract void changeA();
    protected abstract void changeB();
}
class B extends A{
    int c,d;
    protected void changeA(){
        a += c;
    }
    protected void changeB(){
        b += d;
    }
}


我不太明白你想做什么，但我希望这能有所帮助：
abstract class A{
    int a;
    int b;
    public void update(){
        changeA();
        changeB();
    }
    protected abstract void changeA();
    protected abstract void changeB();
}
class B extends A{
    int c,d;
    protected void changeA(){
        a += c;
    }
    protected void changeB(){
        b += d;
    }
}


通过使用transient或JsonIgnore，可以避免从A映射到B（以及从B映射到A），如下所示

下面的工作示例解释了这一点。它只考虑单个对象，但您可以轻松地将其扩展为对象列表

这样，您仍然可以控制扩展类，但就性能而言，它不会增加任何开销。并且序列化代码不受类A中任何更改的影响—例如，添加了一个新字段

假设您的类A有以下字段

class A {
    String name;
    String id;
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public String getId() {return id;}
    public void setId(String id) {this.id = id;}
}

将B类定义如下

class B extends A {
    @JsonIgnore
    transient String temp_1;
    @JsonIgnore
    transient String temp_2;
    //Getter and setters
    public String getTemp_1() {return temp_1;}
    public void setTemp_1(String temp_1) {this.temp_1 = temp_1;}
    public String getTemp_2() {return temp_2;}
    public void setTemp_2(String temp_2) {this.temp_2 = temp_2;}
}

示例代码-请注意，它直接反序列化到对象B而不是对象A。

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Sample {

    public B fromJson(String jsonA) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.readValue(jsonA, B.class);
    }

    public void doProcess(B b){
        b.setTemp_1("newTemp1");
        b.setName("newName");
    }
    public String toJson(B b) throws JsonProcessingException{
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(b);
    }

    public static void main(String[] args) 
       throws JsonParseException, JsonMappingException, IOException {

        String incomingJson = "{ \"id\": \"123\",  \"name\" : \"JM\" }";
        System.out.println("Input->  " + incomingJson);
        Sample sample = new Sample();
        B b = sample.fromJson(incomingJson);
        sample.doProcess(b);
        String modifiedJson = sample.toJson(b);
        System.out.println("Output-> "+modifiedJson);
    }
}

输出

Input->  { "id": "123",  "name" : "JM" }
Output-> {"name":"newName","id":"123"}

通过使用transient或JsonIgnore，可以避免从A映射到B（以及从B映射到A），如下所示

下面的工作示例解释了这一点。它只考虑单个对象，但您可以轻松地将其扩展为对象列表

这样，您仍然可以控制扩展类，但就性能而言，它不会增加任何开销。并且序列化代码不受类A中任何更改的影响—例如，添加了一个新字段

假设您的类A有以下字段

class A {
    String name;
    String id;
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public String getId() {return id;}
    public void setId(String id) {this.id = id;}
}

将B类定义如下

class B extends A {
    @JsonIgnore
    transient String temp_1;
    @JsonIgnore
    transient String temp_2;
    //Getter and setters
    public String getTemp_1() {return temp_1;}
    public void setTemp_1(String temp_1) {this.temp_1 = temp_1;}
    public String getTemp_2() {return temp_2;}
    public void setTemp_2(String temp_2) {this.temp_2 = temp_2;}
}

示例代码-请注意，它直接反序列化到对象B而不是对象A。

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Sample {

    public B fromJson(String jsonA) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.readValue(jsonA, B.class);
    }

    public void doProcess(B b){
        b.setTemp_1("newTemp1");
        b.setName("newName");
    }
    public String toJson(B b) throws JsonProcessingException{
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(b);
    }

    public static void main(String[] args) 
       throws JsonParseException, JsonMappingException, IOException {

        String incomingJson = "{ \"id\": \"123\",  \"name\" : \"JM\" }";
        System.out.println("Input->  " + incomingJson);
        Sample sample = new Sample();
        B b = sample.fromJson(incomingJson);
        sample.doProcess(b);
        String modifiedJson = sample.toJson(b);
        System.out.println("Output-> "+modifiedJson);
    }
}

输出

Input->  { "id": "123",  "name" : "JM" }
Output-> {"name":"newName","id":"123"}

子分类看起来更干净，这样你就永远拥有了可以按原样使用的A类。或者装饰图案，可能是吗？子分类看起来更干净，这样你就永远拥有可以按原样使用的A级。或者装饰模式，可能是？它是一个web应用程序。A级定义由4个此类小型应用程序共享，这些应用程序共享A级对象的内容，并负责对象的部分（某些字段）。中间（temp）字段不重要，仅用于派生主字段的值。@userDSSR Ok，但应用程序是如何执行的？它们都在同一台机器上（因此可以共享同一个文件），还是在2台以上不同的机器上运行，因此必须在某个时间点进行同步？最后，您的文件的规模是多少？这些是10位的单一Json文件，还是10 GB的文件，以及一次需要存在/执行多少个Json