开发者社区> 神巧合> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

HBase API 详细例子(封装的DAO类)

简介: HBase中没有库的概念 HBase lib目录下所有JAR包复制到项目中,Hbase 版本0.98.5 package com.zxing.imgQRCode; import java.io.IOException; import java.util.LinkedList; import java.util.List; import org.apache.hadoop.conf.Con
+关注继续查看


HBase没有库的概念

HBase lib目录下所有JAR包复制到项目中,Hbase 版本0.98.5

package com.zxing.imgQRCode;

import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

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.KeyValue;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.ZooKeeperConnectionException;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.client.HConnection;
import org.apache.hadoop.hbase.client.HConnectionManager;
import org.apache.hadoop.hbase.client.HTableInterface;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.io.compress.Compression.Algorithm;
import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding;

public class HbaseConnection {
    private String rootDir;
    private String zkServer;
    private String port;
    private Configuration conf;
    private HConnection hConn=null;
    
    public HbaseConnection(String rootDir, String zkServer, String port) {
        super();
        this.rootDir = rootDir;
        this.zkServer = zkServer;
        this.port = port;
        conf=HBaseConfiguration.create();
        conf.set("hbase.rootdir", rootDir);
        conf.set("hbase.zookeeper.quorum ", zkServer);
        conf.set("hbase.zookeeper.property.clientPort", port);
        try {
            hConn=HConnectionManager.createConnection(conf);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    //创建表
    public void crateTable(String tableName,List<String> cols){
        try {
            HBaseAdmin admin=new HBaseAdmin(conf);
            if(admin.tableExists(tableName))
                throw new IOException("table exists");
            else{
                
                HTableDescriptor tableDesc=new HTableDescriptor(tableName);
                for(String col:cols){
                    
                    HColumnDescriptor colDesc=new HColumnDescriptor(col);
                    colDesc.setCompressionType(Algorithm.GZ);
                    colDesc.setDataBlockEncoding(DataBlockEncoding.DIFF);
                    tableDesc.addFamily(colDesc);
                }
                admin.createTable(tableDesc);
            }
            
        } catch (MasterNotRunningException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ZooKeeperConnectionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
    }
    //插入数据
    public void saveData(String tableName,List<Put> puts){
        
        try {
            HTableInterface table =hConn.getTable(tableName);
            table.put(puts);
            table.setAutoFlush(false);
            table.flushCommits();
            
        } catch (IOException e) {
    
            e.printStackTrace();
        }
    }
    
    //得到数据
    public Result getData(String tableName,String rowkey){
        try {
            HTableInterface table =hConn.getTable(tableName);
            Get get=new Get(rowkey.getBytes());
            return table.get(get);
        } catch (IOException e) {
            
            e.printStackTrace();
        }
        return null;
        
    }     
    
    //输出result结果
    public void format(Result result){
        
        String rowkey=Bytes.toString(result.getRow());
        KeyValue[] kvs=result.raw();
        for (KeyValue kv:kvs){
                String family= Bytes.toString(kv.getFamily());
            String qualifier= Bytes.toString(kv.getQualifier());
            System.out.println("rowkey->"+rowkey+"family->"+family+"qualifier->"+qualifier);
        }
    }
    
    
    //全表扫描
    public void hbaseScan(String tableName){
        
        Scan scan=new Scan();//扫描器
        scan.setCaching(1000);//缓存1000条数据,一次读取1000条
        try {
            HTableInterface table =hConn.getTable(tableName);
            ResultScanner scanner=table.getScanner(scan);//返回迭代器
            for(Result res:scanner){
                format(res);
            }
            
        } catch (IOException e) {
            
            e.printStackTrace();
        }
    }
    
    
    //比较过滤器
    public void filterTest(String tableName){
        Scan scan=new Scan();//扫描器
        scan.setCaching(1000);//缓存1000条数据,一次读取1000条
        RowFilter filter =new RowFilter(CompareFilter.CompareOp.EQUAL,new BinaryComparator("Jack".getBytes()));
        RowFilter filter1 =new RowFilter(CompareFilter.CompareOp.EQUAL,new RegexStringComparator("J\\w+"));
    
        scan.setFilter(filter);
        try {
            HTableInterface table =hConn.getTable(tableName);
            ResultScanner scanner=table.getScanner(scan);//返回迭代器
            for(Result res:scanner){
                format(res);
            }
            
        } catch (IOException e) {
            
            e.printStackTrace();
        }
    }
    
    //PageFilter分页
    public void pageFilterTest(String tableName){
        PageFilter filter = new  PageFilter(4);
       byte[] lastRow=null;
       int pageCount=0; //记录第几页
       try {
        HTableInterface table =hConn.getTable(tableName);
        while(++pageCount>0){
            System.out.println("pageCount = "+ pageCount);
            Scan scan=new Scan();
            scan.setFilter(filter);
            if(lastRow!=null){
                scan.setStartRow(lastRow);
            }
            
            ResultScanner scanner=table.getScanner(scan);
            int count=0;//计数器
            for(Result res:scanner){
                
                lastRow=res.getRow();
                if(++count>3)
                    break;
                format(res);
                if(count<3){
                    break;
                }
                
            }
        }
        
    } catch (IOException e) {
        e.printStackTrace();
    }
    }
    
    public static void main(String[] args) {
    
            String rootDir="hdfs://ns1/hbase";
            String zkServer="10.128.129.230";//集群内网IP
            String port="2181";
            //
            HbaseConnection conn=new HbaseConnection(rootDir, zkServer, port);
            List<String> cols=new LinkedList<String>();
            cols.add("basicInfo");
            cols.add("moreInfo");
             conn.crateTable("students", cols);
             //
             List<Put> puts=new LinkedList<Put>();
             Put put1=new Put("Tom".getBytes());//rowkey
             put1.add("basicInfo".getBytes(), "age".getBytes(), "27".getBytes());
             put1.add("moreInfo".getBytes(), "tel".getBytes(), "110".getBytes());
             Put put2=new Put("Jim".getBytes());
             put2.add("basicInfo".getBytes(), "age".getBytes(), "28".getBytes());
             put2.add("moreInfo".getBytes(), "tel".getBytes(), "111".getBytes());
             puts.add(put1);
             puts.add(put2);
             conn.saveData("students", puts);
             
             //
             
             
           Result result=  conn.getData("students", "Tom");
             conn.format(result);
             //
             conn.hbaseScan("students");
               //
             conn.filterTest("students");
             
              //
             conn.pageFilterTest("students");
    }

}



常用接口

package test;

import hbase.HbaseUtils;

import java.io.IOException;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;

import net.sf.json.JSONObject;

import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.HTableInterface;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.PageFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.Test;

import com.xd.iis.se.common.Constants;
import com.xd.iis.se.hbase.CommHbaseUtils;
import com.xd.iis.se.hbutils.MeUtils;

import commn.CommonConstants;

public class SyncTestUtils {
    //hbase表名(hbaseapi包中的Constants类中定义了表名和数字的映射关系)
private  final static  String wz_content="wz_content";//1
private  final static  String lt_content="lt_content";//4
private  final static  String wb_content="wb_content";//2
private static  final   String wb_comment="wb_comment";//45

private static final String sinawb_user="sinawb_user";// 微博用户表

/*   TitleHs的定义在hbaseapi包中SwitchBeanAndJsonUtils类中jsonToDocument方法里
 * 
 *   从326行代码开始
 * 
 * hbase表字段定义hbaseapi包中HIContentCommon类
 * 
 * pfsearch包中IContentCommon类
 * */
    @Test
    public void hbaseTableNameToDigitalMapping() {

        
        for(Entry<String, String>     entry: Constants.rstypemp.entrySet()){
            
            System.out.println(entry.getKey()+":"+entry.getValue());
        }

    }
    @Test
    public void seconds(){
            System.out.println(new Date().getTime());
              System.out.println(System.nanoTime());
              System.out.println(System.currentTimeMillis());
        //时间转换
            System.out.println(TimeUnit.NANOSECONDS.convert(10L, TimeUnit.MILLISECONDS));

    }
    
    //毫秒转换成日期
    @Test
    public void millsToDate(){
            String mills="1460459403324";
            
            Date date=new Date(Long.parseLong(mills));
          System.out.println(date);
          System.out.println(date.getTime());
    }
    
    
    
    
    //手工干预生成19位的全网微博评论tokenKey(键,rowkey)=wbcomment_key
    //TokenTable=hotmanwb_token
    /*
     * hbase(main):003:0> scan 'hotmanwb_token',LIMIT=>2
     ROW                                          COLUMN+CELL                                                                                                                         
     hotmanwb_key                                 column=content:date, timestamp=1459310036375, value=1459310031972331086                                                             
     hotmanwbcomment_key                          column=content:date, timestamp=1460600117890, value=1460600079542140091                                                             
     ltcomment_key                                column=content:date, timestamp=1460600483717, value=1460600441668719114                                                             
     wzcomment_key                                column=content:date, timestamp=1460599817280, value=1460599777817713930  
     
     */
    @Test
    public void generateTokenKeyForWeiboComment(){
        Calendar calendar = Calendar.getInstance();
         calendar.setTime(new Date());
         //三十天前的时间
         calendar.add(calendar.DATE, -30);
         Date date = calendar.getTime();
         //第一位表示星期
         System.out.println(date);
        //13位加6位拼成19位
        String startTime=date.getTime()+"000000";
        
        System.out.println("startTime:"+startTime);
        //插入或者更新时间
    HbaseUtils.insertData("hotmanwb_token", "wbcomment_key", startTime);
        //1458109165143000000   19位
        
    }
    
    
    

    //hbase根据表名和rowkey查询一条数据(tokenkey)
    @Test
    public void findByRowKey(){
        
        String startTime=HbaseUtils.QueryByCondition1("hotmanwb_token", "wbcomment_key");
        System.out.println(startTime);
    }
    
    
    //hbase返回前几条数据
    /*key:014604646505869913352145
    key:014604646505954866550445
    key:014604988869079841915645
    key:014605014502935460283945
    key:014605014503712711041745*/
    @Test
    public  void  scanTopRowComment(){
        ResultScanner resultScanner = null;
        HTableInterface table = HbaseUtils.pool.getTable(wz_content);
        try {
            Scan scan = new Scan();
            //设置过滤器,只返回20条
            Filter filter = new PageFilter(5); 
            scan.setFilter(filter);
        //RegionServer是否应当缓存 当前客户端访问过的数据块    如果是随机的get 这个最好为false
            scan.setCacheBlocks(true);
            
          /*简而言之就是  batch 是qualifier column级别的       caching是row级别的
            batch 就是每次迭代从服务器获取的记录数, 设置太小 会频繁到服务器取数据,
                                    太大 会对客户端造成比较大的压力,  具体根据需要使用 , 正常使用可以不必管
                                    它, 大批量读取可以考虑用它改善性能
                                    这里要注意了: 这个记录数是qualifier不是row, 如果一个row有17个qualifier,
            setBatch(5),一个row就会分散到4个Result中, 分别持有5,5,5,2个qualifier
                                  (默认一个row的所有qualifier会在一个Result中)*/
            /*scan.setBatch(100);*/    //setFilter与setBatch不能都打开,会冲突
            //setCaching发给scanners的缓存的Row的数量
            scan.setCaching(100);
            scan.setMaxVersions(1);
            resultScanner = table.getScanner(scan);
        /*    for (Result r : rs) {
                return new String(r.getRow());
            }*/

            Iterator<Result> res = resultScanner.iterator();// 返回查询遍历器
            while (res.hasNext()) {
                Result result = res.next();
                System.out.println(result);
                System.out.println("key:" + new String(result.getRow()));
                //date列存的是json字符串
                String value = new String(result.getValue(
                        CommonConstants.CRAWLERCONTENT_TABLE_COLUMNS
                                .getBytes(),
                        CommonConstants.CRAWLERCONTENT_TABLE_COLUMN2
                                .getBytes()), "ISO8859-1");
                System.out.println("value:" + value);
                
                JSONObject js = JSONObject.fromObject(value);
                System.out.println(js);
            }
            
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //这样一定要记住 用完close
            if(resultScanner!=null)  resultScanner.close();
        }
    }
    
    //根据rowkey范围扫描
    @Test
    public  void  scanByRowKeyRangeComment(){
        ResultScanner resultScanner = null;
        HTableInterface table = HbaseUtils.pool.getTable(wb_comment);
        String startRow="01420459403324297147";//
        String stopRow="014605014503712711";//20位
        try {
            Scan scan = new Scan();
            //设置过滤器,只返回20条
            Filter filter = new PageFilter(5); 
            scan.setFilter(filter);
            scan.setStartRow(startRow.getBytes());
            scan.setStopRow(stopRow.getBytes());
        //RegionServer是否应当缓存 当前客户端访问过的数据块    如果是随机的get 这个最好为false
            scan.setCacheBlocks(true);
            
          /*简而言之就是  batch 是qualifier column级别的       caching是row级别的
            batch 就是每次迭代从服务器获取的记录数, 设置太小 会频繁到服务器取数据,
                                    太大 会对客户端造成比较大的压力,  具体根据需要使用 , 正常使用可以不必管
                                    它, 大批量读取可以考虑用它改善性能
                                    这里要注意了: 这个记录数是qualifier不是row, 如果一个row有17个qualifier,
            setBatch(5),一个row就会分散到4个Result中, 分别持有5,5,5,2个qualifier
                                  (默认一个row的所有qualifier会在一个Result中)*/
            /*scan.setBatch(100);*/    //setFilter与setBatch不能都打开,会冲突
            //setCaching发给scanners的缓存的Row的数量
            scan.setCaching(100);
            scan.setMaxVersions(1);
            resultScanner = table.getScanner(scan);
        /*    for (Result r : rs) {
                return new String(r.getRow());
            }*/

            Iterator<Result> res = resultScanner.iterator();// 返回查询遍历器
            while (res.hasNext()) {
                Result result = res.next();
                System.out.println(result);
                System.out.println("key:" + new String(result.getRow()));
                //date列存的是json字符串
                String value = new String(result.getValue(
                        CommonConstants.CRAWLERCONTENT_TABLE_COLUMNS
                                .getBytes(),
                        CommonConstants.CRAWLERCONTENT_TABLE_COLUMN2
                                .getBytes()), "ISO8859-1");
                System.out.println("value:" + value);
                
                JSONObject js = JSONObject.fromObject(value);
                System.out.println(js);
            }
            
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //这样一定要记住 用完close
            if(resultScanner!=null)  resultScanner.close();
        }
    }
    
    
    
    @Test
    //hbase生成行键(hbaseApi包) 第一个url参数无用
    public void createRowKey(){
        
    //typemp.put("wb_comment", "45");// 微博评论表对应编码最后两位
    String newRowKey=MeUtils.createKeyCode("", "wb_comment");
    
    System.out.println(newRowKey);
    
/*String oldRowKey=MeUtils.createKeyCode_oid("http://www.baidu.com", "wb_comment");
    
    System.out.println(oldRowKey);*/
    //rowkey=114606860784008157170445 24位
    //1+19位时间戳+2位随机数+2位表名
    }
    
    /*Timestamp

    HBase通过row和column确定一份数据,这份数据的值可能有多个版本,不同版本的值按照时间倒序排序,即最新的数据排在最前面,
    查询时默认返回最新版本。如上例中row key=1的author:nickname值有两个版本,分别为1317180070811对应的“一叶渡江”和1317180718830对应的“yedu”
    (对应到实际业务可以理解为在某时刻修改了nickname为yedu,但旧值仍然存在)。Timestamp默认为系统当前时间(精确到毫秒),也可以在写入数据时指定该值。
    Value
    每个值通过4个键唯一索引,tableName+RowKey+ColumnKey+Timestamp=>value,
    例如上例中{tableName=’blog’,RowKey=’1’,ColumnName=’author:nickname’,Timestamp=’ 1317180718830’}索引到的唯一值是“yedu”。
    */
    
    
    
    
    /*大Solr(192.168.20.190对应三个域名)
         # 24 index
        solr_24h=http://solr-24h.wyq.cn/solr
        # month index
        solr_month=http://solr-month.wyq.cn/solr
        # week index
        solr_week=http://solr-week.wyq.cn/solr
    */    
    
    @Test
    public  void  scanTopRowContent(){
        ResultScanner resultScanner = null;
        
        HTableInterface table = HbaseUtils.pool.getTable(wz_content);
        try {
            Scan scan = new Scan();
            //设置过滤器,只返回20条
            Filter filter = new PageFilter(5); 
            scan.setFilter(filter);
        //RegionServer是否应当缓存 当前客户端访问过的数据块    如果是随机的get 这个最好为false
            scan.setCacheBlocks(true);
            
          /*简而言之就是  batch 是qualifier column级别的       caching是row级别的
            batch 就是每次迭代从服务器获取的记录数, 设置太小 会频繁到服务器取数据,
                                    太大 会对客户端造成比较大的压力,  具体根据需要使用 , 正常使用可以不必管
                                    它, 大批量读取可以考虑用它改善性能
                                    这里要注意了: 这个记录数是qualifier不是row, 如果一个row有17个qualifier,
            setBatch(5),一个row就会分散到4个Result中, 分别持有5,5,5,2个qualifier
                                  (默认一个row的所有qualifier会在一个Result中)*/
            /*scan.setBatch(100);*/    //setFilter与setBatch不能都打开,会冲突
            //setCaching发给scanners的缓存的Row的数量
            scan.setCaching(100);
            scan.setMaxVersions(1);
            resultScanner = table.getScanner(scan);
         // 返回查询遍历器
            Iterator<Result> res = resultScanner.iterator();
            while (res.hasNext()) {
                System.out.println("--------------行分割线-------------");
                Result result = res.next();
                System.out.println("\n"+"------单个result--------");
                System.out.println(result);
                System.out.println("\n"+"------result中Cells--------");
                //由{row key, Family:Qualifier, version} 唯一确定的单元。cell中的数据是没有类型的,全部是以字节的形式进行存储的
                 for  (Cell cell : result.rawCells()) {
                         //rowkey
                    System.out.println("Rowkey : " +Bytes.toString (CellUtil.cloneRow(cell)));
                              //列簇+列(Family是第一级列,Qualifier是第二级列)
                            System.out.println("Familiy:Quilifier : " +Bytes.toString (CellUtil.cloneFamily(cell))
                                     +":"+Bytes.toString (CellUtil.cloneQualifier (cell))); 
                              //值
                            System.out.println ("Value : " +Bytes.toString (CellUtil.cloneValue (cell)));
                            System.out.println("TimeStamp : "  +cell.getTimestamp());
                }
                 
                 
            /*     //老API
                 System.out.println("\n"+ "------result中KeyValues--------");   
                for( KeyValue kv:result.list()){  
                     
                      System.out.println(String.format("row:%s, family:%s, qualifier:%s, qualifiervalue:%s, timestamp:%s.",   
                              Bytes.toString(kv.getRow()),   
                              Bytes.toString(kv.getFamily()),   
                              Bytes.toString(kv.getQualifier()),   
                              Bytes.toString(kv.getValue()),  
                              kv.getTimestamp()));       
                  } */ 
            }
            
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //这样一定要记住 用完close
            if(resultScanner!=null)  resultScanner.close();
        }
    }
    
    //SecureCRT上传下载文件
    //sz  下载命令
    //rz -be 上传文件 单独用rz会有两个问题:上传中断、上传文件变化(md5不同),

    /*解决办法是上传是用rz -be,并且去掉弹出的对话框中“Upload files as ASCII”前的勾选。
    
    -a, –ascii
    -b, –binary 用binary的方式上传下载,不解释字符为ascii
    -e, –escape 强制escape 所有控制字符,比如Ctrl+x,DEL等
    
    rar,gif等文件文件采用 -b 用binary的方式上传。
    
    文件比较大而上传出错的话,采用参数 -e*/

    //根据rowkey查找数据
    
    @Test
    public void select(){
        String ID="114615497672016941968326";
        try {
            String json=CommHbaseUtils.select(ID);
            System.out.println(json);
            JSONObject js = JSONObject.fromObject(json);
            System.out.println(js);
        } catch (IOException e) {
            
            e.printStackTrace();
        }
        
    }
    
    
    /*//血和泪的经验教训
    
    ArrayList非线程安全,即使使用Collections.synchronizedList(new ArrayList<SolrInputDocument>())
    访问方法size()方法得出来的大小也是错的,还是推荐使用vector代替
    
    
    //因为solrserver服务的url配置文件pfs.properties未打包进去,找不到url发生空指针异常
    ScheduledExecutorService对于线程中发生的http服务方面的异常无法捕获,jstack -l命令打印信息
     java.lang.Thread.State: WAITING (parking) at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x0000000712e8e7e8> (a 
    解决方案:
    异常可以替代使用Timer定时器来捕获
    */
    
    
    /*修改properties文件编码
     * 全局修改:
     *  window-> preference -> general -> content types 
        找到右边的 java properties file ,将其编码改为 utf-8  
          单个文件修改:
          右击该properties文件--properties--Resource--Text file encoding,
          选中other,选择其它编码方式,如UTF-8或GBK,这样就能在properties里面输入中文,而不会自动转成Unicode了。
     * */
    
    
    
}


本文出自 “点滴积累” 博客,请务必保留此出处http://tianxingzhe.blog.51cto.com/3390077/1698822

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
实验Hbase的test中的TestTableMapReduce类--修改成简单易懂点的
不积跬步,无以至千里! 这几天狂看mapreduce对hbase进行操作的例子,消化吸收,熟能生巧,掌握mapreduce和hbase交互的各个细节,以及整体流程等,整体流程等年前写一篇总结下,这几天先狂看吧 看,复制,修改,运行,遇到各种问题,解决,慢慢的就熟了。 这个类是干啥的呢,其实就是对hbase的某表进行简单操作,不过用的是mapreduce,即效率高,当然,看这个,主要吸收其用mapreduce操作hbase的思路及如何编程。 这个类功能是:将表中所有行 列族f1的某列q1的值倒序后放在另一列族f2的列q2,所谓倒序即 abc变成cba,456变成654,其中q1和q2是可
0 0
Hadoop原理与技术——Hbase实操
Hadoop原理与技术——Hbase实操
0 0
Hadoop原理与技术——Hbase的基本操作
Hadoop原理与技术——Hbase的基本操作
0 0
SLF4J: Hbase和Flume的slf4j-log4j12-x.x.xx.jar与hadoop的slf4j-log4j12-x.x.xx.jar冲突
SLF4J: Hbase和Flume的slf4j-log4j12-x.x.xx.jar与hadoop的slf4j-log4j12-x.x.xx.jar冲突
0 0
Hadoop安装Hbase启动失败报错解决方法
Hadoop安装Hbase启动失败报错解决方法
0 0
BigData:大数据开发的简介、核心知识(linux基础+Java/Python编程语言+Hadoop{HDFS、HBase、Hive}+Docker)、经典场景应用之详细攻略
BigData:大数据开发的简介、核心知识(linux基础+Java/Python编程语言+Hadoop{HDFS、HBase、Hive}+Docker)、经典场景应用之详细攻略
0 0
Hadoop生态上几个技术的关系与区别:hive、pig、hbase 关系与区别(三)
Hadoop生态上几个技术的关系与区别:hive、pig、hbase 关系与区别(三)
0 0
+关注
文章
问答
文章排行榜
最热
最新
相关电子书
更多
玩转HBase和Lindorm 大数据入门和实战
立即下载
《玩转HBase和Lindorm大数据入门和实战》
立即下载
云数据库HBase企业级安全解析
立即下载