qq_37001101

Kafka+采集用户信息行为+flume整合（鼠标停留时间）

Kafka+采集用户信息行为+flume（鼠标停留时间）

一、Kafka概述

与消息系统类似，是消息中间件的一种。能够订阅和发布流式数据，能够以容错的方式存储流式数据，当数据产生时就能够处理

生产者:数据产生者

消费者:数据使用者

中间件:进行数据缓冲

采集用户信息行为：

用户信息采集：页面上两个按钮、三个模块，当点击按钮的时候会显示点击那个按钮的日志，当鼠标滑过的时候显示鼠标在某个区域停留的时间

Log4j的代码如下：

# 全局配置 -> DEBUG(调试) -> INFO(信息) ->ERROR(错误)
log4j.rootLogger=DEBUG,stdout,file
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
# 日志格式 p:日志级别 t:线程 m:信息 n:换行
log4j.appender.stdout.layout.ConversionPattern=%m%n

log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=/home/hadoop/data.log
log4j.appender.file.append=true
log4j.appender.file.layout=org.apache.log4j.PatternLayout

Jsp页面的代码如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path;
%>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Titletitle>
    <script type="text/javascript">
        var basePath = '<%= basePath%>';
    script>

引入jar包
    <script type="text/javascript" src="js/jquery-1.7.1.min.js">script>
    <script type="text/javascript">
        $(function () {
            $(".product").click(function () {
                var productId = $(this).data("productid");
                $.ajax({
                    url : basePath + "/EventServlet",
                    type : "post",
                    data : {
                        type : "click",
                        product : productId
                    }
                })
            });
            var date = 0;
            $(".productDiv").mouseover(function () {
                date = new Date();
                console.log(date)
            })
            $(".productDiv").mouseleave(function () {
                var time = new Date() - date;
                var productId = $(this).data("productid");
                $.ajax({
                    url : basePath + "/EventServlet",
                    type : "post",
                    data : {
                        type : "mouse",
                        product : productId,
                        time : time
                    }
                })
            })
        });
    script>
head>
<body>
<% session.setAttribute("count",1); %>
<form action="<%= basePath%>/LoggerServlet" method="post">
    <input type="text" name="userName" />
    <br />
    <input type="submit" value="提交" >
form>
<div id="content" style="border: 1px solid red;width: 3000px;height: 1002px">
    <div id="left" style="border: 1px solid red;float: left;width: 600px;height: 998px">
        <div class="productDiv" style="width: 300px;height: 300px;border: 1px solid blue;margin: 5px;" data-productid = "3">div>
        <div class="productDiv" style="width: 300px;height: 300px;border: 1px solid blue;margin: 5px;" data-productid = "4">div>
        <div class="productDiv" style="width: 300px;height: 300px;border: 1px solid blue;margin: 5px;" data-productid = "5">div>
    div>
    <div id="right" style="border: 1px solid red;float: left;width: 998px;height: 998px">
        <input class="product" type="button" value="商品1" data-productid = "1" />
        <input class="product" type="button" value="商品2" data-productid = "2" />
    div>
div>
body>
html>

Serverlet的代码如下：

import org.apache.log4j.Logger;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(name = "EventServlet",urlPatterns = "/EventServlet")
public class EventServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 根据不同的事件类型记录用户的行为信息
        String type = request.getParameter("type");
        String productId = request.getParameter("product");
        Logger logger = Logger.getRootLogger();
        switch (type){
            case "click" : {
                logger.info("click-" + productId);
                break;
            }
            case "mouse" : {
                Long time = Long.parseLong(request.getParameter("time"));
                logger.info("mouse-" + productId + "-" + time);
            }
        }
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }
}

kafka解决的问题

供求平衡

供大于求

数据产生快 - 使用较慢(数据计算) -> 多生产的数据如何存储/高效的对数据进行消费

供不应求 - 合理确定生产消费模式([推送]/拉取)产生一些数据就推送一些数据

Kafka容错性 - 多副本机制(leader) -> 进程异常终止会推选出新的leader -> 保证正常工作

容错性指的是多副本一个挂掉启用另外一个

Kafka就相当于篮子

二、部署和使用

前置环境:zookeeper

tar -zvxf zookeeper-3.4.12.tar.gz
vi ~/.bash_profile
export ZK_HOME=/home/bigdata/zookeeper-3.4.12
export PATH=$PATH:$ZK_HOME/bin

source ~/.bash_profile

cd $ZK_HOME/conf
mv zoo_sample.cfg zoo.cfg
vi zoo.cfg
dataDir=/home/bigdata/zookeeper

zkServer.sh start

kafka安装

tar -zvxf kafka_2.10-0.10.2.2.tgz
mv kafka_2.10-0.10.2.2 kafka-0.10.2.2

vi ~/.bash_profile
export KAFKA_HOME=/home/bigdata/kafka-0.10.2.2
PATH=$PATH:$KAFKA_HOME/bin

source ~/.bash_profile

mkdir ~/kafka //存放kafka的缓存日志

核心配置(server.properties)

# 不重复的整数，每个broker监听一个端口
broker.id
# 是否开启topic的删除
delete.topic.enble
# kafka日志文件:逗号分隔多个路径
log.dirs
# 分区数量
num.partitions
# zookeeper的地址
zookeeper.connect

1. 单节点单Broker

server-0.properties配置

mv $KAFKA_HOME/config/server.properties $KAFKA_HOME/config/server-0.properties
vi $KAFKA_HOME/conf/server-0.properties
broker.id=0 //每个broker监听一个端口,将数据保存log中

delete.topic.enble=ture
listeners=PLAINTEXT://SZ01:9092
log.dirs=/home/bigdata/kafka/logs-0
num.partitions=1
zookeeper.connect=SZ01:2181

启动kafka

kafka-server-start.sh -daemon $KAFKA_HOME/config/server-0.properties

2. 单节点多Broker

在单节点的server.properties配置基础上进行修改

cp $KAFKA_HOME/config/server-0.properties $KAFKA_HOME/config/server-1.properties
cp $KAFKA_HOME/config/server-0.properties $KAFKA_HOME/config/server-2.properties
cp $KAFKA_HOME/config/server-0.properties $KAFKA_HOME/config/server-3.properties

server-1.properties

broker.id=1
listeners=PLAINTEXT://SZ01:9093
log.dirs=/home/bigdata/kafka/logs-1
num.partitions=1
zookeeper.connect=SZ01:2181

server-2.properties

broker.id=2
listeners=PLAINTEXT://SZ01:9094
log.dirs=/home/bigdata/kafka/logs-2
num.partitions=1
zookeeper.connect=SZ01:2181

server-3.properties

broker.id=3
listeners=PLAINTEXT://SZ01:9095
log.dirs=/home/bigdata/kafka/logs-3
num.partitions=1
zookeeper.connect=SZ01:2181

启动kafka

kafka-server-start.sh -daemon $KAFKA_HOME/config/server-1.properties
kafka-server-start.sh -daemon $KAFKA_HOME/config/server-2.properties
kafka-server-start.sh -daemon $KAFKA_HOME/config/server-3.properties

停止Kafka

kafka-server-stop.sh
# 失效时使用如下脚本
kill -s TERM $(jps -l | grep 'kafka\.Kafka' | awk '{print $1}')

三、Kafka的使用

1. Topic操作

使用kafka-topics.sh

使用--zookeeper指定zookeeper地址

使用--replication-factor指定副本个数

使用--partitions指定分区数

使用--topic指定名称

使用--list显示Topic列表

(1)创建Topic

单broker

理清topic创建的概念

Broker------相当于篮子

topic -> 多个副本(小于等于broker) -> 多个分区

每一个篮子可以装一个副本，每个副本分几个区

Partitions必须小于factor

删除Topic

1.配置文件中开启delete.topic.enble = true

2.通过命令执行删除操作 -> marked

kafka-topics.sh --delete --zookeeper hh:2181 --topic first_topic

3.停止Kafka进程

4.log.dir中的文件夹清空

5.启动Kafka进程

kafka-topics.sh --create --zookeeper hh:2181 --replication-factor 1 --partitions 1 --topic first_topic

多broker

kafka-topics.sh --create --zookeeper hh:2181 --replication-factor 3 --partitions 1 --topic myTopic

(2)查看Topic列表

kafka-topics.sh --list --zookeeper SZ01:2181

(3)删除Topic

kafka-topics.sh --delete --zookeeper SZ01:2181 --topic first_topic
# 标记删除后，删除对应目录下文件，重启kafka

(4)查看Topic描述

kafka-topics.sh --describe --zookeeper SZ01:2181 [--topic first_topic]

2. 消息测试

使用kafka-console-producer.sh生产消息

使用--broker-list指定broker列表

使用kafka-console-consumer.sh消费消息

使用--bootstrap-server指定需要连接的服务

使用--from-beginning指定从开始位置开始消费

(1)生产消息

单broker

kafka-console-producer.sh --broker-list hh:9092 --topic first_topic
hello kafka

多broker

kafka-console-producer.sh --broker-list SZ01:9093,SZ01:9094,SZ01:9095 --topic myTopic
hello kafka

(2)消费消息

单broker

kafka-console-consumer.sh --bootstrap-server hh:9092 --topic first_topic [--from-beginning]

多broker

kafka-console-consumer.sh --zookeeper hh:2181 --topic myTopic [--from-beginning]

3. 容错性

当topic下存在多个broker时，会选举出一个leader，当其他节点出现故障时，不影响使用。当leader出现故障时，如果当前topic下还有其他节点，会重新选举出leader，保证使用

以上使用的是脚本的方式进行测试，现在要做的是使用程序进行监控

四、Kafka的API编程

1. 开发环境

新建Scala项目

使用sbt构建

添加依赖

scalaVersion := "2.10.7"

libraryDependencies += "org.apache.kafka" % "kafka-clients" % "0.10.2.2"

2. 配置文件

在scala下新建两个配置文件

kafkaConsumer.properties

kafkaProducer.properties

Producer配置项

# 连接列表（数据存放主机）
bootstrap.servers=hh:9092
# 配置请求完成标准
acks=all
# 设置重试次数
retries=0
# 缓冲区大小(字节)
batch.size=16384
# 生产者发送消息时的等待时间(毫秒)
linger.ms=1
# 缓冲内存大小(字节)
buffer.memory=33554432
# key的序列化方式
key.serializer=org.apache.kafka.common.serialization.IntegerSerializer
# value的序列化方式
value.serializer=org.apache.kafka.common.serialization.StringSerializer

Consumer配置项

# 连接列表
bootstrap.servers=hh:9092
# 使用者所属组(唯一)
group.id=test
# 自动提交偏移量
enable.auto.commit=true
# 提交偏移量频率(毫秒)
auto.commit.interval.ms=1000
# key的反序列化方式
key.deserializer=org.apache.kafka.common.serialization.IntegerDeserializer
# value的反序列化方式
value.deserializer=org.apache.kafka.common.serialization.StringDeserializer

工具类：（向程序中加载配置项的作用）

src\main\scala\com\qfedu\kakfa\util

import java.io.IOException;
import java.util.Properties;

public class PropertiesUtil {

   private String fileName;
   private Properties properties = new Properties();

   public PropertiesUtil(String fileName) {
      this.fileName = fileName;
      open();
   }

   private void open() {
      try {
         properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName));
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

   /**
    * 根据key取出properties文件中对应的value
    * @param key
    * @return value
    */
   public String readPropertyByKey(String key) {
      return properties.getProperty(key);
   }

   /**
    * 从文件中读取配置后将整个的Properties返回
    * @return properties成员
    */
   public Properties getProperties(){
      return this.properties;
   }

}

3.\main\scala\com\qfedu\kafka建立生产者消费者

生产者

import com.qfedu.util.PropertiesUtil
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord}
// 继承Thread
class KafkaMsgProducer extends Thread {
  // 使用工具类读取配置
  val properties = new PropertiesUtil("kafkaProducer.properties").getProperties()
  // 初始化KafkaProducer
  val producer = new KafkaProducer[Int, String](properties)
  // 重写run方法
  override def run() = {
   for (i <- 0 until 100){
   producer.send(new ProducerRecord[Int, String]("first_topic", i, s"msg:$i"))
   Thread.sleep(1000)
   }
   // 释放资源
   producer.close
  }
}

实际操作的代码

import com.qfedu.kakfa.util.PropertiesUtil
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord}

object Producer {
  def main(args: Array[String]): Unit = {
    val props = new PropertiesUtil("kafkaProducer.properties").getProperties
    val producer = new KafkaProducer[Int,String](props)
    for (i <- 0 until 100)
      producer.send(new ProducerRecord("first_topic",i,s"value:$i"))
    producer.close()
  }
}

首先linux端启动消费者（前提kafka进程启动，topic已经建立）

kafka-console-consumer.sh --bootstrap-server hh:9092 --topic first_topic

启动程序上面

4. Consumer API

实际操作的代码

import java.util
import java.util.Properties
import com.qfedu.kakfa.util.PropertiesUtil
import org.apache.kafka.clients.consumer.{ConsumerRecord, ConsumerRecords, KafkaConsumer}
object Consumer {
  def main(args: Array[String]): Unit = {
    // 读取配置文件后给消费者指定不同的id
    val prop1:Properties = new PropertiesUtil("kafkaConsumer.properties").getProperties
    prop1.setProperty("group.id","test01")
    val prop2:Properties = new PropertiesUtil("kafkaConsumer.properties").getProperties
    prop2.setProperty("group.id","test02")
    val consumer1 = new KafkaConsumer[Int,String](prop1)
    val consumer2 = new KafkaConsumer[Int,String](prop2)
    // 传入的集合为Collection子类
    consumer1.subscribe(util.Arrays.asList("first_topic"))
    consumer2.subscribe(util.Arrays.asList("first_topic"))
    while (true){
      // 设置超时时间，接收生产数据
      val records1: ConsumerRecords[Int, String] = consumer1.poll(100)
      val records2: ConsumerRecords[Int, String] = consumer2.poll(100)
      val it1 = records1.iterator()
      // 使用迭代器遍历
      while (it1.hasNext){
        val record: ConsumerRecord[Int, String] = it1.next()
        println(s"consumer1 - offset:${record.offset},key:${record.key},value:${record.value}")
      }
      val it2 = records2.iterator()
      // 使用迭代器遍历
      while (it2.hasNext){
        val record: ConsumerRecord[Int, String] = it2.next()
        println(s"consumer2 - offset:${record.offset},key:${record.key},value:${record.value}")
      }
    }
  }
}

启动程序：

启动生产者：（前提如上）

kafka-console-producer.sh --broker-list hh:9092 --topic first_topic

flume与kafka的整合：

实现过程：

WebServer - Flume

Source : exec

channel : memory

sink : avro

DataServer - Flume

Source : avro

channel : memory

sink : Kafka

Flum监听web的日志放到data.log文件夹----flum读取到avro-----再次从avro中读取到first_topic

第一步：打包如上的web（鼠标滑动的）程序存放到linux的tomcat的 webapps

文件夹下------改名为ROOT.war

第二步配置flume的启动配置文件

WebServer端的配置文件example-file.conf

mple.conf: A single-node Flume configuration

# Name the components on this agent

a1.sources = r1

a1.sinks = k1

a1.channels = c1

# Describe/configure the source

a1.sources.r1.type = exec

a1.sources.r1.command = tail -f /home/hadoop/data.log

# Describe the sink

a1.sinks.k1.type = avro

a1.sinks.k1.hostname =hh

a1.sinks.k1.port = 8888

# Use a channel which buffers events in memory

a1.channels.c1.type = memory

# Bind the source and sink to the channel

a1.sources.r1.channels = c1

a1.sinks.k1.channel = c1

DataServer端的flume的配置文件example-fileAvro.confkafka.conf

mple.conf: A single-node Flume configuration

# Name the components on this agent

a2.sources = r1

a2.sinks = k1

a2.channels = c1

# Describe/configure the source

a2.sources.r1.type = avro

a2.sources.r1.bind = hh

a2.sources.r1.port = 8888

# Describe the sink

a2.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink

a2.sinks.k1.kafka.bootstrap.servers = hh:9092

a2.sinks.k1.kafka.topic = first_topic

# Use a channel which buffers events in memory

a2.channels.c1.type = memory

# Bind the source and sink to the channel

a2.sources.r1.channels = c1

a2.sinks.k1.channel = c1

第三步启动tomcat

./startup.sh

第四步：启动两个flume

启动一个fileflum

flume-ng agent \

--name a1 \

--conf $FLUME_HOME/conf \

--conf-file $FLUME_HOME/conf/example-file.conf &

flume-ng agent \

--name a2 \

--conf $FLUME_HOME/conf \

--conf-file $FLUME_HOME/conf/example-fileAvro.confkafka.conf &

第五步启动kafka进程

kafka-server-start.sh -daemon $KAFKA_HOME/config/server-0.properties

开一个topic

kafka-topics.sh --create --zookeeper hh:2181 --replication-factor 1 --partitions 1 --topic first_topic

第六步开启一个消费者

查看topic

kafka-topics.sh --list --zookeeper hh:2181

__consumer_offsets

first_topic

开启消费者

kafka-console-consumer.sh --bootstrap-server hh:9092 --topic first_topic

第七步：测试：

时间段数据的统计：

Web阶段经过flum，再经过kafka 再kafka里面监听两个消费者一个是属于鼠标滑过求一个时间段内，在每个区域的总时间

另一个是监听一段时间内点击的数量

在Scala的项目中添加如下程序

main\scala\com\qfedu\kafka\consumer\MouseConsumer.scala

package com.qfedu.kafka.consumer

import java.util
import java.util.{Date, Properties}

import com.qfedu.kakfa.util.PropertiesUtil
import org.apache.kafka.clients.consumer.{ConsumerRecord, ConsumerRecords, KafkaConsumer}

import scala.collection.mutable.HashMap

object MouseConsumer {
  def main(args: Array[String]): Unit = {
    // 读取配置文件后给消费者指定不同的id
    val prop: Properties = new PropertiesUtil("kafkaConsumer.properties").getProperties
    prop.setProperty("group.id", "mouse")
    val consumer = new KafkaConsumer[Int, String](prop)
    // 传入的集合为Collection子类
    consumer.subscribe(util.Arrays.asList("first_topic"))
    val start = new Date().getTime
    var flag = true
    val result = new HashMap[String, Integer]()
    while (flag) {
      val end = new Date().getTime
      if ((end - start) > (2 * 60 * 1000)) {
        flag = false
      }
      // 设置超时时间，接收生产数据
      val records: ConsumerRecords[Int, String] = consumer.poll(100)
      val it = records.iterator()
      // 使用迭代器遍历
      while (it.hasNext) {
        val record: ConsumerRecord[Int, String] = it.next()
        val types = record.value().split("-")(0)
        if ("mouse".equals(types)) {
          val key = record.value().split("-")(1)
          val time = record.value().split("-")(2).toInt
          val count = result.getOrElse[Integer](key, 0) + time
          result.put(key, count)
        }
      }
    }
    for ((key, value) <- result) {
      println(s"key:$key,value:$value")
    }
  }
}

main\scala\com\qfedu\kafka\consumer\ClickConsumer.scala

package com.qfedu.kafka.consumer

import java.util
import java.util.{Date, Properties}

import scala.collection.mutable.HashMap
import com.qfedu.kakfa.util.PropertiesUtil
import org.apache.kafka.clients.consumer.{ConsumerRecord, ConsumerRecords, KafkaConsumer}

object ClickConsumer {
  def main(args: Array[String]): Unit = {
    // 读取配置文件后给消费者指定不同的id
    val prop:Properties = new PropertiesUtil("kafkaConsumer.properties").getProperties
    prop.setProperty("group.id","click")
    val consumer = new KafkaConsumer[Int,String](prop)
    // 传入的集合为Collection子类
    consumer.subscribe(util.Arrays.asList("first_topic"))
    val start = new Date().getTime
    var flag = true
    val result = new HashMap[String,Integer]()
    while (flag){
      val end = new Date().getTime
      if ((end - start) > (2 * 60 * 1000)){
        flag = false
      }
      // 设置超时时间，接收生产数据
      val records: ConsumerRecords[Int, String] = consumer.poll(100)
      val it = records.iterator()
      // 使用迭代器遍历
      while (it.hasNext){
        val record: ConsumerRecord[Int, String] = it.next()
        val types = record.value().split("-")(0)
        if ("click".equals(types)){
          val key = record.value().split("-")(1)
          val count = result.getOrElse[Integer](key,0) + 1
          result.put(key,count)
        }
      }
    }
    for ((key,value) <- result){
      println(s"key:$key,value:$value")
    }
  }
}

在前一个例子都启动的前提下，在IDEA中启动这两个程序

不断的做点击按钮以及鼠标滑过的操作

等待2分钟后出现如下结果：

key:5,value:4522

key:4,value:7443

key:3,value:11462

key:2,value:11

key:1,value:13

提取数据 -> 两个消费者(click/mouse) -> 计算出最多的被浏览商品/被点击商品(2 * 60 * 1000)

15号当日的数据 -> 10 - 14日之间的所有的统计结果 -> 保存策略 -> 更新频率

数据采集(Flume-Kafka) -> 数据分析(数据接收 - 计算 - 历史结果合并 - 历史结果存放)

计算频率 - 1秒

最新结果 - 10秒

你可能感兴趣的:(kafka,flume,IDEA,scala)

git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
Kafka 消息丢失如何处理？架构文摘JGWZ 学习
今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
【六】阿伟开始搭建Kafka学习环境能源恒观中间件学习 kafka spring
阿伟开始搭建Kafka学习环境概述上一篇文章阿伟学习了Kafka的核心概念，并且把市面上流行的消息中间件特性进行了梳理和对比，方便大家在学习过程中进行对比学习，最后梳理了一些Kafka使用中经常遇到的Kafka难题以及解决思路，经过上一篇的学习我相信大家对Kafka有了初步的认识，本篇将继续学习Kafka。一、安装和配置学习一项技术首先要搭建一套服务，而Kafka的运行主要需要部署jdk、zook
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
spring如何整合druid连接池？惜.己 spring spring junit 数据库 java idea 后端 xml
目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
Kafka是如何保证数据的安全性、可靠性和分区的喜欢猪猪 kafka 分布式
Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
【算法练习】IDEA集成leetcode插件实现快速刷 2401_84102892 2024年程序员学习算法 intellij-idea leetcode
============点击右侧边leetcode->设置->配置地址、用户名、密码、存放目录、文件模板用户名要登录后在账号信息里看模板代码1.codefilename!velocityTool.camelC
idea使用自定义checkstyle.xml配置文件 Gemkey
1.下载插件image.png2.插件安装完后,找到设置中的checkstyle,点击"+",新增自定义规则image.png3.输入描述信息,点击Browse找到对应的文件image.pngimage.png4.可以把active勾上,则使用默认校验规则,点击OK,则可以开始使用自定义规则检测单个文件了image.png
101个浪漫的点子..哈哈有需要可以试试...中英对照~ Hecks 学习心得 IDEA UP Go 音乐网页游戏
Thisisafreebonusversionof101RomanticIdeas.Feelfreetoforwardtoormakecopiesforyourfriends.下面是101个浪漫的点子。可随意转发给你的朋友们IDEA#1点子1Ifyourpartnerisgoingawayforafewdays,tellherthatyouareworriedabouthersoyouhaveor
1.8，69 知行思合一
运气动力学万维钢老师提出的名词，不愧是物理博士出身，good1idea，创意一些新名词。开文引用查理芒格的话：得到你想要的东西，最保险的办法，就是让自己配得上你想要的那个东西。接着举例《绝命毒师》Breakingbad导演文斯·吉里根接受采访说的话，引出成功的经验——运气。我们现在所处的这个社会不管是美国还是中国，大体上都是一个精英社会——人们可以靠天赋和努力去争取财富和地位，而不像历史上那样家庭
svg图片兼容性和用法优缺点独行侠_ef93
svg图片的使用方法第一次来认认真真的研究了下svg图片，之前只是在网上见过，但都是一晃而过也没当回事，最近网站改版看到同事有用到svg格式的图片，想想自己干了几年的重构也没用过，这些细节的知识是应该好好研究研究了。暂时还没研究得完全透切，先记下目前为止所看到的吧不然又给忘了。svg可缩放矢量图形（ScalableVectorGraphics），顾名思义就是任意改变其大小也不会变形，是基于可扩展标
Kafka详细解析与应用分析芊言芊语 kafka 分布式
Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
Kafka 基础与架构理解 StaticKing KAFKA kafka
目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
git 恢复误删的远程分支 Hanfank
需求实际工作上，肯定会有不小心的时候，比如我吧，删除了本地dev分支，intellijidea提示是否将trackedbranch也删掉，结果一不小心将远程分支也删除了，接下来就是我的救赎之旅。查看reflog，找到最后一次commitidgitreflog--date=isoreflog是referencelog的意思，也就是引用log，记录HEAD在各个分支上的移动轨迹。选项--date=is
Flume：大规模日志收集与数据传输的利器傲雪凌霜，松柏长青后端大数据 flume 大数据
Flume：大规模日志收集与数据传输的利器在大数据时代，随着各类应用的不断增长，产生了海量的日志和数据。这些数据不仅对业务的健康监控至关重要，还可以通过深入分析，帮助企业做出更好的决策。那么，如何高效地收集、传输和存储这些海量数据，成为了一项重要的挑战。今天我们将深入探讨ApacheFlume，它是如何帮助我们应对这些挑战的。一、Flume概述ApacheFlume是一个分布式、可靠、可扩展的日志
【免费】springboot项目申报管理系统|毕业设计|Javaweb项目计算机学姐来啦 springboot ssm java spring boot 课程设计后端毕设毕业设计 java-ee
收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
探索未来，大规模分布式深度强化学习——深入解析IMPALA架构汤萌妮Margaret
探索未来，大规模分布式深度强化学习——深入解析IMPALA架构scalable_agent项目地址:https://gitcode.com/gh_mirrors/sc/scalable_agent在当今的人工智能研究前沿，深度强化学习（DRL）因其在复杂任务中的卓越表现而备受瞩目。本文要介绍的是一个开源于GitHub的重量级项目：“ScalableDistributedDeep-RLwithImp
全面指南：用户行为从前端数据采集到实时处理的最佳实践数字沉思营销流量运营系统架构前端内容运营大数据
引言在当今的数据驱动世界，实时数据采集和处理已经成为企业做出及时决策的重要手段。本文将详细介绍如何通过前端JavaScript代码采集用户行为数据、利用API和Kafka进行数据传输、通过Flink实时处理数据的完整流程。无论你是想提升产品体验还是做用户行为分析，这篇文章都将为你提供全面的解决方案。设计一个通用的ClickHouse表来存储用户事件时，需要考虑多种因素，包括事件类型、时间戳、用户信
车载以太网之SOME/IP IT_码农车载以太网车载以太网 SOME/IP
整体介绍SOME/IP(全称为：Scalableservice-OrientedMiddlewarEoverIP)，是运行在车载以太网协议栈基础之上的中间件，或者也可以称为应用层软件。发展历程AUTOSAR4.0-完成宝马SOME/IP消息的初步集成；AUTOSAR4.1-支持SOME/IP-SD及其发布/订阅功能；AUTOSAR4.2-添加transformer用于序列化以及其他相关优化；AUT
Docker安装Kafka和Kafka-Manager 阿靖哦
本文介绍如何通过Docker安装kafka与kafka界面管理界面一、拉取zookeeper由于kafka需要依赖于zookeeper，因此这里先运行zookeeper1、拉取镜像dockerpullwurstmeister/zookeeper2、启动dockerrun-d--namezookeeper-p2181:2181-eTZ="Asia/Shanghai"--restartalwayswu
主流行架构 rainbowcheng 架构架构
nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
python基于django/flask的NBA球员大数据分析与可视化python+java+node.js QQ_511008285 python django flask java spring boot 数据分析
前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以本文针对NBA球员的大数据进行
Java基于spring boot的国产电影数据分析与可视化python+java+node.js QQ_511008285 java spring boot 数据分析 python django vue.js flask
前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以该系统使用进行大数据处理和
idea右侧工具栏找不到maven窗口足球数据分析 intellij-idea
idea没有识别到是maven项目处理方案：右键pom.xml文件,点击"addasmavenproject"
[附源码]SSM计算机毕业设计游戏账号交易平台JAVA 计算机程序源码 java 游戏 mysql
项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
月度总结 | 2022年03月 | 考研与就业的抉择 | 确定未来走大数据开发路线「已注销」个人总结 hadoop
一、时间线梳理3月3日，寻找到同专业的就业伙伴3月5日，着手准备Java八股文，决定先走Java后端路线3月8月，申请到了校图书馆的考研专座，决定暂时放弃就业，先准备考研，买了数学和408的资料书3月9日-3月13日，因疫情原因，宿舍区暂封，这段时间在准备考研，发现内容特别多3月13日-3月19日，大部分时间在刷Hadoop、Zookeeper、Kafka的视频，同时在准备实习的项目3月20日，退
分布式消息队列Kafka 叶域大数据分布式 kafka scala spark
分布式消息队列Kafka简介：Kafka是一个分布式消息队列系统，用于处理实时数据流。消息按照主题（Topic）进行分类存储，发送消息的实体称为Producer，接收消息的实体称为Consumer。Kafka集群由多个Kafka实例（Server）组成，每个实例称为Broker。主要用途：广泛应用于构建实时数据管道和流应用程序，适用于需要高吞吐量和低延迟的数据处理场景依赖：Kafka集群和消费者依
K8S学习之PV&&PVC david161
部署mysql之前我们需要先了解一个概念有状态服务。这是一种特殊的服务，简单的归纳下就是会产生需要持久化的数据，并且有很强的I/O需求，且重启需要依赖上次存储到磁盘的数据。如典型的mysql，kafka，zookeeper等等。在我们有比较优秀的商业存储的前提下，非常推荐使用有状态服务进行部署，计算和存储分离那是相当的爽的。在实际生产中如果没有这种存储，localPV也是不错的选择，当然local
Java 入门基础篇05 - Java的关键字仔仔 v1.0 Java基础 java 开发语言 intellij-idea
什么是关键字？就是被java语言赋予特殊含义的单词。关键字的特点组成关键的字母都是小写。常见关键字class,public,static,void.....。关键字注意事项goto和const是java语言的保留字，关键字在IDEA编译器中有明确的颜色变化。关键字列表ABSTRACTCONTINUEFORNEWSWITCHassertdefaultgotopackagesynchronizedbo
关于旗正规则引擎中的MD5加密问题何必如此 jsp MD5 规则加密
一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 2.在规
【Spark101】Scala Promise/Future在Spark中的应用 bit1129 Promise
Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
spark sql 访问hive数据的配置详解 daizj spark sql hive thriftserver
spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下： 1、下载源码 2、下载Maven,并配置此配置简单，就略过
HTTP 协议通信周凡杨 java httpclient http 通信
一：简介 HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！二：代码举例测试类： import java
java unix时间戳转换 g21121 java
把java时间戳转换成unix时间戳： Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())) SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
web报表工具FineReport常用函数的用法总结（报表函数）老A不折腾 web报表 finereport 总结
说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。 CLASS CLASS(object):返回object对象的所属的类。 CNMONEY CNMONEY(number,unit)返回人民币大写。 number:需要转换的数值型的数。 unit:单位，
java jni调用c++ 代码报错墙头上一根草 java C++jni
# # A fatal error has been detected by the Java Runtime Environment: # # EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 # # JRE version: Java(TM) SE Ru
Spring中事件处理de小技巧 aijuans spring Spring 教程 Spring 实例 Spring 入门 Spring3
Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
linux shell ls脚本样例 annan211 linux linux ls源码 linux 源码
#! /bin/sh - #查找输入文件的路径 #在查找路径下寻找一个或多个原始文件或文件模式 # 查找路径由特定的环境变量所定义 #标准输出所产生的结果通常是查找路径下找到的每个文件的第一个实体的完整路径 # 或是filename :not found 的标准错误输出。 #如果文件没有找到则退出码为0 #否则即为找不到的文件个数 #语法 pathfind [--
List,Set,Map遍历方式 (收集的资源,值得看一下) 百合不是茶 list set Map遍历方式
List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
解决SimpleDateFormat的线程不安全问题的方法 bijian1013 java thread 线程安全
在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： public class DateUtil01 { private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void format(Date d
http请求测试实例（采用fastjson解析） bijian1013 http 测试
在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 import java.util.HashMap; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import
【RPC框架Hessian三】Hessian 异常处理 bit1129 hessian
RPC异常处理概述 RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
【日志分析】日志分析工具 bit1129 日志分析
1. 网站日志实时分析工具 GoAccess http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 3.log.io 和
nginx优化加强战斗力及遇到的坑解决 ronin47 nginx 优化
　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。　　　来以下优化：　　　
java-50-输入两棵二叉树A和B，判断树B是不是A的子结构 bylijinnan java
思路来自： http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ import ljn.help.*; public class HasSubtree { /**Q50. * 输入两棵二叉树A和B，判断树B是不是A的子结构。例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
mongoDB 备份与恢复开窍的石头 mongDB备份与恢复
Mongodb导出与导入 1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通用选项: -h host 主机 --port port 端口 -u username 用户名 -p passwd 密码 2: mongoexport 导出json格式的文件
[网络与通讯]椭圆轨道计算的一些问题 comsci 网络
如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
软件专利如何申请 cuiyadll 软件专利申请
软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
Android学习笔记 darrenzhu android
1.启动一个AVD 2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 3.如何启动一个程序 am start -n package name/.activityName am start -n com.example.helloworld/.MainActivity 启动Android设置工具的命令如下所示： # am start -
apache虚拟机配置，本地多域名访问本地网站 dcj3sjt126com apache
现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 1、首先修改C盘WINDOWS\system32\drivers\etc目录下的
yii2 restful web服务[速率限制] dcj3sjt126com PHP yii2
速率限制为防止滥用，你应该考虑增加速率限制到您的API。例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。如果一个用户同一个时间段内太多的请求被接收，将返回响应状态代码 429 (这意味着过多的请求)。要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
Hadoop2.5.2安装——单机模式 eksliang hadoop hadoop单机部署
转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述 Hadoop有三种模式单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。二、下载地址 Hadoop 网址http:
LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构 gundumw100 android
一切为了快速迭代 import java.util.ArrayList; import org.json.JSONObject; import android.animation.ObjectAnimator; import android.os.Bundle; import android.support.v4.widget.SwipeRefreshLayo
三道简单的前端HTML/CSS题目 ini html Web 前端 css 题目
使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm 在HTML中加入<table style=”color:red; font-size:10pt”>，此为（）。http://hovertree.com/s
overrided方法编译错误 kane_xie override
问题描述：在实现类中的某一或某几个Override方法发生编译错误如下： Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it 当去掉@Over
Java中使用代理IP获取网址内容（防IP被封，做数据爬虫） mcj8089 免费代理IP 代理IP 数据爬虫 JAVA设置代理IP 爬虫封IP
推荐两个代理IP网站： 1. 全网代理IP：http://proxy.goubanjia.com/ 2. 敲代码免费IP：http://ip.qiaodm.com/ Java语言有两种方式使用代理IP访问网址并获取内容，方式一，设置System系统属性 // 设置代理IP System.getProper
Nodejs Express 报错之 listen EADDRINUSE qiaolevip 每天进步一点点学习永无止境 nodejs 纵观千象
当你启动 nodejs服务报错： >node app Express server listening on port 80 events.js:85 throw er; // Unhandled 'error' event ^ Error: listen EADDRINUSE at exports._errnoException (
C++中三种new的用法 _荆棘鸟_ C++new
转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 作者: mt 其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： string* ps = new string("
Ruby深入研究笔记1 wudixiaotie Ruby
module是可以定义private方法的 module MTest def aaa puts "aaa" private_method end private def private_method puts "this is private_method" end end