Storm入门（七）可靠性机制代码示例
一、关联代码
使用maven，代码如下。
pom.xml 参考 http://www.cnblogs.com/hd3013779515/p/6970551.html
MessageTopology.java
package cn.ljh.storm.reliability;
import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.topology.TopologyBuilder;
import org.apache.storm.utils.Utils;
public class MessageTopology {
public static void main(String[] args) throws Exception {
TopologyBuilder builder = new TopologyBuilder();
builder.setSpout("MessageSpout", new MessageSpout(), 1);
builder.setBolt("SpilterBolt", new SpliterBolt(), 5).shuffleGrouping("MessageSpout");
builder.setBolt("WriterBolt", new WriterBolt(), 1).shuffleGrouping("SpilterBolt");
Config conf = new Config();
conf.setDebug(false);
LocalCluster cluster = new LocalCluster();
cluster.submitTopology("messagetest", conf, builder.createTopology());
Utils.sleep(20000);
cluster.killTopology("messagetest");
cluster.shutdown();
}
}
MessageSpou.java
package cn.ljh.storm.reliability;
import org.apache.storm.topology.OutputFieldsDeclarer;
import java.util.Map;
import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.base.BaseRichSpout;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Values;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MessageSpout extends BaseRichSpout {
public static Logger LOG = LoggerFactory.getLogger(MessageSpout.class);
private SpoutOutputCollector _collector;
private int index = 0;
private String[] subjects = new String[]{
"Java,Python",
"Storm,Kafka",
"Spring,Solr",
"Zookeeper,FastDFS",
"Dubbox,Redis"
};
public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
_collector = collector;
}
public void nextTuple() {
if(index < subjects.length){
String sub = subjects[index];
//使用messageid参数，使可靠性机制生效
_collector.emit(new Values(sub), index);
index++;
}
}
public void declareOutputFields(OutputFieldsDeclarer declarer) {
declarer.declare(new Fields("subjects"));
}
@Override
public void ack(Object msgId) {
LOG.info("【消息发送成功！】(msgId = " + msgId + ")");
}
@Override
public void fail(Object msgId) {
LOG.info("【消息发送失败！】(msgId = " + msgId + ")");
LOG.info("【重发进行中。。。】");
_collector.emit(new Values(subjects[(Integer)msgId]), msgId);
LOG.info("【重发成功！】");
}
}
SpliterBolt.java
package cn.ljh.storm.reliability;
import java.util.Map;
import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseRichBolt;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;
public class SpliterBolt extends BaseRichBolt {
OutputCollector _collector;
private boolean flag = false;
public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
_collector = collector;
}
public void execute(Tuple tuple) {
try{
String subjects = tuple.getStringByField("subjects");
// if(!flag && subjects.equals("Spring,Solr")){
// flag = true;
// int a = 1/0;
// }
String[] words = subjects.split(",");
for(String word : words){
//注意：要携带tuple对象，用于处理异常时重发策略。
_collector.emit(tuple, new Values(word));
}
//对tuple进行ack
_collector.ack(tuple);
}catch(Exception ex){
ex.printStackTrace();
//对tuple进行fail，使重发。
_collector.fail(tuple);
}
}
public void declareOutputFields(OutputFieldsDeclarer declarer) {
declarer.declare(new Fields("word"));
}
}
WriterBolt.java
package cn.ljh.storm.reliability;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Map;
import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseRichBolt;
import org.apache.storm.tuple.Tuple;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class WriterBolt extends BaseRichBolt {
private static Logger LOG = LoggerFactory.getLogger(WriterBolt.class);
OutputCollector _collector;
private FileWriter fileWriter;
private boolean flag = false;
public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
_collector = collector;
if(fileWriter == null){
try {
fileWriter = new FileWriter("D:\\test\\"+"words.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void execute(Tuple tuple) {
try {
String word = tuple.getStringByField("word");
// if(!flag && word.equals("Kafka")){
// flag = true;
// int a = 1/0;
// }
fileWriter.write(word + "\r\n");
fileWriter.flush();
} catch (Exception e) {
e.printStackTrace();
//对tuple进行fail，使重发。
_collector.fail(tuple);
}
//对tuple进行ack
_collector.ack(tuple);
}
public void declareOutputFields(OutputFieldsDeclarer declarer) {
}
}
二、执行效果
1、代码要点说明
MessageSpout.java
（1）发射tuple时要设置messageId来使可靠性机制生效
_collector.emit(new Values(sub), index);
（2）重写ack和fail方法
@Override
public void ack(Object msgId) {
LOG.info("【消息发送成功！】(msgId = " + msgId + ")");
}
@Override
public void fail(Object msgId) {
LOG.info("【消息发送失败！】(msgId = " + msgId + ")");
LOG.info("【重发进行中。。。】");
_collector.emit(new Values(subjects[(Integer)msgId]), msgId);
LOG.info("【重发成功！】");
}
SpliterBolt.java
（1）发射新tuple时设置输入tuple参数，以使新tuple和输入tuple为一个整体
_collector.emit(tuple, new Values(word));
（2）完成处理后进行ack，失败时进行fail
_collector.ack(tuple);
_collector.fail(tuple);
WriterBolt.java
（1）完成处理后进行ack，失败时进行fail
_collector.ack(tuple);
_collector.fail(tuple);
2、正常处理结果
3、放开SpliterBolt 的错误代码
结果显示能够正确的重发。
4、放开SpliterBolt 的错误代码
能够正确进行重发，但是文件中storm字符串出现了两次。
5、总结
通过以上测试，如果在第一个bolt处理时出现异常，可以让整个数据进行重发，如果第二个bolt处理时出现异常，也可以让整个数据进行重发，但是同时出现了重复处理的事务性问题，需要进行特殊的处理。
（1）如果数据入库的话，可以把messageId也进行入库保存。此messageId可以用来判断是否重复处理。
（2）事务性tuple尽量不要拆分。
（3）使用storm的Trident框架。
