Java ConnectionFactory.setAutomaticRecoveryEnabled方法代码示例

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
static ConnectionProvider create(final RabbitMqConfig config, final DefaultSslConfigurator sslConfigurator) {
    final ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setUsername(config.username());
    connectionFactory.setPassword(config.password());
    connectionFactory.setVirtualHost(config.virtualHost());
    connectionFactory.setAutomaticRecoveryEnabled(config.networkRecoveryEnabled());
    connectionFactory.setTopologyRecoveryEnabled(config.topologyRecoveryEnabled());
    connectionFactory.setConnectionTimeout((int) config.connectionTimeout().toMillis());
    connectionFactory.setHandshakeTimeout((int) config.handshakeTimeout().toMillis());
    connectionFactory.setShutdownTimeout((int) config.shutdownTimeout().toMillis());
    connectionFactory.setNetworkRecoveryInterval(config.networkRecoveryInterval().toMillis());
    connectionFactory.setRequestedHeartbeat((int) config.heartbeat().getSeconds());
    connectionFactory.setRequestedChannelMax(config.channelLimit());
    connectionFactory.setRequestedFrameMax(config.frameSizeLimit());
    if (config.nonBlockingIoEnabled()) {
        connectionFactory.useNio();
    } else {
        connectionFactory.useBlockingIo();
    }
    if (config.sslEnabled()) {
        sslConfigurator.configure(connectionFactory, config);
    }
    return new RabbitConnectionProvider(config, connectionFactory);
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
/**
 * 注册主机
 * 
 * @param hostPort
 */
private synchronized static void registerFactory(String hostPort) {
	if (hostPort == null || hostPort.isEmpty())
		return;
	if (!hostPort.contains(":"))
		return;

	String[] params = hostPort.split(":");
	if (params.length != 2) {
		logger.warn("hostPort illegal, length is not 2");
		return;
	}
	logger.info("registering new factory [" + hostPort + "] ...");
	ConnectionFactory factory = new ConnectionFactory();
	factory.setHost(params[0]);
	factory.setPort(Integer.valueOf(params[1]));
	factory.setAutomaticRecoveryEnabled(automaticRecovery);
	factory.setNetworkRecoveryInterval(networkRecoveryInterval);
	factory.setUsername(userName);
	factory.setPassword(password);
	ConnectionFactoryManager.getInstance().register(hostPort, factory);
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
private ConnectionFactory createConnectionFactory() throws IOException {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setUsername(this.config.getUsername());
    factory.setPassword(this.config.getPassword());
    factory.setVirtualHost(this.config.getVirtualHost());

    factory.setAutomaticRecoveryEnabled(true);
    factory.setConnectionTimeout(this.config.getConnectionTimeout());
    factory.setNetworkRecoveryInterval(this.config.getNetworkRecoveryInterval());

    if (this.threadFactory != null) {
        factory.setThreadFactory(this.threadFactory);
    }

    return factory;
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
private void init() throws IOException {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setAutomaticRecoveryEnabled(true);
    factory.setHost(this.server);
    if (this.port > 0) factory.setPort(this.port);
    if (this.username != null && this.username.length() > 0) factory.setUsername(this.username);
    if (this.password != null && this.password.length() > 0) factory.setPassword(this.password);
    try {
        this.connection = factory.newConnection();
        //Map<String, Object> map = this.connection.getServerProperties();
        if (!this.connection.isOpen()) throw new IOException("no connection");
        this.channel = connection.createChannel();
        if (!this.channel.isOpen()) throw new IOException("no channel");
        this.queues = new ConcurrentHashMap<>();
    } catch (TimeoutException e) {
        throw new IOException(e.getMessage());
    }
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
private void setupConnectionFactory(ConnectionFactory factory) {
    String uri = "localhost";
    try {
        factory.setAutomaticRecoveryEnabled(false);
        factory.setHost(uri);
        factory.setPassword("test");
        factory.setUsername("test");
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
@Override
public void init(AbstractConfiguration config, ApplicationListenerFactory factory) {
    try {
        ConnectionFactory cf = new ConnectionFactory();
        cf.setUsername(config.getString("rabbitmq.userName", ConnectionFactory.DEFAULT_USER));
        cf.setPassword(config.getString("rabbitmq.password", ConnectionFactory.DEFAULT_PASS));
        cf.setVirtualHost(config.getString("rabbitmq.virtualHost", ConnectionFactory.DEFAULT_VHOST));
        cf.setAutomaticRecoveryEnabled(true);
        cf.setExceptionHandler(new RabbitMQExceptionHandler());
        this.conn = cf.newConnection(Address.parseAddresses(config.getString("rabbitmq.addresses")));
        this.channel = conn.createChannel();

        logger.trace("Initializing RabbitMQ application resources ...");

        APPLICATION_TOPIC = config.getString("communicator.application.topic");
        this.channel.exchangeDeclare(APPLICATION_TOPIC, "topic", true);

        logger.trace("Initializing RabbitMQ application consumer's workers ...");

        Channel consumerChan = this.conn.createChannel();
        consumerChan.queueDeclare(config.getString("rabbitmq.app.queueName"), true, false, true, null);
        consumerChan.queueBind(config.getString("rabbitmq.app.queueName"), APPLICATION_TOPIC, config.getString("rabbitmq.app.routingKey"));
        consumerChan.basicConsume(config.getString("rabbitmq.app.queueName"), true, new RabbitMQApplicationConsumer(consumerChan, factory.newListener()));

    } catch (IOException | TimeoutException e) {
        logger.error("Failed to connect to RabbitMQ servers", e);
        throw new IllegalStateException("Init RabbitMQ communicator failed");
    }
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
private ConnectionFactory initConnectionFactory() {
    ConnectionFactory factory = new ConnectionFactory();
    // TODO: pawel - Future. use SSL if vc is HTTPS
    factory.setHost(this.serverIP);
    factory.setPort(this.port);
    factory.setUsername(this.user);
    factory.setPassword(this.password);
    factory.setAutomaticRecoveryEnabled(true);
    factory.setThreadFactory(
            new ThreadFactoryBuilder().setNameFormat("RabbitMQ-Thread-Pool " + this.serverIP + " - %d").build());
    return factory;
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
@Override
public ConnectionFactory build(String config) throws Exception {
	final Context context = new ContextImpl(config);
	ConnectionFactory factory = new ConnectionFactory();
	factory.setHost(getString(context, RABBITMQ_HOST, "localhost"));
	factory.setPort(getInt(context, RABBITMQ_PORT, 5672));
	factory.setUsername(getString(context, RABBITMQ_USERNAME, null));
	factory.setPassword(getString(context, RABBITMQ_PASSWORD, null));
	factory.setConnectionTimeout(context.getInt(RABBITMQ_CONNECT_TIMEOUT, 30000));
	factory.setAutomaticRecoveryEnabled(context.getBoolean(RABBITMQ_AUTOMATIC_RECOVERY, true));
	return factory;
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
@Override
public ConnectionFactory build(String config) {
	final Context context = new ContextImpl(config);
	ConnectionFactory factory = new ConnectionFactory();
	factory.setHost(getString(context, RABBITMQ_HOST, "localhost"));
	factory.setPort(getInt(context, RABBITMQ_PORT, 5672));
	factory.setUsername(getString(context, RABBITMQ_USERNAME, null));
	factory.setPassword(getString(context, RABBITMQ_PASSWORD, null));
	factory.setConnectionTimeout(context.getInt(RABBITMQ_CONNECT_TIMEOUT, 30000));
	factory.setAutomaticRecoveryEnabled(context.getBoolean(RABBITMQ_AUTOMATIC_RECOVERY, true));
	return factory;
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
public ConnectionFactory createFactoryFor(final RabbitMQEndpoint endpoint) {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setUsername(endpoint.getUsername());
    factory.setPassword(endpoint.getPassword());
    factory.setVirtualHost(endpoint.getVhost());
    factory.setHost(endpoint.getHostname());
    factory.setPort(endpoint.getPortNumber());
    if (endpoint.getClientProperties() != null) {
        factory.setClientProperties(endpoint.getClientProperties());
    }
    factory.setConnectionTimeout(endpoint.getConnectionTimeout());
    factory.setRequestedChannelMax(endpoint.getRequestedChannelMax());
    factory.setRequestedFrameMax(endpoint.getRequestedFrameMax());
    factory.setRequestedHeartbeat(endpoint.getRequestedHeartbeat());
    if (endpoint.getSslProtocol() != null) {
        try {
            if (endpoint.getSslProtocol().equals("true")) {
                factory.useSslProtocol();
            } else if (endpoint.getTrustManager() == null) {
                factory.useSslProtocol(endpoint.getSslProtocol());
            } else {
                factory.useSslProtocol(endpoint.getSslProtocol(), endpoint.getTrustManager());
            }
        } catch (NoSuchAlgorithmException | KeyManagementException e) {
            throw new IllegalArgumentException("Invalid sslProtocol " + endpoint.getSslProtocol(), e);
        }
    }
    if (endpoint.getAutomaticRecoveryEnabled() != null) {
        factory.setAutomaticRecoveryEnabled(endpoint.getAutomaticRecoveryEnabled());
    }
    if (endpoint.getNetworkRecoveryInterval() != null) {
        factory.setNetworkRecoveryInterval(endpoint.getNetworkRecoveryInterval());
    }
    if (endpoint.getTopologyRecoveryEnabled() != null) {
        factory.setTopologyRecoveryEnabled(endpoint.getTopologyRecoveryEnabled());
    }
    return factory;
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
private synchronized Connection createConnection(ChannelType connectionType) throws ConnectionFailureException {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date startTime = new Date();
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    settings.getClient_properties().put("connection_type", connectionType.toString());
    settings.getClient_properties().put("connect_time", sdf.format(startTime)+"Z");

    ConnectionFactory cf = new ConnectionFactory();
    cf.setRequestedHeartbeat(settings.getHeartbeat());
    cf.setConnectionTimeout(settings.getConnection_timeout_millis());
    cf.setShutdownTimeout(settings.getShutdown_timeout_millis());
    cf.setRequestedFrameMax(settings.getFrame_max());
    cf.setHandshakeTimeout(settings.getHandshake_timeout_millis());
    cf.setClientProperties((Map)settings.getClient_properties());
    //cf.setSocketConfigurator(); NOTE is this worth investigating??
    cf.setRequestedChannelMax(0);//Hard coded ..
    cf.setAutomaticRecoveryEnabled(false);//Hard coded ..
    cf.setTopologyRecoveryEnabled(false);//Hard coded ..

    Exception lastException = null;
    Connection connection = null;
    for (BrokerAddresses.BrokerAddress address : addresses) {
        cf.setPassword(address.password);
        cf.setUsername(address.username);
        cf.setPort(address.port);
        cf.setHost(address.host);
        cf.setVirtualHost(address.virtualHost);
        try {
            if(address.scheme.toLowerCase().equals("amqps")){
                cf.useSslProtocol();
                cf.setSocketFactory(SSLSocketFactory.getDefault()); //Because rabbit uses NoopTrustStore by default...
            }
            log.infoWithParams("Creating "+connectionType+" connection to broker ...",
                    "address", address.toString(),
                    "settings", settings.toString());
            connection = cf.newConnection();
            boolean isOpen = connection.isOpen();
            if(!isOpen){
                continue;
            }
            break;
        } catch (Exception e) {
            log.debugWithParams("Failed to createConnection to broker",
                    "address", address.toString());
            lastException = e;
        }
    }

    if(connection == null){
        throw new ConnectionFailureException(cf, lastException);
    }

    conToChannel.put(connectionType,
            new ConnectionInfo(
                    connection,
                    new ArrayList<ChannelImpl>(),
                    settings.getClient_properties(),
                    connectionType)
    );
    log.infoWithParams("Successfully created "+connectionType+" connection to broker.",
            "address", addresses.get(0).toString(),
            "localPort", ((AMQConnection) connection).getLocalPort(),
            "settings", settings.toString());

    return connection;

}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
/**
 *
 * @return Connection Factory for RMQ
 * @throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException if Malformed URI has been passed
 */
public ConnectionFactory getConnectionFactory() throws URISyntaxException,
	NoSuchAlgorithmException, KeyManagementException {
	ConnectionFactory factory = new ConnectionFactory();
	if (this.uri != null && !this.uri.isEmpty()){
		try {
			factory.setUri(this.uri);
		} catch (URISyntaxException | NoSuchAlgorithmException | KeyManagementException e) {
			LOG.error("Failed to parse uri", e);
			throw e;
		}
	} else {
		factory.setHost(this.host);
		factory.setPort(this.port);
		factory.setVirtualHost(this.virtualHost);
		factory.setUsername(this.username);
		factory.setPassword(this.password);
	}

	if (this.automaticRecovery != null) {
		factory.setAutomaticRecoveryEnabled(this.automaticRecovery);
	}
	if (this.connectionTimeout != null) {
		factory.setConnectionTimeout(this.connectionTimeout);
	}
	if (this.networkRecoveryInterval != null) {
		factory.setNetworkRecoveryInterval(this.networkRecoveryInterval);
	}
	if (this.requestedHeartbeat != null) {
		factory.setRequestedHeartbeat(this.requestedHeartbeat);
	}
	if (this.topologyRecovery != null) {
		factory.setTopologyRecoveryEnabled(this.topologyRecovery);
	}
	if (this.requestedChannelMax != null) {
		factory.setRequestedChannelMax(this.requestedChannelMax);
	}
	if (this.requestedFrameMax != null) {
		factory.setRequestedFrameMax(this.requestedFrameMax);
	}

	return factory;
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
/**
 * initialize rabbit mq listener
 * 
 * @param builder properties to init channel.
 * @throws Exception if failed.
 */
public RmqChannel(Rmq.Builder builder) throws Exception {

  final ConnectionFactory factory = new ConnectionFactory();

  factory.setHost(builder.host());

  if (builder.port() != -1) {
    factory.setPort(builder.port());
  }

  factory.setConnectionTimeout(builder.timeout());

  factory.setAutomaticRecoveryEnabled(builder.autoRecovery());
  factory.setNetworkRecoveryInterval(builder.networkRecoveryInterval());

  if (builder.credentials() != null && builder.credentials() instanceof BasicCredentials) {
    BasicCredentials basic = (BasicCredentials) builder.credentials();
    factory.setUsername(basic.username());
    factory.setPassword(basic.password());
  }


  this.connection = factory.newConnection();
  this.channel = connection.createChannel();

}