Storm 实验：广告实时统计

最新推荐文章于 2023-07-03 03:33:41 发布
最新推荐文章于 2023-07-03 03:33:41 发布
阅读量407 收藏 2
点赞数 1
分类专栏： 大数据 Application 文章标签： storm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44992559/article/details/115498481
版权

一、实验描述

  实验数据通过java代码生成，每条数据的格式如下：
     时间戳 省份 城市 用户ID 广告ID
  实验主要完成三个需求，即
(1) 实现实时的动态黑名单机制: 把每天对某个广告点击超过100次的用户拉黑，黑名单用户ID存入Mysql
(2) 实时统计每天各省市各广告的点击总流量，并将其存入Mysql
(3) 最近1分钟广告总点击量，每10s计算一次，并通过html展示

二、实验代码

  • 数据模拟生成
package cn.edu.neu.advertise;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.*;

/**
 * @author 32098
 */
public class KafkaDataMocker {
    public static List<String> mockData() throws InterruptedException {
        List<String> list = new ArrayList<>();

        List<String> provinceList = Arrays.asList("江西", "辽宁", "浙江", "广东", "湖南", "湖北", "吉林", "黑龙江", "福建");
        List<String> cityList = Arrays.asList("南昌","沈阳","杭州","广州","长沙","武汉","长春","哈尔滨","厦门");

        int len = provinceList.size();
        Random r = new Random();
        for(int i=0; i<r.nextInt(100); i++){
            Thread.sleep(10);
            int idx = r.nextInt(len);
            String province = provinceList.get(idx);
            String city = cityList.get(idx);
            String uid = "U" + r.nextInt(10);
            String aid = "Ad_" + r.nextInt(20);
            String record = System.currentTimeMillis() + " " + province + " " + city + " " + uid + " " + aid;
            list.add(record);
        }
        return list;
    }

    public static void main(String[] args) throws InterruptedException {
        HashMap<String, Object> pros = new HashMap<>(3);
        pros.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "master:9092");
        pros.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        pros.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> producer = new KafkaProducer<>(pros);
        int ite = 0;
        while (true){
            ite = ite + 1;
            System.out.println("################"+ ite +"################");
            List<String> records = mockData();
            records.forEach(
                    elem -> {
                        System.out.println(elem);
                        ProducerRecord<String, String> record = new ProducerRecord<>("advertise-user", null, elem);
                        producer.send(record);
                    }
            );
            Thread.sleep(1000);
        }
    }
}

/*
启动Kafka服务器：kafka-server-start.sh config/server.properties
启动Kafka消费者(console)：kafka-console-consumer.sh --bootstrap-server master:9092 --topic storm-topic --from-beginning
 */
  • MysqlUtil
package cn.edu.neu.advertise;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * @author 32098
 */
public class MysqlUtil {
    public static Connection getConnection(){
        String url = "jdbc:mysql://master:3306/user_advertise?useUnicode=true&characterEncoding=utf-8";
        String user = "root";
        String password = "Hive@2020";
        try {
            return DriverManager.getConnection(url, user, password);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }
}
  • 实时的动态黑名单机制
package cn.edu.neu.advertise;

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;

import java.util.Map;

/**
 * @author 32098
 * 实现实时的动态黑名单机制: 把每天对某个广告点击超过100次的用户拉黑，黑名单用户ID存入Mysql
 */
public class BlackListBoltA extends BaseRichBolt {
    private OutputCollector collector;

    @Override
    public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
    }

    @Override
    public void execute(Tuple input) {
        try {
            String value = input.getStringByField("value");
            // 必须ack，否则会重复消费kafka中的消息
            collector.ack(input);
            System.out.println("Received from kafka: "+ value);
            String[] strs = value.split(" ");
            collector.emit(new Values(strs[0], strs[3], strs[4]));
        }catch (Exception e){
            e.printStackTrace();
            collector.fail(input);
        }
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("time_stamp", "uid", "aid"));
    }
}

package cn.edu.neu.advertise;

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 java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;

/**
 * @author 32098
 * 实现实时的动态黑名单机制: 把每天对某个广告点击超过100次的用户拉黑，黑名单用户ID存入Mysql
 */
public class BlackListBoltB extends BaseRichBolt {
    private OutputCollector collector;

    @Override
    public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
        this.collector = outputCollector;
    }

    @Override
    public void execute(Tuple tuple) {
        String ts = tuple.getStringByField("time_stamp");
        String uid = tuple.getStringByField("uid");
        String aid = tuple.getStringByField("aid");
        String value = "1";
        collector.ack(tuple);

        try {
            Connection conn = MysqlUtil.getConnection();
            assert conn != null;
            PreparedStatement ps = conn.prepareStatement("select uid from black_list where uid=?");
            ps.setString(1, uid);
            ResultSet rs = ps.executeQuery();
            if(!rs.next()){
                String day = new SimpleDateFormat("yyyy-MM-dd").format(new Date(Long.parseLong(ts.trim())));
                ps = conn.prepareStatement(
                        "select * from user_advertise where day=? and uid=? and aid=?"
                );
                ps.setString(1, day);
                ps.setString(2, uid);
                ps.setString(3, aid);
                rs = ps.executeQuery();
                if(rs.next()){
                    PreparedStatement psA = conn.prepareStatement(
                            "update user_advertise set count = count + ? where day=? and uid=? and aid=?"
                    );
                    // psA.setInt(1, 1);
                    psA.setString(1, value);
                    psA.setString(2, day);
                    psA.setString(3, uid);
                    psA.setString(4, aid);
                    psA.executeUpdate();
                    psA.close();
                }else{
                    PreparedStatement psB = conn.prepareStatement("insert into user_advertise(day,uid,aid,count) values (?,?,?,?)");
                    psB.setString(1, day);
                    psB.setString(2, uid);
                    psB.setString(3, aid);
                    psB.setString(4, value);
                    psB.executeUpdate();
                    psB.close();
                }
                ps = conn.prepareStatement(
                        "select * from user_advertise where day=? and uid=? and aid=? and count>60"
                );
                ps.setString(1, day);
                ps.setString(2, uid);
                ps.setString(3, aid);
                rs = ps.executeQuery();
                if(rs.next()){
                    PreparedStatement psC = conn.prepareStatement("insert into black_list(uid) value(?) on duplicate key update uid=?");
                    psC.setString(1, uid);
                    psC.setString(2, uid);
                    psC.executeUpdate();
                    psC.close();
                }
                ps.close();
            }
            conn.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {

    }
}


package cn.edu.neu.advertise;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.kafka.spout.KafkaSpout;
import org.apache.storm.kafka.spout.KafkaSpoutConfig;
import org.apache.storm.kafka.spout.KafkaSpoutRetryExponentialBackoff;
import org.apache.storm.kafka.spout.KafkaSpoutRetryService;
import org.apache.storm.topology.TopologyBuilder;
import org.apache.storm.tuple.Fields;

/**
 * @author 32098
 */
public class BlackListApp {
    private static final String BOOTSTRAP_SERVERS = "master:9092";
    private static final String TOPIC_NAME = "advertise-user";

    public static void main(String[] args) {

        final TopologyBuilder builder = new TopologyBuilder();
        builder.setSpout("kafka_spout", new KafkaSpout<>(getKafkaSpoutConfig()), 1);
        builder.setBolt("boltA", new BlackListBoltA(), 2).setNumTasks(2).shuffleGrouping("kafka_spout");
        builder.setBolt("boltB", new BlackListBoltB(), 2).setNumTasks(2).fieldsGrouping("boltA", new Fields("time_stamp", "uid", "aid"));

        // 如果外部传参cluster则代表线上环境启动,否则代表本地启动
        if (args.length > 0 && "cluster".equals(args[0])) {
            try {
                StormSubmitter.submitTopology("Cluster-BlackListApp", new Config(), builder.createTopology());
            } catch (AlreadyAliveException | InvalidTopologyException | AuthorizationException e) {
                e.printStackTrace();
            }
        } else {
            LocalCluster cluster = new LocalCluster();
            cluster.submitTopology("Local-BlackListApp",
                    new Config(), builder.createTopology());
        }
    }

    private static KafkaSpoutConfig<String, String> getKafkaSpoutConfig() {
        return KafkaSpoutConfig.builder(BlackListApp.BOOTSTRAP_SERVERS, BlackListApp.TOPIC_NAME)
                // 除了分组ID,以下配置都是可选的。分组ID必须指定,否则会抛出InvalidGroupIdException异常
                .setProp(ConsumerConfig.GROUP_ID_CONFIG, "kafkaSpoutTestGroup")
                // 定义重试策略
                .setRetry(getRetryService())
                // 定时提交偏移量的时间间隔,默认是15s
                .setOffsetCommitPeriodMs(10_000)
                .build();
    }

    /**
     * 定义重试策略
     * @return KafkaSpoutRetryService
     */
    private static KafkaSpoutRetryService getRetryService() {
        return new KafkaSpoutRetryExponentialBackoff(KafkaSpoutRetryExponentialBackoff.TimeInterval.microSeconds(500),
                KafkaSpoutRetryExponentialBackoff.TimeInterval.milliSeconds(2), Integer.MAX_VALUE, KafkaSpoutRetryExponentialBackoff.TimeInterval.seconds(10));
    }
}
  • 实时统计每天各省市各广告的点击总流量
package cn.edu.neu.advertise;

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;

import java.util.Map;

/**
 * @author 32098
 * 实时统计每天各省市各广告的点击总流量，并将其存入Mysql
 */
public class ClickCountBoltA extends BaseRichBolt {
    private OutputCollector collector;

    @Override
    public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
    }

    @Override
    public void execute(Tuple input) {
        try {
            String value = input.getStringByField("value");
            // 必须ack，否则会重复消费kafka中的消息
            collector.ack(input);
            System.out.println("Received from kafka: "+ value);
            String[] strs = value.split(" ");
            collector.emit(new Values(strs[0], strs[1], strs[2], strs[4]));
        }catch (Exception e){
            e.printStackTrace();
            collector.fail(input);
        }
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("time_stamp", "province", "city", "aid"));
    }
}


package cn.edu.neu.advertise;

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 java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;

/**
 * @author 32098
 */
public class ClickCountBoltB extends BaseRichBolt {
    private OutputCollector collector;

    @Override
    public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
        this.collector = outputCollector;
    }

    @Override
    public void execute(Tuple tuple) {
        String ts = tuple.getStringByField("time_stamp");
        String province = tuple.getStringByField("province");
        String city = tuple.getStringByField("city");
        String aid = tuple.getStringByField("aid");
        String value = "1";
        collector.ack(tuple);

        String day = new SimpleDateFormat("yyyy-MM-dd").format(new Date(Long.parseLong(ts.trim())));

        try {
            Connection conn = MysqlUtil.getConnection();
            assert conn != null;
            PreparedStatement ps = conn.prepareStatement(
                    "insert into province_city_advertise(day,province,city,aid,count) values (?,?,?,?,?) on duplicate key update count=count+?"
            );
            ps.setString(1, day);
            ps.setString(2, province);
            ps.setString(3, city);
            ps.setString(4, aid);
            ps.setString(5, value);
            ps.setString(6, value);
            ps.executeUpdate();
            ps.close();
            conn.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }

    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {

    }
}


package cn.edu.neu.advertise;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.kafka.spout.KafkaSpout;
import org.apache.storm.kafka.spout.KafkaSpoutConfig;
import org.apache.storm.kafka.spout.KafkaSpoutRetryExponentialBackoff;
import org.apache.storm.kafka.spout.KafkaSpoutRetryService;
import org.apache.storm.topology.TopologyBuilder;
import org.apache.storm.tuple.Fields;

/**
 * @author 32098
 */
public class ClickCountApp {
    private static final String BOOTSTRAP_SERVERS = "master:9092";
    private static final String TOPIC_NAME = "advertise-user";

    public static void main(String[] args) {

        final TopologyBuilder builder = new TopologyBuilder();
        builder.setSpout("kafka_spout", new KafkaSpout<>(getKafkaSpoutConfig()), 1);
        builder.setBolt("boltA", new ClickCountBoltA()).shuffleGrouping("kafka_spout");
        builder.setBolt("boltB", new ClickCountBoltB()).fieldsGrouping("boltA", new Fields("time_stamp", "province", "city", "aid"));

        // 如果外部传参cluster则代表线上环境启动,否则代表本地启动
        if (args.length > 0 && "cluster".equals(args[0])) {
            try {
                StormSubmitter.submitTopology("Cluster-ClickCountApp", new Config(), builder.createTopology());
            } catch (AlreadyAliveException | InvalidTopologyException | AuthorizationException e) {
                e.printStackTrace();
            }
        } else {
            LocalCluster cluster = new LocalCluster();
            cluster.submitTopology("Local-ClickCountApp",
                    new Config(), builder.createTopology());
        }
    }

    private static KafkaSpoutConfig<String, String> getKafkaSpoutConfig() {
        return KafkaSpoutConfig.builder(ClickCountApp.BOOTSTRAP_SERVERS, ClickCountApp.TOPIC_NAME)
                .setProp(ConsumerConfig.GROUP_ID_CONFIG, "kafkaSpoutTestGroup")
                .setRetry(getRetryService())
                .setOffsetCommitPeriodMs(10_000)
                .build();
    }

    /**
     * 定义重试策略
     * @return KafkaSpoutRetryService
     */
    private static KafkaSpoutRetryService getRetryService() {
        return new KafkaSpoutRetryExponentialBackoff(KafkaSpoutRetryExponentialBackoff.TimeInterval.microSeconds(500),
                KafkaSpoutRetryExponentialBackoff.TimeInterval.milliSeconds(2), Integer.MAX_VALUE, KafkaSpoutRetryExponentialBackoff.TimeInterval.seconds(10));
    }
}
  • 最近1分钟广告总点击量，每10s计算一次，并通过html展示
package cn.edu.neu.advertise;

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;

import java.util.Map;

/**
 * @author 32098
 * 最近1分钟广告总点击量,每10s计算一次
 */
public class ClickNearlyMinuteBoltA extends BaseRichBolt {
    private OutputCollector collector;

    @Override
    public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
    }

    @Override
    public void execute(Tuple input) {
        try {
            String value = input.getStringByField("value");
            // 必须ack，否则会重复消费kafka中的消息
            collector.ack(input);
            System.out.println("Received from kafka: "+ value);
            String[] strs = value.split(" ");
            collector.emit(new Values(strs[0], strs[4]));
        }catch (Exception e){
            e.printStackTrace();
            collector.fail(input);
        }
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("time_stamp", "aid"));
    }
}



package cn.edu.neu.advertise;

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.topology.base.BaseWindowedBolt;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.utils.Utils;
import org.apache.storm.windowing.TupleWindow;

import java.awt.*;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Array;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author 32098
 * 最近1分钟广告总点击量,每10s计算一次
 */
public class ClickNearlyMinuteBoltB extends BaseWindowedBolt {
    private OutputCollector collector;
    private String projectRoot;

    @Override
    public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
        this.collector = outputCollector;
        this.projectRoot = System.getProperty("user.dir");
    }

    @Override
    public void execute(TupleWindow tupleWindow) {
        Map<String, Integer> hmsClick = new TreeMap<>();

        for (Tuple tuple: tupleWindow.get()){

            String ts = tuple.getStringByField("time_stamp");
            String aid = tuple.getStringByField("aid");

            long timeStamp = Long.parseLong(ts.trim());
            String time = new SimpleDateFormat("HH:mm:ss").format(new Date(timeStamp));
            String[] hms = time.split(":");
            int s = (Integer.parseInt(hms[2])/10+1)*10;
            int m = Integer.parseInt(hms[1]);
            int h = Integer.parseInt(hms[0]);
            if(s == 60){
                m = m + 1;
                s = 0;
                if(m == 60){
                    h = h + 1;
                    if(h == 24){
                        h = 0;
                    }
                }
            }
            String hStr, mStr, sStr;
            if(h < 10){
                hStr = "0" + h;
            }else{
                hStr = String.valueOf(h);
            }
            if(m < 10){
                mStr = "0" + m;
            }else{
                mStr = String.valueOf(m);
            }
            if(s == 0){
                sStr = "00";
            }else{
                sStr = String.valueOf(s);
            }

            String hms_ = hStr+":"+mStr+":"+sStr;
            if(hmsClick.containsKey(hms_)){
                hmsClick.put(hms_, hmsClick.get(hms_)+1);
            }else{
                hmsClick.put(hms_, 1);
            }
        }
        String file = projectRoot + "/src/main/java/cn/edu/neu/advertise/advertise_click_nearly_minute.json";
        try {
            PrintWriter out = new PrintWriter(new FileWriter(new File(file), false));
            StringBuffer jsonStr = new StringBuffer("[");
            hmsClick.forEach(
                    (xtime, yclick) -> {
                        String jsonElem = "{\"xtime\":\""+xtime+"\",\"yclick\":\""+yclick+"\"},";
                        System.out.println(jsonElem);
                        jsonStr.append(jsonElem);
                    }
            );
            jsonStr.deleteCharAt(jsonStr.length()-1);
            jsonStr.append("]");
            out.println(jsonStr.toString());
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {

    }
}

  继承 BaseWindowedBolt 以实现滑动窗口。

package cn.edu.neu.advertise;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.kafka.spout.KafkaSpout;
import org.apache.storm.kafka.spout.KafkaSpoutConfig;
import org.apache.storm.kafka.spout.KafkaSpoutRetryExponentialBackoff;
import org.apache.storm.kafka.spout.KafkaSpoutRetryService;
import org.apache.storm.topology.TopologyBuilder;
import org.apache.storm.tuple.Fields;
import org.apache.storm.topology.base.BaseWindowedBolt.Duration;

import java.util.concurrent.TimeUnit;

/**
 * @author 32098
 */
public class ClickNearlyMinuteApp {
    private static final String BOOTSTRAP_SERVERS = "master:9092";
    private static final String TOPIC_NAME = "advertise-user";

    public static void main(String[] args) {

        final TopologyBuilder builder = new TopologyBuilder();
        builder.setSpout("kafka_spout", new KafkaSpout<>(getKafkaSpoutConfig()), 1);
        builder.setBolt("boltA", new ClickNearlyMinuteBoltA()).shuffleGrouping("kafka_spout");
        // window
        builder.setBolt("boltB", new ClickNearlyMinuteBoltB().withWindow(new Duration(60, TimeUnit.SECONDS), new Duration(10, TimeUnit.SECONDS)),1).setNumTasks(1).fieldsGrouping("boltA", new Fields("time_stamp", "aid"));

        Config config = new Config();
        config.put(Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS, 70000);
        // 如果外部传参cluster则代表线上环境启动,否则代表本地启动
        if (args.length > 0 && "cluster".equals(args[0])) {
            try {
                StormSubmitter.submitTopology("Cluster-ClickNearlyMinuteApp", config, builder.createTopology());
            } catch (AlreadyAliveException | InvalidTopologyException | AuthorizationException e) {
                e.printStackTrace();
            }
        } else {
            LocalCluster cluster = new LocalCluster();
            cluster.submitTopology("Local-ClickNearlyMinuteApp",
                    config, builder.createTopology());
        }
    }

    private static KafkaSpoutConfig<String, String> getKafkaSpoutConfig() {
        return KafkaSpoutConfig.builder(ClickNearlyMinuteApp.BOOTSTRAP_SERVERS, ClickNearlyMinuteApp.TOPIC_NAME)
                .setProp(ConsumerConfig.GROUP_ID_CONFIG, "kafkaSpoutTestGroup")
                .setRetry(getRetryService())
                .setOffsetCommitPeriodMs(10_000)
                .build();
    }

    /**
     * 定义重试策略
     * @return KafkaSpoutRetryService
     */
    private static KafkaSpoutRetryService getRetryService() {
        return new KafkaSpoutRetryExponentialBackoff(KafkaSpoutRetryExponentialBackoff.TimeInterval.microSeconds(500),
                KafkaSpoutRetryExponentialBackoff.TimeInterval.milliSeconds(2), Integer.MAX_VALUE, KafkaSpoutRetryExponentialBackoff.TimeInterval.seconds(10));
    }
}

  java.lang.IllegalArgumentException: Window duration (length + sliding interval) value 70000 is more than topology.message.timeout.secs value 30000 (非法参数异常，滑动窗口大小加滑动间隔的值大于timeout的默认值)
  解决方法：config.put(Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS, 70000);

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>最近1分钟广告总点击量,每10s计算一次</title>
<!--    <script src="echarts.js"></script>-->
<!--    <script type="text/javascript" src="jquery-1.9.0.min.js"></script>-->
    <script src="https://cdn.staticfile.org/echarts/4.3.0/echarts.min.js"></script>
    <script type="text/javascript" src="https://cdn.staticfile.org/jquery/1.10.2/jquery.min.js"></script>
</head>
<body>

<div id="display" style="height: 450px; width:800px"></div>
<script>
    var myChart = echarts.init(document.getElementById("display"));
    setInterval(function () {
        $.getJSON("advertise_click_nearly_minute.json",function(data){
            var x = [];
            var y = [];
            $.each(data,function (i,obj) {
                x.push(obj.xtime)
                y.push(obj.yclick)
            });
            var option = {
                xAxis:{
                    type:"category",
                    data:x
                },
                yAxis:{
                    type:"value",
                },
                series:[{
                    data:y,
                    type:"line"
                }]
            };
            myChart.setOption(option)
        })
    },5000)
</script>

</body>
</html>


[
{"xtime":"22:28:20","yclick":"92"},
{"xtime":"22:28:30","yclick":"110"},
{"xtime":"22:28:40","yclick":"105"},
{"xtime":"22:28:50","yclick":"99"},
{"xtime":"22:29:00","yclick":"88"},
{"xtime":"22:29:10","yclick":"60"}
]

三、实验结果

  • 需求(1)
    在这里插入图片描述
    在这里插入图片描述
  • 需求(2)
    在这里插入图片描述
  • 需求(3)
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

基于Storm的最近一分钟广告总点击量(每10秒统计一次)视频

珞清殇
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
storm流式计算（实时系统）
01-18
storm流式计算的介绍，包括kafka、redis的介绍，包含日志系统、电商交易系统的文档。
Storm实战：构建大数据实时计算
01-05
随着大数据实时处理需求的强劲增长，Storm的出现填补了大数据处理生态系统的缺失，并被越来越多的公司所采用。阿里巴巴集团数据平台事业部商家数据业务部正是最早使用Storm的技术团队之一。 　《Storm实战：构建...
Storm安装与实验
weixin_33979203的博客
11-10 372
接上一篇Kafka的安装与实验： http://www.cnblogs.com/charlesblc/p/6046023.html 还有再上一篇Flume的安装与实验： http://www.cnblogs.com/charlesblc/p/6046023.html   Storm的安装可以参考这篇： http://shiyanjun.cn/archives/934.html   有1.0后的版本...
Storm-实时计算系统
qq_43002947的博客
04-21 1128
Storm-实时计算系统 作者 | WenasWei 一 Storm 1.1 Storm简介 Storm 最早是由 BackType 公司开发的实时处理系统，底层由 Clojure 实现。Clojure 也是一门基于 JVM 的高级面向函数式的编程语言。2011年 Twitter 公司收购了 BackType 公司，便使用 Storm 帮助企业解决了实时海量数据处理的问题。阿里巴巴在 Storm 基础上，使用 Java 代替 Clojure 实现了核心，并在性能上进行了优化，产生了JStorm。目前 St
大数据技术基础实验十四：Storm实验——部署Storm
北天的博客
11-14 1533
大数据技术基础实验十四，本次实验我们将了解学习有关Storm的一些知识以及如何在虚拟机集群中进行Storm部署。
Spark日志分析项目Demo(8)--SparkStream，广告点击流量实时统计
zhi_fu的博客
09-09 3824
广告点击统计需求： (1)对接kafka，获得数据 (2)发现某个用户某天对某个广告的点击量已经大于等于100,写入黑名单，进行过滤 (3)计算广告点击流量实时统计结果 (4)实时统计每天每个省份top3热门广告 (5)实时统计每天每个广告在最近1小时的滑动窗口内的点击趋势（每分钟的点击量）主流程代码public static void main(String[] args) {
Storm 实战：构建大数据实时计算完整版
05-19
随着大数据实时处理需求的强劲增长，Storm的出现填补了大数据处理生态系统的缺失，并被越来越多的公司所采用。阿里巴巴集团数据平台事业部商家数据业务部正是最早使用Storm的技术团队之一。 《Storm实战：构建...
Storm 实战：构建大数据实时计算 PDF带书签完整版
12-19
Storm的实时计算能力使其在社交媒体分析、广告定向、物联网(IoT)数据处理等领域有广泛应用。 3. **Spout组件**：Spout是Storm拓扑中的数据源，它可以是任何产生数据流的源头，如消息队列、数据库或是传感器等。...
Storm实战构建大数据实时计算
03-29
Storm官方网站有段简介 Storm是一个免费并开源的分布式实时计算系统。利用Storm可以很容易做到可靠地处理无限的数据流，像Hadoop批量处理大数据一样，Storm可以实时处理数据。Storm简单，可以使用任何编程语言。
使用kafka和storm简单模拟天猫双十一实时统计订单各个维度信息
虾哔哔的博客
04-14 3084
程序说明: 根据双十一当天的订单mq，快速计算当天的订单量、销售金额 思路： 1,支付系统发送mq到kafka集群中，编写storm程序消费kafka的数据并计算实时的订单数量、订单数量 2,将计算的实时结果保存在redis中 3,外部程序实时展示结果 程序设计 数据产生：编写kafka数据生产者，模拟订单系统发送mq 数据输入：使用PaymentSpout消费kafka中的数据 ...
基于storm的实时计算应用实践
tianlianchao1982的专栏
06-06 4632
有赞使用storm已经有将近3年时间，稳定支撑着实时统计、数据同步、对账、监控、风控等业务。订单实时统计是其中一个典型的业务，对数据准确性、性能等方面都有较高要求，也是上线时间最久的一个实时计算应用。通过订单实时统计，描述使用storm时，遇到的准确性、性能、可靠性等方面的问题。订单实时统计的演进第一版：流程走通在使用storm之前，显示实时统计数据一般有两种方案：在数据库里执行count、sum...
大数据技术基础实验十五：Storm实验——实时WordCountTopology
北天的博客
11-18 1674
大数据技术基础实验十五，利用Storm集群实现实时WordCountTopology。
Storm实时计算：Storm的实时计算原理和使用方法
最新发布
禅与计算机程序设计艺术
07-03 5722
作者：禅与计算机程序设计艺术 Storm 实时计算：Storm 的实时计算原理和使用方法 在大数据处理领域，实时计算是一个重要的话题。在 Hadoop 生态系统中，Storm 是一个实时计算框架，它可以在实时数据流的基础上进行实时计算。本文将介绍 St
在线实时大数据平台Storm并行度试验
医疗影像检索
08-10 4186
集群模式试验：同一文件输入数据如何处理，数据变量共享 1）集群模式一个worker内一个spout一个Bolt jps:1个worker storm list:1个wokers，4个tasks 2）集群模式一个worker内一个spout 两个Bolt jps:1个worker storm list:1个wokers，6个tasks 不同bolt线程之间对变量counter是互斥读写
Storm实验 -- DRPC的使用
weixin_34189116的博客
05-05 159
2019独角兽企业重金招聘Python工程师标准>>> ...
Storm 的可靠性保证测试
一个有情怀的程序猿博客
07-07 285
Storm 是一个分布式的实时计算框架，可以很方便地对流式数据进行实时处理和分析，能运用在实时分析、在线数据挖掘、持续计算以及分布式 RPC 等场景下。Storm 的实时性可以使得数据从收集到处理展示在秒级别内完成，从而为业务方决策提供实时的数据支持。 在美团点评公司内部，实时计算主要应用场景包括实时日志解析、用户行为分析、实时消息推送、消费趋势展示、实时新客判断、实时活跃用户数统计等。这些数据提供给各事业群，并作为他们实时决策的有力依据，弥补了离线计算“T+1”的不足。 在实时计算中，用户不仅仅关..
Storm实验 -- 单词计数4
weixin_34235371的博客
05-03 116
2019独角兽企业重金招聘Python工程师标准>>> ...
Storm实验 -- 单词计数3
weixin_34054931的博客
05-03 165
2019独角兽企业重金招聘Python工程师标准>>> ...
基于storm和hadoop的广告系统研究【2】
无人境域
10-11 1315
文中所有实现方案全部基于storm、hadoop以及nosql等开源技术 计算广告学概念：点击此处 计算广告的运作系统主要包括广告算法、广告、语境、受众（用户）四个方面，针对这四个方面当下的广告形式可归纳为三类：基于文本分析、基于用户分析和基于用户参与。 一、基于文本分析 这种形式最常见的就是浏览的网页内容的与广告主题的匹配，比如看关于诺基亚1020自拍神器的测评文章，同时网页的广
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值