Storm超实用教程详解-附示例

news2024/11/26 15:31:06

一、理论基础

      Storm 是一个免费并开源的分布式实时计算系统。利用 Storm 可以很容易做到可靠地处理无限的 数据流，像 Hadoop 批量处理大数据一样，Storm 可以实时处理数据。在Storm中，topology的构建是一个有向无环图。结点就是Spout或者Bolt，而边就是Spout和Bolt之间或者是Bolt和Bolt之间连接关系。它的一些基本概念如下：在传统的master/slave架构中，都是master节点负责任务的接受、分配、监控等管理任务，从节点负责任务的执行。

 

Spout发送单元，流的源头

它有两种实现方式BaseRichSpout和IRichSpout，建议实现前一种。通常Spout从外部数据源，如消息队列中读取元组数据并吐到拓扑里。Spout可以是可靠的(reliable)或者不可靠(unreliable)的。通过配置config的acker为0或emit方法不带msgId来实现，默认acker值为1。

Spout可以一次给多个流吐数据。此时需要通过OutputFieldsDeclarer的declareStream函数来声明多个流并在调用SpoutOutputCollector提供的emit方法时指定元组吐给哪个流。Storm框架会不断调用它去做元组的轮询。如果没有新的元组过来，就直接返回，否则把新元组吐到拓扑里。nextTuple必须是非阻塞的，因为Storm在同一个线程里执行Spout的函数。

Tuple：发送的数据流

是一个轻量级的数据格式，支持基本的类型，如果想实现自定义的类型，需要实现自己的序列化方式。在同一个流中,Tuple的数据格式应该都是一样的。不同流中的数据格式可能相同，也可能不同。这个对象必须是可序列化的。

Streams：核心抽象&&Stream Grouping：流分组

一个流由无限的元组序列组成，这些元组会被分布式并行地创建和处理。通过流中元组包含的字段名称来定义这个流。每个流声明时都被赋予了一个ID

  • OutputFieldsDeclarer: 用来声明流和流的定义
  • Serialization: Storm元组的动态类型转化，声明自定义的序列化方式
  • ISerialization: 自定义的序列化必须实现这个接口
  • CONFIG.TOPOLOGY_SERIALIZATIONS: 可以通过这个配置来注册自定义的序列化接口

Storm 中最重要的抽象，应该就是 Stream grouping 了，它能够控制 Spot/Bolt 对应的 Task 以什么样的方式来分发 Tuple，将 Tuple 发射到目的 Spot/Bolt 对应的 Task.定义拓扑的时候，一部分工作是指定每个Bolt应该消费哪些流。流分组定义了一个流在一个消费它的Bolt内的多个任务(task)之间如何分组。流分组跟计算机网络中的路由功能是类似的，决定了每个元组在拓扑中的处理路线。在Storm中有七个内置的流分组策略，你也可以通过实现CustomStreamGrouping接口来自定义一个流分组策略:

  1. shuffleGrouping：随机分配，元组到Bolt的某个任务上，这样保证同一个Bolt的每个任务都能够得到相同数量的元组。
  2. fieldsGrouping：字段分组， 按照指定的分组字段来进行流的分组。例如，流是用字段“user-id"来分组的，那有着相同“user-id"的元组就会分到同一个任务里，但是有不同“user-id"的元组就会分到不同的任务里。通过这种流分组方式，我们就可以做到让Storm产出的消息在这个"user-id"级别是严格有序的，这对一些对时序敏感的应用(例如，计费系统)是非常重要的。
  3. Partial Key grouping: 跟字段分组一样，流也是用指定的分组字段进行分组的，但是在多个下游Bolt之间是有负载均衡的，这样当输入数据有倾斜时可以更好的利用资源。
  4. allGrouping：广播发送，流会复制给Bolt的所有任务。小心使用这种分组方式。在拓扑中，如果希望某类元祖发送到所有的下游消费者，就可以使用这种All grouping的流分组策略。
  5. globalGrouping: 整个流会分配给Bolt的一个任务。具体一点，会分配给有最小ID的任务。全局分组， 这个tuple被分配到storm中的一个bolt的其中一个task。再具体一点就是分配给id值最低的那个task。 
  6. Direct grouping：一种特殊的分组。对于这样分组的流，元组的生产者决定消费者的哪个任务会接收处理这个元组。只能在声明做直连的流(direct streams)上声明Direct groupings分组方式。只能通过使用emitDirect系列函数来吐元组给直连流。一个Bolt可以通过提供的TopologyContext来获得消费者的任务ID，也可以通过OutputCollector对象的emit函数(会返回元组被发送到的任务的ID)来跟踪消费者的任务ID。在ack的实现中，Spout有两个直连输入流，ack和ackFail，使用了这种直连分组的方式。
  7. Local or shuffle grouping：如果目标Bolt在同一个worker进程里有一个或多个任务，元组就会通过洗牌的方式分配到这些同一个进程内的任务里。否则，就跟普通的洗牌分组一样。这种方式的好处是可以提高拓扑的处理效率，因为worker内部通信就是进程内部通信了，相比拓扑间的进程间通信要高效的多。worker进程间通信是通过使用Netty来进行网络通信的。
  • TopologyBuilder: 使用这个类来定义拓扑
  • InputDeclarer: 当调用TopologyBuilder的setBolt函数时会返回这个对象，它用来声明一个Bolt的输入流并指定流的分组方式
  • CoordinatedBolt: 这个Bolt对于分布式的RPC拓扑很有用，大量使用了直连流(direct streams)和直连分组(direct groupings)

Bolt：流水线上的处理单元

把数据的计算处理过程合理的拆分到多个Bolt、合理设置Bolt的task数量，能够提高Bolt的处理能力，提升流水线的并发度。它也有两种实现方式BaseRichBolt和IRichBolt，建议实现前一种。

Bolt可以给多个流吐出元组数据。此时需要使用OutputFieldsDeclarer的declareStream方法来声明多个流并在使用[OutputColletor]的emit方法时指定给哪个流吐数据。当你声明了一个Bolt的输入流，也就订阅了另外一个组件的某个特定的输出流。如果希望订阅另一个组件的所有流，需要单独挨个订阅。InputDeclarer有语法糖来订阅ID为默认值的流。例如declarer.shuffleGrouping("redBolt")订阅了redBolt组件上的默认流，跟declarer.shuffleGrouping("redBolt", DEFAULT_STREAM_ID)是相同的。

必须注意OutputCollector不是线程安全的，所以所有的吐数据(emit)、确认(ack)、通知失败(fail)必须发生在同一个线程里。

  • IRichBolt: 这是Bolt的通用接口
  • IBasicBolt: 很方便的Bolt接口，用于定义做过滤或者简单处理的Bolt
  • OutputCollector: Bolt通过这个类的实例来吐元组给输出流

Topology

把spout和bolt连接起来，构建一张有向无图topy图，拓扑会一直运行下去直到被kill掉。一个拓扑就是一个复杂的多阶段的流计算。worker、executor、task的关系

  1. worker是一个进程.1 个 worker 进程执行的是 1 个 topology 的子集(注:不会出现 1 个 worker 为多个 topology 服务)。1 个 worker 进程会启动 1 个或多个 executor 线程来执行 1 个 topology 的 component(spout 或 bolt)。因此，1 个运行中的 topology 就是由集群中多台物理机上的多个 worker 进程组成的。
  2. executor是一个线程，是运行tasks的物理容器.executor 是 1 个被 worker 进程启动的单独线程。每个 executor 只会运行 1 个 topology 的 1 个 component(spout 或 bolt)的 task(注:task 可以是 1 个或多个，storm 默认是 1 个 component 只生成 1 个 task，executor 线程里会在每次循环里顺序调用所有 task 实例)。
  3. task是对spout/bolt/acker等任务的逻辑抽象.是最终运行 spout 或 bolt 中代码的单元(注:1 个 task 即为 spout 或 bolt 的 1 个实例， executor 线程在执行期间会调用该 task 的 nextTuple 或 execute 方法)。topology 启动后，1 个 component(spout 或 bolt)的 task 数目是固定不变的，但该 component 使用的 executor 线 程数可以动态调整(例如:1 个 executor 线程可以执行该 component 的 1 个或多个 task 实 例)。这意味着，对于 1 个 component 存在这样的条件:#threads<=#tasks(即:线程数小于 等于 task 数目)。默认情况下 task 的数目等于 executor 线程数目，即 1 个 executor 线程只运 行 1 个 task。

二、常见配置

有很多topology级的配置可以设。 以”TOPOLOGY”打头的配置是topology级别的配置，可以覆盖全局级别的配置。下面是一些比较常见的：

1）Config.TOPOLOGY_WORKER设置:  这个设置用多少个工作进程来执行这个topology。比如，如果你把它设置成25， 那么集群里面一共会有25个java进程来执行这个topology的所有task。如果你的这个topology里面所有组件加起来一共有150的并行 度，那么每个进程里面会有6个线程(150 / 25 = 6)。

2）Config.TOPOLOGY_ACKERS: 这个配置设置acker线程的数目。Ackers是Storm的可靠性API的一部分。

3）Config.TOPOLOGY_MAX_SPOUT_PENDING:  这个设置一个spout task上面最多有多少个没有处理的tuple（没有ack/failed）回复， 我们推荐你设置这个配置，以防止tuple队列爆掉。

4）Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS: 这个配置storm的tuple的超时时间  – 超过这个时间的tuple被认为处理失败了。这个设置的默认设置是30秒，对于大多数的topology都已经足够了。

5）Config.TOPOLOGY_SERIALIZATIONS: 为了在你的tuple里面使用自定义类型，你可以用这个配置注册自定义serializer。

三、示例程序

示例1：BaseRichSpout

import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichSpout;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Values;
import backtype.storm.utils.Utils;

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class SentenceSpout extends BaseRichSpout {
    private static final long serialVersionUID = 4608825077450573093L;
    private ConcurrentHashMap<UUID, Values> pending;
    private SpoutOutputCollector collector;
    private String[] sentences = {
            "connecting the dots",
            "love and loss",
            "keep looking",
            "do not settle",
            "stay hungry",
            "stay foolish"
    };
    private int index;

    /**
     * Spout的构造函数，类初始化时被调用，一般会把读取数据源的操作放在此方法里。里面接收了三个参数，
     * 第一个是创建Topology时的配置，
     * 第二个是所有的Topology数据，可以设置一些变量
     * 第三个是用来把Spout的数据发射给bolt,发布交给bolts处理的数据
     * **/
    @Override
    public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
        this.index = 0;
        this.collector = collector;
        //要处理的数据
        this.pending = new ConcurrentHashMap<UUID, Values>();
    }

    /**
     * 声明输出元组的字段信息
     */
    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("sentence"));
    }

    /**
     * 这是Spout最主要的方法，在这里我们读取文本文件，并把它的每一行发射出去（给bolt）
     * 这个方法会不断被调用，死循环。为了降低它对CPU的消耗，当任务完成时让它sleep一下
     * /
    @Override
    public void nextTuple() {
        Values value = new Values(sentences[index]);
        UUID msgId = UUID.randomUUID();
        this.pending.put(msgId, value);
        //每行发布一个Tuple,后面必须带个消息ID，如果不带msgID则下游Blot处理失败时就不会调用ack方法
        this.collector.emit(value,msgId);
        index++;
        if(index >= sentences.length){
            index = 0;
        }
        // 休眠0.1毫秒
        Utils.sleep(100);
    }

    /**
     * 元组被正常处理后的操作
     */
    @Override
    public void ack(Object msgId){
        this.pending.remove(msgId);
    }

    /**
     * 如果元组未被正常处理就重发
     */
    @Override
    public void fail(Object msgId){
        this.collector.emit(this.pending.get(msgId),msgId);
    }
}

示例2：BaseRichBolt

/*把句子分割成为单词，然后传递到下游的Bolt*/
public class SplitSentenceBolt extends BaseRichBolt {
    private static final long serialVersionUID = 2390867112177953110L;
    private OutputCollector collector;

    /**
     * 在Storm中，这个方法相当于Bolt的构造函数，类初始化时被调用，
     * 所以一般会把Bolt初始化操作放在这个方法里
     */
    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
    }

    /**
     * 声明输出元组的字段信息,发送给下一个Bolt
     */
    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("word"));
    }

    /**这是bolt中最重要的方法，每当接收到一个tuple时，此方法便被调用
     * 这个方法的作用就是把文本文件中的每一行切分成一个个单词，并把这些单词发射出去（给下一个bolt处理）
     * **/
    @Override
    public void execute(Tuple tuple) {
        String sentence = tuple.getStringByField("sentence");//值可以按位置或名称读取
        String[] words = sentence.split(" ");
        for(String word:words){
            word = word.trim();
            // 将输出的tuple和输入的tuple锚定
            this.collector.emit(tuple,new Values(word));
        }
        // 告诉Spout，这个元组已经被成功处理了
        this.collector.ack(tuple);
    }
}
--------------------------------------------------------------------------------
/*统计各个单词出现的次数，然后传递给下游的Bolt*/
public class WordCountBolt extends BaseRichBolt {
    private static final long serialVersionUID = 360868701353402042L;
    private OutputCollector collector;
    private HashMap<String,Integer> counters;

    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
        counters = new HashMap<String, Integer>();
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("word","count"));
    }

    @Override
    public void execute(Tuple tuple) {
        String word = tuple.getStringByField("word");
        Integer count = counters.get(word);
        if(null == count){
            count = 0;
        }
        count++;
        this.counters.put(word, count);
        // 将输出的tuple和输入的tuple锚定
        this.collector.emit(tuple,new Values(word,count));
        // 告诉上游Bolt，这个元组已经被成功处理了
        this.collector.ack(tuple);
    }
}
--------------------------------------------------------------------------------
/*拓扑运行结束时打印单词计数（这里只是演示而这样做的，生成环境中Storm会一直运行下去，除非你主动停止它）*/
public class ReportBolt extends BaseRichBolt {
    private static final long serialVersionUID = -1884042962508663765L;
    private HashMap<String,Integer> counts;

    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollector arg2) {
        this.counts = new HashMap<String, Integer>();
    }

    /**
     * 这个Bolt什么也不输出
     */
    @Override
    public void declareOutputFields(OutputFieldsDeclarer arg0) {

    }

    @Override
    public void execute(Tuple tuple) {
        String word = tuple.getStringByField("word");
        Integer count = tuple.getIntegerByField("count");
        this.counts.put(word, count);
    }

    /*Topology执行完毕的清理工作，比如关闭连接、释放资源等操作都会写在这里*/
    @Override
    public void cleanup(){
        System.out.println("******count result******");
        for (Map.Entry<String, Integer> entry : counts.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

示例3：Topology

/*Topology中的各结点已经构造完毕，接下来要把它们连接起来，构成一张有向无环图*/
public class WordCountTopology {
    private static final String CENTENER_SPOUT_ID = "sentence-spout";
    private static final String SPLIT_BOLT_ID = "split-bolt";
    private static final String COUNT_BOLT_ID = "count-bolt";
    private static final String REPORT_BOLT_ID = "report-bolt";
    private static final String TOPOLOGY_NAME = "word-count-toplogy";
    public static void main(String[] args){
        SentenceSpout spout = new SentenceSpout();
        SplitSentenceBolt splitBolt = new SplitSentenceBolt();
        WordCountBolt countBolt = new WordCountBolt();
        ReportBolt reportBolt = new ReportBolt();

        TopologyBuilder builder = new TopologyBuilder();
        builder.setSpout(CENTENER_SPOUT_ID, spout);

        //下面setBolt方法的并发度全是1，根据情况来设置
        // SentenceSpout ---> SplitSentenceBolt。在spout和bolts之间通过shuffleGrouping（随机分配Bolt）方法连接
        builder.setBolt(SPLIT_BOLT_ID, splitBolt).shuffleGrouping(CENTENER_SPOUT_ID);

        // SplitSentenceBolt ---> WordCountBolt，把相同的单词发给同一个Bolt
        builder.setBolt(COUNT_BOLT_ID, countBolt).fieldsGrouping(SPLIT_BOLT_ID, new Fields("word"));

        // WordCountBolt ---> ReportBolt
        builder.setBolt(REPORT_BOLT_ID, reportBolt).globalGrouping(COUNT_BOLT_ID);

        Config config = new Config();

        /*//在storm中可以用这种方式取出值来
        config.put("wordsFile", "d:/text.txt");
        config.get("wordsFile");
        conf.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, 1);
        */

        //创建一个本地模式cluster
        LocalCluster cluster = new LocalCluster();
        cluster.submitTopology(TOPOLOGY_NAME, config, builder.createTopology());
        // 休眠10秒
        Utils.sleep(10000);
        cluster.killTopology(TOPOLOGY_NAME);
        cluster.shutdown();
    }
}

四、与Kafka集成

public class StormKafkaTopo {
     public static void main(String[] args) {
         BrokerHosts brokerHosts = new ZkHosts("192.168.1.216:2181/kafka");
         SpoutConfig spoutConfig = new SpoutConfig(brokerHosts, "topic1", "/kafka", "kafkaspout");
         Config conf = new Config();
         Map<String, String> map = new HashMap<String, String>();
         map.put("metadata.broker.list", "192.168.1.216:9092");
         map.put("serializer.class", "kafka.serializer.StringEncoder");
         conf.put("kafka.broker.properties", map);32         conf.put("topic", "topic2");
         spoutConfig.scheme = new SchemeAsMultiScheme(new MessageScheme());
         TopologyBuilder builder = new TopologyBuilder();
         builder.setSpout("spout", new KafkaSpout(spoutConfig));
         builder.setBolt("bolt", new SenqueceBolt()).shuffleGrouping("spout");
         builder.setBolt("kafkabolt", new KafkaBolt<String, Integer>()).shuffleGrouping("bolt");
         if(args != null && args.length > 0) {
             //提交到集群运行
            try {
                 StormSubmitter.submitTopology(args[0], conf, builder.createTopology());
            } catch (AlreadyAliveException e) {
                 e.printStackTrace();
             } catch (InvalidTopologyException e) {
                 e.printStackTrace();
             }
        } else {
             //本地模式运行
             LocalCluster cluster = new LocalCluster();
             cluster.submitTopology("Topotest1121", conf, builder.createTopology());
             Utils.sleep(1000000);
            cluster.killTopology("Topotest1121");
             cluster.shutdown();
         }       
    }
}

 

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

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

相关文章

CKA 04_部署 harbor 仓库 containerd 连接 harbor 仓库 kubeadm 引导集群

CKA 04_部署 harbor 仓库 containerd 连接 harbor 仓库 kubeadm 引导集群

文章目录 1. 清空之前的策略1.1 kubeadm 重置1.2 刷新 IPtables 表 2. 查看 Kubernetes 集群使用的镜像3. 搭建 harbor 仓库3.1 部署 docker3.1.1 准备镜像源3.1.2 安装 docker3.1.3 开机自启 docker3.1.4 修改内核参数&#xff0c;打开桥接3.1.5 验证生效 3.2 准备 harbor 仓库…
阅读更多...
chatgpt赋能python：Python如何写网站的SEO

chatgpt赋能python：Python如何写网站的SEO

Python如何写网站的SEO 在当今的数字时代&#xff0c;网站是公司或个人吸引更多目标受众和客户的重要媒介之一。然而&#xff0c;拥有优秀内容和设计不足以保证流量。搜寻引擎优化(SEO)是一项重要的工作&#xff0c;它帮助网站排名更高&#xff0c;被更多人看到。Python是一种…
阅读更多...
chatgpt赋能python：Python技术分享：如何再建立一个文档的SEO

chatgpt赋能python：Python技术分享：如何再建立一个文档的SEO

Python技术分享&#xff1a;如何再建立一个文档的SEO Python作为一种高级编程语言&#xff0c;被业内大量使用。它的易用性、跨平台性、语法简单易懂、代码可读性高等特性进一步增强了它的流行度。在使用Python编程时&#xff0c;经常会需要生成文档&#xff0c;使得我们的项目…
阅读更多...
软考A计划-系统架构师-官方考试指定教程-(12/15)

软考A计划-系统架构师-官方考试指定教程-(12/15)

点击跳转专栏>Unity3D特效百例点击跳转专栏>案例项目实战源码点击跳转专栏>游戏脚本-辅助自动化点击跳转专栏>Android控件全解手册点击跳转专栏>Scratch编程案例 &#x1f449;关于作者 专注于Android/Unity和各种游戏开发技巧&#xff0c;以及各种资源分享&am…
阅读更多...
chatgpt赋能python：Python如何免费群发短信

chatgpt赋能python：Python如何免费群发短信

Python如何免费群发短信 在数字化时代&#xff0c;短信成为了快速高效的沟通方式之一。针对群发短信需求&#xff0c;市场上存在着多种短信群发软件&#xff0c;而Python作为一个强大的编程工具&#xff0c;也可以轻松实现免费的短信群发功能。本篇文章将为大家介绍如何通过Py…
阅读更多...
从QGIS图层中裁剪需要的区域

从QGIS图层中裁剪需要的区域

GiS数据裁切&#xff0c;创建一个临时图层&#xff0c;通过矢量裁切的方法&#xff0c;将Gis图层进行裁切&#xff1b;影像裁切&#xff0c;将影像图层放置在Gis中&#xff0c;截取影像图以及临时图层的轮廓&#xff0c;放入PS中进行对比&#xff0c;然后将影像图裁切下来。 1…
阅读更多...
软件测试01：软件及分类和缺陷的定义

软件测试01：软件及分类和缺陷的定义

软件测试&#xff1a;软件及分类和缺陷的定义 软件 程序数据文档 软件分类 层次分类 系统软件应用软件组织分类 商业软件开源软件结构分类 单机软件分布式软件(两种&#xff1a;BS服务端架构模型和CS客户端架构模型) 软件缺陷 软件缺陷的由来 起源于上世纪70年代中期 《测…
阅读更多...
javaScript蓝桥杯---新增地址

javaScript蓝桥杯---新增地址

目录 一、介绍二、准备三、目标四、代码五、完成 一、介绍 网购大家应该再熟悉不过&#xff0c;网购中有个很难让人忽略的功能就是地址管理&#xff0c;接下来就让我们通过完善代码来探索下地址管理中常用功能的实现吧&#xff5e; 本题需要在已提供的基础项目中使用 JS 知识…
阅读更多...
chatgpt赋能python：Python输入：优秀的函数、方法和技巧

chatgpt赋能python：Python输入：优秀的函数、方法和技巧

Python输入&#xff1a;优秀的函数、方法和技巧 引言 从文件读取数据&#xff0c;在终端上接收用户输入&#xff0c;在Web应用程序中处理表单数据&#xff0c;这些都是Python中经常需要进行的一些任务。Python内置了许多函数和方法来处理这些任务&#xff0c;但是从众多的选项…
阅读更多...
CSS 谈谈你对重排和重绘的理解

CSS 谈谈你对重排和重绘的理解

一、前言 当我们给我们的DOM结构改变或者给DOM结构设置样式时&#xff0c;会触发回流和重绘&#xff0c;但不同的样式改变&#xff0c;是否触发重排和重绘是不确定的。我们有必要深度理解重排和重绘&#xff0c;通过减少重排可以提高性能。 了解浏览器的解析渲染机制: (1).解析…
阅读更多...
C++中的数组理解与应用

C++中的数组理解与应用

数组的数据结构 数组是最基本的数据结构&#xff0c;关于数组的面试题也屡见不鲜&#xff0c;本文罗列了一些常见的面试题&#xff0c;仅供参考。目前有以下18道题目。 数组求和 求数组的最大值和最小值 求数组的最大值和次大值 求数组中出现次数超过一半的元素 求数组中元…
阅读更多...
详解c++---二叉搜索树的讲解和模拟实现

详解c++---二叉搜索树的讲解和模拟实现

目录标题 二分查找的优缺点搜索二叉树的规则搜索二叉树的特性二叉搜索树的性能分析准备工作二叉搜索树的插入函数二叉搜索树的打印函数二叉搜索树的查找函数二叉搜索树的删除函数拷贝构造函数赋值重载析构函数递归版本的find函数递归版本的插入递归的删除方法搜索树的应用模型 …
阅读更多...
burpsuite+xray实现联动测试（手动分析和自动化测试同时进行）

burpsuite+xray实现联动测试（手动分析和自动化测试同时进行）

目的&#xff1a;安全测试过程中手动分析测试与xray自动化扫描测试结合&#xff0c;这样可以从多层保障安全测试的分析&#xff0c;针对平台业务接口量大的安全测试是十分有用的&#xff0c;可以实现双向测试同时开始。 xray简介 xray 是一款功能强大的安全评估工具&#xff…
阅读更多...
MySQL数据库基础 05

MySQL数据库基础 05

第五章 排序与分页 1. 排序数据1.1 排序规则1.2 单列排序1.3 多列排序 2. 分页2.1 背景2.2 实现规则2.3 拓展 1. 排序数据 1.1 排序规则 使用 ORDER BY 子句排序 ASC&#xff08;ascend&#xff09;: 升序DESC&#xff08;descend&#xff09;:降序 ORDER BY 子句在SELECT语句…
阅读更多...
chatgpt赋能python：Python如何避免代码重复

chatgpt赋能python：Python如何避免代码重复

Python如何避免代码重复 作为一名有10年Python编程经验的工程师&#xff0c;我深知代码重复会降低程序的可维护性&#xff0c;使代码变得混乱和难以扩展。因此&#xff0c;我想在这篇文章中介绍一些技术和最佳实践来避免Python代码重复。 为什么要避免重复代码&#xff1f; …
阅读更多...
idea插件开发-Library

idea插件开发-Library

库是模块所依赖的已编译代码&#xff08;例如 JAR 文件&#xff09;的存档。IntelliJ 平台支持三种类型的库&#xff1a;1、Module Library&#xff1a;库类只在本模块可见&#xff0c;库信息记录在模块.iml文件中。2、Project Library&#xff1a;库类在项目中可见&#xff0c…
阅读更多...
Scrapy框架 增量式、分布式爬虫

Scrapy框架 增量式、分布式爬虫

文章目录 Scrapy框架1.增量爬虫2.分布式爬虫 Scrapy框架 1.增量爬虫 实现思路 利用redis集合数据类型 1.获取到url后进行判断 是否重复&#xff1f;&#xff1f;&#xff1f; 2.第一次爬取到数据&#xff0c;爬取完成写入该记录... &#xff08;两个点: 必须要没有爬过的数据…
阅读更多...
chatgpt赋能python：Python实现计算器：从入门到实现

chatgpt赋能python：Python实现计算器：从入门到实现

Python实现计算器&#xff1a;从入门到实现 计算器是计算机科学中最基础并且实用的东西之一。Python作为一种高级编程语言&#xff0c;它可以用于编写一个功能完整的计算器。在本文中&#xff0c;我们将介绍Python如何实现一个简单的、交互式的计算器&#xff0c;通过使用基本…
阅读更多...
【MySQL 数据库】7、SQL 优化

【MySQL 数据库】7、SQL 优化

目录 一、插入数据优化(1) insert 语句① 批量插入数据② 手动控制事务③ 主键顺序插入&#xff0c;性能要高于乱序插入 (2) load 大批量插入数据【☆❀ 二、主键优化(1) 数据组织形式(2) 页分裂(3) 页合并(4) 主键设计原则 三、orber by 优化四、group by 优化五、limit 优化&…
阅读更多...
chatgpt赋能python：Python怎么五个一行输出？

chatgpt赋能python：Python怎么五个一行输出？

Python怎么五个一行输出&#xff1f; 在Python中&#xff0c;实现五个一行输出并不难&#xff0c;只需要使用循环语句即可。下面&#xff0c;我们将介绍如何使用Python实现五个一行输出。 实现方法 首先&#xff0c;我们需要定义一个包含一定数量元素的列表或字符串。然后&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023