至少掌握五点&＃xff1a;

1.    深入理解HTable&＃xff0c;掌握如何结合业务涉及高性能的HTable。

2.    掌握与HBase的交互&＃xff0c;通过HBase Shell命令及Java API进行数据的增删改查。

3.    掌握如何用MapReduce分析HBase里的数据

4.    掌握如何测试HBase MapReduce。

HBase简介&＃xff1a;

         HBase在产品中还包含了Jetty&＃xff0c;在HBase启动时采用嵌入式的方式来启动Jetty&＃xff0c;因此可以通过web界面对HBase进行管理和查看当前运行的一些状态&＃xff0c;非常轻巧。

简单来说&＃xff0c;你在HBase中的表创建的可以看做是一张很大的表&＃xff0c;而这个表的属性可以根据需求去动态增加&＃xff0c;在HBase中没有表与表之间关联查询。

列存储

HStore存储是HBase存储的核心了&＃xff0c;其中由两部分组成&＃xff0c;一部分是MemStore&＃xff0c;一部分是StoreFiles。MemStore是Sorted Memory Buffer&＃xff0c;用户写入的数据首先会放入MemStore&＃xff0c;当MemStore满了以后会Flush成一个StoreFile&＃xff08;底层实现是HFile&＃xff09;&＃xff0c;当StoreFile文件数量增长到一定阈值&＃xff0c;会触发Compact合并操作&＃xff0c;将多个StoreFiles合并成一个StoreFile&＃xff0c;合并过程中会进行版本合并和数据删除&＃xff0c;因此可以看出HBase其实只有增加数据&＃xff0c;所有的更新和删除操作都是在后续的compact过程中进行的&＃xff0c;这使得用户的写操作只要进入内存中就可以立即返回&＃xff0c;保证了HBase I/O的高性能。当StoreFilesCompact后&＃xff0c;会逐步形成越来越大的StoreFile&＃xff0c;当单个StoreFile大小超过一定阈值后&＃xff0c;会触发Split操作&＃xff0c;同时把当前Region Split成2个Region&＃xff0c;父Region会下线&＃xff0c;新Split出的2个孩子Region会被HMaster分配到相应的HRegionServer上&＃xff0c;使得原先1个Region的压力得以分流到2个Region上。

HFile里面的每个KeyValue对就是一个简单的byte数组。

 HRegion是Hbase中分布式存储和负载均衡的最小单元。最小单元就表示不同的Hregion可以分布在不同的HRegion server上。但一个Hregion是不会拆分到多个server上的。

HFile格式&＃xff1a;

一、HBase基本概念&＃xff1a;

2个主要概念&＃xff1a;

a) Rowkey: Hbase 中的记录是按照rowkey来排序的&＃xff1b;

b) Column family&＃xff1a;(列族)是在系统启动之前预先定义好的&＃xff1b;

c) Hbase优缺点&＃xff1a;

1.不支持条件查询以及orderby等查询&＃xff1b;

2.列可以动态增加&＃xff0c;列为空则不存储数据&＃xff0c;节省存储空间&＃xff1b;

3.会自动切分数据&＃xff1b;4.可以提供高并发读写操作的支持&＃xff1b;

访问方式&＃xff1a; 访问hbasetable中的行&＃xff0c;只有三种方式&＃xff1a;

1 通过单个row key访问

2 通过row key的range

3 全表扫描

Row key&＃xff1a;行键 (Row key)可以是任意字符串(最大长度是 64KB&＃xff0c;实际应用中长度一般为 10-100bytes)&＃xff0c;在hbase内部&＃xff0c;row key保存为字节数组。

存储&＃xff1a;  HBase以表的形式存储数据。表有行和列组成&＃xff0c;存储时&＃xff0c;数据按照Row key的字典序(byte order)排序存储。设计key时&＃xff0c;要充分排序存储这个特性&＃xff0c;将经常一起读取的行存储放到一起。(位置相关性) 

存储类型&＃xff1a;  TableName 是字符串

RowKey 和 ColumnName 是二进制值&＃xff08;Java 类型 byte[]&＃xff09;

Timestamp 是一个 64 位整数&＃xff08;Java 类型 long&＃xff09;

value 是一个字节数组&＃xff08;Java类型 byte[]&＃xff09;

存储结构&＃xff1a;即HTable按Row key自动排序&＃xff0c;每个Row包含任意数量个Columns&＃xff0c;Columns之间按Columnkey自动排序&＃xff0c;每个Column包含任意数量个Values。理解该存储结构将有助于查询结果的迭代。

        (RowKey,List(SortedMap(column,List(value,TimeStamp))))

列簇&＃xff1a;hbase表中的每个列&＃xff0c;都归属与某个列族。列名都以列族作为前缀。

         HBase中的列可以动态新增。

存储单元&＃xff1a;HBase中通过row和columns确定的为一个存贮单元称为cell。

            每个cell都保存着同一份数据的多个版本。版本通过时间戳来索引。

HBase为null的Column不会被存储&＃xff0c;这样既节省了空间又提高了读性能

cell中的数据是没有类型的&＃xff0c;全部是字节码形式存贮

两种数据版本回收方式&＃xff1a;一是保存数据的最后n个版本

二是保存最近一段时间内的版本&＃xff08;比如最近七天&＃xff09;

用户可以针对每个列族进行设置值value&＃xff1a;每个值由4个键唯一索引

tableName&＃43;RowKey&＃43;ColumnKey&＃43;Timestamp&＃61;>value

二、搭建HBase环境&＃xff1a;

http://hbase.apache.org/book/quickstart.html和http://hbase.apache.org/book/notsoquick.html。 如果你在windows环境下配置cygwin及ssh遇到问题可以参考http://qa.taobao.com/?p&＃61;10633

1.    创建一个Maven工程。

mvn archetype:generate-DgroupId&＃61;com.alibaba.webx -DartifactId&＃61;tutorial1 -Dversion&＃61;1.0-SNAPSHOT -Dpackage&＃61;com.alibaba.webx.tutorial1-DarchetypeArtifactId&＃61;archetype-webx-quickstart-DarchetypeGroupId&＃61;com.alibaba.citrus.sample-DarchetypeVersion&＃61;1.0-SNAPSHOT -DinteractiveMode&＃61;false

 cmd进入刚才建立的项目&＃xff0c;运行&＃xff1a;mvn jetty:run   在浏览器中打开&＃xff1a;localhost:8081就可以看到我们新建的webx项目了。具体里面是怎么运行的&＃xff0c;可以查看webx用户手册。

2.    加入Hadoop、HBase依赖&＃xff1a;

3.    在src/test/resources目录下新建文件conf/hbase-site.xml

文件具体配置为&＃xff1a;

[java] view plaincopy

1.   
2.     
3.      hbase.zookeeper.property.clientPort  
4.       2222  
5.      
6.      
7.      hbase.zookeeper.quorum  
8.       xxx.xxx.xxx.xxx.xxx  
9.      
10.  "true">  
11.  hbase.defaults.for.version  
12.  0.90.2  
13.     
14.    

配置你工程要使用的zookeeper客户端端口号和zookeeper的地址&＃xff0c;这个地址可以向开发索要。

 

4.    写测试文件&＃xff1a;

[java] view plaincopy

1. public class HbaseTest {  
2.        private static Configuration conf &＃61; null;  
3.          static {  
4.             conf &＃61; HBaseConfiguration.create();  
5.            conf.addResource("conf/hbase-site.xml");  
6.       }}  

       如果不报错&＃xff0c;表示链接已经通过&＃xff0c;接下来就可以创建表以及对表的增删改查了。

三、基础知识&＃xff1a;

1.     通过HBase shell 与HBase交互&＃xff1a;

              进入控制台&＃xff1a;bin/hbase shell

              创建表&＃xff1a;create ‘表名’,’列簇名’,’列簇名’

              增加记录&＃xff1a;put ‘表名’,’Row Key’,’列簇名&＃xff1a;列名’,’value’

              查询&＃xff1a;get ‘表名’,’Row Key’

              删除&＃xff1a;delete‘表名’,’Row Key’,’列簇名&＃xff1a;列名’  &＃xff08;只能删除一列&＃xff09;

                      delete‘表名’,’Row Key’                    &＃xff08;删除RowKey的所有列&＃xff09;

              删除表&＃xff1a;>disable ‘表名’

                        >drop ‘表名’

2.     通过Java 的API与HBase交互&＃xff1a;

              步骤一&＃xff1a;

                     创建一个Maven工程加入依赖&＃xff1a;

[java] view plaincopy

1.                     
2. org.apache.hbase  
3. hbase  
4. 0.90.2  
5.   

如果你的Maven库里还没有hbase&＃xff0c;还需要配置下repository:

[java] view plaincopy

1.          
2.   
3. cloudera  
4. https://repository.cloudera.com/content/groups/public  
5.   
6.   

                     步骤二&＃xff1a;

                              确保HBase环境已启动且能连接到&＃xff0c;将HBase环境的hbase-site.xml文件拷贝到上述工程的src/test/resources目录

                     加载配置->创建表->增加记录->根据RowKey查询->遍历查询与迭代->删除记录->删除表

 

                  具体操作可以参考&＃xff1a;http://qa.taobao.com/?p&＃61;13894

                                    http://www.cnblogs.com/panfeng412/archive/2011/08/14/2137984.html

四、深入理解HBase&＃xff1a;

思考&＃xff1a;HBase服务器内部由那些主要部件构成&＃xff1f;

HBase的内部工作原理是什么&＃xff1f;

1.    HBase的工作原理&＃xff1a;

                  首先HBase Client端会连接Zookeeper Qurom(从下面的代码也能看出来&＃xff0c;例如&＃xff1a;HBASE_CONFIG.set("hbase.zookeeper.quorum","192.168.50.216") )。通过Zookeeper组件Client能获知哪个Server管理-ROOT-Region。那么Client就去访问管理-ROOT-的Server&＃xff0c;在META中记录了HBase中所有表信息&＃xff0c;(你可以使用 scan &＃39;.META.&＃39; 命令列出你创建的所有表的详细信息),从而获取Region分布的信息。一旦Client获取了这一行的位置信息&＃xff0c;比如这一行属于哪个Region&＃xff0c;Client将会缓存这个信息并直接访问HRegionServer。久而久之Client缓存的信息渐渐增多&＃xff0c;即使不访问.META.表也能知道去访问哪个HRegionServer。HBase中包含两种基本类型的文件&＃xff0c;一种用于存储WAL的log&＃xff0c;另一种用于存储具体的数据&＃xff0c;这些数据都通过DFS Client和分布式的文件系统HDFS进行交互实现存储。

2.    Client访问数据过程&＃xff1a;

Client访问用户数据之前需要首先访问zookeeper&＃xff0c;然后访问-ROOT-表&＃xff0c;接着访问.META.表&＃xff0c;最后才能找到用户数据的位置去访问&＃xff0c;中间需要多次网络操作&＃xff0c;不过client端会做cache缓存。

-ROOT-表、.META都是存放在哪里&＃xff1f;&＃xff1f;

client访问hbase上数据的过程并不需要master参与&＃xff08;寻址访问zookeeper和region server&＃xff0c;数据读写访问region server&＃xff09;&＃xff0c;master仅仅维护者table和region的元数据信息&＃xff0c;负载很低。

3.    在HBase上进行MapReduce操作&＃xff1a;

4.    HBase系统架构&＃xff1a;

　　        HBase Client使用HBase的RPC机制与HMaster和HRegionServer进行通信&＃xff0c;对于管理类操作&＃xff0c;Client与HMaster进行RPC&＃xff1b;对于数据读写类操作&＃xff0c;Client与HRegionServer进行RPC

5.    Zookeeper&＃xff1a;

                  Zookeeper简单说就是协调和服务于分布式应用程序的服务。

　　        Zookeeper Quorum中除了存储了-ROOT-表的地址和HMaster的地址&＃xff0c;HRegionServer也会把自己以Ephemeral方式注册到Zookeeper中&＃xff0c;使得HMaster可以随时感知到各个HRegionServer的健康状态。此外&＃xff0c;Zookeeper也避免了HMaster的单点问题。

1 保证任何时候&＃xff0c;集群中只有一个master

2存贮所有Region的寻址入口。

3 实时监控RegionServer的状态&＃xff0c;将Region server的上线和下线信息实时通知给Master

4 存储Hbase的schema,包括有哪些table&＃xff0c;每个table有哪些column family

 

Zookeeper到底为我们干了什么&＃xff1f;

1.    集中配置&＃xff1a;可以APP1的配置配置到/APP1 znode下的所有机器。

2.    集群管理&＃xff1a;同步&＃xff1a;维护活机列表(让集群所有机器得到实时更新)&＃xff0c;

组服务&＃xff1a;从集群中选择Master。

3.    …..

参考&＃xff1a;http://hi.baidu.com/surendaxiao/blog/item/cb1b42f86b03084e252df233.html

6.    HMaster&＃xff1a;

　　HMaster没有单点问题&＃xff0c;HBase中可以启动多个HMaster&＃xff0c;通过Zookeeper的MasterElection机制保证总有一个Master运行&＃xff0c;HMaster在功能上主要负责Table和Region的管理工作&＃xff1a;

　　1. 管理用户对Table的增、删、改、查操作

　　2. 管理HRegionServer的负载均衡&＃xff0c;调整Region分布

　　3. 在Region Split后&＃xff0c;负责新Region的分配

　　4. 在HRegionServer停机后&＃xff0c;负责失效HRegionServer 上的Regions迁移

7.    HRegionServer&＃xff1a;

　　HRegionServer主要负责响应用户I/O请求&＃xff0c;向HDFS文件系统中读写数据&＃xff0c;是HBase中最核心的模块。

　　HRegionServer内部管理了一系列HRegion对象&＃xff0c;每个HRegion对应了Table中的一个Region&＃xff0c;HRegion中由多个HStore组成。每个HStore对应了Table中的一个ColumnFamily的存储&＃xff0c;可以看出每个Column Family其实就是一个集中的存储单元&＃xff0c;因此最好将具备共同IO特性的column放在一个ColumnFamily中&＃xff0c;这样最高效。

 

思考&＃xff1a; 

 

 

8.    Hadoop&＃43;HBase&＃43;Zookeeper三者关系&＃xff1a;

1.经过Map、Reduce运算后产生的结果看上去是被写入到HBase了&＃xff0c;但是其实HBase中HLog和StoreFile中的文件在进行flush to disk操作时&＃xff0c;这两个文件存储到了HDFS的DataNode中&＃xff0c;HDFS才是永久存储。

2.ZooKeeper跟HadoopCore、HBase有什么关系呢&＃xff1f;ZooKeeper都提供了哪些服务呢&＃xff1f;主要有&＃xff1a;管理Hadoop集群中的NameNode&＃xff0c;HBase中HBaseMaster的选举&＃xff0c;Servers之间状态同步等。具体一点&＃xff0c;细一点说&＃xff0c;单只HBase中ZooKeeper实例负责的工作就有&＃xff1a;存储HBase的Schema&＃xff0c;实时监控HRegionServer,存储所有Region的寻址入口&＃xff0c;当然还有最常见的功能就是保证HBase集群中只有一个Master。

 

Hadoop、ZooKeeper和HBase之间应该按照顺序启动和关闭&＃xff1a;启动Hadoop—>启动ZooKeeper集群—>启动HBase—>停止HBase—>停止ZooKeeper集群—>停止Hadoop。

参考&＃xff1a;http://www.tbdata.org/archives/1509

 

五&＃xff1a;理解Hadoop&＃xff1a;

Hadoop学习网址&＃xff1a;http://book.51cto.com/art/201106/269616.htm

 

1.    MapReduce

(1)   MapReduce基础&＃xff1a;
一个简单的MapReduce程序需要三样东西
1. 实现Mapper&＃xff0c;处理输入的对&＃xff0c;输出中间结果
2. 实现Reduce&＃xff0c;对中间结果进行运算&＃xff0c;输出最终结果
3. 在main方法里定义运行作业&＃xff0c;定义一个job&＃xff0c;在这里控制job如何运行等。

Mapper接口&＃xff1a;是一个泛型&＃xff0c;有4个形式的参数类型&＃xff0c;分别指定map函数的输入键&＃xff0c;输入值&＃xff0c;输出键&＃xff0c;输出值。

数据类型&＃xff1a;Hadoop规定了自己的一套可用于网络序列优化的基本类型&＃xff0c;而不是使用内置的java类型&＃xff0c;这些都在org.apache.hadoop.io包中定义&＃xff0c;上面使用的Text类型相当于java的String类型&＃xff0c;IntWritable类型相当于java的Integer类型。

          Maper  和Reducer 可以理解为分久必合&＃xff0c;合久必分&＃xff01;

                            Maper是将任务切分成很多个小任务&＃xff0c;分配给不同的工作者去完成

                          Reducer是将哪些工作者做完的工作结果收集起来加以整理汇总成最后结果。

总结&＃xff1a;job的配置有着复杂的属性参数&＃xff0c;如文件分割策略、排序策略、map输出内存缓冲区的大小、工作线程数量等&＃xff0c;深入理解掌握这些参数才能使自己的MapReduce程序在集群环境中运行的最优。

(2)深入理解MapReduce&＃xff1a;

        &＃xff08;1&＃xff09;在map进行之前&＃xff0c;需要对输入文件在客户端先进行“分片”&＃xff0c;然后将分片信息上传到HDFS。

        &＃xff08;2&＃xff09;分片上传结束后&＃xff0c;jobtracker拿到分片信息&＃xff0c;来分配map,reduct task&＃xff1b;map对每条记录的输出以 的形式输出。

        &＃xff08;3&＃xff09;如果定义了combiner&＃xff0c;则在本地会对map处理的结果进行处理&＃xff1a;对相同key的聚合&＃xff0c;对key的排序&＃xff0c;value的迭代。combiner完成类似于本地reduce的功能。

        &＃xff08;4&＃xff09;在进入reduce阶段之前&＃xff0c;系统会完成一些列操作&＃xff08;merge&＃xff0c;sort&＃xff09;&＃xff1a;将list中key相同的数据进行合并、排序&＃xff0c;最后形成>的数据&＃xff1b;

             然后发往一个reduce

        &＃xff08;5&＃xff09;进入一个reduce&＃xff0c;相同的key的map输出会到达同一个reduce&＃xff0c;reduce对key相同的多个value进行“reduce操作”&＃xff1b;

        > 没有combiner的处理过程&＃xff1a;

             

        > 添加combiner的处理过程&＃xff1a;

             

         &＃xff1f;为什么我买的map函数和reduce函数一般使用静态类&＃xff1f;

           答&＃xff1a;task内部可以共享静态类属性&＃xff0c;每个task可能会多次调用map或reduce函数&＃xff0c;但每个key只对应某个节点上的某个task的reduce函数的一次执行。

               多个task之间不能共享静态类属性&＃xff0c;即使是在同一台机器上&＃xff0c;因为是以进程的方式在运行。

 

 

        1. Map类&＃xff1a;(继承TableMapper或者Mapper)

           Map原理&＃xff1a;

                在map阶段&＃xff0c;使用job.setInputFormatClass定义的InputFormat将输入的数据集分割成小数据块splites&＃xff0c;同时InputFormat提供一个RecordReder的实现。本例子中使用的是                        TextInputFormat&＃xff0c;他提供的RecordReder会将文本的一行的行号作为key&＃xff0c;这一行的文本作为value。这就是自定义Map的输入是的原因。然后调用自定义Map的map方法&＃xff0c;将一个个对输入给Map的map方法。注意输出应该符合自定义Map中定义的输出。最终是生成一个List。在map阶段的最后&＃xff0c;会先调用job.setPartitionerClass对这个List进行分区&＃xff0c;每个分区映射到一个reducer。每个分区内又调用job.setSortComparatorClass设置的key比较函数类排序。可以看到&＃xff0c;这本身就是一个二次排序。如果没有通过job.setSortComparatorClass设置key比较函数类&＃xff0c;则使用key的实现的compareTo方法。在第一个例子中&＃xff0c;使用了IntPair实现的compareTo方法&＃xff0c;而在下一个例子中&＃xff0c;专门定义了key比较函数类。

                   

                 Q: map的结果发给那个reduce&＃xff1f;谁来管理这一切&＃xff1f;

                 A:     Partitioner用于划分键值空间&＃xff08;key space&＃xff09;。

                       Partitioner负责控制map输出结果key的分割。Key&＃xff08;或者一个key子集&＃xff09;被用 于产生分区&＃xff0c;通常使用的是Hash函数。分区的数目与一个作业的reduce任务的数目是一样的。因此&＃xff0c;它控制将中间过程的key&＃xff08;也就是这条记录&＃xff09;应该发送给m个reduce任务中的哪一个来进行reduce操作。

        

        2. Reduce类:(继承TableReducer或者Reducer)

           Reduce的原理&＃xff1a;在reduce阶段&＃xff0c;reducer接收到所有映射到这个reducer的map输出后&＃xff0c;也是会调用job.setSortComparatorClass设置的key比较函数类对所有数据对排序。然后开始构造一个key对应的value迭代器。这时就要用到分组&＃xff0c;使用jobjob.setGroupingComparatorClass设置的分组函数类。只要这个比较器比较的两个key相同&＃xff0c;他们就属于同一个组&＃xff0c;它们的value放在一个value迭代器&＃xff0c;而这个迭代器的key使用属于同一个组的所有key的第一个key。最后就是进入Reducer的reduce方法&＃xff0c;reduce方法的输入是所有的&＃xff08;key和它的value迭代器&＃xff09;。同样注意输入与输出的类型必须与自定义的Reducer中声明的一致。

                         reduce的输出是没有排序的。

 

           Q: Reduce的数目应该设置多少&＃xff1f;

           A:Reduce的数目建议是0.95或1.75乘以 ( *mapred.tasktracker.reduce.tasks.maximum)。用0.95&＃xff0c;所有reduce可以在maps一完成时就立刻启动&＃xff0c;开始传输map的输出结                            果。用1.75&＃xff0c;速度快的节点可以在完成第一轮reduce任务后&＃xff0c;可以开始第二轮&＃xff0c;这样可以得到比较好的负载均衡的效果。上述比例因子比整体数目稍小一些是为了给框                            架中的推测性任务&＃xff08;speculative-tasks&＃xff09; 或失败的任务预留一些reduce的资源。

           Q: Reduce的三个阶段都干了什么&＃xff1f;

           A: Reducer有3个主要阶段&＃xff1a;shuffle、sort和reduce。

               

               Shuffle &＃xff1a;Reducer的输入就是Mapper已经排好序的输出。在这个阶段&＃xff0c;框架通过HTTP为每个Reducer获得所有Mapper输出中与之相关的分块。&＃xff08;其实就是copy的过程&＃xff09;

               Sort &＃xff1a;这个阶段&＃xff0c;框架将按照key的值对Reducer的输入进行分组 &＃xff08;因为不同mapper的输出中可能会有相同的key&＃xff0c;combain保证了同一台机器相同key的合并&＃xff0c;但是不同机器也可能有相同的key&＃xff09;。

                map的输出是一边被取回一边被合并的。

 

        3. Job 的配置&＃xff1a;

           (1). 使用job.setInputFormatClass定义的InputFormat将输入的数据集分割成小数据块splites,HadoopMap/Reduce框架为每一个Split产生一个map任务.

             Map的数目通常是由输入数据的大小决定的&＃xff0c;一般就是所有输入文件的总块&＃xff08;block&＃xff09;数。如果你输入10TB的数据&＃xff0c;每个块&＃xff08;block&＃xff09;的大小是 128MB&＃xff0c;你将需要大约82,000个map来完成任务&＃xff0c;除非使用setNumMapTasks(int)将这个数值设置得更高。

           (2).如果需要中间过程对key的分组规则和reduce前对key的分组规则不同&＃xff0c;那么可以通过 JobConf.setOutputValueGroupingComparator(Class)来指定一个Comparator。再加上 JobConf.setOutputKeyComparatorClass(Class)可用于控制中间过程的key如何被分组&＃xff0c;所以结合两者可以实现按值的二次排序

           (3).一些作业的参数可以被直截了当地进行设置&＃xff08;例如&＃xff1a; setNumReduceTasks(int)&＃xff09;&＃xff0c;而另一些参数则与框架或者作业的其他参数之间微妙地相互影响&＃xff0c;并且设置起来比较复杂&＃xff08;例如&＃xff1a;              setNumMapTasks(int)&＃xff09;

           (4).Mapper和Reducer的实现可以利用Reporter 来报告进度&＃xff0c;或者仅是表明自己运行正常。我们从界面上看到的图形就是利用Reporter来进行进度的展示。

 

 

 

(2)    MapReduce基本编程&＃xff1a;

Ø  创建一个Maven工程

Ø  加入hadoop依赖

Ø  编写Map类

Ø  编写reduce类

Ø  定义job

(3)    进行Mapreduce测试&＃xff1a;

l   用MRUnit做单元测试&＃xff1a;

Ø  加入mrunit依赖

Ø  单独测试Map

Ø  单独测试Reduce

Ø  测试MapReduce

参考&＃xff1a;叶渡&＃xff1a;Hadoop学习笔记_yedu.pdf

 

疑惑&＃xff1a;1. 使用MRUnit&＃xff0c;测试代码在.run下通过&＃xff0c;在.runTest()失败&＃xff0c;原因是什么&＃xff1f;两者有什么区别&＃xff1f;

 

l   运行MapReduce  Job进行集成测试

 

流程&＃xff1a;预设置(准备输入文件、启动hadoop进程等)->运行作业->输出结果跟预期结果的对比->报告导致失败的原因

 

l   精简HBaseMapReduce测试&＃xff1a;

使用Hadoop/HBaseMini Cluster (iTest-hadoop)

参考文档&＃xff1a;http://qa.taobao.com/?p&＃61;13939

&＃xff08;不安装Hadoop、HBase环境&＃xff0c;只要有JDK搞定MapReduce的Job测试&＃xff09;

 

 

 

 

2.    本地搭建单机版hadoop环境&＃xff08;win&＃xff09;&＃xff1a;

            Hadoop主要是在Linux 平台下运行的&＃xff0c;如果想在 Windows 平台下运行&＃xff0c;你需要安装 Cygwin 才能运行&＃xff0c; Hadoop 脚本。

         按照“在Windows上安装Hadoop教程.pdf“执行完成。

         安装还可以参考文档&＃xff1a;http://blog.csdn.net/savechina/article/details/5656937

         按照“在Windows上安装Hadoop教程.pdf“的说明进行到最后一步时&＃xff0c;在启动./start-all.sh之前&＃xff0c;需要 格式化一个新的分布式文件&＃xff0c;./hadoopnamenode –format .这样就会启动JobTracker.

        

         浏览NameNode 和JobTracker 的网络接口&＃xff0c;他们的地址默认为&＃xff1a;

              NameNode – http://localhost:50070/

              JobTracker  – http://localhost:50030/

         Node数为0&＃xff0c;如何配置NameNode 和Datanode&＃xff1f;&＃xff1f;

Ø  运行hadoop自带jar文件&＃xff1a;

        运行hadoop自带的jar文件&＃xff0c;理解MapReduce的过程&＃xff1a;hadoop-0.20.2-examples.jar

        跑通自己第一个Job程序&＃xff1a;

              首先开启hadoop服务&＃xff1a; ./start-all.sh

1.    根据文档示例编写wordCout程序。

2.    将编写的代码打包成HadoopTest.jar放到本地某一个目录下&＃xff0c; (打包的时候要选择mainclass)

或者直接运行hadoop自带文件中的示例jar包(hadoop-0.20.2-examples.jar)。

3.    将要分析的数据传到hdfs上去

在dfs上创建测试输入目录&＃xff1a;./hadoop dfs –mkdir test-in

然后将本地文件copy到test-in中: ./hadoop dfs –copyFromLocal [本地文件目录] test-in

验证文件是否复制成功&＃xff1a; ./hadoop dfs –ls test-in

 注&＃xff1a;这里的test-in其实是HDFS路径下的目录&＃xff0c;七绝对路径为

“http://localhost:50070/user/XXXXX/test-in”

      4. 开始执行

./bin/hadoopjar hadoop-0.20.2-examples.jar wordCount test-in test-out

当遇到文件已存在异常的时候&＃xff0c;只要将test-out改一个名字即可。

5.    遇到问题&＃xff1a;

抛出文件不存在的异常&＃xff0c;原因是找不到tmp目录。开如图上的目录看到并不存在那样的目录结构&＃xff0c;说明根本就没有创建相应的目录结构&＃xff0c;可能是连tmp都没有找到&＃xff0c;所以查找配置文件发现&＃xff0c;conf下的mapred-site.xml中中默认配置是

./tmp,所以修改成自己的相应目录就可以了。

6.    运行成功&＃xff1a;

 

 

Ø  运行自己编写的文件&＃xff1a;

(1).逻辑性代码&＃xff1a;

1.    编写自己的mapper函数&＃xff1a;继承Mapper基类&＃xff0c;实现map方法

2.    编写自己的reducer函数&＃xff1a;继承reducer基类&＃xff0c;实现reduce方法

3.    编写自己的主函数&＃xff1a;创建job&＃xff0c;配置map、combiner、reducer类型&＃xff0c;设置输入输出路径&＃xff0c;                  设置输出键/值格式&＃xff0c;提交任务

(2).驱动性代码&＃xff1a;驱动类来注册业务的class为一个可标示的命令&＃xff0c;让hadoop jar可以执行。

       如&＃xff1a;

(3). 最后一步&＃xff1a;将自己的项目导出成jar格式&＃xff0c;注意&＃xff1a;在选择main class时&＃xff0c;是选择我们创建的驱动类&＃xff0c;而不是逻辑主类。

3. 一个Job的请求过程&＃xff1a;

用户通过界面提交一个Job&＃xff0c;服务器把Job请求发送给gateway&＃xff0c;gateway接收请求后按照一定的逻辑拼装成MR需要的请求文件。

Gateway&＃xff1a;我把可以把gateway理解为跳板机&＃xff0c;我们的机器不能直接访问集群&＃xff0c;需要一个入口&＃xff0c;这个入口就是Gateway。

思考&＃xff1a;这个跳板机是单独拿出来的一台机器专门做Job的入口的呢&＃xff0c;还是只是机群中的普通机器&＃xff1f;

JobTracker&＃xff1a;

TaskTracker&＃xff1a;

 

我们提交一个JOB&＃xff08;一般通过JobClient&＃xff0c;这个类有三种策略来提交一个JOB&＃xff0c;1、job完成后才返回状态2、job提交后&＃xff0c;返回一个持有状态的Handler&＃xff0c;3、提交job&＃xff0c;但是不返回状态&＃xff09;

首先会从JobTracker&＃xff08;hadoop中运用了master/slaver机制&＃xff0c;他是master服务&＃xff0c;那么slaver在这里就是tasktracker&＃xff09;中的得到一个job的definition Id, 其实这个id也就是JobTracker管理job的个数

jobClient会从Configuration找到hadoop系统目录&＃xff08;"mapred.system.dir",默认值"/tmp/hadoop/mapred/system"&＃xff09;在这里jobClient做了一件比较重要的事情&＃xff0c;他把input的数据做split操作&＃xff08;相当于将大数据量切分成若干块&＃xff0c;具体切分成多大&＃xff0c;这个通过一个公式来计算的&＃xff1a;FileInputFormat的策略max(minimumSize,min(maximumSize, blockSize))  其中minSize表示一个map切分的最小容量&＃xff0c;maxSize即最大容量&＃xff0c;blockSize表示HDFS中的block容量&＃xff09;[1]&＃xff0c;从而决定了Map的个数&＃xff08;其实就是MapTask的数量&＃xff09;。jobClient还将一部分资源文件放到jobtracker的FS中&＃xff08;jar、file、archives、split[2]&＃xff09;

正式提交

JT(jobtracker)会根据这个job创建一个JobInProgress对象&＃xff0c;这个对象记录着这个job所有信息。最后JT会将这个job注册到JobInProgressListener中&＃xff08;以下简称JIPL&＃xff09;&＃xff0c;让JIPL监听这些job。JIPL是在JT启动的时候启动的监听器&＃xff08;由TaskScheduler注入&＃xff0c;作用参照step 7&＃xff09;。一个EagerTaskInitializationListener&＃xff1a;它是一个生命周期和JT一样的监听线程&＃xff0c;主要功能就是初始化这个Job,并且创建相应的TaskInProgress(TIP,包括M个MapTask,N个ReduceTask,2个CleanTask,2个SetupTask)。另一个就是JobQueueJobInProgressListener&＃xff0c;这个listener是处理job队列的&＃xff0c;也就是job提交的先后顺序跟它有关系&＃xff0c;默认的是FIFO。

在初始化job的时候&＃xff08;其实是初始化MapTask&＃xff09;,会将之前的input数据split的信息回流回来&＃xff0c;初始化maptask

到这里&＃xff0c;JT初始化job工作完毕。

每台slaver机器启动的时候&＃xff0c;都会启动一个tasktracker的线程&＃xff0c;这个线程主要负责和JT去通信&＃xff0c;也就是发送心跳&＃xff08;通过RPC通信协议&＃xff09;。当发送心跳的时候&＃xff0c;TT会将自己现有的状态&＃xff08;是否是刚刚启动、是否刚初始化&＃xff0c;自己状态是否可以申请新的task&＃xff0c;如果JT中没有这个TT的引用&＃xff0c;那么需要保存下来&＃xff09;JT首先会获取Setup和CleanUp的Task&＃xff08;默认每个job都会有两个setuptask和两个cleanup task&＃xff09;&＃xff0c;如果没有了以上两种类型的task&＃xff0c;那么剩下的就是MapTask和ReduceTask此时&＃xff0c;JT会去向TaskScheduler这个调度类去申请Task。在hadoop中&＃xff0c;默认的TaskScheduler是JobQueueTaskScheduler&＃xff0c;他持有JPL的引用。当TT发送一个心跳表明自己空闲需要执行Task时&＃xff0c;这时候&＃xff0c;JT会调用Schedule的assignTask方法去获得一个Task。&＃xff08;这里Hadoop找MapTask的时候&＃xff0c;首先node-local&＃xff0c;然后rack-local&＃xff0c;最后才是不同机架&＃xff0c;具体怎么找&＃xff0c;还未仔细看&＃xff09;

 

TT发送心跳后&＃xff0c;JT返回给TT一个HeartbeatResponse对象的引用&＃xff0c;这里面包含着需要执行Tasks的action数组&＃xff08;如果action的类型LaunchTaskAction&＃xff1a;执行一个新的Task, 如果CommitTaskAction&＃xff1a;加入commitResponses列表&＃xff0c;由Task在适当的时候提交给JobTracker&＃xff09;&＃xff0c;同时JT还会更新TTS的内容。所以TT根据这两点&＃xff0c;就可以很好的判断自己Task在JT那边的状态。 执行任务前先调用localizeTask()更新一下jobConf文件并写入到本地目录中。然后通过调用Task的createRunner()方法创建TaskRunner对象并调用其start()方法&＃xff0c;值得注意点是&＃xff0c;TaskRunner会去新开一个JVM去执行Task(如果考虑掉Task开销小而且多&＃xff0c;可以将jvm reuse)。

 

 

两种启动Job方式&＃xff1a;

A:Submit()

submit函数会把Job提交给对应的Cluster&＃xff0c;然后不等待Job执行结束就立刻返回。同时会把Job实例的状态设置为JobState.RUNNING&＃xff0c;从而来表示Job正在进行中。然后在Job运行过程中&＃xff0c;可以调用getJobState()来获取Job的运行状态。

B:waitForCompletion(boolean)

waitForCompletion函数会提交Job到对应的Cluster&＃xff0c;并等待Job执行结束。函数的boolean参数表示是否打印Job执行的相关信息。返回的结果是一个boolean变量&＃xff0c;用来标识Job的执行结果。

执行Job的内部流程&＃xff1a;

1).Inputformat会从job的INPUT_DIR目录下读入待处理的文件&＃xff0c;检查输入的有效性并将文件切分成InputSplit列表。Job实例可以通过setInputFormatClass(Class)函数来设置所需的inputformat。

2).当Inputformat对输入文件分片后&＃xff0c;会对每个分片构建一个MapperTask实例&＃xff08;MapTask(String, TaskAttemptID, int, TaskSplitIndex, int)&＃xff09;。其实整个Mapper类的调度过程&＃xff0c;都是由MapperTask来实现的。MapperTask的run(JobConf,TaskUmbilicalProtocol)方法实现了对于Mapper task调度的整个过程。

2.1)  RecordReader会解析InputSplit&＃xff0c;生成对应的key/value pair。Inputformat中有一个除了用于分片的getSplits(JobContext)方法外&＃xff0c;还有一个方法createRecordReader(InputSplit,TaskAttemptContext)&＃xff0c;该方法用于给每一个分片创建一个RecordReader。重写这个方法&＃xff0c;可以添加自己的RecordReader。

2.2)Mapper类会对属于一个InputSplit所有key/value pair调用一次map函数。关于Mapper类的作用&＃xff0c;在Javadoc中描述如下&＃xff1a;“Mapper maps input key/value pairs to a set ofintermediate key/value pairs”。 Job实例可以通过setMapperClass(Class)函数来设置自己的Mapper类。

2.3)可以通过Job实例的setSortComparatorClass(Class)方法来为Mapper设定一个Comparator class&＃xff0c;用来对Mapper的结果根据key进行排序。

2.4)可以通过Job实例的setPartitionerClass(Class)方法来为Mapper设定一个Partitioner Class&＃xff0c;用来对Mapper的结果根据Reducer进行分片。

2.5)可以通过Job实例的setCombinerClass(Class)方法为Mapper设定一个Combiner Class&＃xff0c;用来在本地进行聚集操作&＃xff0c;从而减少从Mapper到Reducer的数据传输量。

3).Mapper执行结束之后&＃xff0c;ReducerTask类会被用来进行整个Reducer操作的调度

3.1)Shuffle类会被调用从而来获取在Mapper输出中属于本Reducer的分片&＃xff0c;并将多个分片combine成一个。

3.2)Shuffle类会使用MergeManager根据Job实例的setSortComparatorClass(Class)所设定的Comparator class对key/value pair进行排序

3.3)在shuffle操作执行结束之后&＃xff0c;如果对于Reducer的input数据&＃xff0c;有使用特殊分组的需求的话&＃xff0c;可以通过Job实例的setGroupingComparatorClass(Class)方法来实现定制的分组策略&＃xff0c;否则&＃xff0c;则使用setSortComparatorClass(Class)的比较方式。

3.4)在分组后的结果中&＃xff0c;针对每一个 pair 调用Reduce的reduce(K2, Iterator, OutputCollector,Reporter)方法。可以通过Job实例的setReducerClass(Class)方法类设置相应的Reduce实现。

4).Reduce的结果将由OutputCollector.collect(WritableComparable, Writable)写入文件系统

参考文档&＃xff1a;http://blog.csdn.net/derekjiang/article/details/6851625

思考&＃xff1a;

 

 

3.    启动Hadoop过程&＃xff1a;

(1)  启动NameNode:

启动NameNode节点&＃xff1b;

初始化操作(如在name目录下创建文件)&＃xff1b;

记录HDFS状态(如安全模式状态)&＃xff1b;

本机FS注册&＃xff0c;启动HDFS容器&＃xff0c;并初始化&＃xff1b;

(2)  启动DataNode:

(3)  启动SecondaryNameNode:

(4)  启动JobTracker:

(5)  启动TaskTracker:

4.    运行Map&＃xff0c;Reduce过程&＃xff1a;

1.    在分布式环境中客户端创建任务并提交。

2.    InputFormat做Map前的预处理&＃xff0c;主要负责以下工作&＃xff1a;

1.    验证输入的格式是否符合JobConfig的输入定义&＃xff0c;这个在实现Map和构建Conf的时候就会知道&＃xff0c;不定义可以是Writable的任意子类。

2.    将input的文件切分为逻辑上的输入InputSplit&＃xff0c;其实这就是在上面提到的在分布式文件系统中blocksize是有大小限制的&＃xff0c;因此大文件会被划分为多个block。

3.    通过RecordReader来再次处理inputsplit为一组records&＃xff0c;输出给Map。&＃xff08;inputsplit只是逻辑切分的第一步&＃xff0c;但是如何根据文件中的信息来切分还需要RecordReader来实现&＃xff0c;例如最简单的默认方式就是回车换行的切分&＃xff09;

3.    RecordReader处理后的结果作为Map的输入&＃xff0c;Map执行定义的Map逻辑&＃xff0c;输出处理后的key和value对应到临时中间文件。

4.    Combiner可选择配置&＃xff0c;主要作用是在每一个Map执行完分析以后&＃xff0c;在本地优先作Reduce的工作&＃xff0c;减少在Reduce过程中的数据传输量。

5.    Partitioner可选择配置&＃xff0c;主要作用是在多个Reduce的情况下&＃xff0c;指定Map的结果由某一个Reduce处理&＃xff0c;每一个Reduce都会有单独的输出文件。&＃xff08;后面的代码实例中有介绍使用场景&＃xff09;

6.    Reduce执行具体的业务逻辑&＃xff0c;并且将处理结果输出给OutputFormat。

7.    OutputFormat的职责是&＃xff0c;验证输出目录是否已经存在&＃xff0c;同时验证输出结果类型是否如Config中配置&＃xff0c;最后输出Reduce汇总后的结果。

5.    MapReduce 中如何处理HBase中的数据&＃xff1f;如何读取HBase数据给Map&＃xff1f;如何将结果存储到HBase中&＃xff1f;

Mapper类&＃xff1a;包括一个内部类(Context)和四个方法(setup,map,cleanup,run)&＃xff1b;

         setup,cleanup用于管理Mapper生命周期中的资源。setup -> map -> cleanup&＃xff0c;

 run方法执行了这个过程&＃xff1b;

        map方法用于对一次输入的key/value对进行map动作&＃xff0c;对应HBase操作也就是一行的处理&＃xff1b;

 

job的配置&＃xff1a;

5.1TableInputFormat完成了什么功能&＃xff1f;

        (1)通过设置conf.set(TableInputFormat.INPUT_TABLE,"udc_sell");设定HBase的输入表&＃xff1b;

                设置conf.set(TableInputFormat.SCAN,TableMRUtil.convertScanToString(scan));设定对HBase输入表的scan方式&＃xff1b;

               

        (2)通过TableInputFormat.setConf(Configration conf)方法初始化scan对象&＃xff1b;

            scan对象是从job中设置的对象&＃xff0c;以字符串的形式传给TableInputFormat&＃xff0c;在TableInputFormat内部将scan字符创转换为scan对象

                     

      * TableMapReduceUtily有两个方法&＃xff1a;convertScanToString和convertStringToScan作用&＃xff1f;

            将scan实例转换为Base64字符串  和将Base64字符串还原为scan实例&＃xff1b;

             Q:为什么不直接穿Scan对象而是费尽周折地转换来转换去呢&＃xff1f;

             A:

         (3)TableInputFormat继承了TableInputFormatBase实现了InputFormat抽象类的两个抽象方法&＃xff1a;

            getSplits()和createRecordReader()方法&＃xff1a;

l  getSplits()断定输入对象的切分原则&＃xff1a;对于TableInputFormatBase&＃xff0c;会遍历HBase相应表的所有HRegion&＃xff0c;每一个HRegion都会被分成一个split&＃xff0c;所以切分的块数是与表中HRegion的数目是相同的&＃xff1b; InputSplitsplit &＃61;newTableSplit(table.getTableName(),splitStart, splitStop, regionLocation);在split中只会记载HRegion的其实rowkey和终止rowkey&＃xff0c;具体的去读取这篇区域的数据是createRecordReader()实现的。

              计算出来的每一个分块都将被作为一个map Task的输入&＃xff1b;

                 Q:但是分出的块分给那台机器的那个task去执行Map&＃xff0c;即jobTracker如何调度任务给taskTracker&＃xff1f;

                 A: 需要进一步了解Map的本地化运行机制和jobTracker的调度算法&＃xff1b;&＃xff08;可能是就近原则&＃xff09;.

                    对于一个map任务&＃xff0c;jobtracker会考虑tasktracker的网络位置&＃xff0c;并选取一个距离其输入分片文件最近的tasktracker。在最理想的情况下&＃xff0c;任务是数据本地化的(data-local),也就是任务运行在输入分片所在的节点上。同样&＃xff0c;任务也可能是机器本地化的&＃xff1a;任务和输入分片在同一个机架&＃xff0c;但不在同一个节点上。reduce任务&＃xff0c;jobtracker简单滴从待运行的reduce任务列表中选取下一个来运行&＃xff0c;用不着考虑数据段饿本地化。

l  createRecordReader()按照必然格式读取响应数据&＃xff1a;

              接收split块&＃xff0c;返回读取记录的结果&＃xff1b; 

                 public RecordReader createRecordReader(InputSplit split, TaskAttemptContext context){

                  

                }

                trr.init()返回的是这个分块的起始rowkey的记录;

               RecordReader将一个split解析成对的形式提供给map函数&＃xff0c;key就是rowkey&＃xff0c;value就是对应的一行数据&＃xff1b;

               RecordReader用于在划分中读取对。RecordReader有五个虚方法&＃xff0c;分别是&＃xff1a; initialize&＃xff1a;初始化&＃xff0c;输入参数包括该Reader工作的数据划分InputSplit和Job的上下文context&＃xff1b;nextKey&＃xff1a;得到输入的下一个Key&＃xff0c;如果数据划分已经没有新的记录&＃xff0c;返回空&＃xff1b; nextValue&＃xff1a;得到Key对应的Value&＃xff0c;必须在调用nextKey后调用&＃xff1b;getProgress&＃xff1a;得到现在的进度&＃xff1b; close&＃xff1a;来自java.io的Closeable接口&＃xff0c;用于清理RecordReader。

5.2   job.setInputFormatClass(TableInputFormat.class);         

                                      

5.3   TableMapReduceUtil.initTableReducerJob("daily_result",DailyReduce.class, job);

       使用了该方法就不需要再单独定义

       initTableReducerJob()方法完成了一系列操作&＃xff1a;

                (1). job.setOutputFormatClass(TableOutputFormat.class); 设置输出格式&＃xff1b;

                (2). conf.set(TableOutputFormat.OUTPUT_TABLE, table);设置输出表&＃xff1b;

                     (3).初始化partition&＃xff1b;

 

六&＃xff1a;HBase测试点&＃xff1a;

前提&＃xff1a;自己维护HBase集群&＃xff0c;否则无需关注HBase本身。

1.      功能测试&＃xff1a;

(1)  Row Key的校验(重点)&＃xff1a;

rowkey的长度、rowkey的排序、rowkey是否有遗失

(2)  Value的校验&＃xff1a;

(3)  Table schema&＃xff1a;

TTL(生存周期)&＃xff1a;

压缩方式&＃xff1a;Value值的压缩是否出错。

(4)  Family名称正确性的校验&＃xff1a;

(5)  破坏性校验&＃xff1a;

由于HBase的数据都是在集群中有备份的&＃xff0c;所以才去人工宕机&＃xff0c;查看数据是否能够正常取出。

 

2.     性能测试&＃xff1a;

(1)  对HBase性能测试的工具&＃xff1a;YCSB

YCSB&＃xff08;Yahoo!Cloud Serving Benchmark&＃xff09;是雅虎开源的一款通用的性能测试工具。

通过这个工具我们可以对各类NoSQL产品进行相关的性能测试。

参考文档&＃xff1a;http://www.cnblogs.com/gpcuster/archive/2011/08/16/2141430.html

 

参考&＃xff1a;http://www.spnguru.com/(趋势科技)

 

七&＃xff1a;Hadoop测试点&＃xff1a;

1.    Job任务请求&＃xff1a;

job需要解析一个request的请求文件&＃xff0c;这里需要考虑到文件编码格式的问题。

2.    MR数据处理&＃xff1a;

(1)  MR异常&＃xff1a;

 

3.    程序的稳定和优化&＃xff1a;

 

Hadoop测试参考&＃xff1a;HADOOP测试常见问题和测试方法.docx

八&＃xff1a;附

1.    RPC通信协议&＃xff1a;

RPC&＃xff08;RemoteProcedure Call Protocol&＃xff09;——远程过程调用协议&＃xff0c;它是一种通过网络从远程计算机程序上请求服务&＃xff0c;而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在&＃xff0c;如TCP或UDP&＃xff0c;为通信程序之间携带信息数据。在OSI网络通信模型中&＃xff0c;RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

 

九&＃xff1a;随想&＃xff1a;

1.    Hadoop 的分布式并行运算有一个作为主控的JobTracker&＃xff0c;用于调度和管理其它的 TaskTracker, JobTracker 可以运行于集群中任一台计算机上。TaskTracker负责执行任务&＃xff0c;必须运行于 DataNode 上&＃xff0c;即 DataNode 既是数据存储结点&＃xff0c;也是计算结点。

 

思考&＃xff1a; JobTracker是如何从闲置的机器中选择出来的&＃xff1f;是不是任何一台集群中的机器都可能有成为JobTracker的可能&＃xff1f;所以机器都同事装了JobTracker和TaskTracker吗&＃xff1f;

是谁在管理着JobTracker的分配和TaskTracker的运行&＃xff1f;

2.     

随笔记录&＃xff1a;

1.Zookeeper中记录了-ROOT-表的location&＃xff0c;我们的程序会通过我们配置的zookeeper地址找到zookeeper&＃xff0c;然后根据zookeeper中存储的-ROOT-表的location&＃xff0c;去到相应的机器上访问-ROOT-表&＃xff0c;根据-ROOT-表中描述的.META表找到相应的Ration信息。                                                                   

-ROOT-表只有一个区域&＃xff0c;而.META可以有多个区域。