import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    camelContext = new DefaultCamelContext();
    SimpleRegistry registry = new SimpleRegistry();
    Map<String, Object> params = new HashMap<String, Object>();
    params.put("custName", "Willem");
    // bind the params
    registry.put("params", params);
    camelContext.setRegistry(registry);
    
    template = camelContext.createProducerTemplate();
    ServiceHelper.startServices(template, camelContext);

    Endpoint value = camelContext.getEndpoint(getEndpointUri());
    assertNotNull("Could not find endpoint!", value);
    assertTrue("Should be a JPA endpoint but was: " + value, value instanceof JpaEndpoint);
    endpoint = (JpaEndpoint)value;

    transactionTemplate = endpoint.createTransactionTemplate();
    entityManager = endpoint.createEntityManager();
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
    // create the registry to be the SimpleRegistry which is just a Map based implementation
    SimpleRegistry registry = new SimpleRegistry();
    // register our HelloBean under the name helloBean
    registry.put("helloBean", new HelloBean());

    // tell Camel to use our SimpleRegistry
    context = new DefaultCamelContext(registry);

    // create a producer template to use for testing
    template = context.createProducerTemplate();

    // add the route using an inlined RouteBuilder
    context.addRoutes(new RouteBuilder() {
        public void configure() throws Exception {
            from("direct:hello").bean("helloBean", "hello");
        }
    });
    // star Camel
    context.start();
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
/** Prepares Db and data source, which must be added to Camel registry. */
@BeforeClass
public static void setup() throws Exception {
    DeleteDbFiles.execute("~", "jbpm-db-test", true);

    h2Server = Server.createTcpServer(new String[0]);
    h2Server.start();

    setupDb();

    DataSource ds = setupDataSource();

    SimpleRegistry simpleRegistry = new SimpleRegistry();
    simpleRegistry.put("myDs", ds);

    handler = new CamelHandler(new SQLURIMapper(), new RequestPayloadMapper("payload"), new ResponsePayloadMapper("queryResult"), new DefaultCamelContext(simpleRegistry));
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Override
protected CamelContext createCamelContext() throws Exception {
    SimpleRegistry registry = new SimpleRegistry();
    ActiveMQConnectionFactory connectionFactory =
        new ActiveMQConnectionFactory("vm://embedded?broker.persistent=false");
    registry.put("connectionFactory", connectionFactory);

    JmsTransactionManager jmsTransactionManager = new JmsTransactionManager();
    jmsTransactionManager.setConnectionFactory(connectionFactory);
    registry.put("jmsTransactionManager", jmsTransactionManager);

    SpringTransactionPolicy propagationRequired = new SpringTransactionPolicy();
    propagationRequired.setTransactionManager(jmsTransactionManager);
    propagationRequired.setPropagationBehaviorName("PROPAGATION_REQUIRED");
    registry.put("PROPAGATION_REQUIRED", propagationRequired);

    SpringTransactionPolicy propagationNotSupported = new SpringTransactionPolicy();
    propagationNotSupported.setTransactionManager(jmsTransactionManager);
    propagationNotSupported.setPropagationBehaviorName("PROPAGATION_NOT_SUPPORTED");
    registry.put("PROPAGATION_NOT_SUPPORTED", propagationNotSupported);

    CamelContext camelContext = new DefaultCamelContext(registry);

    ActiveMQComponent activeMQComponent = new ActiveMQComponent();
    activeMQComponent.setConnectionFactory(connectionFactory);
    activeMQComponent.setTransactionManager(jmsTransactionManager);
    camelContext.addComponent("jms", activeMQComponent);

    return camelContext;
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@SuppressWarnings("Convert2streamapi")
private void unregisterExecutorComponent(Executor... executors) {
	for (Executor executor : executors) {
		//unregister beans
		Registry registry = context.getRegistry();
		if (registry instanceof PropertyPlaceholderDelegateRegistry) {
			registry = ((PropertyPlaceholderDelegateRegistry) registry).getRegistry();
		}
		SimpleRegistry openexRegistry = (SimpleRegistry) registry;
		Set<Map.Entry<String, Object>> beansEntries = executor.beans().entrySet();
		for (Map.Entry<String, Object> beansEntry : beansEntries) {
			if (openexRegistry.containsKey(beansEntry.getKey())) {
				openexRegistry.remove(beansEntry.getKey());
			}
		}
		//unregister components
		Set<String> keys = executor.components().keySet();
		for (String key : keys) {
			if (context.getComponentNames().contains(key)) {
				context.removeComponent(key);
			}
		}
	}
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@SuppressWarnings("Convert2streamapi")
private void registerExecutorComponent(Executor... executors) {
	for (Executor executor : executors) {
		//register beans
		Registry registry = context.getRegistry();
		if (registry instanceof PropertyPlaceholderDelegateRegistry) {
			registry = ((PropertyPlaceholderDelegateRegistry) registry).getRegistry();
		}
		SimpleRegistry openexRegistry = (SimpleRegistry) registry;
		Set<Map.Entry<String, Object>> beansEntries = executor.beans().entrySet();
		for (Map.Entry<String, Object> beansEntry : beansEntries) {
			if (!openexRegistry.containsKey(beansEntry.getKey())) {
				openexRegistry.put(beansEntry.getKey(), beansEntry.getValue());
			}
		}
		//register components
		Set<Map.Entry<String, org.apache.camel.Component>> components = executor.components().entrySet();
		for (Map.Entry<String, org.apache.camel.Component> entry : components) {
			if (!context.getComponentNames().contains(entry.getKey())) {
				context.addComponent(entry.getKey(), entry.getValue());
			}
		}
	}
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
public void testLoadRegistry() throws Exception {
    SimpleRegistry registry = new SimpleRegistry();
    registry.put("myBean", "This is a log4j logging configuation file");

    CamelContext context = new DefaultCamelContext(registry);
    context.start();

    InputStream is = ResourceHelper.resolveMandatoryResourceAsInputStream(context, "ref:myBean");
    assertNotNull(is);

    String text = context.getTypeConverter().convertTo(String.class, is);
    assertNotNull(text);
    assertTrue(text.contains("log4j"));
    is.close();

    context.stop();
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
public void testErrorListener() throws Exception {
    try {
        SimpleRegistry registry = new SimpleRegistry();
        registry.put("myListener", listener);

        RouteBuilder builder = createRouteBuilder();
        CamelContext context = new DefaultCamelContext(registry);
        context.addRoutes(builder);
        context.start();

        fail("Should have thrown an exception due XSLT file not found");
    } catch (FailedToCreateRouteException e) {
        // expected
    }

    assertFalse(listener.isWarning());
    assertTrue("My error listener should been invoked", listener.isError());
    assertTrue("My error listener should been invoked", listener.isFatalError());
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Override
protected CamelContext createCamelContext() throws Exception {

    final PropertiesComponent pc = new PropertiesComponent("classpath:org/apache/camel/component/properties/myproperties.properties");
    pc.setPropertiesResolver(new PropertiesResolver() {
        public Properties resolveProperties(CamelContext context, boolean ignoreMissingLocation, String... uri) throws Exception {
            resolvedCount++;
            return new DefaultPropertiesResolver(pc).resolveProperties(context, ignoreMissingLocation, uri);
        }
    });

    // put the properties component into the registry so that it survives restarts
    SimpleRegistry registry = new SimpleRegistry();
    registry.put("properties", pc);

    return new DefaultCamelContext(registry);
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Test(expected = FailedToCreateRouteException.class)
public void shouldFailWhenThereIsNoJobLauncher() throws Exception {
    // Given
    SimpleRegistry registry = new SimpleRegistry();
    registry.put("mockJob", job);
    CamelContext camelContext = new DefaultCamelContext(registry);
    camelContext.addRoutes(new RouteBuilder() {
        @Override
        public void configure() throws Exception {
            from("direct:start").to("spring-batch:mockJob");
        }
    });

    // When
    camelContext.start();
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Test(expected = FailedToCreateRouteException.class)
public void shouldFailWhenThereIsMoreThanOneJobLauncher() throws Exception {
    // Given
    SimpleRegistry registry = new SimpleRegistry();
    registry.put("mockJob", job);
    registry.put("launcher1", jobLauncher);
    registry.put("launcher2", jobLauncher);
    CamelContext camelContext = new DefaultCamelContext(registry);
    camelContext.addRoutes(new RouteBuilder() {
        @Override
        public void configure() throws Exception {
            from("direct:start").to("spring-batch:mockJob");
        }
    });

    // When
    camelContext.start();
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Test
public void shouldResolveAnyJobLauncher() throws Exception {
    // Given
    SimpleRegistry registry = new SimpleRegistry();
    registry.put("mockJob", job);
    registry.put("someRandomName", jobLauncher);
    CamelContext camelContext = new DefaultCamelContext(registry);
    camelContext.addRoutes(new RouteBuilder() {
        @Override
        public void configure() throws Exception {
            from("direct:start").to("spring-batch:mockJob");
        }
    });

    // When
    camelContext.start();

    // Then
    SpringBatchEndpoint batchEndpoint = camelContext.getEndpoint("spring-batch:mockJob", SpringBatchEndpoint.class);
    JobLauncher batchEndpointJobLauncher = (JobLauncher) FieldUtils.readField(batchEndpoint, "jobLauncher", true);
    assertSame(jobLauncher, batchEndpointJobLauncher);
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Override
public CamelContext createCamelContext() throws Exception {
    SimpleRegistry registry = new SimpleRegistry();
    registry.put("testStrategy", new ListAggregationStrategy());
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(broker.getTcpConnectorUri());

    SjmsComponent sjmsComponent = new SjmsComponent();
    sjmsComponent.setConnectionFactory(connectionFactory);

    SjmsBatchComponent sjmsBatchComponent = new SjmsBatchComponent();
    sjmsBatchComponent.setConnectionFactory(connectionFactory);

    CamelContext context = new DefaultCamelContext(registry);
    context.addComponent("sjms", sjmsComponent);
    context.addComponent("sjms-batch", sjmsBatchComponent);
    return context;
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Override
protected CamelContext createCamelContext() throws Exception {
    SimpleRegistry registry = new SimpleRegistry();
    registry.put("aggStrategy", AggregationStrategies.groupedExchange());

    ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
    connectionFactory.setBrokerURL(broker.getTcpConnectorUri());

    SjmsComponent sjmsComponent = new SjmsComponent();
    sjmsComponent.setConnectionFactory(connectionFactory);

    SjmsBatchComponent sjmsBatchComponent = new SjmsBatchComponent();
    sjmsBatchComponent.setConnectionFactory(connectionFactory);

    CamelContext context = new DefaultCamelContext(registry);
    context.addComponent("sjms-batch", sjmsBatchComponent);
    context.addComponent("sjms", sjmsComponent);

    return context;
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Test
public void invalidConfiguration() throws Exception {
    // Given
    SimpleRegistry registry = new SimpleRegistry();
    registry.put("eventBus", new EventBus());
    CamelContext context = new DefaultCamelContext(registry);
    context.addRoutes(new RouteBuilder() {
        @Override
        public void configure() throws Exception {
            from("guava-eventbus:eventBus?listenerInterface=org.apache.camel.component.guava.eventbus.CustomListener&eventClass=org.apache.camel.component.guava.eventbus.MessageWrapper").
                    to("mock:customListenerEvents");
        }
    });

    try {
        context.start();
        fail("Should throw exception");
    } catch (FailedToCreateRouteException e) {
        IllegalStateException ise = assertIsInstanceOf(IllegalStateException.class, e.getCause());
        assertEquals("You cannot set both 'eventClass' and 'listenerInterface' parameters.", ise.getMessage());
    }
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
protected void createContextWithGivenRoute(RouteBuilder route, int timeWork) throws Exception, InterruptedException {
    SimpleRegistry registry = new SimpleRegistry();
    ModelCamelContext context = new DefaultCamelContext(registry);
    Tracer tracer = new Tracer();
    tracer.setLogName("MyTracerLog");
    tracer.getDefaultTraceFormatter().setShowProperties(false);
    tracer.getDefaultTraceFormatter().setShowHeaders(false);
    tracer.getDefaultTraceFormatter().setShowBody(true);
    context.addInterceptStrategy(tracer);
    context.addRoutes(route);
    context.addComponent("activeMq", activeMq);

    this.camelContext = context;
    this.ct = context.createConsumerTemplate();
    this.pt = context.createProducerTemplate();

    context.start();
    context.setTracing(false);
    Thread.sleep(timeWork);
    context.stop();
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
public void testSendA19() throws Exception {

        SimpleRegistry registry = new SimpleRegistry();
        HL7MLLPCodec codec = new HL7MLLPCodec();
        codec.setCharset("iso-8859-1");
        codec.setConvertLFtoCR(true);

        registry.put("hl7codec", codec);
        CamelContext camelContext = new DefaultCamelContext(registry);
        camelContext.start();
        ProducerTemplate template = camelContext.createProducerTemplate();
        String line1 = "MSH|^~\\&|MYSENDER|MYRECEIVER|MYAPPLICATION||200612211200||QRY^A19|1234|P|2.4";
        String line2 = "QRD|200612211200|R|I|GetPatient|||1^RD|0101701234|DEM||";

        StringBuilder in = new StringBuilder();
        in.append(line1);
        in.append("\r");
        in.append(line2);

        template.requestBody("mina2:tcp://127.0.0.1:" + MINA2_PORT + "?sync=true&codec=#hl7codec", in.toString());
        
        template.stop();
        camelContext.stop();
    }
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Override
public void init(ServiceDomain domain) {
    if (_logger.isDebugEnabled()) {
        _logger.debug("Initialization of CamelExchangeBus for domain " + domain.getName());
    }

    SimpleRegistry registry = _camelContext.getWritebleRegistry();
    for (Processors processor : Processors.values()) {
        registry.put(processor.name(), processor.create(domain));
    }

    // CAMEL-7728 introduces an issue on finding BeanManager due to the fact that default
    // applicationContextClassLoader in the CamelContext is not a bundle deployment class loader.
    // We need to ensure the applicationContextClassLoader is the bundle deployment class loader
    // for now. This will be unnecessary once CAMEL-7759 is merged.
    _camelContext.setApplicationContextClassLoader(Thread.currentThread().getContextClassLoader());
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
    // create the registry to be the SimpleRegistry which is just a Map based implementation
    SimpleRegistry registry = new SimpleRegistry();
    // register our HelloBean under the name helloBean
    registry.put("helloBean", new HelloBean());

    // tell Camel to use our SimpleRegistry
    context = new DefaultCamelContext(registry);

    // create a producer template to use for testing
    template = context.createProducerTemplate();

    // add the route using an inlined RouteBuilder
    context.addRoutes(new RouteBuilder() {
        public void configure() throws Exception {
            from("direct:hello").beanRef("helloBean");
        }
    });
    // star Camel
    context.start();
}
 

import org.apache.camel.impl.SimpleRegistry; //导入依赖的package包/类
@Inject
JdbiExample(ReceiveCommandsAsJsonRoute receiveCommandsRoute,
			JdbiConsumeCommandsRoute consumeCommandsRoute, 
			JdbiConsumeEventsRoute consumeEventsRoute) throws Exception  {
	
	main = new Main() ;
	main.enableHangupSupport();
	registry = new SimpleRegistry();
	context = new DefaultCamelContext(registry);

	context.addRoutes(receiveCommandsRoute);
	context.addRoutes(consumeCommandsRoute);
	context.addRoutes(consumeEventsRoute);
	
	main.getCamelContexts().clear();
	main.getCamelContexts().add(context);
	main.setDuration(-1);
	main.start();
	
	
}