大数量学习序列之三 —– HBase Java Api 图文详解

引言

在上一篇中大数据学习序列之二 —–
HBase环境搭建(单机)

中,成功搭建了Hadoop+HBase的条件,本文则紧要讲述使用Java
对HBase的部分操作。

编者按:近日虚拟化技术一度突破虚拟内存和虚拟服务器两大空间,延伸到网络虚拟化、微处理器虚拟化、文件虚拟化和仓储虚拟化等众多世界。越来越多的铺面也早就在里头接纳虚拟化技术,那么公司实现虚拟化环境都有怎么样优势呢?

一、事前备选

即使现在云总括正大行其道,但公司虚拟化不应该被边缘化。遵照wired.com网站的Innovation
Insights专栏文章介绍,虚拟化可以扶持公司下降数据基本的碳排量,降低本钱开支和提供统计节点的全自动配置。换句话说,不要以为虚拟化已经不合时宜了。以下是信用社布局虚拟化所能享有的七大益处:

1.确认hadoop和hbase成功启动

澳门美高梅手机网站 1

一、整合

2.肯定防火墙是否关闭

那一个要用20台服务器来处理20项工作负荷的时日已经停止了。现在,购买两到三台大的服务器,然后在虚拟环境中运行五个干活负荷已化作可能的。简单说,运行这一个“模拟机”能够有无比浓厚的补益,包括更强大的资源整合。由于虚拟机(VM)能够被安排为基于特殊的需要周转应用程序或操作系统,在单机上组合不同的做事负荷,帮保持其依旧运转卓越已变为可能的。迁移到一个虚拟化的条件也给公司提供拿到“整合”的机遇,国际调研单位Forrester Research的大卫 Bartoletti将其名叫“整合率” 。而运行在情理服务器上的应用程序,并未充分利用所分配的资源,因为那个往往都是为虚拟化准备的。

3.maven所急需的依赖架包

<!--hadoop 相关架包 -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-mapreduce-client-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-yarn-common</artifactId>
            <version>2.8.2</version>
        </dependency>

<!--HBase相关jar -->
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-hadoop-compat</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>1.1.2</version>
        </dependency>
<dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.1.2</version>
        </dependency>
<dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-common</artifactId>
            <version>1.1.2</version>
        </dependency>

二、确保正常运行时刻

4.修改hosts文件(可选)

修改Windows C:\Windows\System32\drivers\etc
目录下的hosts文件,添加hbase的主机ip和主机名做涉嫌映射。

192.168.238.128 master

注:假使不采取映射,那么将代码中的主机名改成IP即可。

有了实时迁移,容错,高可用性那些功效,虚拟化服务器可以确保集团的工作量和健康运作时刻,并压缩意外停机的也许。尽管灾难袭来,迁移虚拟机也要比总计转移整个服务器的快照和内容所花费的年月和资源要少得多。

5.HBase的原理

这篇随笔介绍得很详细:
http://blog.csdn.net/woshiwanxin102213/article/details/17584043

三、改进配置时间

二、测试示例

行使软件定义的网络(SDN),作为公司网络和大体路由器之间的一个抽象层,允许工作负荷几乎分秒被安排。这样,虚拟环境便成为非凡的接纳测试和配置环境,因为资源可以遵照要求开展分配,然后要是他们不再需要就足以再次来到到网络“池”。此外,虚拟化可以扶助企业制伏VLAN的限量,其只同意4096个单身的网络。依靠三级域名和24位虚拟网络接口(VNIs)覆盖网络,同时,允许高达1600万个独立网络。

1.创建表

开创两张表 t_student、t_student_info 这两张表,并添加七个列族
制造成功之后方可在 hbase
shell和16010界面中看到。澳门美高梅手机网站 2

澳门美高梅手机网站 3

澳门美高梅手机网站 4

四、迈向云

2.添加数据

成功成立表之后,在这两张表中插入数据。
因为HBase是动态数据库,所以列是可以激增的。
澳门美高梅手机网站,HBase的激增和改动是一个办法,数据一致的,后来的数据会将前方的遮盖掉!
澳门美高梅手机网站 5

澳门美高梅手机网站 6

有关虚拟环境和云之间的底限往往存在着很多的眼花缭乱。在实践中,这两者是老大相似的,但依据商业消息 的通讯指出,“虚拟化与云总结的不同之处就在于虚拟化是用软件来支配硬件,而云统计是指服务所带动的操作的结果。” 然则,虚拟的商家条件,往往是信用社迈向云总括的美妙的垫脚石。

3.询问数据

各自按照表名、行健、列族、列来查询
澳门美高梅手机网站 7

五、细粒度安全

4.刨除数据

去除其中的一条数据
澳门美高梅手机网站 8

当工作负荷可以很有益的运作在具有虚拟服务器上时,就有可能建立细粒度安全磋商。这对于店铺而言是一个不得缺失的功效,其关系到医疗保健集团,金融业集团或政党机构,当每项工作负荷都可以举行单独安全的治本时,合规性就不再是一个挑衅了。

三、代码示例

六、分析

工具类

import java.io.IOException;
import java.util.ArrayList;
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.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

import com.alibaba.fastjson.JSONObject;

/**
 * 
 * Title: HBaseUtil
 * Description: HBase工具类 
 * Version:1.0.0
 * @author pancm
 * @date 2017年12月6日
 */
public class HBaseUtil {
    /** hadoop 连接 */
    private static Configuration conf = null;
    /** hbase 连接 */
    private static Connection con = null;
    /** 会话 */
    private static Admin admin = null;

    private static String ip ="master";
    private static String port ="2181";
    private static String port1 ="9001";

   // 初始化连接
   static {
       // 获得配制文件对象
       conf = HBaseConfiguration.create(); 
       // 设置配置参数
        conf.set("hbase.zookeeper.quorum", ip);
        conf.set("hbase.zookeeper.property.clientPort", port);  
        //如果hbase是集群,这个必须加上 
        //这个ip和端口是在hadoop/mapred-site.xml配置文件配置的
        conf.set("hbase.master", ip+":"+port1); 
   }


    /**
     * 获取连接
     * 
     * @return
     */
    public synchronized static Connection getConnection() {
        try {
            if (null == con || con.isClosed()) {
                // 获得连接对象
                con = ConnectionFactory.createConnection(conf);
            }
        } catch (IOException e) {
            System.out.println("获取连接失败!");
            e.printStackTrace();
        }

        return con;
    }

    /**
     * 连接关闭
     */
    public static void close() {
        try {
            if (admin != null) {
                admin.close();
            }
            if (con != null) {
                con.close();
            }
        } catch (IOException e) {
            System.out.println("连接关闭失败!");
            e.printStackTrace();
        }
    }

    /**
     * 创建表
     * 
     * @param tableName
     *            表名
     * @param columnFamily
     *            列族
     */
    public static void creatTable(String tableName, String[] columnFamily) {
        if(null==tableName||tableName.length()==0){
            return;
        }
        if(null==columnFamily||columnFamily.length==0){
            return;
        }
        // 创建表名对象
        TableName tn = TableName.valueOf(tableName);
        // a.判断数据库是否存在
        try {
            // 获取会话
            admin = getConnection().getAdmin();
            if (admin.tableExists(tn)) {
                System.out.println(tableName + " 表存在,删除表....");
                // 先使表设置为不可编辑
                admin.disableTable(tn);
                // 删除表
                admin.deleteTable(tn);
                System.out.println("表删除成功.....");
            }
            // 创建表结构对象
            HTableDescriptor htd = new HTableDescriptor(tn);
            for (String str : columnFamily) {
                // 创建列族结构对象
                HColumnDescriptor hcd = new HColumnDescriptor(str);
                htd.addFamily(hcd);
            }
            // 创建表
            admin.createTable(htd);
            System.out.println(tableName + " 表创建成功!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            close();
        }
    }

    /**
     * 数据单条插入或更新
     * 
     * @param tableName
     *            表名
     * @param rowKey
     *            行健 (主键)
     * @param family
     *            列族
     * @param qualifier
     *            列
     * @param value
     *            存入的值
     * @return
     */
    public static void insert(String tableName, String rowKey, String family,
            String qualifier, String value) {
        Table t = null;
        try {
            t = getConnection().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);
            System.out.println(tableName + " 更新成功!");
        } catch (IOException e) {
            System.out.println(tableName + " 更新失败!");
            e.printStackTrace();
        } finally {
            close();
        }
    }

    /**
     * 数据批量插入或更新
     * 
     * @param tableName
     *            表名
     * @param list
     *            hbase的数据 
     * @return
     */
    public static void insertBatch(String tableName, List<?> list) {
        if (null == tableName ||tableName.length()==0) {
            return;
        }
        if( null == list || list.size() == 0){
            return;
        }
        Table t = null;
        Put put = null;
        JSONObject json = null;
        List<Put> puts = new ArrayList<Put>();
        try {
            t = getConnection().getTable(TableName.valueOf(tableName));
            for (int i = 0, j = list.size(); i < j; i++) {
                json = (JSONObject) list.get(i);
                put = new Put(Bytes.toBytes(json.getString("rowKey")));
                put.addColumn(Bytes.toBytes(json.getString("family")),
                        Bytes.toBytes(json.getString("qualifier")),
                        Bytes.toBytes(json.getString("value")));
                puts.add(put);
            }
            t.put(puts);
            System.out.println(tableName + " 更新成功!");
        } catch (IOException e) {
            System.out.println(tableName + " 更新失败!");
            e.printStackTrace();
        } finally {
            close();
        }
    }

    /**
     * 数据删除 
     * @param tableName 表名
     * @param rowKey    行健
     * @return
     */
    public static void delete(String tableName, String rowKey) {
        delete(tableName,rowKey,"","");
    }

    /**
     * 数据删除 
     * @param tableName 表名
     * @param rowKey    行健
     * @param family    列族
     * @return
     */
    public static void delete(String tableName, String rowKey, String family) {
        delete(tableName,rowKey,family,"");
    }

    /**
     * 数据删除 
     * @param tableName 表名
     * @param rowKey    行健
     * @param family    列族
     * @param qualifier 列
     * @return
     */
    public static void delete(String tableName, String rowKey, String family,
            String qualifier) {
        if (null == tableName ||tableName.length()==0) {
            return;
        }
        if( null == rowKey || rowKey.length() == 0){
            return;
        }
        Table t = null;
        try {
            t = getConnection().getTable(TableName.valueOf(tableName));
            Delete del = new Delete(Bytes.toBytes(rowKey));
            // 如果列族不为空
            if (null != family && family.length() > 0) {
                // 如果列不为空
                if (null != qualifier && qualifier.length() > 0) {
                    del.addColumn(Bytes.toBytes(family),
                            Bytes.toBytes(qualifier));
                } else {
                    del.addFamily(Bytes.toBytes(family));
                }
            }      
            t.delete(del);    
        } catch (IOException e) {
            System.out.println("删除失败!");
            e.printStackTrace();
        } finally {
          close();
        }
    }

    /**
     * 查询该表中的所有数据
     * 
     * @param tableName
     *            表名
     */
    public static void select(String tableName) {
        if(null==tableName||tableName.length()==0){
            return;
        }
        Table t = null;
        List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
        try {
            t = getConnection().getTable(TableName.valueOf(tableName));
            // 读取操作
            Scan scan = new Scan();
            // 得到扫描的结果集
            ResultScanner rs = t.getScanner(scan);
            if (null == rs ) {
                return;
            }
            for (Result result : rs) {
                // 得到单元格集合
                List<Cell> cs = result.listCells();
                if (null == cs || cs.size() == 0) {
                    continue;
                }
                for (Cell cell : cs) {
                    Map<String,Object> map=new HashMap<String, Object>();
                    map.put("rowKey", Bytes.toString(CellUtil.cloneRow(cell)));// 取行健
                    map.put("timestamp", cell.getTimestamp());// 取到时间戳
                    map.put("family", Bytes.toString(CellUtil.cloneFamily(cell)));// 取到列族
                    map.put("qualifier", Bytes.toString(CellUtil.cloneQualifier(cell)));// 取到列
                    map.put("value", Bytes.toString(CellUtil.cloneValue(cell)));// 取到值
                    list.add(map);
                }
            }
            System.out.println("查询的数据:"+list);
        } catch (IOException e) {
            System.out.println("查询失败!");
            e.printStackTrace();
        } finally {
            close();
        }
    }

    /**
     * 根据表名和行健查询
     * @param tableName
     * @param rowKey
     */
    public static void select(String tableName, String rowKey) {
        select(tableName,rowKey,"","");
    }

    /**
     * 根据表名、行健和列族查询
     * @param tableName
     * @param rowKey
     * @param family
     */
    public static void select(String tableName, String rowKey, String family) {
        select(tableName,rowKey,family,"");
    }

    /**
     * 根据条件明细查询
     * 
     * @param tableName
     *            表名
     * @param rowKey
     *            行健 (主键)
     * @param family
     *            列族
     * @param qualifier
     *            列
     */
    public static void select(String tableName, String rowKey, String family,
            String qualifier) {
        Table t = null;
        List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
        try {
            t = getConnection().getTable(TableName.valueOf(tableName));
            // 通过HBase中的 get来进行查询
            Get get = new Get(Bytes.toBytes(rowKey));
            // 如果列族不为空
            if (null != family && family.length() > 0) {
                // 如果列不为空
                if (null != qualifier && qualifier.length() > 0) {
                    get.addColumn(Bytes.toBytes(family),
                            Bytes.toBytes(qualifier));
                } else {
                    get.addFamily(Bytes.toBytes(family));
                }
            }
            Result r = t.get(get);
            List<Cell> cs = r.listCells();
            if (null == cs || cs.size() == 0) {
                return;
            }
            for (Cell cell : cs) {
                Map<String,Object> map=new HashMap<String, Object>();
                map.put("rowKey", Bytes.toString(CellUtil.cloneRow(cell)));// 取行健
                map.put("timestamp", cell.getTimestamp());// 取到时间戳
                map.put("family", Bytes.toString(CellUtil.cloneFamily(cell)));// 取到列族
                map.put("qualifier", Bytes.toString(CellUtil.cloneQualifier(cell)));// 取到列
                map.put("value", Bytes.toString(CellUtil.cloneValue(cell)));// 取到值
                list.add(map);
            }
            System.out.println("查询的数据:"+list);
        } catch (IOException e) {
            System.out.println("查询失败!");
            e.printStackTrace();
        } finally {
            close();
        }
    }
}

虚拟化所提供的资源整合也使得集团能够动用实时的高层次的解析,以监测网络功能和钻井“大数量”拿到更大的考察价值。在观念的服务器实施那多少个解决方案也是唯恐的,但每每索要花费相当高的财力,而即便部署了虚拟化,分析工具在一切虚拟网络展开抓取已变为可能,不管是其它操作系统或工作负荷,这反过来又为公司更是提供了可操作的见地。

测试代码

import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.JSONObject;
/**
 * 
* Title: hbaseTest
* Description: HBase 相关测试
* Version:1.0.0  
* @author pancm
* @date 2017年11月23日
 */
public class hbaseTest {

    public static void main(String[] args) {
        test();
    }

    /**
     * 一些测试
     */
    private static void test() {
        String tableName1="t_student",tableName2="t_student_info";
        String []columnFamily1={"st1","st2"};
        String []columnFamily2={"stf1","stf2"};
        HBaseUtil.creatTable(tableName1, columnFamily1);
        HBaseUtil.creatTable(tableName2, columnFamily2);

        HBaseUtil.insert(tableName1, "1001", columnFamily1[0], "name", "zhangsan");
        HBaseUtil.insert(tableName1, "1002", columnFamily1[0], "name", "lisi");
        HBaseUtil.insert(tableName1, "1001", columnFamily1[1], "age", "18");
        HBaseUtil.insert(tableName1, "1002", columnFamily1[1], "age", "20");

        HBaseUtil.insert(tableName2, "1001", columnFamily2[0], "phone", "123456");
        HBaseUtil.insert(tableName2, "1002", columnFamily2[0], "phone", "234567");
        HBaseUtil.insert(tableName2, "1001", columnFamily2[1], "mail", "123@163.com");
        HBaseUtil.insert(tableName2, "1002", columnFamily2[1], "mail", "234@163.com");

        HBaseUtil.select(tableName1); //查询该表所有数据
        HBaseUtil.select(tableName1, "1001"); //根据表名和行健查询
        HBaseUtil.select(tableName2, "1002",columnFamily2[0]); //根据表名、行健和列族查询
        HBaseUtil.select(tableName2, "1002",columnFamily2[1],"mail"); //根据表名、行健、列族、和列查询

        HBaseUtil.select(tableName1, "1002"); //根据表名和行健查询
        HBaseUtil.delete(tableName1, "1002", columnFamily1[0]);//删除数据
        HBaseUtil.select(tableName1, "1002"); //根据表名和行健查询

    }
}

七、统一通信(UC)

公司虚拟化的结尾一个大利益是统一通信(UC)。援助实时录像、语音和网络聊天需求最简易的点子,是利用一个托管PBX和VoIP提供商来处理所有的外地通信需求。虚拟化这项工作代表你公司将不再依靠于传统的电信运营商,同时将数据存储在他乡意味着本土IT专业人士不需要操心管理总是的题材。

您的店铺考虑安排虚拟化了吧?整私营源,进步健康运转时刻和改进配置时间都是其从一起始就能拉动的很好的优势。而平安,方便迁移到云总结和强化洞察分析,以及对统一通信的支撑这么些元素都是集团布局虚拟化的益处。

小说转载自:http://www.sdnlab.com/6694.html

想要拿到更多实时情报,请关注:www.sdnlab.com

��

发表评论

电子邮件地址不会被公开。 必填项已用*标注