获取源数据推送到Kafka

最新推荐文章于 2024-09-05 22:19:51 发布

不要em0啦

最新推荐文章于 2024-09-05 22:19:51 发布

阅读量1k

点赞数 23

分类专栏：数据分析实践文章标签： kafka 分布式

本文链接：https://blog.csdn.net/2201_75642955/article/details/136751125

版权

数据分析实践专栏收录该内容

28 篇文章 0 订阅

订阅专栏

打开BigData-KongGuan项目

打开BigData-KongGuan项目，在上一个任务（“用户登录”）的基础上继续完成本阶段任务。
初始化加载SpringBoot项目的代码所在位置src/main/java/com/qrsoft/BigDataKongGuanApplication.java ，代码如下：

package com.qrsoft;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class BigDataKongGuanApplication{
	public static ConfigurableApplicationContext appConfig;
	public static void main(String[] args)	throws IOException, URISyntaxException, InterruptedException {
		appConfig = SpringApplication.run(BigDataKongGuanApplication.class, args);
	}
}

2、编写TimeTaskService类，并配置HBase参数和基础参数

代码所在位置src/main/java/com/qrsoft/service/TimeTaskService.java。
在com.qrsoft.service包下，创建TimeTaskService类，首先，定义一些变量用于临时保存查询结果：

package com.qrsoft.service;

import com.alibaba.fastjson.JSON;
import com.qrsoft.common.Constants;
import com.qrsoft.util.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
public class TimeTaskService {

    //本次查询的最后一个rowKey
    //kg_PlanData计划数据
    private static byte[] planDataLastRowKey = null;
    //Kg_WarnFlightHistory航班指令告警数据
    private static byte[] warnFlightLastRowKey = null;
    //Kg_ATCDutyInfo管制值班人员数据
    private static byte[] aTCDutyLastRowKey = null;
    //Kg_WarnSimilarHistory相似航班号告警数据
    private static byte[] warnSimilarLastRowKey = null;
    //kg_AFTN报文数据
    private static byte[] aFTNLastRowKey = null;
    //kg_ATC报文数据
    private static byte[] aTCLastRowKey = null;
    //kg_callSaturation扇区通话饱和度数据
    private static byte[] callSaturationLastRowKey = null;

    //kg_ATC扇区数据 计时
    private static String atcDataTime = "20180101";
    //kg_AFTN报文数据 计时
    private static String aftnDataTime = "20180101";
    //kg_callSaturation扇区通话饱和度数据 计时
    private static String callDataTime = "20180101";
    //kg_PlanData计划数据 计时
    private static String planDataTime = "20180101";
    //Kg_WarnFlightHistory航班指令告警数据 计时
    private static String warnFlightDataTime = "20180101";
    //Kg_WarnSimilarHistory相似航班号告警数据 计时
    private static String warnSimilarDataTime = "20180101";
    //Kg_ATCDuty 管制员数据 计时
    private static String atcDutyDataTime = "20180101";

    //每次查询的数据量
    private static int selectLimit = 30;
    
		// … 后面将继续编写以下方法 …
		// … getDateAndDepositInKafka方法 …
		// … timingGetData方法 …
}

3、在TimeTaskService类中，添加getDateAndDepositInKafka方法，实现HBase分页查询，查询指定数量的数据，将数据放到Kafka中

在getDateAndDepositInKafka方法会使用到其他一些工具类，例如：常量工具类、分页模型工具类、HBase数据访问工具类等；

1）编写getDateAndDepositInKafka方法，用于读取HBase的数据，并将数据放到不同的Kafka Topic中：

private static byte[] getDateAndDepositInKafka(String topic, String tableName,byte[] lastRowKey, String date, String family, String column) throws SQLException {
    return null;
    // … 此处需要补充代码 …
}

类名	方法名	参数	返回值
TimeTaskService	getDateAndDepositInKafka	topic：kafka topic名称 tableName：HBase中的表名 lastRowKey：起始行键 date：查询的飞行计划时间 family：HBase表的列族 column：查询HBase表的列	HBase本次分页查询记录最后的行键值 lastrowkey，该值将作为下次查询的起始行键
类引用/依赖	Constants：定义常量的工具类，例如，Kafka Topic的名称。 HBasePageModel：自定义的HBase表数据分页模型工具类。 HQueryFilterUtil：hbase查询fileter组合工具类。 HBaseUtils：HBase数据访问的工具类。 KafkaUtils：Kafka操作的工具类。 DateUtils：日期操作的工具类。 MultiRadar：雷达数据表对应的实体类。 MultiRadarMapper：读取雷达数据表的数据访问类。

类名

方法名

参数

返回值

TimeTaskService

getDateAndDepositInKafka

topic：kafka topic名称

tableName：HBase中的表名

lastRowKey：起始行键

date：查询的飞行计划时间

family：HBase表的列族

column：查询HBase表的列

HBase本次分页查询记录最后的行键值 lastrowkey，该值将作为下次查询的起始行键

类引用/依赖

Constants：定义常量的工具类，例如，Kafka Topic的名称。

HBasePageModel：自定义的HBase表数据分页模型工具类。

HQueryFilterUtil：hbase查询fileter组合工具类。

HBaseUtils：HBase数据访问的工具类。

KafkaUtils：Kafka操作的工具类。

DateUtils：日期操作的工具类。

MultiRadar：雷达数据表对应的实体类。

MultiRadarMapper：读取雷达数据表的数据访问类。

2）编写com.qrsoft.common.Constants类，该类为当前项目中使用的常量的定义，包括当前任务阶段使用的Kafka Topic名称等：

代码所在位置src/main/java/com/qrsoft/common/Constants.java，核心代码如下：

package com.qrsoft.common;

public class Constants {
	//间隔时间
	public final static int INTERVAL_TIME_10MIN = 10*60*1000;// 10分钟
	public final static int INTERVAL_TIME_5MIN = 5*60*1000;// 5分钟
	public final static int INTERVAL_TIME_1MIN = 60*1000;// 1分钟
	public final static int INTERVAL_TIME_30SEC = 30*1000;// 30秒
	public final static int INTERVAL_TIME_10SEC = 10*1000;// 10秒
	public final static int INTERVAL_TIME_5SEC = 5*1000;// 5秒
	//每分钟读取条数
	public final static int READ_COUNT = 10;
	//kg_airport
	public final static String TABLE_AIRPORT = "kg_airport";
	//kg_airlinecompany
	public final static String TABLE_AIRLINECOMPANY = "kg_airlinecompany";
	//kg_PlanData计划数据
	public final static String TASK_PlANDATA = "task_PlanData";
	public final static String TABLE_PlANDATA = "Kg_PlanData";
	public final static String FAMILY_PlANDATA = "ReportHome";
	public final static String COLUMN_PlANDATA = "EXECUTE_DATE";
	//kg_MultiRadarData综合航迹数据 
	public final static String TASK_RADAR = "task_Radar";
	public final static String TABLE_RADAR = "Kg_MultiRadarData";
	public final static String FAMILY_RADAR = "RadarHome";
	public final static String COLUMN_RADAR = "EXECUTE_DATE";
	//kg_AFTN报文数据
	public final static String TASK_AFTN = "task_Aftn";
	public final static String TABLE_AFTN = "Kg_AFTN";
	public final static String FAMILY_AFTN = "AFTNHome";
	public final static String COLUMN_AFTN = "EXECUTE_DATE";
	//Kg_ATCDutyInfo管制值班人员数据
	public final static String TASK_ATCDUTY = "task_ATCDuty";
	public final static String TABLE_ATCDUTY = "Kg_ATCDutyInfo";
	public final static String FAMILY_ATCDUTY = "ATCDutyHome";
	public final static String COLUMN_ATCDUTY = "SEND_TIME";
	//Kg_WarnFlightHistory航班指令告警数据
	public final static String TASK_WARNFLIGHT = "task_WarnFlight";
	public final static String TABLE_WARNFLIGHT = "Kg_WarnFlightHistory";
	public final static String FAMILY_WARNFLIGHT = "WarnFlightHome";
	public final static String COLUMN_WARNFLIGHT = "GJ_DATE";
	//Kg_WarnSimilarHistory相似航班号告警数据
	public final static String TASK_WARNSIMILAR = "task_WarnSimilar";
	public final static String TABLE_WARNSIMILAR = "Kg_WarnSimilarHistory";
	public final static String FAMILY_WARNSIMILAR = "WarnSimilarHome";
	public final static String COLUMN_WARNSIMILAR = "GJ_DATE";
    //Kg_ATC扇区信息
    public final static String TASK_ATC = "task_ATC";
    public final static String TABLE_ATC = "Kg_ATC";
    public final static String FAMILY_ATC = "ATCHome";
    public final static String COLUMN_ATC = "EXECUTE_DATE";
	//Kg_CallSaturation 扇区通话饱和度信息
	public final static String TASK_CALLSATURATION = "task_CallSaturation";
	public final static String TABLE_CALLSATURATION = "Kg_CallSaturation";
	public final static String FAMILY_CALLSATURATION = "SaturationHome";
	public final static String COLUMN_CALLSATURATION = "SEND_TIME";
}

3）编写com.qrsoft.util.HBasePageModel类，该类是自定义的HBase表数据分页模型工具类，可参考以下代码实现分页功能，也可以根据这个思路自行查找资料，独立完成此类的编写。此类主要用于构建HBase分页模型：

代码所在位置src/main/java/com/qrsoft/util/HBasePageModel.java，核心代码如下：

package com.qrsoft.util;

import org.apache.hadoop.hbase.client.Result;
import java.io.Serializable;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HBasePageModel implements Serializable {
    private static final long serialVersionUID = 330410716100946538L;
    private int pageSize = 100;
    private int pageIndex = 0;
    private int prevPageIndex = 1;
    private int nextPageIndex = 1;
    private int pageCount = 0;
    private int pageFirstRowIndex = 1;
    private byte[] pageStartRowKey = null;
    private byte[] pageEndRowKey = null;
    private boolean hasNextPage = true;
    private int queryTotalCount = 0;
    private long startTime = System.currentTimeMillis();
    private long endTime = System.currentTimeMillis();
    private List<Result> resultList = new ArrayList<Result>();
    private List<Map<String,String>> list= new ArrayList<Map<String,String>>();

    public HBasePageModel(int pageSize) {
        this.pageSize = pageSize;
    }
    //获取分页记录数量
    public int getPageSize() {
        return pageSize;
    }
    //设置分页记录数量
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }
    //获取当前页序号
    public int getPageIndex() {
        return pageIndex;
    }
    //设置当前页序号
    public void setPageIndex(int pageIndex) {
        this.pageIndex = pageIndex;
    }
    //获取分页总数
    public int getPageCount() {
        return pageCount;
    }
    //设置分页总数
    public void setPageCount(int pageCount) {
        this.pageCount = pageCount;
    }
    //获取每页的第一行序号
    public int getPageFirstRowIndex() {
        this.pageFirstRowIndex = (this.getPageIndex() - 1) * this.getPageSize() + 1;
        return pageFirstRowIndex;
    }
    //获取每页起始行键
    public byte[] getPageStartRowKey() {
        return pageStartRowKey;
    }
    //设置每页起始行键
    public void setPageStartRowKey(byte[] pageStartRowKey) {
        this.pageStartRowKey = pageStartRowKey;
    }
    //获取每页结束行键
    public byte[] getPageEndRowKey() {
        return pageEndRowKey;
    }
    //设置每页结束行键
    public void setPageEndRowKey(byte[] pageEndRowKey) {
        this.pageEndRowKey = pageEndRowKey;
    }
    //获取上一页序号
    public int getPrevPageIndex() {
        if(this.getPageIndex() > 1) {
            this.prevPageIndex = this.getPageIndex() - 1;
        } else {
            this.prevPageIndex = 1;
        }
        return prevPageIndex;
    }
    //获取下一页序号
    public int getNextPageIndex() {
        this.nextPageIndex = this.getPageIndex() + 1;
        return nextPageIndex;
    }
    //获取是否有下一页
    public boolean isHasNextPage() {
//这个判断是不严谨的，因为很有可能剩余的数据刚好够一页。
        if(this.getResultList().size() == this.getPageSize()) {
            this.hasNextPage = true;
        } else {
            this.hasNextPage = false;
        }
        return hasNextPage;
    }
    //获取已检索总记录数
    public int getQueryTotalCount() {
        return queryTotalCount;
    }
    //获取已检索总记录数
    public void setQueryTotalCount(int queryTotalCount) {
        this.queryTotalCount = queryTotalCount;
    }
    //初始化起始时间（毫秒）
    public void initStartTime() {
        this.startTime = System.currentTimeMillis();
    }
    //初始化截止时间（毫秒）
    public void initEndTime() {
        this.endTime = System.currentTimeMillis();
    }
    //获取毫秒格式的耗时信息
    public String getTimeIntervalByMilli() {
        return String.valueOf(this.endTime - this.startTime) + "毫秒";
    }
    //获取秒格式的耗时信息
    public String getTimeIntervalBySecond() {
        double interval = (this.endTime - this.startTime)/1000.0;
        DecimalFormat df = new DecimalFormat("#.##");
        return df.format(interval) + "秒";
    }
    //获取HBase检索结果集合
    public List<Result> getResultList() {
        return resultList;
    }
    //设置HBase检索结果集合
    public void setResultList(List<Result> resultList) {
        this.resultList = resultList;
    }
	public List<Map<String, String>> getList() {
		return list;
	}
	public void setList(List<Map<String, String>> list) {
		this.list = list;
	}
}

4）编写com.qrsoft.util.HQueryFilterUtil类，该类是HBase查询过滤器的组合工具。

代码所在位置src/main/java/com/qrsoft/util/HQueryFilterUtil.java，核心代码如下：

package com.qrsoft.util;

import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.util.List;

public class HQueryFilterUtil {
	public static final int subStringFilter=1;
	public static Filter newFilter(int type, String family, String column, String value){
		switch (type) {
		case subStringFilter:
			return newSubStringFilter(family, column, value);
		default:
			throw new RuntimeException("filter type not exists");
		}
	}
	//family:column中包含字符串value
	public static Filter newSubStringFilter(String family, String column, String value){
		SubstringComparator comp = new SubstringComparator(value);
		return new SingleColumnValueFilter(Bytes.toBytes(family), Bytes.toBytes(column), CompareOp.EQUAL,comp);
	}
	//查询最多返回行数
	public static Filter rowLimitFilter(int rowcount){
		return new PageFilter(rowcount);
	}
	public  static FilterList or(List<Filter> filterList){
		return newList(FilterList.Operator.MUST_PASS_ONE,filterList);
	}
	public  static FilterList and(List<Filter> filterList){
		return newList(FilterList.Operator.MUST_PASS_ALL,filterList);
	}
	private static FilterList newList(FilterList.Operator oper, List<Filter> filterList){
		FilterList list = new FilterList(oper);
		for(Filter f:filterList){
			list.addFilter(f);
		}
		return list;
	}
}

5）编写com.qrsoft.util.KafkaUtils类，该类是Kafka操作的工具类。

代码所在位置src/main/java/com/qrsoft/util/KafkaUtils.java，核心代码如下：

package com.qrsoft.util;

import kafka.serializer.StringEncoder;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import java.io.IOException;
import java.util.Properties;

/***
 * kafka工具类
 */
public class KafkaUtils {
	@SuppressWarnings("rawtypes")
	private static KafkaProducer _producer;

	/**
	 * 获取kafka生产者消息
	 */
	@SuppressWarnings("rawtypes")
	private static KafkaProducer GetProducer() {
		if (_producer == null) {
			_producer = createProducer();
		}
		return _producer;
	}

	/**
	 * 向kafka中传入数据
	 *
	 * @param topic   topic名称
	 * @param message 消息
	 * @return true成功，false失败
	 */
	@SuppressWarnings({"rawtypes", "unchecked"})
	public static boolean SendMessage(String topic, String message) {
		// 创建一个producer的对象
		Producer producer = GetProducer();
		try {
			// 使用produer发送消息
			producer.send(new ProducerRecord(topic, "message" + message, message));
			//TimeUnit.SECONDS.sleep(5);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/***
	 * 创建Producer的实例
	 */
	@SuppressWarnings("rawtypes")
	private static KafkaProducer createProducer()  {

		Properties properties = null;
		try {
			properties = PropertiesLoaderUtils.loadAllProperties("kafka.properties");
		} catch (IOException e) {
			e.printStackTrace();
		}
		String bootstrap = properties.get("bootstrap.servers").toString();
		String zookeeper = properties.get("zookeeper.connect").toString();
		String metadata = properties.get("metadata.broker.list").toString();

		Properties props = new Properties();
		// 该地址是集群的子集，用来探测集群。
		props.put("bootstrap.servers", bootstrap);

		// 声明zk
		props.put("zookeeper.connect", zookeeper);
		props.put("serializer.class", StringEncoder.class.getName());

		// 声明Broker的地址
		props.put("metadata.broker.list", metadata);
		props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

		return new KafkaProducer(props);
	}
}

6）编写com.qrsoft.util.DateUtils类，该类是日期操作的工具类。

代码所在位置src/main/java/com/qrsoft/util/DateUtils.java，核心代码如下：

package com.qrsoft.util;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * Title: DateUtils.java Description: 日期工具类
 */
public class DateUtils {
    public static String myDateUtils(String time){
        if(time.equals("20181231")){
            return "20180101";
        }
        SimpleDateFormat sd = new SimpleDateFormat("yyyyMMdd");
        String newDate = time;
        try {
            Date parse = sd.parse(time);
            long newTime = parse.getTime()+(1000*60*60*24);
            Date newDate1 = new Date(newTime);
            newDate = sd.format(newDate1);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return newDate;
    }
}

7）编写com.qrsoft.util.HBaseUtils类，该类是HBase数据访问的工具类。

代码所在位置src/main/java/com/qrsoft/util/HBaseUtils.java。

初始化HBase连接：

package com.qrsoft.util;

import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.PageFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import java.io.IOException;
import java.util.*;

public class HBaseUtils {
	private static Configuration conf = null;
	private static Connection conn = null;
	static { getInstance(); }
	public static Connection getInstance() {
		try {
			Properties properties = 
PropertiesLoaderUtils.loadAllProperties("hbase.properties");
			String hbase = properties.get("hbase.zookeeper.quorum").toString();
			String zookeeper = properties.get("zookeeper.znode.parent").toString();
			if (null == conn) {
				conf = HBaseConfiguration.create();
				conf.setInt("hbase.rpc.timeout", 24000);
				conf.setInt("hbase.client.operation.timeout", 300000);
				conf.setInt("hbase.client.scanner.timeout.period", 240000);
				conf.set("hbase.zookeeper.quorum", hbase);
				conf.set("zookeeper.znode.parent", zookeeper);
				conn = ConnectionFactory.createConnection(conf);
				return conn;
			} else {
				return conn;
			}
		} catch (Exception e) {
			System.out.println("Hbase连接异常：" + e.getMessage());
		}
		return conn;
	}
// … scanResultByPageFilter实现分页检索表数据 …
// … selectFirstResultRow 实现检索指定表的第一行记录 …
}

8）添加scanResultByPageFilter方法实现分页检索表数据

/**
	 * （如果在创建表时为此表指定了非默认的命名空间，则需拼写上命名空间名称，格式为【namespace:tablename】）。
	 * @param tableName   表名称(*)。
	 * @param startRowKey 起始行键(可以为空，如果为空，则从表中第一行开始检索)。
	 * @param endRowKey   结束行键(可以为空)。
	 * @param filterList  检索条件过滤器集合(不包含分页过滤器；可以为空)。
	 * @param maxVersions 指定最大版本数【如果为最大整数值，则检索所有版本；如果为最小整数值，则检索最新版本；否则只检索指定的版本数】。
	 * @param pageModel   分页模型(*)。
	 * @return 返回HBasePageModel分页对象。
	 */
	public static HBasePageModel scanResultByPageFilter(String tableName, byte[] startRowKey, byte[] endRowKey,FilterList filterList, int maxVersions, HBasePageModel pageModel) {
		if (pageModel == null) {
			pageModel = new HBasePageModel(10);
		}
		if (maxVersions <= 0) {
			// 默认只检索数据的最新版本
			maxVersions = Integer.MIN_VALUE;
		}
		pageModel.initStartTime();
		pageModel.initEndTime();
		if (StringUtils.isBlank(tableName)) {
			return pageModel;
		}
		HTable table = null;

		try {
			// 根据HBase表名称，得到HTable表对象 
			table = (HTable) getInstance().getTable(TableName.valueOf(tableName.getBytes()));
			//getInstance().getTable(TableName.valueOf(tableName));
			//HBaseTableManageUtil.getHBaseTable(tableName);
			int tempPageSize = pageModel.getPageSize();
			boolean isEmptyStartRowKey = false;
			if (startRowKey == null) {
				// 则读取表的第一行记录，这里用到了笔者本人自己构建的一个表数据操作类。
				Result firstResult = selectFirstResultRow(tableName, filterList);
				if (firstResult == null) {
					return pageModel;
				}
				startRowKey = firstResult.getRow();
			}
			if (pageModel.getPageStartRowKey() == null) {
				isEmptyStartRowKey = true;
				pageModel.setPageStartRowKey(startRowKey);
			} else {
				if (pageModel.getPageEndRowKey() != null) {
					pageModel.setPageStartRowKey(pageModel.getPageEndRowKey());
				}
				// 从第二页开始，每次都多取一条记录，因为第一条记录是要删除的。
				tempPageSize += 1;
			}

			Scan scan = new Scan();
			scan.setStartRow(pageModel.getPageStartRowKey());
			if (endRowKey != null) {
				scan.setStopRow(endRowKey);
			}
			PageFilter pageFilter = new PageFilter(pageModel.getPageSize() + 1);
			if (filterList != null) {
				filterList.addFilter(pageFilter);
				scan.setFilter(filterList);
			} else {
				scan.setFilter(pageFilter);
			}
			if (maxVersions == Integer.MAX_VALUE) {
				scan.setMaxVersions();
			} else if (maxVersions == Integer.MIN_VALUE) {

			} else {
				scan.setMaxVersions(maxVersions);
			}
			ResultScanner scanner = table.getScanner(scan);
			List<Result> resultList = new ArrayList<Result>();
			int index = 0;

			Map<String, String> rowMap;
			List<Map<String, String>> rowList = new ArrayList<Map<String, String>>();
			for (Result rs : scanner.next(tempPageSize)) {
				if (isEmptyStartRowKey == false && index == 0) {
					index += 1;
					continue;
				}
				if (!rs.isEmpty()) {
					//默认存入集合
					resultList.add(rs);
					//制作每一行数据集合
					rowMap = new HashMap<String, String>();
					//存入主键
					rowMap.put("rowKey", Bytes.toString(rs.getRow()));
					//存入各字段
					NavigableMap<byte[], NavigableMap<byte[], byte[]>> rowMap1 = rs.getNoVersionMap();
					for (byte[] f : rowMap1.keySet()) {
						NavigableMap<byte[], byte[]> colMap = rowMap1.get(f);
						for (byte[] c : colMap.keySet()) {
							rowMap.put(Bytes.toString(c), Bytes.toString(colMap.get(c)));
						}
					}
					rowList.add(rowMap);
				}
				index += 1;
			}
			scanner.close();
			pageModel.setResultList(resultList);
			pageModel.setList(rowList);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				table.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		int pageIndex = pageModel.getPageIndex() + 1;
		pageModel.setPageIndex(pageIndex);
		if (pageModel.getResultList().size() > 0) {
			// 获取本次分页数据首行和末行的行键信息
			byte[] pageStartRowKey = pageModel.getResultList().get(0).getRow();
			byte[] pageEndRowKey = pageModel.getResultList().get(pageModel.getResultList().size() - 1).getRow();
			pageModel.setPageStartRowKey(pageStartRowKey);
			pageModel.setPageEndRowKey(pageEndRowKey);
		}
		int queryTotalCount = pageModel.getQueryTotalCount() + pageModel.getResultList().size();
		pageModel.setQueryTotalCount(queryTotalCount);
		pageModel.initEndTime();
		//pageModel.printTimeInfo();
		return pageModel;
	}

9）编写selectFirstResultRow方法，实现检索指定表的第一行记录

/**
	 * 检索指定表的第一行记录。<br>
	 * （如果在创建表时为此表指定了非默认的命名空间，则需拼写上命名空间名称，格式为【namespace:tablename】）。
	 *
	 * @param tableName  表名称(*)。
	 * @param filterList 过滤器集合，可以为null。
	 * @return
 */
public static Result selectFirstResultRow(String tableName, FilterList filterList) {
		if (StringUtils.isBlank(tableName)) return null;
		HTable table = null;
		try {
			table = (HTable) getInstance().getTable(TableName.valueOf(tableName.getBytes()));
			//getTable(TableName.valueOf(tableName));
			Scan scan = new Scan();
			//scan.setCaching(20);
			if (filterList != null && filterList.getFilters().size() != 0) {
				scan.setFilter(filterList);
			}
			ResultScanner scanner = table.getScanner(scan);
			Iterator<Result> iterator = scanner.iterator();
			int index = 0;
			if(iterator.hasNext()){
				Result next = iterator.next();
				return  next;
			}
			scanner.close();
			return  null;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				table.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
}

10）编写com.qrsoft.entity.MultiRadar类，该类是访问雷达数据的数据实体类。

代码所在位置src/main/java/com/qrsoft/entity/MultiRadar.java，核心代码如下：

package com.qrsoft.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("multiradar_number")
public class MultiRadar implements Serializable {
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;
    @TableField(value = "TRACK_NUMBER")
    private String trackNumber;
    @TableField(value = "AREA_SOURCE")
    private String areaSource;
    @TableField(value = "SEND_RADAR_TIME")
    private String sendRadarTime;
    @TableField(value = "RADAR_TYPE")
    private String radarType;
    @TableField(value = "ACID")
    private String acid;
    @TableField(value = "SSR_CODE")
    private String ssrCode;
    @TableField(value = "ZHIJIAO_X")
    private String zhijiaoX;
    @TableField(value = "ZHIJIAO_Y")
    private String zhijiaoY;
    @TableField(value = "RADAR_LONGTITUDE")
    private String radarLongtitude;
    @TableField(value = "RADAR_LATITUDE")
    private String radarLatitude;
    @TableField(value = "RADAR_HEIGHT")
    private String radarHeight;
    @TableField(value = "SPEED_X")
    private String speedX;
    @TableField(value = "SPEED_Y")
    private String speedY;
    @TableField(value = "RADAR_SPEED")
    private String radarSpeed;
    @TableField(value = "DIRECTION")
    private String direction;
    @TableField(value = "RADAR_CFL")
    private String radarCfl;
    @TableField(value = "FCU")
    private String fcu;
    @TableField(value = "TIME")
    private String time;
    @TableField(value = "FLYSTATUS")
    private String flystatus;
    @TableField(value = "CLIMBORDOWN_SPEED")
    private String climbordownSpeed;
}

11）编写com.qrsoft.mapper.MultiRadarMapper接口，该接口是访问雷达数据的数据访问接口。

代码所在位置src/main/java/com/qrsoft/mapper/MultiRadarMapper.java。

package com.qrsoft.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.qrsoft.entity.MultiRadar;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface MultiRadarMapper extends BaseMapper<MultiRadar> {
}

回到com.qrsoft.service.TimeTaskService类中，继续编写getDateAndDepositInKafka方法，执行分页查询，每次查询指定数量的数据，将查询的HBase中的数据，推送到Kafka的topic中

private static byte[] getDateAndDepositInKafka(String topic, String tableName, byte[] lastRowKey, String date, String family, String column) 
        throws SQLException {
        // 从hbase中取出数据
        List<Filter> rowFilters = new ArrayList<Filter>();
        FilterList filterList = new FilterList(rowFilters);
        HBasePageModel pageModel = new HBasePageModel(selectLimit + 1);
//		if(!topic.equals(Constants.TASK_RADAR)) {
        if (date != null) {
            Filter filter = HQueryFilterUtil.newSubStringFilter(family, column, date);
            filterList.addFilter(filter);
        }
//		}
        HBasePageModel hbasePageModel = HBaseUtils.scanResultByPageFilter(
tableName, lastRowKey, null, filterList, 0, pageModel);
        // 获取本次查询的最后一个rowKey
        int dataSize = hbasePageModel.getList().size();
        if (dataSize > 0) {
            Map<String, String> map = hbasePageModel.getList().get(dataSize - 1);
            String rowkey = map.get("rowKey");
            lastRowKey = rowkey.getBytes();
            // 把每一条数据放入Kafka
            for (int i = 0; i < hbasePageModel.getList().size() - 1; i++) {
                // System.out.println(JSONArray.fromObject(hbasePageModel.getList().get(i)).toString());
                KafkaUtils.SendMessage(topic, JSON.toJSONString(hbasePageModel.getList().get(i)));
                System.out.println("============" + JSON.toJSONString(hbasePageModel.getList().get(i)) + "==============");
            }
            System.out.println(tableName + "此批次最后一个rowkey：" + rowkey);
        }

        System.out.println(dataSize + "===================================" + selectLimit);
        if (dataSize < selectLimit) {
            if (topic.equals(Constants.TASK_ATC)) {
                atcDataTime = DateUtils.myDateUtils(date);
                System.out.println(Constants.TASK_ATC + "更新数据时间为" + atcDataTime);
            } else if (topic.equals(Constants.TASK_AFTN)) {
                aftnDataTime = DateUtils.myDateUtils(date);
                System.out.println(Constants.TASK_AFTN + "更新数据时间为" + aftnDataTime);
            } else if (topic.equals(Constants.TASK_PlANDATA)) {
                planDataTime = DateUtils.myDateUtils(date);
                System.out.println(Constants.TASK_PlANDATA + "更新数据时间为" + planDataTime);
            } else if (topic.equals(Constants.TASK_WARNFLIGHT)) {
                warnFlightDataTime = DateUtils.myDateUtils(date);
                System.out.println(Constants.TASK_WARNFLIGHT + "更新数据时间为" + warnFlightDataTime);
            } else if (topic.equals(Constants.TASK_WARNSIMILAR)) {
                warnSimilarDataTime = DateUtils.myDateUtils(date);
                System.out.println(Constants.TASK_WARNSIMILAR + "更新数据时间为" + warnSimilarDataTime);
            } else if (topic.equals(Constants.TASK_CALLSATURATION)) {
                callDataTime = DateUtils.myDateUtils(date);
                System.out.println(Constants.TASK_CALLSATURATION + "更新数据时间为" + callDataTime);
            } else if (topic.equals(Constants.TASK_ATCDUTY)) {
                atcDutyDataTime = DateUtils.myDateUtils(date);
                System.out.println(Constants.TASK_ATCDUTY + "更新数据时间为" + atcDutyDataTime);
            }
        }
        return lastRowKey;
}

在resources目录下创建或导入HBase和Kafka相关配置文件

1）创建或导入hbase.properties文件，内容如下：

#hbase.rpc.timeout=24000
#hbase.client.operation.timeout=300000
#hbase.client.scanner.timeout.period=240000
# 注意：zookeeper.quorum请根据你当前环境所安装zookeeper的服务器名称进行设置
hbase.zookeeper.quorum=node1,node2,node3
zookeeper.znode.parent=/hbase

2）创建或导入kafka.properties文件，内容如下：

# 注意：请根据你当前环境所安装zookeeper和kafka的服务器名称进行设置
bootstrap.servers=node1:9092,node2:9092,node3:9092
zookeeper.connect=node1:2181,node2:2181,node3:2181
metadata.broker.list=node1:9092,node2:9092,node3:9092
key.serializer=org.apache.kafka.common.serialization.StringSerializer
value.serializer=org.apache.kafka.common.serialization.StringSerializer

4、创建定时任务，启动数据获取，设置Topic名称

代码所在位置src/main/java/com/qrsoft/service/TimeTaskService.java。

回到com.qrsoft.service.TimeTaskService类中，继续编写timingGetData方法（每间隔30秒执行一次定时任务），核心代码如下：

@Scheduled(cron = "*/30 * * * * *")
public void timingGetData() {
    System.out.println("定时任务启动获取数据");
    try {
        planDataLastRowKey = getDateAndDepositInKafka(Constants.TASK_PlANDATA, Constants.TABLE_PlANDATA, planDataLastRowKey, planDataTime, Constants.FAMILY_PlANDATA, Constants.COLUMN_PlANDATA);
        warnFlightLastRowKey = getDateAndDepositInKafka(Constants.TASK_WARNFLIGHT, Constants.TABLE_WARNFLIGHT, warnFlightLastRowKey, warnFlightDataTime, Constants.FAMILY_WARNFLIGHT, Constants.COLUMN_WARNFLIGHT);
        aTCDutyLastRowKey = getDateAndDepositInKafka(Constants.TASK_ATCDUTY, Constants.TABLE_ATCDUTY, aTCDutyLastRowKey, atcDutyDataTime, Constants.FAMILY_ATCDUTY, Constants.COLUMN_ATCDUTY);
        warnSimilarLastRowKey = getDateAndDepositInKafka(Constants.TASK_WARNSIMILAR, Constants.TABLE_WARNSIMILAR, warnSimilarLastRowKey, warnSimilarDataTime, Constants.FAMILY_WARNSIMILAR, Constants.COLUMN_WARNSIMILAR);
        aFTNLastRowKey = getDateAndDepositInKafka(Constants.TASK_AFTN, Constants.TABLE_AFTN, aFTNLastRowKey, aftnDataTime, Constants.FAMILY_AFTN, Constants.COLUMN_AFTN);
        aTCLastRowKey = getDateAndDepositInKafka(Constants.TASK_ATC, Constants.TABLE_ATC, aTCLastRowKey, atcDataTime, Constants.FAMILY_ATC, Constants.COLUMN_ATC);
        callSaturationLastRowKey = getDateAndDepositInKafka(Constants.TASK_CALLSATURATION, Constants.TABLE_CALLSATURATION, callSaturationLastRowKey, callDataTime, Constants.FAMILY_CALLSATURATION, Constants.COLUMN_CALLSATURATION);
        // 注意：
        //1）“实时飞行数据”对应的Topic，由于直接从HBase读取实时飞行数据推送到Kafka后，在使用时会因为实时飞行数据的时间隔太短，导致在地图上显示飞行状态和位置时，移动的不明显；
        //2）为了在演示的时候提高体验度，所以将下面一行代码注释掉，而这部分功能单独写了一个TimeTask2Service.java的类；
        //3）在TimeTask2Service.java的类中，使用的实时飞行数据是从HBase中读取的已经处理过的保存到本地的数据，实时飞行数据的时间间隔变大，在使用该数据时能明显感觉到飞机在移动；
		//radarLastRowKey=getDateAndDepositInKafka(Constants.TASK_RADAR,Constants.TABLE_RADAR,radarLastRowKey,multiRadarDataTime,Constants.FAMILY_RADAR,Constants.COLUMN_RADAR);

   } catch (SQLException e) {
        e.printStackTrace();
        log.info("获取数据失败！", e.getMessage());
   }
}

5、单独处理“实时飞行数据”，将数据推送到相应的Kafka Topic

注意：

1）处理“实时飞行数据”推送对应的Topic。由于直接从HBase读取实时飞行数据推送到Kafka后，在使用时会因为实时飞行数据的时间隔太短，导致在地图上显示飞行状态和位置时，移动的不明显；

2）为了在演示的时候提高体验度，这部分功能单独写了一个TimeTask2Service.java的类；

3）在TimeTask2Service.java的类中，使用的实时飞行数据是从HBase中读取的已经处理过的保存到本地的数据，实时飞行数据的时间间隔变大，在使用该数据时能明显感觉到飞机在移动；

准备数据

将提供的数据文件放到/opt/data/目录（也可以放到任意目录下，但是需要修改下代码中读取文件的路径），可以查看一下数据是否存在，如图：

代码所在位置src/main/java/com/qrsoft/service/TimeTask2Service.java
创建com.qrsoft.service.TimeTask2Service类，核心代码如下：

package com.qrsoft.service;

import cn.hutool.core.io.file.FileReader;
import com.qrsoft.util.KafkaUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.net.URISyntaxException;
import java.util.List;

@Service
@Slf4j
public class TimeTask2Service {
    /**
     * 实时航线飞行，为了模拟数据飞行数据飞行，从历史数据取出文本文件，通过读取每行文件，得到飞行轨迹，每个文本文件代表一架飞机
     */
    public static List<String> str0 = null;
    public static int count0 = 0;
    public static List<String> str1 = null;
    public static int count1 = 0;
    public static List<String> str2 = null;
    public static int count2 = 0;
    public static List<String> str3 = null;
    public static int count3 = 0;
    public static List<String> str4 = null;
    public static int count4 = 0;
    public static List<String> str5 = null;
    public static int count5 = 0;
    public static List<String> str6 = null;
    public static int count6 = 0;
    public static List<String> str7 = null;
    public static int count7 = 0;
    public static List<String> str8 = null;
    public static int count8 = 0;
    public static List<String> str9 = null;
    public static int count9 = 0;
    public static List<String> str10 = null;
    public static int count10 = 0;
    public static List<String> str11 = null;
    public static int count11 = 0;

    /**
     * 获取文件位置，如果是linux服务器发布需要放在换成linux目录 如果是window可以使用data里的数据
     */
    public TimeTask2Service() throws URISyntaxException, IOException, InterruptedException {
        FileReader fileReader0 = new FileReader("/opt/data/part-00000");
        str0 = fileReader0.readLines();
        FileReader fileReader1 = new FileReader("/opt/data/part-00001");
        str1 = fileReader1.readLines();
        FileReader fileReader2 = new FileReader("/opt/data/part-00002");
        str2 = fileReader2.readLines();
        FileReader fileReader3 = new FileReader("/opt/data/part-00003");
        str3 = fileReader3.readLines();
        FileReader fileReader4 = new FileReader("/opt/data/part-00004");
        str4 = fileReader4.readLines();
        FileReader fileReader5 = new FileReader("/opt/data/part-00005");
        str5 = fileReader5.readLines();
        FileReader fileReader6 = new FileReader("/opt/data/part-00006");
        str6 = fileReader6.readLines();
        FileReader fileReader7 = new FileReader("/opt/data/part-00007");
        str7 = fileReader7.readLines();
        FileReader fileReader8 = new FileReader("/opt/data/part-00008");
        str8 = fileReader8.readLines();
        FileReader fileReader9 = new FileReader("/opt/data/part-00009");
        str9 = fileReader9.readLines();
        FileReader fileReader10 = new FileReader("/opt/data/part-00010");
        str10 = fileReader10.readLines();
        FileReader fileReader11= new FileReader("/opt/data/part-00011");
        str11 = fileReader11.readLines();
    }

    @Scheduled(cron = "*/10 * * * * *")
    public void timingGetData() {
        System.out.println("实时轨迹任务");
        if (count0 >= str0.size()) {
            count0 = 0;
            System.out.println("数据归零");
        }
        String s0 = str0.get(count0++);

        if (count1 >= str1.size()) {
            count1 = 0;
            System.out.println("数据归零");
        }
        String s1 = str1.get(count1++);

        if (count2 >= str2.size()) {
            count2 = 0;
            System.out.println("数据归零");
        }
        String s2 = str2.get(count2++);
        if (count3 >= str3.size()) {
            count3 = 0;
            System.out.println("数据归零");
        }
        String s3 = str3.get(count3++);
        if (count4 >= str4.size()) {
            count4 = 0;
            System.out.println("数据归零");
        }
        String s4 = str4.get(count4++);
        if (count5 >= str5.size()) {
            count5 = 0;
            System.out.println("数据归零");
        }
        String s5 = str5.get(count5++);
        if (count6 >= str6.size()) {
            count6 = 0;
            System.out.println("数据归零");
        }
        String s6 = str6.get(count6++);

        if (count7 >= str7.size()) {
            count7 = 0;
            System.out.println("数据归零");
        }
        String s7 = str7.get(count7++);
        if (count8 >= str8.size()) {
            count8 = 0;
            System.out.println("数据归零");
        }
        String s8 = str8.get(count8++);

        if (count9 >= str9.size()) {
            count9 = 0;
            System.out.println("数据归零");
        }
        String s9 = str9.get(count9++);

        if (count10 >= str10.size()) {
            count10 = 0;
            System.out.println("数据归零");
        }
        String s10 = str10.get(count10++);

        if (count11 >= str11.size()) {
            count11 = 0;
            System.out.println("数据归零");
        }
        String s11 = str11.get(count11++);

        KafkaUtils.SendMessage("task_Radar", s0);
        KafkaUtils.SendMessage("task_Radar", s1);
        KafkaUtils.SendMessage("task_Radar", s2);
        KafkaUtils.SendMessage("task_Radar", s3);
        KafkaUtils.SendMessage("task_Radar", s4);
        KafkaUtils.SendMessage("task_Radar", s5);
        KafkaUtils.SendMessage("task_Radar", s6);
        KafkaUtils.SendMessage("task_Radar", s7);
        KafkaUtils.SendMessage("task_Radar", s8);
        KafkaUtils.SendMessage("task_Radar", s9);
        KafkaUtils.SendMessage("task_Radar", s10);
        KafkaUtils.SendMessage("task_Radar", s11);
        System.out.println("----------------------航迹数据更新----------------------");
    }
}

6、测试

确保Hadoop、HBase、Kafka集群都已经正常启动，如果没有正常启动，请参考前面环境安装部署的相应任务完成集群的启动。

启动SpringBoot项目

在控制台显示类似下面的结果：

在node1节点上，查看kafka中的topic是否有数据

[root@node1 ~]# kafka-console-consumer.sh --bootstrap-server node1:9092 --from-beginning --topic task_CallSaturation

不要em0啦

关注

23
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录