Week09_day05(Java API操作Hbase)

package com.wyh.HbaseAPI;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class Demo1Junit {

    //定义成员变量，保证每个test都可以访问到
    private Configuration conf;
    private HConnection conn;
    private HBaseAdmin hAdmin;

    /**
     *
     * 建立与Hbase的连接，设置成before,使下面的Test执行之前都先执行这个
     */
    @Before
    public void connect(){
        try {
            //获取Configuration，读取Hadoop的配置文件
            conf = new Configuration();

            //获取zookeeper的配置
            conf.set("hbase.zookeeper.quorum","master:2181,node1:2181,node2:2181");
            //获取连接，可以通过这个连接获取到表
            conn = HConnectionManager.createConnection(conf);

            //获取到HMaster,因为HMaster是对表进行DDL操作的
            hAdmin = new HBaseAdmin(conf);

            System.out.println("建立连接成功。。。"+conn);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     *
     * 在Hbase中创建表
     */
    @Test
    public void createTable(){
        try {
            //使用HTableDescriptor对象创建一个表对象
            HTableDescriptor students = new HTableDescriptor("students");

            //使用HColumnDescriptor对象创建一个列簇
            HColumnDescriptor info = new HColumnDescriptor("info");
            String name = Bytes.toString(students.getName());

            //将列簇加入到表中
            students.addFamily(info);
            System.out.println(name+"表 创建成功。。");

            //使用HMaster对象来创建该表
            hAdmin.createTable(students);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 删除Hbase中的表，在Hbase中并没有真正将表进行删除，内部是将其打上一个标记，上查询不到，HMaster定时清理过期文件
     */
    @Test
    public void deleteTable(){
        try {
            //使用HMaster对象来读表进行操作

            //判断是否有该表存在
            if(hAdmin.tableExists("student")){

                //在删除表之前，必须将其表设置成不可用，否则报错
                hAdmin.disableTable("student");

                //调用delete方法删除表
                hAdmin.deleteTable("student");

                //友情提示
                System.out.println(conn.getTable("student").getName()+"表 成功被删除。。");

            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 往创建的表中插入一条数据
     */
    @Test
    public void putData(){
        try {
            //获取到表的实例
            HTableInterface student = conn.getTable("student");

            //创建Put实例,给一个行键
            Put put = new Put("001".getBytes());

            //将这个行键的值，添加列簇，列名，具体的值
            put.add("info".getBytes(),"name".getBytes(),"zhangsan".getBytes());

            //调用put方法添加一行数据
            student.put(put);

            System.out.println(student.getName()+"表 成功插入数据。。");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * get方法获取到表的数据
     */
    @Test
    public void getData(){
        try {
            //获取到表的实例
            HTableInterface student = conn.getTable("student");

            //获取get实例 添加指定的rowkey
            Get get = new Get("001".getBytes());

            //获取到行键信息
            String rowkey = Bytes.toString(get.getRow());

            //调用get方法，返回一个结果集
            Result result = student.get(get);
            //调用getValue()方法获取到一个字节数组的一个结果集，再利用Bytes工具类的toString()方法去将其转换成字符串
            String s = Bytes.toString(result.getValue("info".getBytes(), "name".getBytes()));

            //输出
            System.out.println(rowkey+"\t"+s);
            System.out.println("查询结束。。。");


        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 一次性插入多条数据
     */
    @Test
    public void putAll(){
        //创建一个ArrayList存Put
        ArrayList<Put> puts = new ArrayList<Put>();

        try {
            //获取表实例
            HTableInterface students = conn.getTable("students");

            //读取数据
            BufferedReader br = new BufferedReader(new FileReader("D:\\shujia\\shujia006\\hadoop\\src\\data\\students.txt"));
            String line;
            while ((line = br.readLine())!=null){
                String[] split = line.split(",");
                String id = split[0];
                String name = split[1];
                String age = split[2];
                String gender = split[3];
                String clazz = split[4];

                //为每一行数据根据行键创建一个新的Put
                Put put = new Put(id.getBytes());

                //插入每一列
                put.add("info".getBytes(),"name".getBytes(),name.getBytes());
                put.add("info".getBytes(),"age".getBytes(),age.getBytes());
                put.add("info".getBytes(),"gender".getBytes(),gender.getBytes());
                put.add("info".getBytes(),"clazz".getBytes(),clazz.getBytes());

                //将这个put对象加入到集合中去
                puts.add(put);
            }

            //使用put(List<Put> list)方法添加数据
            students.put(puts);

            System.out.println("students.txt 数据插入完毕。。。");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 查询结果，两种方法进行查询
     */
    @Test
    public void getdata(){
        try {
            //获取到表的实例
            HTableInterface students = conn.getTable("students");

            //创建一个Get实例 穿一个行键
            Get get = new Get("1500100014".getBytes());
            String id = Bytes.toString(get.getRow());

            //获取结果集
            Result result = students.get(get);

            /**
             * 查询方法一：已经知道列的数量和列名
             */
            String name = Bytes.toString(result.getValue("info".getBytes(), "name".getBytes()));
            String age = Bytes.toString(result.getValue("info".getBytes(), "age".getBytes()));
            String gender = Bytes.toString(result.getValue("info".getBytes(), "gender".getBytes()));
            String clazz = Bytes.toString(result.getValue("info".getBytes(), "clazz".getBytes()));

            System.out.println(id+"\t"+name+"\t"+age+"\t"+gender+"\t"+clazz);


            /**
             * 查询方法二：不知道列的数量和列名
             * @deprecated as of 0.96, use {@link CellUtil#cloneValue(Cell)}
             */

            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                String s = Bytes.toString(CellUtil.cloneValue(cell));
                System.out.print(s);
                System.out.print("\t");
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * scan 查询多条数据
     *
     */
    @Test
    public void scanAll(){
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            //创建scan实例
            Scan scan = new Scan();

            //定义查询的范围 含头不含尾
            scan.setStartRow("1500100014".getBytes());
            scan.setStopRow("1500100085".getBytes());


            //将设置好的scan加入进去，返回一个结果的迭代器
            ResultScanner scanner = students.getScanner(scan);

            //因为next()指向的是下一个索引，所以我们类似读取数据的做法去遍历取值
            Result result;
            while ((result=scanner.next())!=null){

                //调用之前写好的方法
                print(result);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }




    /**
     *
     *
     * scan扫描查询有需求的数据，比较器和过滤器
     *
     * 通过运用4种比较器，过滤出姓于，年纪大于23岁，性别为女，且是理科的学生。
     *
     * 正则比较器 RegexStringComparator
     * 包含比较器 SubstringComparator
     * 二进制前缀比较器 BinaryPrefixComparator
     * 二进制比较器 BinaryComparator
     *
     */
    @Test
    public void FilterData(){
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            /**
             * 第一个过滤器，过滤出班级是理科开头的
             */
            //创建比较器 正则比较器 RegexStringComparator
            RegexStringComparator regexStringComparator = new RegexStringComparator("理科.");

            //创建过滤器 列过滤器 SingleColumnValueFilter
            SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter("info".getBytes(),"clazz".getBytes(),
                    CompareFilter.CompareOp.EQUAL,regexStringComparator);

            /**
             * 第二个过滤器，过滤出性别是女生的
             */
            //创建比较器 包含比较器 SubStringComparator
            SubstringComparator gender = new SubstringComparator("女");

            //创建过滤器 列过滤器 SingleColumnValueFilter
            SingleColumnValueFilter singleColumnValueFilter1 = new SingleColumnValueFilter("info".getBytes(), "gender".getBytes(),
                    CompareFilter.CompareOp.EQUAL, gender);

            /**
             * 第三个过滤器，过滤出年纪大于23岁的
             */
            //创建比较器 二进制比较器 BinaryComparator
            BinaryComparator binaryComparator = new BinaryComparator("23".getBytes());

            //创建过滤器 列过滤器 SingleColumnValueFilter
            SingleColumnValueFilter singleColumnValueFilter2 = new SingleColumnValueFilter("info".getBytes(), "age".getBytes(),
                    CompareFilter.CompareOp.GREATER_OR_EQUAL, binaryComparator);

            /**
             * 第四个过滤器，过滤出姓于的
             */
            //创建比较器 二进制前缀比较器 BinaryPrefixComparator
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("于".getBytes());

            //创建过滤器 列过滤器 SingleColumnValueFilter
            SingleColumnValueFilter singleColumnValueFilter3 = new SingleColumnValueFilter("info".getBytes(), "name".getBytes(),
                    CompareFilter.CompareOp.EQUAL, binaryPrefixComparator);


            //要想实现多个需求，就添加多个过滤条件
            //创建一个过滤器列表,可以添加多个过滤器
            FilterList filterList = new FilterList();
            filterList.addFilter(singleColumnValueFilter);
            filterList.addFilter(singleColumnValueFilter1);
            filterList.addFilter(singleColumnValueFilter2);
            filterList.addFilter(singleColumnValueFilter3);

            //创建scan实例
            Scan scan = new Scan();

            //将过滤器添加进去
            scan.setFilter(filterList);


            //通过表的实例获取结果迭代器
            ResultScanner scanner = students.getScanner(scan);

            Result result = null;
            while ((result = scanner.next())!=null){
                print(result);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 行键过滤器  RowFilter 使用 startRow/stopRow 方式比较好
     *
     */
    @Test
    public void rowFilter(){
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");


            /**
             * 使用行键比较器，过滤出学号是以15001001开头的学生 过滤的对象是rowkey
             */
            //创建filter实例
            //创建比较器 使用二进制前缀比较器 BinaryPrefixComparator
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("15001001".getBytes());

            //创建过滤器 行键比较器 RowFilter()
            RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL, binaryPrefixComparator);

            /**
             * 使用二进制前缀比较器过滤出文科的
             */
            //创建比较器 二进制前缀比较器
            BinaryPrefixComparator binaryPrefixComparator1 = new BinaryPrefixComparator("文科".getBytes());

            //创建过滤器
            SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter("info".getBytes(), "clazz".getBytes(),
                    CompareFilter.CompareOp.EQUAL, binaryPrefixComparator1);


            //创建一个过滤器集合
            FilterList filterList = new FilterList();
            filterList.addFilter(rowFilter);
            filterList.addFilter(singleColumnValueFilter);

            //创建scan实例
            Scan scan = new Scan();
            scan.setFilter(filterList);

            ResultScanner scanner = students.getScanner(scan);
            Result result = null;
            while ((result=scanner.next())!=null){
                print(result);
            }


        } catch (IOException e) {
            e.printStackTrace();
        }


    }


    /**
     * 关闭连接
     */
    @After
    public void close(){
        if(conn!=null){
            try {
                conn.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

            System.out.println("conn连接已经关闭。。");
        }

        if(hAdmin!=null){
            try {
                hAdmin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("hAdmin已经关闭。。");

        }
    }




    /**
     * 编写一个方法，实现调用实现显示查询结果
     */
    public static void print(Result result){
        String id = Bytes.toString(result.getRow());
        String name = Bytes.toString(result.getValue("info".getBytes(), "name".getBytes()));
        String age = Bytes.toString(result.getValue("info".getBytes(), "age".getBytes()));
        String gender = Bytes.toString(result.getValue("info".getBytes(), "gender".getBytes()));
        String clazz = Bytes.toString(result.getValue("info".getBytes(), "clazz".getBytes()));
        System.out.println(id+"\t"+name+"\t"+age+"\t"+gender+"\t"+clazz);
    }


}