Camel框架的快速认识和使用

Camel框架的快速认识和使用

 

Camel流程框架是Apache下的一个开源项目，是较为成熟的流程框架。在web项目中也可以无缝地集成于Spring当中。

 

一、简单使用

 

引入camel相关的jar包：camel-core-2.10.4.jar。

1、经典的入门示例——文件移动

 

1. public class FileMoveWithCamel {

2. public static void main(String[] args) {

3. try{

4. CamelContext camelCtx = new DefaultCamelContext();

5. camelCtx.addRoutes(new RouteBuilder() {

6.  

7. //此示例中，只能转移文件，而无法转移目录

8. @Override

9. public void configure() throws Exception {

10. from("file:f:/tmp/inbox?delay=30000").to("file:f:/tmp/outbox");

11. }

12.  

13. });

14.  

15. camelCtx.start();

16. boolean loop = true;

17. while(loop) {

18. Thread.sleep(25000);

19. }

20. System.out.println("循环完毕");

21. camelCtx.stop();

22. } catch(Exception ex) {

23. ex.printStackTrace();

24. }

25. }

 其中file:类似于http://，是camel的协议组件。camel支持的组件还包括：bean browse dataset direct file log mock properties seda test timer stub validator vm xlst等。其中常用的有bean和direct以及file

运行上述程序，会发现file:f:/tmp/inbox下的文件被转移到file:f:/tmp/outbox了，并且在file:f:/tmp/inbox会生成一个.camel文件夹存放刚才被转移的文件。

 

2、入门示例二——带Processor处理

先定义一个处理器，实现org.apache.camel.Processor接口

1. public class FileConvertProcessor implements Processor {

2.  

3. @Override

4. public void process(Exchange exchange) throws Exception {

5. // Object obj = exchange.getIn().getBody(); //如果是getBody()则返回一个Object

6. //如果是getBody(Class<T>)则返回T类型的实例

7. InputStream body = exchange.getIn().getBody(InputStream.class);

8. // System.out.println("进入:" + body);

9. BufferedReader br = new BufferedReader(new InputStreamReader(body, "UTF-8"));

10.  

11. StringBuilder sb = new StringBuilder("");

12. String str;

13. while((str = br.readLine()) != null) {

14. System.out.println(str);

15. sb.append(str + " ");

16. }

17. exchange.getOut().setHeader(Exchange.FILE_NAME, "converted.txt");

18.  

19. exchange.getOut().setBody(sb.toString());

20. System.out.println("body:" + exchange.getOut().getBody());

21.  

22. }

 

加上处理器后处理文件的程序

1. public class FileProcessWithCamel {

2. public static void main(String[] args) {

3. try{

4. CamelContext camelCtx = new DefaultCamelContext();

5. camelCtx.addRoutes(new RouteBuilder() {

6.  

7. @Override

8. public void configure() throws Exception {

9. FileConvertProcessor processor = new FileConvertProcessor();

10. //noop表示等待、无操作

11. from("file:f:/tmp/inbox?noop=true").process(processor).to("file:f:/tmp/outbox");

12. }

13. });

14.  

15. camelCtx.start();

16. boolean loop = true;

17. //死循环表示挂起camel上下文，以便持续监听

18. while(loop) {

19. Thread.sleep(25000);

20. }

21. camelCtx.stop();

22. } catch(Exception ex) {

23. ex.printStackTrace();}

24. }

25. }

 运行程序后将用一行打印file:f:/tmp/inbox下的文件的多行内容，并在file:f:/tmp/outbox下生成名为converted.txt的文件。该文件的内容即为file:f:/tmp/inbox下的文件的多行内容显示成的一行。

 

这里要特别注意getIn（setIn）,getOut（setOut）怎么用：先看下面一张图

 这张图表明了：假设有流程A->B->C->D->……则A在处理完毕之后给B的话，A必须setOut结果，然后B要取流程中的“上一个”节点（即A）的结果则必须getIn取结果再处理，以此类推……A不能setIn结果，否则B getIn的话会取不到A set的结果。

 

二、集成在Spring当中

 需引入camel-core-2.10.4.jar camel-spring-2.10.4.jar

 

对已第一部分的第一示例，若在Spring中配置，并设置它随着web项目的启动而启动，则可以这样写：

 

[xml] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:drools="http://drools.org/schema/drools-spring"  
4.     xmlns:camel="http://camel.apache.org/schema/spring"  
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
6. http://drools.org/schema/drools-spring http://anonsvn.jboss.org/repos/labs/labs/jbossrules/trunk/drools-container/drools-spring/src/main/resources/org/drools/container/spring/drools-spring-1.0.0.xsd  
7. http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">  
8.       
9.     <bean id="fileConverter" class="com.xxxx.FileConvertProcessor" />  
10.       
11.     <camelContext id="camel" autoStartup="true" xmlns="http://camel.apache.org/schema/spring">       
12.         <route>    
13.             <from uri="file:f:/tmp/inbox?delay=30000"/>    
14.             <process ref="fileConverter"/>    
15.             <to uri="file:f:/tmp/outbox"/>   
16.         </route>   
17.     </camelContext>  
18. </beans>  

 

除此之外，其实更为常见的是一个处理流程往往需要经过很多个bean类。而查看camel direct组件的用法：

In the route below we use the direct component to link the two routes together:

可知bean与bean之间的流程连接用的是direct，这里不妨用fileConverter和fileConverter2两个Processor测试（它们的具体定义省略，都得实现Processor接口），于是：

 

[xml] view plain copy

1.        <bean id="fileConverter" class="com.xxx.FileConvertProcessor" />  
2. <bean id="fileConverter2" class="com.xxx.FileConvertProcessor2" />  
3.   
4. <camelContext id="camel" autoStartup="true" xmlns="http://camel.apache.org/schema/spring">  
5.      <template id="producerTemplate" />  
6.     <threadPool id="pool" threadName="Thread-dataformat"  
7.         poolSize="50" maxPoolSize="200" maxQueueSize="250" rejectedPolicy="CallerRuns" />  
8. <route>    
9.            <from uri="file:f:/tmp/inbox?delay=30000"/>    
10.            <process ref="fileConverter"/>    
11.            <to uri="file:f:/tmp/outbox"/>   
12.            <to uri="direct://start"/>     
13.        </route>   
14.          
15.         <route>   
16.         <from uri="direct://start"/>    
17.             <threads executorServiceRef="pool">  
18.         <process ref="fileConverter"/>   
19.         <to uri="bean://fileConverter2"/>    
20.             </threads>   
21.        </route>  
22. </camelContext>  

 注意到上面第二个路由<route  />中to的配置被放在一个线程池当中了，这也是比较常见的用法。这里表明流程经过fileConverter处理，流向fileConverter2继续处理。

 

另外，我们常常需要根据某一条件判断流程的“下一步”应该走向哪里，这时候就要用到类似el表达式的if else判断了。再定义一个fileConverter3，表明根据条件选择——流程在经过fileConverter时，根据配置条件选择“下一步”流向fileConverter2还是fileConverter3（fileConverter2和fileConverter3定义省略，它们都得实现Processor接口）

 

 

[xml] view plain copy

1. <bean id="fileConverter" class="com.xxxx.FileConvertProcessor" />  
2.     <bean id="fileConverter2" class="com.xxx.FileConvertProcessor2" />  
3.     <bean id="fileConverter3" class="com.xxx.FileConvertProcessor3" />  
4.       
5. <camelContext id="camel" autoStartup="true" xmlns="http://camel.apache.org/schema/spring">  
6.          <template id="producerTemplate" />  
7.         <threadPool id="pool" threadName="Thread-dataformat"  
8.             poolSize="50" maxPoolSize="200" maxQueueSize="250" rejectedPolicy="CallerRuns" />  
9.     <route>    
10.             <from uri="file:f:/tmp/inbox?delay=30000"/>    
11.             <process ref="fileConverter"/>    
12.             <to uri="file:f:/tmp/outbox"/>   
13.             <to uri="direct://start"/>     
14.         </route>   
15.           
16.          <route>   
17.             <from uri="direct://start"/>    
18.             <threads executorServiceRef="pool">  
19.                 <choice>  
20.                     <when>  
21.                         <simple>${body.length} > 40</simple>  
22.                         <process ref="fileConverter"/>   
23.                         <to uri="bean://fileConverter2"/>    
24.                     </when>  
25.                     <otherwise>  
26.                      <process ref="fileConverter"/>   
27.                      <to uri="bean://fileConverter3"/>  
28.                     </otherwise>  
29.                 </choice>  
30.             </threads>   
31.         </route>  
32. </camelContext>  

 <choice />和<otherwise />即表示选择分支，而<when />下的<simple />标签则用来放判断条件，写法和el表达式的条件判断很类似。

注意Camel流程的开始时，应该在Java代码中用ProducerTemplate.sendBody("direct://xxx",data)开始流程的源头。ProducerTemplate是从配置文件的bean获取(<template id="producerTemplate" />)的，然后ProducerTemplate.start()启动Camel流程。然后在配置文件中通过<from uri="direct://xxx"/>开始接收流程传过来的data数据