HBase协处理器

一． 协处理器定义
HBase可以让用户的部分逻辑在数据存放端及HBase服务端进行计算的机制（框架），协处理器允许用户在hbase服务端上运行自己的代码。
二． 协处理器的分类
1.从加载角度来分类：
系统协处理器：配置好配置文件，完全导入，全局使用协处理器
表协处理器：用户可以指定某一张表使用协处理器
2.从功能角度来分类
Observer协处理器：相当于关系型数据库中的触发器
Endpoint协处理器：动态终端，类似于一个存储过程
3.Observer分类
RegionObserver协处理器：允许处理region上的事件
RegionServerObserver协处理器：处理RegionServer上的事件
MasterObserver协处理器：专门处理HMaster上的一些事件，比如创建删除表等操作。
WalObserver协处理器：允许处理日志上的事件
三. Observer的执行流程图
在region打开前可以添加自己的逻辑，关闭时也可以实现自己的逻辑。

四. Endpoint
动态RPC插件接口，实现代码被部署在HBase服务器服务端，从而通过RPC调用，需要自己实现一个客户端，去调用服务端上的实现。

五. Endpoint的代码实例
例子：使用hbase endpoint实现对某个column求和
1.创建endpoint.proto文件：生成java的一个文件

option java_pakage = “com.jkb.coprocessor.endpoint”;//java包名
option java_outer_classname = “Sum”;  // 类名
option java_generic_service = true;
option java_generate_equals_and_hash = true;
option optimize_for = SPEED;
//定义请求包的格式
message SumRequence{
required string family = 1;// 传入string类型的family
required string column = 2;// 传入string类型的column

}
//定义回复包的格式
message SumResponse{
required int64 sum = 1 [default = 0]; //返回int64 ，相当于java的long型的结果。
}
//定义rpc服务器类的定义
service SumService{
rpc getSum(SumRequest)
returns (SumResponse);
}

2.执行命令，将.proto文件生成java代码

protoc endpoint.proto --java_out=./

3.将java文件放入eclipse中相应的工程中相应的目录下，然后加载Hbase中的jar包

4.写服务端的代码
SumEndPoint类

Package com.jkb.coprocessor.endpoint;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.Coprocessor;
import org.apache.hadoop.hbase.CoprocessorEnvironment;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.coprocessor.CoprocessorException;
import org.apache.hadoop.hbase.coprocessor.CoprocessorService;
import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
import org.apache.hadoop.hbase.protobuf.ResponseConverter;
import org.apache.hadoop.hbase.regionserver.InternalScanner;
import org.apache.hadoop.hbase.util.Bytes;

import com.google.protobuf.RpcCallback;
import com.google.protobuf.RpcController;
import com.google.protobuf.Service;

import edu.endpoint.Sum.SumRequest;
import edu.endpoint.Sum.SumResponse;
import edu.endpoint.Sum.SumService;

public class SumEndPoint extends SumService implements Coprocessor,CoprocessorService{
    //写协处理器必须要实现的接口,实现相应的方法start(),stop()
    private RegionCoprocessorEnvironment env;//定义一个协处理器实例保存的环境，保持其生命周期的环境


 //自己写的rpc,序列化框架的方法
/**
参数：RpcController controller：RpcController提供一种方法来设置真对rpc的实现，包括找出一些错误
SumRequest request：请求，在里面获取到传入的值
RpcCallback<SumResponse> done：rpc的回调返回
*/
    @Override
    public void getSum(RpcController controller, SumRequest request,
            RpcCallback<SumResponse> done) {
       Scan scan = new Scan(); // 创建scan 对region进行scan
       scan.addFamily(Bytes.toBytes(request.getFamily()));//设置要使用的值的family
       scan.addColumn(Bytes.toBytes(request.getFamily()), Bytes.toBytes(request.getColumn()));//设置要使用的值的column

       SumResponse response = null;//返回的消息对象
       InternalScanner scanner = null;//接口
       try{
           scanner = env.getRegion().getScanner(scan);
           List<Cell> results = new ArrayList<Cell>(); //返回的一个list
           boolean hasMore = false;
           Long sum = 0L;
           do{
               hasMore = scanner.next(results);//results是否有下一行
               for(Cell cell: results){
                   sum += Long.parseLong(new String(CellUtil.cloneValue(cell)));
               }
               results.clear();
           }while(hasMore);
//如果处理正确，会返回结果给消息对象
           response = SumResponse.newBuilder().setSum(sum).build();
       }catch(IOException e){//如果发生错误则处理异常
           ResponseConverter.setControllerException(controller, e);
       }finally{
           if(scanner!=null){
               try {
                scanner.close();
            } catch (IOException e) {
            }
           }
       }
        done.run(response);//rpc把结果回调回去
    }

    @Override
    public Service getService() {
        return this;
    }

    @Override
    public void start(CoprocessorEnvironment env) throws IOException {
        if(env instanceof RegionCoprocessorEnvironment){
            this.env = (RegionCoprocessorEnvironment)env;
        }else{
            throw new CoprocessorException("no load region");
        }

    }

    @Override
    public void stop(CoprocessorEnvironment arg0) throws IOException {

    }

}

5.endpoint协处理器的客户端
Test 类

Public class Tset{
    public static conf = HBaseConfiguration.create();
    conf.set(“hbase.zookeeper.quorum”,”192.168.1.148”);
    HConnection conn = HConnectionManager.createConnection(conf);
    HTableInterface table = new HTableInterface();

    long h = 0;
    final SumRequest request = SumRequest.newBuilder().setFamily(“a”).setColumn(“b”).build();
    try{
        Map<byte[],Long> result = table.coprocessorService(SumService.class,null,null,new Batch.Call<SumService,Long>(){
            public Long call<SumService aggregate> throws IOException{
            BlockingRpcCallback rpcCallback = new BlockingRpcCallback();
            Aggregate.getSum(null,request,rpcCallback);
            SumResponse response = (SumResponse)rpcCallback.get();
            Return response.hasSum ? response.getSum : 0L;
        }
        });
        for(Long sum : result.values()){
            h += sum;
        }
        System.out.println(“sum = ” + h);
    }catch(ServiceException e){
         e.printStackTrace();
    }catch(Throwable e){
         e.printStackTrace();
    }

    table.close();
    conn.close();
}

6.运行测试
//把服务端的代码打成jar包(sumt.jar)上传到HDFS上

rz

hadoop fs –put sumt.jar /2016/0808/

//进入hbase shell

create ‘sum_table’,’d’

put ‘sum_table’,’r1’,’d:b’,’100’

put ‘sum_table’,’r2’,’d:b’,’100’

scan

disable

//加载协处理器
alter ‘sum_table’, Method -> ‘table_att’,’Coprocessor’ -> ‘hdfs://hadoop.hbase:9000/20160808/sumt.jar|edu.endpoint.SumEndpoint|100’

enable ‘sum_table’

//eclipse中跑客户端的测试代码

六.Observer的代码实例
利用Observer的二级索引的简单例子
实现场景：
table1 rowkey是r，值是d:b d:c
table1
r d:b d:c
table2
d:b d:c
向table1中写入一行数据后table2以d:b为rowkey,以d:c为值

ObserverPut.java

public class ObserverPut extends BaseRegionObserver{
        @Override
        public void postPut(final ObserverContext<RegionCoprocessorEvironment> e,final Put put, final WALEdit edit, final Durability durability) throws          IOException{
    HTableInterface table = e.getEnvironment().getTable(TableName.valueOf(“index_ob_table”));
    List<Cell> cell_b = put.get(“d”.getBytes(),”b”.getBytes());
    Iterator<cell> cellItor_b = cell.iterator();
    List<Cell> cell_c = put.get(“d”.getBytes(),”c”.getBytes());
    //Iterator<cell> cellItor_c = cell.iterator();
    While(cellItor_b.hasnext()){
        Cell tmp = cellItor_b.next();
        Put indexput = new Put(CellUtil.cloneValue(tmp));
        for(Cell c : cell_c){
                indexput.add(“d”.getBytes(),”c”.getBytes(),CellUtil.cloneValue(c));
        }
    table.put(indexput);
    }
    table.close();
    }
}

Test类

public class Test{
    public static void main(String[] args) throws IOEXception{
        Configuration conf = new Configuration();
        conf.set(“hbase.zookeeper.quorum”,”192.168.1.148”);
        HConnection conn = HConnectionManager.createConnection(conf);
        HTableInterface table = conn.getTable(“ob_table”);
        Put put = new Put(“r”.getBytes());
        put.add(“d”.getBytes(),”b”.getBytes(),”b1”.getBytes());
        put.add(“d”.getBytes(),”c”.getBytes(),”c1”.getBytes());
        table.put(put);
        table.close();
        conn.close();
    }
}

//打包ObserverPut.java为obput.jar

rz //上传到服务器上

hadoop fs –put obput.jar /20160808/  // 上传到HDFS

hhase shell 

create ‘index_ob_table’,’d’
create ‘obtable’,’d’

//加载协处理器

disable ‘ob_table’

alter ‘ob_table’, Method -> ‘table_att’,’Coprocessor’ -> ‘hdfs://hadoop.hbase:9000/20160808/obput.jar|edu.Observer.ObserverPut|100’

enable ‘ob_table’

跑Test测试，向ob_table加入一行数据

scan ‘ob_table’

scan ‘index_ob_table’