public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("Example").setMaster("local[2]");
// Create a StreamingContext with a 1-second batch size from a SparkConf
JavaStreamingContext jssc =
new JavaStreamingContext(
conf, Durations.seconds(10)); // Create a DStream from all the input on port 7777
JavaDStream<String> lines = jssc.socketTextStream("localhost", 7777);
// Filter our DStream for lines with "error"
// Split up into words.
final JavaDStream<String> wordDStream =
lines.flatMap(
new FlatMapFunction<String, String>() {
public Iterable<String> call(String x) {
return Arrays.asList(x.split(" "));
}
});
final JavaPairDStream<String, Integer> wordPairDStream =
wordDStream.mapToPair(
new PairFunction<String, String, Integer>() {
@Override
public Tuple2<String, Integer> call(String s) throws Exception {
return new Tuple2<String, Integer>(s, 1);
}
});
final JavaPairDStream<String, Integer> totalWordPairDStream =
wordPairDStream.reduceByKeyAndWindow(
new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer a, Integer b) throws Exception {
return a + b;
}
},
Durations.seconds(30),
Durations.seconds(20));
// totalWordPairDStream.foreach(new Function2<JavaPairRDD<String, Integer>, Time, Void>()
// {
// @Override
// public Void call(JavaPairRDD<String, Integer> wordPairRDD, Time time) throws
// Exception {
//
// final List<Tuple2<String, Integer>> collect = wordPairRDD.collect();
// for (Tuple2<String, Integer> t : collect) {
// System.out.println("the value is t" + t._1() + "," + t._2());
// }
//
// return null;
// }
// });
totalWordPairDStream.print();
// Start our streaming context and wait for it to "finish"
jssc.start();
// Wait for the job to finish
jssc.awaitTermination();
}
public static void main(String[] args) {
SparkConf conf =
new SparkConf()
.setMaster("local[4]")
.setAppName("SparkStreamingPullDataFromFlume for Java");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(30));
// JavaReceiverInputDStream<SparkFlumeEvent> lines = FlumeUtils.createStream(jsc,"master1",
// 9999); flume push data to Spark Streaming
JavaReceiverInputDStream<SparkFlumeEvent> lines =
FlumeUtils.createPollingStream(
jsc, "master1", 9999); // Spark Streaming pull data from flume
JavaDStream<String> words =
lines.flatMap(
new FlatMapFunction<SparkFlumeEvent, String>() {
private static final long serialVersionUID = 1L;
@Override
public Iterable<String> call(SparkFlumeEvent event) throws Exception {
String line = new String(event.event().getBody().array());
return Arrays.asList(line.split(" "));
}
});
JavaPairDStream<String, Integer> pairs =
words.mapToPair(
new PairFunction<String, String, Integer>() {
private static final long serialVersionUID = 1L;
@Override
public Tuple2<String, Integer> call(String word) throws Exception {
return new Tuple2<String, Integer>(word, 1);
}
});
JavaPairDStream<String, Integer> wordsCount =
pairs.reduceByKey(
new Function2<
Integer, Integer, Integer>() { // 对相同的Key，进行Value的累计（包括Local和Reducer级别同时Reduce）
private static final long serialVersionUID = 1L;
@Override
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
wordsCount.print();
jsc.start();
jsc.awaitTermination();
jsc.close();
}
public static void main(String[] args) throws Exception {
if (args.length < 1) {
System.err.println("Usage: JavaQueueStream <master>");
System.exit(1);
}
StreamingExamples.setStreamingLogLevels();
// Create the context
JavaStreamingContext ssc =
new JavaStreamingContext(
args[0],
"QueueStream",
new Duration(1000),
System.getenv("SPARK_HOME"),
JavaStreamingContext.jarOfClass(JavaQueueStream.class));
// Create the queue through which RDDs can be pushed to
// a QueueInputDStream
Queue<JavaRDD<Integer>> rddQueue = new LinkedList<JavaRDD<Integer>>();
// Create and push some RDDs into the queue
List<Integer> list = Lists.newArrayList();
for (int i = 0; i < 1000; i++) {
list.add(i);
}
for (int i = 0; i < 30; i++) {
rddQueue.add(ssc.sparkContext().parallelize(list));
}
// Create the QueueInputDStream and use it do some processing
JavaDStream<Integer> inputStream = ssc.queueStream(rddQueue);
JavaPairDStream<Integer, Integer> mappedStream =
inputStream.mapToPair(
new PairFunction<Integer, Integer, Integer>() {
@Override
public Tuple2<Integer, Integer> call(Integer i) {
return new Tuple2<Integer, Integer>(i % 10, 1);
}
});
JavaPairDStream<Integer, Integer> reducedStream =
mappedStream.reduceByKey(
new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer i1, Integer i2) {
return i1 + i2;
}
});
reducedStream.print();
ssc.start();
ssc.awaitTermination();
}
public static void main(String[] args) {
// Create a Spark Context.
SparkConf conf = new SparkConf().setAppName("Activity").set("spark.eventLog.enabled", "true");
;
JavaSparkContext sc = new JavaSparkContext(conf);
JavaStreamingContext jssc = new JavaStreamingContext(sc, STREAM_INTERVAL);
String TOPIC = "activityevent";
String zkQuorum = "localhost:2181";
String group = "1";
Map<String, Integer> topicMap = new HashMap<String, Integer>();
topicMap.put(TOPIC, 1);
JavaPairReceiverInputDStream<String, String> messages =
KafkaUtils.createStream(jssc, zkQuorum, group, topicMap);
// messages.print();
JavaDStream<String> activitydatastream =
messages.map(
new Function<Tuple2<String, String>, String>() {
@Override
public String call(Tuple2<String, String> tuple2) {
return tuple2._2();
}
});
final Long teamWindowDurationMs = Durations.minutes(1).milliseconds();
JavaDStream<Activity> ActivityEntryDStream = activitydatastream.map(Activity::parseFromLine);
JavaPairDStream<WithTimestamp<String>, Double> ActivityWindowDStream =
ActivityEntryDStream.mapToPair(
windows ->
new Tuple2<>(
WithTimestamp.create(
windows.getActivity(),
// Apply Fixed Window by rounding the timestamp down to the nearest
// multiple of the window size
(convertMillsecs(windows.getTimestamp()) / teamWindowDurationMs)
* teamWindowDurationMs),
windows.getXaxis()))
.reduceByKey(SUM_REDUCER);
ActivityWindowDStream.print();
jssc.start();
jssc.awaitTermination();
// jssc.close();
sc.stop();
sc.close();
}
public static void main(String[] args) throws Exception {
if (args.length < 2) {
System.err.println(
"Usage: JavaDirectKafkaWordCount <brokers> <topics>\n"
+ " <brokers> is a list of one or more Kafka brokers\n"
+ " <topics> is a list of one or more kafka topics to consume from\n\n");
System.exit(1);
}
String brokers = args[0];
String topics = args[1];
// Create context with a 2 seconds batch interval
SparkConf sparkConf = new SparkConf().setAppName("JavaDirectKafkaWordCount");
JavaStreamingContext jssc = new JavaStreamingContext(sparkConf, Durations.seconds(2));
Set<String> topicsSet = new HashSet<>(Arrays.asList(topics.split(",")));
Map<String, String> kafkaParams = new HashMap<>();
kafkaParams.put("metadata.broker.list", brokers);
// Create direct kafka stream with brokers and topics
JavaPairInputDStream<String, String> messages =
KafkaUtils.createDirectStream(
jssc,
String.class,
String.class,
StringDecoder.class,
StringDecoder.class,
kafkaParams,
topicsSet);
// Get the lines, split them into words, count the words and print
JavaDStream<String> lines =
messages.map(
new Function<Tuple2<String, String>, String>() {
@Override
public String call(Tuple2<String, String> tuple2) {
return tuple2._2();
}
});
JavaDStream<String> words =
lines.flatMap(
new FlatMapFunction<String, String>() {
@Override
public Iterable<String> call(String x) {
return Arrays.asList(SPACE.split(x));
}
});
JavaPairDStream<String, Integer> wordCounts =
words
.mapToPair(
new PairFunction<String, String, Integer>() {
@Override
public Tuple2<String, Integer> call(String s) {
return new Tuple2<>(s, 1);
}
})
.reduceByKey(
new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer i1, Integer i2) {
return i1 + i2;
}
});
wordCounts.print();
// Start the computation
jssc.start();
jssc.awaitTermination();
}
public static void main(String[] args) {
String master = System.getenv("MASTER");
if (master == null) {
master = "local[2]";
}
SparkConf conf = new SparkConf().setAppName("Voter Application").setMaster(master);
Logger.getLogger("org").setLevel(Level.ERROR);
Logger.getLogger("akka").setLevel(Level.ERROR);
final Long batch_duration = Long.valueOf(args[0]);
JavaStreamingContext jssc =
new JavaStreamingContext(conf, new Duration(Integer.valueOf(args[0])));
jssc.checkpoint(".");
JavaReceiverInputDStream<String> votes = jssc.receiverStream(new Voter("localhost", 6789));
// transform text line stream to PhoneCall stream
JavaDStream<PhoneCall> phoneCalls =
votes.map(
new Function<String, PhoneCall>() {
public PhoneCall call(String s) {
return getPhoneCall(s);
}
});
JavaDStream<Long> counts = votes.count();
counts.print();
// create updateFunction which is used to update the total call count for each phone number
Function2<List<Integer>, Optional<Integer>, Optional<Integer>> updateFunction =
new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {
public Optional<Integer> call(List<Integer> values, Optional<Integer> state) {
// add the new values with the previous running count to get the
// new count
Integer sum = 0;
for (Integer i : values) {
sum += i;
}
Integer newSum = sum + state.or(0);
return Optional.of(newSum);
}
};
//
JavaPairDStream<Long, Integer> calls =
phoneCalls.mapToPair(
new PairFunction<PhoneCall, Long, Integer>() {
public Tuple2<Long, Integer> call(PhoneCall x) {
return new Tuple2<Long, Integer>(x.phoneNumber, 1);
}
});
// generate the accumulated count for phone numbers
final JavaPairDStream<Long, Integer> callNumberCounts = calls.updateStateByKey(updateFunction);
// callNumberCounts.print();
JavaPairDStream<Long, PhoneCall> pairVotes =
phoneCalls.mapToPair(
new PairFunction<PhoneCall, Long, PhoneCall>() {
public Tuple2<Long, PhoneCall> call(PhoneCall call) throws Exception {
return new Tuple2<Long, PhoneCall>(call.voteId, call);
}
});
// generate the validate phone numbers, which is still allowed to send vote
JavaPairDStream<Long, Integer> allowedCalls =
callNumberCounts.filter(
new Function<Tuple2<Long, Integer>, Boolean>() {
public Boolean call(Tuple2<Long, Integer> v1) throws Exception {
if (v1._2() > Voter.MAX_VOTES) return false;
return true;
}
});
// allowedCalls.print();
// get validate contestant phone calls
JavaDStream<PhoneCall> validContestantPhoneCalls =
phoneCalls.filter(
new Function<PhoneCall, Boolean>() {
public Boolean call(PhoneCall call) {
if (call.contestantNumber > Voter.NUM_CONTESTANTS) return false;
return true;
}
});
JavaPairDStream<Long, PhoneCall> anotherTemporyPhoneCalls =
validContestantPhoneCalls.mapToPair(
new PairFunction<PhoneCall, Long, PhoneCall>() {
public Tuple2<Long, PhoneCall> call(PhoneCall x) {
return new Tuple2<Long, PhoneCall>(x.phoneNumber, x);
}
});
// get validate phone call records
JavaPairDStream<Long, Tuple2<PhoneCall, Integer>> validatePhoneCalls =
anotherTemporyPhoneCalls.join(allowedCalls);
// validatePhoneCalls.print();
JavaDStream<PhoneCall> validateCalls =
validatePhoneCalls.transform(
new Function<JavaPairRDD<Long, Tuple2<PhoneCall, Integer>>, JavaRDD<PhoneCall>>() {
public JavaRDD<PhoneCall> call(JavaPairRDD<Long, Tuple2<PhoneCall, Integer>> v1)
throws Exception {
JavaRDD<PhoneCall> item =
v1.map(
new Function<Tuple2<Long, Tuple2<PhoneCall, Integer>>, PhoneCall>() {
public PhoneCall call(Tuple2<Long, Tuple2<PhoneCall, Integer>> validItem)
throws Exception {
return validItem._2()._1();
}
});
return item;
}
});
// validateCalls.print();
// save all votes with redis
validateCalls.foreachRDD(
new Function<JavaRDD<PhoneCall>, Void>() {
public Void call(JavaRDD<PhoneCall> rdd) throws Exception {
rdd.foreach(
new VoidFunction<PhoneCall>() {
public void call(PhoneCall call) throws Exception {
// System.out.println(call.toString());
String key = String.valueOf(call.voteId);
String value = call.getContent();
// save <key,value> using redis
JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");
Jedis jedis = pool.getResource();
try {
jedis.set(key, value);
} finally {
if (null != jedis) {
jedis.close();
}
}
/// ... when closing your application:
pool.destroy();
}
});
return null;
}
});
// validate calls
JavaPairDStream<Integer, Integer> contestantVotes =
validateCalls.mapToPair(
new PairFunction<PhoneCall, Integer, Integer>() {
public Tuple2<Integer, Integer> call(PhoneCall x) {
return new Tuple2<Integer, Integer>(x.contestantNumber, 1);
}
});
// use window to get generate leaderboard
Integer size = Integer.valueOf(args[1]);
Integer slide = Integer.valueOf(args[2]);
JavaDStream<PhoneCall> windowCalls =
validateCalls.window(new Duration(size), new Duration(slide));
// windowCalls.print();
// generate window contestant count
JavaPairDStream<Integer, Integer> windowContestantNums =
windowCalls.mapToPair(
new PairFunction<PhoneCall, Integer, Integer>() {
public Tuple2<Integer, Integer> call(PhoneCall x) {
return new Tuple2<Integer, Integer>(x.contestantNumber, 1);
}
});
JavaPairDStream<Integer, Integer> windContestantCounts =
windowContestantNums.reduceByKey(
new Function2<Integer, Integer, Integer>() {
public Integer call(Integer i1, Integer i2) throws Exception {
return i1 + i2;
}
});
windContestantCounts.print();
// generate the accumulated count for contestants
JavaPairDStream<Integer, Integer> totalContestantCounts =
contestantVotes.updateStateByKey(updateFunction);
// used for sorting
PairFunction<Tuple2<Integer, Integer>, Integer, Integer> swapFunction =
new PairFunction<Tuple2<Integer, Integer>, Integer, Integer>() {
public Tuple2<Integer, Integer> call(Tuple2<Integer, Integer> in) {
return in.swap();
}
};
JavaPairDStream<Integer, Integer> swappedTotalContestantCounts =
totalContestantCounts.mapToPair(swapFunction);
JavaPairDStream<Integer, Integer> sortedTotalContestantCounts =
swappedTotalContestantCounts.transformToPair(
new Function<JavaPairRDD<Integer, Integer>, JavaPairRDD<Integer, Integer>>() {
public JavaPairRDD<Integer, Integer> call(JavaPairRDD<Integer, Integer> in)
throws Exception {
return in.sortByKey(false);
}
});
sortedTotalContestantCounts.print();
// make some statistics
phoneCalls.foreachRDD(
new Function<JavaRDD<PhoneCall>, Void>() {
public Void call(JavaRDD<PhoneCall> rdd) throws Exception {
Long count = rdd.count();
// System.out.println( "count : " + count );
Double throughput = (count.doubleValue() * 1000 / batch_duration.doubleValue());
System.out.println("Current rate = " + throughput + " records / second");
XMemcachedClientBuilder builder =
new XMemcachedClientBuilder(AddrUtil.getAddresses("localhost:11211"));
XMemcachedClient client = (XMemcachedClient) builder.build();
client.setPrimitiveAsString(true);
Long currentTimeStamp = System.currentTimeMillis();
// System.out.println("End time: " + currentTimeStamp);
client.add(currentTimeStamp.toString(), 0, throughput);
return null;
}
});
jssc.start(); // Start the computation
jssc.awaitTermination(); // Wait for the computation to terminate
}
public static void main(String[] args) {
// Create the context with a 10 second batch size
SparkConf sparkConf = new SparkConf().setAppName("Assignment");
JavaStreamingContext ssc = new JavaStreamingContext(sparkConf, new Duration(10000));
// Create a JavaReceiverInputDStream on target ip:port and count the
// words in input stream of \n delimited text (eg. generated by 'nc')
// Note that no duplication in storage level only for running locally.
// Replication necessary in distributed scenario for fault tolerance.
JavaReceiverInputDStream<String> lines =
ssc.socketTextStream(
"localhost", Integer.parseInt("9999"), StorageLevels.MEMORY_AND_DISK_SER);
JavaDStream<String> words =
lines.flatMap(
new FlatMapFunction<String, String>() {
@Override
public Iterable<String> call(String x) {
List<String> allMatches = new ArrayList<String>();
Matcher matcher = SPACE.matcher(x);
while (matcher.find()) {
allMatches.add(matcher.group().toLowerCase());
}
return Lists.newArrayList(allMatches.toArray(new String[0]));
}
});
JavaPairDStream<String, Integer> wordCounts =
words.mapToPair(
new PairFunction<String, String, Integer>() {
@Override
public Tuple2<String, Integer> call(String s) {
return new Tuple2<String, Integer>(s, 1);
}
});
// Reduce function adding two integers, defined separately for clarity
Function2<Integer, Integer, Integer> reduceFunc =
new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer i1, Integer i2) throws Exception {
return i1 + i2;
}
};
JavaPairDStream<String, Integer> windowedWordCounts =
wordCounts.reduceByKeyAndWindow(reduceFunc, new Duration(30000), new Duration(10000));
windowedWordCounts.print();
ssc.start();
ssc.awaitTermination();
}
public static void main(String[] args) {
if (args.length < 4) {
System.err.println("Usage: JavaKafkaWordCount <zkQuorum> <group> <topics> <numThreads>");
System.exit(1);
}
StreamingExamples.setStreamingLogLevels();
// SparkConf sparkConf = new SparkConf().setAppName("JavaKafkaWordCount");
// sparkConf.setMaster("spark://60f81dc6426c:7077");
// SparkConf sparkConf = new
// SparkConf().setAppName("JavaKafkaWordCount").setMaster("spark://60f81dc6426c:7077");
// Create the context with a 1 second batch size
JavaStreamingContext jssc =
new JavaStreamingContext("local[4]", "JavaKafkaWordCount", new Duration(2000));
int numThreads = Integer.parseInt(args[3]);
Logger.getLogger("org").setLevel(Level.OFF);
Logger.getLogger("akka").setLevel(Level.OFF);
Map<String, Integer> topicMap = new HashMap<String, Integer>();
String[] topics = args[2].split(",");
for (String topic : topics) {
topicMap.put(topic, numThreads);
}
/* for(String t: topic)
{
topicMap.put(t, new Integer(3));
}*/
// NotSerializable notSerializable = new NotSerializable();
// JavaRDD<String> rdd = sc.textFile("/tmp/myfile");
// rdd.map(s -> notSerializable.doSomething(s)).collect();
JavaPairReceiverInputDStream<String, String> messages =
KafkaUtils.createStream(jssc, args[0], args[1], topicMap);
// JavaPairReceiverInputDStream<String, String> kafkaStream =
// KafkaUtils.createStream(jssc, "localhost:2181","streamingContext",
// topicMap);
System.out.println("Connection !!!!");
/*JavaDStream<String> data = messages.map(new Function<Tuple2<String, String>, String>()
{
public String call(Tuple2<String, String> message)
{
return message._2();
}
}
);*/
JavaDStream<String> lines =
messages.map(
new Function<Tuple2<String, String>, String>() {
@Override
public String call(Tuple2<String, String> tuple2) {
return tuple2._2();
}
});
JavaDStream<String> words =
lines.flatMap(
new FlatMapFunction<String, String>() {
@Override
public Iterable<String> call(String x) {
return Lists.newArrayList(SPACE.split(x));
}
});
JavaPairDStream<String, Integer> wordCounts =
words
.mapToPair(
new PairFunction<String, String, Integer>() {
@Override
public Tuple2<String, Integer> call(String s) {
return new Tuple2<String, Integer>(s, 1);
}
})
.reduceByKey(
new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer i1, Integer i2) {
return i1 + i2;
}
});
wordCounts.print();
jssc.start();
jssc.awaitTermination();
}