寻找合适的设计模式

Question

Our code has several processors, each one having several api methods, where each method is overloaded also with same method that can accept collection.
For example:

public class Foo {
    public X foo(Y y){...}
    public Collection<X> foo(Collection<Y> y){... // iterate and execute foo(y) ... }
    public Z bar(W w){...}
    public Collection<Z> bar(Collection<W> w){... // iterate and execute bar(w) ... }
}
public class Other{
    // also method and method on collection
}

Naturally, those methods on collections are actually duplication code of iteration.
What we are looking for, is kind of way to make some pattern or use generics, so the iteration over collection will be implemented once , also for that need a way to somehow pass the method name.

Answer 1

I'd suggest Startegy pattern . And do something like:

public interface Transformer<X, Y> {
    Y transform( X input );
}

class Processor {

    public <X,Y> Collection<Y> process( Collection<X> input, Transformer<X, Y> transformer) {
        Collection<Y> ret = new LinkedList<Y>();
        // generic loop, delegating transformation to specific transformer
        for( X x : input) {
            ret.add( transformer.transform( x ) );
        }
        return ret;
    }
}

Example:

public static void main( String[] args ) {
        List<String> strings = new LinkedList<String>();
        strings.add( "1" );
        strings.add( "2" );
        strings.add( "3" );

        Processor p = new Processor();

        Collection<Integer> numbers = p.process( strings, new Transformer<String, Integer>() {
            @Override
            public Integer transform( String input ) {
                return Integer.parseInt( input );
            }
        } );
    }

Answer 2

I can't see how reflection could help here. You're trying to replace something as trivial as

public Collection<X> foo(Collection<Y> y) {
    List<X> result = Lists.newArrayList();
    for (Y e : y) result.add(foo(e));
    return result;
}

by something probably much slower. I don't think that saving those 3 lines (several times) is worth it, but you might want to try either annotation processing (possibly without using annotations) or dynamic code generation. In both cases you'd write the original class as is without the collection methods and use a different one containing both the scalar and the collection methods.

---

Or you might want to make it more functionally styled:

public class Foo {
    public final RichFunction<Y, X> foo = new RichFunction<Y, X>() {
        X apply(Y y) {
            return foo(y);
        }
    }

    // after some refactoring the original method can be made private
    // or inlined into the RichFunction
    public X foo(Y y){...}

    // instead of calling the original method like
    // foo.foo(y)
    // you'd use
    // foo.foo.apply(y)
    // which would work for both the scalar and collection methods
}

public abstract class RichFunction<K, V> extends com.google.common.base.Function<K, V> {
    Collection<V> apply(Collection<K> keys) {
        List<V> result = Lists.newArrayList();
        for (K k : keys) result.add(apply(k));
        return result;
    }
}

Answer 3

RUAKH - I chosed to implement your suggestion for reflection (although, admit, I don't like reflection). So, I did something like the code below THANKS :)

public class Resource {
    private static final int CLIENT_CODE_STACK_INDEX;
    static {
        // Finds out the index of "this code" in the returned stack trace - funny but it differs in JDK 1.5 and 1.6
        int i = 0;
        for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
            i++;
            if (ste.getClassName().equals(Resource.class.getName())) {
                break;
            }
        }
        CLIENT_CODE_STACK_INDEX = i;
    }
    public static String getCurrentMethodName() {
        return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX].getMethodName();
    }
    protected <IN,OUT> Collection<OUT> doMultiple(String methodName, Collection<IN> inCol, Class<?>... parameterTypes){
        Collection<OUT> result = new ArrayList<OUT>();
        try {
            Method m = this.getClass().getDeclaredMethod(methodName, parameterTypes);
            if (inCol==null || inCol.size()==0){
                return result;
            }
            for (IN in : inCol){
                Object o = m.invoke(this, in);
                result.add((OUT) o);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }
}

public class FirstResource extends Resource{
    public String doSomeThing(Integer i){
        // LOTS OF LOGIC
        return i.toString();
    }
    public Collection<String> doSomeThing(Collection<Integer> ints){
        return doMultiple(getCurrentMethodName(), ints, Integer.class);
    }
}

Answer 4

You should use Strategy pattern. By using Strategy pattern you can omit the usage if/else which makes the code more complex. Where strategy pattern creates less coupled code which is much simpler. By using Strategy pattern you can achieve more ways to configure code dynamically. So I would like to suggest you to use Strategy pattern.