Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF 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.apache.flink.streaming.connectors.rabbitmq.common; import com.rabbitmq.client.ConnectionFactory; import org.apache.flink.util.Preconditions; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.Serializable; import java.net.URISyntaxException; import java.security.KeyManagementException; import java.security.NoSuchAlgorithmException; /** * Connection Configuration for RMQ. * If {@link Builder#setUri(String)} has been set then {@link RMQConnectionConfig#RMQConnectionConfig(String, Integer, * Boolean, Boolean, Integer, Integer, Integer, Integer)} * will be used for initialize the RMQ connection or * {@link RMQConnectionConfig#RMQConnectionConfig(String, Integer, String, String, String, Integer, Boolean, * Boolean, Integer, Integer, Integer, Integer)} * will be used for initialize the RMQ connection */ public class RMQConnectionConfig implements Serializable { private static final long serialVersionUID = 1L; private static final Logger LOG = LoggerFactory.getLogger(RMQConnectionConfig.class); private String host; private Integer port; private String virtualHost; private String username; private String password; private String uri; private Integer networkRecoveryInterval; private Boolean automaticRecovery; private Boolean topologyRecovery; private Integer connectionTimeout; private Integer requestedChannelMax; private Integer requestedFrameMax; private Integer requestedHeartbeat; /** * * @param host host name * @param port port * @param virtualHost virtual host * @param username username * @param password password * @param networkRecoveryInterval connection recovery interval in milliseconds * @param automaticRecovery if automatic connection recovery * @param topologyRecovery if topology recovery * @param connectionTimeout connection timeout * @param requestedChannelMax requested maximum channel number * @param requestedFrameMax requested maximum frame size * @param requestedHeartbeat requested heartbeat interval * @throws NullPointerException if host or virtual host or username or password is null */ private RMQConnectionConfig(String host, Integer port, String virtualHost, String username, String password, Integer networkRecoveryInterval, Boolean automaticRecovery, Boolean topologyRecovery, Integer connectionTimeout, Integer requestedChannelMax, Integer requestedFrameMax, Integer requestedHeartbeat) { Preconditions.checkNotNull(host, "host can not be null"); Preconditions.checkNotNull(port, "port can not be null"); Preconditions.checkNotNull(virtualHost, "virtualHost can not be null"); Preconditions.checkNotNull(username, "username can not be null"); Preconditions.checkNotNull(password, "password can not be null"); this.host = host; this.port = port; this.virtualHost = virtualHost; this.username = username; this.password = password; this.networkRecoveryInterval = networkRecoveryInterval; this.automaticRecovery = automaticRecovery; this.topologyRecovery = topologyRecovery; this.connectionTimeout = connectionTimeout; this.requestedChannelMax = requestedChannelMax; this.requestedFrameMax = requestedFrameMax; this.requestedHeartbeat = requestedHeartbeat; } /** * * @param uri the connection URI * @param networkRecoveryInterval connection recovery interval in milliseconds * @param automaticRecovery if automatic connection recovery * @param topologyRecovery if topology recovery * @param connectionTimeout connection timeout * @param requestedChannelMax requested maximum channel number * @param requestedFrameMax requested maximum frame size * @param requestedHeartbeat requested heartbeat interval * @throws NullPointerException if URI is null */ private RMQConnectionConfig(String uri, Integer networkRecoveryInterval, Boolean automaticRecovery, Boolean topologyRecovery, Integer connectionTimeout, Integer requestedChannelMax, Integer requestedFrameMax, Integer requestedHeartbeat) { Preconditions.checkNotNull(uri, "Uri can not be null"); this.uri = uri; this.networkRecoveryInterval = networkRecoveryInterval; this.automaticRecovery = automaticRecovery; this.topologyRecovery = topologyRecovery; this.connectionTimeout = connectionTimeout; this.requestedChannelMax = requestedChannelMax; this.requestedFrameMax = requestedFrameMax; this.requestedHeartbeat = requestedHeartbeat; } /** @return the host to use for connections */ public String getHost() { return host; } /** @return the port to use for connections */ public int getPort() { return port; } /** * Retrieve the virtual host. * @return the virtual host to use when connecting to the broker */ public String getVirtualHost() { return virtualHost; } /** * Retrieve the user name. * @return the AMQP user name to use when connecting to the broker */ public String getUsername() { return username; } /** * Retrieve the password. * @return the password to use when connecting to the broker */ public String getPassword() { return password; } /** * Retrieve the URI. * @return the connection URI when connecting to the broker */ public String getUri() { return uri; } /** * Returns automatic connection recovery interval in milliseconds. * @return how long will automatic recovery wait before attempting to reconnect, in ms; default is 5000 */ public Integer getNetworkRecoveryInterval() { return networkRecoveryInterval; } /** * Returns true if automatic connection recovery is enabled, false otherwise * @return true if automatic connection recovery is enabled, false otherwise */ public Boolean isAutomaticRecovery() { return automaticRecovery; } /** * Returns true if topology recovery is enabled, false otherwise * @return true if topology recovery is enabled, false otherwise */ public Boolean isTopologyRecovery() { return topologyRecovery; } /** * Retrieve the connection timeout. * @return the connection timeout, in milliseconds; zero for infinite */ public Integer getConnectionTimeout() { return connectionTimeout; } /** * Retrieve the requested maximum channel number * @return the initially requested maximum channel number; zero for unlimited */ public Integer getRequestedChannelMax() { return requestedChannelMax; } /** * Retrieve the requested maximum frame size * @return the initially requested maximum frame size, in octets; zero for unlimited */ public Integer getRequestedFrameMax() { return requestedFrameMax; } /** * Retrieve the requested heartbeat interval. * @return the initially requested heartbeat interval, in seconds; zero for none */ public Integer getRequestedHeartbeat() { return requestedHeartbeat; } /** * * @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; } /** * The Builder Class for {@link RMQConnectionConfig} */ public static class Builder { private String host; private Integer port; private String virtualHost; private String username; private String password; private Integer networkRecoveryInterval; private Boolean automaticRecovery; private Boolean topologyRecovery; private Integer connectionTimeout; private Integer requestedChannelMax; private Integer requestedFrameMax; private Integer requestedHeartbeat; private String uri; /** * Set the target port. * @param port the default port to use for connections * @return the Builder */ public Builder setPort(int port) { this.port = port; return this; } /** @param host the default host to use for connections * @return the Builder */ public Builder setHost(String host) { this.host = host; return this; } /** * Set the virtual host. * @param virtualHost the virtual host to use when connecting to the broker * @return the Builder */ public Builder setVirtualHost(String virtualHost) { this.virtualHost = virtualHost; return this; } /** * Set the user name. * @param username the AMQP user name to use when connecting to the broker * @return the Builder */ public Builder setUserName(String username) { this.username = username; return this; } /** * Set the password. * @param password the password to use when connecting to the broker * @return the Builder */ public Builder setPassword(String password) { this.password = password; return this; } /** * Convenience method for setting the fields in an AMQP URI: host, * port, username, password and virtual host. If any part of the * URI is ommited, the ConnectionFactory's corresponding variable * is left unchanged. * @param uri is the AMQP URI containing the data * @return the Builder */ public Builder setUri(String uri) { this.uri = uri; return this; } /** * Enables or disables topology recovery * @param topologyRecovery if true, enables topology recovery * @return the Builder */ public Builder setTopologyRecoveryEnabled(boolean topologyRecovery) { this.topologyRecovery = topologyRecovery; return this; } /** * Set the requested heartbeat. * @param requestedHeartbeat the initially requested heartbeat interval, in seconds; zero for none * @return the Builder */ public Builder setRequestedHeartbeat(int requestedHeartbeat) { this.requestedHeartbeat = requestedHeartbeat; return this; } /** * Set the requested maximum frame size * @param requestedFrameMax initially requested maximum frame size, in octets; zero for unlimited * @return the Builder */ public Builder setRequestedFrameMax(int requestedFrameMax) { this.requestedFrameMax = requestedFrameMax; return this; } /** * Set the requested maximum channel number * @param requestedChannelMax initially requested maximum channel number; zero for unlimited */ public Builder setRequestedChannelMax(int requestedChannelMax) { this.requestedChannelMax = requestedChannelMax; return this; } /** * Sets connection recovery interval. Default is 5000. * @param networkRecoveryInterval how long will automatic recovery wait before attempting to reconnect, in ms * @return the Builder */ public Builder setNetworkRecoveryInterval(int networkRecoveryInterval) { this.networkRecoveryInterval = networkRecoveryInterval; return this; } /** * Set the connection timeout. * @param connectionTimeout connection establishment timeout in milliseconds; zero for infinite * @return the Builder */ public Builder setConnectionTimeout(int connectionTimeout) { this.connectionTimeout = connectionTimeout; return this; } /** * Enables or disables automatic connection recovery * @param automaticRecovery if true, enables connection recovery * @return the Builder */ public Builder setAutomaticRecovery(boolean automaticRecovery) { this.automaticRecovery = automaticRecovery; return this; } /** * The Builder method * If URI is NULL we use host, port, vHost, username, password combination * to initialize connection. using {@link RMQConnectionConfig#RMQConnectionConfig(String, Integer, String, String, String, * Integer, Boolean, Boolean, Integer, Integer, Integer, Integer)} * * else URI will be used to initialize the client connection * {@link RMQConnectionConfig#RMQConnectionConfig(String, Integer, Boolean, Boolean, Integer, Integer, Integer, Integer)} * @return RMQConnectionConfig */ public RMQConnectionConfig build() { if (this.uri != null) { return new RMQConnectionConfig(this.uri, this.networkRecoveryInterval, this.automaticRecovery, this.topologyRecovery, this.connectionTimeout, this.requestedChannelMax, this.requestedFrameMax, this.requestedHeartbeat); } else { return new RMQConnectionConfig(this.host, this.port, this.virtualHost, this.username, this.password, this.networkRecoveryInterval, this.automaticRecovery, this.topologyRecovery, this.connectionTimeout, this.requestedChannelMax, this.requestedFrameMax, this.requestedHeartbeat); } } } }