Spring Cloud Auto-Config JNDI

compile("com.solacesystems:sol-jms:${solaceJMSVersion}")

<dependency>
  <groupId>com.solacesystems</groupId>
  <artifactId>sol-jms</artifactId>
  <version>10.+</version>
</dependency>

{
  "VCAP_SERVICES": {
    "solace-pubsub": [ {
        "name": "solace-pubsub-sample-instance",
        "label": "solace-pubsub",
        "plan": "enterprise-shared",
        "tags": [
            (...)
            ],
        "credentials": {
          "clientUsername": "v005.cu000001",
          "clientPassword": "bb90fcb0-6c83-4a10-bafa-3ec225bbfc08",
          "msgVpnName": "v005",
            (...)
          "smfHosts": [ "tcp://192.168.132.14:7000" ],
            (...)
        }
      }
    }
  ]
}

// A Sprint JmsTemplate for the auto selected Solace Messaging service,
// This is the only required bean to run this application.
// Note that both SolaceController and ProducerConfiguration use this for
// their respective purposes but the same connection factory is provided.
@Autowired
private JmsTemplate jmsTemplate;

// The auto selected Solace Messaging service for the matching ConnectionFactory,
// the relevant information provided by this bean have already been injected
// into the ConnectionFactory.
// This bean is for information only, it can be used to discover more about
// the solace service in use.
@Autowired
SolaceServiceCredentials solaceServiceCredentials;

// A Factory of Factories
// Has the ability to create ConnectionFactory(s) for any available
// SolaceServiceCredentials
// Can be used in case there are multiple Solace Messaging Services to
// select from.
@Autowired
SpringSolJmsJndiTemplateCloudFactory springSolJmsJndiTemplateCloudFactory;

logger.info(String.format("SpringSolJmsJndiTemplateCloudFactory discovered %s solace-pubsub service(s)",
        springSolJmsJndiTemplateCloudFactory.getSolaceServiceCredentials().size()));

// Log what Solace Messaging Services were discovered
for (SolaceServiceCredentials discoveredSolaceMessagingService : SpringSolJmsJndiTemplateCloudFactory
        .getSolaceServiceCredentials()) {
    logger.info(String.format(
            "Discovered Solace Messaging service '%s': HighAvailability? ( %s ), Message VPN ( %s )",
            discoveredSolaceMessagingService.getId(), discoveredSolaceMessagingService.isHA(),
            discoveredSolaceMessagingService.getMsgVpnName()));
}

@Configuration
public class JndiProducerConfiguration {

    // Resource definitions: connection factory and queue destination
    @Value("${solace.jms.demoConnectionFactoryJndiName}")
    private String connectionFactoryJndiName;


    // Use from the jndi connection config
    @Autowired
	private JndiTemplate jndiTemplate;

	@Bean
    public JndiObjectFactoryBean connectionFactory() {
        JndiObjectFactoryBean factoryBean = new JndiObjectFactoryBean();
        factoryBean.setJndiTemplate(jndiTemplate);
        factoryBean.setJndiName(connectionFactoryJndiName);

        return factoryBean;
    }

    @Bean
	public CachingConnectionFactory cachingConnectionFactory() {
		CachingConnectionFactory ccf = new CachingConnectionFactory((ConnectionFactory) connectionFactory().getObject());
		ccf.setSessionCacheSize(10);
		return ccf;
	}

    // DynamicDestinationResolver can be used instead for physical, non-jndi destinations
    @Bean
    public JndiDestinationResolver jndiDestinationResolver() {
    	JndiDestinationResolver jdr = new JndiDestinationResolver();
        jdr.setCache(true);
        jdr.setJndiTemplate(jndiTemplate);
        return jdr;
    }

	@Bean
	public JmsTemplate producerJmsTemplate() {
		JmsTemplate jt = new JmsTemplate(cachingConnectionFactory());
		jt.setDeliveryPersistent(true);
		jt.setDestinationResolver(jndiDestinationResolver());
		jt.setPubSubDomain(true);	// This sample is publishing to topics
		return jt;
	}
}

@Autowired
private JmsTemplate jmsTemplate;

...

this.jmsTemplate.convertAndSend(message.getTopic(), message.getBody());

@EnableJms
public class JndiConsumerConfiguration {

	// Resource definitions: connection factory and queue destination
    @Value("${solace.jms.demoConnectionFactoryJndiName}")
    private String connectionFactoryJndiName;

    @Autowired
    JndiTemplate jndiTemplate;


	@Bean
    public JndiObjectFactoryBean connectionFactory() {
        JndiObjectFactoryBean factoryBean = new JndiObjectFactoryBean();
        factoryBean.setJndiTemplate(jndiTemplate);
        factoryBean.setJndiName(connectionFactoryJndiName);
        return factoryBean;
    }

    // DynamicDestinationResolver can be used instead for physical, non-jndi destinations
    @Bean
    public JndiDestinationResolver jndiDestinationResolver() {
    	JndiDestinationResolver jdr = new JndiDestinationResolver();
        jdr.setCache(true);
        jdr.setJndiTemplate(jndiTemplate);
        return jdr;
    }
}

@Autowired
private ConnectionFactory connectionFactory;

@Autowired
private JndiDestinationResolver jndiDestinationResolver;

public class SimpleMessageListener implements MessageListener {
    @Override
    public void onMessage(Message message) {

        numMessagesReceived.incrementAndGet();

        if (message instanceof TextMessage) {
            lastReceivedMessage = (TextMessage) message;
            try {
                logger.info("Received message : " + lastReceivedMessage.getText());
            } catch (JMSException e) {
                logger.error("Error getting text of the received TextMessage: " + e);
            }
        } else {
            logger.error("Received message that was not a TextMessage: " + message);
        }
    }
}

// Create a listener explicitly, runtime
public DefaultMessageListenerContainer createListener(String destination) {
    // do something here to create a message listener container
    DefaultMessageListenerContainer lc = new DefaultMessageListenerContainer();
    lc.setConnectionFactory(connectionFactory);
    lc.setDestinationResolver(jndiDestinationResolver);
    lc.setDestinationName(destination);
    lc.setMessageListener(new SimpleMessageListener());
    lc.setPubSubDomain(true);
    lc.initialize();
    return lc;
}

...

DefaultMessageListenerContainer listenercontainer = createListener(subscriptionTopic);
listenercontainer.start();

@RequestMapping(value = "/subscription", method = RequestMethod.POST)
public ResponseEntity<String> addSubscription(@RequestBody SimpleSubscription subscription) {
    // ...
}

@RequestMapping(value = "/message", method = RequestMethod.POST)
public ResponseEntity<String> sendMessage(@RequestBody SimpleMessage message) {
   // ...
}

@RequestMapping(value = "/message", method = RequestMethod.GET)
public ResponseEntity<SimpleMessage> getLastMessageReceived() {
    // ...
}

git clone https://github.com/SolaceSamples/solace-samples-cloudfoundry-java
cd solace-samples-cloudfoundry-java
./gradlew build

cf create-service solace-pubsub enterprise-shared solace-pubsub-sample-instance

cd spring-cloud-autoconf-jms
cf push

cd spring-cloud-autoconf
cf set-env solace-sample-spring-cloud-autoconf solace.jms.demoConnectionFactoryJndiName /jms/cf/default
cf restage solace-sample-spring-cloud-autoconf

export APP_NAME=solace-sample-spring-cloud-autoconf
export APP_URL=`cf apps | grep $APP_NAME | grep started | awk '{ print $6}'`
echo "The application URL is: ${APP_URL}"

# Subscribes the application to the topic "test"
curl -X POST -H "Content-Type: application/json;charset=UTF-8" -d '{"subscription": "test"}' http://$APP_URL/subscription

# Send message with topic "test" and this content: "TEST_MESSAGE"
curl -X POST -H "Content-Type: application/json;charset=UTF-8" -d '{"topic": "test", "body": "Test Message"}' http://$APP_URL/message

# The message should have been asynchronously received by the application.  Check that the message was indeed received:
curl -X GET http://$APP_URL/message

# Unsubscribe the application from the topic "test"
curl -X DELETE http://$APP_URL/subscription/test