Java：对两个不同版本的依赖类使用相同的代码

Question

Consider a Java class Foo that uses a library Bar . Foo should be distributed as a binary .class file and use the version of Bar that is already existing on a clients classpath.

There are two different versions of Bar that only differ in its method signatures. Foo should be compatible with both of them.

Example code:

public class Foo {
    public static void main(String[] args){
        Bar.librarycall("hello from foo");
        //or
        Bar.librarycall("hello from foo",1);
    }
}
//v1
public class Bar {
    public static void librarycall(String argument){
        System.out.println("Bar1: " + argument);
    }
}
//v2
public class Bar {
    public static void librarycall(String argument,int i){
        for(int j = 0; j < i; j++)
            System.out.println("Bar2: " + argument);
    }
}

I want to avoid reflection if possible. How would you propose to create a class Foo that is compatible with both versions of Bar ?

[Edit]

This problem originates in a project I am working on. Bar corresponds to an external library I am using but cannot be modified for the code to work (I don't have the source code and the license doesn't allow modifications).

Answer 1

Reflection does seem like the simplest way. The alternative would be to try calling the second version and catch a NoSuchMethodException .

public class Foo {
    public static void main(String[] args){
        try {
            Bar.librarycall("hello from foo",1);
        catch(NoSuchMethodException e) {
            Bar.librarycall("hello from foo");
        }
}

This is ugly, and slower, use Reflection its what its there for.

Answer 2

听起来这是一项由策略模式处理的任务。

Answer 3

A refelective solution.

    Class<?> c;
    try {
        c = Class.forName("Bar");
        Method meths[] = c.getMethods();
        Method v1method = null;
        Method v2method = null;
        for(Method m:meths) {
            if(!m.getName().equals("librarycall")) continue;
            if(!Modifier.isStatic(m.getModifiers())) {
                System.out.println("Should be static");
                continue;
            }
            Class<?> params[] = m.getParameterTypes();
            if(params.length == 1 && params[0].equals(String.class) )
                v1method = m;
            if(params.length == 2 && params[0].equals(String.class) && params[1].equals(Integer.TYPE) )
                v2method = m;
        }
        if(v2method!=null) {
            v2method.invoke(null,"V2",5);
        }
        else if(v1method!=null) {
            v1method.invoke(null,"V1");
        }
        else
            System.out.println("No method found");

    } catch (ClassNotFoundException e) {
        System.out.println(e);
    } catch (IllegalArgumentException e) {
        System.out.println(e);
    } catch (IllegalAccessException e) {
        System.out.println(e);
    } catch (InvocationTargetException e) {
        System.out.println(e);
    }

You could use c = Bar.class; or if you already have an instance bar of Bar c = bar.getClass() . The invoke syntax is for static methods if its non static you need v1method.invoke(bar,"V1"); .

Answer 4

I'm assuming that:

1. You cannot change any of the versions of the Bar class files
2. You have the ability to write new Foo files
3. For some reason, you really want to avoid using Reflection
4. The two Bar files have the same package name

You may need to distribute two versions of the Foo class, as mentioned by JB Nizet in the comment to your question.