Java Hadoop多输入

我正在使用hadoop map reduce，我想计算两个文件。我的第一次Map/Reduce迭代为我提供了一个文件，其中包含一个对ID号，如下所示：

A 30
D 20

A ABC 30
D EFGH 20

我的目标是使用该文件中的ID与另一个文件关联，并具有另一个三元组输出：ID、编号、名称，如下所示：

A 30
D 20

A ABC 30
D EFGH 20

但我不确定使用Map Reduce是否是最好的方法。例如，使用文件读取器读取第二个输入文件并通过ID获取名称是否更好？或者我可以用Map Reduce来做吗

如果是这样的话，我想知道怎么做。我尝试了多输入解决方案：

MultipleInputs.addInputPath(job2, new Path(args[1]+"-tmp"),
    TextInputFormat.class, FlightsByCarrierMapper2.class);
MultipleInputs.addInputPath(job2, new Path("inputplanes"),
    TextInputFormat.class, FlightsModeMapper.class); 

但我想不出任何解决方案来将两者结合起来并获得我想要的输出。我现在的方法就是给我一个列表，比如：

A ABC
A 30
B ABCD
C ABCDEF
D EFGH
D 20

在我最后一次减价后，我得到以下信息：

N125DL  767-332
N125DL  7   , 
N126AT  737-76N
N126AT  19  , 
N126DL  767-332
N126DL  1   , 
N127DL  767-332
N127DL  7   , 
N128DL  767-332
N128DL  3

我要这个：N127DL 7 767-332。而且，我不想要那些不结合的

这是我的课堂：

公共类航班ByCarrierReducer 2扩展了Reducer{

String merge = "";
protected void reduce(Text token, Iterable<Text> values, Context context) 
                            throws IOException, InterruptedException {

    int i = 0;  
    for(Text value:values)
    {
        if(i == 0){
            merge = value.toString()+",";
        }
        else{
            merge += value.toString();
        }
        i++;
    }

        context.write(token, new Text(merge));

}

String merge=”“；
受保护的void reduce（文本标记、Iterable值、上下文）
抛出IOException、InterruptedException{
int i=0；
用于（文本值：值）
{
如果（i==0）{
merge=value.toString（）+“，”；
}
否则{
merge+=value.toString（）；
}
i++；
}
write（标记，新文本（合并））；
}

}

更新：

这就是我正在使用的示例

我尝试使用：TailNum和Cancelled（1或0）获取对应于TailNum的模型名称。我的模型文件有一个TailNumb，model和其他东西。我当前的输出是：

N193JB ERJ 190-100 IGW

N194DN 767-332

N19503 EMB-135ER

N19554 EMB-145LR

N195DN 767-332

N195DN 2

首先是钥匙，其次是模型，取消航班的钥匙出现在模型下面

---

我想要一个trio键，Model Number of Cancelled，因为我想要每个模型的取消数

您可以使用ID作为两个映射器的键来加入它们。 您可以这样编写映射任务

public void map(LongWritable k, Text value, Context context) throws IOException, InterruptedException
{
    //Get the line
    //split the line to get ID seperate
    //word1 = A 
    //word2 = 30
                //Likewise for A ABC
                   //word1 = A 
                  //word2 = ABC
    context.write(word1, word2);
}

我想你可以继续同样的地图任务。 然后编写一个CommonReducer作业，Hadoop框架在其中按键对数据进行分组。 因此，您将能够获取ID作为密钥。 您可以缓存其中一个值，然后执行concat

String merge = "";
public void reduce(Text key, Iterable<Text> values, Context context)
{
    int i =0;
    for(Text value:values)
    {
        if(i == 0){
            merge = value.toString()+",";
        }
        else{
            merge += value.toString();
        }
        i++;
    }
    valEmit.set(merge);
    context.write(key, valEmit);
}

你可以找到这个例子

希望这有帮助

---

更新

输入1

A 30
D 20

输入2

A ABC
D EFGH

输出

A ABC 30
D EFGH 20

Mapper.java

import java.io.IOException;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

/**
 * @author sreeveni
 *
 */
public class Mapper1 extends Mapper<LongWritable, Text, Text, Text> {
    Text keyEmit = new Text();
    Text valEmit = new Text();

    public void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
        String line = value.toString();
        String parts[] = line.split(" ");
        keyEmit.set(parts[0]);
        valEmit.set(parts[1]);
        context.write(keyEmit, valEmit);
    }
}

import java.io.IOException;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

/**
 * @author sreeveni
 *
 */
public class ReducerJoin extends Reducer<Text, Text, Text, Text> {

    Text valEmit = new Text();
    String merge = "";

    public void reduce(Text key, Iterable<Text> values, Context context)
            throws IOException, InterruptedException {
        String character = "";
        String number = "";
        for (Text value : values) {
            // ordering output
            String val = value.toString();
            char myChar = val.charAt(0);

            if (Character.isDigit(myChar)) {
                number = val;
            } else {
                character = val;
            }
        }
        merge = character + " " + number;
        valEmit.set(merge);
        context.write(key, valEmit);
    }

}

import java.io.IOException；
导入org.apache.hadoop.io.LongWritable；
导入org.apache.hadoop.io.Text；
导入org.apache.hadoop.mapreduce.Mapper；
/**
*@作者sreeveni
*
*/
公共类Mapper1扩展了Mapper{
Text-keyEmit=新文本（）；
Text valEmit=新文本（）；
公共void映射（可长写键、文本值、上下文）
抛出IOException、InterruptedException{
字符串行=value.toString（）；
字符串部分[]=行分割（“”）；
keyEmit.set（部件[0]）；
valEmit.set（第[1]部分）；
write（keyEmit，valEmit）；
}
}

Reducer.java

import java.io.IOException;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

/**
 * @author sreeveni
 *
 */
public class Mapper1 extends Mapper<LongWritable, Text, Text, Text> {
    Text keyEmit = new Text();
    Text valEmit = new Text();

    public void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
        String line = value.toString();
        String parts[] = line.split(" ");
        keyEmit.set(parts[0]);
        valEmit.set(parts[1]);
        context.write(keyEmit, valEmit);
    }
}

import java.io.IOException;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

/**
 * @author sreeveni
 *
 */
public class ReducerJoin extends Reducer<Text, Text, Text, Text> {

    Text valEmit = new Text();
    String merge = "";

    public void reduce(Text key, Iterable<Text> values, Context context)
            throws IOException, InterruptedException {
        String character = "";
        String number = "";
        for (Text value : values) {
            // ordering output
            String val = value.toString();
            char myChar = val.charAt(0);

            if (Character.isDigit(myChar)) {
                number = val;
            } else {
                character = val;
            }
        }
        merge = character + " " + number;
        valEmit.set(merge);
        context.write(key, valEmit);
    }

}

import java.io.IOException；
导入org.apache.hadoop.io.Text；
导入org.apache.hadoop.mapreduce.Reducer；
/**
*@作者sreeveni
*
*/
公共类ReducerJoin扩展Reducer{
Text valEmit=新文本（）；
字符串merge=“”；
公共void reduce（文本键、Iterable值、上下文）
抛出IOException、InterruptedException{
字符串=”；
字符串编号=”；
用于（文本值：值）{
//排序输出
字符串val=value.toString（）；
char myChar=val.charAt（0）；
if（字符isDigit（myChar））{
数字=val；
}否则{
字符=val；
}
}
合并=字符+“”+数字；
集合（合并）；
context.write（key，valEmit）；
}
}

驾驶员等级

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.MultipleInputs;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

/**
 * @author sreeveni
 *
 */
public class Driver extends Configured implements Tool {
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        // checking the arguments count

        if (args.length != 3) {
            System.err
                    .println("Usage : <inputlocation>  <inputlocation>  <outputlocation> ");
            System.exit(0);
        }
        int res = ToolRunner.run(new Configuration(), new Driver(), args);
        System.exit(res);

    }

    @Override
    public int run(String[] args) throws Exception {
        // TODO Auto-generated method stub
        String source1 = args[0];
        String source2 = args[1];
        String dest = args[2];
        Configuration conf = new Configuration();
        conf.set("mapred.textoutputformat.separator", " "); // changing default
                                                            // delimiter to user
                                                            // input delimiter
        FileSystem fs = FileSystem.get(conf);
        Job job = new Job(conf, "Multiple Jobs");

        job.setJarByClass(Driver.class);
        Path p1 = new Path(source1);
        Path p2 = new Path(source2);
        Path out = new Path(dest);
        MultipleInputs.addInputPath(job, p1, TextInputFormat.class,
                Mapper1.class);
        MultipleInputs.addInputPath(job, p2, TextInputFormat.class,
                Mapper1.class);
        job.setReducerClass(ReducerJoin.class);

        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        job.setOutputFormatClass(TextOutputFormat.class);

        /*
         * delete if exist
         */
        if (fs.exists(out))
            fs.delete(out, true);

        TextOutputFormat.setOutputPath(job, out);
        boolean success = job.waitForCompletion(true);

        return success ? 0 : 1;
    }

}

import org.apache.hadoop.conf.Configuration；
导入org.apache.hadoop.conf.Configured；
导入org.apache.hadoop.fs.FileSystem；
导入org.apache.hadoop.fs.Path；
导入org.apache.hadoop.io.Text；
导入org.apache.hadoop.mapreduce.Job；
导入org.apache.hadoop.mapreduce.lib.input.MultipleInputs；
导入org.apache.hadoop.mapreduce.lib.input.TextInputFormat；
导入org.apache.hadoop.mapreduce.lib.output.TextOutputFormat；
导入org.apache.hadoop.util.Tool；
导入org.apache.hadoop.util.ToolRunner；
/**
*@作者sreeveni
*
*/
公共类驱动程序扩展配置的实现工具{
公共静态void main（字符串[]args）引发异常{
//TODO自动生成的方法存根
//检查参数计数
如果（参数长度！=3）{
System.err
.println（“用法：”）；
系统出口（0）；
}
int res=ToolRunner.run（新配置（），新驱动程序（），args）；
系统退出（res）；
}
@凌驾
公共int运行（字符串[]args）引发异常{
//TODO自动生成的方法存根
字符串source1=args[0]；
字符串source2=args[1]；
字符串dest=args[2]；
Configuration conf=新配置（）；
conf.set（“mapred.textoutputformat.separator”，“”）；//更改默认值
//用户分隔符
//输入分隔符
FileSystem fs=FileSystem.get（conf）；
作业作业=新作业（配置，“多个作业”）；
job.setJarByClass（Driver.class）；
路径p1=新路径（源1）；
路径p2=新路径（源2）；
路径输出=新路径（目的地）；
MultipleInputs.addInputPath（作业、p1、TextInputFormat.class、，
Mapper1.class）；