Java Generics: łączenie razem obiektu funkcji ogólnej

Oto sposób na zrobienie tego. Metoda run nie jest bezpieczna dla typów, ale biorąc pod uwagę, że jedynym sposobem dołączenia rury jest wykonanie jej w bezpieczny sposób, cały łańcuch jest bezpieczny dla typu.

public class Chain<S, T> { 
    private List<Pipe<?, ?>> pipes; 

    private Chain() { 
    } 

    public static <K, L> Chain<K, L> start(Pipe<K, L> pipe) { 
     Chain<K, L> chain = new Chain<K, L>(); 
     chain.pipes = Collections.<Pipe<?, ?>>singletonList(pipe);; 
     return chain; 
    } 

    public <V> Chain<S, V> append(Pipe<T, V> pipe) { 
     Chain<S, V> chain = new Chain<S, V>(); 
     chain.pipes = new ArrayList<Pipe<?, ?>>(pipes); 
     chain.pipes.add(pipe); 
     return chain; 
    } 

    @SuppressWarnings({ "rawtypes", "unchecked" }) 
    public T run(S s) { 
     Object source = s; 
     Object target = null; 
     for (Pipe p : pipes) { 
      target = p.transform(source); 
      source = target; 
     } 
     return (T) target; 
    } 

    public static void main(String[] args) { 
     Pipe<String, Integer> pipe1 = new Pipe<String, Integer>() { 
      @Override 
      public Integer transform(String s) { 
       return Integer.valueOf(s); 
      } 
     }; 
     Pipe<Integer, Long> pipe2 = new Pipe<Integer, Long>() { 
      @Override 
      public Long transform(Integer s) { 
       return s.longValue(); 
      } 
     }; 
     Pipe<Long, BigInteger> pipe3 = new Pipe<Long, BigInteger>() { 
      @Override 
      public BigInteger transform(Long s) { 
       return new BigInteger(s.toString()); 
      } 
     }; 
     Chain<String, BigInteger> chain = Chain.start(pipe1).append(pipe2).append(pipe3); 
     BigInteger result = chain.run("12"); 
     System.out.println(result); 
    } 
}

Źródło

2011-12-30 16:48:12

Naprawdę fajnie, i jak wszystkie dobre rozwiązania, to jest oczywiste, gdy już jest znana :) – downer

Dziękuję za odpowiedź :) Tworzę projekt [github project] (https://github.com/smartorigin/Dynamic-Workflow) na podstawie Twojego odpowiedź, która dodaje funkcjonalność asynchroniczną i wykonywanie równoległe. Mam nadzieję, że to komuś pomogłoby. –

Oto inny sposób, aby to zrobić: w ten sposób pozwala na krok transformacji, aby uzyskać listę. Na przykład transformacja może podzielić łańcuch na wiele podłańcuchów. Co więcej, pozwala na wspólny kod obsługi wyjątków, jeśli transformacja dowolnej wartości powoduje wyjątek. Umożliwia także użycie pustej listy jako wartości zwracanej zamiast niejednoznacznej wartości pustej, która musi zostać przetestowana, aby uniknąć wyjątku NullPointerException. Głównym problemem z tym jest to, że robi każdy krok transformacji w całości przed przejściem do następnego kroku, który może nie być efektywny pod względem pamięci.

public class Chain<IN, MEDIAL, OUT> { 
    private final Chain<IN, ?, MEDIAL> head; 
    private final Transformer<MEDIAL, OUT> tail; 

    public static <I, O> Chain<I, I, O> makeHead(@Nonnull Transformer<I, O> tail) { 
     return new Chain<>(null, tail); 
    } 

    public static <I, M, O> Chain<I, M, O> append(@Nonnull Chain<I, ?, M> head, @Nonnull Transformer<M, O> tail) { 
     return new Chain<>(head, tail); 
    } 

    private Chain(@Nullable Chain<IN, ?, MEDIAL> head, @Nonnull Transformer<MEDIAL, OUT> tail) { 
     this.head = head; 
     this.tail = tail; 
    } 

    public List<OUT> run(List<IN> input) { 
     List<OUT> allResults = new ArrayList<>(); 

     List<MEDIAL> headResult; 
     if (head == null) { 
      headResult = (List<MEDIAL>) input; 
     } else { 
      headResult = head.run(input); 
     } 

     for (MEDIAL in : headResult) { 
      // try/catch here 
      allResults.addAll(tail.transform(in)); 
     } 

     return allResults; 
    } 

    public static void main(String[] args) { 

     Transformer<String, Integer> pipe1 = new Transformer<String, Integer>() { 
      @Override 
      public List<Integer> transform(String s) { 
       return Collections.singletonList(Integer.valueOf(s) * 3); 
      } 
     }; 
     Transformer<Integer, Long> pipe2 = new Transformer<Integer, Long>() { 
      @Override 
      public List<Long> transform(Integer s) { 
       return Collections.singletonList(s.longValue() * 5); 
      } 
     }; 
     Transformer<Long, BigInteger> pipe3 = new Transformer<Long, BigInteger>() { 
      @Override 
      public List<BigInteger> transform(Long s) { 
       return Collections.singletonList(new BigInteger(String.valueOf(s * 7))); 
      } 
     }; 
     Chain<String, ?, Integer> chain1 = Chain.makeHead(pipe1); 
     Chain<String, Integer, Long> chain2 = Chain.append(chain1, pipe2); 
     Chain<String, Long, BigInteger> chain3 = Chain.append(chain2, pipe3); 
     List<BigInteger> result = chain3.run(Collections.singletonList("1")); 
     System.out.println(result); 
    } 
}

Źródło

2014-04-08 17:18:40 Shannon

Oczywiście, jeśli jesteś w stanie używać Java 8, zamiast tego chcesz użyć strumienia. Lub coś w stylu RxJava. – Shannon

Java Generics: łączenie razem obiektu funkcji ogólnej

Odpowiedz

Powiązane problemy