org.apache.camel.spi.Registry Java Examples

@Override
public void configure() throws Exception {
    final CryptoDataFormat crypto = new CryptoDataFormat("DES", null);

    from("direct:encrypt")
        .process(new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                Registry registry = exchange.getContext().getRegistry();
                Message in = exchange.getIn();
                Key key = registry.lookupByNameAndType("shared_" + in.getHeader("system"), Key.class);
                in.setHeader(CryptoDataFormat.KEY, key);
            }
        })
        .log("Encrypting message: ${body} using ${header[CamelCryptoKey]}")
        .marshal(crypto)
        .log("Message encrypted: ${body}")
        .to("direct:decrypt");

    from("direct:decrypt")
        .log("Decrypting message: ${body} using ${header[CamelCryptoKey]}")
        .unmarshal(crypto)
        .log("Message decrypted: ${body}")
        .to("mock:decrypted");
}
 

public JsonSimplePredicate(final String expression, final CamelContext context) {
    final Language language = ObjectHelper.notNull(context.resolveLanguage("simple"), "simple language");
    final String ognlExpression = convertSimpleToOGNLForMaps(expression);

    predicate = language.createPredicate(expression);
    ognlPredicate = language.createPredicate(ognlExpression);

    final Registry registry = context.getRegistry();
    final Set<ObjectMapper> mappers = registry.findByType(ObjectMapper.class);

    if (mappers.size() != 1) {
        mapper = MAPPER;
    } else {
        mapper = mappers.iterator().next();
    }
}
 

public void insertOrder(InputOrder order, Registry registry) {
    DataSource ds = registry.lookupByNameAndType("myDataSource", DataSource.class);
    JdbcTemplate jdbc = new JdbcTemplate(ds);

    Object[] args = new Object[] { order.getCustomerId(), order.getRefNo(), order.getPartId(), order.getAmount()};
    jdbc.update("insert into riders_order (customer_id, ref_no, part_id, amount) values (?, ?, ?, ?)", args);
}
 

public void insertOrder(InputOrder order, Registry registry) {
    DataSource ds = registry.lookupByNameAndType("myDataSource", DataSource.class);
    JdbcTemplate jdbc = new JdbcTemplate(ds);

    Object[] args = new Object[] { order.getCustomerId(), order.getRefNo(), order.getPartId(), order.getAmount()};
    jdbc.update("insert into riders_order (customer_id, ref_no, part_id, amount) values (?, ?, ?, ?)", args);
}
 

public RuntimeValue<CamelContext> createContext(
        RuntimeValue<Registry> registry,
        RuntimeValue<TypeConverterRegistry> typeConverterRegistry,
        RuntimeValue<ModelJAXBContextFactory> contextFactory,
        RuntimeValue<XMLRoutesDefinitionLoader> xmlLoader,
        RuntimeValue<ModelToXMLDumper> xmlModelDumper,
        RuntimeValue<FactoryFinderResolver> factoryFinderResolver,
        BeanContainer beanContainer,
        String version,
        CamelConfig config) {

    FastCamelContext context = new FastCamelContext(
            factoryFinderResolver.getValue(),
            version,
            xmlLoader.getValue(),
            xmlModelDumper.getValue());

    context.setDefaultExtension(RuntimeCamelCatalog.class, () -> new CamelRuntimeCatalog(config.runtimeCatalog));
    context.setRegistry(registry.getValue());
    context.setTypeConverterRegistry(typeConverterRegistry.getValue());
    context.setLoadTypeConverters(false);
    context.setModelJAXBContextFactory(contextFactory.getValue());
    context.build();
    context.addLifecycleStrategy(new CamelLifecycleEventBridge());
    context.getManagementStrategy().addEventNotifier(new CamelManagementEventBridge());

    // register to the container
    beanContainer.instance(CamelProducers.class).setContext(context);

    return new RuntimeValue<>(context);
}
 

public void bind(
        RuntimeValue<Registry> runtime,
        String name,
        Class<?> type,
        Object instance) {

    runtime.getValue().bind(name, type, instance);
}
 

public void bind(
        RuntimeValue<Registry> runtime,
        String name,
        Class<?> type,
        RuntimeValue<?> instance) {

    runtime.getValue().bind(name, type, instance.getValue());
}
 

public void bind(
        RuntimeValue<Registry> runtime,
        String name,
        Class<?> type) {

    try {
        runtime.getValue().bind(name, type, type.newInstance());
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

@Path("/checks/failing/{enabled}")
@GET
public void toggleFailingHealthCheck(@PathParam("enabled") boolean enabled) {
    Registry registry = camelContext.getRegistry();
    FailingHealthCheck failingHealthCheck = registry.lookupByNameAndType(FailingHealthCheck.class.getSimpleName(),
            FailingHealthCheck.class);
    failingHealthCheck.getConfiguration().setEnabled(enabled);
}
 

@Override
public boolean accept(final Phase phase, final Runtime runtime) {
    if (phase == Phase.ConfigureContext) {
        final Registry registry = runtime.getRegistry();
        registry.bind("syndesis", new IntegrationRouteLoader());

        return true;
    }

    return false;
}
 

private void validate(Registry registry) throws Exception {
    final CamelContext context = new DefaultCamelContext(registry);

    try {
        context.setAutoStartup(false);
        context.addRoutes(new RouteBuilder() {
            @Override
            public void configure() throws Exception {
                from("direct:start")
                    .to("my-sql-proxy")
                    .to("mock:result");
            }
        });

        context.start();

        Collection<String> names = context.getComponentNames();

        assertThat(names).contains("my-sql-proxy");
        assertThat(names).contains("sql-my-sql-proxy");

        SqlComponent sqlComponent = context.getComponent("sql-my-sql-proxy", SqlComponent.class);
        DataSource sqlDatasource = sqlComponent.getDataSource();

        assertThat(sqlDatasource).isEqualTo(this.ds);

        Map<String, Endpoint> endpoints = context.getEndpointMap();
        assertThat(endpoints).containsKey("sql-my-sql-proxy://select%20from%20dual");
    } finally {
        context.stop();
    }
}
 

@Singleton
@Produces
Registry camelRegistry() {
    return this.context.getRegistry();
}
 

/**
 * Returns the registry associated to this runtime.
 */
default Registry getRegistry() {
    return getCamelContext().getRegistry();
}
 

@Test
public void shouldComposeRegistries() {
    final Registry registry = camelContext.getRegistry();
    Assertions.assertThat(registry.lookupByName("bean")).isEqualTo(Ordered.HIGHEST_PRECEDENCE);
}
 

public RuntimeValue<Registry> createRegistry() {
    return new RuntimeValue<>(new RuntimeRegistry());
}
 

public RuntimeValue<Registry> getRegistry() {
    return value;
}
 

public CamelRegistryBuildItem(RuntimeValue<Registry> value) {
    this.value = value;
}
 

@Path("/registry/lookup-registry")
@GET
@Produces(MediaType.TEXT_PLAIN)
public boolean lookupRegistry() {
    return registry.findByType(Registry.class).size() == 1;
}