protected RoutesBuilder instantiateBuilder(Class<? extends RoutesBuilder> type) throws IllegalAccessException, InstantiationException { return camelContext.getInjector().newInstance(type); } }
@Inject Injector injector; ... return injector.newInstance(MyClass.class);
@Override public <T> T newInstance(Class<T> type, Object instance) { return injector.newInstance(type, instance); }
@Override public <T> T newInstance(Class<T> type) { return getReferenceByType(manager, type) .orElseGet(() -> injector.newInstance(type)); }
private RoutesBuilder instantiateBuilder(Class<? extends RoutesBuilder> type) { return camelContext.getInjector().newInstance(type); } }
protected RoutesBuilder instantiateBuilder(Class<?> type) throws IllegalAccessException, InstantiationException { return (RoutesBuilder) camelContext.getInjector().newInstance(type); } }
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; } }
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); }
@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); } } }
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; } }
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; } }
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); } } }
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 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()); }
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); }