java - 从类中调用已实现的接口(interface)重写方法

Question

我开始用 Java 做一些高级的事情(对我来说是高级 xD)。

我有这个:

interface ResultSet {
    public void close();
}

class DbResult {
    ResultSet data;
    Statement statement;

    public void close() {
        this.data.close();
        this.statement.close();
    }
}

我试过这样做:

interface ResultSet { //I think that is abstract or something
    public void close();
}

abstract class DbResult implements ResultSet {
    Statement statement;

    @Override
    public void close() {
        super.close();
        this.statement.close();
    }
}

显然它不起作用，因为 ResultSet 不是父类(super class)。我还尝试使 DbResult 成为接口(interface)并扩展 ResultSet，但它告诉我接口(interface)方法不能有主体，所以我不知道该怎么做。

我正在尝试这样做，以便我可以关闭结果语句并且结果只有一个变量而不是 2 个，因此不太容易因忘记关闭语句而发生内存泄漏。

Database 类以这种方式查询数据库:

class Database {
    private Connection connection;

    /* Here a constructor that
       inits the connection and such things */

    public DbResult query(String q) {
        Statement statement = this.connection.createStatement();
        DbResult result = (DbResult)statement.executeQuery(q);
        result.statement = statement;
        return result;
    }

编辑:好吧，既然我知道我不能，我想知道我是否可以用一种骇人听闻的形式来做到这一点:

有没有办法检查类中是否调用了不存在的方法，捕获它并在另一个变量中调用该方法名称？

例如，ResultSet 有一个名为 getString() 的方法。我想知道是否可以调用 DbResult.getString("blah"); 并且 DbResult 会将该方法重定向到 this.data 但是无需在 DbResult 类中实现 getString 方法。

我想知道是否可行，因为 ResultSet 中有大量函数，调用 DbResult.data.METHOD 不如 DbResult 优雅。方法.

Answer 1

Is there a way of checking if a method that does not exists is called in a class, catch it and invoke that method name in another variable?

因此，您希望包装对实例的调用，而不必扩展它或实现它的每个方法，这实际上是可能的，但仅限于通过接口(interface)公开的方法。好消息是 ResultSet 实际上是一个接口(interface)。

这可以通过动态代理(参见Proxy 和InvocationHandler)来完成。

您可以创建一个由 InvocationHandler 支持的 Proxy，它包装了 ResultSet。对代理实例的任何调用都将委托(delegate)给 InvocationHandler，它可以直接处理它们，或者在您的情况下，将它们委托(delegate)给包装的实际 ResultSet 实例。

public class MyResultSetInvocationHandler implements InvocationHandler {

    private final ResultSet wrappedResultSet;

    private MyResultSetInvocationHandler(ResultSet resultSet) {
        wrappedResultSet = resultSet;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        try {
            // call method on delegate
            Object result = method.invoke(wrappedResultSet, args);

            // optionally do something with the result, and return it afterwards
            return result;
        }
        catch (Throwable ex) {
            // handle exception, or rethrow it
            throw ex;
        }
    }

    /**
     * Factory method, creates a dynamic proxy wrapping the given result set.
     */
    public static ResultSet wrap(ResultSet delegate) {
        MyResultSetInvocationHandler handler = new MyResultSetInvocationHandler(delegate);
        return (ResultSet) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[] { ResultSet.class }, handler);
    }
}

用法:

// the actual result set
ResultSet resultSet = ...

// and your wrapped proxy/handler as a surrogate
resultSet = MyResultSetInvocationHandler.wrap(resultSet);