• java操作HBase

    创建一个学生信息表，用来存储学生的姓名（姓名作为行键，且假设姓名不会重复）以及考试成绩，其中考试成绩（score）是一个列族，存储了各个科目的考试成绩。然后向student中添加数据

    1、HBase依赖

    2. 	org.apache.hbase
    3. 	hbase-server
    4. 	1.4.13
    7. 	org.apache.hbase
    8. 	hbase-client
    9. 	1.4.13

    2、HBase数据源

    1. package com.example.demo.config;
    2.  
    3. import com.example.demo.service.ICodeService;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.boot.ApplicationArguments;
    6. import org.springframework.boot.ApplicationRunner;
    7. import org.springframework.core.annotation.Order;
    8. import org.springframework.stereotype.Component;
    9.  
    10. import java.util.HashMap;
    11. import java.util.List;
    12. import java.util.Map;
    13.  
    14. @Component
    15. @Order(1) 
    16. public class NmsHBaseSource implements ApplicationRunner {
    17.  
    18. 	// 管理HBase的配置信息
    19.     public static Configuration conf;
    20. 	// 管理HBase的连接
    21.     public static Connection conn;
    22. 	// 管理HBase数据库的连接
    23.     public static Admin admin;
    24.  
    25.     @Override
    26.     public void run(ApplicationArguments args) throws Exception {
    27. 		conf = HBaseConfiguration.create();
    28.         System.setProperty("HADOOP_USER_NAME", "hadoop");
    29.         conf.set("HADOOP_USER_NAME", "hadoop");
    30.         conf.set("hbase.root.dir", "hdfs://master:9000/hbase");
    31.         conf.set("hbase.zookeeper.quorum", "master");//配置Zookeeper的ip地址
    32.         conf.set("hbase.zookeeper.property.clientPort", "2181");//配置zookeeper的端口
    33.  
    34.         conn = ConnectionFactory.createConnection(conf);
    35.         admin = conn.getAdmin();
    36.     }
    37. 	
    38. 	 /**
    39.      * 关闭所有连接
    40.      *
    41.      * @throws IOException 可能出现的异常
    42.      */
    43.     public static void close() throws IOException {
    44.         if (admin != null)
    45.             admin.close();
    46.         if (conn != null)
    47.             conn.close();
    48.     }
    49. 	
    50. 	/**
    51.      * 创建表
    52.      * @param myTableName 表名
    53.      * @param colFamily 列族名的数组
    54.      * @throws IOException 可能出现的异常
    55.      */
    56.     public static void createTable(String myTableName, String[] colFamily) throws IOException {
    57.         TableName tableName = TableName.valueOf(myTableName);
    58.         if (admin.tableExists(tableName)) {
    59.             logger.info(myTableName + "表已经存在");
    60.         } else {
    61.             HTableDescriptor hTableDescriptor = new HTableDescriptor(tableName);
    62.             for (String str : colFamily) {
    63.                 HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(str);
    64.                 hTableDescriptor.addFamily(hColumnDescriptor);
    65.             }
    66.             admin.createTable(hTableDescriptor);
    67.         }
    68.     }
    69. 	
    70. 	 /**
    71.      * 添加数据
    72.      * @param tableName 表名
    73.      * @param rowkey 行键
    74.      * @param colFamily 列族
    75.      * @param col 列
    76.      * @param value 值
    77.      * @throws IOException 可能出现的异常
    78.      */
    79.     public static void insertData(String tableName,String rowkey,String colFamily,String col,String value) throws IOException {
    80.         Table table = conn.getTable(TableName.valueOf(tableName));
    81.         Put put = new Put(rowkey.getBytes());
    82.         put.addColumn(colFamily.getBytes(),col.getBytes(),value.getBytes());
    83.         table.put(put);
    84.         table.close();
    85.     }
    86. 	
    87. 	/**
    88.      * 根据行键删除数据
    89.      * @param tableName 表名
    90.      * @param rowkey 行键
    91.      * @throws IOException 可能出现的异常
    92.      */
    93.     public static void deleteData(String tableName,String rowkey) throws IOException {
    94.         Table table = conn.getTable(TableName.valueOf(tableName));
    95.         Delete delete = new Delete(rowkey.getBytes());
    96.         table.delete(delete);
    97.         table.close();
    98.     }
    99.  
    100.     /**
    101.      * 获取数据
    102.      * @param tableName 表名
    103.      * @param rowkey 行键
    104.      * @param colFamily 列族
    105.      * @param col 列
    106.      * @throws IOException 可能出现的异常
    107.      */
    108.     public static void getData(String tableName,String rowkey,String colFamily,String col) throws IOException {
    109.         Table table = conn.getTable(TableName.valueOf(tableName));
    110.         Get get = new Get(rowkey.getBytes());
    111.         get.addColumn(colFamily.getBytes(),col.getBytes());
    112.         Result result = table.get(get);
    113.         System.out.println(new String(result.getValue(colFamily.getBytes(),col.getBytes())));
    114.         table.close();
    115.     }
    116.  
    117.     public static void main(String[] args) throws IOException {
    118.         init();
    119.         createTable("student",new String[]{"score"});
    120.         insertData("student","zhangsan","score","English","69");
    121.         insertData("student","zhangsan","score","Math","86");
    122.         insertData("student","zhangsan","score","Computer","77");
    123.         getData("student","zhangsan","score","Computer");
    124.         close();
    125.     }
    126. }

    3、Hbase过滤器查询

    过滤器可以分为两种：比较过滤器和专用过滤器

    比较过滤器 

    LESS —— 小于

    LESS_OR_EQUAL —— 小于等于

    EQUAL —— 等于

    NOT_EQUAL —— 不等于

    GREATER_OR_EQUAL —— 大于等于

    GREATER —— 大于

    NO_OP —— 排除所有

    专用过滤器

    BinaryComparator —— 按字节索引顺序比较指定字节数组，采用Bytes.compareTo(byte[])
    BinaryPrefixComparator —— 跟前面相同，只是比较左端的数据是否相同
    NullComparator —— 判断给定的是否为空
    BitComparator —— 按位比较
    RegexStringComparator —— 提供一个正则的比较器，仅支持 EQUAL 和非EQUAL
    SubstringComparator —— 判断提供的子串是否出现在value中

    • 3.1、ResultScanner结果处理handleResultScanner

    1. /**
    2.  *	ResultScanner结果解析
    3.  */
    4. public void handleResultScanner(ResultScanner scanner) throws IOException {
    5. 	//因为ResultScanner类继承了迭代器
    6. 	//使用增强for循环遍历
    7. 	for (Result rs : scanner) {
    8. 	String id = Bytes.toString(rs.getRow());
    9. 	System.out.println("当前行的rowkey为：" + id);
    10. 	//继续增强for循环得到每一行中的每一个单元格（列）
    11. 	//获取一行中的所有单元格
    12. 	for (Cell cell : rs.listCells()) {
    13. 		//获取该单元格属于的列簇
    14. 		String family = Bytes.toString(CellUtil.cloneFamily(cell));
    15. 		//获取该单元格的列名
    16. 		String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    17. 		//获取该单元格的列值
    18. 		String value = Bytes.toString(CellUtil.cloneValue(cell));
    19. 		System.out.println(family + ":" + colName + "的值为：" + value);
    20. 	}
    21. ​
    22. 	String name = Bytes.toString(rs.getValue("info".getBytes(), "name".getBytes()));
    23. 	String age = Bytes.toString(rs.getValue("info".getBytes(), "age".getBytes()));
    24. 	String gender = Bytes.toString(rs.getValue("info".getBytes(), "gender".getBytes()));
    25. 	String clazz = Bytes.toString(rs.getValue("info".getBytes(), "clazz".getBytes()));
    26. 	System.out.println("学号：" + id + ",姓名：" + name + ",年龄：" + age + ",性别：" + gender + ",班级：" + clazz);
    27. 	
    28. }

    3.2、rowKey过滤器RowFilter

    1. /**
    2.  *  行键过滤器
    3.  *  通过RowFilter与BinaryComparator过滤比rowKey 1500100010小的所有值出来
    4.  */
    5. @Test
    6. public void RowFilter1(){
    7. 	try {
    8. 		//获取表的实例
    9. 		HTableInterface students = conn.getTable("students");
    10. ​
    11. 		BinaryComparator binaryComparator = new BinaryComparator("1500100010".getBytes());
    12. ​
    13. 		//创建一个行键过滤器的对象
    14. 		RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.LESS, binaryComparator);
    15. ​
    16. 		Scan scan = new Scan();
    17. 		scan.setFilter(rowFilter);
    18. ​
    19. 		ResultScanner scanner = students.getScanner(scan);
    20. 		handleResultScanner(scanner);
    21. ​
    22. 	} catch (IOException e) {
    23. 		e.printStackTrace();
    24. 	}
    25. }

    3.3、列族过滤器FamilyFilter

    1. /**
    2.  * 	通过FamilyFilter与SubstringComparator查询列簇名包含in的所有列簇下面的数据
    3.  */
    4. @Test
    5. public void FamilyFilter1(){
    6. 	try {
    7. 		//获取表的实例
    8. 		HTableInterface students = conn.getTable("students");
    9. ​
    10. 		//创建一个比较器对象
    11. 		//只要列簇名中包含了in，就把该列簇下的所有列查询出来
    12. 		SubstringComparator substringComparator = new SubstringComparator("in");
    13. ​
    14. 		//创建列簇过滤器
    15. 		FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, substringComparator);
    16. ​
    17. 		Scan scan = new Scan();
    18. 		scan.setFilter(familyFilter);
    19. ​
    20. 		//获取数据
    21. 		ResultScanner scanner = students.getScanner(scan);
    22. 		handleResultScanner(scanner);
    23. ​
    24. ​
    25. 	} catch (IOException e) {
    26. 		e.printStackTrace();
    27. 	}
    28. }
    29.  
    30. /**
    31.  *	通过FamilyFilter与 BinaryPrefixComparator 过滤出列簇以i开头的列簇下的所有数据
    32.  *
    33.  */
    34. @Test
    35. public void FamilyFilter2(){
    36. 	try {
    37. 		//获取表的实例
    38. 		HTableInterface students = conn.getTable("students");
    39. ​
    40. 		//创建前缀比较器
    41. 		BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("i".getBytes());
    42. ​
    43. 		//创建列簇过滤器
    44. 		FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, binaryPrefixComparator);
    45. ​
    46. 		Scan scan = new Scan();
    47. 		scan.setFilter(familyFilter);
    48. ​
    49. 		ResultScanner scanner = students.getScanner(scan);
    50. 		handleResultScanner(scanner);
    51. ​
    52. 	} catch (IOException e) {
    53. 		e.printStackTrace();
    54. 	}
    55. }

    3.4、列过滤器QualifierFilter

    1. /**
    2.  * 通过QualifierFilter与SubstringComparator查询列名包含ge的列的值
    3.  *
    4.  */
    5. @Test
    6. public void QualifierFilter1(){
    7. 	try {
    8. 		//获取表的实例
    9. 		HTableInterface students = conn.getTable("students");
    10. ​
    11. 		//创建包含比较器
    12. 		//age
    13. 		//gender
    14. 		SubstringComparator substringComparator = new SubstringComparator("ge");
    15. ​
    16. 		//创建一个列过滤器
    17. 		QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, substringComparator);
    18. ​
    19. 		Scan scan = new Scan();
    20. 		scan.setFilter(qualifierFilter);
    21. ​
    22. 		ResultScanner scanner = students.getScanner(scan);
    23. 		handleResultScanner(scanner);
    24. ​
    25. ​
    26. 	} catch (IOException e) {
    27. 		e.printStackTrace();
    28. 	}
    29. }
    30.  
    31. /**
    32.  *
    33.  * 通过QualifierFilter与SubstringComparator查询列名包含ge的列的值
    34.  */
    35. @Test
    36. public void QualifierFilter2(){
    37. 	try {
    38. 		//获取表的实例
    39. 		HTableInterface students = conn.getTable("students");
    40. ​
    41. 		SubstringComparator substringComparator = new SubstringComparator("am");
    42. ​
    43. 		//创建列过滤器
    44. 		QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, substringComparator);
    45. ​
    46. 		Scan scan = new Scan();
    47. 		scan.setFilter(qualifierFilter);
    48. ​
    49. 		ResultScanner scanner = students.getScanner(scan);
    50. 		handleResultScanner(scanner);
    51. ​
    52. 	} catch (IOException e) {
    53. 		e.printStackTrace();
    54. 	}
    55. }

    3.5、列值过滤器ValueFilter

    1. /**
    2.  *	通过ValueFilter与BinaryPrefixComparator过滤出所有的cell中值以 "张" 开头的学生
    3.  */
    4. @Test
    5. public void ValueFilter1() {
    6. 	try {
    7. 		//获取表的实例
    8. 		HTableInterface students = conn.getTable("students");
    9. ​
    10. 		//创建前缀比较器
    11. 		BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("张".getBytes());
    12. ​
    13. 		//创建列值过滤器的对象
    14. 		ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, binaryPrefixComparator);
    15. ​
    16. 		Scan scan = new Scan();
    17. 		scan.setFilter(valueFilter);
    18. ​
    19. 		ResultScanner scanner = students.getScanner(scan);
    20. ​
    21. 		//因为ResultScanner类继承了迭代器
    22. 		//使用增强for循环遍历
    23. //            for (Result rs : scanner) {
    24. //                String id = Bytes.toString(rs.getRow());
    25. //                System.out.println("当前行的rowkey为：" + id);
    26. //                //继续增强for循环得到每一行中的每一个单元格（列）
    27. //                //获取一行中的所有单元格
    28. //                for (Cell cell : rs.listCells()) {
    29. //                    //获取该单元格属于的列簇
    30. //                    String family = Bytes.toString(CellUtil.cloneFamily(cell));
    31. //                    //获取该单元格的列名
    32. //                    String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    33. //                    //获取该单元格的列值
    34. //                    String value = Bytes.toString(CellUtil.cloneValue(cell));
    35. //                    System.out.println(family + ":" + colName + "的值为：" + value);
    36. //                }
    37. //            }
    38. ​
    39. 		handleResultScanner(scanner);
    40. 	} catch (IOException e) {
    41. 		e.printStackTrace();
    42. 	}
    43. }
    44.  
    45. /**
    46.  *	过滤出文科的学生，只会返回以文科开头的数据列，其他列的数据不符合条件，不会返回
    47.  */
    48. @Test
    49. public void ValueFilter12(){
    50. 	try {
    51. 		//获取表的实例
    52. 		HTableInterface students = conn.getTable("students");
    53. ​
    54. 		//创建正则比较器
    55. 		RegexStringComparator regexStringComparator = new RegexStringComparator("^文科.*");
    56. ​
    57. 		//创建列值过滤器
    58. 		ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, regexStringComparator);
    59. ​
    60. 		Scan scan = new Scan();
    61. 		scan.setFilter(valueFilter);
    62. ​
    63. 		ResultScanner scanner = students.getScanner(scan);
    64. 		handleResultScanner(scanner);
    65. ​
    66. ​
    67. 	} catch (IOException e) {
    68. 		e.printStackTrace();
    69. 	}
    70. }

    3.6、单列值过滤器 SingleColumnValueFilter

    1. /**
    2.  * 单列值过滤器
    3.  * SingleColumnValueFilter会返回满足条件的cell所在行的所有cell的值（即会返回一行数据）
    4.  *
    5.  * 通过SingleColumnValueFilter与查询文科班所有学生信息
    6.  */
    7. @Test
    8. public void SingleColumnValueFilter(){
    9. 	try {
    10. 		//获取表的实例
    11. 		HTableInterface students = conn.getTable("students");
    12. ​
    13. 		//创建一个正则比较器
    14. 		RegexStringComparator regexStringComparator = new RegexStringComparator("^文科.*");
    15. ​
    16. 		//创建单列值过滤器对象
    17. 		SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(
    18. 				"info".getBytes(),
    19. 				"clazz".getBytes(),
    20. 				CompareFilter.CompareOp.EQUAL,
    21. 				regexStringComparator
    22. 		);
    23. ​
    24. 		Scan scan = new Scan();
    25. 		scan.setFilter(singleColumnValueFilter);
    26. ​
    27. 		ResultScanner scanner = students.getScanner(scan);
    28. 		handleResultScanner(scanner);
    29. ​
    30. ​
    31. 	} catch (IOException e) {
    32. 		e.printStackTrace();
    33. 	}
    34. }

    3.7、列值排除过滤器SingleColumnValueExcludeFilter

    1. /**
    2.  * 列值排除过滤器
    3.  * 与SingleColumnValueFilter相反，会排除掉指定的列，其他的列全部返回
    4.  *
    5.  * 通过SingleColumnValueExcludeFilter与BinaryComparator查询文科一班所有学生信息，最终不返回clazz列
    6.  */
    7. @Test
    8. public void SingleColumnValueExcludeFilter(){
    9. 	try {
    10. 		//获取表的实例
    11. 		HTableInterface students = conn.getTable("students");
    12. ​
    13. 		//创建一个二进制比较器
    14. 		BinaryComparator binaryComparator = new BinaryComparator("文科一班".getBytes());
    15. ​
    16. 		//创建一个列值排除过滤器
    17. 		SingleColumnValueExcludeFilter singleColumnValueExcludeFilter = new SingleColumnValueExcludeFilter(
    18. 				"info".getBytes(),
    19. 				"clazz".getBytes(),
    20. 				CompareFilter.CompareOp.EQUAL,
    21. 				binaryComparator
    22. 		);
    23. ​
    24. 		Scan scan = new Scan();
    25. 		scan.setFilter(singleColumnValueExcludeFilter);
    26. ​
    27. 		ResultScanner scanner = students.getScanner(scan);
    28. 		handleResultScanner(scanner);
    29. ​
    30. ​
    31. 	} catch (IOException e) {
    32. 		e.printStackTrace();
    33. 	}
    34. }

    3.8、rowKey前缀过滤器PrefixFilter

    1. /**
    2.  * rowkey前缀过滤器
    3.  *
    4.  * 通过PrefixFilter查询以150010008开头的所有前缀的rowkey
    5.  */
    6. @Test
    7. public void PrefixFilter(){
    8. 	try {
    9. 		//获取表的实例
    10. 		HTableInterface students = conn.getTable("students");
    11. ​
    12. 		//创建rowkey前缀过滤器
    13. 		PrefixFilter prefixFilter = new PrefixFilter("150010008".getBytes());
    14. 		Scan scan = new Scan();
    15. ​
    16. 		scan.setFilter(prefixFilter);
    17. 		ResultScanner scanner = students.getScanner(scan);
    18. 		handleResultScanner(scanner);
    19. ​
    20. ​
    21. 	} catch (IOException e) {
    22. 		e.printStackTrace();
    23. 	}
    24. ​
    25. }

    3.9、分页过滤器PageFilter

    1. /**
    2.  * 分页过滤器
    3.  * 分页有两个条件
    4.  * pageNum  第几页
    5.  * pageSize 每页有几条
    6.  */
    7. @Test
    8. public void pageFilter() throws IOException {
    9.  
    10. 	int pageNum = 3;
    11. 	int pageSize = 2;
    12.  
    13.  
    14. 	/*
    15. 	分为两种情况判断：
    16. 	第一页
    17. 	其他页
    18. 	 */
    19. 	if (pageNum == 1){
    20. 		Scan scan = new Scan();
    21. 		//设置起始rowKey
    22. 		scan.setStartRow("".getBytes());
    23. 		//设置最大的返回结果，返回pageSize条
    24. 		scan.setMaxResultSize(pageSize);
    25. 		//分页过滤器
    26. 		PageFilter pageFilter = new PageFilter(pageSize);
    27. 		scan.setFilter(pageFilter);
    28.  
    29. 		ResultScanner resultScanner = table.getScanner(scan);
    30. 		for (Result result : resultScanner) {
    31. 			byte[] row = result.getRow();
    32. 			System.out.println("数据的rowKey为" + Bytes.toString(row));
    33. 			List cells = result.listCells();
    34. 			for (Cell cell : cells) {
    35. 				byte[] qualifier = cell.getQualifier();
    36. 				byte[] family = cell.getFamily();
    37. 				byte[] value = cell.getValue();
    38. 				//id列和age列是整型数据
    39. 				if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
    40. 					System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
    41. 				} else {
    42. 					System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
    43. 				}
    44. 			}
    45. 		}
    46. 	} else {
    47. 		String startRow = "";
    48. 		Scan scan = new Scan();
    49. 		/*
    50. 		第二页的起始rowKey = 第一页的结束rowKey + 1
    51. 		第三页的起始rowKey = 第二页的结束rowKey + 1
    52. 		 */
    53. 		int resultSize = (pageNum - 1) * pageSize + 1;
    54. 		scan.setMaxResultSize(resultSize);
    55. 		//设置一次性往前扫描5条，最后一个rowKey是第三页起始rowKey
    56. 		PageFilter pageFilter = new PageFilter(resultSize);
    57. 		scan.setFilter(pageFilter);
    58. 		//resultScanner里面有5条数据
    59. 		ResultScanner scanner = table.getScanner(scan);
    60. 		for (Result result : scanner) {
    61. 			//获取rowKey
    62. 			byte[] row = result.getRow();
    63. 			//最后一次循环遍历 rowKey为0005
    64. 			startRow = Bytes.toString(row);
    65. 		}
    66. 		Scan scan1 = new Scan();
    67. 		scan1.setStartRow(startRow.getBytes());
    68. 		scan1.setMaxResultSize(pageSize);
    69.  
    70. 		PageFilter pageFilter1 = new PageFilter(pageSize);
    71. 		scan1.setFilter(pageFilter1);
    72.  
    73. 		ResultScanner scanner1 = table.getScanner(scan1);
    74. 		for (Result result : scanner1) {
    75. 			byte[] row = result.getRow();
    76. 			System.out.println("数据的rowKey为" + Bytes.toString(row));
    77. 			List cells = result.listCells();
    78. 			for (Cell cell : cells) {
    79. 				// byte[] qualifier = cell.getQualifier();
    80. 				// byte[] family = cell.getFamily();
    81. 				// byte[] value = cell.getValue();
    82. 				String family = Bytes.toString(CellUtil.cloneFamily(cell));
    83. 				//获取该单元格的列名
    84. 				String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    85. 				//获取该单元格的列值
    86. 				String value = Bytes.toString(CellUtil.cloneValue(cell));
    87. 				//id列和age列是整型数据
    88. 				if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
    89. 					System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
    90. 				} else {
    91. 					System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
    92. 				}
    93. 			}
    94. 		}
    95. 	}
    96. }

    3.10、多过滤器综合查询FilterList

    1. /**
    2.  * 通过运用4种比较器过滤出姓于，年纪大于23岁，性别为女，且是理科的学生。
    3.  *
    4.  * 正则比较器   RegexStringComparator
    5.  * 包含比较器   SubstringComparator
    6.  * 二进制前缀比较器   BinaryPrefixComparator
    7.  * 二进制比较器      BinaryComparator
    8.  *
    9.  */
    10. @Test
    11. public void FilterData1(){
    12. 	try {
    13. 		//获取表的实例
    14. 		HTableInterface students = conn.getTable("students");
    15. ​
    16. 		/**
    17. 		 *  第一个过滤器，过滤出是理科开头的班级
    18. 		 */
    19. 		RegexStringComparator regexStringComparator = new RegexStringComparator("^理科.*");
    20. 		//单列值过滤器
    21. 		SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter("info".getBytes(), "clazz".getBytes(),
    22. 				CompareFilter.CompareOp.EQUAL, regexStringComparator);
    23. ​
    24. 		/**
    25. 		 * 第二个过滤器，过滤出性别是女生的
    26. 		 */
    27. ​
    28. 		SubstringComparator substringComparator = new SubstringComparator("女");
    29. 		SingleColumnValueFilter singleColumnValueFilter1 = new SingleColumnValueFilter("info".getBytes(), "gender".getBytes(),
    30. 				CompareFilter.CompareOp.EQUAL, substringComparator);
    31. ​
    32. 		/**
    33. 		 * 第三个过滤器，过滤出年龄大于23岁的
    34. 		 */
    35. 		BinaryComparator binaryComparator = new BinaryComparator("20".getBytes());
    36. 		SingleColumnValueFilter singleColumnValueFilter2 = new SingleColumnValueFilter("info".getBytes(), "age".getBytes(),
    37. 				CompareFilter.CompareOp.GREATER, binaryComparator);
    38. ​
    39. ​
    40. 		/**
    41. 		 * 第四个过滤器，过滤出姓于的学生
    42. 		 */
    43. 		BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("于".getBytes());
    44. 		SingleColumnValueFilter singleColumnValueFilter3 = new SingleColumnValueFilter("info".getBytes(), "name".getBytes(),
    45. 				CompareFilter.CompareOp.EQUAL, binaryPrefixComparator);
    46. ​
    47. ​
    48. 		Scan scan = new Scan();
    49. ​
    50. 		//要想实现多个需求同时过滤，就需要创建多个过滤器，添加到一个过滤器列表中
    51. 		//然后将过滤器列表传给扫描器scan
    52. 		FilterList filterList = new FilterList();
    53. 		filterList.addFilter(singleColumnValueFilter);
    54. 		filterList.addFilter(singleColumnValueFilter1);
    55. 		filterList.addFilter(singleColumnValueFilter2);
    56. 		filterList.addFilter(singleColumnValueFilter3);
    57. ​
    58. 		scan.setFilter(filterList);
    59. ​
    60. 		ResultScanner scanner = students.getScanner(scan);
    61. ​
    62. 		handleResultScanner(scanner);
    63. ​
    64. ​
    65. 	} catch (IOException e) {
    66. 		e.printStackTrace();
    67. 	}
    68. ​
    69. }
    70.  
    71. /**
    72.  * 	过滤出学号是以15001001开头的文科学生
    73.  */
    74. @Test
    75. public void filterData2(){
    76. 	try {
    77. 		//获取表的实例
    78. 		HTableInterface students = conn.getTable("students");
    79. ​
    80. 		/**
    81. 		 *  创建第一个过滤器，过滤是以15001001开头的rowkey
    82. 		 */
    83. 		BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("15001001".getBytes());
    84. 		//创建行键过滤器
    85. 		RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL, binaryPrefixComparator);
    86. ​
    87. 		/**
    88. 		 * 创建第二个过滤器，过滤出文科的学生
    89. 		 */
    90. 		RegexStringComparator regexStringComparator = new RegexStringComparator("^文科.*");
    91. 		SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter("info".getBytes(), "clazz".getBytes(),
    92. 				CompareFilter.CompareOp.EQUAL,
    93. 				regexStringComparator);
    94. ​
    95. ​
    96. 		FilterList filterList = new FilterList();
    97. 		filterList.addFilter(rowFilter);
    98. 		filterList.addFilter(singleColumnValueFilter);
    99. ​
    100. 		Scan scan = new Scan();
    101. 		scan.setFilter(filterList);
    102. 		ResultScanner scanner = students.getScanner(scan);
    103. 		handleResultScanner(scanner);
    104. ​
    105. 	} catch (IOException e) {
    106. 		e.printStackTrace();
    107. 	}
    108. ​
    109. }

  • 相关阅读:
    基本数据类型和运算符（java）
    安路远程调试使用chipwatcher报错
    QT入门10个小demo——连接MySql实现登录模块
    科普文：一文搞懂jvm原理(三)执行引擎
    优雅的接口防刷处理方案
    关于unordered_map中元素的插入顺序与遍历顺序问题
    计网学习笔记一 Networking && Internet
    STL——查找算法及实例
    并发编程（多线程）-可见性问题
    VMware ESXi 8.0 SLIC 2.6 & macOS Unlocker (Oct 2022 GA)
  • 原文地址：https://blog.csdn.net/qq_41482600/article/details/136655894