基于hadoop的网页元素抽取

关于Hadoop的介绍

hadoop是分布式文件系统（也就是HDFS），或者一个同类的分布式文件系统，管理着集群的数据。Hadoop提供了一套基础设施来处理大多数困难的工作以保证任务能够执行成功。MapReduce是一种计算模型，该模型可将大型数据处理任务分解成很多单个的、可以在服务器集群中并行执行的任务。这些任务的计算结果可以合并在一起来计算最终的结果。

在Ubuntu下使用Hadoop编程：

安装hadoop：http://www.powerxing.com/install-hadoop/
在eclipse中编写hadoop的代码：http://www.powerxing.com/hadoop-build-project-using-eclipse/

hadoop的数据类型

 BooleanWritable 标准布尔变量的封装
 ByteWritable 单字节数的封装
 DoubleWritable 双字节数的封装
 FloatWritable 浮点数的封装
 IntWritable 整数的封装
 LongWritable Long的封装
 Text   使用UTF8格式的文本封装
 NullWritable 无键值时的站位符

关于map和Reducer：

Mapper接口负责数据处理阶段。它采用的形式为Mapper< K1,V1,K2,V2 >Java泛型，这里键类和值类分别实现WritableComparable和Writable接口。Mapper只有一个方法–map，用于处理一个单独的键/值对。
Reducer任务接收来自各个mapper的输出时，它按照键/值对中的键对输入数据进行排序，并将相同键的值归并。然后调用reduce（）函数，并通过迭代那些与指定键相关联的值，生成一个列表（K3，V3）

编写的代码示例

package org.apache.hadoop.examples;

import java.io.IOException;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

public class WordCount {
    public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable>{

        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();

        public void map(Object key, Text value, Context context) throws IOException, InterruptedException{
            String line = value.toString();
            line = line.replace("\\", "");
            String regex = "性别：</span><span class=\"pt_detail\">(.*?)</span>";
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(line);
            while(matcher.find()){
                String term = matcher.group(1);
                word.set(term);
                context.write(word, one);
            }
        }
    }

    public static class IntSumReducer extends Reducer<Text, IntWritable, Text, IntWritable>{

        private IntWritable result = new IntWritable();

        public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException{
            int sum = 0;
            for(IntWritable val :values){
                sum+= val.get();
            }
            result.set(sum);
            context.write(key, result);
        }
    }

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
        if(otherArgs.length != 2){
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2);
        }
        Job job = new Job(conf, "word count");
        job.setJarByClass(WordCount.class);
        job.setMapperClass(TokenizerMapper.class);
        job.setCombinerClass(IntSumReducer.class);
        job.setReducerClass(IntSumReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true)?0:1);
    }


}