Question

假设我有一个xml，其中包含许多类似于此结构的嵌套逻辑运算符：

<?xml version="1.0" encoding="UTF-8"?>
<Or>
    <And>
        <Condition1>
        <Condition2>
    </And>
    <Or>
        <And>
            <Condition3>
            <Condition4>
            <Or>
                <Condition5>
                <Condition6>
            </Or>
        </And>
        <Condition7>
    </Or>
    <Condition8>
</Or>

结构的长度或深度没有限制。

我想用Java表示这个结构，并且能够在任何给定时间确定根节点的布尔值。我能想到这样做的唯一方法就是某种嵌套的List安排，我试图避免这种安排，因为我担心这可能会非常“混乱”。对此有更优雅的解决方案吗？

Answer 1

我在我的一个项目中遇到了类似的问题。我的解决方案是创建一个类型树，其中包含一个名为value的字段和一个名为descendants的树列表。

当节点是运算符时，将使用运算符名称（AND，OR，NOT）填充值，并将子条件添加到后代列表中。当它是一个条件时，该值将包含条件，列表将为空。

类Tree还包含一个返回布尔值的方法evaluate（boolean neutralElement）。在评估节点时，如果它不是运算符，我会简单地评估它。如果它是一个运算符，我会将当前运算符应用于它的后代（中性元素是必要的，因为由于项目条件，后代可能是一个空文本，如果其父级是OR或者true，则应该将其评估为false，如果是父母是一个AND）。

Answer 2

这是一个有趣的问题。在我看来，使用JAXB很容易解决。这是一个小原型：

import java.io.StringReader;
import java.util.List;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAnyElement;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSeeAlso;

import org.xml.sax.InputSource;

public class Test {
  public static void main(String... args) {
    String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" +
        "<Or>\r\n" +
        "  <And>\r\n" +
        "    <Condition value = 'true'/>\r\n" +
        "    <Condition value = 'true'/>\r\n" +
        "  </And>\r\n" +
        "  <And>\r\n" +
        "    <Condition value = 'false'/>\r\n" +
        "    <Condition value = 'true'/>\r\n" +
        "    <Or>\r\n" +
        "      <Condition value = 'false'/>\r\n" +
        "      <Condition value = 'true'/>\r\n" +
        "    </Or>\r\n" +
        "  </And>\r\n" +
        "  <Condition value = 'false'/>\r\n" +
        "  <Condition value = 'false'/>\r\n" +
        "</Or>";
    try {
      Evaluable o = (Evaluable) JAXBContext.newInstance(BooleanOperators.class, Condition.class).createUnmarshaller()
          .unmarshal(new InputSource(new StringReader(xml)));
      System.out.println(o);
      System.out.println(o.evaluate());
    } catch (JAXBException e) {
      e.printStackTrace();
    }
  }
}

interface Evaluable {
  static final Evaluable TRUE = of(true);
  static final Evaluable FALSE = of(false);

  boolean evaluate();

  static Evaluable of(boolean result) {
    return new Evaluable() {
      @Override
      public boolean evaluate() {
        return result;
      }
    };
  }
}

@XmlAccessorType(XmlAccessType.NONE)
@XmlSeeAlso({ And.class, Or.class })
abstract class BooleanOperators implements Evaluable {
  @XmlAnyElement(lax = true)
  protected List<Evaluable> evaluables;

  @Override
  public String toString() {
    return getClass().getSimpleName() + " {" + evaluables + "}";
  }
}

@XmlRootElement(name = "And")
@XmlAccessorType(XmlAccessType.NONE)
class And extends BooleanOperators {
  @Override
  public boolean evaluate() {
    if (evaluables == null || evaluables.isEmpty()) {
      return true;
    }
    return evaluables.stream().reduce(TRUE, (i, j) -> Evaluable.of(i.evaluate() && j.evaluate())).evaluate();
  }
}

@XmlRootElement(name = "Or")
@XmlAccessorType(XmlAccessType.NONE)
class Or extends BooleanOperators {
  @Override
  public boolean evaluate() {
    if (evaluables == null || evaluables.isEmpty()) {
      return true;
    }
    return evaluables.stream().reduce(FALSE, (i, j) -> Evaluable.of(i.evaluate() || j.evaluate())).evaluate();
  }
}

@XmlRootElement(name = "Condition")
@XmlAccessorType(XmlAccessType.NONE)
class Condition implements Evaluable {
  @XmlAttribute(required = true, name = "value")
  private boolean result;
  @Override
  public boolean evaluate() {
    return result;
  }

  @Override
  public String toString() {
    return "Condition (" + result + ")";
  }
}

Java中的动态嵌套逻辑处理

2 个答案: