sparksql读写hbase
//写入hbase(hfile方式）
org.apache.hadoop.hbase.client.Connection conn = null;
try {
SparkLog.debug("开始读取hbase信息...");
if (StringUtils.isNotBlank(type) && type.equalsIgnoreCase("hbase")) {
SparkLog.debug("==========================================");
String hbasetable = dict.getStringItem("table", "");
String hbase_site_path = dict.getStringItem("path_site", "");
String hfile_path = dict.getStringItem("hfile_path", "");
Configuration conf = ss.sparkContext().hadoopConfiguration();
if (StringUtils.isBlank(hbase_site_path)) {
SparkLog.warn("参数配置错误，未配置hbase-site信息!");
}
if (StringUtils.isNotBlank(hbase_site_path)) {
hbase_site_path = hbase_site_path + (hbase_site_path.contains("hbase-site.xml") ? "" : "/hbase-site.xml");
conf.addResource(new Path(hbase_site_path));
} SparkLog.debug("读取hbase信息完成");
conf.set(HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD, "");
if (!P_Spark.delHDFSDir(hfile_path)) {
return TCResult.newFailureResult("SPARK_ERROR", "删除旧文件失败");
}
conf.setInt("hbase.mapreduce.bulkload.max.hfiles.perRegion.perFamily", );
SparkLog.debug(conf); SparkLog.debug("创建hbase的链接...");
// 创建hbase的链接,利用默认的配置文件,实际上读取的hbase的master地址
conn = ConnectionFactory.createConnection(conf); SparkLog.debug("开始生成hfile文件...");
//必须按照key排序
data.flatMapToPair(new PairFlatMapFunction<Row, ImmutableBytesWritable, KeyValue>() { private static final long serialVersionUID = -8033772725296906227L; @Override
public Iterator<Tuple2<ImmutableBytesWritable, KeyValue>> call(Row s) throws Exception {
byte[] rowkey = Bytes.toBytes((new SimpleDateFormat("yyyyMMddHHmmss.sss")).format(System.currentTimeMillis())+Math.random()*);
List<Tuple2<ImmutableBytesWritable,KeyValue>> cols = new ArrayList<>();
byte[] family = Bytes.toBytes("fm"); String hostname =s.get()==null ? "":s.getString();
String request_date =s.get()==null ? "":s.getString();
String post_id=s.get()==null ? "":Integer.toString(s.getInt());
String title=s.get()==null ? "":s.getString();
String author=s.get()==null ? "":s.getString();
String country=s.get()==null ? "":s.getString();
String category=s.get()==null ? "":s.getString(); //String filds[] =s.schema().fieldNames();//获取列名 //列名需要排序，按顺序加入
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "author".getBytes(), Bytes.toBytes(author))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "category".getBytes(), Bytes.toBytes(category))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "country".getBytes(), Bytes.toBytes(country))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "hostname".getBytes(), Bytes.toBytes(hostname))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "post_id".getBytes(), Bytes.toBytes(post_id))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "request_date".getBytes(), Bytes.toBytes(request_date))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "title".getBytes(), Bytes.toBytes(title))));
return cols.iterator();
}
}).sortByKey().saveAsNewAPIHadoopFile(hfile_path, ImmutableBytesWritable.class, KeyValue.class, HFileOutputFormat2.class, conf);
SparkLog.debug("生成hfile文件成功");
LoadIncrementalHFiles load = new LoadIncrementalHFiles(conf);
// 根据表名获取表
SparkLog.debug("根据表名获取表...");
Table table = conn.getTable(TableName.valueOf(hbasetable));
SparkLog.debug(table.toString()); // 获取hbase表的region分布
SparkLog.debug("获取hbase表的region分布...");
RegionLocator regionLocator = conn.getRegionLocator(TableName
.valueOf(hbasetable));
// 创建一个hadoop的mapreduce的job
Job job = Job.getInstance(conf);
// 设置job名称
job.setJobName("DumpFile");
// 此处最重要,需要设置文件输出的key,因为我们要生成HFil,所以outkey要用ImmutableBytesWritable
job.setMapOutputKeyClass(ImmutableBytesWritable.class);
// 输出文件的内容KeyValue
job.setMapOutputValueClass(KeyValue.class);
// 配置HFileOutputFormat2的信息
HFileOutputFormat2.configureIncrementalLoad(job, table,
regionLocator); // 开始导入
SparkLog.debug("开始导入...");
load.doBulkLoad(new Path(hfile_path), conn.getAdmin(), table,
regionLocator);
// load.doBulkLoad(new Path(path),new , table,regionLocator);
// load.doBulkLoad(new Path(path), (HTable)table);这个目前也可用
table.close(); } } catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR", e);
} finally {
try {
conn.close();
} catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR", e);
}
}
//读取hbase
Configuration conf = sc.hadoopConfiguration();
3 if (null != hbase_site_path) {
hbase_site_path = hbase_site_path.contains("hbase-site.xml") ? hbase_site_path : hbase_site_path
+ "/hbase-site.xml";
conf.addResource(new Path(hbase_site_path));
} else {
if(zn_parent == null || zn_parent.equals("")){
zn_parent="/hbase";
}
conf.set("hbase.zookeeper.quorum", quorum);
conf.set("hbase.zookeeper.property.clientPort", zkport);
conf.set("zookeeper.znode.parent", zn_parent); }
conf.set(HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD, "");
JavaRDD<String> javardd = null;
try {
conf.set(TableInputFormat.INPUT_TABLE, tablename);
JavaPairRDD<ImmutableBytesWritable, Result> hbRDD = sc
.newAPIHadoopRDD(conf, TableInputFormat.class,
ImmutableBytesWritable.class, Result.class); javardd = hbRDD.values().map(new Function<Result, String>(){ /**
*
*/
private static final long serialVersionUID = 1L; @Override
public String call(Result r) throws Exception {
// TODO 自动生成的方法存根
String s = "";
for (Cell cell : r.rawCells()) {
s += "Rowkey:"
+ Bytes.toString(CellUtil.cloneRow(cell))
+ ",column="
+ Bytes.toString(CellUtil.cloneFamily(cell))
+ ":"
+ Bytes.toString(
CellUtil.cloneQualifier(cell))
.replaceAll("Quilifier:", "")
+ ",timestamp=" + cell.getTimestamp()
+ ",value:"
+ Bytes.toString(CellUtil.cloneValue(cell));
}
return s;
} });
SparkLog.debug("hbase table records num = " + javardd.count()); } catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR",e);
}
//hbase读取方式2（saveAsNewAPIHadoopDataset && put方式）
String hbasetable = dict.getStringItem("table", "");
String hbase_site_path = dict.getStringItem("path_site", "");
//String hfile_path = dict.getStringItem("hfile_path", "");
Configuration conf = ss.sparkContext().hadoopConfiguration(); if (StringUtils.isBlank(hbase_site_path)) {
SparkLog.warn("参数配置错误，未配置hbase-site信息!");
}
if (StringUtils.isNotBlank(hbase_site_path)) {
hbase_site_path = hbase_site_path + (hbase_site_path.contains("hbase-site.xml") ? "" : "/hbase-site.xml");
conf.addResource(new Path(hbase_site_path));
} SparkLog.debug("读取hbase信息完成");
conf.set(HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD, "");
conf.set(TableOutputFormat.OUTPUT_TABLE, hbasetable); Job job = Job.getInstance(conf);
// 设置job名称
job.setJobName("DumpFile");
// 此处最重要,需要设置文件输出的key,因为我们要生成HFil,所以outkey要用ImmutableBytesWritable
job.setMapOutputKeyClass(ImmutableBytesWritable.class);
// 输出文件的内容Result
job.setMapOutputValueClass(Put.class); job.setOutputFormatClass((TableOutputFormat.class)); data.mapToPair(new PairFunction<Row, ImmutableBytesWritable, Put>() { private static final long serialVersionUID = -8033772725296906227L; @Override
public Tuple2<ImmutableBytesWritable, Put> call(Row s) throws Exception {
byte[] rowkey = Bytes.toBytes((new SimpleDateFormat("yyyyMMddHHmmss.sss")).format(System.currentTimeMillis())+Math.random()*); byte[] family = Bytes.toBytes("fm"); String hostname =s.get()==null ? "":s.getString();
String request_date =s.get()==null ? "":s.getString();
String post_id=s.get()==null ? "":Integer.toString(s.getInt());
String title=s.get()==null ? "":s.getString();
String author=s.get()==null ? "":s.getString();
String country=s.get()==null ? "":s.getString();
String category=s.get()==null ? "":s.getString(); Put put = new Put(rowkey); put.addImmutable(family,Bytes.toBytes("hostname"),Bytes.toBytes(hostname));
put.addImmutable(family,Bytes.toBytes("request_date"),Bytes.toBytes(request_date));
put.addImmutable(family,Bytes.toBytes("post_id"),Bytes.toBytes(post_id));
put.addImmutable(family,Bytes.toBytes("title"),Bytes.toBytes(title));
put.addImmutable(family,Bytes.toBytes("author"),Bytes.toBytes(author));
put.addImmutable(family,Bytes.toBytes("country"),Bytes.toBytes(country));
put.addImmutable(family,Bytes.toBytes("category"),Bytes.toBytes(category)); return new Tuple2<ImmutableBytesWritable, Put>(new ImmutableBytesWritable(rowkey),put); }
}).saveAsNewAPIHadoopDataset(job.getConfiguration());
//创建hbase表结构
org.apache.hadoop.hbase.client.Connection conn = null;
try { //创建hbase的链接,利用默认的配置文件,实际上读取的hbase的master地址
conn = ConnectionFactory.createConnection(conf);
// 根据表名获取表
HBaseAdmin admin =(HBaseAdmin) conn.getAdmin(); if (!admin.tableExists(tablename)) {
SparkLog.info("Table Not Exists! Create Table");
HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tablename));
String fms[] =Col_family.split(",");
for(int i=;i<fms.length;i++){
tableDesc.addFamily(new HColumnDescriptor(fms[i].getBytes()));
}
admin.createTable(tableDesc);
}else{
SparkLog.info("Table Exists! Do not Create Table");
}
}catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR", e);
} finally {
try {
conn.close();
} catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR", e);
}
}
// 添加一条数据
public static void addRow(String tableName, String rowKey, String columnFamily, String column, String value)
throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 通过rowkey创建一个put对象
Put put = new Put(Bytes.toBytes(rowKey));
// 在put对象中设置列族、列、值
put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
// 插入数据,可通过put(List<Put>)批量插入
table.put(put);
// 关闭资源
table.close();
conn.close();
}
// 通过rowkey获取一条数据
public static void getRow(String tableName, String rowKey) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 通过rowkey创建一个get对象
Get get = new Get(Bytes.toBytes(rowKey));
// 输出结果
Result result = table.get(get);
for (Cell cell : result.rawCells()) {
System.out.println(
"行键:" + new String(CellUtil.cloneRow(cell)) + "\t" +
"列族:" + new String(CellUtil.cloneFamily(cell)) + "\t" +
"列名:" + new String(CellUtil.cloneQualifier(cell)) + "\t" +
"值:" + new String(CellUtil.cloneValue(cell)) + "\t" +
"时间戳:" + cell.getTimestamp());
}
// 关闭资源
table.close();
conn.close();
}
// 全表扫描
public static void scanTable(String tableName) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 创建一个扫描对象
Scan scan = new Scan();
// 扫描全表输出结果
ResultScanner results = table.getScanner(scan);
for (Result result : results) {
for (Cell cell : result.rawCells()) {
System.out.println(
"行键:" + new String(CellUtil.cloneRow(cell)) + "\t" +
"列族:" + new String(CellUtil.cloneFamily(cell)) + "\t" +
"列名:" + new String(CellUtil.cloneQualifier(cell)) + "\t" +
"值:" + new String(CellUtil.cloneValue(cell)) + "\t" +
"时间戳:" + cell.getTimestamp());
}
}
// 关闭资源
results.close();
table.close();
conn.close();
}
// 删除一条数据
public static void delRow(String tableName, String rowKey) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 删除数据
Delete delete = new Delete(Bytes.toBytes(rowKey));
table.delete(delete);
// 关闭资源
table.close();
conn.close();
}
// 删除多条数据
public static void delRows(String tableName, String[] rowkeys) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 删除多条数据
List<Delete> list = new ArrayList<Delete>();
for (String row : rowkeys) {
Delete delete = new Delete(Bytes.toBytes(row));
list.add(delete);
}
table.delete(list);
// 关闭资源
table.close();
conn.close();
}
// 删除列族
public static void delColumnFamily(String tableName, String columnFamily) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 创建一个数据库管理员
HBaseAdmin hAdmin = (HBaseAdmin) conn.getAdmin();
// 删除一个表的指定列族
hAdmin.deleteColumn(tableName, columnFamily);
// 关闭资源
conn.close();
}
// 删除数据库表
public static void deleteTable(String tableName) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 创建一个数据库管理员
HBaseAdmin hAdmin = (HBaseAdmin) conn.getAdmin();
if (hAdmin.tableExists(tableName)) {
// 失效表
hAdmin.disableTable(tableName);
// 删除表
hAdmin.deleteTable(tableName);
System.out.println("删除" + tableName + "表成功");
conn.close();
} else {
System.out.println("需要删除的" + tableName + "表不存在");
conn.close();
System.exit();
}
}
// 追加插入(将原有value的后面追加新的value，如原有value=a追加value=bc则最后的value=abc)
public static void appendData(String tableName, String rowKey, String columnFamily, String column, String value)
throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 通过rowkey创建一个append对象
Append append = new Append(Bytes.toBytes(rowKey));
// 在append对象中设置列族、列、值
append.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
// 追加数据
table.append(append);
// 关闭资源
table.close();
conn.close();
}
// 符合条件后添加数据(只能针对某一个rowkey进行原子操作)
public static boolean checkAndPut(String tableName, String rowKey, String columnFamilyCheck, String columnCheck, String valueCheck, String columnFamily, String column, String value) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 设置需要添加的数据
Put put = new Put(Bytes.toBytes(rowKey));
put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
// 当判断条件为真时添加数据
boolean result = table.checkAndPut(Bytes.toBytes(rowKey), Bytes.toBytes(columnFamilyCheck),
Bytes.toBytes(columnCheck), Bytes.toBytes(valueCheck), put);
// 关闭资源
table.close();
conn.close(); return result;
}
// 符合条件后刪除数据(只能针对某一个rowkey进行原子操作)
public static boolean checkAndDelete(String tableName, String rowKey, String columnFamilyCheck, String columnCheck,
String valueCheck, String columnFamily, String column) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 设置需要刪除的delete对象
Delete delete = new Delete(Bytes.toBytes(rowKey));
delete.addColumn(Bytes.toBytes(columnFamilyCheck), Bytes.toBytes(columnCheck));
// 当判断条件为真时添加数据
boolean result = table.checkAndDelete(Bytes.toBytes(rowKey), Bytes.toBytes(columnFamilyCheck), Bytes.toBytes(columnCheck),
Bytes.toBytes(valueCheck), delete);
// 关闭资源
table.close();
conn.close(); return result;
}
// 计数器(amount为正数则计数器加，为负数则计数器减，为0则获取当前计数器的值)
public static long incrementColumnValue(String tableName, String rowKey, String columnFamily, String column, long amount)
throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 计数器
long result = table.incrementColumnValue(Bytes.toBytes(rowKey), Bytes.toBytes(columnFamily), Bytes.toBytes(column), amount);
// 关闭资源
table.close();
conn.close(); return result;
}
内置过滤器的使用
HBase为筛选数据提供了一组过滤器，通过这个过滤器可以在HBase中数据的多个维度（行、列、数据版本）上进行对数据的筛选操作，也就是说过滤器最终能够筛选的数据能够细化到具体的一个存储单元格上（由行键、列名、时间戳定位）。通常来说，通过行键、值来筛选数据的应用场景较多。需要说明的是，过滤器会极大地影响查询效率。所以，在数据量较大的数据表中，应尽量避免使用过滤器。
下面介绍一些常用的HBase内置过滤器的用法：
1、RowFilter：筛选出匹配的所有的行。使用BinaryComparator可以筛选出具有某个行键的行，或者通过改变比较运算符（下面的例子中是CompareFilter.CompareOp.EQUAL）来筛选出符合某一条件的多条数据，如下示例就是筛选出行键为row1的一行数据。
// 筛选出匹配的所有的行
Filter rf = new RowFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("row1")));
2、PrefixFilter：筛选出具有特定前缀的行键的数据。这个过滤器所实现的功能其实也可以由RowFilter结合RegexComparator来实现，不过这里提供了一种简便的使用方法，如下示例就是筛选出行键以row为前缀的所有的行。
// 筛选匹配行键的前缀成功的行
Filter pf = new PrefixFilter(Bytes.toBytes("row"));
3、KeyOnlyFilter：这个过滤器唯一的功能就是只返回每行的行键，值全部为空，这对于只关注于行键的应用场景来说非常合适，这样忽略掉其值就可以减少传递到客户端的数据量，能起到一定的优化作用。
// 返回所有的行键，但值全是空
Filter kof = new KeyOnlyFilter();
4、RandomRowFilter：按照一定的几率（<=0会过滤掉所有的行，>=1会包含所有的行）来返回随机的结果集，对于同样的数据集，多次使用同一个RandomRowFilter会返回不同的结果集，对于需要随机抽取一部分数据的应用场景，可以使用此过滤器。
// 随机选出一部分的行
Filter rrf = new RandomRowFilter((float) 0.8);
5、InclusiveStopFilter：扫描的时候，我们可以设置一个开始行键和一个终止行键，默认情况下，这个行键的返回是前闭后开区间，即包含起始行，但不包含终止行。如果我们想要同时包含起始行和终止行，那么可以使用此过滤器。
// 包含了扫描的上限在结果之内
Filter isf = new InclusiveStopFilter(Bytes.toBytes("row1"));
6、FirstKeyOnlyFilter：如果想要返回的结果集中只包含第一列的数据，那么这个过滤器能够满足要求。它在找到每行的第一列之后会停止扫描，从而使扫描的性能也得到了一定的提升。
// 筛选出每行的第一个单元格
Filter fkof = new FirstKeyOnlyFilter();
7、ColumnPrefixFilter：它按照列名的前缀来筛选单元格，如果我们想要对返回的列的前缀加以限制的话，可以使用这个过滤器。
// 筛选出前缀匹配的列
Filter cpf = new ColumnPrefixFilter(Bytes.toBytes("qual1"));
8、ValueFilter：按照具体的值来筛选单元格的过滤器，这会把一行中值不能满足的单元格过滤掉，如下面的构造器，对于每一行的一个列，如果其对应的值不包含ROW2_QUAL1，那么这个列就不会返回给客户端。
// 筛选某个（值的条件满足的）特定的单元格
Filter vf = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("ROW2_QUAL1"));
9、ColumnCountGetFilter：这个过滤器在遇到一行的列数超过我们所设置的限制值的时候，结束扫描操作。
// 如果突然发现一行中的列数超过设定的最大值时，整个扫描操作会停止
Filter ccf = new ColumnCountGetFilter(2);
10、SingleColumnValueFilter：用一列的值决定这一行的数据是否被过滤，可对它的对象调用setFilterIfMissing方法，默认的参数是false。其作用是，对于咱们要使用作为条件的列，如果参数为true，这样的行将会被过滤掉，如果参数为false，这样的行会包含在结果集中。
// 将满足条件的列所在的行过滤掉
SingleColumnValueFilter scvf = new SingleColumnValueFilter(
• Bytes.toBytes("colfam1"),
• Bytes.toBytes("qual2"),
• CompareFilter.CompareOp.NOT_EQUAL,
• new SubstringComparator("BOGUS"));
scvf.setFilterIfMissing(true);
11、SingleColumnValueExcludeFilter：这个过滤器与第10种过滤器唯一的区别就是，作为筛选条件的列，其行不会包含在返回的结果中。
12、SkipFilter：这是一种附加过滤器，其与ValueFilter结合使用，如果发现一行中的某一列不符合条件，那么整行就会被过滤掉。
// 发现某一行中的一列需要过滤时，整个行就会被过滤掉
Filter skf = new SkipFilter(vf);
13、WhileMatchFilter：使用这个过滤器，当遇到不符合设定条件的数据的时候，整个扫描结束。
// 当遇到不符合过滤器rf设置的条件时，整个扫描结束
Filter wmf = new WhileMatchFilter(rf);
14. FilterList：可以用于综合使用多个过滤器。其有两种关系： Operator.MUST_PASS_ONE表示关系AND，Operator.MUST_PASS_ALL表示关系OR，并且FilterList可以嵌套使用，使得我们能够表达更多的需求。
// 综合使用多个过滤器，AND和OR两种关系
List<Filter> filters = new ArrayList<Filter>();
filters.add(rf);
filters.add(vf);
FilterList fl = new FilterList(FilterList.Operator.MUST_PASS_ALL,filters);
下面给出一个使用RowFilter过滤器的完整示例：
public class HBaseFilter {
private static final String TABLE_NAME = "table1";
public static void main(String[] args) throws IOException {
// 设置配置
Configuration conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "localhost");
conf.set("hbase.zookeeper.property.clientPort", "2181");
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(TABLE_NAME));
// 创建一个扫描对象
Scan scan = new Scan();
// 创建一个RowFilter过滤器
Filter filter = new RowFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("abc")));
// 将过滤器加入扫描对象
scan.setFilter(filter);
// 输出结果
ResultScanner results = table.getScanner(scan);
for (Result result : results) {
for (Cell cell : result.rawCells()) {
System.out.println(
"行键:" + new String(CellUtil.cloneRow(cell)) + "\t" +
"列族:" + new String(CellUtil.cloneFamily(cell)) + "\t" +
"列名:" + new String(CellUtil.cloneQualifier(cell)) + "\t" +
"值:" + new String(CellUtil.cloneValue(cell)) + "\t" +
"时间戳:" + cell.getTimestamp());
}
}
// 关闭资源
results.close();
table.close();
conn.close();
}
}
sparksql读写hbase的更多相关文章
- Spark读写Hbase的二种方式对比
作者:Syn良子 出处:http://www.cnblogs.com/cssdongl 转载请注明出处 一.传统方式 这种方式就是常用的TableInputFormat和TableOutputForm ...
- Spark(四): Spark-sql 读hbase
SparkSQL是指整合了Hive的spark-sql cli, 本质上就是通过Hive访问HBase表,具体就是通过hive-hbase-handler, 具体配置参见:Hive(五):hive与h ...
- 【原创】大叔经验分享（25）hive通过外部表读写hbase数据
在hive中创建外部表: CREATE EXTERNAL TABLE hive_hbase_table(key string, name string,desc string) STORED BY ' ...
- Spark读写HBase
Spark读写HBase示例 1.HBase shell查看表结构 hbase(main)::> desc 'SDAS_Person' Table SDAS_Person is ENABLED ...
- Spark学习笔记——读写Hbase
1.首先在Hbase中建立一张表,名字为student 参考 Hbase学习笔记——基本CRUD操作 一个cell的值,取决于Row,Column family,Column Qualifier和Ti ...
- SparkSQL读取HBase数据
这里的SparkSQL是指整合了Hive的spark-sql cli(关于SparkSQL和Hive的整合,见文章后面的参考阅读). 本质上就是通过Hive访问HBase表,具体就是通过hive-hb ...
- Update(Stage4)：sparksql：第1节 SparkSQL_使用场景_优化器_Dataset & 第2节 SparkSQL读写_hive_mysql_案例
目标 SparkSQL 是什么 SparkSQL 如何使用 Table of Contents 1. SparkSQL 是什么 1.1. SparkSQL 的出现契机 1.2. SparkSQL 的适 ...
- Flink连接器-批处理-读写Hbase
Flink批处理与hbase的读写 source-hbase 父类 是模仿官方写的. import org.apache.flink.api.common.io.LocatableInputSplit ...
- Spark读写Hbase中的数据
def main(args: Array[String]) { val sparkConf = new SparkConf().setMaster("local").setAppN ...
随机推荐
- jsp内置对象pageContext如何在Servlet中获取值
pageContext javax.servlet.jsp.PageContext 的实例,该对象代表该JSP 页面上下文,使用该对象可以访问页面中的共享数据.常用的方法有getServletCont ...
- H5 移动端开发中 ios/安卓坑 和经验总结
1. ios new时间对象,需要用逗号隔开传日期的方式, 不支持 new Date('2019-03-01 08:00:00') 格式: 支持以下两种方式: 2. ios个别版本对fixed的属性的 ...
- 安装oracle11g时遇到环境不满足最低要求
在安装oracle11g时出现问题:INS-13001环境不满足最低要求 解决方法:找到下载解压后的文件,依次打开以下文件路径:Oracle11g\database\stage\cvu, 在cvu文件 ...
- Asset Catalogs
原文见这里. Asset Catalogs用于简化管理程序内用到的图片.每个asset catalog可以包含image set, App Icon, Launch Image和OS X Icon(如 ...
- 用 crontab 实现开机自动运行脚本
开发「bufpay.com 个人即时到账收款平台」的时候,订单状态和支付二维码的状态如果过期了要实时修改状态,最大效率利用支付二维码. 过期脚本需要开机启动,并且 deamon 运行,有很多办法可以开 ...
- Excel2013打开提示 文件格式和扩展名不匹配。文件可能已损坏或不安全。除非您信任其来源，否则请勿打开。是否仍要打开它?
有的时候打开xls文档时,会提示“文件格式和扩展名不匹配.文件可能已损坏或不安全.除非您信任其来源,否则请勿打开.是否仍要打开它?” 遇到这种情况,我们需要 1.win键+R键,打开“运行“,输入re ...
- JsonCpp在vs中使用
Jsoncpp是c++生成和解析Json数据的跨平台开源库.下面简介如何在vs中使用. 1.官网下载.https://sourceforge.net/projects/jsoncpp/解压文件得到js ...
- AML与PIO整合问题
要想把PIO引擎封装成AML组件,面临如下问题(逐渐补充): 1)版本不兼容 内容项 AML PIO 选型 兼容? JDK 1.7 1.8 1.8 是 SPARK 1.6.1 2.1.1 HA ...
- WEB中需求分析应该考虑的问题
一． 针对用户群体要考虑因素 1.用户年龄 2.选择素材 3.网站布局 4.颜色搭配 5. 用户体验及动效 6.功能便捷 用户需求.用户兴趣爱好.性格.职业.教育水平高低.消费观念.PC端和移动端哪一 ...
- php连接数据库（一）
1.php链接数据库: 1.链接数据库 2.判断是否连接成功 3.设置字符集 4.选择数据库 5.准备SQL语句 6.发送SQL语句 7.处理结果集 8.释放资源(关闭数据库) $result = m ...