Java tutorial
/* * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. * * WSO2 Inc. licenses this file to you under the Apache License, * Version 2.0 (the "License"); you may not use this file except * in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.wso2.carbon.transport.jms.factory; import org.apache.commons.pool2.KeyedPooledObjectFactory; import org.apache.commons.pool2.PooledObject; import org.apache.commons.pool2.impl.DefaultPooledObject; import org.apache.commons.pool2.impl.GenericKeyedObjectPool; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.wso2.carbon.transport.jms.exception.JMSConnectorException; import org.wso2.carbon.transport.jms.utils.JMSConstants; import java.util.Properties; import java.util.concurrent.ConcurrentHashMap; import javax.jms.Connection; import javax.jms.JMSException; import javax.jms.QueueConnection; import javax.jms.Session; import javax.jms.TopicConnection; /** * JMS Connection Factory which pools connections for better performance. */ public class PooledJMSConnectionFactory extends JMSConnectionFactory implements KeyedPooledObjectFactory<PooledConnectionKey, Connection> { private static final Logger log = LoggerFactory.getLogger(PooledJMSConnectionFactory.class); private GenericKeyedObjectPool<PooledConnectionKey, Connection> keyedObjectPool = new GenericKeyedObjectPool<>( this); private ConcurrentHashMap<Connection, PooledConnectionKey> connectionKeyMap = new ConcurrentHashMap<>(); public PooledJMSConnectionFactory(Properties properties) throws JMSConnectorException { super(properties); Object maxConcurrentConnections = properties.get(JMSConstants.MAX_CONNECTIONS); if (maxConcurrentConnections != null) { keyedObjectPool.setMaxTotal(Integer.parseInt((String) maxConcurrentConnections)); } } @Override public Connection createConnection() throws JMSException { PooledConnectionKey key = new PooledConnectionKey(null, null); Connection connection; try { connection = keyedObjectPool.borrowObject(key); if (!validateObject(key, new DefaultPooledObject<>(connection))) { keyedObjectPool.invalidateObject(key, connection); throw new JMSException("Could not create a valid connection"); } return connection; } catch (Exception e) { throw new JMSException("Error occurred creating connection : " + e.getMessage()); } } @Override public Connection createConnection(String userName, String password) throws JMSException { PooledConnectionKey key = new PooledConnectionKey(userName, password); try { return keyedObjectPool.borrowObject(key); } catch (Exception e) { throw new JMSException("Error occurred creating connection : " + e.getMessage()); } } @Override public QueueConnection createQueueConnection() throws JMSException { return (QueueConnection) createConnection(); } @Override public QueueConnection createQueueConnection(String userName, String password) throws JMSException { return (QueueConnection) createConnection(userName, password); } @Override public TopicConnection createTopicConnection() throws JMSException { return (TopicConnection) createConnection(); } @Override public TopicConnection createTopicConnection(String userName, String password) throws JMSException { return (TopicConnection) createConnection(userName, password); } @Override public void closeConnection(Connection connection) throws JMSConnectorException { PooledConnectionKey key = connectionKeyMap.get(connection); if (key != null) { try { keyedObjectPool.returnObject(key, connection); } catch (Exception e) { throw new JMSConnectorException("Failed to return the connection back to the pool", e); } } } // PooledObjectFactory implementations /** * This is invoked when a new connection object has to be made. * * @param key The connection key * @return Wrapped connection object * @throws Exception Any exception thrown when creating a JMS connection will be thrown */ @Override public PooledObject<Connection> makeObject(PooledConnectionKey key) throws Exception { Connection connection; String username = key.getUsername(); String password = key.getPassword(); if (username == null && password == null) { connection = super.createConnection(); } else { connection = super.createConnection(key.getUsername(), key.getPassword()); } connectionKeyMap.put(connection, key); return new DefaultPooledObject<>(connection); } /** * This is called when an connection object is invalidated. * * @param key The connection key * @param pooledConnectionObject The invalidated wrapped connection object. * @throws Exception Any exception thrown when closing a JMS connection will be thrown */ @Override public void destroyObject(PooledConnectionKey key, PooledObject<Connection> pooledConnectionObject) throws Exception { Connection connection = pooledConnectionObject.getObject(); connectionKeyMap.remove(connection); connection.close(); } /** * Validates a connection object and verifies it can be used further. * * @param key The connection key * @param pooledConnectionObject The wrapped connection object * @return True if the object is valid */ @Override public boolean validateObject(PooledConnectionKey key, PooledObject<Connection> pooledConnectionObject) { boolean valid = false; try { Session session = pooledConnectionObject.getObject().createSession(false, Session.AUTO_ACKNOWLEDGE); session.close(); valid = true; } catch (JMSException e) { log.warn("Connection with key " + key.hashCode() + " is not valid anymore"); } return valid; } /** * Activates a suspended connection. * * @param key The connection key * @param pooledConnectionObject Wrapped suspended connection object. * @throws Exception Any exception thrown when starting a JMS connection will be thrown */ @Override public void activateObject(PooledConnectionKey key, PooledObject<Connection> pooledConnectionObject) throws Exception { pooledConnectionObject.getObject().start(); } /** * Suspend a connection. * * @param key The connection key * @param pooledConnectionObject The wrapped connection object that needs to be suspended. * @throws Exception Any exception thrown when stopping a JMS connection will be thrown */ @Override public void passivateObject(PooledConnectionKey key, PooledObject<Connection> pooledConnectionObject) throws Exception { pooledConnectionObject.getObject().stop(); } }