Java CamelContextStartedEvent类代码示例

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
public void testSuspendResume() throws Exception {
    assertEquals(6, events.size());
    assertIsInstanceOf(CamelContextStartingEvent.class, events.get(0));
    assertIsInstanceOf(RouteAddedEvent.class, events.get(1));
    assertIsInstanceOf(RouteAddedEvent.class, events.get(2));
    assertIsInstanceOf(RouteStartedEvent.class, events.get(3));
    assertIsInstanceOf(RouteStartedEvent.class, events.get(4));
    assertIsInstanceOf(CamelContextStartedEvent.class, events.get(5));

    context.suspend();

    assertEquals(8, events.size());
    assertIsInstanceOf(CamelContextSuspendingEvent.class, events.get(6));
    // notice direct component is not suspended (as they are internal)
    assertIsInstanceOf(CamelContextSuspendedEvent.class, events.get(7));

    context.resume();

    assertEquals(10, events.size());
    assertIsInstanceOf(CamelContextResumingEvent.class, events.get(8));
    assertIsInstanceOf(CamelContextResumedEvent.class, events.get(9));
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
public void testStopWithFailure() throws Exception {
    stopOrder = "";

    context.stop();

    assertEquals("CBA", stopOrder);

    assertEquals(5, events.size());

    assertIsInstanceOf(CamelContextStartingEvent.class, events.get(0));
    assertIsInstanceOf(CamelContextStartedEvent.class, events.get(1));
    assertIsInstanceOf(CamelContextStoppingEvent.class, events.get(2));
    ServiceStopFailureEvent event = assertIsInstanceOf(ServiceStopFailureEvent.class, events.get(3));
    assertIsInstanceOf(CamelContextStoppedEvent.class, events.get(4));

    assertEquals("Fail B", event.getCause().getMessage());
    assertEquals("Failure to stop service: B due to Fail B", event.toString());
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
@Test
@InSequence(2)
public void sendMessageToDefaultCamelContextInbound(List<Class> events) throws InterruptedException {
    defaultOutbound.expectedMessageCount(1);
    defaultOutbound.expectedBodiesReceived("test-default");
    defaultOutbound.message(0).exchange().matches(fromCamelContext("camel-cdi"));

    defaultInbound.sendBody("test-default");

    assertIsSatisfied(2L, TimeUnit.SECONDS, defaultOutbound);

    assertThat("Events fired are incorrect", events,
        contains(
            CamelContextStartingEvent.class,
            CamelContextStartedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeCreatedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeSentEvent.class,
            ExchangeCompletedEvent.class,
            ExchangeSentEvent.class));
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
@Test
@InSequence(3)
public void sendMessageToFirstCamelContextInbound(@ContextName("first") List<Class> events) throws InterruptedException {
    firstOutbound.expectedMessageCount(1);
    firstOutbound.expectedBodiesReceived("test-first");
    firstOutbound.expectedHeaderReceived("context", "first");
    firstOutbound.message(0).exchange().matches(fromCamelContext("first"));

    firstInbound.sendBody("test-first");

    assertIsSatisfied(2L, TimeUnit.SECONDS, firstOutbound);

    assertThat("Events fired are incorrect", events,
        contains(
            CamelContextStartingEvent.class,
            CamelContextStartedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeCreatedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeSentEvent.class,
            ExchangeCompletedEvent.class,
            ExchangeSentEvent.class));
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
@Test
@InSequence(4)
public void sendMessageToSecondCamelContextInbound(@ContextName("second") List<Class> events) throws InterruptedException {
    secondOutbound.expectedMessageCount(1);
    secondOutbound.expectedBodiesReceived("test-second");
    secondOutbound.expectedHeaderReceived("context", "second");
    secondOutbound.message(0).exchange().matches(fromCamelContext("second"));

    secondInbound.sendBody("test-second");

    assertIsSatisfied(2L, TimeUnit.SECONDS, secondOutbound);

    assertThat("Events fired are incorrect", events,
        contains(
            CamelContextStartingEvent.class,
            CamelContextStartedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeCreatedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeSentEvent.class,
            ExchangeCompletedEvent.class,
            ExchangeSentEvent.class));
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
@Test
@InSequence(2)
public void sendMessageToInbound(List<Class> events) throws InterruptedException {
    outbound.expectedMessageCount(1);
    outbound.expectedBodiesReceived("test");

    inbound.sendBody("test");

    assertIsSatisfied(2L, TimeUnit.SECONDS, outbound);

    assertThat("Events fired are incorrect!", events,
        contains(
            CamelContextStartingEvent.class,
            CamelContextStartedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeCreatedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeSentEvent.class,
            ExchangeCompletedEvent.class,
            ExchangeSentEvent.class));
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
@Test
@InSequence(3)
public void stopCamelContext(CamelContext context, List<Class> events) throws Exception {
    context.stop();

    assertThat("Events fired are incorrect!", events,
        contains(
            CamelContextStartingEvent.class,
            CamelContextStartedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeCreatedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeSentEvent.class,
            ExchangeCompletedEvent.class,
            ExchangeSentEvent.class,
            CamelContextStoppingEvent.class,
            CamelContextStoppedEvent.class));
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
@Test
public void testEventBridge() throws Exception {
    EventManager eventManager = new EventManager();
    CountingObserver observer = new CountingObserver();
    eventManager.addObserver(observer, CamelContextStartedEvent.class);
    eventManager.addObserver(observer, CamelContextStoppedEvent.class);

    CamelEventBridge eventBridge = new CamelEventBridge(eventManager);
    DefaultCamelContext context = new DefaultCamelContext();
    context.getManagementStrategy().addEventNotifier(eventBridge);

    assertTrue(observer.counter == 0);
    context.start();
    assertTrue(observer.counter == 1);
    context.stop();
    assertTrue(observer.counter == 2);
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
/**
 * Remove all converters to {@link StAXSource}.
 *
 * @param event event about finished start of {@link CamelContext}
 * @throws Exception all errors
 */
@Override
public void notify(final EventObject event) throws Exception {
    if (event instanceof CamelContextStartedEvent) {
        CamelContext camelContext = ((CamelContextStartedEvent) event).getContext();

        if (camelContext.getTypeConverterRegistry().removeTypeConverter(StAXSource.class, byte[].class)) {
            Log.debug("Remove converter from '{}' to '{}'.", byte[].class.getSimpleName(),
                    StAXSource.class.getSimpleName());
        }
        if (camelContext.getTypeConverterRegistry().removeTypeConverter(StAXSource.class, File.class)) {
            Log.debug("Remove converter from '{}' to '{}'.", File.class.getSimpleName(),
                    StAXSource.class.getSimpleName());
        }
        if (camelContext.getTypeConverterRegistry().removeTypeConverter(StAXSource.class, InputStream.class)) {
            Log.debug("Remove converter from '{}' to '{}'.", InputStream.class.getSimpleName(),
                    StAXSource.class.getSimpleName());
        }
        if (camelContext.getTypeConverterRegistry().removeTypeConverter(StAXSource.class, String.class)) {
            Log.debug("Remove converter from '{}' to '{}'.", String.class.getSimpleName(),
                    StAXSource.class.getSimpleName());
        }
    }
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
@Test
@InSequence(2)
public void sendMessageToDefaultCamelContextInbound(@Named("defaultContext") List<Class> events) throws InterruptedException {
    defaultOutbound.expectedMessageCount(1);
    defaultOutbound.expectedBodiesReceived("test-default");
    defaultOutbound.message(0).exchange().matches(fromCamelContext("camel-cdi"));

    defaultInbound.sendBody("test-default");

    assertIsSatisfied(2L, TimeUnit.SECONDS, defaultOutbound);

    assertThat("Events fired are incorrect", events,
        contains(
            CamelContextStartingEvent.class,
            CamelContextStartedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeCreatedEvent.class,
            ExchangeSendingEvent.class,
            ExchangeSentEvent.class,
            ExchangeCompletedEvent.class,
            ExchangeSentEvent.class));
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
void hello(@Observes CamelContextStartedEvent event,
           // Configuration properties can be injected with @ConfigProperty
           @ConfigProperty(name = "message") String message,
           // Property placeholders in @Uri qualifier are also resolved
           @Uri("{{destination}}") ProducerTemplate producer) {
    producer.sendBody(message);
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
public void testExchangeDone() throws Exception {
    getMockEndpoint("mock:result").expectedMessageCount(1);

    template.sendBody("direct:start", "Hello World");

    assertMockEndpointsSatisfied();

    assertEquals(14, events.size());
    assertIsInstanceOf(CamelContextStartingEvent.class, events.get(0));
    assertIsInstanceOf(RouteAddedEvent.class, events.get(1));
    assertIsInstanceOf(RouteAddedEvent.class, events.get(2));
    assertIsInstanceOf(RouteStartedEvent.class, events.get(3));
    assertIsInstanceOf(RouteStartedEvent.class, events.get(4));
    assertIsInstanceOf(CamelContextStartedEvent.class, events.get(5));
    assertIsInstanceOf(ExchangeCreatedEvent.class, events.get(7));
    assertIsInstanceOf(ExchangeSentEvent.class, events.get(9));
    assertIsInstanceOf(ExchangeSentEvent.class, events.get(11));
    assertIsInstanceOf(ExchangeCompletedEvent.class, events.get(12));

    // this is the sent using the produce template to start the test
    assertIsInstanceOf(ExchangeSentEvent.class, events.get(13));

    context.stop();

    assertEquals(20, events.size());
    assertIsInstanceOf(CamelContextStoppingEvent.class, events.get(14));
    assertIsInstanceOf(RouteStoppedEvent.class, events.get(15));
    assertIsInstanceOf(RouteRemovedEvent.class, events.get(16));
    assertIsInstanceOf(RouteStoppedEvent.class, events.get(17));
    assertIsInstanceOf(RouteRemovedEvent.class, events.get(18));
    assertIsInstanceOf(CamelContextStoppedEvent.class, events.get(19));
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
public void testExchangeFailed() throws Exception {
    try {
        template.sendBody("direct:fail", "Hello World");
        fail("Should have thrown an exception");
    } catch (Exception e) {
        // expected
        assertIsInstanceOf(IllegalArgumentException.class, e.getCause());
    }

    assertEquals(10, events.size());
    assertIsInstanceOf(CamelContextStartingEvent.class, events.get(0));
    assertIsInstanceOf(RouteAddedEvent.class, events.get(1));
    assertIsInstanceOf(RouteAddedEvent.class, events.get(2));
    assertIsInstanceOf(RouteStartedEvent.class, events.get(3));
    assertIsInstanceOf(RouteStartedEvent.class, events.get(4));
    assertIsInstanceOf(CamelContextStartedEvent.class, events.get(5));
    assertIsInstanceOf(ExchangeSendingEvent.class, events.get(6));
    assertIsInstanceOf(ExchangeCreatedEvent.class, events.get(7));
    assertIsInstanceOf(ExchangeFailedEvent.class, events.get(8));
    // this is the sent using the produce template to start the test
    assertIsInstanceOf(ExchangeSentEvent.class, events.get(9));

    context.stop();

    assertEquals(16, events.size());
    assertIsInstanceOf(CamelContextStoppingEvent.class, events.get(10));
    assertIsInstanceOf(RouteStoppedEvent.class, events.get(11));
    assertIsInstanceOf(RouteRemovedEvent.class, events.get(12));
    assertIsInstanceOf(RouteStoppedEvent.class, events.get(13));
    assertIsInstanceOf(RouteRemovedEvent.class, events.get(14));
    assertIsInstanceOf(CamelContextStoppedEvent.class, events.get(15));
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
public void testExchangeFailed() throws Exception {
    try {
        template.sendBody("direct:fail", "Hello World");
        fail("Should have thrown an exception");
    } catch (Exception e) {
        // expected
        assertIsInstanceOf(IllegalArgumentException.class, e.getCause());
    }

    assertEquals(10, events.size());
    assertIsInstanceOf(CamelContextStartingEvent.class, events.get(0));
    assertIsInstanceOf(RouteAddedEvent.class, events.get(1));
    assertIsInstanceOf(RouteAddedEvent.class, events.get(2));
    assertIsInstanceOf(RouteStartedEvent.class, events.get(3));
    assertIsInstanceOf(RouteStartedEvent.class, events.get(4));
    assertIsInstanceOf(CamelContextStartedEvent.class, events.get(5));
    assertIsInstanceOf(ExchangeSendingEvent.class, events.get(6));
    assertIsInstanceOf(ExchangeCreatedEvent.class, events.get(7));
    assertIsInstanceOf(ExchangeFailedEvent.class, events.get(8));
    assertIsInstanceOf(ExchangeSentEvent.class, events.get(9));

    assertEquals(4, events2.size());

    context.stop();
    assertIsInstanceOf(ExchangeSendingEvent.class, events2.get(0));
    assertIsInstanceOf(ExchangeCreatedEvent.class, events2.get(1));
    assertIsInstanceOf(ExchangeFailedEvent.class, events2.get(2));
    assertIsInstanceOf(ExchangeSentEvent.class, events2.get(3));

    assertEquals(16, events.size());
    assertIsInstanceOf(CamelContextStoppingEvent.class, events.get(10));
    assertIsInstanceOf(RouteStoppedEvent.class, events.get(11));
    assertIsInstanceOf(RouteRemovedEvent.class, events.get(12));
    assertIsInstanceOf(RouteStoppedEvent.class, events.get(13));
    assertIsInstanceOf(RouteRemovedEvent.class, events.get(14));
    assertIsInstanceOf(CamelContextStoppedEvent.class, events.get(15));

    assertEquals(4, events2.size());
}
 

import org.apache.camel.management.event.CamelContextStartedEvent; //导入依赖的package包/类
@Test
public void camelStartedEvent(@Uri("mock:started") MockEndpoint started) {
    assertThat("Event fired is incorrect!", started.getExchanges(),
        contains(
            hasProperty("in",
                hasProperty("body", instanceOf(CamelContextStartedEvent.class)))));
}