apache camel

camel是一种的路由规则引擎，可以用来作为中间者连接不同的接口，其中的from表示读取源接口的数据，to表示向目的接口写数据，在from和to后面可以接processor，根据from和to的链式顺序，我们可以将from后面processor的叫前置处理器，to后面的processor叫后置处理器。

component

camel可以对接很多种生态，比如rest api，jdbc，rabbitmq等。camel和spring进行集成后，对于spring相关项目的开发很方便，只需要引入相关依赖。常用的组件direct，在编写路由配置时会时可以使用该组件，例如

@Component
public class SelfApiRoute extends RouteBuilder {
    @Value("${url}")
    private String url;

    @Override
    public void doConfigure() {
        from("direct:myInterface").process(new Processor(){}).to(url+"xxxx").process(new Processor(){});
    }
}

这里direct代表是中转节点，可以认为这里是一个接口的定义，在其他的模块可以通过productTemplate使用该接口，例如

@Autowired
private ProducerTemplate producerTemplate;

void function() {
    producerTemplate.requestBody("direct:myInterface", myObject , String.class);
}

ProducerTemplate是通过依赖

	<dependency>
			<groupId>org.apache.camel.springboot</groupId>
			<artifactId>camel-spring-boot-starter</artifactId>
			<version>${camel.version}</version>
		</dependency>

中的配置类CamelAutoConfiguration引入的

    	  /**
     * Default producer template for the bootstrapped Camel context.
     * Create the bean lazy as it should only be created if its in-use.
     */
    // We explicitly declare the destroyMethod to be "" as the Spring @Bean
    // annotation defaults to AbstractBeanDefinition.INFER_METHOD otherwise
    // and in that case Service::close (ProducerTemplate implements Service)
    // would be used for bean destruction. And we want Camel to handle the
    // lifecycle.
    @Bean(destroyMethod = "")
    @ConditionalOnMissingBean(ProducerTemplate.class)
    @Lazy
    ProducerTemplate producerTemplate(CamelContext camelContext,
                                      CamelConfigurationProperties config) throws Exception {
        final ProducerTemplate producerTemplate = camelContext.createProducerTemplate(config.getProducerTemplateCacheSize());
        // we add this producerTemplate as a Service to CamelContext so that it performs proper lifecycle (start and stop)
        camelContext.addService(producerTemplate);
        return producerTemplate;
    }

通过引入依赖后，就可以直接注入使用ProducerTemplate对象。从名称可以看出来这个组件是生产者，可以调用路由配置中定义的direct接口。
还有一个组件jdbc也较为常用，就是直接去查询数据库，比如我们可以中转一个接口后对参数进行处理，然后直接去查询另一个数据库返回结果，示例代码如下

   from("direct:countByName")
        .process(new Processor(){
            @Override
            public void process(Exchange exchange) throws Exception {
                Request request = exchange.getIn().getBody(Request.class);
                exchange.getIn().setHeader("name", request.getName());
            }
        })
        .setBody(constant("select count(1) from xx where user_name = :?name "))
        .to("jdbc:datasource?useHeadersAsParameters=true")
        .process(new Processor(){
            @Override
            public void process(Exchange exchange) throws Exception {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> dataList = exchange.getIn().getBody(List.class);
                List<String> urls = new ArrayList<>();
                for(Map<String, Object> map: dataList){
                    urls.add(String.valueOf(map.values()));
                }
                exchange.getMessage().setBody(urls);
            }
        });

from代表定义了一个中转接口，处理后将数据设置到body传给to，to这里采用jdbc组件，jdbc后面跟的是数据源的名称，数据源可以通过注入spring容器中，然后直接这个sql后，将结果处理再返回，返回结果是将结果设置到message的body中。
需要使用哪些组件就可以直接引入，比如rabbitmq就可以引入

<dependency>
	<groupId>org.apache.camel.springboot</groupId>
	<artifactId>camel-rabbitmq-starter</artifactId>
	<version>${camel.version}</version>
</dependency>

具体的使用可以参考github上面的camel example例子https://github.com/apache/camel-spring-boot-examples