小编Sha*_*P S的帖子

我使用npx create-react-app my-app命令创建了一个 React 项目。然后我使用npm start. 当我将项目提交到 Github 时，我会在项目页面中获得安全建议。

serialize-javascript vulnerability found in yarn.lock

**Remediation**

Upgrade serialize-javascript to version 2.1.1 or later. 

我的 package.json 文件中没有 serialize-javascript 依赖项。这是 Github 中的项目 - https://github.com/shankarps/ReactPracticeProject/

我该如何解决这个错误？

如何确保项目创建时包含最新的依赖项？

我正在学习 API 中的反应流，它与 JMS 之间的相似性让我感到震惊。在 JMS 中，我们也有异步处理、发布者和订阅者。在做出这种等价时我缺少什么视角？

我试图用SBT运行Scala示例来从MongoDB读取数据.每当我尝试将从Mongo读取的数据访问到RDD时,我都会收到此错误.

Exception in thread "dag-scheduler-event-loop" java.lang.NoClassDefFoundError: org/apache/spark/sql/DataFrame
at java.lang.Class.getDeclaredMethods0(Native Method)
at java.lang.Class.privateGetDeclaredMethods(Class.java:2701)
at java.lang.Class.getDeclaredMethod(Class.java:2128)
at java.io.ObjectStreamClass.getPrivateMethod(ObjectStreamClass.java:1431)
at java.io.ObjectStreamClass.access$1700(ObjectStreamClass.java:72)
at java.io.ObjectStreamClass$2.run(ObjectStreamClass.java:494)
at java.io.ObjectStreamClass$2.run(ObjectStreamClass.java:468)
at java.security.AccessController.doPrivileged(Native Method)
at java.io.ObjectStreamClass.<init>(ObjectStreamClass.java:468)
at java.io.ObjectStreamClass.lookup(ObjectStreamClass.java:365)
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1134)
at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)

我已经显式导入了Dataframe,即使它没有在我的代码中使用.有人可以帮忙解决这个问题吗？

我的代码:

package stream

import org.apache.spark._
import org.apache.spark.SparkContext._
import com.mongodb.spark._
import com.mongodb.spark.config._
import com.mongodb.spark.rdd.MongoRDD
import org.bson.Document
import org.apache.spark.sql.SQLContext
import org.apache.spark.sql.DataFrame

object SpaceWalk {

def main(args: Array[String]) {

    val sparkConf = new SparkConf().setAppName("SpaceWalk")
    .setMaster("local[*]")
    .set("spark.mongodb.input.uri", "mongodb://127.0.0.1/nasa.eva")
    .set("spark.mongodb.output.uri", "mongodb://127.0.0.1/nasa.astronautTotals")

    val sc = new SparkContext(sparkConf)
    val rdd = …

我编写了一个 JUnit 测试用例来测试 Spring Kafka 文档中“使用 Java 配置”课程中的代码。（https://docs.spring.io/spring-kafka/reference/htmlsingle/#_with_java_configuration）。唯一的区别是我在课堂上使用了嵌入式 Kafka 服务器，而不是本地主机服务器。我正在使用 Spring Boot 2.0.2 及其 Spring-Kafka 依赖项。

在运行这个测试用例时，我发现消费者没有从主题中读取消息，并且“assertTrue”检查失败。没有其他错误。

@RunWith(SpringRunner.class)
public class SpringConfigSendReceiveMessage {

    public static final String DEMO_TOPIC =  "demo_topic";
    @Autowired
    private Listener listener;

    @Test
    public void testSimple() throws Exception {
        template.send(DEMO_TOPIC, 0, "foo");
        template.flush();
        assertTrue(this.listener.latch.await(60, TimeUnit.SECONDS));
    }

    @Autowired
    private KafkaTemplate<Integer, String> template;

    @Configuration
    @EnableKafka
    public static class Config {

        @Bean
        public KafkaEmbedded kafkaEmbedded() {
            return new KafkaEmbedded(1, true, 1, DEMO_TOPIC);
        }

        @Bean
        public ConsumerFactory<Integer, String> createConsumerFactory() {
            Map<String, …

这个问题适用于Spring Kafka,与Apache Kafka和High Level Consumer相关:跳过损坏的消息

有没有办法配置Spring Kafka使用者跳过无法读取/处理(损坏)的记录？

我看到如果无法反序列化,消费者会陷入同一记录的情况.这是消费者抛出的错误.

Caused by: com.fasterxml.jackson.databind.JsonMappingException: Can not construct instance of java.time.LocalDate: no long/Long-argument constructor/factory method to deserialize from Number value 

消费者轮询主题并在循环中继续打印相同的错误,直到程序被杀死.

在具有以下使用者工厂配置的@KafkaListener中,

Map<String, Object> props = new HashMap<>();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);

我对卡夫卡有点陌生，正在阅读文档。Kafka 办公网站有一个关于 KStream 的示例。应用程序绑定到某个主题，消息一到达就会立即进行处理。结果将发布回主题或数据库。

Spring Kafka 注释 @KafkaListener 具有相同的功能。例如，我尝试了KafaListner 应用程序。同样在这里，我们收听一个主题并在发布内容时对其进行处理。

所以我很想知道 1. 这两个有什么不同？2. 在什么场景下选择哪一个？

我正在构建一个Kafka Consumer应用程序，该应用程序使用来自Kafka Topic的消息并执行数据库更新任务。每天都会大批量生产消息-因此，该主题在10分钟内加载了大约100万条消息。主题有8个分区。

Spring Kafka使用者（用@KafkaListener注释并使用ConcurrentKafkaListenerContainerFactory注释）在极短的时间内触发。

批处理大小有时仅为1或2条消息。如果它可以一次使用大约1000条消息并一起处理（例如，我可以在一个更新SQL中更新数据库），而不是为每条消息连接到数据库，则将有助于提高性能。

我已经尝试在工厂中减少并发，以避免多个线程消耗较少的消息。

我还将Kafka的server.properties中的socket.send.buffer.bytes属性从102400增加到1024000。

这些步骤没有增加批处理大小。

我还有其他配置可以用来增加消费者的浴室大小吗？