Apache Camel - 24 - Controlling Start-up and Shutdown of Routes（动态控制路由的启动和关闭）

最新推荐文章于 2024-08-06 03:46:46 发布
最新推荐文章于 2024-08-06 03:46:46 发布
阅读量2.1k 收藏 4
点赞数 1
分类专栏： Apache Camel Apache Camel 使用教程 文章标签： Apache Camel 动态控制路由
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Simba_cheng/article/details/83893140
版权

我把所有学习Apache Camel找的PDF都上传了，需要的同学自取：

《Mastering Apache Camel》

《Red_Hat_Fuse-7.0-Apache_Camel_Development_Guide-en-US》

《Apache Camel Developer's Cookbook》

 

目录

前言

动态控制Apache Camel路由的注意点

1. 设置路由ID

2.禁止自动启动

动态控制Apache Camel路由

本篇文章对应的完整项目源码地址：14-ApacheCamel-DynamicControlRoutes

Apache Camel 系列完整项目代码地址：ApacheCamelDemo

如果觉得不错，麻烦点个Star

 

前言

之前一篇文章《Apache Camel - 22 - Controlling route startup and shutdown(Camel控制路由的启动/关闭顺序)》，了解了如何控制路由的启动和关闭顺序。

下面了解下如何动态控制路由的启动与关闭。

 

 

动态控制Apache Camel路由的注意点

在了解动态控制 Apache Camel 路由之前，首先要了解两个细节，这有助于更好地使用、管理路由。

1. 设置路由ID

通过路由ID，可以动态的控制路由启动与关闭。

有助于在日志中更快的查找问题。

如果应用程序庞大，可以将路由ID，注册至ZooKeeper或其他管理平台，以此更好地管理

使用方式:

Java DSL:
        from("xxx").routeId("xxxID").process(...).to(...);
XML DSL:
	<camelContext id="CamelContextID" xmlns="http://camel.apache.org/schema/spring">
		<route id="xxxID">
			<from uri="xxx"/>
			<process ref="..."/>
			<to uri="..."/>
		</route>
	</camelContext>

 

2.禁止自动启动

一般情况，将路由添加到CamelContext中之后，随着camelContext的启动，它会自动启动路由。

既然咱们想动态控制，那就先将其设置为'禁止自动启动'

使用方式:

Java DSL:
	from("xxx").routeId("xxxID").autoStartup(false).to(...);
XML DSL:
	<camelContext id="CamelContextID" xmlns="http://camel.apache.org/schema/spring">
		<route id="xxxID" autoStartup="false">
			<from uri="..."/>
			<to uri="..."/>
		</route>
	</camelContext>

 

 

动态控制Apache Camel路由

我们可以通过CamelContext对象中的startRoute（）和stopRoute（）方法控制路由的启动和停止。

看下关键代码：

DynamicControlRoutesMainApp

package com.server;

import com.server.conf.LogBackConfigLoader;
import com.server.routes.master.MasterHttpRoute;
import com.server.routes.slave.SlaveHttpRoute;
import org.apache.camel.CamelContext;
import org.apache.camel.impl.DefaultCamelContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 动态控制路由
 *
 * @author CYX
 */
public class DynamicControlRoutesMainApp {

    private static final Logger LOGGER = LoggerFactory.getLogger(DynamicControlRoutesMainApp.class);

    private static final String LOGBACK_FILENAME = "./conf/logback.xml";

    public static CamelContext camelContext;

    public static void main(String[] args) {

        // 初始化参数、异常直接kill程序
        try {
            LogBackConfigLoader.loadLogBack(LOGBACK_FILENAME);
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }

        LOGGER.info("===== 准备启动 CamelContext =====");

        try {
            // 创建CamelContext上下文
            camelContext = new DefaultCamelContext();
            camelContext.start();

            // 将MasterHttpRoute路由加入CamelContext中
            camelContext.addRoutes(new MasterHttpRoute());

            // 将SlaveHttpRoute路由加入CamelContext中
            // 其中'test-route-control-03'禁止自动启动，由Master路由进行控制
            camelContext.addRoutes(new SlaveHttpRoute());

            // 保证主线程不退出
            synchronized (DynamicControlRoutesMainApp.class) {
                DynamicControlRoutesMainApp.class.wait();
            }

        } catch (Exception e) {
            LOGGER.error("error : {} , errorMessage : {}", new Object[]{e, e.getMessage()});
        }
    }
}

SlaveHttpRoute

package com.server.routes.slave;

import org.apache.camel.*;
import org.apache.camel.builder.RouteBuilder;
import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.InputStream;

/**
 * Slave工作路由-Http
 *
 * @author CYX
 * @date 2018/11/7 14:03
 */
public class SlaveHttpRoute extends RouteBuilder {

    private static final Logger LOGGER = LoggerFactory.getLogger(SlaveHttpRoute.class);

    @Override
    public void configure() throws Exception {

        /**
         * 第一个路由（普通写法，不增加任何配置）
         */
        from("jetty:http://127.0.0.1:8282/test-route-control").process(new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {

                InputStream inputStream = exchange.getIn().getBody(InputStream.class);
                String bodyStr = IOUtils.toString(inputStream, "UTF-8");

                LOGGER.info("bodyStr : {}", new Object[]{bodyStr});
                inputStream.close();

                // 存入到exchange的out区域
                if (exchange.getPattern() == ExchangePattern.InOut) {
                    Message outMessage = exchange.getOut();
                    outMessage.setBody("消息收到" + "-已处理-slave-01");
                }
            }
        });

        /**
         * 第二个路由（设置route id）
         */
        from("jetty:http://127.0.0.1:8282/test-route-contro2").routeId("test-route-control-02").process(new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {

                InputStream inputStream = exchange.getIn().getBody(InputStream.class);
                String bodyStr = IOUtils.toString(inputStream, "UTF-8");

                LOGGER.info("bodyStr : {}", new Object[]{bodyStr});
                inputStream.close();

                // 存入到exchange的out区域
                if (exchange.getPattern() == ExchangePattern.InOut) {
                    Message outMessage = exchange.getOut();
                    outMessage.setBody("消息收到" + "-已处理-slave-02");
                }
            }
        });

        /**
         * 第三个路由（设置route id、设置禁止自动启动）
         */
        from("jetty:http://127.0.0.1:8282/test-route-contro3").routeId("test-route-control-03").autoStartup(false).process(new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {

                InputStream inputStream = exchange.getIn().getBody(InputStream.class);
                String bodyStr = IOUtils.toString(inputStream, "UTF-8");

                LOGGER.info("bodyStr : {}", new Object[]{bodyStr});
                inputStream.close();

                // 存入到exchange的out区域
                if (exchange.getPattern() == ExchangePattern.InOut) {
                    Message outMessage = exchange.getOut();
                    outMessage.setBody("消息收到" + "-已处理-slave-03");
                }
            }
        });
    }

}

Slave路由中，创建了三个路由，第一个路由没有什么特别的，第二个路由我们手动设置了路由ID。

第三个路由除了路由ID外，嗨设置了autoStartup(false)，这个是禁止路由自动启动，由Master路由对它进行控制

 

MasterHttpRoute

package com.server.routes.master;

import com.server.DynamicControlRoutesMainApp;
import com.server.dto.PersonDTO;
import com.server.util.CommonUtils;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.ExchangePattern;
import org.apache.camel.Message;
import org.apache.camel.Processor;
import org.apache.camel.builder.RouteBuilder;
import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.InputStream;

/**
 * master路由-用来控制Slave路由的启动和停止
 *
 * @author CYX
 * @date 2018/11/7 15:26
 */
public class MasterHttpRoute extends RouteBuilder {

    private static final Logger LOGGER = LoggerFactory.getLogger(MasterHttpRoute.class);

    private CamelContext camelContext = DynamicControlRoutesMainApp.camelContext;

    @Override
    public void configure() throws Exception {

        /**
         * master路由
         * 该路由控制slave中的其他路由
         */
        from("jetty:http://127.0.0.1:8282/masterRoute").routeId("masterRoute").process(new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {

                InputStream bodyStream = exchange.getIn().getBody(InputStream.class);
                String bodyStr = IOUtils.toString(bodyStream, "UTF-8");

                LOGGER.info("bodyStr : {}", new Object[]{bodyStr});

                PersonDTO personDTO = CommonUtils.toJavaObject(bodyStr, PersonDTO.class);

                if ("0".equals(personDTO.getSlaveFlag())) {

                    //停止'test-route-control-03'路由

                    camelContext.stopRoute("test-route-control-03");
                    LOGGER.info("===== 停止 routeID:test-route-control-03 =====");

                } else if ("1".equals(personDTO.getSlaveFlag())) {

                    //启动'test-route-control-03'路由

                    camelContext.startRoute("test-route-control-03");
                    LOGGER.info("===== 启动 routeID:test-route-control-03 =====");

                } else if ("2".equals(personDTO.getSlaveFlag())) {

                    //暂停'test-route-control-03'路由

                    camelContext.suspendRoute("test-route-control-03");
                    LOGGER.info("===== 暂停 routeID:test-route-control-03 =====");

                    //设置暂停时间
                    //camelContext.suspendRoute("",3600, TimeUnit.SECONDS);
                }

                if (exchange.getPattern() == ExchangePattern.InOut) {
                    Message outMessage = exchange.getOut();
                    outMessage.setBody("消息收到" + "-已处理-00");
                }
            }
        });

    }

}

Master路由，camelContext成员变量，指向DynamicControlRoutesMainApp.camelContext。

Master路由，单独发布一个Master Http服务，通过调用这个http服务，来控制slave路由的开启、停止、暂停。

 

启动程序，查看控制台的日志。

一共四条路由信息。

第一条：Master路由，自己设定的路由ID

第二条：Slave普通路由，未设置任何参数，路由ID是系统给定的。

第三条：Slave普通路由，自己设定路由ID

第四条：Slave路由，自己设定路由ID，并且设定禁止自动启动，由Master控制。

 

调用测试方法：startRoute()，服务端接收到信息，解析后，启动 ID为'test-route-control-03'的路由

 

接着调用testOtherRoutes()方法，测试 ID为'test-route-control-03'的路由，是否能够成功调用。

没问题，该路由成功调用。

 

暂停路由

 

停止路由

 

ok，完结...

本篇文章对应的完整项目源码地址：14-ApacheCamel-DynamicControlRoutes

Apache Camel 系列完整项目代码地址：ApacheCamelDemo

如果觉得不错，麻烦点个Star

Simba_cheng
关注
专栏目录
ApacheCamel快速入门（中）
02-25
接上文EndpointDirect用于在两个编排好的路由间实现Exchange消息的连接，上一个路由中由最后一个元素处理完的Exchange对象，将被发送至由Direct连接的下一个路由起始位置（http://camel.apache.org/direct.html）。注意，两个被连接的路由一定要是可用的，并且存在于同一个Camel服务中。以下的例子说明了EndpointDirect的简单使用方式。以上代码片段中，我们编排了两个可用的路由（尽管两个路由都很简单，但确实是两个独立的路由）命名为DirectRouteA和DirectRouteB。其中DirectRouteA实例在最后一个Endpo
ApacheCamel-JDBC
02-07
Apache Camel 是一个流行的开源集成框架，它允许开发者以声明式的方式定义路由和转换数据，使得在不同的软件组件之间实现通信变得更加简单。JDBC（Java Database Connectivity）是Java平台中的一个标准API，用于与...
apache camel 相关配置_动态路由Apache Camel
weixin_32701893的博客
01-15 705
Is there some solution to create a camel route dynamically, in time execution? In a common way, we explicitly define a camel route as:from("direct:a").to("direct:b");However, I want to create some rou...
Apache Camel：开源集成框架的领航者
最新发布
gitblog_00018的博客
08-06 964
Apache Camel：开源集成框架的领航者 camelApache Camel is an open source integration framework that empowers you to quickly and easily integrate various systems consuming or producing data.项目地址:https://gitcode.co...
Apache Camel添加动态路由
走马行酒醴，驱车布鱼肉
10-08 6647
方法一： 定义RoutBuilder的方法 public static void fun1(String[] args) throws Exception { ModelCamelContext context = new DefaultCamelContext(); context.start(); RouteBuilder route = new RouteBuilde
Camel 动态启停路由
weixin_41368339的博客
04-28 3072
        Camel动态启停路由的实现思路。首先将路由定义class存入表中，作为基础数据使用。当tomcat启动完成后，我们启动一个定时任务，让他读取表中所有需要启动的路由，然后利用反射技术动态生成路由实例，将该实例注册到camelContext中。到此tomcat的启动全部完成，我们启用的路由也全部加载了。         第二步，提供一个全部路由的展示页面，在该页面中提供路由的启动和停...
Apache Camel 路由
chenbj123的博客
10-12 1257
Apache Camel 路由
05-ApacheCamel-CXF-WebService
02-02
Apache Camel 是一个强大的开源企业集成库，它提供了一种模型化的路由和消息转换方式，使得开发者可以轻松地在各种系统间构建复杂的集成解决方案。CXF 是一个流行的开放源代码服务框架，它支持多种Web服务标准，如...
camel-spring-boot-examples：Apache Camel Spring引导示例
01-30
Apache Camel 是一个强大的集成框架，它允许开发者轻松地在各种企业级应用集成中创建和维护路由规则。Spring Boot 是一个流行的 Java 框架，它简化了 Spring 应用的初始化和配置。当两者结合，我们可以创建易于管理...
01-ApacheCamel-HelloWorld
01-31
Apache Camel 是一个强大的开源集成框架，它允许开发者在各种组件之间路由、转换和处理消息，以构建企业级的集成解决方案。在这个"01-ApacheCamel-HelloWorld"示例中，我们将深入理解如何使用 Camel 实现一个简单的 ...
ApacheCamel-FTP
02-05
Apache Camel 是一个流行的开源集成框架，它允许开发者在不同的系统、协议和服务之间建立灵活的数据通信。FTP（File Transfer Protocol）是互联网上广泛使用的文件传输协议，用于上传、下载和管理远程服务器上的文件...
Apache Camel源码研究之启动
夫礼者的专栏
11-27 2133
Apache Camel作为一个实现了大部分EIP的集成组件，发展至今已经拥有了三百多个扩展组件，如何管理这些组件的生命周期，以及如何在合适的时机调用它们的自定义逻辑势必是一个非常具有挑战的任务，而Camel的启动属于这个挑战性任务中非常重要的一环。
Apache Camel简介
最佳 Java 编程
05-17 1354
Apache Camel是著名的企业集成模式的开源实现。 Camel是一个路由和中介引擎，可以帮助开发人员以各种领域特定语言（DSL）（例如Java，Spring / XML，scala等）创建路由和中介规则。 骆驼用途广泛 Camel使用URI来支持大量的传输和消息传递模型，例如HTTP，JMS，JBI，Mina，SCA，CXF，它还与外部组件和数据格式很好地兼容。 要了解Camel的...
camel动态加载route
萌级小菜鸟的博客
06-20 4710
camel的路由规则加载默认使用xml或java方法来创建，但这2个方法不能够动态加载路由，查看camel的源码发现，可以通过路由规则字符串来动态的加载。 假设需要加载的路由如下 <routes xmlns="http://camel.apache.org/schema/spring"> <route id="node-1"> <from...
camel动态设置路由执行
萌级小菜鸟的博客
01-26 3914
camel 动态路由跳转
apache-camel 快速入门
hhhxxx1230的博客
05-04 1405
## camel套路 1. 构建`CamelContext` 1. 使用`DSL`构建`RouteBuilder`对象, 并将该对象添加到`CamelContext`中 1. `CamelContext`会使用`RouteBuilder`构建`Route`对象 1. 调用`camel.start()`方法启动`CamelContext` 1. 一旦`CamelContext`监测到符合`Route`中`from`规则的消息, 就好执行路由.
apache camel_Apache Camel入门
最佳 Java 编程
06-05 320
apache camel 在先前的博文中，我们了解了企业集成模式（EIP）。 现在，在这篇文章中，我们将研究实现这些模式的Apache Camel框架。 关于骆驼： Apache Camel是一个开放源代码项目，已有将近5年的历史，并且拥有大量的用户社区。 该框架的核心是一个引擎，它负责中介工作并将消息从一个系统路由到另一个系统。 在外围，它具有大量组件，可以与使用各种协议（例如FTP，R...
【Apache Camel】基础知识
又言又语
03-06 2012
通常应用程序中只有一个 CamelContext，但也可以同时存在多个 CamelContext，但多个 CamelContext 之间彼此需要隔离，如果要在多个 CamelContext 之间通信，则需要加入一个传输层（如消息队列）。Message 接口提供了单个消息的抽象表示，如请求消息、回复消息、异常消息。Routes 用于连接源 Endpoints 和目标 Endpoints，Routes 描述了消息从源 Endpoints 到目标 Endpoints 的移动过程。
Apache Camel入门
xinyuan的专栏
01-06 2298
什么是Camel？ Camel框架的核心是一个路由引擎，或者更确切地说是一个路由引擎构建器。它允许您定义自己的路由规则，决定从哪个源接收消息，并确定如何处理这些消息并将其发送到其他目标。 Camel提供更高层次的抽象，使您可以使用相同的API与各种系统进行交互，而不管系统使用的协议或数据类型如何。 Camel中的组件提供了针对不同协议和数据类型的API的特定实现。开箱即用，Camel支持80多...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值