为数据库类创建通用的“ getColumn”方法（Java）

Question

I have a Database class that encapsulates the functionality of java.sql.* classes. Basically you subclass it in order to create a connection to a particular database, and then you can use its methods to perform common operations.

One operation I'd like to implement is a getColumn() method. If the expected database column is a String datatype, I could do the following:

public List<String> getColumn(String sql) throws SQLException
{
    List<String> results = new ArrayList<>();
    ResultSet rs = _stmt.executeQuery(sql);
    while (rs.next())
    {
        results.add(rs.getString(1));
    }
    return results;
}

But I would like to genericize this method with a template parameter, and use the proper ResultSet.get* method to populate the ArrayList .

Something like this:

public <T> List<T> getColumn(String sql) throws SQLException
{
    List<T> results = new ArrayList<>();
    ResultSet rs = _stmt.executeQuery(sql);
    while (rs.next())
    {
        // if T is String, do:
        // results.add(rs.getString(1));
        // if T is Integer, do:
        // results.add(rs.getInt(1));
        // etc.
    }
    return results;

I'm sure there must be an elegant way to do this. Thoughts? Am I going about this the wrong way? }

Answer 1

Here's one way of doing it,

public <T> List<T> getColumn(String sql) throws SQLException {
    List<T> results = new ArrayList<>();
    ResultSet rs = _stmt.executeQuery(sql);
    while (rs.next()) {
        @SuppressWarnings("unchecked")
        final T colVal = (T) rs.getObject(1);
        results.add(colVal);
    }
    return results;
}

Answer 2

A common mistake is attempting a method with signature like:

<T> T fn()

In Java there is no way to find out within an invocation of fn what T . The choices are return null , unsafely cast an object that may or may not be a T or throw an exception. If you have something similar but a return type of List<T> the only thing you could store in that list is null .

So what to do. Typically you would pass in an argument to create the required type. A function object, for instance. (I would use java.util.function.Function , but checked exceptions get in the way.)

List<String> names = getColumn(
    "SELECT [...]",
    (result, column) -> result.getString(column)
);
[...]

interface ResultFunction<T> {
    T get(ResultSet results, int column) throws SQLException;
}

public <T> List<T> getColumn(
    String sql, ResultFunction<T> function
) throws SQLException {
    List<T> values = new ArrayList<>();
    try (ResultSet result = _stmt.executeQuery(sql)) {
        while (result.next()) {
            values.add(function.get(result, 1));
        }
    }
    return values;
}

You may want to expand the functionality of ResultFunction and perhaps use enums.