1

私たちのコードには複数のプロセッサがあり、それぞれに複数の API メソッドがあり、各メソッドはコレクションを受け入れることができる同じメソッドでもオーバーロードされています。
例えば：

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
}

当然、コレクションに対するこれらのメソッドは、実際には反復の重複コードです。
私たちが探しているのは、何らかのパターンを作成したり、ジェネリックを使用したりするための一種の方法であるため、コレクションの反復は一度実装されます。これには、何らかの方法でメソッド名を渡す方法も必要です。

4

4 に答える 4

1

Startegyパターンをお勧めします。そして、次のようなことを行います。

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;
    }
}

例：

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 );
            }
        } );
    }
于 2012-10-10T13:35:11.727 に答える
0

RUAKH-私はあなたの反省の提案を実行することを選びました（しかし、認めます、私は反省が好きではありません）。だから、私は以下のコードのようなことをしましたありがとう:)

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);
    }
}
于 2012-10-10T16:03:39.470 に答える
0

戦略パターンを使用する必要があります。ストラテジー パターンを使用すると、コードをより複雑にする if/else の使用を省略できます。戦略パターンは、より単純な結合の少ないコードを作成します。ストラテジー パターンを使用することで、コードを動的に構成するためのより多くの方法を実現できます。そのため、ストラテジー パターンを使用することをお勧めします。

于 2014-06-12T09:01:55.343 に答える
0

ここでリフレクションがどのように役立つかわかりません。あなたは些細なことを置き換えようとしています

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

おそらくもっと遅い何かによって。この 3 行 (数回) を保存する価値はないと思いますが、注釈処理 (おそらく注釈を使用しない) または動的コード生成のいずれかを試してみてください。どちらの場合も、元のクラスをコレクション メソッドなしでそのまま記述し、スカラー メソッドとコレクション メソッドの両方を含む別のクラスを使用します。

または、より機能的なスタイルにしたいかもしれません:

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;
    }
}
于 2012-10-10T15:28:39.623 に答える