private RoutesBuilder instantiateBuilder(Class<? extends RoutesBuilder> type) { return camelContext.getInjector().newInstance(type); } }
private Optional<ComponentProxyFactory> resolveComponentProxyFactory(CamelContext context, Optional<String> componentProxyFactory) { ComponentProxyFactory factory = null; if (componentProxyFactory.isPresent()) { final String factoryType = componentProxyFactory.get(); final ClassResolver resolver = context.getClassResolver(); Class<? extends ComponentProxyFactory> type = resolver.resolveClass(factoryType, ComponentProxyFactory.class); if (type == null) { throw new IllegalArgumentException("Unable to resolve a ComponentProxyFactory of type: " + factoryType); } factory = context.getInjector().newInstance(type); if (factory == null) { throw new IllegalArgumentException("Unable to instantiate a ComponentProxyFactory of type: " + factoryType); } } return Optional.ofNullable(factory); }
private ComponentProxyCustomizer resolveCustomizer(CamelContext context, String customizerType) { Class<ComponentProxyCustomizer> type = context.getClassResolver().resolveClass(customizerType, ComponentProxyCustomizer.class); if (type == null) { throw new IllegalArgumentException("Unable to resolve a ComponentProxyCustomizer of type: " + customizerType); } final ComponentProxyCustomizer customizer = context.getInjector().newInstance(type); if (customizer == null) { throw new IllegalArgumentException("Unable to instantiate a ComponentProxyCustomizer of type: " + customizerType); } return customizer; } }
@SuppressWarnings("unchecked") public static CamelReactiveStreamsServiceFactory resolveServiceFactory(CamelContext context, String serviceType) { try { FactoryFinder finder = context.getFactoryFinder(ReactiveStreamsConstants.SERVICE_PATH); Class<?> serviceClass = finder.findClass(serviceType); return (CamelReactiveStreamsServiceFactory)context.getInjector().newInstance(serviceClass); } catch (ClassNotFoundException e) { throw new IllegalStateException("Class referenced in '" + ReactiveStreamsConstants.SERVICE_PATH + serviceType + "' not found", e); } catch (Exception e) { throw new IllegalStateException("Unable to create the reactive stream service defined in '" + ReactiveStreamsConstants.SERVICE_PATH + serviceType + "'", e); } } }
/** * Sole constuctor. * * @param camelContext the CamelContext to be used. */ public CamelTypeConverterExtractor(final CamelContext camelContext) { super(camelContext.getPackageScanClassResolver(), camelContext.getInjector(), camelContext.getDefaultFactoryFinder()); _camelContext = camelContext; }
private ComponentProxyCustomizer resolveCustomizer(CamelContext context, String customizerType) { final ComponentProxyCustomizer customizer; Class<ComponentProxyCustomizer> type = context.getClassResolver().resolveClass(customizerType, ComponentProxyCustomizer.class); if (type == null) { throw new IllegalArgumentException("Unable to resolve a ComponentProxyCustomizer of type: " + customizerType); } customizer = context.getInjector().newInstance(type); if (customizer == null) { throw new IllegalArgumentException("Unable to instantiate a ComponentProxyCustomizer of type: " + customizerType); } return customizer; } }
private static ComponentCustomizer<Component> resolveCustomizer(final CamelContext context, final String customizerType) { @SuppressWarnings("rawtypes") final Class<ComponentCustomizer> type = context.getClassResolver().resolveClass(customizerType, ComponentCustomizer.class); if (type == null) { throw new IllegalArgumentException("Unable to resolve a ComponentProxyCustomizer of type: " + customizerType); } @SuppressWarnings("unchecked") final ComponentCustomizer<Component> customizer = context.getInjector().newInstance(type); if (customizer == null) { throw new IllegalArgumentException("Unable to instantiate a ComponentProxyCustomizer of type: " + customizerType); } return customizer; } }
public Object evaluate(Exchange exchange, Class asType) { Object answer = exchange.getIn().getBody(type); if (answer == null) { Object defaultValue = exchange.getIn().getBody(); if (defaultValue != null) { throw ObjectHelper.wrapRuntimeCamelException(new NoTypeConversionAvailableException(defaultValue, type)); } // if we don't have a body then // lets instantiate and inject a new instance answer = exchange.getContext().getInjector().newInstance(type); } return answer; } };
@Override public void init(CamelContext camelContext) { this.camelContext = camelContext; // Attempt to enables JAXB processing so we can easily convert JAXB annotated pojos also Class<?> clazz = camelContext.getClassResolver().resolveClass(JACKSON_JAXB_MODULE); if (clazz != null) { Object obj = camelContext.getInjector().newInstance(clazz); if (obj instanceof Module) { Module module = (Module) obj; defaultMapper.registerModule(module); } } }
private Object mandatoryLoadResource(CamelContext context, String resource) { Object instance = null; if (resource.startsWith("classpath:")) { try (InputStream is = ResourceHelper.resolveMandatoryResourceAsInputStream(context, resource)) { instance = ModelHelper.loadRoutesDefinition(context, is); } catch (Exception e) { throw new IllegalArgumentException(e); } } else if (resource.startsWith("class:")) { Class<?> type = context.getClassResolver().resolveClass(resource.substring("class:".length())); instance = context.getInjector().newInstance(type); } else if (resource.startsWith("bean:")) { instance = context.getRegistry().lookupByName(resource.substring("bean:".length())); } if (instance == null) { throw new IllegalArgumentException("Unable to resolve resource: " + resource); } return instance; }
static JaxbNamespacePrefixMapper newNamespacePrefixMapper(CamelContext camelContext, Map<String, String> namespaces) { // try to load the Sun JAXB 2.1 based Class<?> clazz = camelContext.getClassResolver().resolveClass(SUN_JAXB_21_MAPPER); if (clazz != null) { JaxbNamespacePrefixMapper mapper = (JaxbNamespacePrefixMapper) camelContext.getInjector().newInstance(clazz); mapper.setNamespaces(namespaces); return mapper; } throw new IllegalStateException("Cannot load CamelNamespacePrefixMapper class"); } }
/** * Create a new instance of the entity for the given key */ protected T createEntity(Exchange exchange, Object key) { return exchange.getContext().getInjector().newInstance(getEntityType()); }
private ComponentProxyComponent resolveComponent(String componentId, String componentScheme, CamelContext context, ConnectorDescriptor descriptor) { ComponentProxyFactory factory = ComponentProxyComponent::new; if (descriptor.getConnectorFactory().isPresent()) { final String factoryType = descriptor.getConnectorFactory().get(); final ClassResolver resolver = context.getClassResolver(); Class<? extends ComponentProxyFactory> type = resolver.resolveClass(factoryType, ComponentProxyFactory.class); if (type == null) { throw new IllegalArgumentException("Unable to resolve a ComponentProxyFactory of type: " + factoryType); } factory = context.getInjector().newInstance(type); if (factory == null) { throw new IllegalArgumentException("Unable to instantiate a ComponentProxyFactory of type: " + factoryType); } } return factory.newInstance(componentId, componentScheme); }
private void createTransformerFactory() throws ClassNotFoundException { // provide the class loader of this component to work in OSGi environments Class<TransformerFactory> factoryClass = getCamelContext().getClassResolver().resolveMandatoryClass(SAXON_TRANSFORMER_FACTORY_CLASS_NAME, TransformerFactory.class, SchematronComponent.class.getClassLoader()); LOG.debug("Using TransformerFactoryClass {}", factoryClass); transformerFactory = getCamelContext().getInjector().newInstance(factoryClass); transformerFactory.setURIResolver(new ClassPathURIResolver(Constants.SCHEMATRON_TEMPLATES_ROOT_DIR, this.uriResolver)); transformerFactory.setAttribute(LINE_NUMBERING, true); }
private void doInitAdapter(Exchange exchange) { if (!initJsonAdapter) { try { // need to load this adapter dynamically as its optional LOG.debug("Attempting to enable JacksonJsonAdapter by resolving: {} from classpath", JACKSON_JSON_ADAPTER); Class<?> clazz = exchange.getContext().getClassResolver().resolveClass(JACKSON_JSON_ADAPTER); if (clazz != null) { Object obj = exchange.getContext().getInjector().newInstance(clazz); if (obj instanceof JsonPathAdapter) { adapter = (JsonPathAdapter) obj; adapter.init(exchange.getContext()); LOG.debug("JacksonJsonAdapter found on classpath and enabled for camel-jsonpath: {}", adapter); } } } catch (Throwable e) { LOG.debug("Cannot load " + JACKSON_JSON_ADAPTER + " from classpath to enable JacksonJsonAdapter due " + e.getMessage() + ". JacksonJsonAdapter is not enabled.", e); } initJsonAdapter = true; } } }
@Override public Optional<ProcessorDefinition> handle(Extension step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { final CamelContext context = routeBuilder.getContext(); final TypeConverter converter = context.getTypeConverter(); final String target = step.getName(); if (!Strings.isEmpty(target)) { try { final Class<SyndesisStepExtension> clazz = context.getClassResolver().resolveMandatoryClass(target, SyndesisStepExtension.class); final SyndesisStepExtension stepExtension = context.getInjector().newInstance(clazz); final Map<String, Object> props = new HashMap<>(step.getProperties()); try { IntrospectionSupport.setProperties(context, converter, stepExtension, props); } catch (Exception e) { throw new IllegalStateException(e); } return stepExtension.configure(context, route, props); } catch (ClassNotFoundException e) { throw new IllegalStateException(e); } } return Optional.of(route); } }
private ComponentProxyComponent resolveComponent(CamelContext context, Connector step) { ComponentProxyFactory factory = ComponentProxyComponent::new; if (step.getFactory() != null ) { final ClassResolver resolver = context.getClassResolver(); final Injector injector = context.getInjector(); Class<? extends ComponentProxyFactory> type = resolver.resolveClass(step.getFactory(), ComponentProxyFactory.class); if (type == null) { throw new IllegalArgumentException("Unable to resolve a ComponentProxyFactory of type: " + step.getFactory()); } factory = injector.newInstance(type); if (factory == null) { throw new IllegalArgumentException("Unable to instantiate a ComponentProxyFactory of type: " + step.getFactory()); } } return factory.newInstance(step.getComponentId(), step.getComponentScheme()); }
camelContext.getInjector().newInstance(configuration.getTransport()) );
public TalendJob getJobInstance(boolean isMandatory) throws Exception { final JobResolver jobResolver = JobResolverHolder.getJobResolver(); if (null != jobResolver) { TalendESBJobFactory talendESBJobFactory = jobResolver.getJobService(owner, clazz, isMandatory); if (null != talendESBJobFactory) { return talendESBJobFactory.newTalendESBJob(); } if (!isMandatory) { return null; } } Class<?> jobType = this.getCamelContext().getClassResolver().resolveMandatoryClass(clazz); return (TalendJob) getCamelContext().getInjector().newInstance(jobType); }
public TalendJob getJobInstance(boolean isMandatory) throws Exception { final JobResolver jobResolver = JobResolverHolder.getJobResolver(); if (null != jobResolver) { TalendESBJobFactory talendESBJobFactory = jobResolver.getJobService(owner, clazz, isMandatory); if (null != talendESBJobFactory) { return talendESBJobFactory.newTalendESBJob(); } if (!isMandatory) { return null; } } Class<?> jobType = this.getCamelContext().getClassResolver().resolveMandatoryClass(clazz); return (TalendJob) getCamelContext().getInjector().newInstance(jobType); }