一、概述

1、简介

2、架构

3、使用场景

二、安装

三、基本概念

1、数据模型

列（Column）

列族

KeySpace

节点（Node）

集群（Cluster）

2、数据类型

基础类型

集合类型

自定义数据类型

四、操作

1.客户端操作

cqlsh的基本命令

CQL-查询语言

Keyspace

表操作

索引操作

CRUD操作

2.JAVA操作

一、概述

1、简介

Apache Cassandra是高度可扩展的，高性能的分布式NoSQL数据库。提供高可用性而无需担心单点故障。具有能够处理大量数据的分布式架构。数据放置在具有多个复制因子的不同机器上，以获得高可用性，而无需担心单点故障。

特性：

弹性可扩展性 - Cassandra是高度可扩展的; 它允许添加更多的硬件以适应更多的客户和更多的数据根据要求。
始终基于架构 - Cassandra没有单点故障，它可以连续用于不能承担故障的关键业务应用程序。
快速线性性能 - Cassandra是线性可扩展性的，即它为你增加集群中的节点数量增加你的吞吐量。因此，保持一个快速的响应时间。
灵活的数据存储 - Cassandra适应所有可能的数据格式，包括：结构化，半结构化和非结构化。它可以根据您的需要动态地适应变化的数据结构。
便捷的数据分发 - 可以在多个数据中心之间复制数据，可以灵活地在需要时分发数据。
事务支持 - Cassandra支持属性，如原子性，一致性，隔离和持久性（ACID）。
快速写入 - Cassandra被设计为在廉价的商品硬件上运行。它执行快速写入，并可以存储数百TB的数据，而不牺牲读取效率。

2、架构

Cassandra中的数据分布在集群中的所有节点上，处理多个节点之间的大数据工作负载，而无需担心单点故障。各个节点是相互独立的，但同时与其他节点互连，平等地址。每个阶段都可以进行读写操作，如果其中一个节点发生故障，其他节点也可以继续提供读写请求。

在Cassandra中，集群中的节点作为给定数据片段的副本。如果某些节点以超时值响应，Cassandra会将最新的值返回给客户端。返回最新值后，Cassandra会在后台执行读取修复，以更新旧值。

结构组成：

节点(Node)：Cassandra节点是存储数据的地方。
数据中心(Data center)：数据中心是相关节点的集合。
集群(Cluster)：集群是包含一个或多个数据中心的组件。
提交日志(Commit log)：每个写入操作都将写入提交日志，用户异常恢复数据。
存储表(Mem-table)：内存表是内存驻留的数据结构。提交日志后，数据将被写入内存表。有时，对于单列系列，将有多个内容表。
SSTable：当内容达到阈值时，它是从内存表刷新数据的磁盘文件。
布鲁姆过滤器(Bloom filter)：这些只是快速，非确定性的，用于测试元素是否是集合成员的算法。它是一种特殊的缓存。每次查询后都会访问Bloom过滤器。

3、使用场景

特征

数据写入操作密集
数据修改操作很少
通过主键查询
需要对数据进行分区存储

场景举例

存储日志型数据
类似物联网的海量数据
对数据进行跟踪官网

官网

二、安装

docker pull cassandra

docker run -d -p 9042:9042  --name cassandra cassandra:latest

进入cassandra的命令行

docker exec -it cassandra bash
cqlsh

cassandra数据存放位置共有三处地方：

data目录：

用于存储真正的数据文件，即SSTable文件。如果服务器有多个磁盘，可以指定多个目录，每一个目录都在不同的磁盘中。这样Cassandra就可以利用更多的硬盘空间。在data目录下，Cassandra 会将每一个 Keyspace 中的数据存储在不同的文件目录下，并且 Keyspace 文件目录的名称与 Keyspace 名称相同。

commitlog目录:

用于存储未写入SSTable中的数据，每次Cassandra系统中有数据写入，都会先将数据记录在该日志文件中，以保证Cassandra在任何情况下宕机都不会丢失数据。如果服务器有足够多的磁盘，可以将本目录设置在一个与data目录和cache目录不同的磁盘中，以提升读写性能。

cache目录:

用于存储系统中的缓存数据。

配置文件cassandra.yaml进行修改配置。

cassandra.yaml说明查看

三、基本概念

1、数据模型

Cassandra的数据模型与常见的关系型数据库的数据模型有很大的不同

列（Column）

列是Cassandra的基本数据结构单元，具有三个值：名称，值、时间戳

列（Column）不需要预先定义，只需要在KeySpace里定义列族，然后就可以开始写数据了。

列族

列族相当于关系数据库的表（Table），是包含了多行（Row）的容器。

可以理解为Java结构 Map>，如图：

1）Row key
ColumnFamily 中的每一行都用Row Key（行键）来标识，这个相当于关系数据库表中的主键，并且总是被索引的。

2）主键
Cassandra可以使用PRIMARY KEY 关键字创建主键，主键分为2种

1.单键（一个字段） 2.组合键（多个字段组成）

列族具有以下属性 -

keys_cached - 它表示每个SSTable保持缓存的位置数。
rows_cached - 它表示其整个内容将在内存中缓存的行数。
preload_row_cache -它指定是否要预先填充行缓存。

KeySpace

Cassandra的键空间（KeySpace）相当于数据库，我们创建一个键空间就是创建了一个数据库。键空间包含一个或多个列族（Column Family）

注意：一般将有关联的数据放到同一个 KeySpace 下面，建空间（KeySpace）创建的时候可以指定一些属性：副本因子，副本策略，Durable_writes（是否启用 CommitLog 机制）

副本因子：

副本就是把数据存储到多个节点，来提高容错性。副本因子决定数据有几份副本。例如：副本因子为1表示每一行只有一个副,。副本因子为2表示每一行有两个副本，每个副本位于不同的节点上。在实际应用中为了避免单点故障，会配置为3以上。

注意：副本没有主从之分。可以为每个数据中心定义副本因子。副本策略设置应大于1，但是不能超过集群中的节点数。

副本策略：

描述的是副本放在集群中的策略，目前有2种策略，内容如下：

Durable_writes：

是否启用 CommitLog 机制，默认为true

节点（Node）

存储数据的机器

集群（Cluster）

Cassandra数据库是为跨越多条主机共同工作，对用户呈现为一个整体的分布式系统设计的。Cassandra最外层容器被称为群集。Cassandra将集群中的节点组织成一个环（ring），然后把数据分配到集群中的节点（Node）上。

2、数据类型

基础类型

集合类型

Map:

1、集合的每一项最大是64K。 2、保持集合内的数据不要太大，免得Cassandra 查询延时过长，Cassandra 查询时会读出整个集合内的数据，集合在内部不会进行分页，集合的目的是存储小量数据。 3、不要向集合插入大于64K的数据，否则只有查询到前64K数据，其它部分会丢失。

自定义数据类型

Cqlsh为用户提供了创建自己的数据类型的功能。下面给出了处理用户定义的数据类型时使用的命令。

CREATE TYPE - 创建用户定义的数据类型。
ALTER TYPE - 修改用户定义的数据类型。
DROP TYPE - 删除用户定义的数据类型。
DESCRIBE TYPE - 描述用户定义的数据类型。
DESCRIBE TYPES - 描述用户定义的数据类型。

四、操作

操作类型：

1.客户端操作

docker exec -it my_cassandra  /bin/bash
cd bin
cqlsh

cqlsh的基本命令

选项	使用/作用
help	此命令用于显示有关CQLsh命令选项的帮助主题。
version	它用于查看您正在使用的CQLsh的版本。
color	它用于彩色输出。
debug	它显示其他调试信息。
execute	它用于引导shell接受并执行CQL命令。
show	显示当前会话详情

help 可以查看cqlsh 支持的命令

Describe cluster 提供有关集群的信息

Describe Keyspaces:显示当前Cassandra里的所有键空间

Describe tables 列出键空间的所有表

CQL-查询语言

数据定义命令

Keyspace

1、创建

语法：
    CREATE KEYSPACE <identifier> WITH <properties>
具体语法：
    Create keyspace KeyspaceName with replicaton={'class':strategy name,   
'replication_factor': No of replications on different nodes}

KeyspaceName 代表键空间的名字
strategy name 代表副本放置策略，内容包括：简单策略、网络拓扑策略，选择其中的一个。
No of replications on different nodes 代表复制因子，放置在不同节点上的数据的副本数。

新建：

CREATE KEYSPACE company WITH replication = {'class':'SimpleStrategy', 'replication_factor' : 3};

CREATE KEYSPACE test_keyspace WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3 } AND DURABLE_WRITES = false;

验证：

DESCRIBE keyspaces ;

DESCRIBE company ;

2、使用键空间

USE <identifier>

USE company；

3、修改键空间

语法：
    ALTER KEYSPACE <identifier> WITH <properties>
或者 -
    ALTER KEYSPACE "KeySpace Name" WITH replication = {'class': 'Strategy name', 
'replication_factor' : 'No.Of  replicas'};
又或者 -
    Alter Keyspace KeyspaceName with replication={'class':'StrategyName',   
    'replication_factor': no of replications on different nodes}   
        with DURABLE_WRITES=true/false

注意：

Keyspace Name： Cassandra中的键名称不能更改。
Strategy Name：可以通过使用新的策略名称来更改战略名称。
Replication Factor ：可以通过使用新的复制因子来更改复制因子。
DURABLE_WRITES：可以通过指定其值true / false来更改。默认情况下为true。如果设置为false，则不会将更新写入提交日志，反之亦然。

修改：

alter KEYSPACE company WITH replication = {'class':'SimpleStrategy', 'replication_factor' : 1};

验证：

DESCRIBE company ;

4、删除键空间

DROP KEYSPACE <identifier>

DROP KEYSPACE company;

表操作

注意：操作前，先把键空间company键空间创建，并使用company键空间.

CREATE KEYSPACE company WITH replication = {'class':'SimpleStrategy', 'replication_factor' : 1};
use company;

1、查看所有的表

DESCRIBE TABLES;

2、创建表

CREATE (TABLE | COLUMNFAMILY) <tablename>  
('<column-definition>' , '<column-definition>')  
(WITH <option> AND <option>)

CREATE TABLE t_user(
   id int PRIMARY KEY,  
   name text,  
   age int,  
   gender tinyint,  
   address text ,
   interest set<text>,
   phone list<text>,
   education map<text, text>
);

验证

DESCRIBE TABLE t_user;

主键有两种类型：

单个主键：对单个主键使用以下语法。
```
Primary key (ColumnName)
```

复合主键：对复合主键可使用以下语法。

Primary key(ColumnName1,ColumnName2 . . .)
或-
Primary key((key_part_one,key_part_two),ColumnName2 . . .)
key_part_one:称作Partition Key,Cassandra会对其做一个hash计算，决定放在哪个节点。
key_part_two:CLUSTERING KEY

3、修改表结构

语法，可以添加列，删除列

添加一列：
    ALTER (TABLE | COLUMNFAMILY) <tablename> <instruction>
删除一列：
    ALTER table name  DROP name;

ALTER TABLE t_user ADD email text;
ALTER table t_user DROP email;

4、删除表

DROP TABLE <tablename>

5、清空表

TRUNCATE <tablename>

索引操作

1、普通列创建索引

CREATE INDEX <identifier> ON <tablename>

创建索引的规则

由于主键已编入索引，因此无法在主键上创建索引。
在Cassandra中，不支持集合索引。
没有对列进行索引，Cassandra无法过滤该列，除非它是主键。

CREATE INDEX sname ON t_user(name);

索引原理：

Cassandra自动新创建了一张表格，同时将原始表格之中的索引字段作为新索引表的Primary Key！并且存储的值为原始数据的Primary Key.

2、集合列创建索引

CREATE INDEX ON t_user(interest); -- set集合添加索引
CREATE INDEX mymap ON t_user(KEYS(education)); -- map结合添加索引

3、删除索引

DROP INDEX <identifier>

CRUD操作

数据操作指令

查询指令

1、插入数据

INSERT INTO <tablename>  
(<column1 name>, <column2 name>....)  
VALUES (<value1>, <value2>....)  
USING <option>

INSERT INTO t_user(id, address, age, education, gender, interest, name, phone)
VALUES (1,'dizhi',12,{'code':'12'},1,{'yestouu@gmail.com'},'zs',['123456','1234']);
INSERT INTO t_user(id, address, age, education, gender, interest, name, phone)
VALUES (2,'dizhi',12,{'code':'12'},1,{'yestouu@gmail.com'},'zs',['123456','1234']);
INSERT INTO t_user(id, address, age, education, gender, interest, name, phone)
VALUES (3,'dizhi',12,{'code':'12'},1,{'yestouu@gmail.com'},'zs',['123456','1234']);

2、更新数据

UPDATE <tablename>  
SET <column name> = <new value>  
<column name> = <value>....  
WHERE <condition>
又或者 -
Update KeyspaceName.TableName   
Set ColumnName1=new Column1Value,  
      ColumnName2=new Column2Value,  
      ColumnName3=new Column3Value,  
       .  
       .  
       .  
Where ColumnName=ColumnValue

update t_user set age=2,phone=['1'] where id =1;

#更新set类型数据

update t_user set interest= interest + {'aa'} where id = 1;

update t_user set interest = interest - {'aa'} where id = 1;

update t_user set interest = {} WHERE id = 1;

#更新list类型数据

update t_user set phone = [ '030-55555555' ] + phone where id= 1;

update t_user set phone = phone + [ '040-33333333' ] where id= 1;

update t_user set phone[2] = '050-22222222' where id= 1;

update t_user set phone = phone - ['020-66666666'] where id= 1;

update t_user set phone =[] where id= 1;
#更新map类型数据

update t_user set education={'e': 'f'} where id= 1;

#UPDATE命令设置指定元素的value

update t_user set education['e']='g' where id= 1;

update t_user set education = education + {'a':'b','c':'d'} where id= 1;

update t_user set education=education - {'a','c'} WHERE id = 1;
UPDATE t_user SET education={} WHERE id = 1;

3、删除数据

DELETE FROM <identifier> WHERE <condition>;

delete from t_user where id=1;

#删除某个字段

delete interest FROM t_user WHERE id= 1;

4、查询数据

使用 SELECT 、WHERE、LIKE、GROUP BY 、ORDER BY等关键词

SELECT FROM <tablename>
SELECT FROM <table name> WHERE <condition>;

查询所有数据

select * from t_user;

根据主键查询

select * from t_user where id =1;

查询时使用索引

注意事项：

Primary Key 只能用 = 号查询
第二主键支持= > < >= <=
索引列只支持 = 号
非索引非主键字段过滤可以使用ALLOW FILTERING

create table student (
key_one int,
key_two int,
name text,
age  int,
PRIMARY KEY(key_one, key_two)
);
create INDEX tage ON student (age);

key_one 是第一主键，key_two是第二主键，age是索引列，name是普通列

insert into  student(key_one,key_two,name,age) values(1,2,'a',2);
insert into  student(key_one,key_two,name,age) values(2,3,'b',2);
insert into  student(key_one,key_two,name,age) values(3,4,'c',2);
insert into  student(key_one,key_two,name,age) values(4,5,'d',2);

第一主键只能用=号查询

select * from student where key_one=1;

select * from student where key_one>1;

如果需要完成这个查询，可以使用 ALLOW FILTERING

select * from student where key_one>1 ALLOW FILTERING;

注意：加上ALLOW FILTERING 后确实可以查询出数据，但是不建议这么做

第二主键支持 = 、>、 <、 >= 、 <=

key_two是第二主键,不要单独对key_two 进行查询，

select * from student where key_two = 2;

如果需要完成这个查询，可以使用 ALLOW FILTERING

select * from student where key_two = 2 ALLOW FILTERING;

注意：加上ALLOW FILTERING 后确实可以查询出数据，但是不建议这么做

正确用法：

select * from student where key_one=1 and key_two = 2 ;

索引列只支持=号

select * from student where age = 2;

普通列，非索引非主键字段

普通列，在查询时需要使用ALLOW FILTERING

select * from student where key_one =1 and name='a';

select * from student where key_one =1 and name='a' ALLOW FILTERING;

集合列

ALTER TABLE student ADD email set<text>;

ALTER TABLE student ADD phone list<text>;

ALTER TABLE student ADD education map<text, text>;

create INDEX temail ON student (email);
create INDEX tphone ON student (phone);
create INDEX teducation ON student (education);

insert into student(key_one,key_two,name,age,email,phone,education) values(6,7,'d',2,{'1234'},['1'],{'info':'张三'});
insert into student(key_one,key_two,name,age,email,phone,education) values(7,8,'d',2,{'1234'},['1'],{'info':'张四'});

使用where子句的CONTAINS条件按照给定的值进行过滤。

select * from student where email CONTAINS '1234'; -- 查询set集合

select * from student where education CONTAINS key 'info' allow filtering; --查询map集合的key值
select * from student where education CONTAINS '张四'; --查询map的value值

ALLOW FILTERING

ALLOW FILTERING是一种非常消耗计算机资源的查询方式。如果表包含例如100万行，并且其中95％具有满足查询条件的值，则查询仍然相对有效，这时应该使用ALLOW FILTERING。

如果表包含100万行，并且只有2行包含满足查询条件值，则查询效率极低。Cassandra将无需加载999,998行。如果经常使用查询，则最好在列上添加索引。

ALLOW FILTERING在表数据量小的时候没有什么问题，但是数据量过大就会使查询变得缓慢。

查询时排序

cassandra也是支持排序的，order by。排序也是有条件的

1.必须有第一主键的=号查询

cassandra的第一主键是决定记录分布在哪台机器上，cassandra只支持单台机器上的记录排序。

2.只能根据第二、三、四…主键进行有序的，相同的排序。

3.不能有索引查询

cassandra的任何查询，最后的结果都是有序的，内部就是这样存储的。

select * from student where key_one = 1 order by key_two;

select * from student where key_one = 1 and age =2 order by key_two; --错误，不能有索引查询

分页查询

使用limit 关键字来限制查询结果的条数进行分页

select * from student where key_one = 1 order by key_two limit 1;

批量操作

多次更新操作合并为一次请求，减少客户端和服务端的网络交互。 batch中同一个partition key的操作具有隔离性.

使用BATCH，可以同时执行多个修改语句（插入，更新，删除）

BEGIN BATCH
<insert-stmt>/ <update-stmt>/ <delete-stmt>
APPLY BATCH

BEGIN BATCH
    INSERT INTO t_user(id, address, age, education, gender, interest, name, phone) VALUES (5,'dizhi',12,{'code':'12'},1,{'yestouu@gmail.com'},'zs',['123456','1234']);
    UPDATE t_user set age = 11 where id= 1;
    DELETE FROM t_user WHERE id=2;
APPLY BATCH;

2.JAVA操作

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-cassandra</artifactId>
</dependency>

# 应用名称
spring:
  application:
    name: spring-lean-cassandra
  data:
    cassandra:
      contact-points: 192.168.56.1
      port: 9042
      local-datacenter: datacenter1
      session-name: cassandraCluster
      username:
      password:
      keyspace-name: company
# 应用服务 WEB 访问端口
server:
  port: 9088

手动创建 keyspace和表。

CREATE TABLE person
(
    id      int,
    name    text,
    name_cn text,
    age     int,
    PRIMARY KEY (id)
);
CREATE TABLE city
(
    id      int,
    name    text,
    persons list<text>,
    PRIMARY KEY (id)
);

CREATE TABLE t_user
(
    id    int,
    name  text,
    age   int,
    books list<text>,
    PRIMARY KEY (id)
);
CREATE TABLE testdb (
    key_one text,
    key_two text,
    value double,
    PRIMARY KEY (key_one,key_two ) 
);

import lombok.Data;
import org.springframework.data.cassandra.core.mapping.*;

import java.util.List;

@Data
@Table
public class City {
    @PrimaryKey
    private int id;
    private String name;
    private List<String> persons;
}

import lombok.Data;
import org.springframework.data.cassandra.core.mapping.Column;
import org.springframework.data.cassandra.core.mapping.PrimaryKey;
import org.springframework.data.cassandra.core.mapping.Table;

@Data
@Table
public class Person {

    @PrimaryKey
    private Integer id;
    private String name;
    @Column(value = "name_cn")
    private String nameCn;
    private Integer age;

}

import lombok.Data;
import org.springframework.data.cassandra.core.mapping.PrimaryKey;
import org.springframework.data.cassandra.core.mapping.Table;

import java.io.Serializable;
import java.util.List;


@Data
@Table("t_user")
public class User implements Serializable {

    @PrimaryKey
    private int id;
    private String name;
    private int age;
    private List<String> books;
}

import lombok.Data;
import org.springframework.data.cassandra.core.cql.PrimaryKeyType;
import org.springframework.data.cassandra.core.mapping.Column;
import org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn;
import org.springframework.data.cassandra.core.mapping.Table;

@Data
@Table("testdb")
public class TestDb {
    @PrimaryKeyColumn(value = "key_one",type = PrimaryKeyType.PARTITIONED)
    private String keyOne;
    @PrimaryKeyColumn(value = "key_two",type = PrimaryKeyType.CLUSTERED)
    private String keyTwo;
    @Column("value")
    private double value;
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.cassandra.repository.config.EnableCassandraRepositories;

@EnableCassandraRepositories
@SpringBootApplication
public class SpringLeanCassandraApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringLeanCassandraApplication.class, args);
    }
}

第一种方式：集成CassandraRepository对象。

import com.lean.cassandra.entity.City;
import org.springframework.data.cassandra.repository.CassandraRepository;
public interface CityRepository extends CassandraRepository<City, Integer> {

}


import com.lean.cassandra.entity.Person;
import org.springframework.data.cassandra.repository.AllowFiltering;
import org.springframework.data.cassandra.repository.CassandraRepository;


public interface PersonRepository extends CassandraRepository<Person, Integer> {

    /**
     * 根据名字查询
     *
     * @param name 名字
     * @return Person
     */
    @AllowFiltering
    Person findByName(String name);
}

第二种方式：使用CassandraTemplate进行操作。

import com.lean.cassandra.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.cassandra.core.CassandraTemplate;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;

@Service
public class UserService {

    @Autowired
    private CassandraTemplate cassandraTemplate;

    public void saveUser(User user){
        cassandraTemplate.insert(user);
    }

    public void batchSaveUser(List<User> userList){
        cassandraTemplate.batchOps().insert(userList);
    }

    public void updateUser(User user){
        cassandraTemplate.update(user);
    }

    public User getById(Serializable id) {
        return cassandraTemplate.selectOneById(id, User.class);
    }

    public User getObj(Query query) {
        return cassandraTemplate.selectOne(query, User.class);
    }

    public List<User> listObjs(Query query) {
        return cassandraTemplate.select(query, User.class);
    }
}

package com.lean.cassandra.service;

import com.lean.cassandra.entity.TestDb;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.cassandra.core.CassandraTemplate;
import org.springframework.data.cassandra.core.query.Criteria;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class TestDbService {


    @Autowired
    private CassandraTemplate cassandraTemplate;


    public TestDb save(TestDb testDb) {
        return cassandraTemplate.insert(testDb);
    }

    public List<TestDb> query(TestDb testDb) {
        return cassandraTemplate.select("select * from testdb where key_one = '"+testDb.getKeyOne()+"';", TestDb.class);
    }

    public boolean delete(TestDb testDb) {
        return cassandraTemplate.delete(Query.query(Criteria.where("key_one").is(testDb.getKeyOne())).and(Criteria.where("key_two").lte(testDb.getKeyTwo())), TestDb.class);
    }
}

测试：

第一种：

import com.lean.cassandra.entity.City;
import com.lean.cassandra.entity.Person;
import com.lean.cassandra.repository.CityRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.LinkedList;
import java.util.List;
@SpringBootTest
public class CityRepositoryTest {
    @Autowired
    private CityRepository cityRepository;

    @Test
    public void save() {
        List<String> list = new LinkedList<>();
        for (int i = 0; i < 20; i++) {
            Person person = new Person();
            person.setId(i + 1);
            person.setAge(18 + i);
            person.setName("test" + (i + 1));
            person.setNameCn("测试" + (i + 1));
            list.add(person.toString());
        }
        City city = new City();
        city.setId(1);
        city.setName("深圳");
        city.setPersons(list);
        cityRepository.save(city);
    }
}

package com.lean.cassandra;

import com.lean.cassandra.entity.Person;
import com.lean.cassandra.repository.PersonRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.cassandra.core.query.CassandraPageRequest;
import org.springframework.data.domain.Pageable;

import java.util.LinkedList;
import java.util.List;


@SpringBootTest
public class PersonRepositoryTest {

    @Autowired
    private PersonRepository repository;

    @Test
    public void save() {
        Person person = new Person();
        person.setId(1);
        person.setName("xxb");
        person.setAge(18);
        repository.save(person);
    }

    @Test
    public void saveAll() {
        List<Person> list = new LinkedList<>();
        for (int i = 1; i < 20; i++) {
            Person person = new Person();
            person.setId(i + 1);
            person.setAge(18 + i);
            person.setName("test" + (i + 1));
            person.setNameCn("测试" + (i + 1));
            list.add(person);
        }
        repository.saveAll(list);
    }

    @Test
    public void findById() {
        Person person = repository.findById(1).orElse(null);
        System.out.println(person);
    }

    @Test
    public void findByName() {
        Person person = repository.findByName("xxb");
        System.out.println(person);
    }

    @Test
    public void update() {
        Person person = repository.findById(1).orElse(null);
        person.setAge(20);
        repository.save(person);
        System.out.println(person);
    }

    @Test
    public void all() {
        List<Person> personList = repository.findAll();
        System.out.println(personList);
    }

    @Test
    public void count() {
        long count = repository.count();
        System.out.println(count);
    }

    @Test
    public void delete() {
        repository.deleteById(1);
        Person person = repository.findById(1).orElse(null);
        System.out.println(person);
    }

    @Test
    public void deleteAll() {
        repository.deleteAll();
        long count = repository.count();
        System.out.println(count);
    }

    @Test
    public void page() {
        Pageable pageable = CassandraPageRequest.of(0, 5);
        List<Person> list = repository.findAll(pageable).getContent();
        System.out.println(list);
    }

}

第二种：

package com.lean.cassandra;

import com.alibaba.fastjson.JSON;
import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
import com.google.common.collect.Lists;

import com.lean.cassandra.entity.User;
import com.lean.cassandra.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void saveUser() {
        User user = new User();
        user.setId(1);
        user.setName("aa");
        user.setAge(10);
        user.setBooks(Lists.newArrayList());
        userService.saveUser(user);
    }

    @Test
    public void batchSaveUser() {
        List<User> userList = new ArrayList<>();
        for (int i = 2; i < 100; i++) {
            User user = new User();
            user.setId(0);
            user.setName("aa");
            user.setAge(10);
            user.setBooks(Lists.newArrayList());
            userList.add(user);
        }
        userService.batchSaveUser(userList);
    }

    @Test
    public void updateUser() {
        User user = new User();
        user.setId(1);
        user.setName("dd");
        user.setAge(10);
        user.setBooks(Lists.newArrayList());
        userService.updateUser(user);
    }

    @Test
    public void getById() {
        Integer id = 1;
        User user = userService.getById(id);
        System.out.println(JSON.toJSONString(user));
    }

    @Test
    public void getUserDetail() {
        Query query = Query.empty();
        // query = query.withAllowFiltering();
        User user = userService.getObj(query);
        System.out.println(JSON.toJSONString(user));
    }

    @Test
    public void findUserList() {
        Query query = Query.empty();
        // query = query.withAllowFiltering();
        List<User> userList = userService.listObjs(query);
        System.out.println(JSON.toJSONString(userList));
    }

}

package com.lean.cassandra;


import com.alibaba.fastjson.JSON;
import com.lean.cassandra.entity.TestDb;
import com.lean.cassandra.service.TestDbService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestDbTest {

    @Autowired
    private TestDbService testDbService;

    @Test
    public void save() {
        for (int i = 0; i < 100; i++) {
            TestDb testDb=new TestDb();
            if(i%2==0){
                testDb.setKeyOne("1");
            }else {
                testDb.setKeyOne("2");
            }
            testDb.setKeyTwo((i+2)+"");
            testDb.setValue(1.0D);
            testDbService.save(testDb);
        }
    }

    @Test
    public void query() {
        TestDb testDb=new TestDb();
        testDb.setKeyOne("1");
        List<TestDb> query = testDbService.query(testDb);
        System.out.println(JSON.toJSONString(query));
    }

    @Test
    public void delete() {
        TestDb testDb=new TestDb();
        testDb.setKeyOne("1");
        testDb.setKeyTwo("2");
        testDbService.delete(testDb);
    }
}