@Override public Class<?> classForName(String className, Map context) throws ClassNotFoundException { return delegateClassResolver.resolveClass(className); }
<T> Class<T> loadClass(Object o, ClassResolver resolver, Class<T> type) { if (o == null || o instanceof Class) { return CastUtils.cast((Class<?>) o); } String name = o.toString(); Class<T> c = resolver.resolveClass(name, type); if (c == null) { c = resolver.resolveClass(name, type, getClass().getClassLoader()); } if (c == null) { c = resolver.resolveClass(name, type, org.apache.kafka.clients.producer.KafkaProducer.class.getClassLoader()); } return c; }
public static <T> Class getObjectFactory(CamelContext camelContext, Class<T> type) { if (camelContext == null) { return null; } if (type.getPackage() != null) { String objectFactoryClassName = type.getPackage().getName() + ".ObjectFactory"; return camelContext.getClassResolver().resolveClass(objectFactoryClassName); } return null; }
private Object invokeFunction(Method method, Object customObj, Object source, String[][] parameters) throws Exception { Class<?>[] prmTypes = method.getParameterTypes(); Object[] methodPrms = new Object[prmTypes.length]; methodPrms[0] = source; for (int parameterNdx = 0, methodPrmNdx = 1; parameterNdx < parameters.length; parameterNdx++, methodPrmNdx++) { if (method.isVarArgs() && methodPrmNdx == prmTypes.length - 1) { Object array = Array.newInstance(prmTypes[methodPrmNdx].getComponentType(), parameters.length - parameterNdx); for (int arrayNdx = 0; parameterNdx < parameters.length; parameterNdx++, arrayNdx++) { String[] parts = parameters[parameterNdx]; Array.set(array, arrayNdx, resolver.resolveClass(parts[0]).getConstructor(String.class).newInstance(parts[1])); } methodPrms[methodPrmNdx] = array; } else { String[] parts = parameters[parameterNdx]; methodPrms[methodPrmNdx] = resolver.resolveClass(parts[0]).getConstructor(String.class).newInstance(parts[1]); } } return method.invoke(customObj, methodPrms); }
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); }
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 UnmarshallProcessor(final DataShape dataShape) { if (dataShape.getKind() == DataShapeKinds.JAVA) { type = camelContext.getClassResolver().resolveClass(dataShape.getType()); if (type == null) { throw new IllegalArgumentException("The specified class for shape `" + dataShape + "` cannot be found"); } } else { type = null; } }
@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"); } }
public static ManagedGroupFactory create(CuratorFramework curator, ClassLoader loader, ClassResolver resolver, Callable<CuratorFramework> factory) throws Exception { if (curator != null) { return new StaticManagedGroupFactory(curator, false); } try { Class<?> clazz = resolver.resolveClass("org.apache.camel.component.zookeepermaster.group.internal.osgi.OsgiManagedGroupFactory"); if (clazz != null) { Object instance = clazz.newInstance(); IntrospectionSupport.setProperty(instance, "classLoader", loader); return (ManagedGroupFactory) instance; } } catch (Throwable e) { // Ignore if we'e not in OSGi } return new StaticManagedGroupFactory(factory.call(), true); }
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 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 protected Endpoint createEndpoint(String uri, String path, Map<String, Object> options) throws Exception { JpaEndpoint endpoint = new JpaEndpoint(uri, this); endpoint.setJoinTransaction(isJoinTransaction()); endpoint.setSharedEntityManager(isSharedEntityManager()); // lets interpret the next string as a class if (ObjectHelper.isNotEmpty(path)) { // provide the class loader of this component to work in OSGi environments as camel-jpa must be able // to resolve the entity classes Class<?> type = getCamelContext().getClassResolver().resolveClass(path, JpaComponent.class.getClassLoader()); if (type != null) { endpoint.setEntityType(type); } } return endpoint; }
@SuppressWarnings("unchecked") public ResultSetIterator queryForStreamList(Connection connection, Statement statement, ResultSet rs) throws SQLException { if (outputClass == null) { RowMapper rowMapper = new ColumnMapRowMapper(); return new ResultSetIterator(connection, statement, rs, rowMapper); } else { Class<?> outputClzz = getCamelContext().getClassResolver().resolveClass(outputClass); RowMapper rowMapper = new BeanPropertyRowMapper(outputClzz); return new ResultSetIterator(connection, statement, rs, rowMapper); } }
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()); }
@SuppressWarnings("unchecked") public List<?> queryForList(ResultSet rs, boolean allowMapToClass) throws SQLException { if (allowMapToClass && outputClass != null) { Class<?> outputClazz = getCamelContext().getClassResolver().resolveClass(outputClass); RowMapper rowMapper = new BeanPropertyRowMapper(outputClazz); RowMapperResultSetExtractor<?> mapper = new RowMapperResultSetExtractor(rowMapper); List<?> data = mapper.extractData(rs); return data; } else { ColumnMapRowMapper rowMapper = new ColumnMapRowMapper(); RowMapperResultSetExtractor<Map<String, Object>> mapper = new RowMapperResultSetExtractor<>(rowMapper); List<Map<String, Object>> data = mapper.extractData(rs); return data; } }
protected XMLContext createXMLContext(ClassResolver resolver, ClassLoader contextClassLoader) throws Exception { XMLContext xmlContext = new XMLContext(); if (ObjectHelper.isNotEmpty(getMappingFile())) { Mapping xmlMap; if (contextClassLoader != null) { xmlMap = new Mapping(contextClassLoader); } else { xmlMap = new Mapping(); } xmlMap.loadMapping(resolver.loadResourceAsURL(getMappingFile())); xmlContext.addMapping(xmlMap); } if (getPackages() != null) { xmlContext.addPackages(getPackages()); } if (getClassNames() != null) { for (String name : getClassNames()) { Class<?> clazz = resolver.resolveClass(name); xmlContext.addClass(clazz); } } return xmlContext; }