01-Kafaka

news2025/1/12 11:58:05

1、Kafka 2 的安装与配置

1、上传kafka_2.12-1.0.2.tgz到服务器并解压：

        tar -zxf kafka_2.12-1.0.2.tgz  -C /opt

2、配置环境变量并更新：

编辑profile配置文件：  vim /etc/profile

#设置kafka的环境变量

export KAFKA_HOME=/opt/kafka_2.12-1.0.2

export PATH=$PATH:$KAFKA_HOME/bin

重新加载profile文件:        source /etc/profile

3、在/opt/kafka_2.12-1.0.2目录中输入kafka-按住tab键，如果能调出其他的指令说明我们配置

profile成功。

4、配置/opt/kafka_2.12-1.0.2/config中的server.properties文件：

> Kafka连接Zookeeper的地址:49.234.5.32:2181,后面的 myKafka 是Kafka在Zookeeper中的根节点路径。

zookeeper.connect=49.234.5.32:2181/mykafka

> 发消息到kafka，kafka会给你进行一个持久化，存储的目录。

Log.dir=/var/niko/kafka/kafka-logs

我们创建这个目录/var/niko/kafka/kafka-logs

mkdir -p /var/niko/kafka/kafka-logs

5、启动zookeeper

进入到/opt/zookeeper-3.4.14/bin目录

cd /opt/zookeeper-3.4.14/bin

启动

zkServer.sh start

6、验证zookeeper：

zkServer.sh status

ZooKeeper JMX enabled by default

Using config: /opt/zookeeper-3.4.14/bin/../conf/zoo.cfg

Mode: standalone 说明成功了

7、启动Kafka：

进入Kafka安装的bin目录，执行如下命令：

cd  /opt/kafka_2.12-1.0.2/bin

kafka-server-start.sh  ../config/server.properties

启动成功，可以看到控制台输出的最后一行的started状态:

[2019-07-31 21:18:53,199] INFO [KafkaServer id=0] started (kafka.server.KafkaServer)

8、查看Zookeeper的节点

进入到Zookeeper安装目录的bin目录下

执行 zkCli.sh

执行命令ls /    查看所有的子节点

[mykafka, zookeeper]

9、此时Kafka是前台模式启动，要停止，使用Ctrl+C。

10、如果要后台启动 

进入Kafka安装的bin目录，执行如下命令：

cd /opt/kafka_2.12-1.0.2/bin

执行：kafka-server-start.sh -daemon  ../config/server.properties

11、查看Kafka的后台进程：ps aux | grep kafka

注意 kafka端口号9092

2、查看kafka是否启动

1、输入指令jps，查看kafka是否启动。

2、在任意目录下以后台的方式启动kafka

kafka-server-start.sh  -daemon  /opt/kafka_2.12-1.0.2/config/server.properties

3、再次输入jps，查看kafka是否启动成功。

3、在Linux使用命令生产与消费(了解)

3.1、kafka-topics.sh 用于管理主题

# 列出现有的主题(主题是放在zookeeper的节点上的)

kafka-topics.sh --list --zookeeper localhost:2181/mykafka

# 创建主题，该主题包含一个分区，该分区为Leader分区，它没有Follower分区副本。

--partitions    创建的分区个数

--replication-factor       创建的副本个数，用来实现高可用

kafka-topics.sh --zookeeper 49.234.5.32:2181/mykafka --create --topic topic_1 --partitions 1  --replication-factor 1

# 查看指定主题的详细信息 

kafka-topics.sh --zookeeper 49.234.5.32:2181/mykafka --describe --topic topic_1

输出结果：

Topic:topic_1   PartitionCount:1        ReplicationFactor:1     Configs:

Topic: topic_1  Partition: 0    Leader: 0       Replicas: 0     Isr: 0

#删除指定主题 

kafka-topics.sh --zookeeper 49.234.5.32:2181/mykafka --delete --topic topic_1

3.2、kafka-console-producer.sh用于生产消息

kafka-console-producer.sh --topic topic_1 --broker-list 49.234.5.32:9092

3.3、kafka-console-consumer.sh用于消费消息

kafka-console-consumer.sh  --bootstrap-server 49.234.5.32:9092 --topic topic_1

开启消费者方式二，从头消费，不按照偏移量消费

kafka-console-consumer.sh --bootstrap-server 49.234.5.32:9092 --topic topic_1 --from-beginning

注意：先开启消费消息，在开启生成消息，这样有生成消息的时候就可以直接消费了。

3.4、查看Kafka所有持久化的数据

进入到我们创建的用来保存持久化数据的目录：

cd /var/niko/kafka/kafka-logs

ls  

 有下面的偏移量，说明我们使用kafka成功。

  __consumer_offsets-22  __consumer_offsets-35  __consumer_offsets-48

__consumer_offsets-10      __consumer_offsets-23

4、kafka发送消息的流程

5、Maven项目中使用Kafka开发实战(了解)

1、首先创建一个maven工程，我们将src目录删除，然后再pom.xml文件中设置这个工程的打包方式为pom。

    <!--    这是kafka的工程的父目录 我们使用pom的打包方式-->

    <packaging>pom</packaging>

2、设置工程的maven仓库目录和setting文件。

3、创建子模块producer-consumer-test01 和 producer-product-test01

4、在模块producer-consumer-test01的pom.xml文件中导入依赖。

<dependencies>
	<!-- kafka-clients的依赖-->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <!-- 高版本兼容低版本，我们使用和broker一致的版本 -->
            <version>1.0.2</version>
        </dependency>
    </dependencies>

5.1、生产者

消费者生产消息后，需要broker端的确认，可以同步确认，也可以异步确认。

同步确认效率低，异步确认效率高，但是需要设置回调对象。

package com.wei.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.header.Header;
import org.apache.kafka.common.header.internals.RecordHeader;
import org.apache.kafka.common.serialization.IntegerSerializer;
import org.apache.kafka.common.serialization.StringSerializer;

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class MyProducer1 {


    public static void main(String[] args) throws ExecutionException, InterruptedException {

        /**
         *  1.1、KafkaProducer 的创建需要指定的参数
         *  server地址   key的序列化   value的序列化  timeout   ack  retries
         */
        Map<String,Object> map = new HashMap<>();
        map.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"49.234.5.32:9092");
        map.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
        map.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
//        map.put("request.timeout.ms",55);
//        map.put(ProducerConfig.ACKS_CONFIG,"all");  //有默认值可以不设置
//        map.put(ProducerConfig.RETRIES_CONFIG,3);   //也可以不设置
//        1、创建发送消息的类对象KafkaProducer
        KafkaProducer<Integer, String> producer = new KafkaProducer<>(map);


        /**
         * -String topic:  主题
         * -Integer partition: 分区
         * -Long timestamp: 时间戳
         * -K key:  key
         * -V value:    value
         * -Iterable<Header> headers) ：用于设置用户自定义的消息头字段
         *
         */
//        2.1、创建一个数组，里面存放的都是Header
        ArrayList<Header> headers = new ArrayList<>();
//        添加的是Header接口的实现类RecordHeader  通过构造方法实例化一个RecordHeader对象
        headers.add(new RecordHeader("wode.name","wode.value".getBytes(StandardCharsets.UTF_8)));
//        2、使用producerRecord用来给kafka发送封装的消息
        ProducerRecord<Integer, String> producerRecord = new ProducerRecord<>(
                "topic_2",
                0,
                0,
                "nihao wudi",
                headers
        );
//        3、发送消息
//        消费者生产消息后，需要broker端的确认，可以同步确认，也可以异步确认。
//        同步确认效率低，异步确认效率高，但是需要设置回调对象。
//        3.1、同步发送
//       final Future<RecordMetadata> future = producer.send(producerRecord);
//        final RecordMetadata recordMetadata = future.get();
//        System.out.println("主题是："+recordMetadata.topic());
//        System.out.println("分区是："+recordMetadata.partition());
//        System.out.println("变异量是："+recordMetadata.offset());
//        3.2、异步发送
        producer.send(producerRecord, new Callback() {
            @Override
            public void onCompletion(RecordMetadata metadata, Exception exception) {
                if (exception == null) {
                    System.out.println("消息的主题：" + metadata.topic());
                    System.out.println("消息的分区号：" + metadata.partition());
                    System.out.println("消息的偏移量：" + metadata.offset());
                } else {
                    System.out.println("异常消息：" + exception.getMessage());
                }
            }
        });
//        4、关闭producer
        producer.close();
    }
}

5.2、消费者

package com.lagou.kafka.demo.consumer;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.IntegerDeserializer;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

public class MyConsumer2 {
    public static void main(String[] args) {



        Map<String, Object> configs = new HashMap<>();
        // mac的hosts文件中手动配置域名解析
        configs.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "49.234.5.32:9092");
        // 使用常量代替手写的字符串，配置key的反序列化器
        configs.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, IntegerDeserializer.class);
        // 配置value的反序列化器
        configs.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        // 配置消费组ID
        configs.put(ConsumerConfig.GROUP_ID_CONFIG, "consumer_demo2");
        // 如果找不到当前消费者的有效偏移量，则自动重置到最开始
        // latest表示直接重置到消息偏移量的最后一个
        configs.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

        KafkaConsumer<Integer, String> consumer = new KafkaConsumer<Integer, String>(configs);

        // 先订阅，再消费
        consumer.subscribe(Arrays.asList("topic_1"));

        while (true) {
     // 如果主题中没有可以消费的消息，则该方法可以放到while循环中，每过3秒重新拉取一次
     // 如果还没有拉取到，过3秒再次拉取，防止while循环太密集的poll调用。
            // 批量从主题的分区拉取消息
            final ConsumerRecords<Integer, String> consumerRecords = consumer.poll(3_000);

            // 遍历本次从主题的分区拉取的批量消息
            consumerRecords.forEach(new Consumer<ConsumerRecord<Integer, String>>() {
                @Override
                public void accept(ConsumerRecord<Integer, String> record) {
                    System.out.println(record.topic() + "\t"
                            + record.partition() + "\t"
                            + record.offset() + "\t"
                            + record.key() + "\t"
                            + record.value());
                }
            });
        }

//        consumer.close();

    }
}

6、SpringBoot整合 Kafka

1、首先是创建一个springboot-kafka-sum-demo02项目。

2、通过快速构建的方式添加spring-web 、spring-kafka或者是手动在pom.xml文件中添加spring-web 、spring-kafka的依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>

3、resource目录下的application.properties文件：

#1、设置应用程序的名称和端口号
spring.application.name=springboot-kafka-02
server.port=8080

#2、kafka单体或者集群的host和端口号
spring.kafka.bootstrap-servers=49.234.5.32:9092

#3、producer的配置
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.IntegerSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
#producer生产者每一批次可以放多少条记录
spring.kafka.producer.batch-size=16384
#生产者端 可以用来发送的缓冲区的大小  32MB   单位是字节
spring.kafka.producer.buffer-memory=33554432

#4、consumer的配置
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.IntegerDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.group-id=springboot-consumer02
#如果在kafka的消费者中找不到当前的偏移量  从最早的偏移量开始获取数据
spring.kafka.consumer.auto-offset-reset=earliest

#消费者的偏移量是自动提交还是手动提交  设置成true表示是自动提交变异量   如果有事务的情况下 我们通常是设置成手动提交
spring.kafka.consumer.enable-auto-commit=true
#消费者设置成自动提交偏移量的一个提交频率
spring.kafka.consumer.auto-commit-interval=1000

4、生产者同步发送消息

package com.wei.springbootkafka.producer;

import org.apache.kafka.clients.producer.RecordMetadata;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.ExecutionException;

@RestController
public class MyProducer01 {

//    1、自动注入KafkaTemplate
    @Autowired
    private KafkaTemplate<Integer,String> template;

    @RequestMapping("/send/sync/{message}")
    public String sendSyncMessage(@PathVariable("message") String message){
//        2、使用KafkaTemplate发送消息
        ListenableFuture<SendResult<Integer, String>> future =
                template.send("spring-topic-01", 0, 0, message);
//        3、同步发送消息   get()
        try {
            SendResult<Integer, String> result = future.get();
            RecordMetadata metadata = result.getRecordMetadata();
            System.out.println("主题是："+metadata.topic());
            System.out.println("分区是："+metadata.partition());
            System.out.println("偏移量是："+metadata.offset());
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("异常了");
        }
        return "success";
    }
}

5、生产者异步发送消息 

@RestController
public class MyProducer02 {

//    1、自动注入KafkaTemplate
    @Autowired
    private KafkaTemplate<Integer,String> template;

    @RequestMapping("/send/sync/{message}")
    public String sendSyncMessage(@PathVariable("message") String message){
//        2、使用KafkaTemplate发送消息
        ListenableFuture<SendResult<Integer, String>> future =
                template.send("spring-topic-01", 0, 0, message);
//        3、异步发送消息   
       future.addCallback(new ListenableFutureCallback<SendResult<Integer, String>>() {
           @Override
           public void onFailure(Throwable ex) {
               System.out.println("失败了"+ex.getMessage());
           }

           @Override
           public void onSuccess(SendResult<Integer, String> result) {
               RecordMetadata recordMetadata = result.getRecordMetadata();
               System.out.println("发送消息成功：" + metadata.topic() + "\t" 
                       + metadata.partition() + "\t" 
                       + metadata.offset());
           }
       });
       
       
        return "success";
    }
}

6、消费者消费消息

package com.wei.springbootkafka.consumer;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

//1、交由spring进行管理
@Component
public class MyConsumer01 {
//    2、KafkaListener监听指定的主题
    @KafkaListener(topics="spring-topic-01")
//    3、添加了@KafkaListener注解后  方法中就可以使用ConsumerRecord：用来接收kafka的消息
    public void getMessage(ConsumerRecord<Integer,String> record){
        System.out.println("consumer"
                + record.topic()+"\t"
                + record.partition()+"\t"
                + record.offset()+"\t"
                + record.key()+"\t"
                + record.value()+"\t"
        );
    }
}

7、kafka报错 UnknownHostException 解决方案

运行springboot和kafka整合项目报错java.net.UnknownHostException: VM-4-7-centos

解决方案：

1、cd 到/opt/kafka_2.12-1.0.2/config目录下

2、vim server.properties

设置成listeners=PLAINTEXT://VM-4-7-centos:9092

3、通过查看 linux服务器的 /etc/hosts 文件：将VM-4-7-centos指向的就是linux服务器ip。

127.0.0.1 VM-4-7-centos VM-4-7-centos

49.234.5.32  VM-4-7-centos VM-4-7-centos

4、由于我是在本机服务中访问到了linux服务器上的kafka服务，自然就无法解析到 VM-4-7-centos。因此需要在本机的hosts文件中也加入相应的配置！

5、Mac系统的hosts 文件就在 /etc/hosts 路径里，我们直接是无法编辑的，需要通过下面的方法来修改我们的 hosts 文件。

进入终端（命令窗口）里，输入 sudo vi /etc/hosts ，回车后再输入密码，再回车就可以打开我们的hosts文件了。

添加VM-4-7-centos 的服务器的ip地址：

49.234.5.32 VM-4-7-centos

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/981340.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【ESP32--FreeRTOS 任务间的同步与通信】

【ESP32--FreeRTOS 任务间的同步与通信】

本文主要记录【ESP32–FreeRTOS 任务间的同步与通信】的学习记录&#xff0c;邮件&#xff0c;信号量&#xff0c;事件组的使用和优缺点以及应用场景 &#x1f4cb; 个人简介 &#x1f496; 作者简介&#xff1a;大家好&#xff0c;我是喜欢记录零碎知识点的小菜鸟。&#x1f6…
阅读更多...
软件测试之随机测试

软件测试之随机测试

目录 一、作随机测试之前的一些前提条件 二、随机测试功能点的选取 三、功能点的随机测试 在软件测试中除了根据测试用例和测试说明书进行功能测试外&#xff0c;还需要进行随机测试&#xff08;Ad-hoc testing&#xff09;&#xff0c;随机测试是没有书面测试用例、记录期望…
阅读更多...
【算法】插入排序

【算法】插入排序

插入排序 插入排序代码实现代码优化 排序&#xff1a; 排序&#xff0c;就是使一串记录&#xff0c;按照其中的某个或某些关键字的大小&#xff0c;递增或递减的排列起来的操作。 稳定性&#xff1a; 假定在待排序的记录序列中&#xff0c;存在多个具有相同的关键字的记录&…
阅读更多...
【算法】归并排序 详解

【算法】归并排序 详解

归并排序 详解 归并排序代码实现1. 递归版本2. 非递归版本 排序&#xff1a; 排序&#xff0c;就是使一串记录&#xff0c;按照其中的某个或某些关键字的大小&#xff0c;递增或递减的排列起来的操作。 稳定性&#xff1a; 假定在待排序的记录序列中&#xff0c;存在多个具有相…
阅读更多...
dpkt 处理linux cooked capture

dpkt 处理linux cooked capture

这里写自定义目录标题 欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题&#xff0c;有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants 创建一个自定义列表如何创建一个…
阅读更多...
CUDA小白 - NPP(4) 图像处理 Data Exchange and Initialization（1）

CUDA小白 - NPP(4) 图像处理 Data Exchange and Initialization（1）

cuda小白 原始API链接 NPP GPU架构近些年也有不少的变化&#xff0c;具体的可以参考别的博主的介绍&#xff0c;都比较详细。还有一些cuda中的专有名词的含义&#xff0c;可以参考《详解CUDA的Context、Stream、Warp、SM、SP、Kernel、Block、Grid》 常见的NppStatus&#xf…
阅读更多...
QT 初识多线程

QT 初识多线程

1.QThread线程基础 QThread是Qt线程中有一个公共的抽象类&#xff0c;所有的线程类都是从QThread抽象类中派生的&#xff0c;需要实现QThread中的虚函数run(),通过start()函数来调用run函数。 void run&#xff08;&#xff09;函数是线程体函数&#xff0c;用于定义线程的功能…
阅读更多...
借助CIFAR10模型结构理解卷积神经网络及Sequential的使用

借助CIFAR10模型结构理解卷积神经网络及Sequential的使用

CIFAR10模型搭建 CIFAR10模型结构 0. input : 332x32&#xff0c;3通道32x32的图片 --> 特征图(Feature maps) : 3232x32即经过32个35x5的卷积层&#xff0c;输出尺寸没有变化&#xff08;有x个特征图即有x个卷积核。卷积核的通道数与输入的通道数相等&#xff0c;即35x5&am…
阅读更多...
01-从JDK源码级别剖析JVM类加载机制

01-从JDK源码级别剖析JVM类加载机制

1. 类加载运行全过程 当我们用java命令运行某个类的main函数启动程序时&#xff0c;首先需要通过类加载器把主类加载到JVM。 public class Math {public static final int initData 666;public static User user new User();public int compute() { //一个方法对应一块栈帧…
阅读更多...
整理mongodb文档:事务(一)

整理mongodb文档:事务(一)

个人博客 整理mongodb文档:事务(一) 原文链接&#xff0c;个人博客 求关注&#xff0c;本文主要讲下怎么在mongose下使用事务&#xff0c;建议电脑端看 文章概叙 本文的开发环境为Nodejs&#xff0c;在‘单机模式’讲解最基本的事务概念。并没有涉及分片以及集群&#xff0…
阅读更多...
《向量数据库指南》——AI原生向量数据库Milvus Cloud 2.3新功能

《向量数据库指南》——AI原生向量数据库Milvus Cloud 2.3新功能

New Feature Upsert 功能 支持用户通过 upsert 接口更新或插入数据。已知限制，自增 id 不支持 upsert；upsert 是内部实现是 delete + insert所以性能上会有一定损耗，如果明确知道是写入数据的场景请继续使用 insert。 Range Search 功能 支持用户通过输入参数指定 search 的…
阅读更多...
TortoiseGit设置作者信息和用户名、密码存储

TortoiseGit设置作者信息和用户名、密码存储

前言 Git 客户端每次与服务器交互&#xff0c;都需要输入密码&#xff0c;但是我们可以配置保存密码&#xff0c;只需要输入一次&#xff0c;就不再需要输入密码。 操作说明 在任意文件夹下&#xff0c;空白处&#xff0c;鼠标右键点击 在弹出菜单中按照下图点击 依次点击下…
阅读更多...
LLVM 与代码混淆技术

LLVM 与代码混淆技术

项目源码 什么是 LLVM LLVM 计划启动于2000年&#xff0c;开始由美国 UIUC 大学的 Chris Lattner 博士主持开展&#xff0c;后来 Apple 也加入其中。最初的目的是开发一套提供中间代码和编译基础设施的虚拟系统。 LLVM 命名最早源自于底层虚拟机&#xff08;Low Level Virtu…
阅读更多...
LEARN GIT

LEARN GIT

概念 基础概念 本地电脑 代码区&#xff1a;工作区间&#xff0c;放代码的地方 暂存区&#xff1a;git所管理的暂存区域 本地仓库&#xff1a;git所管理的本机的硬盘区域 远程电脑 远程仓库&#xff1a;github、gitee 代码提交管理的过程 代码区------->暂存区-------&…
阅读更多...
关于 RK3568的linux系统killed用户应用进程(用户现象为崩溃) 的解决方法

关于 RK3568的linux系统killed用户应用进程(用户现象为崩溃) 的解决方法

若该文为原创文章&#xff0c;转载请注明原文出处 本文章博客地址&#xff1a;https://hpzwl.blog.csdn.net/article/details/132710642 红胖子网络科技博文大全&#xff1a;开发技术集合&#xff08;包含Qt实用技术、树莓派、三维、OpenCV、OpenGL、ffmpeg、OSG、单片机、软硬…
阅读更多...
模拟Proactor模式实现 I/O 处理单元

模拟Proactor模式实现 I/O 处理单元

编写main.cpp 1.socket通信 服务器应用程序可以通过读取和写入 Socket 对象 来监听来自客户端的请求并向客户端返回响应 #define MAX_FD 65536 // 最大的文件描述符个数 #define MAX_EVENT_NUMBER 10000 // 监听的最大的事件数量 // 添加信号捕捉 void addsig(int sig, …
阅读更多...
【MySQL】索引 详解

【MySQL】索引 详解

索引 详解 一. 概念二. 作用三. 使用场景四. 操作五. 索引背后的数据结构B-树B树聚簇索引与非聚簇索引 一. 概念 索引是一种特殊的文件&#xff0c;包含着对数据表里所有记录的引用指针。可以对表中的一列或多列创建索引&#xff0c;并指定索引的类型&#xff0c;各类索引有各…
阅读更多...
机器学习的特征工程

机器学习的特征工程

字典特征提取 def dict_demo():"""字典特征提取:return:"""data [{city: 北京, temperature: 100}, {city: 上海, temperature: 60}, {city: 深圳, temperature: 30}]# data [{city:[北京,上海,深圳]},{temperature:["100","6…
阅读更多...
《机器人学一(Robotics(1))》_台大林沛群 第 5 周【机械手臂 轨迹规划】 Quiz 5

《机器人学一(Robotics(1))》_台大林沛群 第 5 周【机械手臂 轨迹规划】 Quiz 5

我又行了&#xff01;&#x1f923; 求解的 位置 可能会有 变动&#xff0c;根据求得的A填写相应值即可。注意看题目。 coursera链接 文章目录 第1题 Cartesian space求解 题1-3 的 Python 代码 第2题第3题第4题 Joint space求解 题4-6 的 Python 代码 第5题第6题其它可参考代…
阅读更多...
leetcode 88：合并两个有序数组 。 双指针解法

leetcode 88：合并两个有序数组 。 双指针解法

题目 算法 双指针 code var merge function(nums1, m, nums2, n) {// 其实就是一个nums1数组从后向前的降序重排&#xff0c;从最后开始&#xff0c;比较nums1有效位置和nums2当前位置数的大小&#xff0c;依次填入&#xff0c;nums2最后若有剩余&#xff0c;则再多一步从后…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023