devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

分布式数据库Cassandra_cassandra数据库

作者：weixin_40725706 | 2024-02-21 20:03:54

赞

踩

cassandra数据库

目录

一、概述

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的命令行 

  1. docker exec -it cassandra bash
  2. 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.客户端操作

  1. docker exec -it my_cassandra  /bin/bash
  2. cd bin
  3. cqlsh

cqlsh的基本命令 

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

help 可以查看cqlsh 支持的命令

 Describe cluster 提供有关集群的信息

 

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

 Describe tables 列出键空间的所有表

CQL-查询语言

数据定义命令

Keyspace

1、创建

  1. 语法：
  2.     CREATE KEYSPACE <identifier> WITH <properties>
  3. 具体语法：
  4.     Create keyspace KeyspaceName with replicaton={'class':strategy name,   
  5. 'replication_factor': No of replications on different nodes}
  6.
  • 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、修改键空间

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

注意：

  • 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、创建表

  1. CREATE (TABLE | COLUMNFAMILY) <tablename>  
  2. ('<column-definition>' , '<column-definition>')  
  3. (WITH <option> AND <option>)
  4.  
  1. CREATE TABLE t_user(
  2.    id int PRIMARY KEY,  
  3.    name text,  
  4.    age int,  
  5.    gender tinyint,  
  6.    address text ,
  7.    interest set<text>,
  8.    phone list<text>,
  9.    education map<text, text>
  10. );

验证 

DESCRIBE TABLE t_user;

 主键有两种类型：

  • 单个主键：对单个主键使用以下语法。 
    Primary key (ColumnName)
  • 复合主键：对复合主键可使用以下语法。 
    1. Primary key(ColumnName1,ColumnName2 . . .)
    2. 或-
    3. Primary key((key_part_one,key_part_two),ColumnName2 . . .)
    4. key_part_one:称作Partition Key,Cassandra会对其做一个hash计算，决定放在哪个节点。
    5. key_part_two:CLUSTERING KEY

3、修改表结构

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

  1. 添加一列：
  2.     ALTER (TABLE | COLUMNFAMILY) <tablename> <instruction>
  3. 删除一列：
  4.     ALTER table name  DROP name;
  5.

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、插入数据

  1. INSERT INTO <tablename>  
  2. (<column1 name>, <column2 name>....)  
  3. VALUES (<value1>, <value2>....)  
  4. USING <option>
  5.

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、更新数据

  1. UPDATE <tablename>  
  2. SET <column name> = <new value>  
  3. <column name> = <value>....  
  4. WHERE <condition>
  5. 又或者 -
  6. Update KeyspaceName.TableName   
  7. Set ColumnName1=new Column1Value,  
  8.       ColumnName2=new Column2Value,  
  9.       ColumnName3=new Column3Value,  
  10.        .  
  11.        .  
  12.        .  
  13. 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
  1. create table student (
  2. key_one int,
  3. key_two int,
  4. name text,
  5. age  int,
  6. PRIMARY KEY(key_one, key_two)
  7. );
  8. create INDEX tage ON student (age);

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

  1. insert into  student(key_one,key_two,name,age) values(1,2,'a',2);
  2. insert into  student(key_one,key_two,name,age) values(2,3,'b',2);
  3. insert into  student(key_one,key_two,name,age) values(3,4,'c',2);
  4. 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，可以同时执行多个修改语句（插入，更新，删除）

  1. BEGIN BATCH
  2. <insert-stmt>/ <update-stmt>/ <delete-stmt>
  3. APPLY BATCH

 

  1. BEGIN BATCH
  2.     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']);
  3.     UPDATE t_user set age = 11 where id= 1;
  4.     DELETE FROM t_user WHERE id=2;
  5. APPLY BATCH;

 2.JAVA操作

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-cassandra</artifactId>
  4. </dependency>
  1. # 应用名称
  2. spring:
  3.   application:
  4.     name: spring-lean-cassandra
  5.   data:
  6.     cassandra:
  7.       contact-points: 192.168.56.1
  8.       port: 9042
  9.       local-datacenter: datacenter1
  10.       session-name: cassandraCluster
  11.       username:
  12.       password:
  13.       keyspace-name: company
  14. # 应用服务 WEB 访问端口
  15. server:
  16.   port: 9088

手动创建 keyspace和表。

  1. CREATE TABLE person
  2. (
  3.     id      int,
  4.     name    text,
  5.     name_cn text,
  6.     age     int,
  7.     PRIMARY KEY (id)
  8. );
  9. CREATE TABLE city
  10. (
  11.     id      int,
  12.     name    text,
  13.     persons list<text>,
  14.     PRIMARY KEY (id)
  15. );
  16.  
  17. CREATE TABLE t_user
  18. (
  19.     id    int,
  20.     name  text,
  21.     age   int,
  22.     books list<text>,
  23.     PRIMARY KEY (id)
  24. );
  25. CREATE TABLE testdb (
  26.     key_one text,
  27.     key_two text,
  28.     value double,
  29.     PRIMARY KEY (key_one,key_two ) 
  30. );

  1. import lombok.Data;
  2. import org.springframework.data.cassandra.core.mapping.*;
  3.  
  4. import java.util.List;
  5.  
  6. @Data
  7. @Table
  8. public class City {
  9.     @PrimaryKey
  10.     private int id;
  11.     private String name;
  12.     private List<String> persons;
  13. }
  14.  
  15. import lombok.Data;
  16. import org.springframework.data.cassandra.core.mapping.Column;
  17. import org.springframework.data.cassandra.core.mapping.PrimaryKey;
  18. import org.springframework.data.cassandra.core.mapping.Table;
  19.  
  20. @Data
  21. @Table
  22. public class Person {
  23.  
  24.     @PrimaryKey
  25.     private Integer id;
  26.     private String name;
  27.     @Column(value = "name_cn")
  28.     private String nameCn;
  29.     private Integer age;
  30.  
  31. }
  32.  
  33. import lombok.Data;
  34. import org.springframework.data.cassandra.core.mapping.PrimaryKey;
  35. import org.springframework.data.cassandra.core.mapping.Table;
  36.  
  37. import java.io.Serializable;
  38. import java.util.List;
  39.  
  40.  
  41. @Data
  42. @Table("t_user")
  43. public class User implements Serializable {
  44.  
  45.     @PrimaryKey
  46.     private int id;
  47.     private String name;
  48.     private int age;
  49.     private List<String> books;
  50. }
  51.  
  52. import lombok.Data;
  53. import org.springframework.data.cassandra.core.cql.PrimaryKeyType;
  54. import org.springframework.data.cassandra.core.mapping.Column;
  55. import org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn;
  56. import org.springframework.data.cassandra.core.mapping.Table;
  57.  
  58. @Data
  59. @Table("testdb")
  60. public class TestDb {
  61.     @PrimaryKeyColumn(value = "key_one",type = PrimaryKeyType.PARTITIONED)
  62.     private String keyOne;
  63.     @PrimaryKeyColumn(value = "key_two",type = PrimaryKeyType.CLUSTERED)
  64.     private String keyTwo;
  65.     @Column("value")
  66.     private double value;
  67. }
  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.data.cassandra.repository.config.EnableCassandraRepositories;
  4.  
  5. @EnableCassandraRepositories
  6. @SpringBootApplication
  7. public class SpringLeanCassandraApplication {
  8.     public static void main(String[] args) {
  9.         SpringApplication.run(SpringLeanCassandraApplication.class, args);
  10.     }
  11. }

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

  1. import com.lean.cassandra.entity.City;
  2. import org.springframework.data.cassandra.repository.CassandraRepository;
  3. public interface CityRepository extends CassandraRepository<City, Integer> {
  4.  
  5. }
  6.  
  7.  
  8. import com.lean.cassandra.entity.Person;
  9. import org.springframework.data.cassandra.repository.AllowFiltering;
  10. import org.springframework.data.cassandra.repository.CassandraRepository;
  11.  
  12.  
  13. public interface PersonRepository extends CassandraRepository<Person, Integer> {
  14.  
  15.     /**
  16.      * 根据名字查询
  17.      *
  18.      * @param name 名字
  19.      * @return Person
  20.      */
  21.     @AllowFiltering
  22.     Person findByName(String name);
  23. }

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

  1. import com.lean.cassandra.entity.User;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.data.cassandra.core.CassandraTemplate;
  4. import org.springframework.data.cassandra.core.query.Query;
  5. import org.springframework.stereotype.Service;
  6.  
  7. import java.io.Serializable;
  8. import java.util.List;
  9.  
  10. @Service
  11. public class UserService {
  12.  
  13.     @Autowired
  14.     private CassandraTemplate cassandraTemplate;
  15.  
  16.     public void saveUser(User user){
  17.         cassandraTemplate.insert(user);
  18.     }
  19.  
  20.     public void batchSaveUser(List<User> userList){
  21.         cassandraTemplate.batchOps().insert(userList);
  22.     }
  23.  
  24.     public void updateUser(User user){
  25.         cassandraTemplate.update(user);
  26.     }
  27.  
  28.     public User getById(Serializable id) {
  29.         return cassandraTemplate.selectOneById(id, User.class);
  30.     }
  31.  
  32.     public User getObj(Query query) {
  33.         return cassandraTemplate.selectOne(query, User.class);
  34.     }
  35.  
  36.     public List<User> listObjs(Query query) {
  37.         return cassandraTemplate.select(query, User.class);
  38.     }
  39. }
  1. package com.lean.cassandra.service;
  2.  
  3. import com.lean.cassandra.entity.TestDb;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.cassandra.core.CassandraTemplate;
  6. import org.springframework.data.cassandra.core.query.Criteria;
  7. import org.springframework.data.cassandra.core.query.Query;
  8. import org.springframework.stereotype.Service;
  9.  
  10. import java.util.List;
  11.  
  12. @Service
  13. public class TestDbService {
  14.  
  15.  
  16.     @Autowired
  17.     private CassandraTemplate cassandraTemplate;
  18.  
  19.  
  20.     public TestDb save(TestDb testDb) {
  21.         return cassandraTemplate.insert(testDb);
  22.     }
  23.  
  24.     public List<TestDb> query(TestDb testDb) {
  25.         return cassandraTemplate.select("select * from testdb where key_one = '"+testDb.getKeyOne()+"';", TestDb.class);
  26.     }
  27.  
  28.     public boolean delete(TestDb testDb) {
  29.         return cassandraTemplate.delete(Query.query(Criteria.where("key_one").is(testDb.getKeyOne())).and(Criteria.where("key_two").lte(testDb.getKeyTwo())), TestDb.class);
  30.     }
  31. }

测试：

第一种：

  1. import com.lean.cassandra.entity.City;
  2. import com.lean.cassandra.entity.Person;
  3. import com.lean.cassandra.repository.CityRepository;
  4. import org.junit.jupiter.api.Test;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.test.context.SpringBootTest;
  7.  
  8. import java.util.LinkedList;
  9. import java.util.List;
  10. @SpringBootTest
  11. public class CityRepositoryTest {
  12.     @Autowired
  13.     private CityRepository cityRepository;
  14.  
  15.     @Test
  16.     public void save() {
  17.         List<String> list = new LinkedList<>();
  18.         for (int i = 0; i < 20; i++) {
  19.             Person person = new Person();
  20.             person.setId(i + 1);
  21.             person.setAge(18 + i);
  22.             person.setName("test" + (i + 1));
  23.             person.setNameCn("测试" + (i + 1));
  24.             list.add(person.toString());
  25.         }
  26.         City city = new City();
  27.         city.setId(1);
  28.         city.setName("深圳");
  29.         city.setPersons(list);
  30.         cityRepository.save(city);
  31.     }
  32. }

  1. package com.lean.cassandra;
  2.  
  3. import com.lean.cassandra.entity.Person;
  4. import com.lean.cassandra.repository.PersonRepository;
  5. import org.junit.jupiter.api.Test;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.boot.test.context.SpringBootTest;
  8. import org.springframework.data.cassandra.core.query.CassandraPageRequest;
  9. import org.springframework.data.domain.Pageable;
  10.  
  11. import java.util.LinkedList;
  12. import java.util.List;
  13.  
  14.  
  15. @SpringBootTest
  16. public class PersonRepositoryTest {
  17.  
  18.     @Autowired
  19.     private PersonRepository repository;
  20.  
  21.     @Test
  22.     public void save() {
  23.         Person person = new Person();
  24.         person.setId(1);
  25.         person.setName("xxb");
  26.         person.setAge(18);
  27.         repository.save(person);
  28.     }
  29.  
  30.     @Test
  31.     public void saveAll() {
  32.         List<Person> list = new LinkedList<>();
  33.         for (int i = 1; i < 20; i++) {
  34.             Person person = new Person();
  35.             person.setId(i + 1);
  36.             person.setAge(18 + i);
  37.             person.setName("test" + (i + 1));
  38.             person.setNameCn("测试" + (i + 1));
  39.             list.add(person);
  40.         }
  41.         repository.saveAll(list);
  42.     }
  43.  
  44.     @Test
  45.     public void findById() {
  46.         Person person = repository.findById(1).orElse(null);
  47.         System.out.println(person);
  48.     }
  49.  
  50.     @Test
  51.     public void findByName() {
  52.         Person person = repository.findByName("xxb");
  53.         System.out.println(person);
  54.     }
  55.  
  56.     @Test
  57.     public void update() {
  58.         Person person = repository.findById(1).orElse(null);
  59.         person.setAge(20);
  60.         repository.save(person);
  61.         System.out.println(person);
  62.     }
  63.  
  64.     @Test
  65.     public void all() {
  66.         List<Person> personList = repository.findAll();
  67.         System.out.println(personList);
  68.     }
  69.  
  70.     @Test
  71.     public void count() {
  72.         long count = repository.count();
  73.         System.out.println(count);
  74.     }
  75.  
  76.     @Test
  77.     public void delete() {
  78.         repository.deleteById(1);
  79.         Person person = repository.findById(1).orElse(null);
  80.         System.out.println(person);
  81.     }
  82.  
  83.     @Test
  84.     public void deleteAll() {
  85.         repository.deleteAll();
  86.         long count = repository.count();
  87.         System.out.println(count);
  88.     }
  89.  
  90.     @Test
  91.     public void page() {
  92.         Pageable pageable = CassandraPageRequest.of(0, 5);
  93.         List<Person> list = repository.findAll(pageable).getContent();
  94.         System.out.println(list);
  95.     }
  96.  
  97. }

 第二种：

  1. package com.lean.cassandra;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
  5. import com.google.common.collect.Lists;
  6.  
  7. import com.lean.cassandra.entity.User;
  8. import com.lean.cassandra.service.UserService;
  9. import org.junit.Test;
  10. import org.junit.runner.RunWith;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.boot.test.context.SpringBootTest;
  13. import org.springframework.data.cassandra.core.query.Query;
  14. import org.springframework.test.context.junit4.SpringRunner;
  15.  
  16. import java.util.ArrayList;
  17. import java.util.List;
  18. @RunWith(SpringRunner.class)
  19. @SpringBootTest
  20. public class UserServiceTest {
  21.  
  22.     @Autowired
  23.     private UserService userService;
  24.  
  25.     @Test
  26.     public void saveUser() {
  27.         User user = new User();
  28.         user.setId(1);
  29.         user.setName("aa");
  30.         user.setAge(10);
  31.         user.setBooks(Lists.newArrayList());
  32.         userService.saveUser(user);
  33.     }
  34.  
  35.     @Test
  36.     public void batchSaveUser() {
  37.         List<User> userList = new ArrayList<>();
  38.         for (int i = 2; i < 100; i++) {
  39.             User user = new User();
  40.             user.setId(0);
  41.             user.setName("aa");
  42.             user.setAge(10);
  43.             user.setBooks(Lists.newArrayList());
  44.             userList.add(user);
  45.         }
  46.         userService.batchSaveUser(userList);
  47.     }
  48.  
  49.     @Test
  50.     public void updateUser() {
  51.         User user = new User();
  52.         user.setId(1);
  53.         user.setName("dd");
  54.         user.setAge(10);
  55.         user.setBooks(Lists.newArrayList());
  56.         userService.updateUser(user);
  57.     }
  58.  
  59.     @Test
  60.     public void getById() {
  61.         Integer id = 1;
  62.         User user = userService.getById(id);
  63.         System.out.println(JSON.toJSONString(user));
  64.     }
  65.  
  66.     @Test
  67.     public void getUserDetail() {
  68.         Query query = Query.empty();
  69.         // query = query.withAllowFiltering();
  70.         User user = userService.getObj(query);
  71.         System.out.println(JSON.toJSONString(user));
  72.     }
  73.  
  74.     @Test
  75.     public void findUserList() {
  76.         Query query = Query.empty();
  77.         // query = query.withAllowFiltering();
  78.         List<User> userList = userService.listObjs(query);
  79.         System.out.println(JSON.toJSONString(userList));
  80.     }
  81.  
  82. }

 

  1. package com.lean.cassandra;
  2.  
  3.  
  4. import com.alibaba.fastjson.JSON;
  5. import com.lean.cassandra.entity.TestDb;
  6. import com.lean.cassandra.service.TestDbService;
  7. import org.junit.Test;
  8. import org.junit.runner.RunWith;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.boot.test.context.SpringBootTest;
  11. import org.springframework.test.context.junit4.SpringRunner;
  12.  
  13. import java.util.List;
  14. @RunWith(SpringRunner.class)
  15. @SpringBootTest
  16. public class TestDbTest {
  17.  
  18.     @Autowired
  19.     private TestDbService testDbService;
  20.  
  21.     @Test
  22.     public void save() {
  23.         for (int i = 0; i < 100; i++) {
  24.             TestDb testDb=new TestDb();
  25.             if(i%2==0){
  26.                 testDb.setKeyOne("1");
  27.             }else {
  28.                 testDb.setKeyOne("2");
  29.             }
  30.             testDb.setKeyTwo((i+2)+"");
  31.             testDb.setValue(1.0D);
  32.             testDbService.save(testDb);
  33.         }
  34.     }
  35.  
  36.     @Test
  37.     public void query() {
  38.         TestDb testDb=new TestDb();
  39.         testDb.setKeyOne("1");
  40.         List<TestDb> query = testDbService.query(testDb);
  41.         System.out.println(JSON.toJSONString(query));
  42.     }
  43.  
  44.     @Test
  45.     public void delete() {
  46.         TestDb testDb=new TestDb();
  47.         testDb.setKeyOne("1");
  48.         testDb.setKeyTwo("2");
  49.         testDbService.delete(testDb);
  50.     }
  51. }

官方网址 

cassandra可视化客户端​​​​​​​

分布式算法实用指南

 Cassandra数据库

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/126218?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号