Question

我在Hadoop上实现了辅助排序，但我并不真正了解框架的行为。

我创建了一个复合键，其中包含原始键和值的一部分，用于排序。

为实现这一点，我实现了自己的分区器

public class CustomPartitioner extends Partitioner<CoupleAsKey, LongWritable>{

@Override
public int getPartition(CoupleAsKey couple, LongWritable value, int numPartitions) {

    return Long.hashCode(couple.getKey1()) % numPartitions;
}

我自己的小组比较器

public class GroupComparator extends WritableComparator {

protected GroupComparator()
{
    super(CoupleAsKey.class, true);
}

@Override
public int compare(WritableComparable w1, WritableComparable w2) {

    CoupleAsKey c1 = (CoupleAsKey)w1;
    CoupleAsKey c2 = (CoupleAsKey)w2;

    return Long.compare(c1.getKey1(), c2.getKey1());
}

}

以下列方式定义了这对夫妇

public class CoupleAsKey implements WritableComparable<CoupleAsKey>{

private long key1;
private long key2;

public CoupleAsKey() {
}

public CoupleAsKey(long key1, long key2) {
    this.key1 = key1;
    this.key2 = key2;
}

public long getKey1() {
    return key1;
}

public void setKey1(long key1) {
    this.key1 = key1;
}

public long getKey2() {
    return key2;
}

public void setKey2(long key2) {
    this.key2 = key2;
}

@Override
public void write(DataOutput output) throws IOException {

    output.writeLong(key1);
    output.writeLong(key2);

}

@Override
public void readFields(DataInput input) throws IOException {

    key1 = input.readLong();
    key2 = input.readLong();
}

@Override
public int compareTo(CoupleAsKey o2) {

    int cmp = Long.compare(key1, o2.getKey1());

    if(cmp != 0)
        return cmp;

    return Long.compare(key2, o2.getKey2());
}

@Override
public String toString() {
    return key1 + ","  + key2 + ",";
}

}

这是驱动程序

Configuration conf = new Configuration();
    Job job = new Job(conf);

    job.setJarByClass(SSDriver.class);

    job.setMapperClass(SSMapper.class);
    job.setReducerClass(SSReducer.class);

    job.setMapOutputKeyClass(CoupleAsKey.class);
    job.setMapOutputValueClass(LongWritable.class);
    job.setPartitionerClass(CustomPartitioner.class);
    job.setGroupingComparatorClass(GroupComparator.class);

    FileInputFormat.addInputPath(job, new Path("/home/marko/WORK/Whirlpool/input.csv"));
    FileOutputFormat.setOutputPath(job, new Path("/home/marko/WORK/Whirlpool/output"));

    job.waitForCompletion(true);

现在，这是有效的，但真正奇怪的是，当在reducer中迭代一个键时，键的第二部分（值部分）在每次迭代中都会发生变化。为什么以及如何？

 @Override
protected void reduce(CoupleAsKey key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {

    for (LongWritable value : values) {

        //key.key2 changes during iterations, why?
        context.write(key, value);
    }

}

Answer 1

定义说明＆＃34;如果您希望发送到单个reducer的数据分区中的所有相关行，您必须实现分组比较器＆＃34;。这只能确保那些设置密钥将被发送到单个 reduce调用，而不是密钥将从复合（或其他）更改为仅包含完成分组的密钥部分的内容。

但是，当您迭代值时，相应的键也会更改。我们通常不会观察到这种情况，因为默认情况下，值会在同一个（非复合）键上分组，因此，即使值发生更改，（ - of-）键也保持不变。

您可以尝试打印密钥的对象引用，您会注意到，每次迭代时，密钥的对象引用也会发生变化（如下所示：）

IntWritable@1235ft
IntWritable@6635gh
IntWritable@9804as

或者，您也可以尝试以下列方式在IntWritable上应用组比较器（您必须编写自己的逻辑）：

你将看到，每次迭代的价值，你的钥匙也在变化。

使用复合键时迭代值时的部分关键更改 - Hadoop

1 个答案: