Does DefaultMessageListenerContainer stop , shutdown close database connections?

Question

I have a DefaultMessageListenerContainer which is processing a message from the queue.

While the message is being processed -- stop , shutdown methods are called on DefaultMessageListenerContainer. Does this close database connections?

Looks like it is closing the database connections and hence the message being processed is getting interrupted from completely processing.

I see these errors :

o.s.jdbc.support.SQLErrorCodesFactory : Error while extracting database name Closed Connection; nested exception is java.sql.SQLRecoverableException: Closed Connection

could these be because the DefaultMessageListenerContainer was stopped and shutdown ?

---

My code is as follows . startStopContainer is where I am trying to stop and shutdown container. I want to shutdown container only if listener completed processing the current message. I added logic to figure out if listener completed processing .

Is the below logic the only way or is there a better way to figure out if listener completed processing. Please suggest. Thank you.

public class MyMessageConsumerFacade {
    
    private ConnectionFactory connectionFactory() {
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
        connectionFactory.setBrokerURL(url);
        connectionFactory.setUserName(userName);
        connectionFactory.setPassword(password);

        return connectionFactory;
    }

    @Bean
    public MessageListenerContainer listenerContainer() {
        
        DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
        container.setConnectionFactory(connectionFactory());
        container.setDestinationName(queueName);
        container.setMessageListener(new MyJmsListener());      
        return container;
    }
}

public class MyJmsListener implements MessageListener { 
  public boolean onMessageCompleted; 
  public void onMessage(Message message) { 
     onMessageCompleted = false; 
     processMessage(message); 
     onMessageCompleted = true; 
  } 
} 

private String startStopContainer(ExecutionContext etk)  {
        String response = "success";
        
        AnnotationConfigApplicationContext context = null;
        DefaultMessageListenerContainer myNewContainer = null;
        
        if (context == null) {
            context = new AnnotationConfigApplicationContext(MyMessageConsumerFacade.class);
        }   

        if (myNewContainer == null) {
            myNewContainer = context.getBean(DefaultMessageListenerContainer.class);
        }

        MyCaseMessageJmsListener messageJmsListener = (MyCaseMessageJmsListener) myNewContainer.getMessageListener();
        

        if (!myNewContainer.isRunning()) {// container not running
            myNewContainer.start();
        }
        
        //due to some business logic we need to stop listener every 5 minutes, so sleep for 5 minutes and then stop
        try {
            Thread.sleep(300000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
                                
        if (myNewContainer.isRunning()) {
            myNewContainer.stop();
            
        }
        
        //Before shutting down container , make sure listener processed all msgs completely
        if(!messageJmsListener.isOnMessageCompleted) {      
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if(messageJmsListener.isOnMessageCompleted) {
            myNewContainer.shutdown();
        }
        
        if (context != null) {
            context.destroy();          
        }
        
        return response;
    }    

Is there a better way than this?

Answer 1

No; the container knows nothing about JDBC or any connections thereto.

Stopping the container only stops the JMS consumer(s) the consumers from receiving messages; shutDown() on the container closes the consumer(s).

Something else is closing your JDBC connection.