hbase基本操作源码

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
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
package homework;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
 
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.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 Test_Two {
 
    public static Configuration configuration;
    public static Connection connection;
    public static Admin admin;
 
 
    //建立连接
    public static void init(){
        configuration  = HBaseConfiguration.create();
        configuration.set("hbase.rootdir","hdfs://localhost:8020/hbase");
        try{
            connection = ConnectionFactory.createConnection(configuration);
            admin = connection.getAdmin();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    //关闭连接
    public static void close(){
        try{
            if(admin != null){
                admin.close();
            }
            if(null != connection){
                connection.close();
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
 
 
    public static void createTable(String tableName,String[] fields) throws IOException {
 
        init();
        TableName tablename = TableName.valueOf(tableName);
 
        if(admin.tableExists(tablename)){
            System.out.println("表已存在，将执行删除原表，重建新表!");
            admin.disableTable(tablename);
            admin.deleteTable(tablename);//删除原来的表
        }
        HTableDescriptor hTableDescriptor = new HTableDescriptor(TableName.valueOf(tableName));
        for(String str:fields){
            HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(str);
            hTableDescriptor.addFamily(hColumnDescriptor);
        }
        admin.createTable(hTableDescriptor);
        System.out.println("表已创建成功");
 
        close();
    }
 
    /**
     * 向表 tableName、行 row（用 S_Name 表示）和字符串数组 fields 指定的单元格中
     * 添加对应的数据 values。
     * 其中，fields 中每个元素如果对应的列族下还有相应的列限定符的话，
     * 用“columnFamily:column”表示。
     * 例如，同时向“Math”、“Computer Science”、“English”三列添加成绩时，
     * 字符串数组 fields 为{“Score:Math”, ”Score:Computer Science”, ”Score:English”}，
     * 数组values 存储这三门课的成绩。
     */
    public static void addRecord(String tableName,String rowKey,String []fields,String [] values) throws IOException {
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        for (int i = 0; i < fields.length; i++) {
            Put put = new Put(rowKey.getBytes());
            String [] cols = fields[i].split(":");
            if(cols.length==1)
            {
 
                put.addColumn(cols[0].getBytes(), "".getBytes(), values[i].getBytes());//因为当输入的是单列族，split仅读出一个字符字符串，即cols仅有一个元素
            }
            else {
                put.addColumn(cols[0].getBytes(), cols[1].getBytes(), values[i].getBytes());
            }
            table.put(put);
        }
        table.close();
        close();
    }
 
    /**
     * 根据表名查找表信息
     */
    public static void getData(String tableName)throws  IOException{
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Scan scan = new Scan();
        ResultScanner scanner = table.getScanner(scan);
 
        for(Result result:scanner)
        {
            showCell((result));
        }
        close();
    }
 
    /**
     * 格式化输出
     * @param result
     */
    public static void showCell(Result result){
        Cell[] cells = result.rawCells();
        for(Cell cell:cells){
            System.out.println("RowName(行键):"+new String(CellUtil.cloneRow(cell))+" ");
            System.out.println("Timetamp(时间戳):"+cell.getTimestamp()+" ");
            System.out.println("column Family（列簇）:"+new String(CellUtil.cloneFamily(cell))+" ");
            System.out.println("column Name（列名）:"+new String(CellUtil.cloneQualifier(cell))+" ");
            System.out.println("value:（值）"+new String(CellUtil.cloneValue(cell))+" ");
            System.out.println();
        }
    }
    /**
     * 浏览表 tableName 某一列的数据，如果某一行记录中该列数据不存在，则返回 null。
     * 要求当参数 column 为某一列族名称时，如果底下有若干个列限定符，则要列出每个列限定符代表的列的数据；
     * 当参数 column 为某一列具体名称（例如“Score:Math”）时，只需要列出该列的数据。
     * @param tableName
     * @param column
     * @throws IOException
     */
    public static void scanColumn (String tableName,String column) throws IOException
    {
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Scan scan = new Scan();
        String [] cols = column.split(":");
 
        if(cols.length==1)
        {
            scan.addFamily(Bytes.toBytes(column));
        }
        else {
 
            scan.addColumn(Bytes.toBytes(cols[0]),Bytes.toBytes(cols[1]));
        }
        ResultScanner scanner = table.getScanner(scan);
        for (Result result = scanner.next(); result !=null;result = scanner.next()) {
            showCell(result);
        }
        table.close();
        close();
    }
 
 
    /**
     * 修改表 tableName，行 row（可以用学生姓名 S_Name 表示），列 column 指定的单元格的数据。
     * @throws IOException
     */
    public static void modifyData(String tableName,String rowKey,String column,String value) throws IOException
    {
 
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Put put = new Put(rowKey.getBytes());
        String [] cols = column.split(":");
        if(cols.length==1)
        {
            put.addColumn(column.getBytes(),"".getBytes() , value.getBytes());//qualifier:列族下的列名
        }
        else {
 
            put.addColumn(cols[0].getBytes(),cols[1].getBytes() , value.getBytes());//qualifier:列族下的列名
        }
        table.put(put);
        table.close();
        close();
    }
 
 
 
    /**
     * 删除表 tableName 中 row 指定的行的记录。
     * @throws IOException
     */
    public static void deleteRow(String tableName,String rowKey) throws IOException
    {
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Delete delete = new Delete(rowKey.getBytes());
 
        table.delete(delete);
        table.close();
        close();
 
    }
 
    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
        Test_Two test_Two = new Test_Two();
 
        boolean flag =true;
        while(flag)
        {
            System.out.println("------------------------------------------------提供以下功能----------------------------------------------");
            System.out.println("                       1- createTable（创建表  ,提供表名、列族名）                                      ");
            System.out.println("                       2-addRecord （向已知表名、行键、列簇的表添加值）                       ");
            System.out.println("                       3- ScanColumn（浏览表     某一列的数据）                                            ");
            System.out.println("                       4- modifyData（修改某表   某行，某一列，指定的单元格的数据）    ");
            System.out.println("                       5- deleteRow（删除 某表   某行的记录）                                                 ");
            System.out.println("------------------------------------------------------------------------------------------------------------------");
            Scanner scan = new Scanner(System.in);
            String choose1=scan.nextLine();
            switch (choose1) {
                case "1":
                {
                    System.out.println("请输入要创建的表名");
                    String tableName=scan.nextLine();
                    System.out.println("请输入要创建的表的列族个数");
                    int Num=scan.nextInt();
                    String [] fields = new String[Num];
                    System.out.println("请输入要创建的表的列族");
                    /* Scanner scanner = new Scanner(System.in);     scanner.next 如不是全局，即会记得上一次输出。相同地址读入值时*/
                    for(int i=0;i< fields.length;i++)
                    {
/*BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
fields[i] = in.readLine();*/
                        /*fields[i]=scan.next(); 因为之前没有输入过，所以可以读入新值*/
                        scan = new Scanner(System.in);
                        fields[i]=scan.nextLine();
                    }
                    System.out.println("正在执行创建表的操作");
                    test_Two.createTable(tableName,fields);
                    break;
                }
                case "2":
                {
                    System.out.println("请输入要添加数据的表名");
                    String tableName=scan.nextLine();
                    System.out.println("请输入要添加数据的表的行键");
                    String rowKey=scan.nextLine();
 
                    System.out.println("请输入要添加数据的表的列的个数");
                    int num =scan.nextInt();
                    String fields[]=new String[num];
                    System.out.println("请输入要添加数据的表的列信息 共"+num+"条信息");
                    for(int i=0;i< fields.length;i++)
                    {
                        BufferedReader in3= new BufferedReader(new InputStreamReader(System.in));
                        fields[i] = in3.readLine();
                        /*fields[i]=scan.next(); 因为之前没有输入过，所以可以读入新值*/
 
                    }
                    System.out.println("请输入要添加的数据信息 共"+num+"条信息");
                    String values[]=new String[num];
                    for(int i=0;i< values.length;i++)
                    {
                        BufferedReader in2 = new BufferedReader(new InputStreamReader(System.in));
                        values[i] = in2.readLine();
 
                    }
                    System.out.println("原表信息");
                    test_Two.getData(tableName);
                    System.out.println("正在执行向表中添加数据的操作........\n");
                    test_Two.addRecord(tableName, rowKey, fields, values);
                    System.out.println("\n添加后的表的信息........");
                    test_Two.getData(tableName);
                    break;
                }
                case "3":
                {
                    System.out.println("请输入要查看数据的表名");
                    String tableName=scan.nextLine();
                    System.out.println("请输入要查看数据的列名");
                    String column=scan.nextLine();
                    System.out.println("查看的信息如下：........\n");
                    test_Two.scanColumn(tableName, column);
                    break;
                }
                case "4":
                {
                    System.out.println("请输入要修改数据的表名");
                    String tableName=scan.nextLine();
                    System.out.println("请输入要修改数据的表的行键");
                    String rowKey=scan.nextLine();
                    System.out.println("请输入要修改数据的列名");
                    String column=scan.nextLine();
                    System.out.println("请输入要修改的数据信息  ");
                    String value=scan.nextLine();
                    System.out.println("原表信息如下：........\n");
                    test_Two.getData(tableName);
                    System.out.println("正在执行向表中修改数据的操作........\n");
                    test_Two.modifyData(tableName, rowKey, column, value);
                    System.out.println("\n修改后的信息如下：........\n");
                    test_Two.getData(tableName);
 
 
                    break;
                }
                case "5":
                {
                    System.out.println("请输入要删除指定行的表名");
                    String tableName=scan.nextLine();
                    System.out.println("请输入要删除指定行的行键");
                    String rowKey=scan.nextLine();
                    System.out.println("原表信息如下：........\n");
                    test_Two.getData(tableName);
                    System.out.println("正在执行向表中删除数据的操作........\n");
                    test_Two.deleteRow(tableName, rowKey);
                    System.out.println("\n删除后的信息如下：........\n");
                    test_Two.getData(tableName);
                    break;
                }
                default:
                {
                    System.out.println("   你的操作有误 ！！！    ");
                    break;
                }
            }
            System.out.println(" 你要继续操作吗？ 是-true 否-false ");
            flag=scan.nextBoolean();
        }
        System.out.println("   程序已退出！    ");
    }
 
}