HBase新版本Java API编程实战及基本操作方法封装

最新推荐文章于 2024-10-06 02:59:46 发布
最新推荐文章于 2024-10-06 02:59:46 发布
阅读量499 收藏 1
点赞数
分类专栏： Hadoop生态系统 文章标签： hbase

我的HBase版本是0.98
首先说明一下，如果用eclipse操作hbase时，如果报Unknown host错误，找不到主机，是因为你没有配IP地址的映射
方法是 找到你的系统盘里面的C:\Windows\System32\drivers\etc下的hosts文件，打开，增加一个映射
加一个映射

 192.168.52.140    master
   
   
  • 1

话不多说，直接看代码，注释很详细


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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
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.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

public class MyHbaseApi {

    public static void main(String[] args) {
        Admin admin=null;
        Connection con=null;

        try {

            //1.获得配置文件对象
            Configuration conf=HBaseConfiguration.create();
                //设置配置参数
            conf.set("hbase.zookeeper.quorum", "192.168.52.140");
            //2.建立连接
             con=ConnectionFactory.createConnection(conf);
            //3.获得会话
             admin=con.getAdmin();
            //System.out.println(con);
            //System.out.println(admin);
            //4.操作
                //建立数据库
                    //创建表名对象
            TableName tn=TableName.valueOf("stu");
                    //a.判断数据库是否存在
            if(admin.tableExists(tn)){
                System.out.println("====> 表存在，删除表....");
                //先使表设置为不可编辑
                admin.disableTable(tn);
                //删除表
                admin.deleteTable(tn);
                System.out.println("表删除成功.....");
            }
            System.out.println("===>表不存在,创建表......");
            //创建表结构对象
            HTableDescriptor htd=new HTableDescriptor(tn);
            //创建列族结构对象
            HColumnDescriptor hcd1=new HColumnDescriptor("fm1");
            HColumnDescriptor hcd2=new HColumnDescriptor("fm2");
            htd.addFamily(hcd1);
            htd.addFamily(hcd2);
            //创建表
            admin.createTable(htd);

            System.out.println("创建表成功...");

            //向表中插入数据
                //a.单个插入
            Put put =new Put(Bytes.toBytes("row01"));//参数是行健row01
            put.addColumn(Bytes.toBytes("fm1"), Bytes.toBytes("col1"), Bytes.toBytes("value01"));

            //获得表对象
            Table table=con.getTable(tn);
            table.put(put);

            //批量插入
            Put put01 =new Put(Bytes.toBytes("row02"));//参数是行健row02
            put01.addColumn(Bytes.toBytes("fm2"), Bytes.toBytes("col2"), Bytes.toBytes("value02")).
            addColumn(Bytes.toBytes("fm2"), Bytes.toBytes("col3"), Bytes.toBytes("value03"));

            Put put02 =new Put(Bytes.toBytes("row03"));//参数是行健row01
            put02.addColumn(Bytes.toBytes("fm1"), Bytes.toBytes("col4"), Bytes.toBytes("value04"));

            List<Put> puts=Arrays.asList(put01,put02);

            //获得表对象
            Table table02=con.getTable(tn);
            table02.put(puts);

        //读取操作
            //scan
            Scan scan=new Scan();
            //获得表对象
            Table table03=con.getTable(tn);
            //得到扫描的结果集
            ResultScanner rs=table03.getScanner(scan);
            for(Result result:rs){
                //得到单元格集合
                List<Cell> cs=result.listCells();
                for(Cell cell:cs){
                    //取行健
                    String rowKey=Bytes.toString(CellUtil.cloneRow(cell));
                    //取到时间戳
                    long timestamp = cell.getTimestamp();
                    //取到族列
                    String family = Bytes.toString(CellUtil.cloneFamily(cell));  
                    //取到修饰名
                    String qualifier  = Bytes.toString(CellUtil.cloneQualifier(cell));  
                    //取到值
                    String value = Bytes.toString(CellUtil.cloneValue(cell));  

                    System.out.println(" ===> rowKey : " + rowKey + ",  timestamp : " + 
                    timestamp + ", family : " + family + ", qualifier : " + qualifier + ", value : " + value);
                }
            }
            System.out.println(" ===================get取数据==================");

            //get
            Get get = new Get(Bytes.toBytes("row02"));
            get.addColumn(Bytes.toBytes("fm2"), Bytes.toBytes("col2"));
            Table t04 = con.getTable(tn);
            Result r = t04.get(get);
            List<Cell> cs = r.listCells();
            for (Cell cell : cs) {
                String rowKey = Bytes.toString(CellUtil.cloneRow(cell));  //取行键
                long timestamp = cell.getTimestamp();  //取到时间戳
                String family = Bytes.toString(CellUtil.cloneFamily(cell));  //取到族列
                String qualifier  = Bytes.toString(CellUtil.cloneQualifier(cell));  //取到修饰名
                String value = Bytes.toString(CellUtil.cloneValue(cell));  //取到值

                System.out.println(" ===> rowKey : " + rowKey + ",  timestamp : " + 
                timestamp + ", family : " + family + ", qualifier : " + qualifier + ", value : " + value);
            }


          //删除数据
            System.out.println(" ===================delete删除数据==================");
            Delete delete = new Delete(Bytes.toBytes("row02"));
            delete.addColumn(Bytes.toBytes("fm2"), Bytes.toBytes("col2"));
            Table t05 = con.getTable(tn);
            t05.delete(delete);

            System.out.println(" ===================delete删除数据后==================");
            //scan
            scan = new Scan();
            table03 = con.getTable(tn);  //获得表对象
            rs = table03.getScanner(scan);
            for (Result result : rs) {
                cs = result.listCells();
                for (Cell cell : cs) {
                    String rowKey = Bytes.toString(CellUtil.cloneRow(cell));  //取行键
                    long timestamp = cell.getTimestamp();  //取到时间戳
                    String family = Bytes.toString(CellUtil.cloneFamily(cell));  //取到族列
                    String qualifier  = Bytes.toString(CellUtil.cloneQualifier(cell));  //取到修饰名
                    String value = Bytes.toString(CellUtil.cloneValue(cell));  //取到值

                    System.out.println(" ===> rowKey : " + rowKey + ",  timestamp : " + 
                    timestamp + ", family : " + family + ", qualifier : " + qualifier + ", value : " + value);
                }
            }

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

        //5.关闭

                try {
                    if (admin != null){
                        admin.close();
                    }
                    if(con != null){
                        con.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }


    }

}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184

下面看对于上面的基本操作的封装,封装好了，以后就可以直接用


import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseUtil {
    private static Configuration conf;
    private static Connection con;
    // 初始化连接
    static {
        conf = HBaseConfiguration.create(); // 获得配制文件对象
        conf.set("hbase.zookeeper.quorum", "192.168.52.140");
        try {
            con = ConnectionFactory.createConnection(conf);// 获得连接对象
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 获得连接
    public static Connection getCon() {
        if (con == null || con.isClosed()) {
            try {
                con = ConnectionFactory.createConnection(conf);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return con;
    }

    // 关闭连接
    public static void close() {
        if (con != null) {
            try {
                con.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 创建表
    public static void createTable(String tableName, String... FamilyColumn) {
        TableName tn = TableName.valueOf(tableName);
        try {
            Admin admin = getCon().getAdmin();
            HTableDescriptor htd = new HTableDescriptor(tn);
            for (String fc : FamilyColumn) {
                HColumnDescriptor hcd = new HColumnDescriptor(fc);
                htd.addFamily(hcd);
            }
            admin.createTable(htd);
            admin.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 删除表
    public static void dropTable(String tableName) {
        TableName tn = TableName.valueOf(tableName);
        try {
            Admin admin = con.getAdmin();
            admin.disableTable(tn);
            admin.deleteTable(tn);
            admin.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 插入或者更新数据
    public static boolean insert(String tableName, String rowKey,
            String family, String qualifier, String value) {
        try {
            Table t = getCon().getTable(TableName.valueOf(tableName));
            Put put = new Put(Bytes.toBytes(rowKey));
            put.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier),
                    Bytes.toBytes(value));
            t.put(put);
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            HBaseUtil.close();
        }
        return false;
    }

    // 删除
    public static boolean del(String tableName, String rowKey, String family,
            String qualifier) {
        try {
            Table t = getCon().getTable(TableName.valueOf(tableName));
            Delete del = new Delete(Bytes.toBytes(rowKey));

            if (qualifier != null) {
                del.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
            } else if (family != null) {
                del.addFamily(Bytes.toBytes(family));
            }
            t.delete(del);
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            HBaseUtil.close();
        }
        return false;
    }
    //删除一行
    public static boolean del(String tableName, String rowKey) {
        return del(tableName, rowKey, null, null);
    }
    //删除一行下的一个列族
    public static boolean del(String tableName, String rowKey, String family) {
        return del(tableName, rowKey, family, null);
    }

    // 数据读取
    //取到一个值
    public static String byGet(String tableName, String rowKey, String family,
            String qualifier) {
        try {
            Table t = getCon().getTable(TableName.valueOf(tableName));
            Get get = new Get(Bytes.toBytes(rowKey));
            get.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
            Result r = t.get(get);
            return Bytes.toString(CellUtil.cloneValue(r.listCells().get(0)));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    //取到一个族列的值
        public static Map<String, String> byGet(String tableName, String rowKey, String family) {
            Map<String, String> result = null ;
            try {
                Table t = getCon().getTable(TableName.valueOf(tableName));
                Get get = new Get(Bytes.toBytes(rowKey));
                get.addFamily(Bytes.toBytes(family));
                Result r = t.get(get);
                List<Cell> cs = r.listCells();
                result = cs.size() > 0 ? new HashMap<String, String>() : result;
                for (Cell cell : cs) {
                    result.put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell)));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return result;
        }
    //取到多个族列的值
        public static Map<String, Map<String, String>> byGet(String tableName, String rowKey) {
            Map<String, Map<String, String>> results = null ;
            try {
                Table t = getCon().getTable(TableName.valueOf(tableName));
                Get get = new Get(Bytes.toBytes(rowKey));
                Result r = t.get(get);
                List<Cell> cs = r.listCells();
                results = cs.size() > 0 ? new HashMap<String, Map<String, String>> () : results;
                for (Cell cell : cs) {
                    String familyName = Bytes.toString(CellUtil.cloneFamily(cell));
                    if (results.get(familyName) == null)
                    {
                        results.put(familyName, new HashMap<String,  String> ());
                    }
                    results.get(familyName).put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell)));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return results;
        }
}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196

看看测试类

package com.yc.hbase.util;

import static org.junit.Assert.*;

import java.util.Map;

import org.junit.Test;

public class HBaseUtilTest {

    @Test
    public void testCreateTable() {
        //创建表
        HBaseUtil.createTable("myTest", "myfc1", "myfc2", "myfc3");
        HBaseUtil.close();
        HBaseUtil.createTable("myTest02", "myfc1", "myfc2", "myfc3");
        HBaseUtil.close();
    }

    @Test
    public void testDropTable() {
        //删除表
        HBaseUtil.dropTable("myTest");
        HBaseUtil.dropTable("myTest02");
    }

    @Test
    public void testInsert(){
        //插入数据
        HBaseUtil.insert("myTest", "1", "myfc1", "sex", "men");
        HBaseUtil.insert("myTest", "1", "myfc1", "name", "xiaoming");
        HBaseUtil.insert("myTest", "1", "myfc1", "age", "32");
        HBaseUtil.insert("myTest", "1", "myfc2", "name", "xiaohong");
        HBaseUtil.insert("myTest", "1", "myfc2", "sex", "woman");
        HBaseUtil.insert("myTest", "1", "myfc2", "age", "23");
    }

    @Test
    public void testByGet(){
        //得到一行下一个列族下的某列的数据
        String result = HBaseUtil.byGet("myTest", "1", "myfc1", "name");
        System.out.println("结果是的： " + result);
        assertEquals("xiaosan", result);
    }

    @Test
    public void testByGet02(){
        //得到一行下一个列族下的所有列的数据
        Map<String, String> result = HBaseUtil.byGet("myTest", "1", "myfc1");
        System.out.println("结果是的： " + result);
        assertNotNull(result);
    }

    @Test
    public void testByGet03(){
        //得到一行的所有列族的数据
        Map<String, Map<String, String>> result = HBaseUtil.byGet("myTest", "1");

        System.out.println("所有列族的数据是:  "+result);
        System.out.println("结果是的： " + result.get("myfc1"));
        assertNotNull(result);
    }
}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64

转载请指明出处http://blog.csdn.net/tanggao1314/article/details/51408166

(function () {('pre.prettyprint code').each(function () { var lines = (this).text().split(′\n′).length;var numbering = $('
  • ').addClass('pre-numbering').hide(); (this).addClass(′has−numbering′).parent().append( numbering); for (i = 1; i
穿越技术印记的河流
关注
专栏目录
Hbase入门到实操
默主归沙的博客
06-03 1468
Nosql中列式存储之Hbase知识讲解。
HBase编程api介绍
VLTIC的专栏
02-08 5098
HBaseConfiguration是每一个hbase client都会使用到的对象，它代表的是HBase配置信息。它有两种构造方式： public HBaseConfiguration() public HBaseConfiguration(final Configuration c) 默认的构造方式会尝试从hbase-default.xml和hbase-site.xml中读取
HBase Java API编程-学习记录
最新发布
m0_73641772的博客
10-06 594
输出日志的依赖（刷新完成不飘红即为引入成功）命令启动hdfs文件系统和hbase服务，默认端口：16030），验证环境正常。的依赖（刷新完成不飘红即为引入成功）下出现如下图所示的进程即为正确。HBase web页面如下图所示。
HBase Java Api
qq_42933029的博客
11-29 946
任务目标 1.了解HBase语言的基本语法 2.了解HBase开发的原理 3.了解HBase Java API的使用 相关知识 HBase与Hadoop一样，都是用Java编写的，所以HBase对Java支持是必须的，HBase Java API核心类介绍如下： 1.HBaseConfiguration类 HBaseConfiguration是每一个HBase Client都会使用到的对象，它代表...
Hbase JavaAPI的简单封装
leiro486592的博客
08-09 1008
在学习使用Hbase的时候，因为Hbase中存放的是byte数组。所以大部分的输入类型都是byte数组格式的。这样方便了存储其它大型文件，但是对于初学者的我们来讲就是十分不友好的。因此，我在这里对一些东西做了简单的二次封装，提高了学习的效率。这样，我们可以有更多的时间去考虑如何利用Hbase来设计业务逻辑，降低学习的难度。同时，这里做的一些封装，也可以为以后开发的时候封装工具做一个前瞻性的探索。 ...
Hbase JAVA API 编程
SimpleSimpleSimples的博客
05-04 501
1.hbase的API编程 1.1进行kerberos认证获取连接 /** * 进行kerberos认证获取连接 * @return * @throws IOException * @throws InterruptedException */ private static Connection getConnection() throws IOException, ...
java学习路线（项目开发、web方向、大数据方向）.rar
04-29
- **Java语法**：学习Java的基本语法，包括数据类型、变量、运算符、控制结构（如if、switch、for、while）、类与对象、封装、继承和多态等概念。 - **面向对象编程**：理解面向对象的设计原则，如单一职责、开放...
Java 学习路线大全，再也不用迷路啦（持续更新）
腾讯全栈-ITCJF
10-14 2964
路线特点 最新，完整一条龙，从入门到入土（⭐ 表示推荐学习） 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 划分阶段、更有计划，且在最后给出持续学习的方向、探索 Java 程序员发展的无限可能 前言 首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致，目前，Java 的岗位需求多，是后台开发的主流编程语言，功能强大，还是很值得学习的。 阶段 1：Java 入门 目标 培养兴趣、快速上手 前期准备 准备好一款在线、随时随地
人类高质量 Java 学习路线【一条龙版】
Feng_clay的博客
12-04 1666
大家好，我是张讨嫌。现在网上的编程资料实在太多了，而且人人肯定都说自己的最好，那就导致大家又不知道怎么选了。大部分的博主推荐资源，也就是把播放量高的视频说一遍，水一期视频，没有一条很清晰的学习路线。 所以今天我的这个 Java 学习路线就做做减法，给大家来个一条龙服务，Java 要学的知识点、对应的最佳学习资源和预计要花费的时间，都安排的明明白白的，不用选了，有计划了，也别再迷茫和纠结了，就无脑跟着学就行了。 我还在文档中整理了链接，也不用自己搜了，还有思维导图。 大纲 实在太长了，没办法全部展开，
Hbase javaAPI编程
为你封疆的博客
03-10 348
这里主要是针对Hbase的java Api编程做一个记录。以便以后复习回顾。 import java.io.IOException; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import org.apache.commons....
Hbase Java编程
Maynor的博客
03-15 995
文章目录6. Hbase Java编程6.1 需求与数据集6.2 准备工作6.3 需求一：使用Java代码创建表6.4 需求三：使用Java代码删除表6.5 需求二：往表中插入一条数据6.6 需求三：查看一条数据6.7 需求四：删除一条数据6.8 需求五：导入数据6.9 需求六：查询2020年6月份所有用户的用水量 6. Hbase Java编程 6.1 需求与数据集 某某自来水公司，需要存储大量的缴费明细数据。以下截取了缴费明细的一部分内容。 用户id 姓名 用户地址 性别 缴费时间 表示数（本次） 表示
HBase Java API编程：Demo程序实验
qq_35447918的博客
04-03 1203
HBase JavaAPI编程实验 编程环境： 开发工具使用Eclipse，简单好用利于初学者 方式一（必学）：创建一个普通Java Project，直接导入hbase-1.2.0-cdh5.7.0.tar.gz压缩包的lib子目录中与HBaseAPI编程有关的所有jar包，建议初学者使用 操作步骤：EClipse项目=》右键菜单=》Build Path =》Configure Bui...
HBase Java API编程实验
qq_35447918的博客
05-26 1810
HBase Java API 编程实验: 第1个HBase Java程序： 1)启动VirtualBox虚拟机HBaes伪分布式，依次执行执行start-dfs.sh 脚本启动HDFS，再执行start-hbase.sh 脚本启动HBase 2）打开桌面图标"eclipse.exe",启动Java IDE（集成开发环境）Eclipse，查看Eclipse界面的左边栏，已经存在一个项目testHBase 3）Linux终端执行HBase Shell命令，进入HBase Shell命令行终端，执行list命
Hbase高手之路 -- 第五章 -- HBase的Java API编程
kc44601的博客
04-30 3814
Hbase的java API操作: 1.创建表 2.删除表 3.插入数据 4.查看数据 5.导入数据 6.导出数据
HBase Java API 使用示例
vinsuan93的专栏
05-02 1546
在使用HBase Java API 之前，大家首先要了解HBase Java API类，可参考博客：http://www.cnblogs.com/ggjucheng/p/3380267.html 几个相关类与HBase数据模型之间的对应关系 java类 HBase数据模型 HBaseAdmin 数据库（DataBase)
HBase高手之路5—HBase的JavaAPI编程
W_chuanqi的博客
04-10 3590
关闭所有的项目，在Idea的启动页。
HBase Java客户端API操作示例教程
资源摘要信息:"本资源是一套HBase的Java客户端...HBase Java客户端API操作示例代码将帮助开发者学习和使用HBase进行数据分析和存储，能够快速上手HBase的基本操作，并理解如何将Java语言与HBase结合起来解决实际问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值