/** * Factory method which allows derived classes to customize the lazy * creation */ protected ConnectionFactory createListenerConnectionFactory() { return getConnectionFactory(); }
@SuppressWarnings("deprecation") public static JmsComponent jmsComponentTransacted(ConnectionFactory connectionFactory, PlatformTransactionManager transactionManager) { JmsConfiguration template = new JmsConfiguration(connectionFactory); template.setTransactionManager(transactionManager); template.setTransacted(true); template.setTransactedInOut(true); return jmsComponent(template); }
@Override public ActiveMQConnectionFactory getListenerConnectionFactory() { return (ActiveMQConnectionFactory) super.getListenerConnectionFactory(); }
JmsConfiguration config = new JmsConfiguration(pooledConnectionFactory); config.setConcurrentConsumers(1); config.setMaxConcurrentConsumers(1);
/** * Static builder method */ public static JmsComponent jmsComponentClientAcknowledge(ConnectionFactory connectionFactory) { JmsConfiguration template = new JmsConfiguration(connectionFactory); template.setAcknowledgementMode(Session.CLIENT_ACKNOWLEDGE); return jmsComponent(template); }
private void createCamelContext() throws Exception { CamelContext camelContext = getContext(); ConnectionFactory jmsConnectFactory = createConnectionFactory(); PooledConnectionFactory jmsPooledConnectionFactory = new PooledConnectionFactory(); jmsPooledConnectionFactory.setConnectionFactory(jmsConnectFactory); jmsPooledConnectionFactory.setMaxConnections(2); JmsTransactionManager jmsTransactionManager = new JmsTransactionManager(); jmsTransactionManager.setConnectionFactory(jmsConnectFactory); JmsConfiguration jmsConfiguration = new JmsConfiguration(); jmsConfiguration.setConnectionFactory(jmsPooledConnectionFactory); jmsConfiguration.setTransacted(true); jmsConfiguration.setTransactionManager(jmsTransactionManager); jmsConfiguration.setCacheLevelName("CACHE_CONSUMER"); JmsComponent jms = new JmsComponent(); jms.setConfiguration(jmsConfiguration); camelContext.addComponent("jms", jms); }
JmsConfiguration newConfiguration = getConfiguration().copy(); JmsEndpoint endpoint; if (pubSubDomain) { endpoint.getConfiguration().setConnectionFactory(cf); String cfUsername = getAndRemoveParameter(parameters, "username", String.class, getConfiguration().getUsername()); String cfPassword = getAndRemoveParameter(parameters, "password", String.class, getConfiguration().getPassword()); if (cfUsername != null && cfPassword != null) { cf = endpoint.getConfiguration().getConnectionFactory(); ObjectHelper.notNull(cf, "ConnectionFactory"); LOG.debug("Wrapping existing ConnectionFactory with UserCredentialsConnectionFactoryAdapter using username: {} and password: ******", cfUsername); ucfa.setPassword(cfPassword); ucfa.setUsername(cfUsername); endpoint.getConfiguration().setConnectionFactory(ucfa); } else {
/** * Factory method to create the default configuration instance * * @return a newly created configuration object which can then be further * customized */ protected JmsConfiguration createConfiguration() { return new JmsConfiguration(); }
protected void configureMessageListenerContainer(AbstractMessageListenerContainer container, JmsEndpoint endpoint) throws Exception { container.setConnectionFactory(getListenerConnectionFactory()); if (endpoint instanceof DestinationEndpoint) { container.setDestinationResolver(createDestinationResolver((DestinationEndpoint) endpoint)); } else if (destinationResolver != null) { container.setDestinationResolver(destinationResolver); container.setErrorHandler(errorHandler); } else { ErrorHandler handler = new DefaultSpringErrorHandler(endpoint.getCamelContext(), EndpointMessageListener.class, getErrorHandlerLoggingLevel(), isErrorHandlerLogStackTrace()); container.setErrorHandler(handler); configureDefaultMessageListenerContainer(endpoint, listenerContainer); } else if (container instanceof SimpleMessageListenerContainer) { SimpleMessageListenerContainer listenerContainer = (SimpleMessageListenerContainer) container; configureSimpleMessageListenerContainer(listenerContainer);
public JmsConfiguration getConfiguration() { if (configuration == null) { configuration = createConfiguration(); // If we are being configured with spring... if (applicationContext != null) { if (isAllowAutoWiredConnectionFactory()) { Map<String, ConnectionFactory> beansOfTypeConnectionFactory = applicationContext.getBeansOfType(ConnectionFactory.class); if (!beansOfTypeConnectionFactory.isEmpty()) { ConnectionFactory cf = beansOfTypeConnectionFactory.values().iterator().next(); configuration.setConnectionFactory(cf); } } if (isAllowAutoWiredDestinationResolver()) { Map<String, DestinationResolver> beansOfTypeDestinationResolver = applicationContext.getBeansOfType(DestinationResolver.class); if (!beansOfTypeDestinationResolver.isEmpty()) { DestinationResolver destinationResolver = beansOfTypeDestinationResolver.values().iterator().next(); configuration.setDestinationResolver(destinationResolver); } } } } return configuration; }
JmsConfiguration config = new JmsConfiguration(pooledConnectionFactory); config.setConcurrentConsumers(10);
/** * Sets the cache level by name for the underlying JMS resources. * Possible values are: CACHE_AUTO, CACHE_CONNECTION, CACHE_CONSUMER, CACHE_NONE, and CACHE_SESSION. * The default setting is CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more information. */ @Metadata(defaultValue = "CACHE_AUTO", label = "consumer", enums = "CACHE_AUTO,CACHE_CONNECTION,CACHE_CONSUMER,CACHE_NONE,CACHE_SESSION", description = "Sets the cache level by name for the underlying JMS resources." + " Possible values are: CACHE_AUTO, CACHE_CONNECTION, CACHE_CONSUMER, CACHE_NONE, and CACHE_SESSION." + " The default setting is CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more information.") public void setCacheLevelName(String cacheName) { getConfiguration().setCacheLevelName(cacheName); }
public void setTransactionManager(PlatformTransactionManager transactionManager) { getConfiguration().setTransactionManager(transactionManager); }
@ManagedAttribute public void setMaxConcurrentConsumers(int maxConcurrentConsumers) { getConfiguration().setMaxConcurrentConsumers(maxConcurrentConsumers); }
@ManagedAttribute public void setTransacted(boolean consumerTransacted) { getConfiguration().setTransacted(consumerTransacted); }
public void setConnectionFactory(ConnectionFactory connectionFactory) { getConfiguration().setConnectionFactory(connectionFactory); }
@Override public void setListenerConnectionFactory(ConnectionFactory listenerConnectionFactory) { if (listenerConnectionFactory instanceof ActiveMQConnectionFactory) { super.setListenerConnectionFactory(listenerConnectionFactory); } else { throw new IllegalArgumentException("ConnectionFactory " + listenerConnectionFactory + " is not an instanceof " + ActiveMQConnectionFactory.class.getName()); } }
/** * Static builder method */ public static JmsComponent jmsComponent(ConnectionFactory connectionFactory) { return jmsComponent(new JmsConfiguration(connectionFactory)); }
/** * Static builder method */ public static JmsComponent jmsComponentAutoAcknowledge(ConnectionFactory connectionFactory) { JmsConfiguration template = new JmsConfiguration(connectionFactory); template.setAcknowledgementMode(Session.AUTO_ACKNOWLEDGE); return jmsComponent(template); }
@ManagedAttribute public void setConcurrentConsumers(int concurrentConsumers) { getConfiguration().setConcurrentConsumers(concurrentConsumers); }