信仰啊QAQ
信仰啊QAQ

KAFKA

【KAFKA】

名词解释

（1）Producer：消息生产者，就是向 Kafka broker 发消息的客户端。
（2）Consumer：消息消费者，向 Kafka broker 取消息的客户端。
（3）Consumer Group（CG）：消费者组，由多个 consumer 组成。消费者组内每个消
费者负责消费不同分区的数据，一个分区只能由一个组内消费者消费；消费者组之间互不
影响。所有的消费者都属于某个消费者组，即消费者组是逻辑上的一个订阅者。
（4）Broker：一台 Kafka 服务器就是一个 broker。一个集群由多个 broker 组成。一个
broker 可以容纳多个 topic。
（5）Topic：可以理解为一个队列，生产者和消费者面向的都是一个 topic。
（6）Partition：为了实现扩展性，一个非常大的 topic 可以分布到多个 broker（即服
务器）上，一个 topic 可以分为多个 partition，每个 partition 是一个有序的队列。
（7）Replica：副本。一个 topic 的每个分区都有若干个副本，一个 Leader 和若干个
Follower。
（8）Leader：每个分区多个副本的“主”，生产者发送数据的对象，以及消费者消费数
据的对象都是 Leader。
（9）Follower：每个分区多个副本中的“从”，实时从 Leader 中同步数据，保持和
Leader 数据的同步。Leader 发生故障时，某个 Follower 会成为新的 Leader

MessageQueue是什么

消息队列是一种在分布式和大数据开发中不可或缺的中间件。在分布式开发或者大数据开发中通常使用消息队列进行缓冲、系统间解耦和削峰填谷等业务场景，常见的消息队列工作模式大致会分为两大类：

- 至多一次：消息生产者将数据写入消息系统，然后由消费者负责去拉去消息服务器中的消息，一旦消息被确认消费之后 ，由消息服务器主动删除队列中的数据，这种消费方式一般只允许被一个消费者消费，并且消息队列中的数据不允许被重复消费。

- 没有限制:同上诉消费形式不同，生产者发不完数据以后，该消息可以被多个消费者同时消费，并且同一个消费者可以多次消费消息服务器中的同一个记录。主要是因为消息服务器一般可以长时间存储海量消息。

Kafka 基础架构

Kafka集群以Topic形式负责分类集群中的Record每一个Record属于一个Topic。每个Topic底层都会对应一组分区的日志用于持久化Topic中的Record。同时在Kafka集群中，Topic的每一个日志的分区都一定会有1个Borker担当该分区的Leader，其他的Broker担当该分区的follower，Leader负责分区数据的读写操作，follower负责同步改分区的数据。这样如果分区的Leader宕机，改分区的其他follower会选取出新的leader继续负责该分区数据的读写。其中集群的中Leader的监控和Topic的部分元数据是存储在Zookeeper中.

Topics and Logs

Kafka中所有消息是通过Topic为单位进行管理，每个Kafka中的Topic通常会有多个订阅者，负责订阅发送到改Topic中的数据。Kafka负责管理集群中每个Topic的一组日志分区数据。

生产者将数据发布到相应的Topic。负责选择将哪个记录分发送到Topic中的哪个Partition。例如可以round-robin方式完成此操作，然而这种仅是为了平衡负载。也可以根据某些语义分区功能（例如基于记录中的Key）进行此操作。

每组日志分区是一个有序的不可变的的日志序列，分区中的每一个Record都被分配了唯一的序列编号称为是offset，Kafka 集群会持久化所有发布到Topic中的Record信息，改Record的持久化时间是通过配置文件指定,默认是168小时。

log.retention.hours=168

Kafka底层会定期的检查日志文件，然后将过期的数据从log中移除，由于Kafka使用硬盘存储日志文件，因此使用Kafka长时间缓存一些日志文件是不存在问题的。

在消费者消费Topic中数据的时候，每个消费者会维护本次消费对应分区的偏移量，消费者会在消费完一个批次的数据之后，会将本次消费的偏移量提交给Kafka集群，因此对于每个消费者而言可以随意的控制改消费者的偏移量。因此在Kafka中，消费者可以从一个topic分区中的任意位置读取队列数据，由于每个消费者控制了自己的消费的偏移量，因此多个消费者之间彼此相互独立。

Kafka中对Topic实现日志分区的有以下目的：

- 首先，它们允许日志扩展到超出单个服务器所能容纳的大小。每个单独的分区都必须适合托管它的服务器，但是一个Topic可能有很多分区，因此它可以处理任意数量的数据。

- 其次每个服务器充当其某些分区的Leader，也可能充当其他分区的Follwer，因此群集中的负载得到了很好的平衡。

生产者&消费者

消费者使用Consumer Group名称标记自己，并且发布到Topic的每条记录都会传递到每个订阅Consumer Group中的一个消费者实例。如果所有Consumer实例都具有相同的Consumer Group，那么Topic中的记录会在改ConsumerGroup中的Consumer实例进行均分消费；如果所有Consumer实例具有不同的ConsumerGroup，则每条记录将广播到所有Consumer Group进程。

更常见的是，我们发现Topic具有少量的Consumer Group，每个Consumer Group可以理解为一个“逻辑的订阅者”。每个Consumer Group均由许多Consumer实例组成，以实现可伸缩性和容错能力。这无非就是发布-订阅模型，其中订阅者是消费者的集群而不是单个进程。这种消费方式Kafka会将Topic按照分区的方式均分给一个Consumer Group下的实例，如果ConsumerGroup下有新的成员介入，则新介入的Consumer实例会去接管ConsumerGroup内其他消费者负责的某些分区，同样如果一下ConsumerGroup下的有其他Consumer实例宕机，则由改ConsumerGroup其他实例接管。

由于Kafka的Topic的分区策略，因此Kafka仅提供分区中记录的有序性，也就意味着相同Topic的不同分区记录之间无顺序。因为针对于绝大多数的大数据应用和使用场景， 使用分区内部有序或者使用key进行分区策略已经足够满足绝大多数应用场景。但是，如果您需要记录全局有序，则可以通过只有一个分区Topic来实现，尽管这将意味着每个ConsumerGroup只有一个Consumer进程。

高性能之道-顺序写&mmap

Kafka的特性之一就是高吞吐率，但是Kafka的消息是保存或缓存在磁盘上的，一般认为在磁盘上读写数据是会降低性能的，但是Kafka即使是普通的服务器，Kafka也可以轻松支持每秒百万级的写入请求，超过了大部分的消息中间件，这种特性也使得Kafka在日志处理等海量数据场景广泛应用。Kafka会把收到的消息都写入到硬盘中，防止丢失数据。为了优化写入速度Kafka采用了两个技术顺序写入和MMFile 。

因为硬盘是机械结构，每次读写都会寻址->写入，其中寻址是一个“机械动作”，它是最耗时的。所以硬盘最讨厌随机I/O，最喜欢顺序I/O。为了提高读写硬盘的速度，Kafka就是使用顺序I/O。这样省去了大量的内存开销以及节省了IO寻址的时间。但是单纯的使用顺序写入，Kafka的写入性能也不可能和内存进行对比，因此Kafka的数据并不是实时的写入硬盘中 。

Kafka充分利用了现代操作系统分页存储来利用内存提高I/O效率。Memory Mapped Files(后面简称mmap)也称为内存映射文件，在64位操作系统中一般可以表示20G的数据文件，它的工作原理是直接利用操作系统的Page实现文件到物理内存的直接映射。完成MMP映射后，用户对内存的所有操作会被操作系统自动的刷新到磁盘上，极大地降低了IO使用率。

网络IO
一般方案

1、文件在磁盘中数据被copy到内核缓冲区

2、从内核缓冲区copy到用户缓冲区

3、用户缓冲区copy到内核与socket相关的缓冲区。

4、数据从socket缓冲区copy到相关协议引擎发送出去

Zero拷贝

1、文件在磁盘中数据被copy到内核缓冲区

2、从内核缓冲区copy到内核与socket相关的缓冲区。

3、数据从socket缓冲区copy到相关协议引擎发送出去

第二章: 安装&部署

环境搭建-单机

u安装JDK1.8+，配置JAVA_HOME (CentOS 6.10 64bit)

u配置主机名和IP映射

u关闭防火墙&防火墙开机自启动

u安装&启动Zookeeper

u安装&启动|关闭Kafka

环境搭建-集群

u安装JDK，配置JAVA_HOME (CentOS 6.10 64bit)

u配置主机名和IP映射

u关闭防火墙&防火墙开机自启动

u同步时钟 ntpdate cn.pool.ntp.org | ntp[1-7].aliyun.com

u安装&启动Zookeeper

u安装&启动|关闭Kafka

启动
启动zookeeper

进入bin文件夹

# cd /usr/local/zookeeper/bin
# ./zkServer.sh start

通过status查看启动状态。稍微有个等待时间

# ./zkServer.sh status

启动kafka

启动kafka命令

cd /usr/local/kafka_2.2.0/
bin/kafka-server-start.sh -daemon config/server.properties

关闭命令

bin/kafka-server-stop.sh

Topic管理
创建
[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-topics.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --create --topic topic02 --partitions 3 --replication-factor 3
查看
[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-topics.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --list
详情
[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-topics.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --describe --topic topic01

Topic:topic01  PartitionCount:3  ReplicationFactor:3  Configs:segment.bytes=1073741824

  Topic: topic01  Partition: 0  Leader: 0  Replicas: 0,2,3  Isr: 0,2,3

  Topic: topic01  Partition: 1  Leader: 2  Replicas: 2,3,0  Isr: 2,3,0

  Topic: topic01  Partition: 2  Leader: 0  Replicas: 3,0,2  Isr: 0,2,3
修改
[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-topics.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --create --topic topic03 --partitions 1  --replication-factor 1

[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-topics.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --alter --topic topic03 --partitions 2
删除
[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-topics.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --delete --topic topic03
订阅
[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-console-consumer.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --topic topic01 --group g1 --property print.key=true --property print.value=true  --property key.separator=,
生产
[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-console-producer.sh --broker-list node1:9092,node2:9092,node3:9092 --topic topic01
消费组
[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-consumer-groups.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --list g1
[root@node1 kafka_2.11-2.2.0]# ./bin/kafka-consumer-groups.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --describe --group g1

TOPIC PARTITION CURRENT-OFFSET LOG-END-OFFSET LAG CONSUMER-ID    HOST            CLIENT-ID

topic01 1                      0                    0                           0     consumer-1-**    /192.168.52.130 consumer-1

topic01 0                      0                    0                          0      consumer-1-**   /192.168.52.130 consumer-1

topic01 2                      1                     1                          0      consumer-1-**   /192.168.52.130 consumer-1

第三章: Kafka 基础API

1、Topic基本操作 DML管理

2、生产者

3、消费者 sub/assign

4、自定义分区

5、序列化

6、拦截器

POM


    org.apache.kafka
    kafka-clients
    2.2.0




    log4j
    log4j
    1.2.17



    org.slf4j
    slf4j-api
    1.7.25



    org.slf4j
    slf4j-log4j12
    1.7.25




    org.apache.commons
    commons-lang3
    3.9
日志文件 log4j.properties
log4j.rootLogger = info,console

log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern =  %p %d{yyyy-MM-dd HH:mm:ss} %c - %m%n
1、Topic基本操作 DML管理

需在本地配上 主机和IP的映射

192.168.1.111 node1
192.168.1.112 node2
192.168.1.113 node3

C:\Windows\System32\drivers\etc

public class TopicDMLDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //配置连接参数
        Properties props = new Properties();
        props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,
                    "node1:9092,node2:9092,node3:9092");

        KafkaAdminClient adminClient= (KafkaAdminClient) KafkaAdminClient.create(props);

        //查询topics
        KafkaFuture> nameFutures = adminClient.listTopics().names();
        for (String name : nameFutures.get()) {
            System.out.println(name);
        }

        //创建Topics
        List newTopics = Arrays.asList(new NewTopic("topic02", 2, (short) 3));
        createTopicsResult.all().get();//同步创建

        //删除Topic
       // adminClient.deleteTopics(Arrays.asList("topic02"));

        //查看Topic详情
        DescribeTopicsResult describeTopics =
                adminClient.describeTopics(Arrays.asList("topic01"));
        Map tdm = describeTopics.all().get();
        for (Map.Entry entry : tdm.entrySet()) {
            System.out.println(entry.getKey()+"\t"+entry.getValue());
        }

         //关闭连接
        adminClient.close();
    }
}
2、生产者

生产者端

public class ProducerQuickStart {
    public static void main(String[] args) {
        //1、创建生产者
        Properties prop = new Properties();
        prop.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        KafkaProducer producer = new KafkaProducer<>(prop);
        //2、发送消息
        for (int i = 0; i < 10; i++) {
            ProducerRecord record = new ProducerRecord<>("topic01", "key"+i, "value"+i);
            producer.send(record);
        }
        //关闭
        producer.close();
    }
}
3、消费者 sub/assign

subscribe订阅模式下，必须设置消费者组

只能保证分区有序性

subscribe 模式

public class ConsumerQuickStart1 {
    public static void main(String[] args) {
        //1.创建Kafka链接参数
        Properties prop = new Properties();
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.GROUP_ID_CONFIG,"g2");//kafka中消费者通常以组的方式消费
        //2.创建Topic消费者
        KafkaConsumer consumer = new KafkaConsumer<>(prop);

        //3.订阅topic开头的消息队列
        consumer.subscribe(Pattern.compile("^topic.*"));

        while (true){
            ConsumerRecords records = consumer.poll(Duration.ofNanos(1));//每隔一秒取数据
            //有数据
            while (true){
                ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(1));
                Iterator> recordIterator = consumerRecords.iterator();
                while (recordIterator.hasNext()){
                    ConsumerRecord record = recordIterator.next();
                    String key = record.key();
                    String value = record.value();
                    long offset = record.offset();
                    int partition = record.partition();
                    System.out.println("key:"+key+",value:"+value+",partition:"+partition+",offset:"+offset);
                }
            }
        }
    }
}

assign 模式

public class ConsumerQuickStart1 {
    public static void main(String[] args) {
        //1.创建Kafka链接参数
        Properties prop = new Properties();
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.GROUP_ID_CONFIG,"g2");//kafka中消费者通常以组的方式消费
        //2.创建Topic消费者
        KafkaConsumer consumer = new KafkaConsumer<>(prop);
        //3. 订阅相关的topics，手动指定消费分区，失去组管理特性
        List partitions = Arrays.asList(new TopicPartition("topic01", 0));
        //3.订阅topic开头的消息队列
        consumer.assign(partitions);
        //指定消费分区的位置
        consumer.seekToBeginning(partitions);

        while (true){
            ConsumerRecords records = consumer.poll(Duration.ofNanos(1));//每隔一秒取数据
            //有数据
            while (true){
                ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(1));
                Iterator> recordIterator = consumerRecords.iterator();
                while (recordIterator.hasNext()){
                    ConsumerRecord record = recordIterator.next();
                    String key = record.key();
                    String value = record.value();
                    long offset = record.offset();
                    int partition = record.partition();
                    System.out.println("key:"+key+",value:"+value+",partition:"+partition+",offset:"+offset);
                }
            }
        }
    }
}
4、自定义分区

默认分区策略：

1、如果指定策略，会按照我们的策略 比如设置了发送给分区1

2、如果没指定策略，如果有key 会按hash key的方式选择分区

3、如果也没有key ，会采用round-robin 的方式轮训

如果需要自定义分区 ，需要实现Partitioner接口，

configure() ：加载配置项

partition()：核心处理逻辑

public class UserDefinePartitioner  implements Partitioner {
    private AtomicInteger atomicInteger=new AtomicInteger(0);
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        //获取所有分区
        int numPartitions = cluster.partitionsForTopic(topic).size();
        if(keyBytes==null || keyBytes.length==0){
        int andIncrement = counter.getAndIncrement();
        //与上int最大值，保证是个正数
            return (andIncrement & Integer.MAX_VALUE) % numPartitions;
        } else {
            return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
        }
    }

    @Override
    public void close() {
        System.out.println("close");
    }

    @Override
    public void configure(Map configs) {
        System.out.println("configure");
    }
}
5、自定义序列化器

实现Serializer 接口

public class ObjectSerializer implements Serializer {

    @Override
    public void configure(Map configs, boolean isKey) {
        System.out.println("configure");
    }

    @Override
    public byte[] serialize(String topic, Object data) {
        return SerializationUtils.serialize((Serializable) data);
    }

    @Override
    public void close() {
        System.out.println("close");
    }
}


生产者


public class ProducerQuickStart {
    public static void main(String[] args) {
        //1、创建生产者
        Properties prop = new Properties();
        prop.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, ObjectSerializer.class.getName());
        KafkaProducer producer = new KafkaProducer<>(prop);
        //2、发送消息
        for (int i = 0; i < 10; i++) {
            ProducerRecord record = new ProducerRecord<>("topic02", "key"+i, new User(i,"name"+i,new Date()));
            producer.send(record);
        }
        //关闭
        producer.close();
    }
}



消费者


public class ConsumerQuickStart {
    public static void main(String[] args) {
        //1.创建Kafka链接参数
        Properties prop = new Properties();
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, ObjectDeserializer.class.getName());
        prop.put(ConsumerConfig.GROUP_ID_CONFIG,"g2");//kafka中消费者通常以组的方式消费
        //2.创建Topic消费者
        KafkaConsumer consumer = new KafkaConsumer<>(prop);

        //3.订阅topic开头的消息队列
        consumer.subscribe(Arrays.asList("topic02"));

        while (true){
            ConsumerRecords records = consumer.poll(Duration.ofNanos(1));//每隔一秒取数据
            //有数据
            while (true){
                ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(1));
                Iterator> recordIterator = consumerRecords.iterator();
                while (recordIterator.hasNext()){
                    ConsumerRecord record = recordIterator.next();
                    String key = record.key();
                    User value = record.value();
                    long offset = record.offset();
                    int partition = record.partition();
                    System.out.println("key:"+key+",value:"+value+",partition:"+partition+",offset:"+offset);
                }
            }
        }
    }
}



6、自定义拦截器


实现ProducerInterceptor 接口


public class UserDefineInterceptor implements ProducerInterceptor {
    @Override
    public ProducerRecord onSend(ProducerRecord producerRecord) {
        ProducerRecord wrapRecord = new ProducerRecord(producerRecord.topic(), producerRecord.key(), producerRecord.value()+ "---mashibing");
//        wrapRecord.headers().add("user","mashibing".getBytes());
        return wrapRecord;
    }

    @Override
    public void onAcknowledgement(RecordMetadata recordMetadata, Exception e) {
        System.out.println("metadata:"+recordMetadata+",exception:"+e);
    }

    @Override
    public void close() {

    }

    @Override
    public void configure(Map map) {

    }
}


生产者端
public class ProducerQuickStart {
    public static void main(String[] args) {
        //1、创建生产者
        Properties prop = new Properties();
        prop.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,UserDefineInterceptor.class.getName());
        KafkaProducer producer = new KafkaProducer<>(prop);
        //2、发送消息
        for (int i = 0; i < 5; i++) {
            ProducerRecord record = new ProducerRecord<>("topic01", "key"+i, "value"+i);
            producer.send(record);
        }
        //关闭
        producer.close();
    }
}



第四章、Kafka 高级API


Offset自动控制


Kafka消费者默认对于未订阅的topic的offset的时候，也就是系统并没有存储该消费者的消费分区的记录信息，默认Kafka消费者的默认首次消费策略：latest


auto.offset.reset=latest


uearliest - 自动将偏移量重置为最早的偏移量


ulatest - 自动将偏移量重置为最新的偏移量


unone - 如果未找到消费者组的先前偏移量，则向消费者抛出异常


Kafka消费者在消费数据的时候默认会定期的提交消费的偏移量，这样就可以保证所有的消息至少可以被消费者消费1次,用户可以通过以下两个参数配置：


enable.auto.commit = true 默认


auto.commit.interval.ms = 5000 默认


如果用户需要自己管理offset的自动提交，可以关闭offset的自动提交，手动管理offset提交的偏移量，注意用户提交的offset偏移量永远都要比本次消费的偏移量+1，因为提交的offset是kafka消费者下一次抓取数据的位置。


props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,true);//开启自动提交
props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,10000);//十秒后自动提交



Offset手动管理


public class KafkaConsumerDemo_02 {
    public static void main(String[] args) {
        //1.创建Kafka链接参数
        Properties props=new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        props.put(ConsumerConfig.GROUP_ID_CONFIG,"group01");
        //关闭自动提交
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);

        //2.创建Topic消费者
        KafkaConsumer consumer=new KafkaConsumer(props);
        //3.订阅topic开头的消息队列
        consumer.subscribe(Pattern.compile("^topic.*$"));

        while (true){
            ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(1));
            Iterator> recordIterator = consumerRecords.iterator();
            while (recordIterator.hasNext()){
                ConsumerRecord record = recordIterator.next();
                String key = record.key();
                String value = record.value();
                long offset = record.offset();
                int partition = record.partition();
                Map offsets=new HashMap();

                offsets.put(new TopicPartition(record.topic(),partition),new OffsetAndMetadata(offset));
                consumer.commitAsync(offsets, new OffsetCommitCallback() {
                    @Override
                    public void onComplete(Map offsets, Exception exception) {
                        System.out.println("完成："+offset+"提交！");
                    }
                });
                System.out.println("key:"+key+",value:"+value+",partition:"+partition+",offset:"+offset);

            }
        }
    }
}



Acks & Retries


Kafka生产者在发送完一个的消息之后，要求Broker在规定的额时间Ack应答答，如果没有在规定时间内应答，Kafka生产者会尝试n次重新发送消息。


acks=1 默认


acks=1 - Leader会将Record写到其本地日志中，但会在不等待所有Follower的完全确认的情况下做出响应。在这种情况下，如果Leader在确认记录后立即失败，但在Follower复制记录之前失败，则记录将丢失。


acks=0 - 生产者根本不会等待服务器的任何确认。该记录将立即添加到套接字缓冲区中并视为已发送。在这种情况下，不能保证服务器已收到记录。


acks=all - 这意味着Leader将等待全套同步副本确认记录。这保证了只要至少一个同步副本仍处于活动状态，记录就不会丢失。这是最有力的保证。这等效于acks = -1设置。


如果生产者在规定的时间内，并没有得到Kafka的Leader的Ack应答，Kafka可以开启reties重试机制。


request.timeout.ms = 30000 默认


retries = 2147483647 默认


KAFKA_第1张图片


//超时设置
props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,1);
//ack 设置
props.put(ProducerConfig.ACKS_CONFIG,"-1");
//重试次数
props.put(ProducerConfig.RETRIES_CONFIG,10);



幂等性


HTTP/1.1中对幂等性的定义是：一次和多次请求某一个资源对于资源本身应该具有同样的结果（网络超时等问题除外）。也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。


Methods can also have the property of “idempotence” in that (aside from error or expiration issues) the side-effects of N > 0 identical requests is the same as for a single request.


Kafka在0.11.0.0版本支持增加了对幂等的支持。幂等是针对生产者角度的特性。幂等可以保证上生产者发送的消息，不会丢失，而且不会重复。实现幂等的关键点就是服务端可以区分请求是否重复，过滤掉重复的请求。要区分请求是否重复的有两点：


唯一标识：要想区分请求是否重复，请求中就得有唯一标识。例如支付请求中，订单号就是唯一标识


记录下已处理过的请求标识：光有唯一标识还不够，还需要记录下那些请求是已经处理过的，这样当收到新的请求时，用新请求中的标识和处理记录进行比较，如果处理记录中有相同的标识，说明是重复记录，拒绝掉。


KAFKA_第2张图片


幂等性 需设置以下几个参数


//ack 设置  必须设置为all
prop.put(ProducerConfig.ACKS_CONFIG,"all");
//重试次数  要求大于0
prop.put(ProducerConfig.RETRIES_CONFIG,10);
//开启kafka的幂等性
prop.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);
//设置为1 严格保证有序   要求小于5
prop.put(ProducerConfig.MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION,1);



事务控制


Kafka的幂等性，只能保证一条记录的在分区发送的原子性，但是如果要保证多条记录（多分区）之间的完整性，这个时候就需要开启kafk的事务操作。


在Kafka0.11.0.0除了引入的幂等性的概念，同时也引入了事务的概念。通常Kafka的事务分为 *生产者事务Only、**消费者&生产者事务。一般来说默认消费者消费的消息的级别是read_uncommited数据，这有可能读取到事务失败的数据，所有在开启生产者事务之后，需要用户设置消费者的事务隔离级别。


isolation.level = read_uncommitted 默认


该选项有两个值read_committed|read_uncommitted，如果开始事务控制，消费端必须将事务的隔离级别设置为read_committed


开启的生产者事务的时候，只需要指定transactional.id属性即可，一旦开启了事务，默认生产者就已经开启了幂等性。但是要求"transactional.id"的取值必须是唯一的，同一时刻只能有一个"transactional.id"存储在，其他的将会被关闭。


public class ProducerTransactionProducerOnly {
    public static void main(String[] args) {
        KafkaProducer producer = buildProducer();
        //1、初始化事务
        producer.initTransactions();
        try {
            //2.开始事务
            producer.beginTransaction();

            for (int i = 0; i < 10; i++) {
                if (i==8){
                    int j = 10/0;
                }
                ProducerRecord record = new ProducerRecord<>("topic01", "transaction"+i, "value"+i);
                producer.send(record);
                producer.flush();
                //3.提交事务

            }
            producer.commitTransaction();
        }catch (Exception e){
            System.out.println("消息出错了" + e.getMessage());
            //4.终止事务
            producer.abortTransaction();
        }finally {
            producer.close();
        }
}
   
public static KafkaProducer buildProducer(){
        //1、创建生产者
        Properties prop = new Properties();
        prop.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //必须配置事务ID  ，必须唯一
        prop.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"transaction-id"+ UUID.randomUUID().toString());
        //配置kafka批处理大小
        prop.put(ProducerConfig.BATCH_SIZE_CONFIG,1024);
        //等待5ms 如果batch中的数据还不够1024大小  也会发送
        prop.put(ProducerConfig.LINGER_MS_CONFIG,5);
        //配置kafka重试机制和幂等性
        prop.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);
        prop.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,20000);
        prop.put
                (ProducerConfig.ACKS_CONFIG,"all");
        return new KafkaProducer<>(prop);
    }

}




读已提交



public class ConsumerTransactionReadCommited {
    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.GROUP_ID_CONFIG,"g1");//kafka中消费者通常以组的方式消费
        //设置消费者的消费事务的隔离级别read commited
        prop.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG,"read_committed ");
        

        KafkaConsumer consumer = new KafkaConsumer<>(prop);
        consumer.subscribe(Arrays.asList("topic01"));

        while (true){
            ConsumerRecords records = consumer.poll(Duration.ofNanos(1));//每隔一秒取数据
            //有数据
            while (true){
                ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(1));
                Iterator> recordIterator = consumerRecords.iterator();
                while (recordIterator.hasNext()){
                    ConsumerRecord record = recordIterator.next();
                    String key = record.key();
                    String value = record.value();
                    long offset = record.offset();
                    int partition = record.partition();
                    System.out.println("key:"+key+",value:"+value+",partition:"+partition+",offset:"+offset);
                }
            }
        }
    }
}




读未提交 出异常了也能读到消息


public class ConsumerTransactionReadUncommited {
    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.GROUP_ID_CONFIG,"g2");//kafka中消费者通常以组的方式消费
        prop.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG,"read_uncommitted");

        KafkaConsumer consumer = new KafkaConsumer<>(prop);
        consumer.subscribe(Arrays.asList("topic01"));

        while (true){
            ConsumerRecords records = consumer.poll(Duration.ofNanos(1));//每隔一秒取数据
            //有数据
            while (true){
                ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(1));
                Iterator> recordIterator = consumerRecords.iterator();
                while (recordIterator.hasNext()){
                    ConsumerRecord record = recordIterator.next();
                    String key = record.key();
                    String value = record.value();
                    long offset = record.offset();
                    int partition = record.partition();
                    System.out.println("key:"+key+",value:"+value+",partition:"+partition+",offset:"+offset);
                }
            }
        }
    }
}



既是生产者又是消费者 用于做数据的转换。


public class ProducerTransactionProducerAndConsumer {
    public static void main(String[] args) {
        KafkaProducer producer = buildProducer();
        KafkaConsumer consumer = buildConsumer("g1");

        //1、初始化事务
        producer.initTransactions();
        consumer.subscribe(Arrays.asList("topic01"));

        while (true){
            ConsumerRecords records = consumer.poll(Duration.ofSeconds(1));
            if (records.isEmpty()){
                Map offsets= new HashMap<>();
                Iterator> iterator = records.iterator();
                producer.beginTransaction();
                try {
                    while (iterator.hasNext()){
                        ConsumerRecord record = iterator.next();
                        offsets.put(new TopicPartition(record.topic(),record.partition()),new OffsetAndMetadata(record.offset()+1));
                        ProducerRecord pRecord = new ProducerRecord("topic02",record.key(),record.value()+"mashibing--------");
                        producer.send(pRecord);
                    }
                }catch (Exception e){
                    producer.abortTransaction();
                }
            }
        }

    }
    public static KafkaProducer buildProducer(){
        //1、创建生产者
        Properties prop = new Properties();
        prop.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //必须配置事务ID  ，必须唯一
        prop.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"transaction-id"+ UUID.randomUUID().toString());
        //配置kafka批处理大小
        prop.put(ProducerConfig.BATCH_SIZE_CONFIG,1024);
        //等待5ms 如果batch中的数据还不够1024大小  也会发送
        prop.put(ProducerConfig.LINGER_MS_CONFIG,5);
        //配置kafka重试机制和幂等性
        prop.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);
        prop.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,20000);
        prop.put
                (ProducerConfig.ACKS_CONFIG,"all");
        return new KafkaProducer<>(prop);
    }

    public static KafkaConsumer buildConsumer(String group){
        //1、创建生产者
        Properties prop = new Properties();
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1:9092,node2:9092,node3:9092");
        prop.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.GROUP_ID_CONFIG,group);//kafka中消费者通常以组的方式消费
        prop.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG,"read_committed ");
        //必须关闭消费者的自动提交
        prop.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);
        return new KafkaConsumer(prop);
    }

}



数据同步机制


Kafka的Topic被分为多个分区，分区是是按照Segments存储文件块。分区日志是存储在磁盘上的日志序列，Kafka可以保证分区里的事件是有序的。其中Leader负责对应分区的读写、Follower负责同步分区的数据，0.11 版本之前Kafka使用highwatermarker机制保证数据的同步，但是基于highwatermarker的同步数据可能会导致数据的不一致或者是乱序。在Kafka数据同步有以下概念。


LEO：log end offset 标识的是每个分区中最后一条消息的下一个位置，分区的每个副本都有自己的 LEO.


HW: high watermarker称为高水位线，所有HW之前的的数据都理解是已经备份的,当所有节点都备 份成功，Leader会更新水位线。


ISR:In-sync-replicas,kafka的leader会维护一份处于同步的副本集和，如果在replica.lag.time.max.ms时间内系统没有发送fetch请求，或者已然在发送请求，但是在该限定时间内没有赶上Leader的数据就被剔除ISR列表。在Kafka-0.9.0版本剔除replica.lag.max.messages消息个数限定，因为这个会导致其他的Broker节点频繁的加入和退出ISR。


①：High Watermark Truncation followed by Immediate Leader Election（数据丢失）


KAFKA_第3张图片


②: Replica Divergence on Restart after Multiple Hard Failures（数据不一致）


KAFKA_第4张图片


0.11版本之前Kafka的副本备份机制的设计存在问题。依赖HW的概念实现数据同步，但是存在数据不一致问题和丢失数据问题，因此Kafka-0.11版本引入了
 Leader Epoch解决这个问题，不在使用HW作为数据截断的依据。而是已引入了Leader
 epoch的概念，任意一个Leader持有一个LeaderEpoch。该LeaderEpoch这是一个由Controller管理的32位数字，存储在Zookeeper的分区状态信息中，并作为LeaderAndIsrRequest的一部分传递给每个新的Leader。Leader接受Producer请求数据上使用LeaderEpoch标记每个Message。然后，该LeaderEpoch编号将通过复制协议传播，并用于替换HW标记，作为消息截断的参考点。


KAFKA_第5张图片


改进消息格式，以便每个消息集都带有一个4字节的Leader Epoch号。在每个日志目录中，会创建一个新的Leader Epoch Sequence文件，在其中存储Leader Epoch的序列和在该Epoch中生成的消息的Start Offset。它也缓存在每个副本中，也缓存在内存中。


follower变成Leader


当Follower为Leader时，它首先将新的Leader Epoch和副本的LEO添加到Leader Epoch Sequence序列文件的末尾并刷新数据。给Leader产生的每个新消息集都带有新的“Leader Epoch”标记。


Leader变成Follower


如果需要需要从本地的Leader Epoch Sequence加载数据，将数据存储在内存中，给相应的分区的Leader发送epoch 请求，该请求包含最新的EpochID,StartOffset信息.Leader接收到信息以后返回该EpochID所对应的LastOffset信息。该信息可能是最新EpochID的StartOffset或者是当前EpochID的Log End Offset信息.**


情形1：Fllower的Offset比Leader的小
 在这里插入图片描述
 情形2：用户的Leader
 Epoch的信息startOffset信息比Leader返回的LastOffset要大，Follower回去重置自己的Leader
 Epoch文件，将Offset修改为Leader的LastOffset信息，并且截断自己的日志信息。


[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XdtAFjXz-1658630995484)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1657205223328.png)]


Follower在提取过程中，如果关注者看到的LeaderEpoch消息集大于其最新的LeaderEpoch，则会在其LeaderEpochSequence中添加新的LeaderEpoch和起始偏移量，并将Epoch数据文件刷新到磁盘。同时将Fetch的日志信息刷新到本地日志文件。


High Watermark Truncation followed by Immediate Leader Election（数据丢失）


KAFKA_第6张图片


②: Replica Divergence on Restart after Multiple Hard Failures（数据不一致）


KAFKA_第7张图片


第五章、进阶


Kafka-Eagle安装


这是一个监视系统，监视您的kafka群集以及可视的使用者线程，偏移量，所有者等。当您安装Kafka
 Eagle时，用户可以看到当前的使用者组，对于每个组，他们正在消耗的Topic以及该组在每个主题中的偏移量，滞后，日志大小和位置。这对于了解用户从消息队列消耗的速度以及消息队列增加的速度很有用。


[root@CentOSB ~]# tar -zxf kafka-eagle-web-1.4.0-bin.tar.gz -C /usr/
[root@CentOSB ~]# mv /usr/kafka-eagle-web-1.4.0 /usr/kafka-eagle
[root@CentOSB ~]# vi .bashrc
KE_HOME=/usr/kafka-eagle
JAVA_HOME=/usr/java/latest
PATH=$PATH:$JAVA_HOME/bin:$KE_HOME/bin
CLASSPATH=.
export JAVA_HOME
export PATH
export CLASSPATH
export KE_HOME
[root@CentOSB ~]# source .bashrc 
[root@CentOSB ~]# cd /usr/kafka-eagle/
[root@CentOSB kafka-eagle]# vi conf/system-config.properties 

kafka.eagle.zk.cluster.alias=cluster1
cluster1.zk.list=CentOSA:2181,CentOSB:2181,CentOSC:2181
cluster1.kafka.eagle.offset.storage=kafka
kafka.eagle.metrics.charts=true
kafka.eagle.driver=com.mysql.jdbc.Driver
kafka.eagle.url=jdbc:mysql://192.168.52.1:3306/ke?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
kafka.eagle.username=root
kafka.eagle.password=root

[root@CentOSB kafka-eagle]# chmod u+x bin/ke.sh
[root@CentOSB kafka-eagle]# ./bin/ke.sh start
vi /usr/local/kafka_2.2.0/bin/kafka-server-start.sh

如果需要检测Kafka性能指标需要修改Kafka启动文件
vi kafka-server-start.sh
...
if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then
    export KAFKA_HEAP_OPTS="-server -Xms2G -Xmx2G -XX:PermSize=128m -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:ParallelGCThreads=8 -XX:ConcGCThreads=5 -XX:InitiatingHeapOccupancyPercent=70"
    export JMX_PORT="9999"
    #export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G"
fi

flume启动 命令： ./bin/flume-ng agent -c conf/ -n a1 -f conf/kafka.properties -Dflume.root.logger=INFO,console



























你可能感兴趣的:(kafka,java,分布式)






    

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java

    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
    

    • 

  • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    

    • 

  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？
AaronWang94
shirojavajava安全开发语言

    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
    

    • 

  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring

    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
    

    • 

  • 3、JavaWeb-Ajax/Axios-前端工程化-Element
所谓远行Misnearch
#JavaWeb前端ajaxelementuijava前端框架

    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
    

    • 

  • 枚举使用笔记
万变不离其宗_8
项目笔记笔记

    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
    

    • 

  • Python dict字符串转json对象，小数精度丢失问题
朝如青丝 暮成雪
jsonpython

    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
    

    • 

  • java实体中返回前端的double类型四舍五入（格式化）
婲落ヽ紅顏誶
java

    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
    

    • 

  • Apache Kafka的伸缩性探究：实现高性能、弹性扩展的关键
i289292951
kafkakafka

    引言ApacheKafka作为当今最流行的消息中间件之一，以其强大的伸缩性著称。在大数据处理、流处理和实时数据集成等领域，Kafka的伸缩性为其在面临急剧增长的数据流量和多样化业务需求时提供了无与伦比的扩展能力。本文将深入探讨Kafka如何通过其独特的架构设计实现高水平的伸缩性，以及在实际部署中如何优化和利用这一特性。一、Kafka伸缩性的核心设计分区（Partitioning）与水平扩展Kafk
    

    • 

  • Redis分布式锁—SETNX+Lua脚本实现
Sahm5k
javaredis分布式lua

    使用redis实现分布式锁，就是利用redis中的setnx，如果key不存在则进行set操作返回1，key已经存在则直接返回0。优点：设置expiretime过期时间，可以避免程序宕机长期持有锁不释放。redis作为一个中间服务，所有微服务都可见，满足分布式的需求。只需redis中原生setnx命令即可构建，实现简单。性能高效，redis数据在内存中。高可用，可以部署redis集群。加锁在red
    

    • 

  • Java中HashMap底层数据结构及主要参数?
山间漫步人生路
java数据结构开发语言

    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
    

    • 

  • Java学习笔记01
.wsy.
日常java学习笔记

    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
    

    • 

  • Java回溯知识点（含面试大厂题和源码）
一成码农
java面试开发语言

    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
    

    • 

  • Azkaban各种类型的Job编写
__元昊__

    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
    

    • 

  • java基础相关面试题详细总结
。。。。。96
java开发语言

    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
    

    • 

  • 【二】【设计模式】建造者模式
妖精七七_
设计模式设计模式建造者模式

    建造者模式的引入//C10_1.cpp#include#include"SystemConfig.h"intmain(){SystemConfigconfig("mysql://127.0.0.1/","xiaomu","xiaomumemeda","redis://127.0.0.1/","xiaomuredis","xiaomuredispw","kafka://127.0.0.1","xia
    

    • 

  • 若依框架集成seata分布式事务的一些幺蛾子
半山惊竹
分布式

    一、bug连环炮A服务调用B服务，B服务异常，A服务插入的数据没有回退，前面没有思路，就查了下，说是没有切换为seata的数据源，我就在启动类加了一个@EnableAutoDataSourceProxy注解，结果就开始报错了：2024-03-1910:49:30.653[http-nio-8080-exec-2]INFOc.a.n.client.config.impl.CacheData-Line
    

    • 

  • javascript 日期转换为时间戳，时间戳转换为日期的函数
cdcdhj
javascript学习日记javascript开发语言ecmascript

    日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
    

    • 

  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法
杰哥在此
Java系列javajvm算法面试

    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
    

    • 

  • COMP315 JavaScript Cloud Computing for E Commerce
zhuyu0206girl
javascript开发语言ecmascript

    Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
    

    • 

  • kafka-eagle 配置文件修改使用自带的数据库
bright future cheer
kafka数据库分布式

    ######################################multizookeeper&kafkaclusterlistSettingsprefixedwith‘kafka.eagle.’willbedeprecated,use‘efak.’instead######################################efak.zk.cluster.alias=clu
    

    • 

  • JSON与AJAX：网页交互的利器
入冉心
jsonajax前端

    在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
    

    • 

  • Kafka、ActiveMQ、RabbitMQ 及 RocketMQ区别比较
木西爷
kafkaactivemqrabbitmq阿里云rocketmq

    消息队列中间件是分布式系统中重要的组件，主要解决应用耦合、异步消息、流量削锋等问题。它可以实现高性能、高可用、可伸缩和最终一致性架构，是大型分布式系统不可缺少的中间件。消息队列在电商系统、消息通讯、日志收集等应用中扮演着关键作用，以阿里为例，其研发的消息队列（RocketMQ）在历次天猫“双十一”活动中支撑了万亿级的数据洪峰，为大规模交易提供了有力保障。常见消息中间件对比特性ActiveMQRab
    

    • 

  • 程序员开发技术整理
laizhixue
学习前端框架

    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
    

    • 

  • javascript的数据类型及转换
田小田txt

    一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
    

    • 

  • java线程之Lock的使用
dimdark

    目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
    

    • 

  • 【循环神经网络rnn】一篇文章讲透
CX330的烟花
rnn人工智能深度学习算法python机器学习数据结构

    目录引言二、RNN的基本原理代码事例三、RNN的优化方法1长短期记忆网络（LSTM）2门控循环单元（GRU）四、更多优化方法1选择合适的RNN结构2使用并行化技术3优化超参数4使用梯度裁剪5使用混合精度训练6利用分布式训练7使用预训练模型五、RNN的应用场景1自然语言处理2语音识别3时间序列预测六、RNN的未来发展七、结论引言众所周知，CNN与循环神经网络（RNN）或生成对抗网络（GAN）等算法结
    

    • 

  • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解
爱跑步的程序员~
刷题蓝桥杯省赛

    文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
    

    • 

  • Java学习笔记04：Java_数组
JasonYangQ
Javajava

    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
    

    • 

  • 【设计模式】Java 设计模式之桥接模式（Bridge）
新手村长
Java设计模式设计模式java桥接模式

    桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
    

    • 

  • html页面js获取参数值
0624chenhong
html

    1.js获取参数值js
function GetQueryString(name)
{
     var reg = new RegExp("(^|&)"+ name +"=([^&]*)(&|$)");
     var r = windo
    

    • 

  • MongoDB 在多线程高并发下的问题
BigCat2013
mongodbDB高并发重复数据

    最近项目用到 MongoDB , 主要是一些读取数据及改状态位的操作. 因为是结合了最近流行的 Storm进行大数据的分析处理，并将分析结果插入Vertica数据库，所以在多线程高并发的情境下, 会发现 Vertica 数据库中有部分重复的数据. 这到底是什么原因导致的呢？笔者开始也是一筹莫 展，重复去看 MongoDB 的 API , 终于有了新发现 ：
com.mongodb.DB 这个类有
    

    • 

  • c++ 用类模版实现链表(c++语言程序设计第四版示例代码)
CrazyMizzz
数据结构C++

    #include<iostream>
#include<cassert>
using namespace std;
template<class T>
class Node
{
private:
Node<T> * next;
public:
T data; 
    

    • 

  • 最近情况
麦田的设计者
感慨考试生活

       在五月黄梅天的岁月里，一年两次的软考又要开始了。到目前为止，我已经考了多达三次的软考，最后的结果就是通过了初级考试（程序员）。人啊，就是不满足，考了初级就希望考中级，于是，这学期我就报考了中级，明天就要考试。感觉机会不大，期待奇迹发生吧。这个学期忙于练车，写项目，反正最后是一团糟。后天还要考试科目二。这个星期真的是很艰难的一周，希望能快点度过。
  
    

    • 

  • linux系统中用pkill踢出在线登录用户
被触发
linux

    由于linux服务器允许多用户登录，公司很多人知道密码，工作造成一定的障碍所以需要有时踢出指定的用户
1/#who   查出当前有那些终端登录（用 w 命令更详细）
# who
root     pts/0        2010-10-28 09:36 (192
    

    • 

  • 仿QQ聊天第二版
肆无忌惮_
qq

    在第一版之上的改进内容:
 第一版链接:
http://479001499.iteye.com/admin/blogs/2100893
 
用map存起来号码对应的聊天窗口对象,解决私聊的时候所有消息发到一个窗口的问题.
增加ViewInfo类,这个是信息预览的窗口,如果是自己的信息,则可以进行编辑.
 
信息修改后上传至服务器再告诉所有用户,自己的窗口
    

    • 

  • java读取配置文件
知了ing

    1，java读取.properties配置文件
InputStream in;
try {
in = test.class.getClassLoader().getResourceAsStream("config/ipnetOracle.properties");//配置文件的路径
Properties p = new Properties()
    

    • 

  • __attribute__ 你知多少？
矮蛋蛋
C++gcc

    原文地址:
http://www.cnblogs.com/astwish/p/3460618.html
GNU C 的一大特色就是__attribute__ 机制。__attribute__ 可以设置函数属性（Function Attribute ）、变量属性（Variable Attribute ）和类型属性（Type Attribute ）。
__attribute__ 书写特征是：
    

    • 

  • jsoup使用笔记
alleni123
java爬虫JSoup

    <dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.7.3</version>
</dependency>
2014/08/28
今天遇到这种形式， 
    

    • 

  • JAVA中的集合 Collectio 和Map的简单使用及方法
百合不是茶
listmapset

             List ,set ,map的使用方法和区别
java容器类类库的用途是保存对象，并将其分为两个概念：
    Collection集合：一个独立的序列，这些序列都服从一条或多条规则;List必须按顺序保存元素  ，set不能重复元素；Queue按照排队规则来确定对象产生的顺序（通常与他们被插入的
    

    • 

  • 杀LINUX的JOB进程
bijian1013
linuxunix

    今天发现数据库一个JOB一直在执行，都执行了好几个小时还在执行，所以想办法给删除掉
 
系统环境：
   ORACLE 10G
   Linux操作系统
 
操作步骤如下：
第一步.查询出来那个job在运行，找个对应的SID字段
select * from dba_jobs_running--找到job对应的sid
&n
    

    • 

  • Spring AOP详解
bijian1013
javaspringAOP

            最近项目中遇到了以下几点需求，仔细思考之后，觉得采用AOP来解决。一方面是为了以更加灵活的方式来解决问题，另一方面是借此机会深入学习Spring AOP相关的内容。例如，以下需求不用AOP肯定也能解决，至于是否牵强附会，仁者见仁智者见智。
1.对部分函数的调用进行日志记录，用于观察特定问题在运行过程中的函数调用
    

    • 

  • [Gson六]Gson类型适配器(TypeAdapter)
bit1129
Adapter

    TypeAdapter的使用动机
 Gson在序列化和反序列化时，默认情况下，是按照POJO类的字段属性名和JSON串键进行一一映射匹配，然后把JSON串的键对应的值转换成POJO相同字段对应的值，反之亦然，在这个过程中有一个JSON串Key对应的Value和对象之间如何转换(序列化/反序列化)的问题。
 
以Date为例，在序列化和反序列化时，Gson默认使用java.
    

    • 

  • 【spark八十七】给定Driver Program， 如何判断哪些代码在Driver运行，哪些代码在Worker上执行
bit1129
driver

    Driver Program是用户编写的提交给Spark集群执行的application，它包含两部分
作为驱动： Driver与Master、Worker协作完成application进程的启动、DAG划分、计算任务封装、计算任务分发到各个计算节点(Worker)、计算资源的分配等。
计算逻辑本身，当计算任务在Worker执行时，执行计算逻辑完成application的计算任务

    

    • 

  • nginx 经验总结
ronin47
nginx 总结

    　　　深感nginx的强大，只学了皮毛，把学下的记录。
　　　获取Header 信息，一般是以$http_XX（ＸＸ是小写）
           获取body,通过接口，再展开，根据Ｋ取Ｖ
　　　获取uri,以$arg_XX
     &n
    

    • 

  • 轩辕互动-1.求三个整数中第二大的数2.整型数组的平衡点
bylijinnan
数组

    
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ExoWeb {
public static void main(String[] args) {
ExoWeb ew=new ExoWeb();
System.out.pri
    

    • 

  • Netty源码学习-Java-NIO-Reactor
bylijinnan
java多线程netty

    Netty里面采用了NIO-based Reactor Pattern
了解这个模式对学习Netty非常有帮助
参考以下两篇文章：
http://jeewanthad.blogspot.com/2013/02/reactor-pattern-explained-part-1.html
http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf

    

    • 

  • AOP通俗理解
cngolon
springAOP

    1.我所知道的aop     初看aop,上来就是一大堆术语，而且还有个拉风的名字，面向切面编程，都说是OOP的一种有益补充等等。一下子让你不知所措，心想着：怪不得很多人都和 我说aop多难多难。当我看进去以后，我才发现：它就是一些java基础上的朴实无华的应用，包括ioc，包括许许多多这样的名词，都是万变不离其宗而 已。 2.为什么用aop&nb
    

    • 

  • cursor variable 实例
ctrain
variable

    
create or replace procedure proc_test01
as
type emp_row is record(
empno emp.empno%type,
ename emp.ename%type,
job emp.job%type,
mgr emp.mgr%type,
hiberdate emp.hiredate%type,
sal emp.sal%t
    

    • 

  • shell报bash: service: command not found解决方法
daizj
linuxshellservicejps

    今天在执行一个脚本时，本来是想在脚本中启动hdfs和hive等程序，可以在执行到service hive-server start等启动服务的命令时会报错，最终解决方法记录一下：
 
脚本报错如下：
./olap_quick_intall.sh: line 57: service: command not found
./olap_quick_intall.sh: line 59
    

    • 

  • 40个迹象表明你还是PHP菜鸟
dcj3sjt126com
设计模式PHP正则表达式oop

    你是PHP菜鸟，如果你：1. 不会利用如phpDoc 这样的工具来恰当地注释你的代码2. 对优秀的集成开发环境如Zend Studio 或Eclipse PDT 视而不见3. 从未用过任何形式的版本控制系统，如Subclipse4. 不采用某种编码与命名标准 ，以及通用约定，不能在项目开发周期里贯彻落实5. 不使用统一开发方式6. 不转换（或）也不验证某些输入或SQL查询串（译注：参考PHP相关函
    

    • 

  • Android逐帧动画的实现
dcj3sjt126com
android

    一、代码实现：
private ImageView iv;
private AnimationDrawable ad;
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout
    

    • 

  • java远程调用linux的命令或者脚本
eksliang
linuxganymed-ssh2

    转载请出自出处：
http://eksliang.iteye.com/blog/2105862
   
   Java通过SSH2协议执行远程Shell脚本(ganymed-ssh2-build210.jar) 
 使用步骤如下：
1.导包
官网下载:
http://www.ganymed.ethz.ch/ssh2/
ma
    

    • 

  • adb端口被占用问题
gqdy365
adb

    最近重新安装的电脑，配置了新环境，老是出现：
adb server is out of date. killing...
ADB server didn't ACK
* failed to start daemon *
百度了一下，说是端口被占用，我开个eclipse，然后打开cmd，就提示这个，很烦人。
一个比较彻底的解决办法就是修改
    

    • 

  • ASP.NET使用FileUpload上传文件
hvt
.netC#hovertreeasp.netwebform

    前台代码：
<asp:FileUpload ID="fuKeleyi" runat="server" />
<asp:Button ID="BtnUp" runat="server" onclick="BtnUp_Click" Text="上 传" />
    

    • 

  • 代码之谜（四）- 浮点数（从惊讶到思考）
justjavac
浮点数精度代码之谜IEEE

    在『代码之谜』系列的前几篇文章中，很多次出现了浮点数。 浮点数在很多编程语言中被称为简单数据类型，其实，浮点数比起那些复杂数据类型（比如字符串）来说， 一点都不简单。
单单是说明 IEEE浮点数 就可以写一本书了，我将用几篇博文来简单的说说我所理解的浮点数，算是抛砖引玉吧。 一次面试
记得多年前我招聘 Java 程序员时的一次关于浮点数、二分法、编码的面试， 多年以后，他已经称为了一名很出色的
    

    • 

  • 数据结构随记_1
lx.asymmetric
数据结构笔记

    第一章
  1.数据结构包括数据的
逻辑结构、数据的物理/存储结构和数据的逻辑关系这三个方面的内容。 2.数据的存储结构可用四种基本的存储方法表示，它们分别是
顺序存储、链式存储 、索引存储 和 散列存储。 3.数据运算最常用的有五种，分别是
 查找/检索、排序、插入、删除、修改。 4.算法主要有以下五个特性： 
输入、输出、可行性、确定性和有穷性。 5.算法分析的
    

    • 

  • linux的会话和进程组
网络接口
linux

    会话： 一个或多个进程组。起于用户登录，终止于用户退出。此期间所有进程都属于这个会话期。会话首进程：调用setsid创建会话的进程1.规定组长进程不能调用setsid，因为调用setsid后，调用进程会成为新的进程组的组长进程.如何保证？ 先调用fork，然后终止父进程，此时由于子进程的进程组ID为父进程的进程组ID，而子进程的ID是重新分配的，所以保证子进程不会是进程组长，从而子进程可以调用se
    

    • 

  • 二维数组 元素的连续求解
1140566087
二维数组ACM

    import java.util.HashMap;
public class Title {
public static void main(String[] args){
f();
}
// 二位数组的应用
//12、二维数组中，哪一行或哪一列的连续存放的0的个数最多，是几个0。注意，是“连续”。
public static void f(){

    

    • 

  • 也谈什么时候Java比C++快
windshome
javaC++

     
刚打开iteye就看到这个标题“Java什么时候比C++快”，觉得很好笑。
 
你要比，就比同等水平的基础上的相比，笨蛋写得C代码和C++代码，去和高手写的Java代码比效率，有什么意义呢？
 
我是写密码算法的，深刻知道算法C和C++实现和Java实现之间的效率差，甚至也比对过C代码和汇编代码的效率差，计算机是个死的东西，再怎么优化，Java也就是和C
    

    •