DevinKim

(三)HBase的Java代码开发

文章目录

HBase的Java代码开发

配置Maven工程pom.xml文件的依赖
(一)创建表
(二)删除表
(三)向表中添加数据
(四)删除数据
(五)查询数据

1.Get查询
2.Scan查询
3.RowFilter行键过滤器
4.FamilyFilter列族过滤器
5.QualifierFilter列过滤器
6.ValueFilter值过滤器
7.SingleColumnValueFilter单列值过滤器
8.PrefixFilter前缀过滤器
9.PageFilter分页过滤器

HBase的Java代码开发

配置Maven工程pom.xml文件的依赖

    <repositories>
        <repository>
            <id>clouderaid>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/url>
        repository>
    repositories>

    <dependencies>
        <dependency>
            <groupId>org.apache.hadoopgroupId>
            <artifactId>hadoop-clientartifactId>
            <version>2.6.0-mr1-cdh5.14.0version>
        dependency>
        <dependency>
            <groupId>org.apache.hbasegroupId>
            <artifactId>hbase-clientartifactId>
            <version>1.2.0-cdh5.14.0version>
        dependency>

        <dependency>
            <groupId>org.apache.hbasegroupId>
            <artifactId>hbase-serverartifactId>
            <version>1.2.0-cdh5.14.0version>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>org.testnggroupId>
            <artifactId>testngartifactId>
            <version>6.14.3version>
            <scope>testscope>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <version>3.0version>
                <configuration>
                    <source>1.8source>
                    <target>1.8target>
                    <encoding>UTF-8encoding>
                    
                configuration>
            plugin>
            
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-shade-pluginartifactId>
                <version>2.4.3version>
                <executions>
                    <execution>
                        <phase>packagephase>
                        <goals>
                            <goal>shadegoal>
                        goals>
                        <configuration>
                            <minimizeJar>falseminimizeJar>
                        configuration>
                    execution>
                executions>
            plugin>
        plugins>
    build>

(一)创建表

创建myuser表，两个列族，分别为f1，f2。

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import java.io.IOException;	
//创建myuser表，两个列族，分别为f1，f2。
public class CrreateHBaseTable {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        //连接hbase集群不需要指定hbase主节点的ip和端口
        //只需指定各节点zooleeper的ip和端口,只指定一台zookeeper也可以
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");

        //创建连接池对象
        Connection connection = ConnectionFactory.createConnection(configuration);

        //对数据库进行DDL操作时,要获取管理员对象
        Admin admin = connection.getAdmin();

        //指定我们创建的表的名字: myuser
        TableName myuser = TableName.valueOf("myuser");
        HTableDescriptor hTableDescriptor = new HTableDescriptor(myuser);

        //指定myuser表的列族: f1、f2
        HColumnDescriptor f1 = new HColumnDescriptor("f1");
        HColumnDescriptor f2 = new HColumnDescriptor("f2");
        hTableDescriptor.addFamily(f1);
        hTableDescriptor.addFamily(f2);

        //创建表
        admin.createTable(hTableDescriptor);

        //释放资源
        admin.close();
        connection.close();
    }
}

(二)删除表

删除myuser表。

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;

import java.io.IOException;
//删除myuser表
public class DeleteHBaseTable {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        //连接hbase集群不需要指定hbase主节点的ip和端口
        //只需指定各节点zooleeper的ip和端口,只指定一台zookeeper也可以
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");

        //创建连接池对象
        Connection connection = ConnectionFactory.createConnection(configuration);

        //对数据库进行DDL操作时,要获取管理员对象
        Admin admin = connection.getAdmin();

        TableName myuser = TableName.valueOf("myuser");
        admin.disableTable(myuser);
        admin.deleteTable(myuser);

        //释放资源
        admin.close();
        connection.close();
    }
}

(三)向表中添加数据

向myuser表中添加数据

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
//向myuser表中添加数据, rowkey="0001"  f1:name = "zhangsan"  f1:name = 18  f1:id = 25 f2:address = "地球人"
public class AddData {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        
        //获取表
        Table table = connection.getTable(TableName.valueOf("myuser"));

        //创建put对象，并指定rowkey值
        Put put = new Put("0001".getBytes());
        put.addColumn("f1".getBytes(),"name".getBytes(),"zhangsan".getBytes());
        put.addColumn("f1".getBytes(),"age".getBytes(), Bytes.toBytes(18));
        put.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(25));
        put.addColumn("f1".getBytes(),"address".getBytes(),Bytes.toBytes("地球人"));

        //执行添加操作
        table.put(put);
        //释放资源
        table.close();
        
        connection.close();
    }
}

(四)删除数据

删除数据rowkey为0001的数据记录

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import java.io.IOException;
//删除数据rowkey为0001的数据记录
public class DeleteData {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        //获取表
        Table table = connection.getTable(TableName.valueOf("myuser"));
        
        //删除数据
        Delete delete = new Delete("0001".getBytes());
        table.delete(delete);
        
        table.close();
        connection.close();
    }
}

(五)查询数据

向myuser表中插入一批数据用作查询操作

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class InsertBatchData {
    public static void main(String[] args) throws IOException {
        //获取连接
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum", "node01:2181,node02:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        //获取表
        Table myuser = connection.getTable(TableName.valueOf("myuser"));
        //创建put对象，并指定rowkey
        Put put = new Put("0002".getBytes());
        put.addColumn("f1".getBytes(),"id".getBytes(), Bytes.toBytes(1));
        put.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("曹操"));
        put.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(30));
        put.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("沛国谯县"));
        put.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("16888888888"));
        put.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("helloworld"));

        Put put2 = new Put("0003".getBytes());
        put2.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(2));
        put2.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("刘备"));
        put2.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(32));
        put2.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put2.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("幽州涿郡涿县"));
        put2.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("17888888888"));
        put2.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("talk is cheap , show me the code"));


        Put put3 = new Put("0004".getBytes());
        put3.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(3));
        put3.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("孙权"));
        put3.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(35));
        put3.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put3.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("下邳"));
        put3.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("12888888888"));
        put3.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("what are you 弄啥嘞！"));

        Put put4 = new Put("0005".getBytes());
        put4.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(4));
        put4.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("诸葛亮"));
        put4.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(28));
        put4.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put4.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("四川隆中"));
        put4.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("14888888888"));
        put4.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("出师表你背了嘛"));

        Put put5 = new Put("0006".getBytes());
        put5.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(5));
        put5.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("司马懿"));
        put5.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(27));
        put5.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put5.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("哪里人有待考究"));
        put5.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("15888888888"));
        put5.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("跟诸葛亮死掐"));


        Put put6 = new Put("0007".getBytes());
        put6.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(5));
        put6.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("xiaobubu—吕布"));
        put6.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(28));
        put6.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put6.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("内蒙人"));
        put6.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("15788888888"));
        put6.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("貂蝉去哪了"));

        List<Put> listPut = new ArrayList<Put>();
        listPut.add(put);
        listPut.add(put2);
        listPut.add(put3);
        listPut.add(put4);
        listPut.add(put5);
        listPut.add(put6);

        myuser.put(listPut);
        myuser.close();
        connection.close();
    }
}

1.Get查询

查询rowkey为0003的f1列族所有数据

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;
//查询rowkey为0003的f1列族所有数据
public class GetByRowKey {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Table table = connection.getTable(TableName.valueOf("myuser"));

        //通过Get对象,指定rowkey,默认查询这个rowkey的所有数据
        Get get = new Get(Bytes.toBytes("0003"));

        //限制只查询f1列族下面所有列的值
        get.addFamily("f1".getBytes());

        //执行get查询,返回一个result对象,所有rowkey为0003的单元格的所有信息都会都封装在这个对象中
        Result result = table.get(get);

        //将每个单元格的所有信息封装在cell对象内,再放入集合中
        List<Cell> cells = result.listCells();
        //遍历cells, 看cell中封装了哪些信息
        for (Cell cell : cells) {
            byte[] value = CellUtil.cloneValue(cell);//获取单元格的值
            byte[] rowkey = CellUtil.cloneRow(cell);//获取单元格对应的rowkey
            byte[] columnName = CellUtil.cloneQualifier(cell);//获取单元格所属的列名
            byte[] familyName = CellUtil.cloneFamily(cell);//获取单元格所属的列族名

            System.out.println(Bytes.toString(familyName));
            System.out.println(Bytes.toString(columnName));
            System.out.println(Bytes.toString(rowkey));
            
            //列名是Id和列名是age的列对应的value整数int类型,要判断一下转成int类型
            if("id".equals(Bytes.toString(columnName)) || "age".equals(Bytes.toString(columnName))){
                System.out.println(Bytes.toInt(value));
            }else {
                System.out.println(Bytes.toString(value));
            }
        }
        table.close();
        connection.close();
    }
}

2.Scan查询

查询rowkey为[0003,0007)之间的数据

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;
//查询rowkey为[0003,0007)之间的数据
public class ScanRangeData {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Table table = connection.getTable(TableName.valueOf("myuser"));

        Scan scan = new Scan();//默认会全表扫描,所有下面要添加约束

        //扫描f1列族
        scan.addFamily("f1".getBytes());

        //扫描f2列族的phone字段
        scan.addColumn("f2".getBytes(),"phine".getBytes());

        //设定扫描的起始行
        scan.setStartRow("0003".getBytes());
        scan.setStopRow("0007".getBytes());

        //通过getScan查询获得表中符合要求的数据, 返回的是多条数据
        ResultScanner scanner = table.getScanner(scan);

        //遍历ResultScanner 得到每一条数据，每一条数据都是封装在result对象里面了
        for (Result result : scanner) {
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] familyName = CellUtil.cloneFamily(cell);
                byte[] qualifierName = CellUtil.cloneQualifier(cell);
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] valueArr = CellUtil.cloneValue(cell);

                if("id".equals(Bytes.toString(qualifierName)) || "age".equals(Bytes.toString(qualifierName))){
                    int value = Bytes.toInt(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }else {
                    String value = Bytes.toString(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }
            }
        }

        table.close();
        connection.close();
    }
}

3.RowFilter行键过滤器

查询所有的rowkey比0003小的所有的数据

package cn.com.vivo.day01;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.BinaryComparator;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;
//查询所有的rowkey比0003小的所有的数据
public class RowFilterQuery {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Table table = connection.getTable(TableName.valueOf("myuser"));

        Scan scan = new Scan();

        /*  RowFilter需要加上两个参数
            第一个参数就是我们的比较规则
            第二个参数就是我们的比较对象  */
       BinaryComparator binaryComparator = new BinaryComparator("0003".getBytes());//获取比较对象
        RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.LESS, binaryComparator);

        //为scan对象设置过滤器
        scan.setFilter(rowFilter);

        //执行查询
        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] familyName = CellUtil.cloneFamily(cell);
                byte[] qualifierName = CellUtil.cloneQualifier(cell);
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] valueArr = CellUtil.cloneValue(cell);

                if("id".equals(Bytes.toString(qualifierName)) || "age".equals(Bytes.toString(qualifierName))){
                    int value = Bytes.toInt(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }else {
                    String value = Bytes.toString(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }
            }
        }

        table.close();
        connection.close();
    }
}

4.FamilyFilter列族过滤器

查询列族名包含2的所有数据

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;

//查询列族名包含2的所有数据
public class FamilyFilterQuery {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Table table = connection.getTable(TableName.valueOf("myuser"));
        Scan scan = new Scan();

        // familyFilter来实现列族的过滤
        SubstringComparator substringComparator = new SubstringComparator("2");
        FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, substringComparator);
        scan.setFilter(familyFilter);

        //执行查询
        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] familyName = CellUtil.cloneFamily(cell);
                byte[] qualifierName = CellUtil.cloneQualifier(cell);
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] value = CellUtil.cloneValue(cell);
                System.out.println(Bytes.toString(familyName)+"\t"
                        +Bytes.toString(qualifierName)+"\t"
                        +Bytes.toString(rowkey)+"\t"
                        +Bytes.toString(value));
            }
        }

        table.close();
        connection.close();
    }
}

5.QualifierFilter列过滤器

查询列名包含name的所有数据

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;
//查询列名包含name的所有数据
public class QualifierFilterQuery {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Table table = connection.getTable(TableName.valueOf("myuser"));

        Scan scan = new Scan();

        //QualifierFilter来实现列值过滤
        SubstringComparator substringComparator = new SubstringComparator("name");
        QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, substringComparator);
        scan.setFilter(qualifierFilter);

        //执行查询
        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] familyName = CellUtil.cloneFamily(cell);
                byte[] qualifierName = CellUtil.cloneQualifier(cell);
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] value = CellUtil.cloneValue(cell);
                System.out.println(Bytes.toString(familyName)+"\t"
                        +Bytes.toString(qualifierName)+"\t"
                        +Bytes.toString(rowkey)+"\t"
                        +Bytes.toString(value));
            }
        }

        table.close();
        connection.close();
    }
}

6.ValueFilter值过滤器

查询所有数据中包含字符串"8"的数据

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;
//查询所有数据中包含8的数据
public class ValueFilterQuery {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Table table = connection.getTable(TableName.valueOf("myuser"));

        Scan scan = new Scan();

        //ValueFilter来实现列值过滤
        SubstringComparator substringComparator = new SubstringComparator("8");
        ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, substringComparator);
        scan.setFilter(valueFilter);

        //执行查询
        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] familyName = CellUtil.cloneFamily(cell);
                byte[] qualifierName = CellUtil.cloneQualifier(cell);
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] value = CellUtil.cloneValue(cell);
                System.out.println(Bytes.toString(familyName)+"\t"
                        +Bytes.toString(qualifierName)+"\t"
                        +Bytes.toString(rowkey)+"\t"
                        +Bytes.toString(value));
            }
        }

        table.close();
        connection.close();
    }
}

7.SingleColumnValueFilter单列值过滤器

查询f1 列族、name列、值为刘备的数据

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;
//查询f1 列族、name列、值为刘备的数据
//类似与 select * from myuser where name = '刘备'
public class SingleColumnValueFilterQuery {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Table table = connection.getTable(TableName.valueOf("myuser"));

        Scan scan = new Scan();

        //SingleColumnValueFilter来实现单列值过滤
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(
                "f1".getBytes(),
                "name".getBytes(),
                CompareFilter.CompareOp.EQUAL,
                "刘备".getBytes()
        );

        scan.setFilter(singleColumnValueFilter);


        //执行查询
        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] familyName = CellUtil.cloneFamily(cell);
                byte[] qualifierName = CellUtil.cloneQualifier(cell);
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] valueArr = CellUtil.cloneValue(cell);

                if("id".equals(Bytes.toString(qualifierName)) || "age".equals(Bytes.toString(qualifierName))){
                    int value = Bytes.toInt(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }else {
                    String value = Bytes.toString(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }
            }
        }

        table.close();
        connection.close();
    }
}

扩展: SingleColumnValueExcludeFilter 列值排除过滤器，可实现与列值过滤器相反的功能。类似于下面SQL:

select * from myuser where name ！= ‘刘备’

8.PrefixFilter前缀过滤器

查询rowkey前缀以 00开头的所有的数据

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;
//查询rowkey前缀以  00开头的所有的数据
public class PrefixFilterQuery {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Table table = connection.getTable(TableName.valueOf("myuser"));

        Scan scan = new Scan();

        //PrefixFilter来实现前缀过滤
        PrefixFilter prefixFilter = new PrefixFilter("00".getBytes());
        scan.setFilter(prefixFilter);

        //执行查询
        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] familyName = CellUtil.cloneFamily(cell);
                byte[] qualifierName = CellUtil.cloneQualifier(cell);
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] valueArr = CellUtil.cloneValue(cell);

                if("id".equals(Bytes.toString(qualifierName)) || "age".equals(Bytes.toString(qualifierName))){
                    int value = Bytes.toInt(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }else {
                    String value = Bytes.toString(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }
            }
        }

        table.close();
        connection.close();
    }
}

9.PageFilter分页过滤器

每页显示2个rowkey的数据，查询第3页的数据。

package cn.com.vivo.day01;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.PageFilter;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;
//每页显示2个rowkey的数据，查询第3页的数据。
public class PageFilterQuery {
    public static void main(String[] args) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Table table = connection.getTable(TableName.valueOf("myuser"));

        Scan scan = new Scan();

        int pageNum = 3;//从第三页开始查询
        int pageSize = 2;//每页显示2条rowkey的所有数据

        //分页过滤器需要我们提供从页面起始的rowkey, 我们要根据查询的页码来寻找起始的rowkey
        if(pageNum == 1){//如果查询的是第一页,可以使用""来表示第一个rowkey
            //设置一次向后扫描多少条数据,即设置pageSize
            scan.setMaxResultSize(pageSize);
            scan.setStartRow("".getBytes());//表示从第一个rowkey开始查询
        }else {
            //我们要想办法获取第三页的起始rowkey是什么
            String startRow = "";
            int tempPageSize = (pageNum - 1) * pageSize +1;//注意加1后的到的才是第3页的起始rowkey
            scan.setMaxResultSize(tempPageSize);
            PageFilter pageFilter = new PageFilter(tempPageSize);
            scan.setFilter(pageFilter);
            ResultScanner scanner = table.getScanner(scan);
            //遍历的最后一条数据中有我们要找的第三页的startRow
            for (Result result : scanner) {
                List<Cell> cells = result.listCells();
                int startRowIndex = cells.size() - 1;
                byte[] startRowArr = CellUtil.cloneRow(cells.get(startRowIndex));
                startRow = new String(startRowArr);
            }
            scan.setMaxResultSize(pageSize);
            scan.setStartRow(startRow.getBytes());
        }
        PageFilter filter = new PageFilter(pageSize);
        scan.setFilter(filter);
        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] familyName = CellUtil.cloneFamily(cell);
                byte[] qualifierName = CellUtil.cloneQualifier(cell);
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] valueArr = CellUtil.cloneValue(cell);

                if("id".equals(Bytes.toString(qualifierName)) || "age".equals(Bytes.toString(qualifierName))){
                    int value = Bytes.toInt(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }else {
                    String value = Bytes.toString(valueArr);
                    System.out.println(Bytes.toString(familyName)+"\t"
                            +Bytes.toString(qualifierName)+"\t"
                            +Bytes.toString(rowkey)+"\t"
                            +value);
                }
            }
        }

    }
}

你可能感兴趣的:(HBase)

nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
浅谈MapReduce Android路上的人 Hadoop 分布式计算 mapreduce 分布式框架 hadoop
从今天开始，本人将会开始对另一项技术的学习，就是当下炙手可热的Hadoop分布式就算技术。目前国内外的诸多公司因为业务发展的需要，都纷纷用了此平台。国内的比如BAT啦，国外的在这方面走的更加的前面，就不一一列举了。但是Hadoop作为Apache的一个开源项目，在下面有非常多的子项目，比如HDFS，HBase,Hive，Pig,等等，要先彻底学习整个Hadoop，仅仅凭借一个的力量，是远远不够的。
hbase介绍 CrazyL- 云计算+大数据 hbase
hbase是一个分布式的、多版本的、面向列的开源数据库hbase利用hadoophdfs作为其文件存储系统，提供高可靠性、高性能、列存储、可伸缩、实时读写、适用于非结构化数据存储的数据库系统hbase利用hadoopmapreduce来处理hbase、中的海量数据hbase利用zookeeper作为分布式系统服务特点：数据量大：一个表可以有上亿行，上百万列（列多时，插入变慢）面向列：面向列（族）的
Apache HBase基础（基本概述，物理架构，逻辑架构，数据管理，架构特点，HBase Shell） May--J--Oldhu HBase HBase shell hbase物理架构 hbase逻辑架构 hbase
NoSQL综述及ApacheHBase基础一.HBase1.HBase概述2.HBase发展历史3.HBase应用场景3.1增量数据-时间序列数据3.2信息交换-消息传递3.3内容服务-Web后端应用程序3.4HBase应用场景示例4.ApacheHBase生态圈5.HBase物理架构5.1HMaster5.2RegionServer5.3Region和Table6.HBase逻辑架构-Row7.
HBase（一）——HBase介绍 weixin_30595035 大数据数据库数据结构与算法
HBase介绍1、关系型数据库与非关系型数据库（1）关系型数据库关系型数据库最典型的数据机构是表，由二维表及其之间的联系所组成的一个数据组织优点：1、易于维护：都是使用表结构，格式一致2、使用方便：SQL语言通用，可用于复杂查询3、复杂操作：支持SQL，可用于一个表以及多个表之间非常复杂的查询缺点：1、读写性能比较差，尤其是海量数据的高效率读写2、固定的表结构，灵活度稍欠3、高并发读写需求，传统关
HBase介绍 mingyu1016 数据库
概述HBase是一个分布式的、面向列的开源数据库,源于google的一篇论文《bigtable：一个结构化数据的分布式存储系统》。HBase是GoogleBigtable的开源实现，它利用HadoopHDFS作为其文件存储系统，利用HadoopMapReduce来处理HBase中的海量数据，利用Zookeeper作为协同服务。HBase的表结构HBase以表的形式存储数据。表有行和列组成。列划分为
Hbase - 迁移数据[导出,导入] kikiki5
>有没有这样一样情况，把一个集群中的某个表导到另一个群集中，或者hbase的表结构发生了更改，但是数据还要，比如预分区没做，导致某台RegionServer很吃紧，Hbase的导出导出都可以很快的完成这些操作。![](https://upload-images.jianshu.io/upload_images/9028759-4fb9aa8ca3777969.png?imageMogr2/auto
通过DBeaver连接Phoenix操作hbase 不想做咸鱼的王富贵
通过DBeaver连接Phoenix操作hbase前言本文介绍常用一种通用数据库工具Dbeaver，DBeaver可通过JDBC连接到数据库，可以支持几乎所有的数据库产品，包括：MySQL、PostgreSQL、MariaDB、SQLite、Oracle、Db2、SQLServer、Sybase、MSAccess、Teradata、Firebird、Derby等等。商业版本更是可以支持各种NoSQ
Hbase - kerberos认证异常 kikiki2
之前怎么认证都认证不上，问题找了好了，发现它的异常跟实际操作根本就对不上，死马当活马医，当时也是瞎改才好的，给大家伙记录记录。KrbException:ServernotfoundinKerberosdatabase(7)-LOOKING_UP_SERVER>>>KdcAccessibility:removestorm1.starsriver.cnatsun.security.krb5.KrbTg
kvm 虚拟机命令行虚拟机操作、制作快照和恢复快照以及工作常用总结西京刀客云原生(Cloud Native)云计算虚拟化 Linux C/C++服务器 linux kvm
文章目录kvm虚拟机命令行虚拟机操作、制作快照和恢复快照一、kvm虚拟机命令行虚拟机操作(创建和删除)查看虚拟机virt-install创建一个虚拟机关闭虚拟机重启虚拟机销毁虚拟机二、kvm制作快照和恢复快照**创建快照**工作常见问题创建快照报错：：internalsnapshotsofaVMwithpflashbasedfirmwarearenotsupported检查虚拟机是否包含pflas
hadoop 0.22.0 部署笔记 weixin_33701564 大数据 java 运维
为什么80%的码农都做不了架构师？>>>因为需要使用hbase，所以开始对hbase进行学习。hbase是部署在hadoop平台上的NOSql数据库，因此在部署hbase之前需要先部署hadoop。环境：redhat5、hadoop-0.22.0.tar.gz、jdk-6u13-linux-i586.zipip192.168.1.128hostname：localhost.localdomain（
实时数仓之实时数仓架构(Hudi)(1)，2024年最新熬夜整理华为最新大数据开发笔试题 2401_84181221 程序员架构大数据
+Hudi：湖仓一体数据管理框架，用来管理模型数据，包括ODS/DWD/DWS/DIM/ADS等；+Doris：OLAP引擎，同步数仓结果模型，对外提供数据服务支持；+Hbase：用来存储维表信息，维表数据来源一部分有Flink加工实时写入，另一部分是从Spark任务生产，其主要作用用来支持FlinkETL处理过程中的LookupJoin功能。这里选用Hbase原因主要因为Table的HbaseC
HBase 源码阅读（一） Such Devotion hbase 数据库大数据
1.HMastermain方法在上文中MacosM1IDEA本地调试HBase2.2.2，我们使用HMaster的主函数使用"start"作为入参，启动了HMaster进程这里我们再深入了解下HMaster的运行机理publicstaticvoidmain(String[]args){LOG.info("STARTINGservice"+HMaster.class.getSimpleName())
HBase 源码阅读（四）HBase 关于LSM Tree的实现- MemStore Such Devotion hbase lsm-tree 数据库
4.MemStore接口Memstore的函数不能并行的被调用。调用者需要持有读写锁，这个的实现在HStore中我们放弃对MemStore中的诸多函数进行查看直接看MemStore的实现类AbstractMemStoreCompactingMemStoreDefaultMemStore4.1三个实现类的使用场景1.AbstractMemStore角色:基础抽象类作用:AbstractMemStor
大数据（Hbase简单示例） BL小二 hbase 大数据 hadoop
importorg.apache.hadoop.conf.Configuration;importorg.apache.hadoop.hbase.HBaseConfiguration;importorg.apache.hadoop.hbase.TableName;importorg.apache.hadoop.hbase.client.*;importorg.apache.hadoop.hbase
Hbase的简单使用示例傲雪凌霜，松柏长青后端大数据 hbase 数据库大数据
HBase是基于HadoopHDFS构建的分布式、列式存储的NoSQL数据库，适用于存储和检索超大规模的非结构化数据。它支持随机读写，并且能够处理PB级数据。HBase通常用于实时数据存取场景，与Hadoop生态紧密集成。使用HBase的Java示例前置条件HBase集群：确保HBase集群已经安装并启动。如果没有，你可以通过本地伪分布模式或Docker来运行HBase。Hadoop配置：HBas
快手HBase在千亿级用户特征数据分析中的应用与实践王知无
声明：本文的原文是来自Hbase技术社区的一个PPT分享，个人做了整理和提炼。大家注意哈，这种会议PPT类的东西能学习到的更多的是技术方案和他人在实践过程中的经验。希望对大家有帮助。背景快手每天产生数百亿用户特征数据，分析师需要在跨30-90天的数千亿特征数据中，任意选择多维度组合(如:城市=北京&性别=男)，秒级分析用户行为。针对这一需求,快手基于HBase自主研发了支持bitmap转化、存储、
ClickHouse与其他数据库的对比九州Pro ClickHouse 数据库 clickhouse 数据仓库大数据 sql
目录1与传统关系型数据库的对比1.1性能差异1.2数据模型差异1.3适用场景差异2与其他列式存储数据库的对比2.1ApacheCassandra2.2HBase3与分布式数据库的对比3.1GoogleBigQuery3.2AmazonRedshift3.3Snowflake4ClickHouse的缺点5ClickHouse的其他优点1与传统关系型数据库的对比1.1性能差异ClickHouse是一种
Hbase、hive以及ClickHouse的介绍和区别？ damokelisijian866 hbase hive clickhouse
一、Hbase介绍：HBase是一个分布式的、面向列的开源数据库，由ApacheSoftwareFoundation开发，是Hadoop生态系统中的一个重要组件。HBase的设计灵感来源于Google的Bigtable论文，它通过提供类似于Bigtable的能力，在Hadoop之上构建了一个高可靠性、高性能、面向列、可伸缩的分布式存储系统。HBase主要用于存储大量结构化数据，并支持随机读写访问，
Hive和Hbase的区别傲雪凌霜，松柏长青大数据后端 hive hbase hadoop
Hive和HBase都是Hadoop生态系统中的重要组件，它们都能处理大规模数据，但各自有不同的适用场景和设计理念。以下是两者的主要区别：1.数据模型Hive：Hive类似于传统的关系型数据库(RDBMS)，以表格形式存储数据。它使用SQL-like语言HiveQL来查询和处理数据，数据通常是结构化或半结构化的。HBase：HBase是一个NoSQL数据库，基于Google的BigTable模型。
HBase 傲雪凌霜，松柏长青大数据后端 hbase 数据库大数据
ApacheHBase是一个基于Hadoop分布式文件系统（HDFS）构建的分布式、面向列的NoSQL数据库，主要用于处理大规模、稀疏的表结构数据。HBase的设计灵感来自Google的Bigtable，能够在海量数据中提供快速的随机读写操作，适合需要低延迟和高吞吐量的应用场景。HBase核心概念表（Table）：HBase的数据存储在表中，与传统的关系型数据库不同，HBase的表是面向列族（Co
大数据面试题：说下为什么要使用Hive？Hive的优缺点？Hive的作用是什么？蓦然_ 大数据面试题 hive 大数据开发面试题大数据面试
1、为什么要使用Hive？Hive是Hadoop生态系统中比不可少的一个工具，它提供了一种SQL(结构化查询语言)方言，可以查询存储在Hadoop分布式文件系统（HDFS）中的数据或其他和Hadoop集成的文件系统，如MapR-FS、Amazon的S3和像HBase（Hadoop数据仓库）和Cassandra这样的数据库中的数据。大多数数据仓库应用程序都是使用关系数据库进行实现的，并使用SQL作为
Hadoop组件静听山水 Hadoop hadoop
这张图片展示了Hadoop生态系统的一些主要组件。Hadoop是一个开源的大数据处理框架，由Apache基金会维护。以下是每个组件的简短介绍：HBase：一个分布式、面向列的NoSQL数据库，基于GoogleBigTable的设计理念构建。HBase提供了实时读写访问大量结构化和半结构化数据的能力，非常适合大规模数据存储。Pig：一种高级数据流语言和执行引擎，用于编写MapReduce任务。Pig
Hbase BulkLoad用法 kikiki2
要导入大量数据，Hbase的BulkLoad是必不可少的，在导入历史数据的时候，我们一般会选择使用BulkLoad方式，我们还可以借助Spark的计算能力将数据快速地导入。使用方法导入依赖包compilegroup:'org.apache.spark',name:'spark-sql_2.11',version:'2.3.1.3.0.0.0-1634'compilegroup:'org.apach
EMR组件部署指南 ivwdcwso 运维 EMR 大数据开源运维
EMR(ElasticMapReduce)是一个大数据处理和分析平台,包含了多个开源组件。本文将详细介绍如何部署EMR的主要组件,包括:JDK1.8ElasticsearchKafkaFlinkZookeeperHBaseHadoopPhoenixScalaSparkHive准备工作所有操作都在/data目录下进行。首先安装JDK1.8:yuminstalljava-1.8.0-openjdk部署
Sublime text3+python3配置及插件安装 raysonfang
作者：方雷个人博客：http://blog.chargingbunk.cn/微信公众号：rayson_666(Rayson开发分享)个人专研技术方向：微服务方向：springboot,springCloud,Dubbo分布式/高并发：分布式锁，消息队列RabbitMQ大数据处理：Hadoop,spark,HBase等python方向：pythonweb开发一，前言在网上搜索了一些Python开发的
Spring Data：JPA与Querydsl 光图强 java
JPAJPA是java的一个规范，用于在java对象和数据库之间保存数据，充当面向对象领域模型和数据库之间的桥梁。它使用Hibernate、TopLink、IBatis等ORM框架实现持久性规范。SpringDataSpringData是Spring的一个子项目，用于简化数据库访问，支持NoSql数据和关系数据库。支持的NoSql数据库包括：Mongodb、redis、Hbase、Neo4j。Sp
HBase 源码阅读（二） Such Devotion hbase 数据库大数据
衔接在上一篇文章中，HMasterCommandLine类中在startMaster();方法中//这里除了启动HMaster之外，还启动一个HRegionServerLocalHBaseClustercluster=newLocalHBaseCluster(conf,mastersCount,regionServersCount,LocalHMaster.class,HRegionServer.
大数据技术之HBase 与 Hive 集成(7) 大数据深度洞察 Hbase 大数据 hbase hive
目录使用场景HBase与Hive集成使用1）案例一2）案例二使用场景如果大量的数据已经存放在HBase上面，并且需要对已经存在的数据进行数据分析处理，那么Phoenix并不适合做特别复杂的SQL处理。此时，可以使用Hive映射HBase的表格，之后通过编写HQL进行分析处理。HBase与Hive集成使用Hive安装https://blog.csdn.net/qq_45115959/article/
【HBase之轨迹】（1）使用 Docker 搭建 HBase 集群寒冰小澈IceClean 【大数据之轨迹】【Docker之轨迹】笔记 hbase docker hadoop
——目录——0.前置准备1.下载安装2.配置（重）3.启动与关闭4.搭建高可用HBase前言（贫穷使我见多识广）前边经历了Hadoop，Zookeeper，Kafka，他们的集群，全都是使用Docker搭建的一开始的我认为，把容器看成是一台台独立的服务器就好啦也确实是这样，但端口映射问题，让我一路以来磕碰了太多太多，直到现在的HBase，更是将Docker集群所附带的挑战性，放大到了极致（目前是如
java杨辉三角 3213213333332132 java基础
package com.algorithm; /** * @Description 杨辉三角 * @author FuJianyong * 2015-1-22上午10:10:59 */ public class YangHui { public static void main(String[] args) { //初始化二维数组长度 int[][] y
《大话重构》之大布局的辛酸历史白糖_ 重构
《大话重构》中提到“大布局你伤不起”，如果企图重构一个陈旧的大型系统是有非常大的风险，重构不是想象中那么简单。我目前所在公司正好对产品做了一次“大布局重构”，下面我就分享这个“大布局”项目经验给大家。背景公司专注于企业级管理产品软件，企业有大中小之分，在2000年初公司用JSP/Servlet开发了一套针对中
电驴链接在线视频播放源码 dubinwei 源码电驴播放器视频 ed2k
本项目是个搜索电驴（ed2k）链接的应用,借助于磁力视频播放器（官网： http://loveandroid.duapp.com/ 开放平台），可以实现在线播放视频，也可以用迅雷或者其他下载工具下载。项目源码： http://git.oschina.net/svo/Emule,动态更新。也可从附件中下载。项目源码依赖于两个库项目，库项目一链接： http://git.oschina.
Javascript中函数的toString()方法周凡杨 JavaScript js toString function object
简述 The toString() method returns a string representing the source code of the function. 简译之，Javascript的toString()方法返回一个代表函数源代码的字符串。句法 function.
struts处理自定义异常 g21121 struts
很多时候我们会用到自定义异常来表示特定的错误情况，自定义异常比较简单，只要分清是运行时异常还是非运行时异常即可，运行时异常不需要捕获，继承自RuntimeException，是由容器自己抛出，例如空指针异常。非运行时异常继承自Exception，在抛出后需要捕获，例如文件未找到异常。此处我们用的是非运行时异常，首先定义一个异常LoginException: /** * 类描述：登录相
Linux中find常见用法示例 510888780 linux
Linux中find常见用法示例 ·find path -option [ -print ] [ -exec -ok command ] {} \; find命令的参数；
SpringMVC的各种参数绑定方式 Harry642 springMVC 绑定表单
1. 基本数据类型(以int为例，其他类似)： Controller代码： @RequestMapping("saysth.do") public void test(int count) { } 表单代码： <form action="saysth.do" method="post&q
Java 获取Oracle ROWID aijuans java oracle
A ROWID is an identification tag unique for each row of an Oracle Database table. The ROWID can be thought of as a virtual column, containing the ID for each row. The oracle.sql.ROWID class i
java获取方法的参数名 antlove java jdk parameter method reflect
reflect.ClassInformationUtil.java package reflect; import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.Modifier; import javassist.bytecode.CodeAtt
JAVA正则表达式匹配查找替换提取操作百合不是茶 java 正则表达式替换提取查找
正则表达式的查找;主要是用到String类中的split(); String str; str.split();方法中传入按照什么规则截取,返回一个String数组常见的截取规则: str.split("\\.")按照.来截取 str.
Java中equals()与hashCode()方法详解 bijian1013 java set equals()hashCode()
一.equals()方法详解 equals()方法在object类中定义如下： public boolean equals(Object obj) { return (this == obj); } 很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们知道，String 、Math、I
精通Oracle10编程SQL(4)使用SQL语句 bijian1013 oracle 数据库 plsql
--工资级别表 create table SALGRADE ( GRADE NUMBER(10), LOSAL NUMBER(10,2), HISAL NUMBER(10,2) ) insert into SALGRADE values(1,0,100); insert into SALGRADE values(2,100,200); inser
【Nginx二】Nginx作为静态文件HTTP服务器 bit1129 HTTP服务器
Nginx作为静态文件HTTP服务器在本地系统中创建/data/www目录，存放html文件(包括index.html) 创建/data/images目录，存放imags图片在主配置文件中添加http指令 http { server { listen 80; server_name
kafka获得最新partition offset blackproof kafka partition offset 最新
kafka获得partition下标，需要用到kafka的simpleconsumer import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.List; import java.
centos 7安装docker两种方式 ronin47
第一种是采用yum 方式 yum install -y docker
java-60-在O(1)时间删除链表结点 bylijinnan java
public class DeleteNode_O1_Time { /** * Q 60 在O(1)时间删除链表结点 * 给定链表的头指针和一个结点指针(!!)，在O(1)时间删除该结点 * * Assume the list is: * head->...->nodeToDelete->mNode->nNode->..
nginx利用proxy_cache来缓存文件 cfyme cache
user zhangy users; worker_processes 10; error_log /var/vlogs/nginx_error.log crit; pid /var/vlogs/nginx.pid; #Specifies the value for ma
[JWFD开源工作流]JWFD嵌入式语法分析器负号的使用问题 comsci 嵌入式
假如我们需要用JWFD的语法分析模块定义一个带负号的方程式，直接在方程式之前添加负号是不正确的，而必须这样做： string str01 = "a=3.14;b=2.71;c=0;c-((a*a)+(b*b))" 定义一个0整数c,然后用这个整数c去
如何集成支付宝官方文档 dai_lm android
官方文档下载地址 https://b.alipay.com/order/productDetail.htm?productId=2012120700377310&tabId=4#ps-tabinfo-hash 集成的必要条件 1. 需要有自己的Server接收支付宝的消息 2. 需要先制作app，然后提交支付宝审核，通过后才能集成调试的时候估计会真的扣款，请注意
应该在什么时候使用Hadoop datamachine hadoop
原帖地址：http://blog.chinaunix.net/uid-301743-id-3925358.html 存档，某些观点与我不谋而合，过度技术化不可取，且hadoop并非万能。 --------------------------------------------万能的分割线-------------------------------- 有人问我，“你在大数据和Hado
在GridView中对于有外键的字段使用关联模型进行搜索和排序 dcj3sjt126com yii
在GridView中使用关联模型进行搜索和排序首先我们有两个模型它们直接有关联: class Author extends CActiveRecord { ... } class Post extends CActiveRecord { ... function relations() { return array( '
使用NSString 的格式化大全 dcj3sjt126com Objective-C
格式定义The format specifiers supported by the NSString formatting methods and CFString formatting functions follow the IEEE printf specification; the specifiers are summarized in Table 1. Note that you c
使用activeX插件对象object滚动有重影蕃薯耀 activeX插件滚动有重影
使用activeX插件对象object滚动有重影 <object style="width:0;" id="abc" classid="CLSID:D3E3970F-2927-9680-BBB4-5D0889909DF6" codebase="activex/OAX339.CAB#
SpringMVC4零配置 hanqunfeng springmvc4
基于Servlet3.0规范和SpringMVC4注解式配置方式，实现零xml配置，弄了个小demo，供交流讨论。项目说明如下： 1.db.sql是项目中用到的表，数据库使用的是oracle11g 2.该项目使用mvn进行管理，私服为自搭建nexus,项目只用到一个第三方 jar，就是oracle的驱动； 3.默认项目为零配置启动，如果需要更改启动方式，请
《开源框架那点事儿16》：缓存相关代码的演变 j2eetop 开源框架
问题引入上次我参与某个大型项目的优化工作，由于系统要求有比较高的TPS，因此就免不了要使用缓冲。该项目中用的缓冲比较多，有MemCache，有Redis，有的还需要提供二级缓冲，也就是说应用服务器这层也可以设置一些缓冲。当然去看相关实现代代码的时候，大致是下面的样子。 [java] view plain copy print ? public vo
AngularJS浅析 kvhur JavaScript
概念 AngularJS is a structural framework for dynamic web apps. 了解更多详情请见原文链接：http://www.gbtags.com/gb/share/5726.htm Directive 扩展html，给html添加声明语句，以便实现自己的需求。对于页面中html元素以ng为前缀的属性名称，ng是angular的命名空间
架构师之jdk的bug排查(一)---------------split的点号陷阱 nannan408 split
1.前言. jdk1.6的lang包的split方法是有bug的,它不能有效识别A.b.c这种类型,导致截取长度始终是0.而对于其他字符,则无此问题.不知道官方有没有修复这个bug. 2.代码 String[] paths = "object.object2.prop11".split("'"); System.ou
如何对10亿数据量级的mongoDB作高效的全表扫描 quentinXXZ mongodb
本文链接: http://quentinXXZ.iteye.com/blog/2149440 一、正常情况下，不应该有这种需求首先，大家应该有个概念，标题中的这个问题，在大多情况下是一个伪命题，不应该被提出来。要知道，对于一般较大数据量的数据库，全表查询，这种操作一般情况下是不应该出现的，在做正常查询的时候，如果是范围查询，你至少应该要加上limit。说一下，
C语言算法之水仙花数 qiufeihu c 算法
/** * 水仙花数 */ #include <stdio.h> #define N 10 int main() { int x,y,z; for(x=1;x<=N;x++) for(y=0;y<=N;y++) for(z=0;z<=N;z++) if(x*100+y*10+z == x*x*x
JSP指令 wyzuomumu jsp
jsp指令的一般语法格式： <%@ 指令名属性 =”值 ” %> 常用的三种指令： page,include,taglib page指令语法形式： <%@ page 属性 1=”值 1” 属性 2=”值 2”%> include指令语法形式： <%@include file=”relative url”%> (jsp可以通过 include