Java ConnectionFactory.setRequestedHeartbeat方法代码示例

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包/类
/**
 * This is called when a resource adapter instance is bootstrapped.
 *
 * @param ctx
 *            A bootstrap context containing references
 * @throws ResourceAdapterInternalException
 *             indicates bootstrap failure.
 */
public void start(BootstrapContext ctx)
		throws ResourceAdapterInternalException {
	log.tracef("start(%s)", ctx);
	this.bootstrapContext = ctx;
	rabbitCF = new ConnectionFactory();
	try {
		rabbitCF.setUri(uri);
		rabbitCF.setConnectionTimeout(getConnectionTimeout());
		rabbitCF.setRequestedHeartbeat(getRequestedHeartbeat());
	} catch (KeyManagementException | NoSuchAlgorithmException
			| URISyntaxException e) {
		throw new ResourceAdapterInternalException(e);
	}

}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
ConnectionFactory createConnectionFactory() { // package-private for testing
    ConnectionFactory rabbitMqConnectionFactory = new ConnectionFactory();
    rabbitMqConnectionFactory.setHost(rabbitMqConfig.getHost());
    rabbitMqConnectionFactory.setPort(rabbitMqConfig.getPort());
    rabbitMqConnectionFactory.setUsername(rabbitMqConfig.getUsername());
    rabbitMqConnectionFactory.setPassword(rabbitMqConfig.getPassword());
    rabbitMqConnectionFactory.setVirtualHost(rabbitMqConfig.getVirtualHost());
    rabbitMqConnectionFactory.setRequestedHeartbeat(rabbitMqConfig.getRequestedHeartbeat());
    return rabbitMqConnectionFactory;
}
 

import com.rabbitmq.client.ConnectionFactory; //导入方法依赖的package包/类
/**
 * Creates a Connection Factory instance.
 *
 * @param cxManager
 *          ConnectionManager to be associated with created EIS connection
 *          factory instance
 * @return EIS-specific Connection Factory instance or
 *         javax.resource.cci.ConnectionFactory instance
 * @throws ResourceException
 *           Generic exception
 */
public Object createConnectionFactory(ConnectionManager cxManager)
    throws ResourceException {
  log.tracef("createConnectionFactory(%s)", cxManager);
  rabbitCF = new ConnectionFactory();
  try {
    rabbitCF.setUri(uri);
    rabbitCF.setConnectionTimeout(timeout);
    rabbitCF.setRequestedHeartbeat(requestedHeartbeat);
  } catch (KeyManagementException | NoSuchAlgorithmException
      | URISyntaxException e) {
    throw new ResourceException(e);
  }
  return new RabbitmqConnectionFactoryImpl(this, cxManager);
}
 

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;
}