使用更改的构造函数实例化同一类的不同版本，并“摘要”修饰符

Question

我正在编写使用外部库的Java程序。我想编写我的代码，以便它与两个特定库的两个不同版本兼容。

问题是，他们更改了一个类（在我的示例中称为configuration），添加了一个抽象方法，并将构造函数从无符合参数化构造函数更改为参数化构造函数。我无法影响外部图书馆，我必须与我所拥有的东西一起工作。

旧类示例

public class Configuration {

    public Configuration() {
        //Some code...
    }

    public static void main(String[] args) {
        Configuration conf = new Configuration();
        //Some code...
    }

}

新类示例

public abstract class Configuration {

    public Configuration(boolean isCool, Map<String, String> entries, Object otherThing) {
        //Some code...
    }

    public abstract int doSomething();
    
    public static void main(String[] args) {
        Configuration conf = new MyConfiguration(false, null, new Object());
        //Some code...
    }

}

我的实现

public class MyConfiguration extends Configuration {
    
    public MyConfiguration(boolean isCool, Map<String, String> entries, Object otherThing) {
        super(isCool, entries, otherThing);
    }
    
    public MyConfiguration() {
        //needs super constructor call!?
    }

    public int doSomething() {
        //Some code...
        return -1;
    }

    public static void main(String[] args) {
        int version = 0;
        Configuration conf = version > 2 ? new MyConfiguration(false, null, new Object()) : new MyConfiguration();  
        //Some code...
    }

}

​但是，旧类没有参数化的构造函数，因此，如果这样做，我会遇到错误。

• 有什么技巧我不必为超级构造函数打电话吗？
• 也许有一种方法可以使用反思来完成我想要的事情？

Answer 1

您的示例有些奇怪，因为新类示例包含对您的myConfiguration的引用。

通常，最好维护两个版本的myConfiguration类或放弃对该库的旧版本的支持。或者，考虑不要使用进行如此急剧更改的库。

为了完整，有一个骇客解决您的字面问题。假设类configuration不可序列化如图所示，或者至少是旧版本，则可以使用特定的序列化行为。当可序列化类扩展了非序列化类时，其实例化的实例将导致超级类默认构造函数的调用。

因此，使用它的代码看起来像：

public class MyConfiguration extends Configuration implements Serializable {
    public MyConfiguration(
        boolean isCool, Map<String, String> entries, Object otherThing) {
        super(isCool, entries, otherThing);
        // new version setup
    }
  
    private void readObject(java.io.ObjectInputStream in)
                                          throws IOException, ClassNotFoundException {
        // old version, Configuration's default constructor has been called
    }
  
    public static MyConfiguration create() {
        return new ByteArrayOutputStream() {
            MyConfiguration get() {
                final short numFields = 0;
                try {
                    Configuration.class.getConstructor(); // check for old version
                    DataOutputStream os = new DataOutputStream(this);
                    // using import static java.io.ObjectStreamConstants.*;
                    os.writeShort(STREAM_MAGIC);
                    os.writeShort(STREAM_VERSION);
                    os.write(TC_OBJECT);
                    os.write(TC_CLASSDESC);
                    os.writeUTF(MyConfiguration.class.getName());
                    os.writeLong(ObjectStreamClass.lookup(MyConfiguration.class)
                                                  .getSerialVersionUID());
                    os.write(SC_SERIALIZABLE);
                    os.writeShort(numFields);
                    os.write(TC_ENDBLOCKDATA);
                    os.write(TC_NULL);
                    os.flush();
                    return (MyConfiguration)new ObjectInputStream(
                           new ByteArrayInputStream(buf, 0, count)).readObject();
                }
                catch(NoSuchMethodException ex) {
                    // new version
                    return new MyConfiguration(false, Map.of(), null);
                }
                catch(IOException|ClassNotFoundException ex) {
                    throw new AssertionError(ex);
                }
            }
        }.get();
    }

    public int doSomething() {
        //Some code...
        return -1;
    }
}

可以针对新版本编译此类。 create（）方法首先检查是否存在默认构造函数。当缺失时，即使用新版本运行，将调用新构造函数。否则，它可以将一个实例与没有数据流的流进行审理，因此在调用超类默认构造函数之后，readObject可能会执行实际设置。

这一切都需要一个不在乎不兼容的构造函数的懒惰验证者，只要没有人试图实际调用构造函数。正如一开始所说的，您最好使用其他解决方案。