org.springframework.amqp.rabbit.connection.AbstractConnectionFactory.java Source code

Introduction

Here is the source code for org.springframework.amqp.rabbit.connection.AbstractConnectionFactory.java

Source

/*
 * Copyright 2002-2014 the original author or authors.
 *
 * Licensed 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.springframework.amqp.rabbit.connection;

import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.amqp.rabbit.support.RabbitExceptionTranslator;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.Assert;

import com.rabbitmq.client.Address;

/**
 * @author Dave Syer
 * @author Gary Russell
 *
 */
public abstract class AbstractConnectionFactory implements ConnectionFactory, DisposableBean {

    protected final Log logger = LogFactory.getLog(getClass());

    private final com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory;

    private final CompositeConnectionListener connectionListener = new CompositeConnectionListener();

    private final CompositeChannelListener channelListener = new CompositeChannelListener();

    private volatile ExecutorService executorService;

    private volatile Address[] addresses;

    public static final int DEFAULT_CLOSE_TIMEOUT = 30000;

    private volatile int closeTimeout = DEFAULT_CLOSE_TIMEOUT;

    /**
     * Create a new SingleConnectionFactory for the given target ConnectionFactory.
     * @param rabbitConnectionFactory the target ConnectionFactory
     */
    public AbstractConnectionFactory(com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory) {
        Assert.notNull(rabbitConnectionFactory, "Target ConnectionFactory must not be null");
        this.rabbitConnectionFactory = rabbitConnectionFactory;
    }

    public void setUsername(String username) {
        this.rabbitConnectionFactory.setUsername(username);
    }

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

    public void setHost(String host) {
        this.rabbitConnectionFactory.setHost(host);
    }

    public String getHost() {
        return this.rabbitConnectionFactory.getHost();
    }

    public void setVirtualHost(String virtualHost) {
        this.rabbitConnectionFactory.setVirtualHost(virtualHost);
    }

    public String getVirtualHost() {
        return rabbitConnectionFactory.getVirtualHost();
    }

    public void setPort(int port) {
        this.rabbitConnectionFactory.setPort(port);
    }

    public void setRequestedHeartBeat(int requestedHeartBeat) {
        this.rabbitConnectionFactory.setRequestedHeartbeat(requestedHeartBeat);
    }

    public int getPort() {
        return this.rabbitConnectionFactory.getPort();
    }

    /**
     * Set addresses for clustering.
     * @param addresses list of addresses with form "host[:port],..."
     */
    public void setAddresses(String addresses) {
        Address[] addressArray = Address.parseAddresses(addresses);
        if (addressArray.length > 0) {
            this.addresses = addressArray;
        }
    }

    /**
     * A composite connection listener to be used by subclasses when creating and closing connections.
     *
     * @return the connection listener
     */
    protected ConnectionListener getConnectionListener() {
        return connectionListener;
    }

    /**
     * A composite channel listener to be used by subclasses when creating and closing channels.
     *
     * @return the channel listener
     */
    protected ChannelListener getChannelListener() {
        return channelListener;
    }

    public void setConnectionListeners(List<? extends ConnectionListener> listeners) {
        this.connectionListener.setDelegates(listeners);
    }

    public void addConnectionListener(ConnectionListener listener) {
        this.connectionListener.addDelegate(listener);
    }

    @Override
    public boolean removeConnectionListener(ConnectionListener listener) {
        return this.connectionListener.removeDelegate(listener);
    }

    @Override
    public void clearConnectionListeners() {
        this.connectionListener.clearDelegates();
    }

    public void setChannelListeners(List<? extends ChannelListener> listeners) {
        this.channelListener.setDelegates(listeners);
    }

    public void addChannelListener(ChannelListener listener) {
        this.channelListener.addDelegate(listener);
    }

    /**
     * Provide an Executor for
     * use by the Rabbit ConnectionFactory when creating connections.
     * Can either be an ExecutorService or a Spring
     * ThreadPoolTaskExecutor, as defined by a &lt;task:executor/&gt; element.
     * @param executor The executor.
     */
    public void setExecutor(Executor executor) {
        boolean isExecutorService = executor instanceof ExecutorService;
        boolean isThreadPoolTaskExecutor = executor instanceof ThreadPoolTaskExecutor;
        Assert.isTrue(isExecutorService || isThreadPoolTaskExecutor);
        if (isExecutorService) {
            this.executorService = (ExecutorService) executor;
        } else {
            this.executorService = ((ThreadPoolTaskExecutor) executor).getThreadPoolExecutor();
        }
    }

    /**
     * How long to wait (milliseconds) for a response to a connection close
     * operation from the broker; default 30000 (30 seconds).
     *
     * @param closeTimeout the closeTimeout to set.
     */
    public void setCloseTimeout(int closeTimeout) {
        this.closeTimeout = closeTimeout;
    }

    protected final Connection createBareConnection() {
        try {
            if (this.addresses != null) {
                return new SimpleConnection(
                        this.rabbitConnectionFactory.newConnection(this.executorService, this.addresses),
                        this.closeTimeout);
            } else {
                return new SimpleConnection(this.rabbitConnectionFactory.newConnection(this.executorService),
                        this.closeTimeout);
            }
        } catch (IOException e) {
            throw RabbitExceptionTranslator.convertRabbitAccessException(e);
        }
    }

    protected final String getDefaultHostName() {
        String temp;
        try {
            InetAddress localMachine = InetAddress.getLocalHost();
            temp = localMachine.getHostName();
            logger.debug("Using hostname [" + temp + "] for hostname.");
        } catch (UnknownHostException e) {
            logger.warn("Could not get host name, using 'localhost' as default value", e);
            temp = "localhost";
        }
        return temp;
    }

    public void destroy() {
    }
}