Hadoop mapper可以在输出中生成多个键吗？

单个映射器类能否在一次运行中生成多个键值对（相同类型）

我们在映射器中输出键值对，如下所示：

context.write(key, value);

下面是该键的精简版（并举例说明）：

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.hadoop.io.ObjectWritable;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;


public class MyKey extends ObjectWritable implements WritableComparable<MyKey> {

    public enum KeyType {
        KeyType1,
        KeyType2
    }

    private KeyType keyTupe;
    private Long field1;
    private Integer field2 = -1;
    private String field3 = "";


    public KeyType getKeyType() {
        return keyTupe;
    }

    public void settKeyType(KeyType keyType) {
        this.keyTupe = keyType;
    }

    public Long getField1() {
        return field1;
    }

    public void setField1(Long field1) {
        this.field1 = field1;
    }

    public Integer getField2() {
        return field2;
    }

    public void setField2(Integer field2) {
        this.field2 = field2;
    }


    public String getField3() {
        return field3;
    }

    public void setField3(String field3) {
        this.field3 = field3;
    }

    @Override
    public void readFields(DataInput datainput) throws IOException {
        keyTupe = KeyType.valueOf(datainput.readUTF());
        field1 = datainput.readLong();
        field2 = datainput.readInt();
        field3 = datainput.readUTF();
    }

    @Override
    public void write(DataOutput dataoutput) throws IOException {
        dataoutput.writeUTF(keyTupe.toString());
        dataoutput.writeLong(field1);
        dataoutput.writeInt(field2);
        dataoutput.writeUTF(field3);
    }

    @Override
    public int compareTo(MyKey other) {
        if (getKeyType().compareTo(other.getKeyType()) != 0) {
            return getKeyType().compareTo(other.getKeyType());
        } else if (getField1().compareTo(other.getField1()) != 0) {
            return getField1().compareTo(other.getField1());
        } else if (getField2().compareTo(other.getField2()) != 0) {
            return getField2().compareTo(other.getField2());
        } else if (getField3().compareTo(other.getField3()) != 0) {
            return getField3().compareTo(other.getField3());
        } else {
            return 0;
        }
    }

    public static class MyKeyComparator extends WritableComparator {
        public MyKeyComparator() {
            super(MyKey.class);
        }

        public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
            return compareBytes(b1, s1, l1, b2, s2, l2);
        }
    }

    static { // register this comparator
        WritableComparator.define(MyKey.class, new MyKeyComparator());
    }
}

我们作业的输出格式类是：org.apache.hadoop.mapreduce.lib.output.SequenceFileOutputFormat

我之所以这样说，是因为在其他输出格式类中，我看到在write方法的实现中，输出没有追加，只是提交

此外，我们还将以下类用于映射器和上下文： org.apache.hadoop.mapreduce.Mapper

---

org.apache.hadoop.mapreduce.Context

在一个映射任务中多次写入上下文是非常好的

但是，您的密钥类可能有几个问题。无论何时为键实现

writeablecomparable

，都应该实现

equals（Object）

和

hashCode（）

方法。这些不是WritableComparable接口的一部分，因为它们是在

对象中定义的，但您必须提供实现

默认的分区器使用
hashCode（）
方法来决定每个键/值对将使用哪个减缩器。如果您没有提供一个合理的实现，您可能会得到奇怪的结果

根据经验，无论何时实现
hashCode（）
或任何类型的比较方法，都应该提供
equals（Object）
方法。您必须确保它接受
对象
作为参数，因为这是在
对象
类中定义它的方式（您可能要覆盖它的实现）。
不确定“type”是什么意思。您是在询问是否可以获得与多个值关联的同一个键，还是可以多次生成具有相同值的同一个键？我希望通过一次映射程序输出两个键，每个键的值不同。确保这是可能的，这实际上是正确的方法。您确定二进制比较器工作正常吗？您不必从objectwritable进行扩展，只需要实现writablecomparable。您需要在writablecomparable上提供equals（）和hashCode（）方法。它们不是界面的一部分，但是如果没有它们，您的工作将失败。
MyKey key1 = new MyKey();
key1.settKeyType(KeyType.KeyType1);
key1.setField1(1L);
key1.setField2(23);

MyKey key2 = new MyKey();
key2.settKeyType(KeyType.KeyType2);
key2.setField1(1L);
key2.setField3("abc");

context.write(key1, value1);
context.write(key2, value2);