SnakeYaml，读入类中特定标记下的所有内容，忽略其他所有内容

Question

我有一些YAML文件包含很多配置，但我只需要其中的一个标记（mytag）。

component:
  field1:
    - name: nnn1
  field2:
    - name: mmm1

mytag:
   description: hello
   mycomponents:
      - propertyA: aaa
        propertyB: bbb

theirtag:
   bbb: 111
   comps:
      - propA: aaa
        prop: bbb

我需要加载：

class MyClass {
   String description;
   List<MyComponent> mycomponents:
}

如何使用SnakeYaml做到这一点？我没能很快找到任何有用的例子。

跟进：如果我的标签嵌套得更深，该怎么办：（boo/mytag）

boo:
  mytag:
    description: hello
    mycomponents:
      - propertyA: aaa
        propertyB: bbb

谢谢

Answer 1

这不是小事。虽然使用自定义构造函数可能是可行的，但对于这种情况，它们的接口很难处理，我不确定如何处理。

相反，您可以覆盖默认的解析器行为，只需丢弃mytag键周围的任何事件，这样解析器发出的事件流只包含mytag键值内的事件。下面是一个简单的工作示例：

package droggeljug;

import org.yaml.snakeyaml.parser.ParserImpl;
import org.yaml.snakeyaml.events.*;
import org.yaml.snakeyaml.composer.Composer;
import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.reader.StreamReader;

import java.io.*;
import java.util.List;

public class Main {

    public static class MyParser extends ParserImpl {
        private final String containingKey;

        private int depth = -1;
        private boolean checked = false;

        public MyParser(StreamReader reader, boolean emitComments, String containingKey) {
            super(reader, emitComments);
            this.containingKey = containingKey;
        }

        @Override
        public Event peekEvent() {
            if (checked) return super.peekEvent();
            Event e;
            while (true) {
                boolean seenContainingKey = false;
                e = super.peekEvent();
                switch (e.getEventId()) {
                    case StreamStart:
                    case DocumentStart:
                    case Comment:
                    case StreamEnd:
                    case DocumentEnd:
                        return e;
                    case Scalar:
                        if (depth == -1) {
                            if (containingKey.equals(((ScalarEvent)e).getValue())) {
                                seenContainingKey = true;
                                break;
                            }
                        }
                    case Alias:
                        break;
                    case MappingStart:
                    case SequenceStart:
                        if (depth > -1) {
                            depth++;
                        }
                        break;
                    case MappingEnd:
                    case SequenceEnd:
                        if (depth > -1) {
                            depth--;
                        }
                        break;
                }
                if (seenContainingKey) {
                    depth = 0;
                } else if (depth > -1) break;
                checked = true; super.getEvent(); checked = false; // discard
            }

            if (depth == 0) depth = -1;
            checked = true;
            return e;
        }

        public Event getEvent() {
            Event ret = super.getEvent();
            checked = false;
            return ret;
        }
    }

    public static class MyYaml extends Yaml {
        private Object loadContainedFromReader(StreamReader sreader, Class<?> type, String containingKey) {
            Composer composer = new Composer(new MyParser(sreader,
                    loadingConfig.isProcessComments(), containingKey), resolver, loadingConfig);
            constructor.setComposer(composer);
            return constructor.getSingleData(type);
        }

        @SuppressWarnings("unchecked")
        public <T> T loadContainedAs(Reader io, Class<T> type, String containingKey) {
            return (T) loadContainedFromReader(new StreamReader(io), type, containingKey);
        }
    }

    public static class MyClass {
        public static class MyComponent {
            public String propertyA, propertyB;
        }

        public String description;
        public List<MyComponent> mycomponents;
    }

    private static final String input =
            "component:\n" +
            "field1:\n" +
            "  - name: nnn1\n" +
            "field2:\n" +
            "  - name: mmm1\n" +
            "mytag:\n" +
            "    description: hello\n" +
            "    mycomponents:\n" +
            "      - propertyA: aaa\n" +
            "        propertyB: bbb\n" +
            "theirtag:\n" +
            "    bbb: 111\n" +
            "    comps:\n" +
            "      - propA: aaa\n" +
            "        prop: bbb\n";

    public static void main(String args[]) {
        MyYaml yaml = new MyYaml();
        MyClass data = yaml.loadContainedAs(new StringReader(input), MyClass.class, "mytag");
        System.out.println("description = " + data.description);
        for (MyClass.MyComponent c : data.mycomponents) {
            System.out.println("component: (" + c.propertyA + ", " + c.propertyB + ")");
        }
    }
}

过滤代码不完全正确，例如，如果mytag是某个值或序列项，则会失败。您需要跟踪解析器状态，以确保当前标量是映射键。我没有实现它，因为代码已经足够长了。