Java Generics: kết hợp cùng nhau đối tượng hàm chung

Đây là cách để thực hiện. Phương thức chạy không an toàn, nhưng với cách duy nhất để nối thêm một đường ống là làm theo cách an toàn, toàn bộ chuỗi là an toàn kiểu.

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

Nguồn

2011-12-30 16:48:12

thực sự mát mẻ, và giống như tất cả các giải pháp tốt, nó rõ ràng một khi nó được biết đến :) – downer

Cảm ơn câu trả lời của bạn :) Tôi tạo ra một [github project] (https://github.com/smartorigin/Dynamic-Workflow) dựa trên trả lời thêm chức năng không đồng bộ và thực thi song song. Hy vọng nó sẽ giúp ai đó. –

Đây là một cách khác để thực hiện: cách này cho phép bước chuyển đổi kết quả trong danh sách. Ví dụ, một phép biến đổi có thể tách một chuỗi thành nhiều phần tử. Hơn nữa, nó cho phép mã xử lý ngoại lệ phổ biến nếu việc chuyển đổi bất kỳ giá trị nào tạo ra một ngoại lệ. Nó cũng cho phép sử dụng một danh sách rỗng như một giá trị trả về thay vì một giá trị null không rõ ràng mà phải được kiểm tra để tránh NullPointerException. Vấn đề chính với vấn đề này là mỗi bước chuyển đổi hoàn toàn trước khi chuyển sang bước tiếp theo, điều này có thể không hiệu quả về bộ nhớ.

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

Nguồn

2014-04-08 17:18:40 Shannon

Rõ ràng, nếu bạn có thể sử dụng Java 8, thì bạn sẽ muốn sử dụng Luồng thay thế. Hoặc, giống như RxJava. – Shannon

Java Generics: kết hợp cùng nhau đối tượng hàm chung

Trả lời

Các vấn đề liên quan