c - librdkafka 消费者未收到来自代理的消息-6ren

c - librdkafka 消费者未收到来自代理的消息

转载作者：行者123 更新时间：2023-11-30 16:10:48

我使用 librdkafka 库用 C 语言编写了 kafka 消费者和生产者。 Kafka代理版本是kafka_2.12-2.3.0。生产者正在成功生成消息，并且 dr_msg_cb 函数确认已成功交付。但是，消费者没有收到来自代理的消息。有人可以帮忙进一步调试吗？

我可以看到从消费者到代理的 TCP 连接已建立。但 TCPdump 显示代理没有向消费者发送任何数据。我在消费者代码上启用了调试，下面是消息。

[2019 Nov  8 19:18:09.458553135:155:E:logger:1741] TID 05 : [LOG_TRACE]:RDKAFKA-7-SSL: rdkafka#consumer-2: [thrd:app]: Loading CA certificate(s) from file /mnt/ifc/cfg/d
ata/securedata/clientcerts/kafka/ApicCa.crt
[2019 Nov  8 19:18:09.458880860:156:E:logger:1741] TID 05 : [LOG_TRACE]:RDKAFKA-7-SSL: rdkafka#consumer-2: [thrd:app]: Loading certificate from file /mnt/ifc/cfg/data/se
curedata/clientcerts/kafka/KafkaClient.crt
[2019 Nov  8 19:18:09.459151178:157:E:logger:1741] TID 05 : [LOG_TRACE]:RDKAFKA-7-SSL: rdkafka#consumer-2: [thrd:app]: Loading private key file from /mnt/ifc/cfg/data/se
curedata/clientcerts/kafka/KafkaClient8.key
[2019 Nov  8 19:18:09.459583515:158:E:logger:1741] TID 06 : [LOG_TRACE]:RDKAFKA-7-BRKMAIN: rdkafka#consumer-2: [thrd::0/internal]: :0/internal: Enter main broker thread
[2019 Nov  8 19:18:09.459589163:159:E:logger:1741] TID 06 : [LOG_TRACE]:RDKAFKA-7-STATE: rdkafka#consumer-2: [thrd::0/internal]: :0/internal: Broker changed state INIT -
> UP
[2019 Nov  8 19:18:09.459593374:160:E:logger:1741] TID 06 : [LOG_TRACE]:RDKAFKA-7-BROADCAST: rdkafka#consumer-2: [thrd::0/internal]: Broadcasting state change
[2019 Nov  8 19:18:09.459608395:161:E:logger:1741] TID 07 : [LOG_TRACE]:RDKAFKA-7-BROADCAST: rdkafka#consumer-2: [thrd:main]: Broadcasting state change
[2019 Nov  8 19:18:09.459708091:162:E:logger:1741] TID 05 : [LOG_TRACE]:RDKAFKA-7-BROKER: rdkafka#consumer-2: [thrd:app]: ssl://10.0.0.1:9092/bootstrap: Added new broker with NodeId -1
[2019 Nov  8 19:18:09.459718029:163:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-BRKMAIN: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Enter main broker thread
[2019 Nov  8 19:18:09.459723538:164:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-CONNECT: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: broker in state INIT connecting
[2019 Nov  8 19:18:09.459918518:165:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-CONNECT: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Connecting to ipv4#10.0.0.1:9092 (ssl) with socket 34
[2019 Nov  8 19:18:09.460017515:166:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-STATE: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Broker changed state INIT -> CONNECT
[2019 Nov  8 19:18:09.460021977:167:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-BROADCAST: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: Broadcasting state change
[2019 Nov  8 19:18:09.460228677:168:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-CONNECT: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Connected to ipv4#10.0.0.1:9092
[2019 Nov  8 19:18:09.790145695:169:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-SSLVERIFY: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Broker SSL certificate verified
[2019 Nov  8 19:18:09.790151895:170:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-CONNECTED: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Connected (#1)
[2019 Nov  8 19:18:09.790168266:171:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-FEATURE: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Updated enabled protocol features +ApiVersion to ApiVersion
[2019 Nov  8 19:18:09.790172810:172:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-STATE: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Broker changed state CONNECT -> APIVERSION_QUERY
[2019 Nov  8 19:18:09.790176880:173:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-BROADCAST: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: Broadcasting state change
[2019 Nov  8 19:18:09.790888559:174:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-FEATURE: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Updated enabled protocol features to MsgVer1,ApiVersion,BrokerBalancedConsumer,ThrottleTime,Sasl,SaslHandshake,BrokerGroupCoordinator,LZ4,OffsetTime,MsgVer2
[2019 Nov  8 19:18:09.790893525:175:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-STATE: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: Broker changed state APIVERSION_QUERY -> UP
[2019 Nov  8 19:18:09.790897645:176:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-BROADCAST: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: Broadcasting state change
[2019 Nov  8 19:18:09.791643149:177:E:logger:1741] TID 07 : [LOG_TRACE]:RDKAFKA-7-CLUSTERID: rdkafka#consumer-2: [thrd:main]: ssl://10.0.0.1:9092/bootstrap: ClusterId update "" -> "r7Us-jYGQRq34re8owKyJA"
[2019 Nov  8 19:18:09.791654890:178:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-UPDATE: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/bootstrap: NodeId changed from -1 to 1
[2019 Nov  8 19:18:09.791663562:179:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-UPDATE: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/1: Name changed from ssl://10.0.0.1:9092/bootstrap to ssl://10.0.0.1:9092/1
[2019 Nov  8 19:18:09.791668295:180:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-LEADER: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/1: Mapped 0 partition(s) to broker
[2019 Nov  8 19:18:09.791671709:181:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-STATE: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/1: Broker changed state UP -> UPDATE
[2019 Nov  8 19:18:09.791675360:182:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-BROADCAST: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: Broadcasting state change
[2019 Nov  8 19:18:09.791692544:183:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-STATE: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: ssl://10.0.0.1:9092/1: Broker changed state UPDATE -> UP
[2019 Nov  8 19:18:09.791696027:184:E:logger:1741] TID 08 : [LOG_TRACE]:RDKAFKA-7-BROADCAST: rdkafka#consumer-2: [thrd:ssl://10.0.0.1:9092/bootstrap]: Broadcasting state change

消费者代码如下所示。

static void
msg_consume(rd_kafka_message_t *rkmessage, void *opaque)
{
    if (rkmessage == NULL) {
        return;
    }

    if (rkmessage->err) {
        if (rkmessage->err == RD_KAFKA_RESP_ERR__PARTITION_EOF) {
            DEBUG_PRINT(DBG_TRACE,
                        "%% Consumer reached end of %s [%"PRId32"] "
                        "message queue at offset %"PRId64"\n",
                         (rkmessage->rkt) ? 
                          rd_kafka_topic_name(rkmessage->rkt) : "NULL",
                          rkmessage->partition, rkmessage->offset);
            return;
        }

        if (rkmessage->err == RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION ||
            rkmessage->err == RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC) {
            return;
        }

        return;
    }

    if (rkmessage->key_len) {
        DEBUG_PRINT(DBG_TRACE, "Key: %.*s\n", (int)rkmessage->key_len, 
                    (char *)rkmessage->key);
    }

    DEBUG_PRINT(DBG_TRACE, "%.*s\n", (int)rkmessage->len, 
                (char *)rkmessage->payload);
}

syserr_t
kafka_consumer_create()
{
    rd_kafka_topic_conf_t *consTopicCfg;
    rd_kafka_conf_t *conf = NULL;
    rd_kafka_t *rk = NULL;
    char errstr[512];
    rd_kafka_resp_err_t errCode;

    conf = rd_kafka_conf_new();

    if (!conf) {
        return ~SUCCESS;
    }

    rd_kafka_conf_set_log_cb(conf, logger);

    if (rd_kafka_conf_set(conf, "debug", 
                          "generic,broker,topic,security,msg,fetch",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
    }

    if (rd_kafka_conf_set(conf, "bootstrap.servers", broker_list[0],
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "security.protocol", "SSL",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "ssl.certificate.location", kafka_clnt_cert,
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "ssl.key.location", kafka_clnt_key,
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "ssl.ca.location", kafka_apic_cert,
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "auto.commit.enable", "true",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "auto.commit.interval.ms", "500",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "group.id", "consumerGroup",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    consTopicCfg = rd_kafka_topic_conf_new();

    if (RD_KAFKA_CONF_OK != rd_kafka_topic_conf_set(consTopicCfg, 
                                                    "auto.offset.reset",
                                                    "latest" ,errstr,
                                                    sizeof(errstr))) {
        return ~SUCCESS;
    }

    rd_kafka_conf_set_default_topic_conf(conf, consT opicCfg);
    rk = rd_kafka_new(RD_KAFKA_CONSUMER, conf, errstr, sizeof(errstr));
    if (!rk) {
        return ~SUCCESS;
    }

//    conf = NULL; // Disown conf as rd_kafka_new() has ownership now.

    const char *ep_topic="eprecords";
    rd_kafka_topic_partition_list_t *tp_list = 
                            rd_kafka_topic_partition_list_new(1);
    rd_kafka_topic_partition_t* tpObj = 
                            rd_kafka_topic_partition_list_add(tp_list,
                                                              ep_topic, 
                                                      RD_KAFKA_PARTITION_UA);

    if (NULL == tpObj) {
        return ~SUCCESS;
    }

    errCode = rd_kafka_subscribe(rk, tp_list);
    if (errCode  != RD_KAFKA_RESP_ERR_NO_ERROR) {
        return ~SUCCESS;
    }

    rd_kafka_topic_partition_list_destroy(tp_list);

    while(1) {
        rd_kafka_message_t *msg = rd_kafka_consumer_poll(rk, 1000);
        if (msg != NULL) {
            if (msg->err == RD_KAFKA_RESP_ERR_NO_ERROR) {
                msg_consume(msg, NULL);
            }
            rd_kafka_message_destroy(msg);
        }
        rd_kafka_poll(rk,0);
    }
}

我期望在生产者定期发布数据时调用 msg_consume() 。我不确定以下日志消息是否是问题的根源。

“[2019 年 11 月 8 日 19:18:09.791668295:180:E:logger:1741] TID 08:[LOG_TRACE]:RDKAFKA-7-LEADER:rdkafka#consumer-2:[thrd:ssl://10.0。 0.1:9092/bootstrap]: ssl://10.0.0.1:9092/1: 将 0 个分区映射到代理”

最佳答案

在我转向不同的消费者模式后，程序开始运行。代码如下。

static void logger (const rd_kafka_t *rk, int level,
                    const char *fac, const char *buf)
{
    PRINT_ERR("RDKAFKA-%i-%s: %s: %s", level, fac, rk ? rd_kafka_name(rk) : NULL, buf);
}

rd_kafka_t *
kafka_consumer_create()
{
    rd_kafka_conf_t *conf = NULL;
    rd_kafka_t *rk = NULL;
    char errstr[512];
    rd_kafka_resp_err_t errCode;

    conf = rd_kafka_conf_new();

    if (!conf) {
        return ~SUCCESS;
    }

    rd_kafka_conf_set_log_cb(conf, logger);

    if (rd_kafka_conf_set(conf, "enable.partition.eof", "true",
                          errstr, sizeof(errstr) != RD_KAFKA_CONF_OK)) {
        PRINT_ERR("enable partition eof failed %s", errstr);
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "client.id", "kafka-python-Python 2.7.16",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        PRINT_ERR("DR_MSG : failed to set client id %s", errstr);
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "debug", "generic,broker,topic,security,msg,fetch",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "enable.auto.commit","true",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "bootstrap.servers", "192.168.1.1",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "security.protocol", "SSL",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "ssl.certificate.location", "/root/kafka/KafkaClient.crt",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "ssl.key.location", "/root/kafka/KafkaClient8.key",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "ssl.ca.location", "/root/kafka/ApicCa.crt",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "group.id", "test-consumer-group",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    if (rd_kafka_conf_set(conf, "auto.offset.reset", "latest",
                          errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
        return ~SUCCESS;
    }

    rk = rd_kafka_new(RD_KAFKA_CONSUMER, conf, errstr, sizeof(errstr));
    if (!rk) {
        return ~SUCCESS;
    }

    conf = NULL; // Disown conf as rd_kafka_new() has ownership now.

    return rk;
}

static void
msg_consume(rd_kafka_message_t *rkmessage, void *opaque)
{
    if (rkmessage == NULL) {
        PRINT_ERR("Aentp rkmessage error");
        return;
    }

    if (rkmessage->err) {
        if (rkmessage->err == RD_KAFKA_RESP_ERR__PARTITION_EOF) {
            PRINT_ERR("AT2");
            DEBUG_PRINT(DBG_AENTP_TRACE,
                        "%% Consumer reached end of %s [%"PRId32"] "
                        "message queue at offset %"PRId64"\n",
                        (rkmessage->rkt) ? rd_kafka_topic_name(rkmessage->rkt) : "NULL",
                        rkmessage->partition, rkmessage->offset);
            return;
        }

        if (rkmessage->err == RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION ||
            rkmessage->err == RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC) {
            PRINT_ERR("Unknown partition or unknow topic");
            return;
        }

        return;
    }

    if (rkmessage->key_len) {
        DEBUG_PRINT("Key: %.*s\n", (int)rkmessage->key_len, (char *)rkmessage->key);
    }

    DEBUG_PRINT("%.*s\n", (int)rkmessage->len, (char *)rkmessage->payload);
}

void *
kafka_consumer_thread(void *ptr)
{
    rd_kafka_t *rk = kafka_consumer_create();
    rd_kafka_topic_t *rkt = NULL;
    rd_kafka_topic_conf_t *topic_conf;
    rd_kafka_resp_err_t err;
    char errstr[512];

    if (rk == NULL) {        
        return NULL;
    }

    DEBUG_PRINT("Starting Kafka consumer thread");
    topic_conf = rd_kafka_topic_conf_new();
    if (RD_KAFKA_CONF_OK != rd_kafka_topic_conf_set(topic_conf, "auto.offset.reset",
                            "earliest" ,errstr, sizeof(errstr))) {
        AENTP_PRINT_ERR("rd_kafka_topic_conf_set() failed with error: %s\n", errstr);
        return NULL;
    }

    rkt = rd_kafka_topic_new(rk, "records", topic_conf);
    topic_conf = NULL; /* Now owned by topic */

    /* Start consuming */
    if (rd_kafka_consume_start(rkt, 0, RD_KAFKA_OFFSET_END) == -1){
        rd_kafka_resp_err_t err = rd_kafka_last_error();
        PRINT_ERR("%% Failed to start consuming: %s\n", rd_kafka_err2str(err));
        if (err == RD_KAFKA_RESP_ERR__INVALID_ARG) {
            APRINT_ERR("%% Broker based offset storage "
                       "requires a group.id, "
                       "add: -X group.id=yourGroup\n");
        }
        return NULL;
    }

    while(1) {
        rd_kafka_message_t *rkmessage;

        /* Poll for errors, etc. */
        rd_kafka_poll(rk, 0);

        /*
         * Consume single message.
         * See rdkafka_performance.c for high speed
         * consuming of messages.
         */
        rkmessage = rd_kafka_consume(rkt, 0, 1000);
        if (!rkmessage) /* timeout */
            continue;

        msg_consume(rkmessage, NULL);

        /* Return message to rdkafka */
        rd_kafka_message_destroy(rkmessage);

        /* XXX Do we need the seek??? */
        seek_offset = 0;
        if (seek_offset) {
            err = rd_kafka_seek(rkt, 0, seek_offset, 2000);
            if (err)
                AENTP_PRINT_ERR("Seek failed: %s\n", rd_kafka_err2str(err));
            else
                printf("Seeked to %"PRId64"\n", seek_offset);
            seek_offset = 0;
        }
        /* XXX Do we need the seek??? */
    }

    return NULL;
}

请注意为什么之前的方法不起作用。

关于c - librdkafka 消费者未收到来自代理的消息，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/58797316/

文章推荐： c++ - 使用dll源代码C++调试dll文件

文章推荐： c# - 在 jQuery 模态窗口中显示来自代码隐藏的数据

javascript - (未)旋转矩形上的点
我找到了 this excellent question and answer它以 x/y(加上 center x/y 和 degrees/radians)开始并计算旋转- 到 x'/y'。这个计算很
.net - 为什么非法跨线程*未*被检测到？
全部: 我已经创建了一个 Windows 窗体和一个按钮。在另一个线程中，我试图更改按钮的文本，但它崩溃了；但是如果我尝试更改按钮的颜色，它肯定会成功。我认为如果您更改任何 Windows 窗体控件属
c - (未)签名短整型 (C)
本网站的另一个问题已证实，C 中没有缩写的字面后缀，并且可以执行以下操作: short Number = (short)1; 但是转换它和不这样做有什么区别: short Number = 1; 您使
SQL:从表中获取最新的(未)订阅操作
我有下表: ID (int) EMAIL (varchar(50)) CAMPAIGNID (int) isSubscribe (bit) isActionByUser (bit) 此表存储了用户对事
javascript - 如何复制手动(未)选中复选框的状态？
也就是说，无需触发Javascript事件即可改变的属性，如何保留我手动选中或取消选中的复选框的状态，然后复制到另一个地方？运行下面的代码片段并选中或取消选中其中的一些，然后点击“复制”: $('#
c++ - 可以在不取消引用的情况下增加指针仍然是段错误或具有其他(未)定义的肮脏吗？
我在网上找到的所有关于递增指针导致段错误的示例都涉及指针的取消引用 - 如果我只想递增它(例如在 for 循环的末尾)并且我不在乎它是否最终进入无效内存，因为我不会再使用它。例如，在这个程序中，每次迭
java - 如何获取用于记录的(未)编码消息
我有一个 Spring MVC REST 服务，它使用 XStream 将消息与 XML 相互转换。有什么方法可以将请求和响应中的 xml(即正文)打印到普通的 log4j 记录器？在 Contr
git - 当我需要其他分支的一些代码时如何为功能创建分支(未 merge 到开发分支中)
做我的任务有一个很大的挑战，那就是做相互依赖的任务我在这张照片中说的。假设我们有两个任务 A 和 B，执行子任务 A1、A2 和 B1、B2，假设任务 B 依赖于 A。要理想地执行任务 B，您应该执
delphi - 如何从库的角度处理 COM(未)初始化？
通过阅读该网站上的几个答案，我了解到 CoInitialize(Ex) should be called by the creator of a thread 。然后，在该线程中运行的任何代码都可以使
java - FirebaseListAdapter 未 populateView 未被调用
这个问题已经困扰我一段时间了。我以前从未真正使用过 ListViews，也没有使用过 FirebaseListAdapters。我想做的就是通过显示 id 和用户位置来启动列表的基础，但由于某种原因，
java - 检查(未)检查异常 (Java)
我很难解释这两个(看似简单)句子的含义: “受检异常由编译器在编译时检查” 这是什么意思？编译器检查是否捕获了所有已检查的异常(在代码中抛出)？ “未经检查的异常在运行时检查，而不是编译时” 这句话中
python - 如果在值中*未*找到特定的迭代子字符串，如何返回值？
我有一个包含排除子字符串的文本文件，我想迭代该文件以检查并返回不带排除子字符串的输入项。这里我使用 python 2.4，因此下面的代码可以实现此目的，因为 with open 和 any 不起作用
java - 对于(未)验证的请求绕过 @Cacheable
Spring 的缓存框架能否了解请求上下文的身份验证状态，或者更容易推出自己的缓存解决方案？最佳答案尽管我发现这个用例 super 奇怪，但您可以为几乎任何与 SpEL 配合使用的内容设置缓存条件
c++ - 指针/整数算术(未)定义的行为
我有以下函数模板: template HeldAs* duplicate(MostDerived *original, HeldAs *held) { // error checking omi
android - 如果您的应用程序具有设备管理员/设备所有者权限(未 Root )，如何杀死另一个应用程序
如果我的应用程序具有设备管理员/设备所有者权限(未获得 root 权限)，我如何才能从我的应用程序中终止(或阻止启动)另一个应用程序？最佳答案设备所有者可以阻止应用程序: DevicePolicy
tridion - 组件中的 XSLT 被(未)编码
非常简单的问题，但我似乎无法让它正常工作。我有一个组件，其中有一些 XSLT(用于导航)。它通过 XSLT TBB 使用 XSLT Mediator 发布。发布后
jquery - Droppable 创建(未)嵌套对象 - 但可拖动的位置发生变化
我正在将一个对象拖动到一个可拖放的对象内，该对象也是可拖动的。放置对象后，它会嵌套在可放置对象内。同样，如果我将对象拖到可放置的外部，它就不再嵌套。但是，如果我经常拖入和拖出可放置对象，则可拖动对象
jquery - 如何检测 Angular 中是否*未*单击指令元素
我正在尝试为按钮和弹出窗口等多个指令实现“取消选择”功能。也就是说，我希望当用户单击不属于指令模板一部分的元素时触发我的函数。目前，我正在使用以下 JQuery 代码: $('body').click
javascript - 加载 CSS 未 100% 工作
我从 this question 得到了下面的代码，该脚本用于在 Google tasks 上更改 iframe[src="about:blank"] 内的 CSS使用 Chrome 扩展 Tempe
java - 未 stub 调用的 native 类型的返回值
我有一些 @Mock 对象，但没有指定在该对象上调用方法的返回值。该方法返回 int (不是 Integer)。我很惊讶地发现 Mockito 没有抛出 NPE 并返回 0。这是预期的行为吗？例如:

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c - librdkafka 消费者未收到来自代理的消息