Question

我是风暴中的三叉戟新手。我在TridentState上打破了我的头脑。至于我的理解三叉戟维护每个批处理的状态（即元数据）（批处理中的所有元组是否通过在数据库中维护一个事务ID完全处理）并且我不完全确定以下语句做什么

TridentState urlToTweeters =
   topology.newStaticState(getUrlToTweetersState());

我们可以解释在定义上述代码时实际发生了什么吗？

Answer 1

我希望回答永远不会太迟，至少其他人可能会觉得我的回答很有用：）

因此，topology.newStaticState()是Trident对可查询数据存储的抽象。 newStaticState()的参数应该是基于storm.trident.state.StateFactory方法合同的实现。反过来，工厂应该实现makeState()方法返回storm.trident.state.State的实例。但是，如果您打算查询自己的状态，则应返回storm.trident.state.map.ReadOnlyMapState的优惠，因为普通storm.trident.state.State没有查询实际数据源的方法（您实际上会得到）如果您尝试使用除ReadOnlyMapState之外的任何内容，则为类强制转换异常。

所以，让我们试一试！

虚拟状态实现：

public static class ExampleStaticState implements ReadOnlyMapState<String> {

    private final Map<String, String> dataSourceStub;

    public ExampleStaticState() {
        dataSourceStub = new HashMap<>();
        dataSourceStub.put("tuple-00", "Trident");
        dataSourceStub.put("tuple-01", "definitely");
        dataSourceStub.put("tuple-02", "lacks");
        dataSourceStub.put("tuple-03", "documentation");
    }

    @Override
    public List<String> multiGet(List<List<Object>> keys) {

        System.out.println("DEBUG: MultiGet, keys is " + keys);

        List<String> result = new ArrayList<>();

        for (List<Object> inputTuple : keys) {
            result.add(dataSourceStub.get(inputTuple.get(0)));
        }

        return result;
    }

    @Override
    public void beginCommit(Long txid) {
        // never gets executed...
        System.out.println("DEBUG: Begin commit, txid=" + txid);
    }

    @Override
    public void commit(Long txid) {
        // never gets executed...
        System.out.println("DEBUG: Commit, txid=" + txid);
    }
}

工厂：

public static class ExampleStaticStateFactory implements StateFactory {
    @Override
    public State makeState(Map conf, IMetricsContext metrics, int partitionIndex, int numPartitions) {
        return new ExampleStaticState();
    }
}

一个简单的psvm（又名public static void main）：

public static void main(String... args) {
    TridentTopology tridentTopology = new TridentTopology();
    FeederBatchSpout spout = new FeederBatchSpout(Arrays.asList(new String[]{
            "foo"
    }));
    TridentState state = tridentTopology.newStaticState(new ExampleStaticStateFactory());
    tridentTopology
            .newStream("spout", spout)
            .stateQuery(state, new Fields("foo"), new MapGet(), new Fields("bar"))
            .each(new Fields("foo", "bar"), new Debug())
            ;

    Config conf = new Config();
    conf.setNumWorkers(6);

    LocalCluster localCluster = new LocalCluster();
    localCluster.submitTopology("tridentTopology", conf, tridentTopology.build());

    spout.feed(Arrays.asList(new Values[]{
            new Values("tuple-00"),
            new Values("tuple-01"),
            new Values("tuple-02"),
            new Values("tuple-03")
    }));

    localCluster.shutdown();
}

最后，输出：

DEBUG: MultiGet, keys is [[tuple-00], [tuple-01], [tuple-02], [tuple-03]]
DEBUG: [tuple-00, Trident]
DEBUG: [tuple-01, definitely]
DEBUG: [tuple-02, lacks]
DEBUG: [tuple-03, documentation]

你知道，stateQuery（）从输入批处理获取值并将它们映射到数据存储中的值。

潜水更深一点，您可以查看MapGet类（其实例用于在拓扑中查询的人）的来源，并在那里找到以下内容：

public class MapGet extends BaseQueryFunction<ReadOnlyMapState, Object> {
    @Override
    public List<Object> batchRetrieve(ReadOnlyMapState map, List<TridentTuple> keys) {
        return map.multiGet((List) keys);
    }    

    @Override
    public void execute(TridentTuple tuple, Object result, TridentCollector collector) {
        collector.emit(new Values(result));
    }    
}

因此，它只需调用multiGet()实现的ReadOnlyMapState方法，然后发出数据存储中找到的值，将它们添加到已存在的元组中。你可以（虽然它可能不是最好的事情）创建自己的BaseQueryFunction<ReadOnlyMapState, Object>实现，做一些更复杂的事情。

Answer 2

关于三叉戟状态on the storm wiki的良好文档。对您的问题的简单回答是urlToTweeters是一个可以查询的状态对象。我假设上面的陈述来自trident tutorial，转载如下：

TridentState urlToTweeters = topology.newStaticState(getUrlToTweetersState());
TridentState tweetersToFollowers = topology.newStaticState(getTweeterToFollowersState());
topology.newDRPCStream("reach")
  .stateQuery(urlToTweeters, new Fields("args"), new MapGet(), new Fields("tweeters")).each(new Fields("tweeters"), new ExpandList(), new Fields("tweeter"))
  /* At this point we have the tweeters for each url passed in args */
  .shuffle()        
  .stateQuery(tweetersToFollowers, new Fields("tweeter"), new MapGet(), new Fields("followers"))
  .parallelismHint(200)
  .each(new Fields("followers"), new ExpandList(), new Fields("follower"))
  .groupBy(new Fields("follower"))
  .aggregate(new One(), new Fields("one"))
  .parallelismHint(20)
  .aggregate(new Count(), new Fields("reach"));

在此示例中，urlToTweeters将存储URL到Tweeters的映射，并且在下一行（以URL作为其参数）定义的DRPC reach查询最终将产生范围。但在途中（标有内联评论），您会看到每个网址的推文流，即urlToTweeters上的查询结果。

什么是风暴中的三叉戟状态？

2 个答案: