为了账号安全,请及时绑定邮箱和手机立即绑定

如何使用Java API操作Hbase

/ 猿问

如何使用Java API操作Hbase

三国纷争 2018-12-05 10:05:11

如何使用Java API操作Hbase


查看完整描述

1 回答

?
RISEBY
  1. 先导入hbase的相关jar包。

  2. 再根据api进行操作。

  3.  

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

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

package com.util;

 

import java.io.IOException;

import java.util.ArrayList;

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.TableName;

import org.apache.hadoop.hbase.ZooKeeperConnectionException;

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.HBaseAdmin;

import org.apache.hadoop.hbase.client.HTable;

import org.apache.hadoop.hbase.client.HTablePool;

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.filter.CompareFilter.CompareOp;

import org.apache.hadoop.hbase.filter.Filter;

import org.apache.hadoop.hbase.filter.FilterList;

import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;

import org.apache.hadoop.hbase.util.Bytes;

 

public class HBaseUtil {

 

    public static Configuration configuration;  

    static {  

        configuration = HBaseConfiguration.create();  

        configuration.set("hbase.zookeeper.property.clientPort", "2181");  

        configuration.set("hbase.zookeeper.quorum", "192.168.1.103");  

        configuration.set("hbase.master", "192.168.1.103:600000");  

    } 

     

    public static void main(String[] args) throws IOException {  

         createTable("abc");  

         insertData("abc");  

         QueryAll("abc");    

    }  

   

    /** 

     * 创建表 

     * @param tableName 

     */  

    public static void createTable(String tableName) {  

        System.out.println("start create table ......");  

        try {  

            HBaseAdmin hBaseAdmin = new HBaseAdmin(configuration);  

            if (hBaseAdmin.tableExists(tableName)) {// 如果存在要创建的表,那么先删除,再创建  

                hBaseAdmin.disableTable(tableName);  

                hBaseAdmin.deleteTable(tableName);  

                System.out.println(tableName + " is exist,detele....");  

            }  

            HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf(tableName));  

            tableDescriptor.addFamily(new HColumnDescriptor("column1"));  

            tableDescriptor.addFamily(new HColumnDescriptor("column2"));  

            tableDescriptor.addFamily(new HColumnDescriptor("column3"));  

            hBaseAdmin.createTable(tableDescriptor); 

             

            hBaseAdmin.close();

        } catch (MasterNotRunningException e) {  

            e.printStackTrace();  

        } catch (ZooKeeperConnectionException e) {  

            e.printStackTrace();  

        } catch (IOException e) {  

            e.printStackTrace();  

        }  

        System.out.println("end create table ......");  

    }  

   

    /** 

     * 插入数据 

     * @param tableName 

     * @throws IOException 

     */  

    public static void insertData(String tableName) throws IOException {  

        System.out.println("start insert data ......");  

        Connection connection = ConnectionFactory.createConnection(configuration);

            Table table = connection.getTable(TableName.valueOf(tableName));  

        Put put = new Put("112233bbbcccc".getBytes());// 一个PUT代表一行数据,再NEW一个PUT表示第二行数据,每行一个唯一的ROWKEY,此处rowkey为put构造方法中传入的值  

        put.add("column1".getBytes(), null, "aaa".getBytes());// 本行数据的第一列  

        put.add("column2".getBytes(), null, "bbb".getBytes());// 本行数据的第三列  

        put.add("column3".getBytes(), null, "ccc".getBytes());// 本行数据的第三列  

        try {  

            table.put(put);  

        } catch (IOException e) {  

            e.printStackTrace();  

        }  

        System.out.println("end insert data ......");  

    }  

   

    /** 

     * 删除一张表 

     * @param tableName 

     */  

    public static void dropTable(String tableName) {  

        try {  

            HBaseAdmin admin = new HBaseAdmin(configuration);  

            admin.disableTable(tableName);  

            admin.deleteTable(tableName);  

        } catch (MasterNotRunningException e) {  

            e.printStackTrace();  

        } catch (ZooKeeperConnectionException e) {  

            e.printStackTrace();  

        } catch (IOException e) {  

            e.printStackTrace();  

        }  

   

    }  

    /** 

     * 根据 rowkey删除一条记录 

     * @param tablename 

     * @param rowkey 

     */  

     public static void deleteRow(String tablename, String rowkey)  {  

        try {  

            HTable table = new HTable(configuration, tablename);  

            List list = new ArrayList();  

            Delete d1 = new Delete(rowkey.getBytes());  

            list.add(d1);  

               

            table.delete(list);  

            System.out.println("删除行成功!");  

               

        } catch (IOException e) {  

            e.printStackTrace();  

        }  

           

   

    }  

   

     /** 

      * 组合条件删除 

      * @param tablename 

      * @param rowkey 

      */  

     public static void deleteByCondition(String tablename, String rowkey)  {  

            //目前还没有发现有效的API能够实现 根据非rowkey的条件删除 这个功能能,还有清空表全部数据的API操作  

   

    }  

   

   

    /** 

     * 查询所有数据 

     * @param tableName 

     * @throws IOException 

     */  

    public static void QueryAll(String tableName) throws IOException {   

            Connection connection = ConnectionFactory.createConnection(configuration);

            Table table = connection.getTable(TableName.valueOf(tableName));

        try {  

            ResultScanner rs = table.getScanner(new Scan());  

            for (Result r : rs) {  

                System.out.println("获得到rowkey:" + new String(r.getRow()));  

                for (KeyValue keyValue : r.raw()) {  

                    System.out.println("列:" + new String(keyValue.getFamily())  

                            + "====值:" + new String(keyValue.getValue()));  

                }  

            }  

        } catch (IOException e) {  

            e.printStackTrace();  

        }  

    }  

   

    /** 

     * 单条件查询,根据rowkey查询唯一一条记录 

     * @param tableName 

     */  

    public static void QueryByCondition1(String tableName) {  

   

        HTablePool pool = new HTablePool(configuration, 1000);  

        HTable table = (HTable) pool.getTable(tableName);  

        try {  

            Get scan = new Get("abcdef".getBytes());// 根据rowkey查询  

            Result r = table.get(scan);  

            System.out.println("获得到rowkey:" + new String(r.getRow()));  

            for (KeyValue keyValue : r.raw()) {  

                System.out.println("列:" + new String(keyValue.getFamily())  

                        + "====值:" + new String(keyValue.getValue()));  

            }  

        } catch (IOException e) {  

            e.printStackTrace();  

        }  

    }  

   

    /** 

     * 单条件按查询,查询多条记录 

     * @param tableName 

     */  

    public static void QueryByCondition2(String tableName) {  

   

        try {  

            HTablePool pool = new HTablePool(configuration, 1000);  

            HTable table = (HTable) pool.getTable(tableName);  

            Filter filter = new SingleColumnValueFilter(Bytes  

                    .toBytes("column1"), null, CompareOp.EQUAL, Bytes  

                    .toBytes("aaa")); // 当列column1的值为aaa时进行查询  

            Scan s = new Scan();  

            s.setFilter(filter);  

            ResultScanner rs = table.getScanner(s);  

            for (Result r : rs) {  

                System.out.println("获得到rowkey:" + new String(r.getRow()));  

                for (KeyValue keyValue : r.raw()) {  

                    System.out.println("列:" + new String(keyValue.getFamily())  

                            + "====值:" + new String(keyValue.getValue()));  

                }  

            }  

        } catch (Exception e) {  

            e.printStackTrace();  

        }  

   

    }  

   

    /** 

     * 组合条件查询 

     * @param tableName 

     */  

    public static void QueryByCondition3(String tableName) {  

   

        try {  

            HTablePool pool = new HTablePool(configuration, 1000);  

            HTable table = (HTable) pool.getTable(tableName);  

   

            List<Filter> filters = new ArrayList<Filter>();  

   

            Filter filter1 = new SingleColumnValueFilter(Bytes  

                    .toBytes("column1"), null, CompareOp.EQUAL, Bytes  

                    .toBytes("aaa"));  

            filters.add(filter1);  

   

            Filter filter2 = new SingleColumnValueFilter(Bytes  

                    .toBytes("column2"), null, CompareOp.EQUAL, Bytes  

                    .toBytes("bbb"));  

            filters.add(filter2);  

   

            Filter filter3 = new SingleColumnValueFilter(Bytes  

                    .toBytes("column3"), null, CompareOp.EQUAL, Bytes  

                    .toBytes("ccc"));  

            filters.add(filter3);  

   

            FilterList filterList1 = new FilterList(filters);  

   

            Scan scan = new Scan();  

            scan.setFilter(filterList1);  

            ResultScanner rs = table.getScanner(scan);  

            for (Result r : rs) {  

                System.out.println("获得到rowkey:" + new String(r.getRow()));  

                for (KeyValue keyValue : r.raw()) {  

                    System.out.println("列:" + new String(keyValue.getFamily())  

                            + "====值:" + new String(keyValue.getValue()));  

                }  

            }  

            rs.close();  

   

        } catch (Exception e) {  

            e.printStackTrace();  

        }  

   

    }  

     

}


 


查看完整回答
反对 回复 2018-12-22
  • 1 回答
  • 0 关注
  • 281 浏览
我要回答

添加回答

回复

举报

0/150
提交
取消
意见反馈 帮助中心 APP下载
官方微信