每周总结【2020/10/18】

　　本周也不知道是第几周，总结就完事了。这周学习的东西有很多，除了熟悉上周学习的Hadoop之外，软考也在进行备战中。本周收获最大的是Hbase方面的学习。

　　Hbase是基于Hadoop的，分布式、面向列的的开源数据库。是大数据学习中一大基础。Hbase的相关配置比Hadoop简单，由于本人的电脑运行内存只有8G，不能支持虚拟机多开，因此安装的Hbase与Hadoop一样是伪分布式的，下面附上个人认为比较详细的安装教程贴，对应Hbase版本是1.3.1

　　伪分布式Hbase配置:   https://blog.csdn.net/qq_42250913/article/details/86184606

　　Hbase的shell命令在网上有详细说明，在这里不多赘述。主要说明一下maven导入Hbase以及java的API操作。

　　pom.xml

<dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase-client</artifactId>
      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase-server</artifactId>
      <version>1.3.1</version>
    </dependency>

注意!!!导入Hbase的前提要求是Hadoop导入。

　　通过Hbase的java API操作完成对数据的增删改查，实现方式有很多，下面附上个人查找资料找到的一些实现方式。

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.util.ArrayList;
import java.util.List;

public class hbase_try {
    //以下是必要参数，因此static提前运行，用于连接Hbase
    private static Connection connection;
    private static Admin admin;
    static {
        try {
            Configuration conf=HBaseConfiguration.create();
            conf.set("hbase.zookeeper.quorum","hadoop01");
            connection = ConnectionFactory.createConnection(conf);
            admin = connection.getAdmin();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[]args) throws IOException {
        String[] family={"k1","k2"};
        String table="trytable";
        Bean bean=new Bean("001","PYD","20");
        Bean bean1=new Bean("002","KKK","21");
        Bean bean2=new Bean("003","PPP","22");
        CreateTable(table,family);
        insertData(table,bean);
        insertData(table,bean1);
        insertData(table,bean2);
        //获取未加处理的原生数据
        getNoDealData(table);
        //获取该列数据
        Bean rbean=getDataRowkey(table,"bean-001");
        System.out.println(rbean.toString());
        //获取指定单项数据
        String bean_user=getCellData(table,"bean-001","k1","user");
        System.out.println(bean_user);
        //获取表中全部数据
        List<Bean> list=getAllData(table);
        for(Bean beanc:list){
            System.out.println(beanc.toString());
        }
        //删除表中指定cell数据
        deleteByRowkey(table,"bean-003");
        List<Bean> list1=getAllData(table);
        for(Bean beanc1:list1){
            System.out.println(beanc1.toString());
        }
        //删除表
        DeleteTable(table);
    }
    //创建表
    public static void CreateTable(String tablename,String[]family)throws IOException{
        TableName tname=TableName.valueOf(tablename);
        if(admin.tableExists(tname)){
            System.out.println("table Exists!");
        }else{
            HTableDescriptor hTableDescriptor=new HTableDescriptor(TableName.valueOf(tablename));
            for(String f:family){
                HColumnDescriptor hColumnDescriptor=new HColumnDescriptor(f);
                hTableDescriptor.addFamily(hColumnDescriptor);
            }
            admin.createTable(hTableDescriptor);
            System.out.println("Over!");
        }
    }
    //删除表
    public static void DeleteTable(String tablename){
        try{
            TableName tname=TableName.valueOf(tablename);
            admin.disableTable(tname);
            admin.deleteTable(tname);
            System.out.println("Over!");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    //插入数据
    public static void insertData(String tablename,Bean bean)throws IOException{
        TableName tname=TableName.valueOf(tablename);
        Put put=new Put(("bean-"+bean.getId()).getBytes());
        put.addColumn("k1".getBytes(),"user".getBytes(),bean.getUser().getBytes());
        put.addColumn("k2".getBytes(),"num".getBytes(),bean.getNum().getBytes());
        Table table= connection.getTable(tname);
        table.put(put);
        System.out.println("Over!");
    }
    //获取原始数据
    public static void getNoDealData(String tablename){
        try{
            Table table=connection.getTable(TableName.valueOf(tablename));
            Scan scan=new Scan();
            ResultScanner resultScanner=table.getScanner(scan);
            for(Result result:resultScanner){
                System.out.println("scan:"+result);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    //根据Rowkey查询
    public static Bean getDataRowkey(String tablename,String rowkey)throws IOException{
        Table table=connection.getTable(TableName.valueOf(tablename));
        Get get=new Get(rowkey.getBytes());
        Bean bean=new Bean();
        bean.setId(rowkey);
        //判断是否有数据
        if(!get.isCheckExistenceOnly()){
            Result result=table.get(get);
            for(Cell cell:result.rawCells()){
                String colName=Bytes.toString(cell.getQualifierArray(),cell.getQualifierOffset(),cell.getQualifierLength());
                String value=Bytes.toString(cell.getValueArray(),cell.getValueOffset(),cell.getValueLength());
                if(colName.equals("user")){
                    bean.setUser(value);
                }
                if(colName.equals("num")){
                    bean.setNum(value);
                }
            }
        }
        return bean;
    }
    //查询指定单cell的内容
    public static String getCellData(String tablename,String rowkey,String family,String col){
        try{
            Table table=connection.getTable(TableName.valueOf(tablename));
            String result=null;
            Get get=new Get(rowkey.getBytes());
            if(!get.isCheckExistenceOnly()){
                get.addColumn(Bytes.toBytes(family),Bytes.toBytes(col));
                Result res=table.get(get);
                byte[]resByte=res.getValue(Bytes.toBytes(family),Bytes.toBytes(col));
                return result=Bytes.toString(resByte);
            }else{
                return result="NO Data!";
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return "ERROR!";
    }
    //查询指定表名中所有数据
    public static List<Bean> getAllData(String tablename){
        Table table=null;
        List<Bean> list=new ArrayList<Bean>();
        try{
            table=connection.getTable(TableName.valueOf(tablename));
            ResultScanner results=table.getScanner(new Scan());
            Bean bean=null;
            for(Result result:results){
                String id=new String(result.getRow());
                System.out.println("Bean:"+new String(result.getRow()));
                bean=new Bean();
                for(Cell cell:result.rawCells()){
                    String row=Bytes.toString(cell.getRowArray(),cell.getRowOffset(),cell.getRowLength());
                    String family=Bytes.toString(cell.getFamilyArray(),cell.getFamilyOffset(),cell.getFamilyLength());
                    String colName=Bytes.toString(cell.getQualifierArray(),cell.getQualifierOffset(),cell.getQualifierLength());
                    String value=Bytes.toString(cell.getValueArray(),cell.getValueOffset(),cell.getValueLength());
                    bean.setId(row);
                    if(colName.equals("user")){
                        bean.setUser(value);
                    }
                    if(colName.equals("num")) {
                        bean.setNum(value);
                    }
                }
                list.add(bean);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return list;
    }
    //删除指定cell数据
    public static void deleteByRowkey(String tablename,String rowkey)throws IOException{
        Table table=connection.getTable(TableName.valueOf(tablename));
        Delete delete=new Delete(Bytes.toBytes(rowkey));
        table.delete(delete);
        System.out.println("Over!");
    }
}

注意Hbase的一些方法是旧方法，若使用IDEA编写的话会发现一些方法被划上了线，因此记得查找新的方法如何实现，虽然老方法也不影响使用。比如上述代码中创建表的那一块，原构造方法没有使用Table.valueOf()这一方式。

　　在实际应用中我们查找不可能像刚才的代码那样简单查找，而且Hbase是按行列来查询的，若想像SQL语句那样按条件查找的话，需要使用过滤器Filter。Filter有很多种类，本周应测试要求，系统学习了SingleColumnValueFilter。先附上代码。

public static String getData(String JGMC,String SZDY,String JSXQMC,String GJZ) throws IOException, JSONException {
        Table table=connection.getTable(TableName.valueOf("OrganForm2"));
        Scan scan=new Scan();
        JSONArray array=new JSONArray();
        if(JGMC.trim().length()>0) {
            FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ONE);
            SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes("O1"),
                    Bytes.toBytes("JGMC"), CompareFilter.CompareOp.EQUAL ,Bytes.toBytes(JGMC));
            filterList.addFilter(filter);
            scan.setFilter(filterList);
        }

        if(SZDY.trim().length()>0) {
            FilterList filterList1 = new FilterList(FilterList.Operator.MUST_PASS_ONE);
            SingleColumnValueFilter filter1 = new SingleColumnValueFilter(Bytes.toBytes("O1"),
                    Bytes.toBytes("SZDY"), CompareFilter.CompareOp.EQUAL ,Bytes.toBytes(SZDY));
            filterList1.addFilter(filter1);
            scan.setFilter(filterList1);
        }

        if(JSXQMC.trim().length()>0) {
            FilterList filterList2 = new FilterList(FilterList.Operator.MUST_PASS_ONE);
            SingleColumnValueFilter filter2 = new SingleColumnValueFilter(Bytes.toBytes("O1"),
                    Bytes.toBytes("jsxqmc"), CompareFilter.CompareOp.EQUAL ,Bytes.toBytes(JSXQMC));
            filterList2.addFilter(filter2);
            scan.setFilter(filterList2);
        }

        if(GJZ.trim().length()>0) {
            FilterList filterList3 = new FilterList(FilterList.Operator.MUST_PASS_ONE);
            SingleColumnValueFilter filter3 = new SingleColumnValueFilter(Bytes.toBytes("O1"),
                    Bytes.toBytes("gjz"), CompareFilter.CompareOp.EQUAL ,Bytes.toBytes(GJZ));
            filterList3.addFilter(filter3);
            scan.setFilter(filterList3);
        }

        ResultScanner resultScanner=table.getScanner(scan);
        for(Result result:resultScanner){
            System.out.println(Bytes.toString(result.getRow()));
            JSONObject object=new JSONObject();
            object.put("JGMC", Bytes.toString(result.getValue(Bytes.toBytes("O1"), Bytes.toBytes("JGMC"))));
            object.put("SZDY", Bytes.toString(result.getValue(Bytes.toBytes("O1"), Bytes.toBytes("SZDY"))));
            object.put("JSXQMC", Bytes.toString(result.getValue(Bytes.toBytes("O1"), Bytes.toBytes("JSXQMC"))));
            object.put("GJZ", Bytes.toString(result.getValue(Bytes.toBytes("O1"), Bytes.toBytes("GJZ"))));
            object.put("YJLX", Bytes.toString(result.getValue(Bytes.toBytes("O1"), Bytes.toBytes("YJLX"))));
            object.put("JGSX", Bytes.toString(result.getValue(Bytes.toBytes("O1"), Bytes.toBytes("JGSX"))));
            array.add(object);
        }
        return array.toString();
    }

这里因为需要与HTML进行ajax交互，所以使用了json数组封装。由于我们遍历的数据不止一条，可能符合条件的语句有多条。所以需要将结果组合在一起。因此使用到了FilterList，它会在scan遍历后,将所有符合条件的数据条合在一起返回，注意此时直接输出的结果并不是存入时的数据，而是为了能够存入库而经过一次处理的"原生"数据，为了拿到真正的数据我们需要对每一条Filter进行处理，也就是代码中的Bytes.toString方法。SingleColunmnValueFilter在使用中对应的三个Bytes参数分别为"列族"，"列值"，以及查询用的条件值。

　　最后，说明一下在测试过程中踩到的坑。注意我们在提取数据的时候使用的是Bytes.toString方法进行byte[]转化成String，当我们在存入数据时同样要使用Bytes.toBytes进行String转化byte[]操作，有些帖子所写的转换操作是str.getBytes()，然而这样操作，英文数字以及一些字符可以正常读取，但是中文就会出现乱码问题！因此强烈建议使用Bytes.toBytes(str)进行转换存储。

Put put=new Put(("id-"+bean.getWJID()).getBytes());
            //推荐写法（二者存入的表结构不同，仅针对Bytes.toBytes(str)和str.getBytes()说明）
            put.addColumn(Bytes.toBytes("O1"),Bytes.toBytes("SFSH"),Bytes.toBytes(bean.getSFSH()));
            //不推荐写法：put.addColumn("k1".getBytes(),"user".getBytes(),bean.getUser().getBytes());