在Hadoop分布式文件系统的索引和搜索

FROM:http://www.drdobbs.com/parallel/indexing-and-searching-on-a-hadoop-distr/226300241?pgno=3

在今天的信息饱和的世界，地理分布的数据，需要一种系统的巨大增长，有利于快速检索有意义的结果的解析。分布式数据的可搜索的索引去加速的过程很长的路要走。在这篇文章中，我演示了如何使用Lucene和Java的基本数据索引和搜索，如何使用RAM目录索引和搜索，如何创建居住在HDF的数据索引，以及如何搜索这些索引。由开发环境，Eclipse的Java 1.6的Lucene的2.4.0，3.4.2，和Hadoop 0.19.1上运行微软Windows XP SP3。

为了解决这个任务，我把Hadoop的。Apache Hadoop项目的开发可靠，可扩展，分布式计算开源软件，Hadoop分布式文件系统（HDFS）是专为跨广域网的存储和共享文件。HDFS是建立在商品硬件上运行，并提供了容错，资源管理，以及最重要的是，应用程序数据访问的高吞吐量。

在本地文件系统上创建索引

第一步是创建一个索引存储在本地文件系统上的数据。开始通过创建一个Eclipse项目中，创建一个类，然后添加所需的JAR文件添加到项目。以这个例子发现在Web服务器中的日志文件的应用程序的数据：

2010-04-21 02:24:01 GET /blank 200 120

此数据被映射到某些字段：

• 2010-04-21 - 日期字段
• 2时24分01秒 - 时间字段
• GET - 法域（GET或POST） - 我们将记为“CS-方法”
• /空白 - 请求的URL字段 - 我们将表示​​为“CS-URI”
• 200 - 状态代码的请求 - 我们会记为“SC-状态”
• 120 - 时间采取现场（完成请求所需的时间）

  ---

  目前在我们的样本文件的数据位于一个"E:DataFile"名为“test.txt的”如下：

  2010-04-21 02:24:01 GET /blank 200 120
  2010-04-21 02:24:01 GET /US/registrationFrame 200 605
  2010-04-21 02:24:02 GET /US/kids/boys 200 785
  2010-04-21 02:24:02 POST /blank 304 56
  2010-04-21 02:24:04 GET /blank 304 233
  2010-04-21 02:24:04 GET /blank 500 567
  2010-04-21 02:24:04 GET /blank 200 897
  2010-04-21 02:24:04 POST /blank 200 567
  2010-04-21 02:24:05 GET /US/search 200 658
  2010-04-21 02:24:05 POST /US/shop 200 768
  2010-04-21 02:24:05 GET /blank 200 347

我们要建立索引的数据出现在这个“test.txt的”文件，并保存到本地文件系统的索引。下面的Java代码，这样做。（注意每个部分的代码做什么的详细信息）的意见。

// Creating IndexWriter object and specifying the path where Indexed
//files are to be stored.
IndexWriter indexWriter = new IndexWriter("E://DataFile/IndexFiles", new StandardAnalyzer(), true);
             
// Creating BufferReader object and specifying the path of the file
//whose data is required to be indexed.
BufferedReader reader= new BufferedReader(new FileReader("E://DataFile/Test.txt"));
             
String row=null;
         
// Reading each line present in the file.
while ((row=reader.readLine())!= null)
{
// Getting each field present in a row into an Array and file delimiter is "space separated"
String Arow[] = row.split(" ");
                 
// For each row, creating a document and adding data to the document with the associated fields.
org.apache.lucene.document.Document document = new org.apache.lucene.document.Document();
                 
document.add(new Field("date",Arow[0],Field.Store.YES,Field.Index.ANALYZED));
document.add(new Field("time",Arow[1],Field.Store.YES,Field.Index.ANALYZED));
document.add(newField ("cs-method",Arow[2],Field.Store.YES,Field.Index.ANALYZED));
document.add(newField ("cs-uri",Arow[3],Field.Store.YES,Field.Index.ANALYZED));
document.add(newField ("sc-status",Arow[4],Field.Store.YES,Field.Index.ANALYZED));
document.add(newField ("time-taken",Arow[5],Field.Store.YES,Field.Index.ANALYZED));
                 
// Adding document to the index file.
indexWriter.addDocument(document);
}        
indexWriter.optimize();
indexWriter.close();
reader.close();

的Java代码一旦被执行，将创建和索引文件存放在“E :/ /DataFile/ IndexFiles的位置。”

现在，我们可以搜索索引文件中的数据，我们刚刚创建的。基本上，搜索的“场”的数据上完成。您可以使用Lucene搜索引擎支持各种搜索语义搜索，你可以在一个特定的字段​​或字段组合执行搜索。下面的Java代码搜索索引：

// Creating Searcher object and specifying the path where Indexed files are stored.
Searcher searcher = new IndexSearcher("E://DataFile/IndexFiles");
Analyzer analyzer = new StandardAnalyzer();
 
// Printing the total number of documents or entries present in the index file.
System.out.println("Total Documents = "+searcher.maxDoc()) ;
             
// Creating the QueryParser object and specifying the field name on
//which search has to be done.
QueryParser parser = new QueryParser("cs-uri", analyzer);
             
// Creating the Query object and specifying the text for which search has to be done.
Query query = parser.parse("/blank");
             
// Below line performs the search on the index file and
Hits hits = searcher.search(query);
             
// Printing the number of documents or entries that match the search query.
System.out.println("Number of matching documents = "+ hits.length());
 
// Printing documents (or rows of file) that matched the search criteria.
for (int i = 0; i < hits.length(); i++)
{
    Document doc = hits.doc(i);
    System.out.println(doc.get("date")+" "+ doc.get("time")+ " "+
    doc.get("cs-method")+ " "+ doc.get("cs-uri")+ " "+ doc.get("sc-status")+ " "+ doc.get("time-taken"));

在这个例子中，搜索完成领域cs的uri的cs的uri的字段/空白内搜索的文本。因此，搜索代码运行时，所有的文件（或行）的CS-URI字段包含/空白，显示在输出中。的输出如下所示：

Total Documents = 11
Number of matching documents = 7
2010-04-21 02:24:01 GET /blank 200 120
2010-04-21 02:24:02 POST /blank 304 56
2010-04-21 02:24:04 GET /blank 304 233
2010-04-21 02:24:04 GET /blank 500 567
2010-04-21 02:24:04 GET /blank 200 897
2010-04-21 02:24:04 POST /blank 200 567
2010-04-21 02:24:05 GET /blank 200 347

HDFS上的基于内存的索引

现在考虑数据的情况下，位于一个像Hadoop DFS分布式文件系统。上述代码将无法正常工作分布式数据上直接创建索引，所以我们不得不完成前几步的诉讼程序，如从HDFS数据复制到本地文件系统，创建索引的数据出现在本地文件系统，最后将索引文件存储到HDFS。同样的步骤将需要搜索。但这种方法耗时且最理想的，相反，让我们的索引和搜索我们的数据使用HDFS节点的内存中的数据是居住。

假设数据文件“Test.txt的”早期使用现在居住在HDFS上，里面一个工作目录文件夹，名为“/数据文件/ Test.txt的。” 创建另一个称为“/ IndexFiles”HDFS的工作目录里面的文件夹，我们生成的索引文件将被存储。下面的Java代码在内存中的文件存储在HDFS上创建索引文件：

// Path where the index files will be stored.
String Index_DIR="/IndexFiles/";
// Path where the data file is stored.
String File_DIR="/DataFile/test.txt";
// Creating FileSystem object, to be able to work with HDFS
Configuration config = new Configuration();
config.set("fs.default.name","hdfs://127.0.0.1:9000/");
FileSystem dfs = FileSystem.get(config);
// Creating a RAMDirectory (memory) object, to be able to create index in memory.
RAMDirectory rdir = new RAMDirectory();

// Creating IndexWriter object for the Ram Directory
IndexWriter indexWriter = new IndexWriter (rdir, new StandardAnalyzer(), true);
            
// Creating FSDataInputStream object, for reading the data from "Test.txt" file residing on HDFS.
FSDataInputStream filereader = dfs.open(new Path(dfs.getWorkingDirectory()+ File_DIR));
String row=null;
        
// Reading each line present in the file.
while ((row=reader.readLine())!=null)
{

// Getting each field present in a row into an Array and file //delimiter is "space separated".
String Arow[]=row.split(" ");
                
// For each row, creating a document and adding data to the document 
//with the associated fields.
org.apache.lucene.document.Document document = new org.apache.lucene.document.Document();
                
document.add(new Field("date",Arow[0],Field.Store.YES,Field.Index.ANALYZED));
document.add(new Field("time",Arow[1],Field.Store.YES,Field.Index.ANALYZED));
document.add(new Field ("cs-method",Arow[2],Field.Store.YES,Field.Index.ANALYZED));
document.add(new Field ("cs-uri",Arow[3],Field.Store.YES,Field.Index.ANALYZED));
document.add(new Field ("sc-status",Arow[4],Field.Store.YES,Field.Index.ANALYZED));
document.add(new Field ("time-taken",Arow[5],Field.Store.YES,Field.Index.ANALYZED));
                
// Adding document to the index file.
indexWriter.addDocument(document);
}          
indexWriter.optimize();
indexWriter.close();
reader.close();

因此，对于“test.txt的”居住在HDFS上的文件，我们现在有在内存中创建索引文件。存储索引文件，在HDFS文件夹：

// Getting files present in memory into an array.
String fileList[]=rdir.list();
 
// Reading index files from memory and storing them to HDFS.
for (int i = 0; I < fileList.length; i++)
{
    IndexInput indxfile = rdir.openInput(fileList[i].trim());
    long len = indxfile.length();
    int len1 = (int) len;
 
    // Reading data from file into a byte array.
    byte[] bytarr = new byte[len1];
    indxfile.readBytes(bytarr, 0, len1);
             
// Creating file in HDFS directory with name same as that of    
//index file   
Path src = new Path(dfs.getWorkingDirectory()+Index_DIR+ fileList[i].trim());
    dfs.createNewFile(src);
 
    // Writing data from byte array to the file in HDFS
FSDataOutputStream fs = dfs.create(new    Path(dfs.getWorkingDirectory()+Index_DIR+fileList[i].trim()),true);
    fs.write(bytarr);
    fs.close();

现在我们有必要的Test.txt的“数据文件创建并存储在HDFS目录的索引文件。

基于内存搜索HDFS上

我们现在可以搜索存储在HDFS中的索引。首先，我们必须使HDFS的索引文件在内存中进行搜索。下面的代码是用于这一过程：

// Creating FileSystem object, to be able to work with HDFS
Configuration config = new Configuration();
config.set("fs.default.name","hdfs://127.0.0.1:9000/");
FileSystem dfs = FileSystem.get(config);
 
// Creating a RAMDirectory (memory) object, to be able to create index in memory.
RAMDirectory rdir = new RAMDirectory();
             
// Getting the list of index files present in the directory into an array.
Path pth = new Path(dfs.getWorkingDirectory()+Index_DIR);
FileSystemDirectory fsdir = new FileSystemDirectory(dfs,pth,false,config);
String filelst[] = fsdir.list();
FSDataInputStream filereader = null;
for (int i = 0; i<filelst.length; i++)
{
// Reading data from index files on HDFS directory into filereader object.
filereader = dfs.open(new Path(dfs.getWorkingDirectory()+Index_DIR+filelst[i]));
                 
    int size = filereader.available();
 
    // Reading data from file into a byte array.           
    byte[] bytarr = new byte[size];
    filereader.read(bytarr, 0, size);
     
// Creating file in RAM directory with names same as that of
//index files present in HDFS directory.
    IndexOutput indxout = rdir.createOutput(filelst[i]);
 
    // Writing data from byte array to the file in RAM directory
    indxout.writeBytes(bytarr,bytarr.length);
    indxout.flush();       
    indxout.close();               
}
filereader.close();

现在我们有了所有所需的索引文件在RAM中的目录（或存储器），所以我们可以直接执行搜索索引文件。搜索代码将被用于搜索本地文件系统类似，唯一的变化是，现在将使用RAM的目录对象（RDIR），而不是使用本地文件系统目录路径创建的搜索对象。

Searcher searcher = new IndexSearcher(rdir);
Analyzer analyzer = new StandardAnalyzer();
 
System.out.println("Total Documents = "+searcher.maxDoc()) ;
             
QueryParser parser = new QueryParser("time", analyzer);
             
Query query = parser.parse("02\:24\:04");
             
Hits hits = searcher.search(query);
             
System.out.println("Number of matching documents = "+ hits.length());
 
for (int i = 0; i < hits.length(); i++)
{
Document doc = hits.doc(i);
System.out.println(doc.get("date")+" "+ doc.get("time")+ " "+
doc.get("cs-method")+ " "+ doc.get("cs-uri")+ " "+ doc.get("sc-status")+ " "+ doc.get("time-taken"));

以下输出，搜索是场上的“时间”和“时间”字段内的文本搜索“02 24 04。” 因此，运行代码时，所有的文件（或行）的“时间”字段中包含“02： 24 04”，在输出中显示：

Total Documents = 11
Number of matching documents = 4
2010-04-21 02:24:04 GET /blank 304 233
2010-04-21 02:24:04 GET /blank 500 567
2010-04-21 02:24:04 GET /blank 200 897
2010-04-21 02:24:04 POST /blank 200 567

结论

像HDFS分布式文件系统是一个强大的工具，用于存储和访问大量的数据提供给我们的今天。随着内存的索引和搜索，访问数据，你真的想找到你不关心数据的群山之中得到稍微容易一些。