import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
@Override
public void disconnect() {
    URI address = getAddress();
    if (isConnected()) {
        try {
            NetClient client = copyClient(); // Make a copy just before close
            m_client.close();
            m_client = client;
            setConnected(false);
            logger().debug("Disconnected from {}:{}",
                    address.getHost(), address.getPort());
        } catch (Exception e) {
            logger().error("Failed to disconnect from {}:{}",
                    address.getHost(), address.getPort(), e);
        }
    }
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
private static NetClient newClient(final Builder builder) {
    NetClient client = builder.m_vertx.createNetClient();
    client.setConnectTimeout((int) builder.m_connectTimeout);
    client.setTCPKeepAlive(builder.m_keepAlive);
    client.setSSL(builder.m_sslEnabled);
    if (builder.m_reconnectAttempts > 0) {
        client.setReconnectAttempts(builder.m_reconnectAttempts);
    }
    if (builder.m_reconnectInterval > 0L) {
        client.setReconnectInterval(builder.m_reconnectInterval);
    }
    if (!Strings.isNullOrEmpty(builder.m_keystorePath)) {
        client.setKeyStorePath(builder.m_keystorePath);
    }
    if (!Strings.isNullOrEmpty(builder.m_keystorePassword)) {
        client.setKeyStorePassword(builder.m_keystorePassword);
    }
    if (!Strings.isNullOrEmpty(builder.m_truststorePath)) {
        client.setTrustStorePath(builder.m_truststorePath);
    }
    if (!Strings.isNullOrEmpty(builder.m_truststorePassword)) {
        client.setTrustStorePassword(builder.m_truststorePassword);
    }
    return client;
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
void connect(Handler<Transaction> aConnectionHandler) {
	connectionHandler = aConnectionHandler;
	NetClient client = pg.vertx.createNetClient();
	// client.setReceiveBufferSize(1024);
	client.connect(pg.port, pg.host, new AsyncResultHandler<NetSocket>() {
		@Override
		public void handle(AsyncResult<NetSocket> event) {
			if (event.succeeded()) {
				socket = event.result();
				socket.dataHandler(new Handler<Buffer>() {
					@Override
					public void handle(Buffer buffer) {
						mp.parseMessages(buffer,0,buffer.length());
					}
				});
				socket.write(new Startup(new Buffer(20)).write(pg.user, pg.db, pg.applicationName + "-" + this.hashCode()));
			} else {
				connectionHandler.handle(null);
			}
		}
	});
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
/**
 * Creates a new client for the given URL and handler
 */
protected NetClient createClient(NetSocket socket, URI url, Handler<AsyncResult<NetSocket>> handler) throws MalformedURLException {
    NetClient client = vertx.createNetClient();
    int port = url.getPort();
    String host = url.getHost();
    LOG.info("Connecting " + socket.remoteAddress() + " to host " + host + " port " + port + " protocol " + protocol);
    return client.connect(port, host, handler);
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
@Override
protected NetClient copyClient() {
    return builder(getAddress(), m_vertx)
            .connectTimeout(getConnectTimeout())
            .reconnectAttempts(m_client.getReconnectAttempts())
            .reconnectInterval(m_client.getReconnectInterval())
            .keepAlive(m_client.isTCPKeepAlive())
            .sslEnabled(m_client.isSSL())
            .keystorePath(m_client.getKeyStorePath())
            .keystorePassword(m_client.getKeyStorePassword())
            .truststorePath(m_client.getTrustStorePath())
            .truststorePassword(m_client.getTrustStorePassword())
            .buildClient();
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
/**
 * Allows a subclass to configure the NetClient beyond what this transport might do.
 *
 * @throws IOException if an error occurs.
 */
protected void configureNetClient(NetClient client) throws IOException {
    client.setSendBufferSize(getSocketBufferSize());
    client.setReceiveBufferSize(getSocketBufferSize());
    client.setSoLinger(soLinger);
    client.setTCPKeepAlive(keepAlive);
    client.setTCPNoDelay(tcpNoDelay);
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
@Override
protected void configureNetClient(NetClient client) throws IOException {
    super.configureNetClient(client);

    client.setSSL(true);
    client.setKeyStorePath(context.getKeyStoreLocation());
    client.setKeyStorePassword(context.getKeyStorePassword());
    client.setTrustStorePath(context.getTrustStoreLocation());
    client.setTrustStorePassword(context.getTrustStorePassword());
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
public void route(final SocketWrapper socket, ConnectionParameters params, final Buffer received) {
    NetClient client = null;

    if( params.protocolVirtualHost==null ) {
        params.protocolVirtualHost = defaultVirtualHost;
    }
    HashSet<String> schemes = new HashSet<String>(Arrays.asList(params.protocolSchemes));
    if(params.protocolVirtualHost!=null) {
        List<ServiceDetails> services = serviceMap.getServices(params.protocolVirtualHost);

        // Lets try again with the defaultVirtualHost
        if( services.isEmpty() && !params.protocolVirtualHost.equals(defaultVirtualHost) ) {
            params.protocolVirtualHost = defaultVirtualHost;
            services = serviceMap.getServices(params.protocolVirtualHost);
        }

        if (LOG.isDebugEnabled()) LOG.debug(String.format("%d services match the virtual host", services.size()));
        if (!services.isEmpty()) {
            ClientRequestFacade clientRequestFacade = clientRequestFacadeFactory.create(socket, params);
            ServiceDetails serviceDetails = serviceLoadBalancer.choose(services, clientRequestFacade);
            if (serviceDetails != null) {
                List<String> urlStrings = serviceDetails.getServices();
                if (LOG.isDebugEnabled()) LOG.debug("Selected service exposes the following URLS: {}", urlStrings);
                for (String urlString : urlStrings) {
                    if (StringUtils.isNotEmpty(urlString)) {
                        // lets create a client for this request...
                        try {
                            URI uri = new URI(urlString);
                            //URL url = new URL(urlString);
                            String urlProtocol = uri.getScheme();
                            if (schemes.contains(urlProtocol)) {
                                if( !socket.remoteAddress().toString().equals(clientRequestFacade.getClientRequestKey())  ) {
                                    LOG.info(String.format("Connecting client from '%s' (with key '%s') requesting virtual host '%s' to '%s:%d' using the %s protocol",
                                        socket.remoteAddress(), clientRequestFacade.getClientRequestKey(), params.protocolVirtualHost, uri.getHost(), uri.getPort(), params.protocol
                                      ));
                                } else {
                                    LOG.info(String.format("Connecting client from '%s' requesting virtual host '%s' to '%s:%d' using the %s protocol",
                                        socket.remoteAddress(), params.protocolVirtualHost, uri.getHost(), uri.getPort(), params.protocol
                                      ));
                                }

                                client = createClient(params, socket, uri, received);
                                break;
                            }
                        } catch (URISyntaxException e) {
                            LOG.warn("Failed to parse URI: " + urlString + ". " + e, e);
                        }
                    }
                }
            }
        }
    }

    if (client == null) {
        // failed to route
        handleConnectFailure(socket, String.format("No endpoint available for virtual host '%s' and protocol %s", params.protocolVirtualHost, params.protocol));
    }
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
@Override
public NetClient getClient() {
    return m_client;
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
public NetClient buildClient() {
    return newClient(this);
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
public NetClientAdapter(final IConnection<NetClient> connection) {
    m_connection = connection;
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
public final IConnection<NetClient> getConnection() {
    return m_connection;
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
@Override
public NetClient createNetClient() {
  return null;
}
 

import org.vertx.java.core.net.NetClient; //导入依赖的package包/类
@Override
public NetClient createNetClient() {
    return null;
}