Question

考虑这个class :(来自Hadoop: The definitive guide第3版）：

import java.io.*;
import org.apache.hadoop.io.*;

public class TextPair implements WritableComparable<TextPair> {

  private Text first;
  private Text second;

  public TextPair() {
    set(new Text(), new Text());
  }

  public TextPair(String first, String second) {
    set(new Text(first), new Text(second));
  }

  public TextPair(Text first, Text second) {
    set(first, second);
  }

  public void set(Text first, Text second) {
    this.first = first;
    this.second = second;
  }

  public Text getFirst() {
    return first;
  }

  public Text getSecond() {
    return second;
  }

  @Override
  public void write(DataOutput out) throws IOException {
    first.write(out);
    second.write(out);
  }

  @Override
  public void readFields(DataInput in) throws IOException {
    first.readFields(in);
    second.readFields(in);
  }

  @Override
  public int hashCode() {
    return first.hashCode() * 163 + second.hashCode();
  }

  @Override
  public boolean equals(Object o) {
    if (o instanceof TextPair) {
      TextPair tp = (TextPair) o;
      return first.equals(tp.first) && second.equals(tp.second);
    }
    return false;
  }

  @Override
  public String toString() {
    return first + "\t" + second;
  }

  @Override
  public int compareTo(TextPair tp) {
    int cmp = first.compareTo(tp.first);
    if (cmp != 0) {
      return cmp;
    }
    return second.compareTo(tp.second);
  }
  // ^^ TextPair

  // vv TextPairComparator
  public static class Comparator extends WritableComparator {

    private static final Text.Comparator TEXT_COMPARATOR = new Text.Comparator();

    public Comparator() {
      super(TextPair.class);
    }

    @Override
    public int compare(byte[] b1, int s1, int l1,
                       byte[] b2, int s2, int l2) {

      try {
        int firstL1 = WritableUtils.decodeVIntSize(b1[s1]) + readVInt(b1, s1);
        int firstL2 = WritableUtils.decodeVIntSize(b2[s2]) + readVInt(b2, s2);
        int cmp = TEXT_COMPARATOR.compare(b1, s1, firstL1, b2, s2, firstL2);
        if (cmp != 0) {
          return cmp;
        }
        return TEXT_COMPARATOR.compare(b1, s1 + firstL1, l1 - firstL1,
                                       b2, s2 + firstL2, l2 - firstL2);
      } catch (IOException e) {
        throw new IllegalArgumentException(e);
      }
    }
  }

  static {
    WritableComparator.define(TextPair.class, new Comparator());
  }
  // ^^ TextPairComparator

  // vv TextPairFirstComparator
  public static class FirstComparator extends WritableComparator {

    private static final Text.Comparator TEXT_COMPARATOR = new Text.Comparator();

    public FirstComparator() {
      super(TextPair.class);
    }

    @Override
    public int compare(byte[] b1, int s1, int l1,
                       byte[] b2, int s2, int l2) {

      try {
        int firstL1 = WritableUtils.decodeVIntSize(b1[s1]) + readVInt(b1, s1);
        int firstL2 = WritableUtils.decodeVIntSize(b2[s2]) + readVInt(b2, s2);
        return TEXT_COMPARATOR.compare(b1, s1, firstL1, b2, s2, firstL2);
      } catch (IOException e) {
        throw new IllegalArgumentException(e);
      }
    }

    @Override
    public int compare(WritableComparable a, WritableComparable b) {
      if (a instanceof TextPair && b instanceof TextPair) {
        return ((TextPair) a).first.compareTo(((TextPair) b).first);
      }
      return super.compare(a, b);
    }
  }
  // ^^ TextPairFirstComparator

// vv TextPair
}
// ^^ TextPair

定义了comparators两种：一个按first排序，后跟second，这是默认的comparator. 另一种是仅按first排序，即firstComparator.

如果我必须使用firstComparator来排序我的密钥，我该如何实现？也就是说，如何使用我在上面定义的first comparator覆盖我的默认比较器。

其次，由于unitTest作业的输出不是map，我将如何sorted。？

Answer 1

如果我必须使用firstComparator来排序我的密钥，我该如何实现？也就是说，如何使用我在上面定义的第一个比较器覆盖默认比较器。

我假设你期望一个类似setComparator（firstComparator）的方法。据我所知，没有这样的方法。使用表示键的compareTo()类型的Writeable对键（在映射器侧）进行排序。在您的情况下，compareTo()方法检查第一个值，然后检查第二个值。换句话说，密钥将按第一个值排序，然后，同一组中的密钥（即具有相同的第一个值）将按其第二个值排序。

总而言之，这意味着您的密钥将始终按第一个值排序（如果第一个值无法做出决定，则按第二个值排序）。这反过来意味着不需要使用仅仅查看第一个值的不同比较器（firstComparator），因为已经使用compareTo()类的TextPair方法实现了该比较器。

另一方面，如果firstComparator完全不同地对键进行排序，唯一的解决方案是将firstComparator中的逻辑移动到compareTo()的{{1}}方法代表你的钥匙的班级。我没有看到你为什么不这样做的理由。如果您已经拥有Writable并希望重复使用它，则可以对其进行实例化，并在firstComparator compareTo()的{{1}}方法中调用它。

您可能还想查看TexPair，它用于决定在Writable方法的同一调用中一起使用哪些键。由于您没有准确描述您想要实现的目标，因此我无法确定这是否有用。

其次，我将如何进行unitTest，因为map作业的输出没有排序。？

如名称所示，单元测试意味着测试单个代码单元（大多数情况下是方法/函数/过程）。如果您想对reduce方法进行单元测试，必须提供有趣的输入案例，并检查测试中的方法是否输出预期结果。更具体地说，您必须在键上创建/模拟已排序的Iterable并使用它调用reduce函数。单元测试reduce方法不应该依赖于相应map方法的执行。

如何在Hadoop中的map-reduce作业中通过自定义比较器对键进行排序？

1 个答案: