Springboot快速整合kafka

news2024/12/23 5:59:45

kafka的基本了解

kafka也是 目前常用的消息中间件,支持同步与异步通信,和rabbitmq一样,工作模式大概相同,并且被spingboot整合的后的都是 中间件Template的实列化客户端类 ,消费者监听注解为@KafkaListener,和RabbitListener和很相似,这些消息中间件使用过后,发现大致都是相同的.
rabbitmq快速入门学习
对比
一般选择rabbitmq是完全足够的

环境安装

docker拉取镜像
kafka对zookeeper强依赖,毕竟能装载的数据量有这么大

docker pull zookeeper:3.4.14
#启动  这里使用的是host模式,一般说是需要统一docker网络
docker run -d --name zookeeper -p 2181:2181 zookeeper:3.4.14
#拉取 kafka镜像主义版本依赖问题
docker pull wurstmeister/kafka:2.12-2.3.1
#启动
docker run -d --name kafka \
--env KAFKA_ADVERTISED_HOST_NAME=192.168.249.132 \
--env KAFKA_ZOOKEEPER_CONNECT=192.168.249.132:2181 \
--env KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.249.132:9092 \
--env KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
--env KAFKA_HEAP_OPTS="-Xmx256M -Xms256M" \
--net=host wurstmeister/kafka:2.12-2.3.1

在这里插入图片描述
和消息队列一样,角色分别是生成者和消费者,生产者发送消息交给kafka服务,其中kafka一般是集群方式,单点为broker
kafka没有queue队列一说，是将消息存放在topic主题中和然后分发给消费者,这里的消费者是以组为单位,一组里面可以有多个消费者,但是只有一台机子消费者可以消费消息，而rabbitmq可以是以队列为单位消费,通过交换机进行分发,如果队列绑定多个消费者,那么可以自己选择轮询或者其他消费机制
在 Kafka 和 RabbitMQ 中，消费者组（或集群）的行为略有不同：

Kafka:

Kafka Consumer Group:

  • 在 Kafka 中，一个消费者组可以有多个消费者。
  • 每个分区内的消息只能由消费者组内的一个消费者消费，但不同分区的消息可以被不同的消费者处理。
  • 这种方式确保了分布式消费者组的横向扩展，每个消费者只负责处理特定分区的消息。
RabbitMQ:

RabbitMQ Consumer Group:

  • RabbitMQ 中没有严格的消费者组的概念，而是通过队列的方式来进行消息的订阅。
  • 多个消费者可以订阅同一个队列，每个消息只能被其中一个消费者消费。
  • RabbitMQ 不同于 Kafka 的是，消息不是在队列之间划分，而是通过交换机将消息路由到一个或多个队列。

总结:

在 Kafka 中，分区是横向划分消息的单元，每个分区只能由一个消费者处理，但不同分区可以并行处理。
在 RabbitMQ 中，队列是消息的接收单元，每个消息只能被一个消费者接收，但不同队列的消息是相互独立的。

这里不做过多讨论

基本使用

1.引入依赖

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
</dependency>

2.消息发送


/**
 * 生产者
 */
public class ProducerQuickStart {

    public static void main(String[] args) {
        //1.kafka的配置信息
        Properties properties = new Properties();
        //kafka的连接地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.200.130:9092");
        //发送失败，失败的重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,5);
        //消息key的序列化器
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        //消息value的序列化器
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");

        //2.生产者对象
        KafkaProducer<String,String> producer = new KafkaProducer<String, String>(properties);

        //封装发送的消息 需要指定topic 消息是存放在topic中的
        ProducerRecord<String,String> record = new ProducerRecord<String, String>("topic","100001","hello kafka");

        //3.发送消息
        producer.send(record);

        //4.关闭消息通道，必须关闭，否则消息发送不成功
        producer.close();
    }

}

3.消息消费
其中消息的序列化器和生产者一样,其次消费者单位是组,如果一个消费者组内只有一个可以接收信息,而有多个消费者监听该topic组,那么消息会发给每一个组,默认就是fanout扇出交换机

/**
 * 消费者
 */
public class ConsumerQuickStart {

    public static void main(String[] args) {
        //1.添加kafka的配置信息
        Properties properties = new Properties();
        //kafka的连接地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.200.130:9092");
        //消费者组
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "group2");
        //消息的反序列化器
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        //2.消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(properties);

        //3.订阅主题
        consumer.subscribe(Collections.singletonList("topic"));

        //当前线程一直处于监听状态
        while (true) {
            //4.获取消息
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(1000));
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                System.out.println(consumerRecord.key());
                System.out.println(consumerRecord.value());
            }
        }

    }

}

集群达到高可用

和rqabbit以及其他消息中间件一样为了数据的安全性和可用性,一般都是以集群方式存在在这里插入图片描述
还有集群的数据备份在这里插入图片描述

数据同步和故障转移在这里插入图片描述

ISR（in-sync replica）需要同步复制保存的follower

如果leader失效后，需要选出新的leader，选举的原则如下：

第一：选举时优先从ISR中选定，因为这个列表中follower的数据是与leader同步的

第二：如果ISR列表中的follower都不行了，就只能从其他follower中选取

极端情况，就是所有副本都失效了，这时有两种方案

第一：等待ISR中的一个活过来，选为Leader，数据可靠，但活过来的时间不确定

第二：选择第一个活过来的Replication，不一定是ISR中的，选为leader，以最快速度恢复可用性，但数据不一定完整

生产者性质

kafka支持同步发送消息和异步

  • 同步发送

    使用send()方法发送，它会返回一个Future对象，调用get()方法进行等待，就可以知道消息是否发送成功

RecordMetadata recordMetadata = producer.send(kvProducerRecord).get();
System.out.println(recordMetadata.offset());

  • 异步发送

    调用send()方法，并指定一个回调函数，服务器在返回响应时调用函数

//异步消息发送
producer.send(kvProducerRecord, new Callback() {
    @Override
    public void onCompletion(RecordMetadata recordMetadata, Exception e) {
        if(e != null){
            System.out.println("记录异常信息到日志表中");
        }
        System.out.println(recordMetadata.offset());
    }
});

在这里插入图片描述
如果没有得到kafka服务端的ack确认则会触发回调,可以在生产者配置文件中进行配置
//ack配置 消息确认机制

prop.put(ProducerConfig.ACKS_CONFIG,"all");

在这里插入图片描述以及失败重试机制,配置后只有重试耗尽才会抛出失败
在这里插入图片描述

代码配置代码的配置方式：

//ack配置  消息确认机制
prop.put(ProducerConfig.ACKS_CONFIG,"all");

参数的选择说明

生产者从服务器收到的错误有可能是临时性错误，在这种情况下，retries参数的值决定了生产者可以重发消息的次数，如果达到这个次数，生产者会放弃重试返回错误，默认情况下，生产者会在每次重试之间等待100ms

代码中配置方式：

//重试次数
prop.put(ProducerConfig.RETRIES_CONFIG,10);
  • 消息压缩

默认情况下， 消息发送时不会被压缩。

代码中配置方式：

//数据压缩
prop.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"lz4");
压缩算法说明
snappy占用较少的 CPU， 却能提供较好的性能和相当可观的压缩比， 如果看重性能和网络带宽，建议采用
lz4占用较少的 CPU， 压缩和解压缩速度较快，压缩比也很客观
gzip占用较多的 CPU，但会提供更高的压缩比，网络带宽有限，可以使用这种算法

使用压缩可以降低网络传输开销和存储开销，而这往往是向 Kafka 发送消息的瓶颈所在。

消费者

接下来探讨消费者,
消费者- 消费者组（Consumer Group） ：指的就是由一个或多个消费者组成的群体
在这里插入图片描述

  • 一个发布在Topic上消息被分发给此消费者组中的一个消费者

    • 所有的消费者都在一个组中，那么这就变成了queue模型

    • 所有的消费者都在不同的组中，那么就完全变成了发布-订阅模型 (rabitmq的基本工作模式)

7.2)消息有序性

应用场景：

  • 即时消息中的单对单聊天和群聊，保证发送方消息发送顺序与接收方的顺序一致

  • 充值转账两个渠道在同一个时间进行余额变更，短信通知必须要有顺序
    在这里插入图片描述

topic分区中消息只能由消费者组中的唯一一个消费者处理，所以消息肯定是按照先后顺序进行处理的。但是它也仅仅是保证Topic的一个分区顺序处理，不能保证跨分区的消息先后处理顺序。 所以，如果你想要顺序的处理Topic的所有消息，那就只提供一个分区。

7.3)提交和偏移量

kafka不会像其他JMS队列那样需要得到消费者的确认，消费者可以使用kafka来追踪消息在分区的位置（偏移量）

消费者会往一个叫做_consumer_offset的特殊主题发送消息，消息里包含了每个分区的偏移量。如果消费者发生崩溃或有新的消费者加入群组，就会触发再均衡,没有消费者的确认就只能通过偏移量了

正常的情况在这里插入图片描述
异常

在这里插入图片描述

如果消费者2挂掉以后，会发生再均衡，消费者2负责的分区会被其他消费者进行消费

再均衡后不可避免会出现一些问题

问题一：

如果提交偏移量小于客户端处理的最后一个消息的偏移量，那么处于两个偏移量之间的消息就会被重复处理。

问题二：

在这里插入图片描述

如果提交的偏移量大于客户端的最后一个消息的偏移量，那么处于两个偏移量之间的消息将会丢失。

如果想要解决这些问题，还要知道目前kafka提交偏移量的方式：

提交偏移量的方式有两种，分别是自动提交偏移量和手动提交

  • 自动提交偏移量

当enable.auto.commit被设置为true，提交方式就是让消费者自动提交偏移量，每隔5秒消费者会自动把从poll()方法接收的最大偏移量提交上去

  • 手动提交 ，当enable.auto.commit被设置为false可以有以下三种提交方式

    • 提交当前偏移量（同步提交）

    • 异步提交

    • 同步和异步组合提交

1.提交当前偏移量（同步提交）

把enable.auto.commit设置为false,让应用程序决定何时提交偏移量。使用commitSync()提交偏移量，commitSync()将会提交poll返回的最新的偏移量，所以在处理完所有记录后要确保调用了commitSync()方法。否则还是会有消息丢失的风险。

只要没有发生不可恢复的错误，commitSync()方法会一直尝试直至提交成功，如果提交失败也可以记录到错误日志里。

while (true){
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
    for (ConsumerRecord<String, String> record : records) {
        System.out.println(record.value());
        System.out.println(record.key());
        try {
            consumer.commitSync();//同步提交当前最新的偏移量
        }catch (CommitFailedException e){
            System.out.println("记录提交失败的异常："+e);
        }

    }
}

2.异步提交

手动提交有一个缺点，那就是当发起提交调用时应用会阻塞。当然我们可以减少手动提交的频率，但这个会增加消息重复的概率（和自动提交一样）。另外一个解决办法是，使用异步提交的API。

while (true){
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
    for (ConsumerRecord<String, String> record : records) {
        System.out.println(record.value());
        System.out.println(record.key());
    }
    consumer.commitAsync(new OffsetCommitCallback() {
        @Override
        public void onComplete(Map<TopicPartition, OffsetAndMetadata> map, Exception e) {
            if(e!=null){
                System.out.println("记录错误的提交偏移量："+ map+",异常信息"+e);
            }
        }
    });
}

3.同步和异步组合提交

异步提交也有个缺点，那就是如果服务器返回提交失败，异步提交不会进行重试。相比较起来，同步提交会进行重试直到成功或者最后抛出异常给应用。异步提交没有实现重试是因为，如果同时存在多个异步提交，进行重试可能会导致位移覆盖。

举个例子，假如我们发起了一个异步提交commitA，此时的提交位移为2000，随后又发起了一个异步提交commitB且位移为3000；commitA提交失败但commitB提交成功，此时commitA进行重试并成功的话，会将实际上将已经提交的位移从3000回滚到2000，导致消息重复消费。

try {
    while (true){
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
        for (ConsumerRecord<String, String> record : records) {
            System.out.println(record.value());
            System.out.println(record.key());
        }
        consumer.commitAsync();
    }
}catch (Exception e){+
    e.printStackTrace();
    System.out.println("记录错误信息："+e);
}finally {
    try {
        consumer.commitSync();
    }finally {
        consumer.close();
    }
}

springboot集成kafka

1.先写依赖

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- kafkfa -->
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.apache.kafka</groupId>
                <artifactId>kafka-clients</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
    </dependency>
</dependencies>

生产者端配置文件

server:
  port: 9991
spring:
  application:
    name: kafka-demo
  kafka:
    bootstrap-servers: 192.168.200.130:9092
    producer:
      retries: 10
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

消费者端

server:
  port: 9991
spring:
  application:
    name: kafka-demo
  kafka:
    bootstrap-servers: 192.168.200.130:9092
    consumer:
#这里消费者组就是服务名
      group-id: ${spring.application.name}
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

生产者

@RestController
public class HelloController {

    @Autowired
    private KafkaTemplate<String,String> kafkaTemplate;

    @GetMapping("/hello")
    public String hello(){
        kafkaTemplate.send("topic","程序员");
//如果是对象
 kafkaTemplate.send("topic",  User user = new User();
    user.setUsername("xiaowang");
    user.setAge(18);

    kafkaTemplate.send("user-topic", JSON.toJSONString(user));
);
        return "ok";
    }
}

消费者

package com.heima.kafka.listener;

import com.alibaba.fastjson.JSON;
import com.heima.kafka.pojo.User;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
public class HelloListener {

    @KafkaListener(topics = "user-topic")
    public void onMessage(String message){
        if(!StringUtils.isEmpty(message)){
            User user = JSON.parseObject(message, User.class);
            System.out.println(user);
        }

    }
}

springboot整合后和rabbitmq的使用方法差不多,大致内容和功能都可以实现,延迟队列和匹配routkey

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

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

相关文章

【Node.js】解决npm报错：RequestError: unable to verify the first certificate

【Node.js】解决npm报错：RequestError: unable to verify the first certificate

1. 问题简述 帖主从nodejs官网下载安装nodejs后&#xff0c;发现使用以下命令安装electron会报错&#xff1a; npm install electron 报错信息如下&#xff1a; npm ERR! RequestError: unable to verify the first certificate 2. 解决方案 网上列举的方案&#xff0c;无…
阅读更多...
【刷题笔记】串联所有单词的子串||暴力通过||滑动窗口

【刷题笔记】串联所有单词的子串||暴力通过||滑动窗口

串联所有单词的子串 1 题目描述 https://leetcode.cn/problems/substring-with-concatenation-of-all-words/ 给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。 s 中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。 …
阅读更多...
PGSQL(PostgreSQL)数据库安装教程

PGSQL(PostgreSQL)数据库安装教程

安装包下载 下载地址 下载后点击exe安装包 设置的data存储路径 设置密码 设置端口 安装完毕&#xff0c;配置PGSQL的ip远程连接&#xff0c;pg_hba.conf&#xff0c;postgresql.conf&#xff0c;需要更改这两个文件 pg_hba.conf 最后增加一行 host all all …
阅读更多...
如何计算数据泄露的成本

如何计算数据泄露的成本

现在&#xff0c;几乎所有类型的组织每天都在发生企业 IT 网络遭到破坏的情况。它们是任何合规官员最担心的问题&#xff0c;并且找出更好的方法来防止它们或从中恢复是合规官员永远不会远离的想法。 但数据泄露的实际成本是多少&#xff1f;该数字从何而来&#xff1f;当您获…
阅读更多...
手动将jar包导入本地Maven仓库

手动将jar包导入本地Maven仓库

1、进入存放jar包的目录&#xff0c;可以先放进仓库底下 2、cmd回车 3、执行命令&#xff0c;看到BUILD SUCCESS就是成功了 -DgroupId、-DartifactId、-Dversion、-Dfile记得换成自己对应的 mvn install:install-file -DgroupIdcom.github.03 -DartifactIdonvif -Dversion1.0.7…
阅读更多...
Linux基础操作三：Linux操作命令-目录文件操作

Linux基础操作三：Linux操作命令-目录文件操作

1、关机和重启 关机shutdown -h now 立刻关机shutdown -h 5 5分钟后关机poweroff 立刻关机 重启shutdown -r now 立刻重启shutdown -r 5 5分钟后重启reboot 立刻重启 2、帮助 --help命令shutdown --help&#xff1a;…
阅读更多...
kubernetes(k8s)容器内无法连接同所绑定的Service ClusterIP问题记录

kubernetes(k8s)容器内无法连接同所绑定的Service ClusterIP问题记录

kubernetes(k8s)容器内无法连接同所绑定的Service ClusterIP问题记录 1. k8s环境 k8s使用kubernetes-server-linux-amd64_1.19.10.tar.gz 二进制bin 的方式手动部署 k8s 版本: [rootmaster ~]# kubectl version Client Version: version.Info{Major:"1", Minor:&…
阅读更多...
掌握区块链技术将推进2024年市场发展脚步

掌握区块链技术将推进2024年市场发展脚步

1.高收入潜力 精通区块链的人才通常享有超过全国平均水平的薪酬&#xff0c;这也反映了对于专业技能的需求正在迅速增长。无论你选择成为这个领域哪一块业务的人员&#xff0c;掌握区块链技能均可以显著提升你的收入。 2.职业多样性 无论你目前从事什么职业&#xff0c;都可…
阅读更多...
前端项目环境的搭建

前端项目环境的搭建

一、下载并且安装Node&#xff08;不安装node&#xff0c;就安装nvm。nvm安装教程&#xff09;&#xff1a; 1.官网下载Node&#xff1a;https://nodejs.org/en/ 2.测试nodejs安装是否成功&#xff1a; 在windows powerShell中输入node -v 和 npm -v&#xff0c;看到版本号就…
阅读更多...
WordPress批量上传文章和自动发布文章的方法

WordPress批量上传文章和自动发布文章的方法

专业介绍&#xff1a;WordPress批量上传文章技术解析 在现代数字时代&#xff0c;内容创作是网络存在的驱动力之一。对于博客作者、新闻编辑和内容管理员而言&#xff0c;高效地批量上传文章至WordPress平台是提高工作效率的一个关键方面。WordPress作为最受欢迎的内容管理系统…
阅读更多...
福德植保无人机：农业科技的未来已来

福德植保无人机：农业科技的未来已来

一、引言 随着科技的不断进步&#xff0c;无人机技术已经深入到各个领域。而在农业领域&#xff0c;福德植保无人机更是引领了科技潮流&#xff0c;为农业生产带来了革命性的改变。今天&#xff0c;让我们一起来了解福德植保无人机的魅力所在。 二、福德植保无人机的优势 高效作…
阅读更多...
无人机助力电力设备螺母缺销智能检测识别，python基于YOLOv7开发构建电力设备螺母缺销高分辨率图像小目标检测系统

无人机助力电力设备螺母缺销智能检测识别，python基于YOLOv7开发构建电力设备螺母缺销高分辨率图像小目标检测系统

传统作业场景下电力设备的运维和维护都是人工来完成的&#xff0c;随着现代技术科技手段的不断发展&#xff0c;基于无人机航拍飞行的自动智能化电力设备问题检测成为了一种可行的手段&#xff0c;本文的核心内容就是基于YOLOv7来开发构建电力设备螺母缺销检测识别系统&#xf…
阅读更多...
gromacs学习及使用(2)

gromacs学习及使用(2)

命令解释参考GROMACS基本教程 整个流程参考分子动力学模拟Gromacs一般使用步骤&#xff08;空蛋白&#xff09; 从gromacs 5.0版本开始&#xff0c;所有的工具都是“gmx”的子模块。可以通过下面的命令获得任何一个模块的帮助信息&#xff1a; gmx help (module) 或者 gmx (mo…
阅读更多...
人主机辅与机主人辅

人主机辅与机主人辅

人主机辅和机主人辅的时机和地点一般取决于具体的应用场景和技术发展&#xff0c;具体而言&#xff1a; 人主机辅&#xff1a; 在较为复杂和需要专业知识的工作中&#xff0c;人类主持机器辅助的需求较为常见。例如&#xff0c;在医疗领域中&#xff0c;人类专家可能会利用机器…
阅读更多...
【2023CANN训练营第二季】——Ascend C算子调用及实验演示

【2023CANN训练营第二季】——Ascend C算子调用及实验演示

自定义算子调用方式 完成自定义算子的开发部署后&#xff0c;可以通过单算子调用的方式来验证单算子的功能。单算子调用有API执行和模型执行两种方式&#xff1a; 单算子API执行&#xff1a;基于C语言的API执行算子&#xff0c;无需提供单算子描述文件进行离线模型的转换&…
阅读更多...
docker buildx跨架构构建笔记(x86_64构建下构建aarch64镜像)

docker buildx跨架构构建笔记(x86_64构建下构建aarch64镜像)

docker buildx跨架构构建(x86_64构建aarch64镜像) 文章目录 docker buildx跨架构构建(x86_64构建aarch64镜像)简介第一步 先交叉编译一个aarch64的HelloWorld程序。准备一个用于跨架构的Dockerfile文件使用docker buildx命令构建aarch64架构的镜像。查看镜像具体详细信息&#…
阅读更多...
LeetCode Hot100 438.找到字符串中所有字母异位词

LeetCode Hot100 438.找到字符串中所有字母异位词

题目&#xff1a; 给定两个字符串 s 和 p&#xff0c;找到 s 中所有 p 的 异位词 的子串&#xff0c;返回这些子串的起始索引。不考虑答案输出的顺序。 异位词 指由相同字母重排列形成的字符串&#xff08;包括相同的字符串&#xff09;。 代码&#xff1a; class Solution …
阅读更多...
【shell】shell脚本编程作业

【shell】shell脚本编程作业

1 编写bash脚本&#xff0c;要求用户输入源目录和目标目录(绝对路径&#xff09;&#xff0c;然后列出源目录下所有的文件&#xff0c;并将这些文件拷贝到目标目录&#xff0c;并在文件名后面加上时间戳。&#xff08;提交源代码和运行截图&#xff09; if [ -d $1 ] || [ -d…
阅读更多...
类和对象——(3)再识对象

类和对象——(3)再识对象

归纳编程学习的感悟&#xff0c; 记录奋斗路上的点滴&#xff0c; 希望能帮到一样刻苦的你&#xff01; 如有不足欢迎指正&#xff01; 共同学习交流&#xff01; &#x1f30e;欢迎各位→点赞 &#x1f44d; 收藏⭐ 留言​&#x1f4dd; 你说那里有你的梦想&#xff0c;…
阅读更多...
国产linux单用户模式破解无密码登陆 （麒麟系统用户登录密码遗忘解决办法）

国产linux单用户模式破解无密码登陆 （麒麟系统用户登录密码遗忘解决办法）

笔者手里有一批国产linu系统&#xff0c;目前开始用在日常的工作生产环境中&#xff0c;我这个老程序猿勉为其难的充当运维的或网管的角色。 国产linux系统常见的为麒麟Linux&#xff0c;统信UOS等&#xff0c;基本都是基于debian再开发的linux。 问题描述&#xff1a; 因为…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023