2021SC@SDUSC
上篇已经看了TupleFactory(抽象类)和TupleMaker(接口），接下来继续结合博客内容对源码进行分析
相关资料链接：【Pig源码分析】谈谈Pig的数据模型 -数据库-火龙果软件工程
博客摘要：
在BinSedesTupleFactory的newTuple方法中，返回的是BinSedesTuple对象。BinSedesTuple类继承于DefaultTuple类，在DefaultTuple类中有List<Object> mFields字段，这便是存储Tuple数据的地方了，mFields所持有类型为ArrayList<Object>()；。类图关系：
找到项目中BinSedesTupleFactory的代码：
/**
* Default implementation of TupleFactory.
*/
@InterfaceAudience.Private
public class BinSedesTupleFactory extends TupleFactory {
@Override
public Tuple newTuple() {
return new BinSedesTuple();
}
@Override
public Tuple newTuple(int size) {
return new BinSedesTuple(size);
}
@Override
@SuppressWarnings("unchecked")
public Tuple newTuple(List c) {
return new BinSedesTuple(c);
}
@Override
@SuppressWarnings("unchecked")
public Tuple newTupleNoCopy(List list) {
return new BinSedesTuple(list, 1);
}
@Override
public Tuple newTuple(Object datum) {
Tuple t = new BinSedesTuple(1);
try {
t.set(0, datum);
} catch (ExecException e) {
// The world has come to an end, we just allocated a tuple with one slot
// but we can't write to that slot.
throw new RuntimeException("Unable to write to field 0 in newly " +
"allocated tuple of size 1!", e);
}
return t;
}
@Override
public Class<? extends Tuple> tupleClass() {
return BinSedesTuple.class;
}
@Override
public Class<? extends TupleRawComparator> tupleRawComparatorClass() {
return BinSedesTuple.getComparatorClass();
}
@Override
public boolean isFixedSize() {
return false;
}
}
可以看到newTuple进行了多次重载，上篇我们知道，TupleFactory大多数方法都是抽象方法，这里出现的所有函数均为抽象的实现，是一种重写现象；newTuple返回值是Tuple，返回函数是new BinSedeTuple，Tuple是BinSedeTuple的父类，严格来说，有以下关系，也就是上文那张图
这里也可以看到继承的双面性，一方面可以重用父类的代码，另一方面，子类必须给父类的代码给出实现
这里提出疑问：面向对象程序设计的继承结构真的有必要吗？从前面的分析来看，是不是觉得继承很麻烦？一个程序可以完成的事情使用继承需要五六个程序完成？这里我们拿Tuple举例
指示该对象是否保存的值
*为null的标记
/**
* Marker for indicating whether the value this object holds
* is a null
*/
public static byte NULL = 0x00;
指示该对象是否保存的值
*不是空的标记/**
* Marker for indicating whether the value this object holds
* is not a null
*/
public static byte NOTNULL = 0x01;
使这个元组引用另一个元组的内容。此方法不进行复制
*底层数据。它维护对原始数据的引用
*元组(甚至可能是保存数据的数据结构)。
* @param t元组引用
/**
* Make this tuple reference the contents of another. This method does not copy
* the underlying data. It maintains references to the data from the original
* tuple (and possibly even to the data structure holding the data).
* @param t Tuple to reference.
*/
@Deprecated
void reference(Tuple t);
查找元组的大小。用于响应arity()。
* @return元组中字段的个数。
/**
* Find the size of the tuple. Used to be called arity().
* @return number of fields in the tuple.
*/
int size();
找出给定字段是否为空。
* @param fieldNum检查字段是否为空。
* @如果字段为空则返回true，否则返回false。
* @throws ExecException如果给定的字段数更大
大于或等于元组中字段的数量。
/**
* Find out if a given field is null.
* @param fieldNum Number of field to check for null.
* @return true if the field is null, false otherwise.
* @throws ExecException if the field number given is greater
* than or equal to the number of fields in the tuple.
*/
boolean isNull(int fieldNum) throws ExecException;
查找给定字段的类型。
* @param fieldNum获取类型字段的数量。
* @return类型，编码为字节值。值定义在
* {@link数据类型}。如果字段为空，则返回DataType。未知的
*将被返回。
* @throws ExecException如果字段数大于等于
元组中字段的数量。
/**
* Find the type of a given field.
* @param fieldNum Number of field to get the type for.
* @return type, encoded as a byte value. The values are defined in
* {@link DataType}. If the field is null, then DataType.UNKNOWN
* will be returned.
* @throws ExecException if the field number is greater than or equal to
* the number of fields in the tuple.
*/
byte getType(int fieldNum) throws ExecException;
获取给定字段中的值。
* @param fieldNum获取值的字段号。
* @返回值，作为一个对象。
* @throws ExecException如果字段数大于等于
元组中字段的数量
/**
* Get the value in a given field.
* @param fieldNum Number of the field to get the value for.
* @return value, as an Object.
* @throws ExecException if the field number is greater than or equal to
* the number of fields in the tuple.
*/
Object get(int fieldNum) throws ExecException;
*以列表形式获取元组中的所有字段。
* @return一个包含元组字段的对象有序列表
/**
* Get all of the fields in the tuple as a list.
* @return a list of objects containing the fields of the tuple
* in order.
*/
List<Object> getAll();
在给定字段中设置值。这个不应该被调用，除非
*该元组由{@link TupleFactory#newTuple(int)}构造
*参数大于传递到这里的fieldNum。这个调用将
*不会自动扩展元组大小。如果你打电话的话
* {@link TupleFactory#newTuple(int)}使用2，可以调用
这个函数带有1，但不带有2或更大的值。
* @param fieldNum要设置值的字段号。
* @param val对象放入指定的字段。
* @throws ExecException如果字段数大于等于
元组中字段的数量
/**
* Set the value in a given field. This should not be called unless
* the tuple was constructed by {@link TupleFactory#newTuple(int)} with an
* argument greater than the fieldNum being passed here. This call will
* not automatically expand the tuple size. That is if you called
* {@link TupleFactory#newTuple(int)} with a 2, it is okay to call
* this function with a 1, but not with a 2 or greater.
* @param fieldNum Number of the field to set the value for.
* @param val Object to put in the indicated field.
* @throws ExecException if the field number is greater than or equal to
* the number of fields in the tuple.
*/
void set(int fieldNum, Object val) throws ExecException;
将字段附加到元组。这种方法并不像它可能的那样有效
*强制复制现有数据以增长数据结构。
*只要有可能，你就应该使用
* {@link TupleFactory#newTuple(int)}，然后用
* {@link #set(int, Object)}，而不是
*然后使用{@link TupleFactory#newTuple()}构造它并添加值。
* @param val对象附加到元组。
/**
* Append a field to a tuple. This method is not efficient as it may
* force copying of existing data in order to grow the data structure.
* Whenever possible you should construct your Tuple with
* {@link TupleFactory#newTuple(int)} and then fill in the values with
* {@link #set(int, Object)}, rather
* than construct it with {@link TupleFactory#newTuple()} and append values.
* @param val Object to append to the tuple.
*/
void append(Object val);
确定元组在内存中的大小。这是由数据袋使用的
*来确定它们的内存大小。这并不需要精确，但是
*应该是一个体面的估计。
* @return估计的内存大小，以字节为单位
/**
* Determine the size of tuple in memory. This is used by data bags
* to determine their memory size. This need not be exact, but it
* should be a decent estimation.
* @return estimated memory size, in bytes.
*/
long getMemorySize();
将值元组写入字符串。输出将是结果
对元组中的每个值调用toString。
* @param delim在字符串中使用的分隔符。
* @return包含元组的字符串。
* @throws ExecException不会抛出。这只存在于向后兼容的原因。
/**
* Write a tuple of values into a string. The output will be the result
* of calling toString on each of the values in the tuple.
* @param delim Delimiter to use in the string.
* @return A string containing the tuple.
* @throws ExecException this is never thrown. This only exists for backwards compatability reasons.
*/
String toDelimitedString(String delim) throws ExecException;
笔记：Tuple作为一个接口，其函数只提供了定义，没有提供实现，在abstractTuple中会更加详细的实现，我们来看看它的源码
public abstract class AbstractTuple implements Tuple {
@Override
public Iterator<Object> iterator() {
return getAll().iterator();
}
@Override
public String toString() {
return TupleFormat.format(this);
}
/**
* {@inheritDoc}
*/
@Override
public String toDelimitedString(String delim) throws ExecException {
return Joiner.on(delim).useForNull("").join(this);
}
/**
* {@inheritDoc}
*/
@Override
public byte getType(int fieldNum) throws ExecException {
return DataType.findType(get(fieldNum));
}
/**
* {@inheritDoc}
*/
@Override
public boolean isNull(int fieldNum) throws ExecException {
return (get(fieldNum) == null);
}
@Override
public boolean equals(Object other) {
return (compareTo(other) == 0);
}
@Override
public void reference(Tuple t) {
throw new RuntimeException("Tuple#reference(Tuple) is deprecated and should not be used");
}
}
这里产生了一个疑问，这里toString在Tuple中并没有定义，为何也可以重写？原因如下
我们知道Java中只有接口是可以多重继承的，这里Tuple就用了多重继承，toString改写的是从某个父类继承下来的方法
abstractTuple给出了部分接口的实现，如果它的子类没有重写，那么就会调用abstractTuple里面的方法
abstractTuple调用了很多其他函数，比如TupleFormat,这个是impl目录下的文件，因此不展开分析了,这里给出注释
元组格式的默认实现。Dump和PigDump使用默认值
*实现
/**
* Default implementation of format of Tuple. Dump and PigDump use this default
* implementation
*/
public class TupleFormat
转来转去，我们突然发现，分析了半天，我们仍然不知道Tuple究竟存放了什么！这是因为Tuple具体存放了什么放到defaultTuple实现了，估计的原因是Tuple支持多种类型，因此DefaultTuple只是其中一种实现，其他的实现和DefaultTuple一样继承自AbstractTuple，个人觉得这么设计特别麻烦，直接在顶层实现将各种方法定义好就完事了，这也是使用继承需要面对的问题，有时候继承不一定比直接编程好用，至于多种类型，实际上可以使用模板来实现
最后抛出个问题，在这个程序设计中，这样的继承设计真的有必要吗？
本文的内容先到这里