Java AsynchronousSocketChannel.close方法代码示例

import java.nio.channels.AsynchronousSocketChannel; //导入方法依赖的package包/类
@SuppressWarnings("resource")
public void startClient(SocketAddress addr, Object attachment, AsynchronousChannelGroup group)
{
	AsynchronousSocketChannel channel = null;
	try
	{
		channel = AsynchronousSocketChannel.open(group);
		int recvBufSize = onChannelCreated(channel, attachment);
		if(recvBufSize >= 0)
			channel.connect(addr, new ConnectParam(channel, recvBufSize), _connectHandler);
		else
			channel.close();
	}
	catch(Throwable e)
	{
		doException(null, e);
		closeChannel(channel);
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入方法依赖的package包/类
private void cleanUpChannel(AsynchronousSocketChannel channel) {
	try {
		if (channel != null) {
			channel.close();
		}
	} catch (Exception e){
		// Ignore
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入方法依赖的package包/类
public void testSingleConnect() throws IOException, ExecutionException, InterruptedException, TimeoutException {
	AsynchronousSocketChannel serverConnectionChannel = null;
	try {
		assertNotNull(serverAddress);

		serverConnectionChannel = AsynchronousSocketChannel.open();
		serverConnectionChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
		
		// Ensure we have have returned an open connection
		assertNotNull(serverConnectionChannel);
		assertTrue("Channel is not open", serverConnectionChannel.isOpen());

		// Blocking connect
		Future<Void> future = serverConnectionChannel.connect(serverAddress);
		future.get(getTimeout(), TimeUnit.MILLISECONDS);
		
		// Ensure we are connected
		assertNotNull("Unable to get remote address", serverConnectionChannel.getRemoteAddress());
		
	} finally {
		if (serverConnectionChannel != null) {
			try {
				serverConnectionChannel.close();
			} catch (ClosedChannelException cce) {
				// That's ok
			}
			assertFalse("Channel was not closed", serverConnectionChannel.isOpen());
		}
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入方法依赖的package包/类
public static void onClose(AsynchronousSocketChannel asynchronousSocketChannel) throws IOException {
    outputBuffer = encodeUnmaskedFrame(1, "Connection Closed");
    outputBuffer.flip();
    outputBuffer.rewind();
    while (outputBuffer.hasRemaining()) {
        asynchronousSocketChannel.write(outputBuffer);
    }
    ByteBuffer closeBuffer = encodeUnmaskedFrame(8, "");
    closeBuffer.flip();
    while (closeBuffer.hasRemaining()) {
        asynchronousSocketChannel.write(closeBuffer);
    }
    connectionOpen = false;
    asynchronousSocketChannel.close();
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入方法依赖的package包/类
private static void closeChannel(AsynchronousSocketChannel channel) {
	if (channel == null) {
		return;
	}
	try {
		channel.close();
	} catch (IOException e) {
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入方法依赖的package包/类
@SuppressWarnings("resource")
@Override
public void completed(AsynchronousSocketChannel channel, Object attachment)
{
	beginAccept();
	TcpSession session = null;
	try
	{
		int recvBufSize = onChannelCreated(channel, attachment);
		if(recvBufSize < 0)
		{
			channel.close();
			return;
		}
		session = new TcpSession(TcpManager.this, channel, recvBufSize);
		_sessions.put(session, session);
		onSessionCreated(session);
		session.beginRecv();
	}
	catch(Throwable e)
	{
		doException(session, e);
		if(session != null)
			session.close(TcpSession.CLOSE_EXCEPTION);
		else
			closeChannel(channel);
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入方法依赖的package包/类
public void testMultipleConnectSequential() throws IOException, ExecutionException, InterruptedException, TimeoutException {
	assertNotNull(serverAddress);
	System.out.println("MultipleConnectFutureTest.testMultipleConnectSequential() creating " +
			numberOfConnections + " connections");
	for (int counter = 0; counter < numberOfConnections; counter++) {
		HangNotifier.ping();
		AsynchronousSocketChannel serverConnectionChannel = null;
		try {
			serverConnectionChannel = AsynchronousSocketChannel.open();
			serverConnectionChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
			
			// Ensure we have have returned an open connection
			assertNotNull(serverConnectionChannel);
			assertTrue("Channel is not open on iteration " + counter, serverConnectionChannel.isOpen());
	
			// Blocking connect
			Future<Void> future = serverConnectionChannel.connect(serverAddress);
			future.get(getTimeout(), TimeUnit.MILLISECONDS);
			
			// Ensure we are connected
			assertNotNull("Unable to get remote address on iteration " + counter, serverConnectionChannel.getRemoteAddress());
		} finally {
			if (serverConnectionChannel != null) {
				try {
					serverConnectionChannel.close();
				} catch (ClosedChannelException cce) {
					// That's ok
				} catch (IOException ioe) {
					throw ioe;
				}
				assertFalse("Channel was not closed on iteration " + counter, serverConnectionChannel.isOpen());
			}
		}
		
		// We can't hammer the server continuously, or we'll run out of resource.
		// Sleep before the test claims completion
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {}
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入方法依赖的package包/类
@RestMapping(name = "addnode", auth = false, comment = "动态增加指定Group的Node节点")
public RetResult addNode(@RestParam(name = "group", comment = "Group节点名") final String group,
    @RestParam(name = "addr", comment = "节点IP") final String addr,
    @RestParam(name = "port", comment = "节点端口") final int port) throws IOException {
    InetSocketAddress address;
    try {
        address = new InetSocketAddress(addr, port);
        AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
        channel.connect(address).get(2, TimeUnit.SECONDS);  //连接超时2秒
        channel.close();
    } catch (Exception e) {
        return new RetResult(RET_TRANSPORT_ADDR_ILLEGAL, "InetSocketAddress(addr=" + addr + ", port=" + port + ") is illegal or cannot connect");
    }
    if (transportFactory.findGroupName(address) != null) return new RetResult(RET_TRANSPORT_ADDR_ILLEGAL, "InetSocketAddress(addr=" + addr + ", port=" + port + ") is exists");
    synchronized (this) {
        if (transportFactory.findGroupInfo(group) == null) {
            return new RetResult(RET_TRANSPORT_GROUP_NOT_EXISTS, "not found group (" + group + ")");
        }
        transportFactory.addGroupInfo(group, address);
        for (Service service : transportFactory.getServices()) {
            if (!Sncp.isSncpDyn(service)) continue;
            SncpClient client = Sncp.getSncpClient(service);
            if (Sncp.isRemote(service)) {
                if (client.getRemoteGroups() != null && client.getRemoteGroups().contains(group)) {
                    client.getRemoteGroupTransport().addRemoteAddresses(address);
                }
            } else {
                if (group.equals(client.getSameGroup())) {
                    client.getSameGroupTransport().addRemoteAddresses(address);
                }
                if (client.getDiffGroups() != null && client.getDiffGroups().contains(group)) {
                    for (Transport transport : client.getDiffGroupTransports()) {
                        transport.addRemoteAddresses(address);
                    }
                }
            }
        }
        DefaultAnyValue node = DefaultAnyValue.create("addr", addr).addValue("port", port);
        for (AnyValue groupconf : application.getAppConfig().getAnyValue("resources").getAnyValues("group")) {
            if (group.equals(groupconf.getValue("name"))) {
                ((DefaultAnyValue) groupconf).addValue("node", node);
                break;
            }
        }
        application.restoreConfig();
    }
    return RetResult.success();
}