使用基本抽象类组合两个相似的类

Question

我正在处理一个项目的pull请求，有人告诉我，将两个类似类的代码组合成一个抽象类可能是个好主意，其他两个类将从中扩展。我的问题是我没有正确的方法来做这件事。以下是两个课程：

public class ClassOne<OUT> extends RichInputFormat<OUT, InputSplit> implements NonParallelInput {
private static final Logger LOG = LoggerFactory.getLogger(ClassOne.class);

private final String query;
private final ClusterBuilder builder;

private transient Cluster cluster;
private transient Session session;
private transient Result<OUT> resultSet;
private Class<OUT> inputClass;

public ClassOne(String query, ClusterBuilder builder, Class<OUT> inputClass) {
    Preconditions.checkArgument(!Strings.isNullOrEmpty(query), "Query cannot be null or empty");
    Preconditions.checkArgument(builder != null, "Builder cannot be null");
    Preconditions.checkArgument(inputClass != null, "InputClass cannot be null");

    this.query = query;
    this.builder = builder;
    this.inputClass = inputClass;
}

@Override
public void configure(Configuration parameters) {
    this.cluster = builder.getCluster();
}

@Override
public BaseStatistics getStatistics(BaseStatistics cachedStatistics) throws IOException {
    return cachedStatistics;
}

/**
 * Opens a Session and executes the query.
 *
 * @param ignored
 * @throws IOException
 */
@Override
public void open(InputSplit ignored) throws IOException {
    this.session = cluster.connect();
    MappingManager manager = new MappingManager(session);

    Mapper<OUT> mapper = manager.mapper(inputClass);

    this.resultSet = mapper.map(session.execute(query));
}

@Override
public boolean reachedEnd() throws IOException {
    return resultSet.isExhausted();
}

@Override
public OUT nextRecord(OUT reuse) throws IOException {
    return resultSet.one();
}

@Override
public InputSplit[] createInputSplits(int minNumSplits) throws IOException {
    GenericInputSplit[] split = {new GenericInputSplit(0, 1)};
    return split;
}

@Override
public InputSplitAssigner getInputSplitAssigner(InputSplit[] inputSplits) {
    return new DefaultInputSplitAssigner(inputSplits);
}

/**
 * Closes all resources used.
 */
@Override
public void close() throws IOException {
    try {
        if (session != null) {
            session.close();
        }
    } catch (Exception e) {
        LOG.error("Error while closing session.", e);
    }

    try {
        if (cluster != null) {
            cluster.close();
        }
    } catch (Exception e) {
        LOG.error("Error while closing cluster.", e);
    }
}
}

第二点是：

public class ClassTwo<OUT extends Tuple> extends RichInputFormat<OUT, InputSplit> implements NonParallelInput {
private static final Logger LOG = LoggerFactory.getLogger(ClassTwo.class);

private final String query;
private final ClusterBuilder builder;

private transient Cluster cluster;
private transient Session session;
private transient ResultSet resultSet;

public ClassTwo(String query, ClusterBuilder builder) {
    Preconditions.checkArgument(!Strings.isNullOrEmpty(query), "Query cannot be null or empty");
    Preconditions.checkArgument(builder != null, "Builder cannot be null");

    this.query = query;
    this.builder = builder;
}

@Override
public void configure(Configuration parameters) {
    this.cluster = builder.getCluster();
}

@Override
public BaseStatistics getStatistics(BaseStatistics cachedStatistics) throws IOException {
    return cachedStatistics;
}

/**
 * Opens a Session and executes the query.
 *
 * @param ignored
 * @throws IOException
 */
@Override
public void open(InputSplit ignored) throws IOException {
    this.session = cluster.connect();
    this.resultSet = session.execute(query);
}

@Override
public boolean reachedEnd() throws IOException {
    return resultSet.isExhausted();
}

@Override
public OUT nextRecord(OUT reuse) throws IOException {
    final Row item = resultSet.one();
    for (int i = 0; i < reuse.getArity(); i++) {
        reuse.setField(item.getObject(i), i);
    }
    return reuse;
}

@Override
public InputSplit[] createInputSplits(int minNumSplits) throws IOException {
    GenericInputSplit[] split = {new GenericInputSplit(0, 1)};
    return split;
}

@Override
public InputSplitAssigner getInputSplitAssigner(InputSplit[] inputSplits) {
    return new DefaultInputSplitAssigner(inputSplits);
}

/**
 * Closes all resources used.
 */
@Override
public void close() throws IOException {
    try {
        if (session != null) {
            session.close();
        }
    } catch (Exception e) {
        LOG.error("Error while closing session.", e);
    }

    try {
        if (cluster != null) {
            cluster.close();
        }
    } catch (Exception e) {
        LOG.error("Error while closing cluster.", e);
    }
}
}

不同之处在于Constructor（）、open（）和nextRecord（）方法以及resultSet变量。一班和二班也有。我假设open和nextRecord方法只是不在抽象基类中实现它们，而让它们在类一和类二中实现。但是抽象基类需要有一个构造函数，这两个类有不同的构造函数，基类必须有or，这将使ClassOne或ClassTwo不能工作，这取决于所使用的构造函数。我觉得我忽略了一个简单的解决方案。

感谢任何帮助！谢谢！

Answer 1

在Java（和其他语言）中，完全有可能有一个包含空构造函数的抽象类。因此，使用抽象类提供的两个类的组合可能看起来像这样：

public abstract class ClassAbstract extends RichInputFormat<OUT, InputSplit> implements NonParallelInput {

    private final String query;
    private final ClusterBuilder builder;
    private transient Cluster cluster;
    private transient Session session;

    public ClassAbstract(String query, ClusterBuilder builder) {
        Preconditions.checkArgument(!Strings.isNullOrEmpty(query), "Query cannot be null or empty");
        Preconditions.checkArgument(builder != null, "Builder cannot be null");
        this.query = query;
        this.builder = builder;
    }

    @Override
    public void configure(Configuration parameters) {
        this.cluster = builder.getCluster();
    }

    @Override
    public BaseStatistics getStatistics(BaseStatistics cachedStatistics) throws IOException {
        return cachedStatistics;
    }

    @Override
    public boolean reachedEnd() throws IOException {
        return resultSet.isExhausted();
    }

    @Override
    public InputSplit[] createInputSplits(int minNumSplits) throws IOException {
        GenericInputSplit[] split = {new GenericInputSplit(0, 1)};
        return split;
    }

    @Override
    public InputSplitAssigner getInputSplitAssigner(InputSplit[] inputSplits) {
        return new DefaultInputSplitAssigner(inputSplits);
    }

    /**
     * Closes all resources used.
     */
    @Override
    public void close() throws IOException {
        try {
            if (session != null) {
                session.close();
            }
        } catch (Exception e) {
            LOG.error("Error while closing session.", e);
        }

        try {
            if (cluster != null) {
                cluster.close();
            }
        } catch (Exception e) {
            LOG.error("Error while closing cluster.", e);
        }
    }

}

然后，您的ClassOne构造函数可以简单地：

    public ClassOne(String query, ClusterBuilder builder, Class<OUT> inputClass) {
        super(query, builder);
        Preconditions.checkArgument(inputClass != null, "InputClass cannot be null");
        this.inputClass = inputClass;
    }

ClassTwo的构造函数将变成：

    public ClassTwo(String query, ClusterBuilder builder) {
        super(query, builder);
    }

然后可以通过扩展抽象类并删除抽象类中已经存在的所有代码来实例化子类。