如何在线程主线程中保持阿帕奇骆驼上下文的活动

Question

我正在尝试制作简单的应用程序，该应用程序将侦听来自Artemis的一个队列，然后继续消息，然后在第二个队列中创建新消息。

我已经在方法主駪驼上下文中创建并添加了路由(它将消息转发到 bean(。为了测试此路由以及此 bean 是否正常工作，我正在发送 发送到此队列的消息很少 - 在主线程中启动上下文后

public static void main(String args[]) throws Exception {
CamelContext context = new DefaultCamelContext();
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616", "admin", "admin");
context.addComponent("cmp/q2", JmsComponent.jmsComponentAutoAcknowledge(connectionFactory));
context.addRoutes(new RouteBuilder() {
public void configure() {
from("cmp/q2:cmp/q2").bean(DataRequestor.class, "doSmth(${body}, ${headers})");
}
});
ProducerTemplate template = context.createProducerTemplate();
context.start();
for (int i = 0; i < 2; i++) {
HashMap<String, Object> headers = new HashMap<String, Object>();
headers.put("header1", "some header info");
template.sendBodyAndHeaders("cmp/q2:cmp/q2", "Test Message: " + i, headers);
}
context.stop();
}

在这种情况下，应用程序工作正常，但是当方法main完成时它会停止 - 它只处理由它自己创建的消息。 现在，在我有了用于路由的测试豆之后，我想修改应用程序，使其应该启动并保持活动状态(保持驼峰上下文和路由处于活动状态( - 以便我可以在 Web UI 中手动创建按摩(活动 mq 管理控制台(。

但我真的不知道怎么做。 我已经尝试过用 Thread.sleep(5000( 无限循环; 我尝试在 main 方法中再启动一个线程(也带有无限循环(。 但它没有用。(在无限循环的情况下，对我来说最可疑的是 apllication 正在运行，但是当我在 web UI 中创建消息时，它只是消失了 - 并且系统中没有任何痕迹表明它是由我的 bean 在路由中处理的，假设它应该由我的 bean 处理或只是留在队列中原封不动， 但它只是消失了(。

我现在的问题很愚蠢，但我已经浪费了 3 天来寻找解决方案，因此任何建议或教程链接或一些有价值的信息都值得赞赏。

PS：我有一个痛苦的限制 - 不允许使用Spring框架。

Answer 1

我认为运行独立骆驼的最简单解决方案是从骆驼主开始。骆驼在线文档也有一个使用它的示例 http://camel.apache.org/running-camel-standalone-and-have-it-keep-running.html。 我将在此处复制粘贴示例代码以防万一：

public class MainExample {
private Main main;
public static void main(String[] args) throws Exception {
MainExample example = new MainExample();
example.boot();
}
public void boot() throws Exception {
// create a Main instance
main = new Main();
// bind MyBean into the registry
main.bind("foo", new MyBean());
// add routes
main.addRouteBuilder(new MyRouteBuilder());
// add event listener
main.addMainListener(new Events());
// set the properties from a file
main.setPropertyPlaceholderLocations("example.properties");
// run until you terminate the JVM
System.out.println("Starting Camel. Use ctrl + c to terminate the JVM.n");
main.run();
}
private static class MyRouteBuilder extends RouteBuilder {
@Override
public void configure() throws Exception {
from("timer:foo?delay={{millisecs}}")
.process(new Processor() {
public void process(Exchange exchange) throws Exception {
System.out.println("Invoked timer at " + new Date());
}
})
.bean("foo");
}
}
public static class MyBean {
public void callMe() {
System.out.println("MyBean.callMe method has been called");
}
}
public static class Events extends MainListenerSupport {
@Override
public void afterStart(MainSupport main) {
System.out.println("MainExample with Camel is now started!");
}
@Override
public void beforeStop(MainSupport main) {
System.out.println("MainExample with Camel is now being stopped!");
}
}
}

路由会一直执行，直到您点击 Ctlr+c 或以其他方式停止它...... 如果对此进行测试，请注意类路径中需要 example.properties 文件，其属性为millisecs。

Answer 2

至少需要一个主线程来启动线程来运行骆驼路由，然后检查该线程何时完成。简单的 java 线程方法使用主循环来检查 .wait((，并使用骆驼路由线程的结束来在完成(或关闭(时发出 .notify(( 信号，这将完成工作。

从那里你可以查看执行器服务或使用像Apache Karaf这样的微容器

。PS. 无弹簧的道具！

Answer 3

免责声明：这是用 Kotlin 编写的，但移植到 java 有点微不足道

免责声明：这是为Apache-Camel2.24.2编写

的免责声明：我也在学习阿帕奇-骆驼。文档对我来说有点重

我尝试了Main路线来设置它，但它很快就变得有点复杂。我知道这是一个 java 线程，但我使用的是 kotlin ATM，我将保留大多数类型和导入可用，以便 java 开发人员更容易。

类侦听器

我首先要争取的是了解Main的生命周期。事实证明，您可以实现一个接口来添加此类事件的实现。通过这样的实现，我可以连接任何必须确保camel已经开始的例程(无需猜测(。

import org.apache.camel.CamelContext
import org.apache.camel.main.MainListener
import org.apache.camel.main.MainSupport
typealias Action = () -> Unit
class Listener : MainListener {
private var afterStart: Action? = null
fun registerOnStart(action:Action) {
afterStart = action
}
override fun configure(context: CamelContext) {}
override fun afterStop(main: MainSupport?) {}
override fun afterStart(main: MainSupport?) {
println("started!")
afterStarted?.invoke().also { println("Launched the registered function") }
?: println("Nothing registered to start")
}
override fun beforeStop(main: MainSupport?) {}
override fun beforeStart(main: MainSupport?) {}
}

类应用核心

然后我设置了context的配置(路由、组件等,...(

import org.apache.camel.CamelContext
import org.apache.camel.impl.DefaultCamelContext
import org.apache.camel.impl.SimpleRegistry
import org.apache.camel.main.Main
class ApplicationCore : Runnable {
private val main = Main()
private val registry = SimpleRegistry()
private val context = DefaultCamelContext(registry)
private val listener = Listener() // defined above
// for Java devs: this is more or less a constructor block
init {
main.camelContexts.clear()
listener.registerOnStart({ whateverYouAreDoing().start() })// <- your stuff should run in its own thread because main will be blocked
main.camelContexts.add(context)
main.duration = -1
context.addComponent("artemis", ...)// <- you need to implement your own
context.addRoutes(...)// <- you already know how to do this
...// <- anything else you could need to initialize
main.addMainListener(listener)
}
fun run() {
/* ... add whatever else you need ... */
// The next line blocks the thread until you close it
main.run()
}
fun whateverYouAreDoing(): Thread {
return Thread() {
ProducerTemplate template = context.createProducerTemplate();
for (i in 0..1) {
val headers = HashMap<String, Any>()
headers["header1"] = "some header info"
template.sendBodyAndHeaders("cmp/q2:cmp/q2", "Test Message: $i", headers)
}
context.stop()// <- this is not good practice here but its what you seem to want
}
}
}

在kotlin中，初始化相当容易。您可以轻松地将其转换为java，因为它非常简单

// top level declaration
fun main(vararg args:List<String>) = { ApplicationCore().run() }