Anolis 8.6 部署 Kafka 3.3.1 安装和测试

news2024/12/22 20:43:12

龙蜥 8.6 安装 Kafka 3.3.1 并通过 SpringBoot 3.0.1 版本调试

  • 一.Kafka 安装
    • 1.下载编译后的文件
    • 2.拷贝到 Anolis 并解压
    • 3.启动服务
    • 3.常用命令
      • 1.Topic 增查删
      • 2.生产消费测试
  • 二.SpringBoot 连接 Kafka
    • 1.项目结构、依赖、配置文件和启动类
    • 2.生产者和生产监听
    • 3.消费者和消费监听
    • 4.自定义消费注解
  • 三.测试和验证
    • 1.发送正常数据
    • 2.发送错误数据

一.Kafka 安装

1.下载编译后的文件

下载地址

下载编译后的包
![在这里插入图片描述](https://img-blog.csdnimg.cn/2d4549afb4744c34a50783059648faa1.png

2.拷贝到 Anolis 并解压

Kafka 依赖的 Jdk 环境自行配置

在这里插入图片描述

采用 Raft 配置启动 ，修改配置，自定义路径：vim config/kraft/server.properties

在这里插入图片描述

3.启动服务

生成UUID：./bin/kafka-storage.sh random-uuid

在这里插入图片描述

格式化数据目录：./bin/kafka-storage.sh format -t 3Nke4nZhRueBQrNeJVMrgw -c ./config/kraft/server.properties

在这里插入图片描述

启动服务：./bin/kafka-server-start.sh ./config/kraft/server.properties（末尾加上 & 即以进程形式启动）

在这里插入图片描述

进程形式启动（测试用进程日志输出到空）：./bin/kafka-server-start.sh ./config/kraft/server.properties >/dev/null &

在这里插入图片描述

脚本语句

#!/bin/bash
KAFKA_HOME=/home/kafka_2.13-3.3.1

## 1.生成UUID
UUID=`${KAFKA_HOME}/bin/kafka-storage.sh random-uuid`

## 2.格式化
${KAFKA_HOME}/bin/kafka-storage.sh format -t ${UUID} -c ${KAFKA_HOME}/config/kraft/server.properties

Kafka 启动/停止脚本，创建脚本文件，贴入以下代码：vim /usr/local/bin/kafkaserver.sh

添加可执行权限：chmod a+x /usr/local/bin/kafkaserver.sh

#!/bin/bash
KAFKA_HOME=/home/kafka_2.13-3.3.1

case $1 in
"start")
${KAFKA_HOME}/bin/kafka-server-start.sh ${KAFKA_HOME}/config/kraft/server.properties >/dev/null &
;;
"stop")
${KAFKA_HOME}/bin/kafka-server-stop.sh >/dev/null
;;
*)
echo "Please input start|stop"
;;
esac
sleep 1
pid=`jps | grep Kafka | grep -v grep`
if [ -n "$pid" ]
then
    echo -e "\033[32m Kafka is running \033[0m"
else
    echo -e "\033[31m Kafka is stopped \033[0m"
fi

在这里插入图片描述

3.常用命令

1.Topic 增查删

## 1.创建Topic
./bin/kafka-topics.sh --create --topic kafka-test-topic --bootstrap-server 127.0.0.1:9092
## 2.查看
./bin/kafka-topics.sh --list --bootstrap-server 127.0.0.1:9092
## 3.删除
./bin/kafka-topics.sh --delete --topic kafka-test-topic-ver --bootstrap-server 127.0.0.1:9092

在这里插入图片描述

2.生产消费测试

## 1.生产压测
./bin/kafka-producer-perf-test.sh --topic kafka-test-topic --throughput 1 --num-records 1 --record-size 1024 --producer-props bootstrap.servers=127.0.0.1:9092
## 2.查看消息
./bin/kafka-topics.sh --describe --topic kafka-test-topic --bootstrap-server 127.0.0.1:9092
## 3.消费消息
./bin/kafka-console-consumer.sh --topic kafka-test-topic --from-beginning --bootstrap-server 127.0.0.1:9092

在这里插入图片描述

二.SpringBoot 连接 Kafka

1.项目结构、依赖、配置文件和启动类

项目结构

在这里插入图片描述

maven 依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.demo</groupId>
    <artifactId>Kafka3</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>19</maven.compiler.source>
        <maven.compiler.target>19</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <version.spring>3.0.1</version.spring>
        <version.fastjson>2.0.22</version.fastjson>
        <version.lombok>1.18.24</version.lombok>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${version.spring}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
            <version>${version.spring}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>${version.spring}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
            <version>${version.spring}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${version.fastjson}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${version.lombok}</version>
        </dependency>
    </dependencies>

</project>

配置文件

server:
  port: 8080

spring:
  kafka:
    consumer:
      test-topic: kafka-test-topic

启动类

package com.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration;

/**
 * @author Administrator
 * @Description
 * @create 2023-01-11 22:02
 */
@SpringBootApplication(exclude = {KafkaAutoConfiguration.class})
public class KafkaApplication {

    public static void main(String[] args) {
        SpringApplication.run(KafkaApplication.class,args);
    }

}

2.生产者和生产监听

当前配置是写在代码里的，大家可以改到 YML 配置

package com.demo.config;

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * @author Administrator
 * @Description
 * @create 2023-01-11 22:07
 */
@Component
@EnableKafka
public class ProducerInit {

    @Autowired
    private MyProducerListener myProducerListener;

    @Primary
    @Bean("kafkaTemplate")
    public KafkaTemplate<String,String> kafkaTemplate(){
        KafkaTemplate kafkaTemplate = new KafkaTemplate<>(producerFactory());
        kafkaTemplate.setProducerListener(myProducerListener);
        return kafkaTemplate;
    }

    /**
     * 获取工厂
     * @return
     */
    public ProducerFactory<String,String> producerFactory(){
        return new DefaultKafkaProducerFactory<>(producerConfig());
    }

    /**
     * 获取配置信息
     * @return
     */
    private Map<String,Object> producerConfig(){
        Map<String,Object> map = new HashMap<>(13);
        map.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.1.4:9092");
        map.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        map.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class);
        map.put(ProducerConfig.MAX_BLOCK_MS_CONFIG,1000 * 10);
        map.put(ProducerConfig.BATCH_SIZE_CONFIG,2048 * 20);
        map.put(ProducerConfig.LINGER_MS_CONFIG,1000 * 30);

        map.put(ProducerConfig.BUFFER_MEMORY_CONFIG,1024*1000*1000);
        map.put(ProducerConfig.MAX_REQUEST_SIZE_CONFIG,10240*1000*1000);
        map.put(ProducerConfig.METADATA_MAX_AGE_CONFIG,300000);
        map.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"gzip");

        map.put(ProducerConfig.MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION,2);
        map.put(ProducerConfig.ACKS_CONFIG,"all");
        map.put(ProducerConfig.RETRIES_CONFIG,"3");
        map.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);
        map.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG, 1000 * 3);

        return map;
    }
}

监听器

package com.demo.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.springframework.kafka.support.ProducerListener;
import org.springframework.stereotype.Component;

/**
 * @author Administrator
 * @Description
 * @create 2023-01-11 22:24
 */
@Slf4j
@Component
public class MyProducerListener implements ProducerListener {

    @Override
    public void onSuccess(ProducerRecord producerRecord, RecordMetadata recordMetadata) {

        log.info("T:{} P:{} K:{} O:{}",producerRecord.topic(),recordMetadata.partition(),producerRecord.key(),recordMetadata.offset());

    }

    @Override
    public void onError(ProducerRecord producerRecord, RecordMetadata recordMetadata, Exception exception) {

        log.error("Error T:{} P:{} K:{} O:{}",producerRecord.topic(),producerRecord.partition(),producerRecord.key(),recordMetadata.offset());
        log.error("Error {}",exception.getMessage());

    }

}

发送消息测试类

package com.demo.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

/**
 * @author Administrator
 * @Description
 * @create 2023-01-11 22:02
 */
@Slf4j
@RestController
@RequestMapping("/send")
public class ProducerController {

    @Autowired
    KafkaTemplate kafkaTemplate;

    private String topic = "kafka-test-topic";

    /**
     * 发送消息
     * @param content
     */
    @GetMapping("/test/{content}")
    public void sendData(@PathVariable("content") String content){

        String key = String.valueOf(UUID.randomUUID());

        log.info("Wait For Send Info:{}",content);

        kafkaTemplate.send(topic,key,content);
    }

}

3.消费者和消费监听

消费者配置类

package com.demo.config.consumer;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * @author Administrator
 * @Description
 * @create 2023-01-15 20:31
 */
@Component
public class ConsumerConfigInit {

    @Bean("myContainerFactory")
    @Primary
    public ConcurrentKafkaListenerContainerFactory<String,String> containerFactory(){
        return containerFactory(consumerFactory(),0);
    }

    /**
     * 消费者工厂
     * @return
     */
    private ConsumerFactory<String,String> consumerFactory(){

        Map<String,Object> map = new HashMap<>(7);

        map.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.1.4:9092");
        map.put(ConsumerConfig.GROUP_ID_CONFIG,"my-test");
        map.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        map.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        map.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,true);
        map.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,1000);
        map.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG,100);

        return new DefaultKafkaConsumerFactory<>(map);
    }

    /**
     * 监听器工厂
     * @param consumerFactory
     * @param concurrency
     * @return
     */
    private ConcurrentKafkaListenerContainerFactory<String,String> containerFactory(ConsumerFactory<String,String> consumerFactory,int concurrency){

        ConcurrentKafkaListenerContainerFactory<String,String> factory = new ConcurrentKafkaListenerContainerFactory<>();

        factory.setConsumerFactory(consumerFactory);

        if (concurrency > 0){
            factory.setConcurrency(concurrency);
        }

        return factory;
    }

}

消费者错误监听器

package com.demo.config.consumer;

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.common.protocol.types.Field;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.listener.ConsumerAwareListenerErrorHandler;
import org.springframework.messaging.MessageHeaders;
import org.springframework.stereotype.Component;

/**
 * @author Administrator
 * @Description
 * @create 2023-01-15 20:31
 */
@Slf4j
@Component
public class ConsumerErrorListener {

    @Bean("myErrorHandler")
    public ConsumerAwareListenerErrorHandler errorHandler(){
        return ((message, e, consumer) -> {
            MessageHeaders headers = message.getHeaders();
            log.info("Error header:{} ",headers);
            return null;
        });
    }

}

注解式配置消费者

package com.demo.config.consumer;

import com.demo.config.aspect.ConsumerAnno;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.annotation.PartitionOffset;
import org.springframework.kafka.annotation.TopicPartition;
import org.springframework.stereotype.Component;

/**
 * @author Administrator
 * @Description 这里消费方法不做具体实现，通过切面做统一处理
 * @create 2023-01-15 20:59
 */
@Component
public class MyConsumerInstance {

    /**
     * 丛指定位置消费
     * 或者消费多个Topic 在配置文件内用逗号隔开即可
     * @param record
     */
    @KafkaListener(
            clientIdPrefix = "test-batch",
            //topics = "#{'${spring.kafka.consumer.test-topic}'.split(',')}",
            topicPartitions = {
                    @TopicPartition(
                            topic = "#{'${spring.kafka.consumer.test-topic}'}",
                            partitionOffsets = {
                                    @PartitionOffset(partition = "0",initialOffset = "1")
                            }
                    )
            },
            containerFactory = "myContainerFactory",
            errorHandler = "myErrorHandler"
    )
    @ConsumerAnno(handler = "myHandler")
    public void testConsumer(ConsumerRecord<String,String> record){}



}

4.自定义消费注解

通过注解指定消息处理器，注解类

package com.demo.config.aspect;

import java.lang.annotation.*;

/**
 * @author Administrator
 * @Description
 * @create 2023-01-15 21:20
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ConsumerAnno {

    /**
     * 此处可以指定一个默认的处理器
     * @return
     */
    String handler() default "";

}

切面类：统一的源数据校验、备份、异常处理等

package com.demo.config.aspect;

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author Administrator
 * @Description
 * @create 2023-01-15 21:23
 */
@Slf4j
@Aspect
@Component
public class ConsumerAspect {

    /**
     * 注解型切点
     */
    @Pointcut("@annotation(com.demo.config.aspect.ConsumerAnno)")
    private void annotationPointcut(){}

    @Around("annotationPointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable{

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();

        Object[] args = joinPoint.getArgs();

        if (null != args){

            ConsumerRecord<String,String> record = (ConsumerRecord<String, String>) args[0];

            //TODO 打印原始消息,记录分区偏移等 或者其他统一处理

            log.info("Topic:{} Key:{} P:{} O:{}",record.topic(),record.key(),record.partition(),record.offset());

            //抛出异常
            if (record.value().contains("error")){
                throw new Throwable();
            }
        }

        Method method = signature.getMethod();

        ConsumerAnno consumerAnno = method.getAnnotation(ConsumerAnno.class);

        String handler = consumerAnno.handler();

        //TODO 可以根据默认处理或指定处理器进一步处理消息：通过实例名和Spring容器上下文获取实例

        log.info("Handler:{}",handler);

        return joinPoint.proceed();

    }

}

三.测试和验证

1.发送正常数据

http://127.0.0.1:8080/send/test/Kafak发数

在这里插入图片描述

结果打印

在这里插入图片描述

2.发送错误数据

http://127.0.0.1:8080/send/test/Kafak发error数

在这里插入图片描述

在这里插入图片描述

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

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

相关文章

【Java寒假打卡】Java基础-并发工具类

【Java寒假打卡】Java基础-并发工具类

【Java寒假打卡】Java基础-并发工具类HashMap在多线程下的问题ConcurrentHashMapCountDownLatchHashMap在多线程下的问题 package com.hfut.edu.test14;import com.sun.jdi.request.StepRequest;import java.util.HashMap;public class test2 {public static void main(String…
阅读更多...
信号的时域和频域特性的区别到底是什么？

信号的时域和频域特性的区别到底是什么？

不严谨的说&#xff0c;时域和频域分析就是在不同的空间看待问题的&#xff0c;不同空间所对应的原子(基函数)是不同的。你想一下时域空间的基函数是什么&#xff1f;频域空间的基函数是什么&#xff1f;一般的时-频联合域空间的基函数是什么&#xff1f;小波域空间的基函数是什…
阅读更多...
线索二叉树（c++）

线索二叉树（c++）

1.引言&#xff1a; 二叉树的三种遍历方法能将二叉树中的结点按某种方式生成一个线性序列&#xff0c;能将一个非线性结构进行线性化操作。但随之也产生两个问题&#xff1a; 遍历效率低 在采用左右链表示方法作为二叉树的存储结构时&#xff0c;当二叉树更新后&#xff0c;并…
阅读更多...
【博客586】ipvs的hook点位置以及hook点钩子函数剖析

【博客586】ipvs的hook点位置以及hook点钩子函数剖析

ipvs的hook点位置以及hook点钩子函数剖析 ipvs实现负载均衡的基础 ipvs其实是基于netfilter框架来挂载hook点&#xff0c;从而对流量进行dnat等操作 ipvs的hook点剖析 IPVS的实现利用了Netfilter的三个Hook点&#xff0c;分别是&#xff1a;NF_INET_LOCAL_IN、NF_INET_LOCAL_O…
阅读更多...
【nvidia CUDA 高级编程】NVSHMEM 直方图——复制式方法

【nvidia CUDA 高级编程】NVSHMEM 直方图——复制式方法

博主未授权任何人或组织机构转载博主任何原创文章&#xff0c;感谢各位对原创的支持&#xff01; 博主链接 本人就职于国际知名终端厂商&#xff0c;负责modem芯片研发。 在5G早期负责终端数据业务层、核心网相关的开发工作&#xff0c;目前牵头6G算力网络技术标准研究。 博客…
阅读更多...
pandas时间序列，案列

pandas时间序列，案列

一&#xff1a;pandas时间序列 1.1为什么要学习pandas中的时间序列 不管在什么行业&#xff0c;时间序列都是一种非常重要的数据形式&#xff0c;很多统计数据以及数据的规律也都和时间序列有着非常重要的联系&#xff0c;而且在pandas中处理时间序列是非常简单的 1.2生成一段时…
阅读更多...
【Python技巧】：cmd查看Python版本号居然与自己电脑装的版本不一致，特此提出解决方案

【Python技巧】：cmd查看Python版本号居然与自己电脑装的版本不一致，特此提出解决方案

项目场景&#xff1a; 大家好&#xff01;欢迎大家看我的博客&#xff0c;最近学习Python的GUI&#xff08;PyQt5&#xff09;的时候发现了自己电脑的一个python问题&#xff0c;我本想装一下PyQt5&#xff0c;顺手查了一下自己电脑的Python版本&#xff0c;没想到居然是Python…
阅读更多...
哈希表（二）—— 开散列 / 拉链法 / 哈希桶的模拟实现

哈希表（二）—— 开散列 / 拉链法 / 哈希桶的模拟实现

哈希表的基本思路是通过某种方式将某个值映射到对应的位置&#xff0c;这里的采取的方式是除留余数法&#xff0c;即将原本的值取模以后再存入到数组的对应下标&#xff0c;即便存入的值是一个字符串&#xff0c;也可以根据字符串哈希算法将字符串转换成对应的ASCII码值&#x…
阅读更多...
Week 6 hw3-1 全连接网络反向传播推导

Week 6 hw3-1 全连接网络反向传播推导

Week 6 hw3-1 全连接网络反向传播推导 折腾了半天&#xff0c;记录一下。 作业中网络由若干全连接层ReLU组成&#xff0c;输出层的函数为softmax&#xff0c;损失函数为交叉熵。 一、记号 设网络有nnn层。如图&#xff0c;当i<ni<ni<n时&#xff0c;我们有如下几条…
阅读更多...
机器学习/人工智能 实验一：典型监督学习方法分类实践与比较分析

机器学习/人工智能 实验一：典型监督学习方法分类实践与比较分析

一、实验目的与要求 (1)利用所学习的监督学习方法完成目标识别实验方案的设计。 (2)编程并利用相关软件完成实验测试&#xff0c;得到实验结果。 (3)通过对实验数据的分析﹑整理&#xff0c;方法的对比&#xff0c;得出实验结论&#xff0c;培养学生创新思维和编写实验报告的能…
阅读更多...
【PyTorch深度学习实践】09_卷积神经网络基础

【PyTorch深度学习实践】09_卷积神经网络基础

文章目录1.卷积操作1.1 卷积操作1.2 padding-填充1.3 stride-步长1.4 pooling-池化1.5 基础版CNN代码示例1.6 完整CNN代码示例1.卷积操作 卷积神经网络概览 1.1 卷积操作 输入通道数卷积核通道数&#xff0c;卷积核个数输出通道数 1.2 padding-填充 padding是为了让源图像最…
阅读更多...
FPGA图像处理HLS实现三种图像缩放算法，线性插值、双线性插值、双三次插值，提供HLS工程和vivado工程源码

FPGA图像处理HLS实现三种图像缩放算法，线性插值、双线性插值、双三次插值，提供HLS工程和vivado工程源码

目录一、三种图像缩放算法介绍线性插值双线性插值双三次插值二、HLS实现线性插值图像缩放三、HLS实现双线性插值图像缩放四、HLS实现双三次插值图像缩放五、HLS在线仿真并导出IP六、其他FPGA型号HLS在线仿真并导出IP七、zynq7100开发板vivado工程八、上板调试验证九、福利&…
阅读更多...
纪念QT可直接安装的离线版最后版本5.14.2

纪念QT可直接安装的离线版最后版本5.14.2

为什么说纪念呢&#xff1f;因为&#xff0c;这个版本之后再也没有可下载下来安装的版本了&#xff0c;因为我们以后再也没有这么方便了。为是很么说纪念呢&#xff1f;因为我们从QT还很柔弱的时候开始就是使用的离线版。 以前用c#来做组态&#xff0c;自定义控件开发起来也还…
阅读更多...
基础知识一览2

基础知识一览2

这里写目录标题1.XML2.1 XML中的转义字符2.2 CDATA区2.3 如何去约束XMl:DTD2.3.1 xml文件内部引用DTD约束2.3.2 xml文件引用外部DTD约束2.3.3 xml文件引用公共DTD约束1.XML xml的文件后缀名是.xmlxml有且只有一个根标签xml的标签是尖括号包裹关键字成对出现的&#xff0c;有开…
阅读更多...
如何做好banner设计（banner设计要点包括哪些）

如何做好banner设计（banner设计要点包括哪些）

网页设计的Banner作为表达网站价值或者传达广告信息的视觉主体&#xff0c;一直在根据网络环境的变化而变化着&#xff0c;从表现形式到尺寸大小&#xff0c;再到创意的多元化&#xff0c;因此更需要我们网页设计师们对其设计创意进行丰富和完善&#xff0c;才能真正达到宣传的…
阅读更多...
Elasticsearch入门——Elasticsearch7.8.0版本和Kibana7.8.0版本的下载、安装（win10环境）

Elasticsearch入门——Elasticsearch7.8.0版本和Kibana7.8.0版本的下载、安装（win10环境）

目录一、Elasticsearch7.8.0版本下载、安装1.1、官网下载地址1.2、下载步骤1.3、安装步骤(需要jdk11及以上版本支持)1.4、启动后&#xff0c;控制台中文乱码问题解决二、Node下载、安装&#xff08;安装Kibana之前需要先安装Node&#xff09;2.1、Node官网下载地址2.2、Node下载…
阅读更多...
Linux文字处理和文件编辑（三）

Linux文字处理和文件编辑（三）

1、Linux里的配置文件&#xff1a; /etc/bashrc文件&#xff1a;该配置文件在root用户下&#xff0c;权限很高。~/.bashrc文件&#xff1a;只有当前用户登录时才会执行该配置文件。每次打开终端&#xff0c;都会自动执行配置文件里的代码。比如&#xff0c;alias md‘mkdir’就…
阅读更多...
《2022年终总结》

《2022年终总结》

2022年终总结 笔者成为社畜的一年&#xff0c;整整打了一年工&#xff01; 之前都说每年都有点变化&#xff0c;今年的变化可能就是更加懒散了&#xff0c;玩了更多的手机 就是运动的坚持更加多了&#xff0c;收入也增加了&#xff0c;哈哈&#xff01; 其实今年的变化不大&am…
阅读更多...
41. 【农产品溯源项目前后端Demo】后端目录结构

41. 【农产品溯源项目前后端Demo】后端目录结构

本节介绍下后端代码的目录结构。 1. 实现用户管理、菜单管理、角色管理、代码自动生成等服务，归结为系统管理，是若依框架提供的能力。 2. ruoyi-traces实现农产品溯源应用的代码，如果要引入其他Java包，修改本模块的pom.xml文件。 1）config包加载配置文件数据，配置文件路…
阅读更多...
FPGA：IIC验证镁光EEPROM仿真模型（纯Verilog）

FPGA：IIC验证镁光EEPROM仿真模型（纯Verilog）

目录日常唠嗑一、程序设计二、镁光模型仿真验证三、testbench文件四、完整工程下载日常唠嗑 IIC协议这里就不赘述了&#xff0c;网上很多&#xff0c;这里推荐两个&#xff0c;可以看看【接口时序】6、IIC总线的原理与Verilog实现 &#xff0c;还有IIC协议原理以及主机、从机Ve…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023