`
xhfei
  • 浏览: 115536 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Cassandra API60 Java 代码示例

阅读更多
转自http://archive.cnblogs.com/a/1757272/
文档地址 http://wiki.apache.org/cassandra/API06,实现了绝大部分示例

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.cassandra.thrift.Cassandra;
import org.apache.cassandra.thrift.Column;
import org.apache.cassandra.thrift.ColumnOrSuperColumn;
import org.apache.cassandra.thrift.ColumnParent;
import org.apache.cassandra.thrift.ColumnPath;
import org.apache.cassandra.thrift.ConsistencyLevel;
import org.apache.cassandra.thrift.Deletion;
import org.apache.cassandra.thrift.InvalidRequestException;
import org.apache.cassandra.thrift.KeyRange;
import org.apache.cassandra.thrift.KeySlice;
import org.apache.cassandra.thrift.Mutation;
import org.apache.cassandra.thrift.NotFoundException;
import org.apache.cassandra.thrift.SlicePredicate;
import org.apache.cassandra.thrift.SliceRange;
import org.apache.cassandra.thrift.TimedOutException;
import org.apache.cassandra.thrift.UnavailableException;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;


public class test2 {
    public static void main(String[] args) throws InvalidRequestException, NotFoundException, UnavailableException, TimedOutException, TException, UnsupportedEncodingException {
        TTransport tr = new TSocket("localhost", 9160);
        try {            
            TProtocol proto = new TBinaryProtocol(tr);
            Cassandra.Client client = new Cassandra.Client(proto);
            tr.open();
            
            try{
                System.out.println("::ColumnOrSuperColumn get(keyspace, key, column_path, consistency_level)");
                //ColumnOrSuperColumn get(keyspace, key, column_path, consistency_level)
                //通过 column_path 参数获取 Column 或 SuperColumn 
                //如果查询结果为空将引发 NotFoundException异常. 
                //(这是唯一一个能够抛NotFoundException异常的方法)
                ColumnPath columnPath = new ColumnPath();
                columnPath.setColumn("name".getBytes());
                columnPath.setColumn_family("Standard1");
                //columnPath.setSuper_column("super_column".getBytes()); //如果是SuperColumn
                ColumnOrSuperColumn result_get = client.get("Keyspace1", "3", columnPath, ConsistencyLevel.ONE);
                System.out.println( new String(result_get.column.name, "UTF-8") + " -> " + new String(result_get.column.value, "UTF-8"));
            }catch(NotFoundException e){
                e.printStackTrace();        
            }
            
            System.out.println("::list<ColumnOrSuperColumn> get_slice(keyspace, key, column_parent, predicate, consistency_level)");
            //list<ColumnOrSuperColumn> get_slice(keyspace, key, column_parent, predicate, consistency_level)
            //根据 column_parent返回一组Column 在 predicate参数中可以设定Column的条件
            //(column_parent可以是一个ColumnFamily 名称或者是一个 ColumnFamily/SuperColumn) 
            
            ColumnParent column_parent = new ColumnParent();
            column_parent.setColumn_family("Standard1");
            //columnPath.setSuper_column("super_column".getBytes()); //如果是SuperColumn
            
            SlicePredicate predicate = new SlicePredicate();
            
//            List<byte[]> column_names = new ArrayList<byte[]>();
//            column_names.add("name".getBytes());
//            column_names.add("title".getBytes());    
//            column_names.add("not exists column".getBytes());    
//            predicate.setColumn_names(column_names); //使用指定的column列表
        
            SliceRange sliceRange = new SliceRange();
            sliceRange.setStart("z4".getBytes()); //是Column 的范围
            sliceRange.setFinish("a1".getBytes());
            sliceRange.setReversed(true); //必须与上面start和finish一致;如果为true finish小于start
            sliceRange.setCount(3); //Column数量
            predicate.setSlice_range(sliceRange); //不能和ColumnNames参数同时指定
            
            List<ColumnOrSuperColumn> result_get_slice = client.get_slice("Keyspace1", "3", column_parent, predicate, ConsistencyLevel.ONE);
            for(ColumnOrSuperColumn item:result_get_slice){
                //item.super_column.columns //如果是SuperColumn
                System.out.println( new String(item.column.name, "UTF-8") + " -> " + new String(item.column.value, "UTF-8"));                
            }
            
            System.out.println("::map<string,list<ColumnOrSuperColumn>> multiget_slice(keyspace, keys, column_parent, predicate, consistency_level)");
//            map<string,list<ColumnOrSuperColumn>> multiget_slice(keyspace, keys, column_parent, predicate, consistency_level) 
//                和上面函数get_slice基本相同,只是上面的函数get_slice查询一个key的结果,这个根据list<string>进行查询
            List<String> keys = new ArrayList<String>();
            keys.add("1");
            keys.add("3");
            keys.add("6");
            
            Map<String,List<ColumnOrSuperColumn>> multiget_slice_result = client.multiget_slice("Keyspace1",keys,column_parent,predicate,ConsistencyLevel.ONE);
            for(String key:multiget_slice_result.keySet()){ //遍历Key
                System.out.println("key -> " + key);
                for(ColumnOrSuperColumn item:multiget_slice_result.get(key)){           
                    System.out.println( new String(item.column.name, "UTF-8") + " -> " + new String(item.column.value, "UTF-8"));
                }
            }
            
            System.out.println("::i32 get_count(keyspace, key, column_parent, consistency_level)");
            //计算指定参数 column_parent中的 Column 个数
            //The method is not O(1). It takes all the columns from disk to calculate the answer. The only benefit of the method is that you do not need to pull all the columns over Thrift interface to count them.
            int get_count_result = client.get_count("Keyspace1", "3", column_parent, ConsistencyLevel.ONE);
            System.out.println("get_count_result -> " + get_count_result);
            
            System.out.println("::list<KeySlice> get_range_slices(keyspace, column_parent, predicate, range, consistency_level)");
            //list<KeySlice> get_range_slices(keyspace, column_parent, predicate, range, consistency_level) 
            //是上面所有查询函数综合:指定Column、Key的范围进行查询,其实和multiget_slice很像
            //Replaces get_range_slice. Returns a list of slices for the keys within the specified KeyRange. 
            //Unlike get_key_range, this applies the given predicate to all keys in the range, not just those with undeleted matching data. 
            //This method is only allowed when using an order-preserving partitioner.
            
            KeyRange keyRange = new KeyRange();
            keyRange.setStart_key("1000");
            keyRange.setEnd_key("5000");             
            keyRange.setCount(10);
            //并没有返回key在1000到5000的值 ???
            
            SlicePredicate predicate2 = new SlicePredicate();
            List<byte[]> column_names = new ArrayList<byte[]>();
            column_names.add("title".getBytes());
            predicate2.setColumn_names(column_names);
            
            List<KeySlice> get_range_slices_result = client.get_range_slices("Keyspace1", column_parent, predicate2, keyRange, ConsistencyLevel.ONE);
            
            for(KeySlice keySlice:get_range_slices_result){
                System.out.println("key -> " + keySlice.key);
                for(ColumnOrSuperColumn item:keySlice.columns){           
                    System.out.println( new String(item.column.name, "UTF-8") + " -> " + new String(item.column.value, "UTF-8"));
                }
            }            
            
            System.out.println("::insert(keyspace, key, column_path, value, timestamp, consistency_level)");
            //insert(keyspace, key, column_path, value, timestamp, consistency_level)
            //Insert a Column consisting of (column_path.column, value, timestamp) at the given column_path.
            //column_family and optional column_path.super_column. 
            //Note that column_path.column is here required, since a SuperColumn cannot directly contain binary values -- 
            //it can only contain sub-Columns. 
            long timestamp = System.currentTimeMillis();
            ColumnPath columnPath = new ColumnPath();
            columnPath.setColumn_family("Standard1");
            columnPath.setColumn("name".getBytes());            
            client.insert("Keyspace1", "999322", columnPath, "Rick".getBytes(), timestamp, ConsistencyLevel.ONE);
            System.out.println("Insert ok");
            

            //batch_mutate(keyspace, mutation_map, consistency_level) 
            //Executes the specified mutations on the keyspace. mutation_map is a map<string, map<string, list<Mutation>>>; 
            //the outer map maps the key to the inner map, which maps the column family to the Mutation; 
            //这个参数有点复杂,可以这样看: map<key : string, map<column_family : string, list<Mutation>>>. 
            //To be more specific, the outer map key is a row key, the inner map key is the column family name.
            //A Mutation specifies either columns to insert or columns to delete. See Mutation and Deletion above for more details. 
            Map<String, Map<String, List<Mutation>>> mutation_map = new HashMap<String, Map<String, List<Mutation>>>();
            Map<String, List<Mutation>> mutations = new HashMap<String, List<Mutation>>();
            List<Mutation> mutas = new ArrayList<Mutation>();
            
            Mutation mutation1 = new Mutation();            
            ColumnOrSuperColumn column_or_supercolumn = new ColumnOrSuperColumn();
            Column column = new Column();
            column.setName("name".getBytes());
            column.setValue("Richard".getBytes());
            column.setTimestamp(System.currentTimeMillis());
            column_or_supercolumn.setColumn(column);            
            mutation1.setColumn_or_supercolumn(column_or_supercolumn);
            
            Mutation mutation2 = new Mutation();            
            ColumnOrSuperColumn column_or_supercolumn2 = new ColumnOrSuperColumn();
            Column column2 = new Column();
            column2.setName("email".getBytes());
            column2.setValue("richard@gmail.com".getBytes());
            column2.setTimestamp(System.currentTimeMillis());
            column_or_supercolumn2.setColumn(column2);            
            mutation2.setColumn_or_supercolumn(column_or_supercolumn2);
            mutas.add(mutation2);
            mutas.add(mutation1);
            
            mutations.put("Standard1", mutas);    //Standard1 是column_family
            mutation_map.put("12315", mutations); //12315  是key 可以同时插入多个Key、在不同的columnFamily、多个Column
            
            client.batch_mutate("Keyspace1", mutation_map, ConsistencyLevel.ONE);
            System.out.println("batch_mutate insert done.");
            
            mutation_map.clear();
            mutations.clear();
            mutas.clear();
            Mutation mutation3 = new Mutation();
            
            Deletion deletion1 = new Deletion();
            deletion1.setTimestamp(System.currentTimeMillis());
            SlicePredicate predicate3 = new SlicePredicate();
            predicate3.column_names = new ArrayList<byte[]>();
            predicate3.column_names.add("email".getBytes());
            predicate3.column_names.add("name".getBytes());            
            deletion1.setPredicate(predicate3);            
            //deletion1.setSuper_column(super_column)
            mutation3.setDeletion(deletion1);
            mutas.add(mutation3);//重复
            
            mutations.put("Standard1", mutas);
            mutation_map.put("12315", mutations);
            
            client.batch_mutate("Keyspace1", mutation_map, ConsistencyLevel.ONE);
            System.out.println("batch_mutate deletion done.");
        } catch (TTransportException e) {
            e.printStackTrace();
        }finally{
            tr.close();
        }
    }

}
分享到:
评论

相关推荐

    cassandra入门项目源代码

    这个项目提供了一整套实践性的代码示例,涵盖了从设置开发环境到实现数据存储和检索的关键步骤。 【描述】:在Eclipse中开发这个项目,首先需要安装Eclipse IDE,它是Java开发的常用工具。然后,你需要配置Maven,...

    cassandrasample:使用 DataStax Cassandra Java 驱动程序 API 的代码示例

    卡桑德拉样品使用 DataStax Cassandra Java 驱动程序 API 的代码示例这是一个普通的 java maven 项目。 它与 Java 1.7.x 以及 Maven 3.x 一起使用所有代码片段都非常简单地解释了在应用程序中开始使用 DataStax ...

    cassandra-java-example:一堆使用 Apache Cassandra 和 Datastax Java 驱动程序的 Apache Cassandra 示例

    在 `cassandra-java-example-master` 中,你应该能找到类似的示例代码,通过运行它们来了解 Cassandra 和 Datastax Java 驱动的实际应用。 这个示例项目不仅涵盖了基本的 CRUD 操作,还可能包含更复杂的查询、...

    Cassandra Java Client.zip

    【标题】"Cassandra Java Client.zip" 涉及到的主要知识点是Apache Cassandra数据库与Java客户端的交互。...在进一步学习时,可以参考Cassandra的官方文档、DataStax的Java驱动程序指南以及相关的示例代码。

    cassandra-jdbc-wrapper:用于 Cassandra 的 Datastax Java 驱动程序的 JDBC 包装器

    Cassandra JDBC Wrapper 是一个专门为 Cassandra 数据库设计的 Java JDBC(Java Database Connectivity)包装器,它允许 Java 应用程序通过标准的 JDBC API 来访问和操作 Cassandra 的数据。标题中的 "cassandra-...

    Java及大数据相关的一些代码

    这个压缩包“Java及大数据相关的一些代码”包含了一系列与Java编程和大数据处理相关的源代码示例,旨在帮助开发者逐步理解并掌握相关技术。 首先,让我们深入探讨Java编程语言的基础。Java是一种面向对象的、跨平台...

    Cassandra JDBC Driver 0.8.2

    2. **遵循 JDBC 规范**:该驱动程序按照 JDBC(Java Database Connectivity)规范设计,提供了一个标准化的接口,使得开发人员能够在不深入了解 Cassandra 本身的底层机制的情况下,使用熟悉的 JDBC 代码来操作 ...

    cassandra2.1.2 JDBC最少依赖jar

    请注意,上述代码只是一个基本示例,实际使用时需要替换`&lt;hostname&gt;`、`&lt;keyspace&gt;`、`&lt;username&gt;`和`&lt;password&gt;`为你的Cassandra集群的实际信息。 总结来说,"cassandra2.1.2 JDBC最少依赖jar"是一个包含连接...

    springboot 代码示例

    在"springboot 代码示例"中,我们可以深入学习 Spring Boot 的核心概念和实践应用。这个项目,"springboot-learning-example-master",通常包含了一系列的示例代码,用于演示如何使用 Spring Boot 开发各种功能。 1...

    cassandra Example的一点理解及疑问

    作者可能会通过具体的代码示例来解释如何与Cassandra交互,使用Java驱动或其他编程语言。 【描述】:“NULL” 由于描述为空,我们无法直接获取到作者在示例中遇到的具体问题或讨论的主题。但我们可以推测,作者...

    数据库代码示例.rar

    标题中的“数据库代码示例”可能包含了一些关于如何与数据库交互的编程示例,这通常涉及到SQL查询语言或特定数据库API的使用。 在软件/插件标签中,我们可以理解为这些代码示例可能是用于与数据库交互的软件组件或...

    Java代码实现数据处理共4页.pdf.zip

    "Java代码实现数据处理共4页.pdf.zip"这个文件很显然包含了关于使用Java进行数据处理的详细教程或示例代码,总共分为四页。在这个压缩包里,用户可能找到了如何通过Java进行数据操作、分析和管理的关键步骤。 首先...

    JAVA大数据流处理Flink代码.zip

    在大数据处理领域,Apache Flink 是一个强大的开源流处理框架,专为实时数据流和批处理...通过学习和理解这些代码示例,开发者能够更好地掌握 Flink 在 Java 中的使用,从而在大数据流处理项目中发挥出 Flink 的优势。

    java开发spark程序

    本篇文章将深入探讨如何使用Java开发Spark程序,并基于提供的"sparkJava"压缩包文件中的示例代码进行解析。 首先,我们需要理解Spark的核心概念。Spark主要由四个组件构成:Spark Core、Spark SQL、Spark Streaming...

    Cassandra-examples

    这个示例集主要针对Cassandra版本1.1.7,而Hector库是版本1.1-2,它是一个流行的客户端库,为Java开发者提供了方便的API来操作Cassandra。 Cassandra是一种分布式NoSQL数据库系统,常用于处理大规模数据存储和检索...

    reactivecassandra:React式Cassandra编程示例

    Java驱动程序是基于Cassandra Query Language (CQL) 的,它支持同步和异步两种API。在这个示例中,我们可能看到了如何使用异步API,以充分利用反应式编程的优势。 **3. Cassandra的数据模型** Cassandra的数据模型...

    mapreduce-wordcount:Go 和 Cassandra DB (Java) 中的简单 MapReduce 字数实现

    2. Java源代码:用于与Cassandra交互的Java代码,包括设置连接、配置MapReduce作业以及写入结果到Cassandra。 3. 数据输入:可能包含示例文本文件,用于测试MapReduce任务。 4. 配置文件:如Hadoop配置文件,用于...

    cassandra-customer-events:使用 DataStax Java 驱动程序的示例项目

    项目中可能包含了设置数据库连接、执行查询、插入数据等基本操作的代码示例。"使用原始驱动程序" 表明它不仅展示了基础的 API 使用,还可能包括了对 Cassandra 协议的直接操作。而 "使用映射 API" 和 "关于分支映射...

Global site tag (gtag.js) - Google Analytics