public ActiveMQConfiguration() 
{

}

 protected ConnectionFactory createConnectionFactory() 
{
        ActiveMQConnectionFactory answer = new ActiveMQConnectionFactory();
        if (userName != null) {
            answer.setUserName(userName);
        }
        if (password != null) {
            answer.setPassword(password);
        }
        if (answer.getBeanName() == null) {
            answer.setBeanName("Camel");
        }
        answer.setBrokerURL(getBrokerURL());
        if (isUseSingleConnection()) {
            SingleConnectionFactory scf = new SingleConnectionFactory(answer);
            if (activeMQComponent != null) {
                activeMQComponent.addSingleConnectionFactory(scf);
            }
            return scf;
        }
        else if (isUsePooledConnection()) {
            ConnectionFactory pcf = createPooledConnectionFactory(answer);
            if (activeMQComponent != null) {
                activeMQComponent.addPooledConnectionFactoryService((Service) pcf);
            }
            return pcf;
        }
        else {
            return answer;
        }
}

 protected ConnectionFactory createPooledConnectionFactory(ActiveMQConnectionFactory connectionFactory) 
{
        // lets not use classes directly to avoid a runtime dependency on commons-pool
        // for folks not using this option
        try {
            Class type = loadClass("org.apache.activemq.pool.PooledConnectionFactory", getClass().getClassLoader());
            Constructor constructor = type.getConstructor(org.apache.activemq.ActiveMQConnectionFactory.class);
            return (ConnectionFactory) constructor.newInstance(connectionFactory);
        }
        catch (Exception e) {
            throw new RuntimeException("Failed to instantiate PooledConnectionFactory: " + e, e);
        }
}

 protected PlatformTransactionManager createTransactionManager() 
{
        JmsTransactionManager answer = new JmsTransactionManager(getConnectionFactory());
        answer.afterPropertiesSet();
        return answer;
}

Factory method to create a default transaction manager if one is not specified

 public String getBrokerURL() 
{
        return brokerURL;
}

 public String getPassword() 
{
        return password;
}

 public PlatformTransactionManager getTransactionManager() 
{
        PlatformTransactionManager answer = super.getTransactionManager();
        if (isTransacted() && answer == null) {
            // lets auto-default the transaction manager if its not specified
            answer = createTransactionManager();
            setTransactionManager(answer);
            answer = getTransactionManager();
        }
        return answer;
}

 public String getUserName() 
{
        return userName;
}

 public boolean isUsePooledConnection() 
{
        return usePooledConnection;
}

 public boolean isUseSingleConnection() 
{
        return useSingleConnection;
}

 public static Class<?> loadClass(String name,
    ClassLoader loader) throws ClassNotFoundException 
{
        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        if (contextClassLoader != null) {
            try {
                return contextClassLoader.loadClass(name);
            }
            catch (ClassNotFoundException e) {
                try {
                    return loader.loadClass(name);
                }
                catch (ClassNotFoundException e1) {
                    throw e1;
                }
            }
        } else {
            return loader.loadClass(name);
        }
}

 protected  void setActiveMQComponent(ActiveMQComponent activeMQComponent) 
{
        this.activeMQComponent = activeMQComponent;
}

 public  void setBrokerURL(String brokerURL) 
{
        this.brokerURL = brokerURL;
}

Sets the broker URL to use to connect to ActiveMQ using the ActiveMQ URI format

 public  void setPassword(String password) 
{
        this.password = password;
}

Sets the password/passcode used to login to ActiveMQ

 public  void setUsePooledConnection(boolean usePooledConnection) 
{
        this.usePooledConnection = usePooledConnection;
}

Enables or disables whether a PooledConnectionFactory will be used so that when messages are sent to ActiveMQ from outside of a message consuming thread, pooling will be used rather than the default with the Spring JmsTemplate which will create a new connection, session, producer for each message then close them all down again.

The default value is false by default as it requires an extra dependency on commons-pool.

 public  void setUseSingleConnection(boolean useSingleConnection) 
{
        this.useSingleConnection = useSingleConnection;
}

Enables or disables whether a Spring SingleConnectionFactory will be used so that when messages are sent to ActiveMQ from outside of a message consuming thread, pooling will be used rather than the default with the Spring JmsTemplate which will create a new connection, session, producer for each message then close them all down again.

The default value is true so that a single connection is used by default.

 public  void setUserName(String userName) 
{
        this.userName = userName;
}

Sets the username to be used to login to ActiveMQ