“变量赋值请求”对象设计

Question

我有多个不允许修改对方字段的类，而是必须通过将请求对象添加到Main类的队列来请求修改。在每个循环结束时，Main类将执行请求的修改。

public class Main { 

    public static ClassA a = new ClassA(); 
    public static ClassB b = new ClassB(); 

    private static List<Request> requestQueue = new ArrayList<Request>(); // List holds all requests 

    public static void main(String args[]) { 
     while (true) { 
      a.tick(); 
      b.tick(); 
      for (Request r : requestQueue) { 
       r.field = r.value; // All requests are fulfilled 
      } 
      requestQueue.clear(); 
     } 
    } 

    public static <ValueType> void addModificationRequest(ValueType field, 
      ValueType value) { 
     requestQueue.add(new Request<ValueType>(field, value)); 
    } 
} 

// Request Object 
public class Request<ValueType> { 

    ValueType field; 
    ValueType value; 

    public Request(ValueType field, ValueType value) { 
     this.field = field; 
     this.value = value; 
    } 
} 

// Classes 
public class ClassA { 
    String name = "A"; 

    public void tick() { 
     Main.addModificationRequest(Main.b.name, "NewNameB"); // Try to change b name 
    } 
} 

public class ClassB { 
    String name = "B"; 

    public void tick() { 
     // Nothing 
    } 
} 

我知道代码是乱，但它的最简单的方法我已经想到了这么远。有没有人知道任何可以以更简单，更稳健的方式实现这一点的优秀设计模式？ （注：我必须这样说，没有允许类直接修改对方的可能性。）

编辑：类将有一个以上的可修改的变量。我还需要确定是否有任何请求尝试修改同一个变量，因此我可以忽略其中的一个或两个。

编辑：感谢所有的帮助，我真的很感激它！我决定让这些课程跟踪他们自己的修改。我也将使用我一直使用的相同的请求对象，因为它很简单直接。再次谢谢你。

Answer 1

也许这并不适用于您的用例，但您可以让对象自己跟踪未完成的修改，然后从您的主类中调用，修改实际字段本身。

如果你只需要设置操作，跟踪修改就像保持班级中每个字段的额外字段一样简单。如果您需要一系列算术运算，您可以使用一系列修改。

public class DelayedModificationField<T> { 
    private T field; 
    private T newValue; 
    public T get() { return field;} 
    public delayedSet(T value) { 
     if (newValue != null) throw new ConcurrentModificationException("error"); 
     newValue = value; 
    } 
    public void performSet() { 
     field = newValue; 
     newValue = null; 
    } 

public ExampleClass { 
    private DelayedModificationField<String> myField = new DelayedModificationField<String>(); 
    public void setMyField(String s) { myField.delayedSet(s);} 
    public String getMyField() { return myField.get();} 
    public void performSet() { myField.performSet();} 
} 

主类必须跟踪支持延迟修改的所有对象，并呼吁performSet他们每个刻度。让他们实现一个接口并将它们保存在一个列表中。

Answer 2

这不起作用。我不知道您的任务的确切参数，但我会用单一方法void setField(ValueType newValue)来定义接口Modifiable。然后我会声明ClassA和ClassB执行Modifiable。最后，将您的Request类重新定义为Modifiable和ValueType而不是两个ValueType字段。然后，您的队列循环将是：

for (Request r : requestQueue) { 
    r.modifiable.setField(r.value); 
} 

编辑：

下面是这种方法的修改是扩展到多个领域：

interface Modifiable { 
    void setName(String newName); 
    void setAge(Integer newAge); // I wish 
} 

abstract class Request<ValueType> { 
    Modifiable object; 
    ValueType value; 

    public Request(Modifiable object, ValueType value) { 
     this.object = object; 
     this.value = value; 
    } 

    abstract void execute(); 
} 

class RequestNameChange extends Request<String> { 
    public RequestNameChange(Modifiable object, String name) { 
     super(object, name); 
    } 

    void execute() { 
     object.setName(name); 
    } 
} 

// etc. 

另一种方法是使用反射，但我怀疑这不是你的任务。

Answer 3

尝试“好莱坞”模式 - 它采用了“不要打电话给我们，我们会打电话给你”的风格，也就是使用“回调”代码。

像这样：用匿名类

public static class Main { 

    public static ClassA a = new ClassA(); 
    public static ClassB b = new ClassB(); 

    private static List<Runnable> requestQueue = new ArrayList<Runnable>(); // List holds all requests 

    public static void main(String args[]) { 
     while (true) { 
      a.tick(); 
      b.tick(); 
      for (Runnable r : requestQueue) { 
       r.run(); // All requests are fulfilled 
      } 
      requestQueue.clear(); 
     } 
    } 

    public static void addModificationRequest(Runnable runnable) { 
     requestQueue.add(runnable); 
    } 
} 

呼叫addModificationRequest：

Main.addModificationRequest(new Runnable() { 
    public void run() { 
     Main.b.name = "NewNameB"; 
    } 
}); 

注意，该代码将抛出一个ConcurrentModificationException如果addModificationRequest时调用了foreach循环正在执行。一个便宜的修复方法是将关键字​​添加到addModificationRequest中，并使用类对象作为锁在同步块中执行循环+清除。

编辑：

要通过在外地，所以你可以检查它，试试这个：

interface FieldUpdater extends Runnable 
{ 
    Field getField(); 
} 

static class Main 
{ 

    public static ClassA a = new ClassA(); 
    public static ClassB b = new ClassB(); 

    private static List<FieldUpdater> requestQueue = new ArrayList<FieldUpdater>(); // List holds all requests 

    private static Set<Field> seenBefore = new HashSet<Field>(); 

    public void main(String args[]) 
    { 
     while (true) 
     { 
      a.tick(); 
      b.tick(); 
      for (FieldUpdater r : requestQueue) 
      { 
       if (seenBefore.contains(r.getField())) 
       { 
        continue; // Or do something else specific 
       } 
       seenBefore.add(r.getField()); 
       r.run(); 
      } 
      requestQueue.clear(); 
     } 
    } 

    public synchronized static void addModificationRequest(FieldUpdater fieldUpdater) 
    { 
     requestQueue.add(fieldUpdater); 
    } 
} 

然后打电话给你的方法是这样的：

Main.addModificationRequest(new FieldUpdater() 
    { 
     public void run() 
     { 
      Main.b.name = "NewNameB"; 
     } 

     public Field getField() 
     { 
      return Main.class.getField("name"); 
     } 

    }); 

注意，对于清晰度我故意省略处理可以从getField（）抛出的异常。此外，这不是很好的代码设计，但它确实解决了上述代码的固定问题。