Java Code Examples for org.apache.storm.topology.BasicOutputCollector#emit()

@Override
public void execute(Tuple tuple, BasicOutputCollector basicOutputCollector) {
    int operation = tuple.getIntegerByField("operation");
    if(operation > 0 ) {
        basicOutputCollector.emit(tuple.getValues());
    }
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    String word = tuple.getString(0);
    Integer count = counts.get(word);
    if (count == null) {
        count = 0;
    }
    count++;
    counts.put(word, count);
    collector.emit(new Values(word, count));
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    String sentence = tuple.getString(0);
    for (String word : sentence.split("\\s+")) {
        collector.emit(new Values(word, 1));
    }
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    String word = tuple.getString(0);
    Integer count = counts.get(word);
    if (count == null) {
        count = 0;
    }
    count++;
    counts.put(word, count);
    collector.emit(new Values(word, count));
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    String sentence = tuple.getString(0);
    for (String word : sentence.split("\\s+")) {
        collector.emit(new Values(word, 1));
    }
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    Object id = tuple.getValue(0);
    String tweeter = tuple.getString(1);
    List<String> followers = FOLLOWERS_DB.get(tweeter);
    if (followers != null) {
        for (String follower : followers) {
            collector.emit(new Values(id, follower));
        }
    }
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    String apacheLogLine = tuple.getStringByField(readFieldName);
    try {
        List<Object> out = new ArrayList<>();
        out.add(parser.parse(apacheLogLine));
        collector.emit(out);
    } catch (MissingDissectorsException
            |InvalidDissectorException
            |DissectionFailure e) {
        e.printStackTrace();
    }
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    String word = tuple.getString(0);
    Integer count = counts.get(word);
    if (count == null) {
        count = 0;
    }
    count++;
    counts.put(word, count);
    collector.emit(new Values(word, count));
}
 

@Override
public void execute(Tuple input, BasicOutputCollector collector) {
    byte[] binary = input.getBinary(0);
    String line = new String(binary);
    String[] fields = line.split("\t");

    if(fields == null || fields.length < 10) {
        return;
    }

    // 获取ip和mid
    String ip = fields[1];
    String mid = fields[2];

    // 根据ip获取其所属地（省份）
    String province = null;
    if (ip != null) {
        Jedis jedis = JedisUtil.getJedis();
        province = jedis.hget("ip_info_en", ip);
        // 需要释放jedis的资源，否则会报can not get resource from the pool
        JedisUtil.returnJedis(jedis);
    }

    // 发送数据到下一个bolt，只发送实现业务功能需要的province和mid
    collector.emit(new Values(province, mid));

}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
  String word = tuple.getString(0);
  Integer count = counts.get(word);
  if (count == null) {
    count = 0;
  }
  count++;
  counts.put(word, count);
  collector.emit(new Values(word, count));
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
  String sentence = tuple.getString(0);
  for (String word : sentence.split("\\s+")) {
    collector.emit(new Values(word, 1));
  }
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector outputCollector)
{
  int hash = tuple.getIntegerByField(StormConstants.HASH_FIELD);
  json = (JSONObject) tuple.getValueByField(StormConstants.JSON_DATA_FIELD);

  try
  {
    List<BigInteger> partitions = QueryUtils.partitionDataElement(qSchema, json, embedSelector);

    logger.debug("HashSelectorsAndPartitionDataBolt processing {} outputting results - {}", json.toString(), partitions.size());

    // splitPartitions determines whether each partition piece is sent individually or the full Array is sent together.
    // Since processing in the follow-on bolt (EncRowCalcBolt) is computationally expensive, current working theory is
    // that splitting them up allows for better throughput. Though maybe with better knowledge/tuning of Storm internals
    // and paramters (e.g. certain buffer sizes), it may make no difference.
    if (splitPartitions)
    {
      for (BigInteger partition : partitions)
      {
        outputCollector.emit(new Values(hash, partition));
      }
    }
    else
    {
      outputCollector.emit(new Values(hash, partitions));
    }

  } catch (Exception e)
  {
    logger.warn("Failed to partition data for record -- " + json + "\n", e);
  }
}
 

@Override
public void execute(Tuple input, BasicOutputCollector collector) {
    String sentence = input.getStringByField("value");
    for(int i=0;i<sentence.length();i++){
        char word = sentence.charAt(i);
        collector.emit(new Values(word+""));//分词emit，只有1个单词的元组Tuple
    }
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
  String sentence = tuple.getString(0);
  System.out.println("Sentence received : " + sentence);
  for (String word : sentence.split("\\s+")) {
    collector.emit(new Values(word, 1));
  }
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    String word = tuple.getString(0);
    Integer count = counts.get(word);
    if (count == null) {
        count = 0;
    }
    count++;
    counts.put(word, count);
    collector.emit(new Values(word, count));
}
 

private void emitRankings(BasicOutputCollector collector) {
    collector.emit(new Values(rankings.copy()));
    getLogger().debug("Rankings: " + rankings);
}
 

@Override
public void execute(Tuple input, BasicOutputCollector collector) {
  int number = getTupleValue(input, 0);

  if (number % 2 == 0) {
    System.out.println("Emitting to evens stream: " + number);
    collector.emit("evens", tuple(input.getValues().get(0)));

  } else {
    System.out.println("emitting to odds stream: " + number);
    collector.emit("odds", tuple(input.getValues().get(0)));
  }

  collector.emit(tuple(input.getValues().get(0)));



}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    String arg = tuple.getString(0);
    Object retInfo = tuple.getValue(1);
    collector.emit(new Values(arg + "!!!", retInfo));
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
    String input = tuple.getString(1);
    collector.emit(new Values(tuple.getValue(0), input + "!"));
}
 

private void emitRankings(BasicOutputCollector collector) {
  collector.emit(new Values(rankings.copy()));
  getLogger().debug("Rankings: " + rankings);
}