在spring data cassandra存储库上缓慢插入和保存所有性能

我正在尝试使用spring将1500条记录插入cassandra。我有一个保存这1500条记录的POJO列表，当我调用saveAll或insert对这些数据执行操作时，需要30秒才能完成此操作。有人能给我一个更快完成这件事的建议吗？我目前正在以单节点测试集群的形式运行Cassandra 3.11.2

实体POJO：

package com.samplepoc.pojo;

import static org.springframework.data.cassandra.core.cql.PrimaryKeyType.PARTITIONED;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import org.springframework.data.cassandra.core.mapping.Column;
import org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn;
import org.springframework.data.cassandra.core.mapping.Table;

@Table("health")
public class POJOHealth
{
    @PrimaryKeyColumn(type=PARTITIONED)
    UUID primkey;
    @Column
    String col1;
    @Column
    String col2;
    @Column
    String col3;
    @Column
    String col4;
    @Column
    String col5;
    @Column
    Date ts;
    @Column
    boolean stale;
    @Column
    String col6;
    @Column
    String col7;
    @Column
    String col8;
    @Column
    String col9;
    @Column
    Map<String,String> data_map = new HashMap<String,String>();

    public POJOHealth(
             String col1,
             String col2,
             String col3,
             String col4,
             String col5,
             String col6,
             String col7,
             String col8,
             String col9,
             boolean stale,
             Date ts,
             Map<String,String> data_map
             )
    {
        this.primkey = UUID.randomUUID();
        this.col1=col1;
        this.col2=col2;
        this.col3=col3;
        this.col4=col4;
        this.col5=col5;
        this.col6=col6;
        this.col7=col7;
        this.col8=col8;
        this.col9=col9;
        this.ts=ts;
        this.data_map = data_map;
        this.stale=stale;
    }

    //getters & setter ommitted
}

package com.samplepoc.pojo；
导入静态org.springframework.data.cassandra.core.cql.PrimaryKeyType.PARTITIONED；
导入java.util.Date；
导入java.util.HashMap；
导入java.util.Map；
导入java.util.UUID；
导入org.springframework.data.cassandra.core.mapping.Column；
导入org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn；
导入org.springframework.data.cassandra.core.mapping.Table；
@表（“健康”）
公营医疗
{
@PrimaryKeyColumn（类型=已分区）
UUID-primkey；
@纵队
字符串col1；
@纵队
字符串col2；
@纵队
字符串col3；
@纵队
字符串col4；
@纵队
字符串col5；
@纵队
日期ts；
@纵队
布尔陈旧；
@纵队
字符串col6；
@纵队
字符串col7；
@纵队
字符串col8；
@纵队
字符串col9；
@纵队
Map data_Map=new HashMap（）；
公共卫生(
字符串col1，
字符串col2，
字符串col3，
字符串col4，
字符串col5，
字符串col6，
字符串col7，
字符串col8，
字符串col9，
布尔陈旧，
日期ts，
地图数据
)
{
this.primkey=UUID.randomUUID（）；
这个.col1=col1；
这个.col2=col2；
这个.col3=col3；
这个.col4=col4；
这个.col5=col5；
这个.col6=col6；
这个.col7=col7；
这个.col8=col8；
this.col9=col9；
这个。ts=ts；
this.data\u map=data\u map；
this.stale=stale；
}
//已安装吸气剂和塞特
}

持久化服务代码段：

public void persist(List<POJO> l_POJO)
{
        System.out.println("Enter Persist: "+new java.util.Date());

        List<l_POJO> l_POJO_stale = repository_name.findBycol1AndStale("sample",false);
        System.out.println("Retrieve Old: "+new java.util.Date());

        l_POJO_stale.forEach(s -> s.setStale(true));
        System.out.println("Set Stale: "+new java.util.Date());

        repository_name.saveAll(l_POJO_stale);
        System.out.println("Save stale: "+new java.util.Date());

        try 
        {
            repository_name.insert(l_POJO);
        } 
        catch (Exception e) 
        {
            System.out.println("Error in persisting new data");
        }
        System.out.println("Insert complete: "+new java.util.Date());
}

public void persist（列表l_POJO）
{
System.out.println（“输入Persist:+newjava.util.Date（））；
List l_POJO_stale=repository_name.findbycol1和stale（“sample”，false）；
System.out.println（“检索旧的：+newjava.util.Date（））；
l_POJO_stale.forEach（s->s.setStale（true））；
System.out.println（“setstale:+newjava.util.Date（））；
存储库名称.saveAll（l_POJO_stale）；
System.out.println（“Save stale:+new java.util.Date（））；
尝试
{
存储库名称。插入（l_POJO）；
} 
捕获（例外e）
{
System.out.println（“保存新数据时出错”）；
}
System.out.println（“插入完成：+new java.util.Date（））；
}

我不知道spring，但它使用的java驱动程序可以异步插入。通过这种方式进行保存，实例的延迟决定了吞吐量，而不是查询的效率。ie假设你对C*协调器有10毫秒的延迟，一次保存一个需要30秒（10毫秒在那里，10毫秒返回*1500）

---

如果您同时使用executeAsync插入所有这些代码，并阻塞所有代码，那么您应该能够在不到一秒钟的时间内完成1500个代码，除非您的硬件电源严重不足（几乎任何比raspberry pi更能处理突发事件的代码）。这就是说，如果你的应用程序有任何并发性，你不希望每个应用程序同时发送1000个插入，因此在飞行中设置某种节流阀（即限制为128个的信号量）将是一个非常好的主意。

感谢你的指导@Chris Lohfnik我正在阅读你回答后的spring数据异步操作。异步解决方案可用