1.编写代码，模拟定时对流数据进行定时刷新

最新推荐文章于 2022-07-11 13:37:26 发布
最新推荐文章于 2022-07-11 13:37:26 发布
阅读量300 收藏
点赞数
分类专栏： 大数据内部核心原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35561207/article/details/84935120
版权 
package com.wutos.sync.component;

import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.model.Filters;
import com.wutos.sync.domain.dto.DataMogodbDTO;
import com.wutos.sync.domain.dto.DataSyncDTO;
import com.wutos.sync.domain.dto.DiskStatusMogodbDTO;
import com.wutos.sync.domain.entity.DataSyncLog;
import com.wutos.sync.enums.SyncDataSource;
import com.wutos.sync.enums.SyncOptType;
import com.wutos.sync.mq.ActiveMqManage;
import com.wutos.sync.service.IDataSyncService;
import com.wutos.sync.utils.UUIDUtils;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.bson.Document;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import javax.jms.JMSException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;

public class MogodbTask implements Runnable {

    Logger logger = LoggerFactory.getLogger(MogodbTask.class);
    /**
     * 时间节点结束节点
     */
    private long end;
    /**
     * 时间节点开始节点
     */
    private long nextstart;

    private MogodbTask mogodbTask;
    /**
     * 定时的时间周期,每隔5个小时刷新一次
     */
    static final long timeClock = 60 * 60* 5;

    private StringBuffer stringBuffer = new StringBuffer();

    /**
     * 是否成功的标志位
     */
    public static Boolean successFlag = null;

    public static AtomicLong size = new AtomicLong(0L);//原子性线程操作

    private long num = 1;

    private long CurrentThread = 0;//当前线程数

    private CountDownLatch over;//监控线程数

    private boolean isRunable = true;

    private String platformId;  //

    private IDataSyncService dataSyncService;

    private ActiveMqManage activeMqManage;

    MongoTemplate oplogMongoTemplate;

    long timestrap_value ;

    public static String str = null; // 将StringBuffer转化成字符串
    public static StringBuffer sb = new StringBuffer(); // StringBuffer便于字符串的增删改查操作

    /**
     * Mogodb监听查询间隔：毫秒
     */

    public MogodbTask(long start, long end, String platformId) {
        this.end = end;
        this.nextstart = start;
        this.platformId = platformId;
        this.dataSyncService = (IDataSyncService) SpringUtil.getBean("dataSyncService");
        this.activeMqManage = (ActiveMqManage) SpringUtil.getBean("dataSyncMQ");
        this.oplogMongoTemplate = (MongoTemplate) SpringUtil.getBean("oplogMongoTemplate");
    }

    /**
     * 使用锁机制实现定期的去读取并保证线程安全，mogodb的oplog是不支持批量更新的
     */
    synchronized private long getStart() {
        long temp = nextstart;//
        nextstart = nextstart + timeClock;//时间为一分钟
        return temp;
    }


    synchronized private long getNum() {
        return num++;
    }

    @Override
    public void run() {
        logger.info("hsss ----------------------------------!");
        mogodbdata();
    }


    public void stop() {
        this.isRunable = false;
        logger.info("Mogodbtask is stop!");
    }

    /**
     * 删除从oplog中取出来的日志变化
     * { "ts" : { "$timestamp" : { "t" : 1544078644, "i" : 1 } }, "t" : { "$numberLong" : "1" },
     * "h" : { "$numberLong" : "6632986490438552198" }, "v" : 2, "op" : "d", "ns" : "db_dataCollection.t_diskStatus",
     * "ui" : { "$binary" : "AkPf/x94/kVKWhNPSbN8hQ==", "$type" : "03" }, "wall" : { "$date" : 1544078644457 }, "o" : { "_id" : "14" } }
     *
     * 更新从oplog中取出来的日志变化
     * { "ts" : { "$timestamp" : { "t" : 1544078277, "i" : 1 } }, "t" : { "$numberLong" : "1" },
     * "h" : { "$numberLong" : "-338099272864304700" }, "v" : 2, "op" : "u", "ns" : "db_dataCollection.t_diskStatus",
     * "ui" : { "$binary" : "AkPf/x94/kVKWhNPSbN8hQ==", "$type" : "03" }, "o2" : { "_id" : "13" },
     * "wall" : { "$date" : 1544078277111 }, "o" : { "$v" : 1, "$set" : { "modifiedOn" : "2018-12-05 16:49:45" } } }
     *
     * 插入从oplog中取出来的变化
     * { "ts" : { "$timestamp" : { "t" : 1543999782, "i" : 1 } }, "t" : { "$numberLong" : "1" },
     * "h" : { "$numberLong" : "1559286620930196252" }, "v" : 2, "op" : "i",
     * "ns" : "db_dataCollection.t_cameraChannel", "ui" : { "$binary" : "HUuFNtANi+2TUgHeIvIovg==", "$type" : "03" },
     * "wall" : { "$date" : 1543999782209 }, "o" : { "_id" : "0", "blurStatus" : 0, "brightnessStatus" : 0,
     * "cameraName" : "一楼", "cameraSn" : "10001", "cameraStatus" : 0, "contrastStatus" : 0, "coverStatus" : 0,
     * "deviceId" : "14", "ditherStatus" : 0, "frozenStatus" : 0, "lossStatus" : 0, "modifiedOn" : "2018-12-05 16:49:42",
     * "noiseStatus" : 0, "scenechangeStatus" : 0, "striationStatus" : 0, "unbalanceStatus" : 0 } }
     *
     *
     */

    private void mogodbdata() {
        MongoTemplate oplogMongoTemplate = (MongoTemplate) SpringUtil.getBean("oplogMongoTemplate");
        MongoCollection<Document> oplogRs = oplogMongoTemplate.getCollection("oplog.rs");

        List<String> tableNames = new ArrayList<>();
        //对于应该去进行监控的表添加到响应的tableNames中去。
        //tableNames.add("db_dataCollection.t_deviceData");
        tableNames.add("db_dataCollection.t_diskStatus");//7个键值对
        tableNames.add("db_dataCollection.t_cameraChannel");//16个键值对
        /**
         * mogodb的游标获取，以及得到轮询的所有的值:
         */ //左右每次处理的条数为100
        MongoCursor<Document> cursor = oplogRs.find(Filters.in("ns", tableNames)).iterator();
        String timestrap=null;
        //TODO 这块用来取时间戳作为处理数据流的依据
        while (cursor.hasNext()) {
            Document doc1 = cursor.next();
            JSONObject jsontime = JSONObject.parseObject(doc1.toJson());
            System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------");
            String timelist = jsontime.getString("ts");
            JSONObject datalist = JSONObject.parseObject(timelist);
            //作为从oplog取出的一个值:
            String temp_strap = datalist.getString("$timestamp");
            JSONObject tlist = JSONObject.parseObject(temp_strap);
            timestrap = tlist.getString("t");
            long flag=Long.parseLong(timestrap);
           // TODO 得出时间戳的临界值
            sb.append(flag);//将字符串追加到
            sb.append("%");
            }
            str=sb.toString();//将StringBuffer类型数据转换成String类型
            String[] params = StringUtils.split(str, "%");


            //TODO 获取当前事件毫秒数,并转换为Unix的整点时间戳
            Long currentTimestamps=System.currentTimeMillis();
            Long oneDayTimestamps= Long.valueOf(60*60*24*1000);
            //TODO 每天时间的0点时间戳,并转换为UNIX时间戳的形式
            long current_hour=(currentTimestamps-(currentTimestamps+60*60*8*1000)%oneDayTimestamps)/1000;
            for(int i=0;i<24;i++){
                current_hour=current_hour+timeClock;
                long hour_time=System.currentTimeMillis()/1000-timeClock;
                while(current_hour>hour_time){
                    //TODO 获取当前时间整点时间戳为current_hour，作为一个临界点进行处理,
                    //TODO 当前时间整点数加当前之后的的一个小时,时间戳.
                    long current_end=current_hour+timeClock;
                                    //筛选满足条件的timestrap
                                    for(int j=0;j<params.length;j++) {
                                        //TODO 取出timestrapvalue的值
                                        timestrap_value = Long.parseLong(params[i]);
                                    }
                        if(timestrap_value>current_hour&&timestrap_value<current_end){
                            System.out.println("输出timestrap_value的值"+timestrap_value+"输出current_hour的值"+current_hour+"输出current_end的值"+current_end);
                            while (cursor.hasNext()) {
                                Document doc = cursor.next();
                                System.out.println("输出从满足时效的数据，并进行定时器实时处理操作%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%mogodb中查出来的数据" + doc.toJson());
                                JSONObject jsonObject = JSONObject.parseObject(doc.toJson());
                                System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------");
                                /**
                                 * 删除从oplog中取出来的日志变化
                                 * { "ts" : { "$timestamp" : { "t" : 1544078644, "i" : 1 } }, "t" : { "$numberLong" : "1" },
                                 * "h" : { "$numberLong" : "6632986490438552198" }, "v" : 2, "op" : "d", "ns" : "db_dataCollection.t_diskStatus",
                                 * "ui" : { "$binary" : "AkPf/x94/kVKWhNPSbN8hQ==", "$type" : "03" }, "wall" : { "$date" : 1544078644457 }, "o" : { "_id" : "14" } }
                                 */
                                // TODO 得出时间戳的临界值
                                String oparetion = jsonObject.getString("op");
                                String table = jsonObject.getString("ns");
                                String event = jsonObject.getString("o");
                                System.out.println("输出evenet的值" + event);
                                if (oparetion != "C" || oparetion != "n") {
                                    try {
                                        System.out.println("输出满足条件的json数据------");
                                        parseEntry(jsonObject);//调用相关的业务数据进行PKid和封装。
                                    } catch (Exception e) {
                                        logger.info("mogodb中的数据无新增/更改/删除变化!");
                                    }
                                } else {
                                    System.out.println("mogodb的并未进行有效更改操作！");
                                }
                            }
                        }
                    }
                }
            }
    /**
     * 进入数据的log封装阶段
     */
    private void parseEntry(JSONObject object) {
        System.out.println("进入parseEntryhssssssssssssssssss999999999999999999999999999999数据进行封装阶段！！！！！！！！！！！！！！！");
        //成功的数据放入DataSynclog存档
        List<DataSyncLog> syncList = Lists.newArrayList();
        String tableName = object.getString("ns");//表名称
        String eventType = object.getString("o"); //更改的事件名称,具体的事件
        String pk_id = object.getString("o2");
        JSONObject  hss= JSONObject.parseObject(pk_id);
        DataSyncLog log = new DataSyncLog();
        /**
         * 将主键Id插入到pk_Id中去
         */
        log.setPkId(hss.getString("_id"));
        System.out.println("输出主键_id的值"+hss.getString("_id"));
        log.setDataSource(SyncDataSource.MONGODB.getValue());//2//绑定数据源
        log.setPlatformId(platformId);//初始化方法从service中取值取出来
        log.setId(UUIDUtils.getUuidCode());//uuid
        log.setCreatedOn(LocalDateTime.now());//新增时间
        log.setModifiedOn(log.getCreatedOn());//更改时间
        log.setTableName(tableName);//将表名写入
        if (object.getString("op").matches("i")) {
            System.out.println("进入插入数据封装");
            log.setOperateType(SyncOptType.INSERT.getValue());//i=1
            parseColumn(eventType, log);
        } else if (object.getString("op").matches("u")) {
            System.out.println("进入更改数据封装");
            log.setOperateType(SyncOptType.UPDATE.getValue());//2
            parseColumn(eventType, log);
        } else if (object.getString("op") == "d") {
            System.out.println("进入删除数据封装");
            log.setOperateType(SyncOptType.DELETE.getValue());//3
            parseColumn(eventType, log);
        }
        syncList.add(log);
        if (CollectionUtils.isNotEmpty(syncList)) {
            dataSyncService.insertList(syncList);
        }
        // TODO 放入消息队列并调API
        DataSyncDTO dto = new DataSyncDTO();
        dto.setDataSource(SyncDataSource.MONGODB.getValue());
        dto.setDataSyncLogList(syncList);
        //
        try {
            System.out.println("准备进入hss写的mogodb端的mQ");
            activeMqManage.sendMessage("queue.DataSync", dto);
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }


    /**
     * 将mogodb中的对象转成自己的数据传输对象，进行json转换,并且封装到log中去。
     *
     * @param
     * @param log
     */
    private void parseColumn(String eventType, DataSyncLog log) {
        System.out.println("进入真实有价值的数据的拆开以及封装,查看一下原来的值" + eventType);
        //List<DataMogodbDTO> resultList = Lists.newArrayList();
        JSONObject jsStr = JSONObject.parseObject(eventType); //将字符串{“id”：1}
        //获取主键id的判定条件如下所示
        System.out.println("输出jsStr_id"+jsStr.get("_id"));
            logger.info("update mogodb data");
            String  data = jsStr.getString("$set");
            System.out.println("输出firstkey的值"+data);
            JSONObject datalist = JSONObject.parseObject(data);
            System.out.println("输出数据库中表字段的集合"+datalist);
            System.out.println("datalist.getString(\"_id\")"+datalist.getString("_id")+"判断其他的值是否存在"+datalist.getString("cameraSn")+"其他的一些东西"+datalist.getString("hss"));
               if(log.getTableName().matches("db_dataCollection.t_cameraChannel")){
                   System.out.println("进入db_dataCollection.t_cameraChannel");
                  /**
                   * 将主键id赋值给它
                   */
                   List<DataMogodbDTO> resultList = Lists.newArrayList();
                   DataMogodbDTO model = new DataMogodbDTO();
                  model.set_id(log.getPkId()!=null?log.getPkId():datalist.getString("_id"));
                  model.setPK(true);//更改标志位，设定为存在主键id
                  model.setCameraSn(datalist.getString("cameraSn")!=null?datalist.getString("cameraSn"):"");
                  model.setCameraStatus(datalist.getString("cameraStatus")!=null?datalist.getString("cameraStatus"):"");
                  model.setCameraName(datalist.getString("cameraName")!=null?datalist.getString("cameraName"):"");
                  model.setBlurStatus(datalist.getString("blurStatus")!=null?datalist.getString("blurStatus"):"");
                  model.setBrightnessStatus(datalist.getString("brightnessStatus")!=null?datalist.getString("brightnessStatus"):"");
                  model.setContrastStatus(datalist.getString("contrastStatus")!=null?datalist.getString("contrastStatus"):"");
                  model.setCoverStatus(datalist.getString("coverStatus")!=null?datalist.getString("coverStatus"):"");
                  model.setDitherStatus(datalist.getString("ditherStatus")!=null?datalist.getString("ditherStatus"):"");
                  model.setFrozenStatus(datalist.getString("frozenStatus")!=null?datalist.getString("frozenStatus"):"");
                  model.setLossStatus(datalist.getString("lossStatus")!=null?datalist.getString("lossStatus"):"");
                  model.setNoiseStatus(datalist.getString("noiseStatus")!=null?datalist.getString("noiseStatus"):"");
                  model.setScenechangeStatus(datalist.getString("scenechangeStatus")!=null?datalist.getString("scenechangeStatus"):"");
                  model.setStriationStatus(datalist.getString("striationStatus")!=null?datalist.getString("striationStatus"):"");
                  model.setUnbalanceStatus(datalist.getString("unbalanceStatus")!=null?datalist.getString("unbalanceStatus"):"");
                  model.setModifiedOn(datalist.getString("modifiedOn")!=null?datalist.getString("modifiedOn"):"");
                  resultList.add(model);
                  log.setDataJson(JSONObject.toJSONString(resultList));
              }else if(log.getTableName().matches("db_dataCollection.t_diskStatus")){
                   System.out.println("进入db_dataCollection.t_diskStatus");
                   List<DiskStatusMogodbDTO> resultList = Lists.newArrayList();
                   DiskStatusMogodbDTO model2=new DiskStatusMogodbDTO();
                   model2.set_id(log.getPkId()!=null?log.getPkId():datalist.getString("_id"));
                   model2.setPK(true);//更改标志位，设定为存在主键id
                   model2.setDeviceMainType(datalist.getString("deviceMainType")!=null?datalist.getString("deviceMainType"):"");
                   model2.setDeviceName(datalist.getString("deviceName")!=null?datalist.getString("deviceName"):"");
                   model2.setDeviceStatus(datalist.getString("deviceStatus")!=null?datalist.getString("deviceStatus"):"");
                   model2.setDeviceType(datalist.getString("deviceType")!=null?datalist.getString("deviceType"):"");
                   model2.setModifiedOn(datalist.getString("modifiedOn")!=null?datalist.getString("modifiedOn"):"");
                   String  temp=datalist.getString("modifiedOn")!=null? datalist.getString("modifiedOn"):"--------------没有获取到任务数据";
                   System.out.println("输出对应传入到----------------------------------------------------------------------------------------------------------------------------------------------DTO中详细的变化的time的值"+temp);
                   resultList.add(model2);
                   log.setDataJson(JSONObject.toJSONString(resultList));
               }else{
                   logger.info("datasource data get fail");
               }
              log.setPkId(log.getPkId()!=null?log.getPkId():datalist.getString("_id"));//赋值主键id.
              //resultList.add(model);
              //log.setDataJson(JSONObject.toJSONString(resultList));
//            model.Firstkey();
//            model.setFiledName(column.getName());
//            model.setFiledType(column.getMysqlType());
//            model.setValue(column.getValue());
       // }else if(jsStr.getString("$v")!="1"){
             //进入数据的删除和新增操作

       // }


       // Iterator<String> keys = keylist.keySet().iterator();
        //for (CanalEntry.Column column : columns) {
            //DataMogodbDTO model = new DataMogodbDTO();//数据同步传输表字段，进行数据的跟踪
//            model.Firstkey();
//            model.setFiledName(column.getName());
//            model.setFiledType(column.getMysqlType());
//            model.setValue(column.getValue());
            // 获取主键字段和值
//            if (column.getIsKey()) {
//                id = column.getValue();
//                model.setPK(true);  //这个是事件的主键Id，当存在的时候进行标志，不存在就算了
//            }

//        }

            // log.setPkId(id);
            // log.setDataJson(JSONObject.toJSONString(resultList));
        }
    }


/** 打印结果举例
 ================> binlog[mysql-bin.000010:2407] , name[wesafe_west,abproles] , eventType : UPDATE
 -------> before
 Id : 10    colType=int(11)    update=false
 ConcurrencyStamp : 1ae6614c-e82c-4746-a9a3-57cbc60e80bd    colType=longtext    update=false
 CreationTime : 2017-11-01 04:00:21.000000    colType=datetime(6)    update=false
 CreatorUserId : 2    colType=bigint(20)    update=false
 DeleterUserId : 2    colType=bigint(20)    update=false
 DeletionTime : 2018-02-23 17:54:36.063460    colType=datetime(6)    update=false
 DisplayName : 管理员    colType=varchar(64)    update=false
 IsDefault : 0    colType=bit(1)    update=false
 IsDeleted : 0    colType=bit(1)    update=false
 IsStatic : 0    colType=bit(1)    update=false
 LastModificationTime :     colType=datetime(6)    update=false
 LastModifierUserId :     colType=bigint(20)    update=false
 Name : 68f545a7addc42d29a16d60afa90d11a    colType=varchar(32)    update=false
 NormalizedName : 68F545A7ADDC42D29A16D60AFA90D11A    colType=varchar(32)    update=false
 TenantId : 1    colType=int(11)    update=false
 -------> after
 Id : 10    colType=int(11)    update=false
 ConcurrencyStamp : 1ae6614c-e82c-4746-a9a3-57cbc60e80bd    colType=longtext    update=false
 CreationTime : 2017-11-01 04:00:21.000000    colType=datetime(6)    update=false
 CreatorUserId : 2    colType=bigint(20)    update=false
 DeleterUserId : 2    colType=bigint(20)    update=false
 DeletionTime : 2018-02-23 17:54:36.063460    colType=datetime(6)    update=false
 DisplayName : 管理员1    colType=varchar(64)    update=true
 IsDefault : 0    colType=bit(1)    update=false
 IsDeleted : 0    colType=bit(1)    update=false
 IsStatic : 0    colType=bit(1)    update=false
 LastModificationTime :     colType=datetime(6)    update=false
 LastModifierUserId :     colType=bigint(20)    update=false
 Name : 68f545a7addc42d29a16d60afa90d11a    colType=varchar(32)    update=false
 NormalizedName : 68F545A7ADDC42D29A16D60AFA90D11A    colType=varchar(32)    update=false
 TenantId : 1    colType=int(11)    update=false

 ================> binlog[mysql-bin.000008:2838] , name[wesafe_west,user_profile] , eventType : INSERT
 -------> before
 -------> after
 uid : 211    update=true
 TenantId : 1    update=true
 ================> binlog[mysql-bin.000008:3122] , name[wesafe_west,user_profile] , eventType : DELETE
 -------> before
 uid : 211    update=false
 TenantId : 1    update=false
 -------> after

 */

 

qq_35561207
关注
专栏目录
2022年Java 工程师面试题
weixin_42572320的博客
03-03 2481
第 1 页 共 485 页 目录 1、什么是 Mybatis？............................................................................... 33 2、Mybaits 的优点：............................................................................... 33 3、MyBatis 框架的缺点：.............................
java工程师笔试面试题
热门推荐
pamguangyou的专栏
02-08 2万+
1. J2EE 是什么？它包括哪些技术？ 解答：从整体上讲，J2EE 是使用 Java 技术开发企业级应用的工业标准，它是 Java 技术不断适应和促进企业级应用过程中的产物.适用于企业级应用的 J2EE,提供一个平台独立的、可移植的、多用户的、安全的和基于标准的企业级平台，从而简化企业应用的开发、管理和部署。J2EE 是一个标准，而不是一个现成的产品。 主要包括以下这些技术： 1) Ser
定时器控制的按键扫描程序
05-31
一个完全采用定时器的按键扫描程序，可判断长按和短按，消抖也是采用定时器实现，完全抛弃了死等的方法。适用于初学者，高手就不要下了。
js实现定时刷新当前时间
weixin_40701834的博客
09-28 244
js实现定时刷新当前时间 <!DOTYPE HTML> <head> <meta charset="utf-8"> <title>this is a web of time</title> </head> <body> <p id="demo"></p> <script type="text/javascript"> function setTime() { var d = new
使用rabbitMq延迟队列实现数据状态的刷新
weixin_44315847的博客
01-07 787
1.安装rabbitMq(略)： 安装成功： 2.安装rabbitMq延迟队列插件：rabbitmq-delayed-message-exchange 安装成功后: 交换机会多出一种类型 x-delayed-message 3.业务: @Override @Transactional(rollbackFor = Exception.class) public R add(OrgLifeSaveDTO orgLifeSaveDTO){ //新增会议 baseMapper.insert(o
Vue定时器及原理与TS封装
weixin_44861470的博客
06-16 3926
定时器核心的两个方法：1. setInterval()2. clearInterval（）以下为示例代码：
【无标题】vue3.2+Ts动态显示时间，秒数更新
Saturday1414的博客
07-11 605
vue3.2+Ts动态显示时间，秒数更新
七、Hadoop简明笔记
Norni的博客
09-25 1066
目录1、Hadoop入门1.1 Hadoop优势1.2 Hadoop1.x、Hadoop2.x、Hadoop3.x的区别1.3 HDFS架构概述1.4 YARN架构概述1.5 MapReduce架构概述1.6 HDFS、YARN、MapReduce三者关系1.7 大数据技术生态体系1.8 环境准备1.9 Hadoop运行模式1.10 Hadoop本地模式运行：官方WordCount案例2、搭建H...
NiFi 的使用心得
qq_29454203的博客
05-27 6047
一、NiFi概念 NiFi用来处理数据集成场景的数据分发，BS结构的图形化。Apache NiFi 是一个易于使用，功能强大且可靠的系统，用于处理和分发数据。可以自动化管理系统间的数据流。它使用高度可配置的指示图来管理数据路由、转换和系统中介逻辑，支持从多种数据源动态拉取数据。NiFi原来是NSA的一个项目，目前已经代码开源，是Apache基金会的顶级项目之一。 NiFi是基于Java的，使用Maven支持包的构建管理。 NiFi基于Web方式工作，后台在服务器上进行调度。用户可以将数据处理定义为一个流程，
RFID的复习博客
qq_37937830的博客
06-08 9374
嵌入式考完了，，，，，，不说了，没啥好留恋的，该RFID了。你（这篇博客）是否公开看我心情了。仅以此篇敬我人生最后一门课业考试以及第三篇练笔博客。 哈哈哈哈哈哈哈，最后一门了，加油。 文章目录RFID期末复习随笔第一章射频识别技术概述1.1射频识别技术演变1.1.1 简介1.1.2 主要部件1.2 RFID频段1.2.1 低频（Low Frequency，LF）1.2.2 高频（High Freq...
mongodb监听oplog 全量+增量同步
哈士奇
02-17 4166
一、前言 前一个项目中，涉及到了一次数据迁移，这次迁移需要从mongodb迁移到另一个mongodb实例上，两个源的数据结构是不一样的。涉及到增量和全量数据迁移，整体迁移数据量在5亿左右。本篇即讲理论，也讲实战，往下看↓！ 二、迁移思路 通常的增量和全量迁移，思路基本一致： 在开启全量的时候，开始增量监听，记录下增量的主键id 当全量执行结束的时候，从新跑一边记录的增量主键id的记录，根据getbyId查询一下最新的记录，再upsert到新库中。 思路就是这么样的。 三、同步实战 全量同步 全量的操作
angular2组件中定时刷新并清除定时器
friend_ship的博客
07-04 9390
import { Component,OnInit,ChangeDetectionStrategy,ChangeDetectorRef,OnDestroy} from  "@angular/core"; @Component({ changeDetection:ChangeDetectionStrategy.OnPush }) export class xxxCompone
枚举类型的使用
飞腾创客
10-15 1067
package com.uniclues.webmanagement.log; import java.util.Date; import com.uniclues.dbsearch.permission.UserVO; /**  * @desc 后台日志模型  * @author molin  * @date 上午9:38:51  2013-9-5  */ public class Log...
vue 定时刷新改变输出内容
Jinmy的博客
09-12 3203
  &lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;vue-test&lt;/title&gt; &lt;script src="./vue.js"&gt;&lt;/script&g
1.记录canal数据库中间件在项目中的实际应用以及过程，附上代码：
sandy
12-06 952
增量订阅/消费设计 首先生成一个数据库连接字段，如下所示； 具体的协议格式，可参见：CanalProtocol.proto get/ack/rollback协议介绍： 其中对应的代码，如下所示： Message getWithoutAck(int batchSize)，允许指定batchSize，一次可以获取多条，每次返回的对象为Message，包含的内容为： batchsize是可...
mongodb oplog MySQL_分享用MongoDB中oplog机制实现数据监控实例
weixin_42706667的博客
01-27 371
MongoDB 的Replication是通过一个日志来存储写操作的，这个日志就叫做oplog，而下面这篇文章主要给大家介绍了利用MongoDB中oplog机制实现准实时数据的操作监控的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。前言最近有一个需求是要实时获取到新插入到MongoDB的数据，而插入程序本身已经有一套处理逻辑，所以不方便直接在插入程序里写相关程序，传统的数据库大多自带这种触发...
Apache Flink中如何实现数据流的定时刷新？
最新发布
09-13
Apache Flink是一个开源的流处理框架，用于处理有界和无界的数据流。在Flink中，数据流的定时刷新通常是通过窗口操作（Window）来实现的。窗口操作可以将无限的数据流分割为有限的数据块，然后对这些数据块进行处理。Flink提供了多种类型的窗口，比如滚动窗口（Tumbling Window）、滑动窗口（Sliding Window）和会话窗口（Session Window）。 1. 滚动窗口（Tumbling Window）：将数据流分割为固定大小的连续块，并且这些窗口是不重叠的。对于每个窗口，都可以进行一次计算。 2. 滑动窗口（Sliding Window）：与滚动窗口类似，但是窗口之间可以重叠，并且可以定期进行计算。滑动窗口在每个窗口间隔触发一次计算。 3. 会话窗口（Session Window）：根据时间段将数据流中的事件分组，如果在指定的时间段内没有事件发生，则会话窗口结束。 在Flink中，定时刷新通常与窗口结合使用。例如，通过配置窗口的大小和滑动间隔来控制数据流处理的时间段。在Flink的DataStream API中，你可以使用窗口函数（如`window()`、`timeWindow()`）来指定窗口的类型和大小，并通过`trigger()`方法来定义何时触发窗口的计算。 以下是一个简单的例子，展示了如何在Flink中使用滚动窗口来实现定时刷新： ```java // 假设有一个DataStream的数据源 DataStream<MyEvent> stream = ...; // 对流中的事件应用窗口，每个5分钟的窗口计算一次 stream .keyBy((event) -> event.getKey()) .timeWindow(Time.minutes(5)) .reduce(new MyReduceFunction()); ``` 在这个例子中，`MyReduceFunction`是一个用户自定义的函数，用于处理窗口中的数据。`timeWindow(Time.minutes(5))`定义了一个每5分钟计算一次的滚动窗口。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值