Apache Camel中的開關盒

Question

在Apache Camel（Java DSL）中是否存在類似於Java開關盒的構造？

例如：

from(incomingRoute) 
    .choice() 
    .when(simple("${body.getType} == '" + TYPE.A.name() + "'")) 
       .to(A_Endpoint) 
    .when(simple("${body.getType} == '" + TYPE.B.name() + "'")) 
       .to(B_Endpoint) 
    .when(simple("${body.getType} == '" + TYPE.C.name() + "'")) 
       .to(C_Endpoint) 
    .otherwise() 
       .to(errorEndpoint); 

可以翻譯成別的東西更類似於切換？我的意思是我不想使用簡單謂詞，只是body元素類型的值。 或者我的方法完全錯誤？ （可能合理）

Answer 1

在Java DSL中，簡單表達式與choice（）子句一起使用來實現if-else條件。請參見下面的文檔：

http://camel.apache.org/simple.html

http://camel.apache.org/content-based-router.html

Answer 2

我一般喜歡使用Java 8個Lambda表達式在特定的情景：

public void configure() throws Exception { 
    from(incomingRoute) 
    .choice() 
    .when(bodyTypeIs(TYPE.A)) 
       .to(A_Endpoint) 
    .when(bodyTypeIs( TYPE.B)) 
       .to(B_Endpoint) 
    .when(bodyTypeIs( TYPE.C)) 
       .to(C_Endpoint) 
    .otherwise() 
       .to(errorEndpoint); 
} 

private Predicate bodyTypeIs(TYPE type) { 
    return e -> e.getIn().getBody(BodyType.class).getType() == type; 
} 

此外，使用駱駝Predicate s的Java的8允許一些真棒流利的API大樓，如添加您自己的功能類型Predicate：

@FunctionalInterface 
public interface ComposablePredicate extends Predicate, java.util.function.Predicate<Exchange> { 

    @Override 
    default boolean matches(Exchange exchange) { 
    return test(exchange); 
    } 

    @Override 
    default ComposablePredicate and(java.util.function.Predicate<? super Exchange> other) { 
    Objects.requireNonNull(other); 
    return (t) -> test(t) && other.test(t); 
    } 

    @Override 
    default ComposablePredicate negate() { 
    return (t) -> !test(t); 
    } 

    @Override 
    default ComposablePredicate or(java.util.function.Predicate<? super Exchange> other) { 
    Objects.requireNonNull(other); 
    return (t) -> test(t) || other.test(t); 
    } 
} 

，它允許你寫這樣的東西：

public void configure() throws Exception { 
    from(incomingRoute) 
    .choice() 
    .when(bodyTypeIs(TYPE.A) .or (bodyTypeIs(TYPE.A1))) 
       .to(A_Endpoint) 
    .when(bodyTypeIs( TYPE.B).negate()) 
       .to(NOT_B_Endpoint) 
    .when(bodyTypeIs( TYPE.C) .and (bodyNameIs("name"))) 
       .to(C_Endpoint) 
    .otherwise() 
       .to(errorEndpoint); 
} 

private ComposablePredicate bodyTypeIs(TYPE type) { 
    return e -> bodyFrom(e).getType() == type; 
} 

private BodyType bodyFrom(Exchange e) { 
    return e.getIn().getBody(BodyType.class); 
} 

private ComposablePredicate bodyNameIs(String name) { 
    return e -> bodyFrom(e).getName().equals(name); 
}