java.nio.channels.ServerSocketChannel Java Examples

public static void main(String[] args) throws Exception {

        boolean keepAlive = false;
        String prop = System.getProperty("com.sun.CORBA.transport.enableTcpKeepAlive");
        if (prop != null)
            keepAlive = !"false".equalsIgnoreCase(prop);

        DefaultSocketFactoryImpl sfImpl = new DefaultSocketFactoryImpl();
        ORBImpl orb = new ORBImpl();
        orb.set_parameters(null);
        sfImpl.setORB(orb);

        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress(0));

        InetSocketAddress isa = new InetSocketAddress("localhost", ssc.socket().getLocalPort());
        Socket s = sfImpl.createSocket("ignore", isa);
        System.out.println("Received factory socket" + s);
        if (keepAlive != s.getKeepAlive())
            throw new RuntimeException("KeepAlive value not honoured in CORBA socket");
    }
 

public static void main(String[] args) throws Exception {

        boolean keepAlive = false;
        String prop = System.getProperty("com.sun.CORBA.transport.enableTcpKeepAlive");
        if (prop != null)
            keepAlive = !"false".equalsIgnoreCase(prop);

        DefaultSocketFactoryImpl sfImpl = new DefaultSocketFactoryImpl();
        ORBImpl orb = new ORBImpl();
        orb.set_parameters(null);
        sfImpl.setORB(orb);

        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress(0));

        InetSocketAddress isa = new InetSocketAddress("localhost", ssc.socket().getLocalPort());
        Socket s = sfImpl.createSocket("ignore", isa);
        System.out.println("Received factory socket" + s);
        if (keepAlive != s.getKeepAlive())
            throw new RuntimeException("KeepAlive value not honoured in CORBA socket");
    }
 

public static void main(String args[]) throws Exception {
    InetAddress iaddr = InetAddress.getLocalHost();

    try ( ServerSocket ss = new ServerSocket(0);
          Socket s1 = new Socket(iaddr, ss.getLocalPort());
          Socket s2 = ss.accept() ) {

        test(s1, s2, "Testing NET");
    }

    // check the NIO socket adapter
    try (ServerSocketChannel sc = ServerSocketChannel.open().bind(null);
         SocketChannel s1 = SocketChannel.open(
                 new InetSocketAddress(iaddr, sc.socket().getLocalPort()));
         SocketChannel s2 = sc.accept() ) {

        test(s1.socket(), s2.socket(), "Testing NIO");
    }

    if (failed) {
        throw new RuntimeException("Failed: check output");
    }
}
 

/**
 * Initialize the selector
 * @return The selector we'll be monitoring
 * @throws IOException When the selector can't be created (Usually when the port is already in use)
 */
private Selector initSelector() throws IOException {
	// Create a new selector
	Selector socketSelector = SelectorProvider.provider().openSelector();

	// Create a new non-blocking server socket channel
	this.serverChannel = ServerSocketChannel.open();
	serverChannel.configureBlocking(false);

	// Bind the server socket to the specified address and port
	InetSocketAddress isa = new InetSocketAddress(this.port);
	serverChannel.socket().bind(isa);

	// Register the server socket channel, indicating an interest in
	// accepting new connections
	serverChannel.register(socketSelector, SelectionKey.OP_ACCEPT);

	log.info("Listening on port " + this.port + "...");

	return socketSelector;
}
 

private static void handleNewConnection(
    SSLContext sslContext, Selector selector, ServerSocketChannel serverChannel)
    throws IOException {
  // accept new connection
  SocketChannel rawChannel = serverChannel.accept();
  rawChannel.configureBlocking(false);

  // wrap raw channel in TlsChannel
  TlsChannel tlsChannel =
      ServerTlsChannel.newBuilder(rawChannel, sslContext).withRunTasks(false).build();

  /*
   * Wrap raw channel with a TlsChannel. Note that the raw channel is registered in the selector
   * and the TlsChannel put as an attachment register the channel for reading, because TLS
   * connections are initiated by clients.
   */
  SelectionKey newKey = rawChannel.register(selector, SelectionKey.OP_READ);
  newKey.attach(tlsChannel);
}
 

public static void main(String args[]) throws Exception {
    InetAddress iaddr = InetAddress.getLocalHost();

    try ( ServerSocket ss = new ServerSocket(0);
          Socket s1 = new Socket(iaddr, ss.getLocalPort());
          Socket s2 = ss.accept() ) {

        test(s1, s2, "Testing NET");
    }

    // check the NIO socket adapter
    try (ServerSocketChannel sc = ServerSocketChannel.open().bind(null);
         SocketChannel s1 = SocketChannel.open(
                 new InetSocketAddress(iaddr, sc.socket().getLocalPort()));
         SocketChannel s2 = sc.accept() ) {

        test(s1.socket(), s2.socket(), "Testing NIO");
    }

    if (failed) {
        throw new RuntimeException("Failed: check output");
    }
}
 

@Override
public void start(int port) throws IOException {
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.bind(new InetSocketAddress("0.0.0.0", port));
    serverSocketChannel.configureBlocking(false);

    acceptReactor = new Reactor();
    acceptReactor.start();

    subReactors = new Reactor[5];
    for (int i = 0; i < subReactors.length; i++) {
        subReactors[i] = new Reactor();
        subReactors[i].start();
    }

    Acceptor acceptor = new Acceptor(subReactors);
    acceptReactor.register(serverSocketChannel, SelectionKey.OP_ACCEPT, acceptor);

}
 

/**
 * Creates a port listening server socket
 */
public GfxdTServerSocket(InetSocketAddress bindAddress, boolean blocking,
    boolean clientBlocking, SocketParameters params)
    throws TTransportException {
  this.clientBlocking = clientBlocking;
  this.socketParams = params;
  try {
    // Make server socket
    this.serverSockChannel = ServerSocketChannel.open();
    this.serverSockChannel.configureBlocking(blocking);
    ServerSocket socket = this.serverSockChannel.socket();
    // Prevent 2MSL delay problem on server restarts
    socket.setReuseAddress(true);
    // Bind to listening port
    socket.bind(bindAddress);
  } catch (IOException ioe) {
    throw new TTransportException(TTransportException.NOT_OPEN,
        "Could not bind to host:port " + bindAddress.toString(), ioe);
  }
}
 

public static void main(String args[]) throws Exception {
    InetAddress iaddr = InetAddress.getLocalHost();

    try ( ServerSocket ss = new ServerSocket(0);
          Socket s1 = new Socket(iaddr, ss.getLocalPort());
          Socket s2 = ss.accept() ) {

        test(s1, s2, "Testing NET");
    }

    // check the NIO socket adapter
    try (ServerSocketChannel sc = ServerSocketChannel.open().bind(null);
         SocketChannel s1 = SocketChannel.open(
                 new InetSocketAddress(iaddr, sc.socket().getLocalPort()));
         SocketChannel s2 = sc.accept() ) {

        test(s1.socket(), s2.socket(), "Testing NIO");
    }

    if (failed) {
        throw new RuntimeException("Failed: check output");
    }
}
 

private void init() {

        ServerSocketChannel socketChannel = processor.javaChannel();

        ServerSocket javaSocket = socketChannel.socket();

        try {
            if (serverConfig.getReceiveBufferSize() != null) {
                javaSocket.setReceiveBufferSize(serverConfig.getReceiveBufferSize());
            }
            if (serverConfig.getReuseAddress() != null) {
                javaSocket.setReuseAddress(serverConfig.getReuseAddress());
            }
        } catch (SocketException e) {
            throw new NioException("config channel error:" + e.getMessage(), e);
        }
    }
 

/**
 * Creates a port listening server socket
 */
public GfxdTServerSocket(InetSocketAddress bindAddress, boolean blocking,
    boolean clientBlocking, SocketParameters params)
    throws TTransportException {
  this.clientBlocking = clientBlocking;
  this.socketParams = params;
  try {
    // Make server socket
    this.serverSockChannel = ServerSocketChannel.open();
    this.serverSockChannel.configureBlocking(blocking);
    ServerSocket socket = this.serverSockChannel.socket();
    // Prevent 2MSL delay problem on server restarts
    socket.setReuseAddress(true);
    // Bind to listening port
    socket.bind(bindAddress);
  } catch (IOException ioe) {
    throw new TTransportException(TTransportException.NOT_OPEN,
        "Could not bind to host:port " + bindAddress.toString(), ioe);
  }
}
 

private void handSelectionKeyException(final SelectionKey selectionKey,Exception e){
	SelectableChannel channel = selectionKey.channel();
	if(channel instanceof ServerSocketChannel){
		RpcNioAcceptor acceptor = acceptorCache.get(channel);
		if(acceptor!=null){
			logger.error("acceptor "+acceptor.getHost()+":"+acceptor.getPort()+" selection error "+e.getClass()+" "+e.getMessage()+" start to shutdown");
			this.fireNetListeners(acceptor, e);
			acceptor.stopService();
		}
	}else{
		RpcNioConnector connector = connectorCache.get(channel);
		if(connector!=null){
			logger.error("connector "+connector.getHost()+":"+connector.getPort()+" selection error "+e.getClass()+" "+e.getMessage()+" start to shutdown");
			this.fireNetListeners(connector, e);
			connector.stopService();
		}
	}
	this.logState();
}
 

public static void main(String args[]) throws Exception {
    InetAddress iaddr = InetAddress.getLocalHost();

    try ( ServerSocket ss = new ServerSocket(0);
          Socket s1 = new Socket(iaddr, ss.getLocalPort());
          Socket s2 = ss.accept() ) {

        test(s1, s2, "Testing NET");
    }

    // check the NIO socket adapter
    try (ServerSocketChannel sc = ServerSocketChannel.open().bind(null);
         SocketChannel s1 = SocketChannel.open(
                 new InetSocketAddress(iaddr, sc.socket().getLocalPort()));
         SocketChannel s2 = sc.accept() ) {

        test(s1.socket(), s2.socket(), "Testing NIO");
    }

    if (failed) {
        throw new RuntimeException("Failed: check output");
    }
}
 

public static void main(String[] args) throws Exception {

        boolean keepAlive = false;
        String prop = System.getProperty("com.sun.CORBA.transport.enableTcpKeepAlive");
        if (prop != null)
            keepAlive = !"false".equalsIgnoreCase(prop);

        DefaultSocketFactoryImpl sfImpl = new DefaultSocketFactoryImpl();
        ORBImpl orb = new ORBImpl();
        orb.set_parameters(null);
        sfImpl.setORB(orb);

        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress(0));

        InetSocketAddress isa = new InetSocketAddress("localhost", ssc.socket().getLocalPort());
        Socket s = sfImpl.createSocket("ignore", isa);
        System.out.println("Received factory socket" + s);
        if (keepAlive != s.getKeepAlive())
            throw new RuntimeException("KeepAlive value not honoured in CORBA socket");
    }
 

/**
 * @tests SocketChannel#read(ByteBuffer[], int, int) when remote server
 *        closed
 */
public void test_socketChannel_read_ByteBufferII_remoteClosed()
        throws Exception {
    // regression 1 for HARMONY-549
    ServerSocketChannel ssc = ServerSocketChannel.open();
    ssc.socket().bind(null);
    SocketChannel sc = SocketChannel.open();
    sc.connect(ssc.socket().getLocalSocketAddress());
    ssc.accept().close();
    ByteBuffer[] buf = { ByteBuffer.allocate(10) };
    assertEquals(-1, sc.read(buf, 0, 1));
    ssc.close();
    sc.close();
}
 

public void restart() throws IOException {
    server.close();
    selector.selectNow();
    server = ServerSocketChannel.open();
    server.configureBlocking(false);
    server.socket().setReuseAddress(true);
    server.socket().bind(srcAddr);
    server.register(selector, SelectionKey.OP_ACCEPT);
    bridge.clear();
}
 

TcpAcceptor(
    TcpCrusher crusher,
    NioReactor reactor,
    InetSocketAddress bindAddress,
    InetSocketAddress connectAddress,
    InetSocketAddress bindBeforeConnectAddress,
    TcpCrusherSocketOptions socketOptions,
    TcpFilters filters,
    BufferOptions bufferOptions) throws IOException
{
    this.crusher = crusher;
    this.bindAddress = bindAddress;
    this.connectAddress = connectAddress;
    this.bindBeforeConnectAddress = bindBeforeConnectAddress;
    this.socketOptions = socketOptions;
    this.reactor = reactor;
    this.bufferOptions = bufferOptions;
    this.filters = filters;
    this.totalAccepted = new AtomicInteger(0);

    this.serverSocketChannel = ServerSocketChannel.open();
    this.serverSocketChannel.configureBlocking(false);
    this.serverSocketChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);

    if (socketOptions.getBacklog() > 0) {
        this.serverSocketChannel.bind(bindAddress, socketOptions.getBacklog());
    } else {
        this.serverSocketChannel.bind(bindAddress);
    }

    this.serverSelectionKey = reactor.getSelector()
        .register(serverSocketChannel, 0, (selectionKey) -> this.accept());

    this.state = new State(State.FROZEN);
}
 

public static void main(String[] args) throws IOException {
   ServerSocketChannel server = ServerSocketChannel.open();
   server.bind(new InetSocketAddress("127.0.0.1", 5557));
   while (true) {
      SocketChannel client = server.accept();
      new Thread(new Client(client)).start();
   }
}
 

@Override
public ClientListener getClientConnection(SocketChannel sc, ServerSocketChannel ssc)
{
  ClientListener client;
  if (authToken == null) {
    client = new UnidentifiedClient();
  } else {
    AuthClient authClient = new AuthClient();
    authClient.setToken(authToken);
    client = authClient;
  }
  return client;
}
 

private ServerSocketChannelThread(String name) {
    super(name);
    try {
        ssc = ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress((0)));
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
}
 

/**
 * @return Local socket channel, used for accepting the incoming connections
 */
private ServerSocketChannel getServerChannel() throws IOException {
    if (serverChannel == null) {
        ServerSocketChannel _serverChannel = selector.provider().openServerSocketChannel();
        _serverChannel.bind(localAddress);
        _serverChannel.configureBlocking(true);
        serverChannel = _serverChannel;
        LOGGER.info("Opening server channel for incoming connections @ {}", localAddress);
    }
    return serverChannel;
}
 

private void doInitSocketServerTcp() throws IOException {
    dirtyServerTcp = ServerSocketChannel.open();
    dirtyServerTcp.configureBlocking(false);

    // Bind the server socket to the specified address and port
    InetSocketAddress isa = new InetSocketAddress(CLIENT_HOST, CLIENT_PORT);
    dirtyServerTcp.bind(isa);
}
 

private void acceptOP(SelectionKey key, Selector selector) throws IOException {

        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel socketChannel = serverChannel.accept();
        socketChannel.configureBlocking(false);

        System.out.println("Incoming connection from: " + socketChannel.getRemoteAddress());

        // write an welcome message
        socketChannel.write(ByteBuffer.wrap("Hello!\n".getBytes("UTF-8")));

        // register channel with selector for further I/O
        keepDataTrack.put(socketChannel, new ArrayList<byte[]>());
        socketChannel.register(selector, SelectionKey.OP_READ);
    }
 

public RpcNioAcceptor(AbstractRpcNioSelector selector){
	try {
		serverSocketChannel = ServerSocketChannel.open();
		serverSocketChannel.configureBlocking(false);
		this.selector = selector;
	} catch (IOException e) {
		this.handleNetException(e);
	}
}
 

private void acceptConnection( SelectionKey key ) throws IOException {
    ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();

    SocketChannel socketChannel = serverSocketChannel.accept();
    socketChannel.configureBlocking(false);
    socketChannel.register(getSelector(), SelectionKey.OP_READ);
    initWriteQueue( socketChannel.keyFor(getSelector()));
}
 

public final void openServerSocket(InetAddress address, int tcpPort) throws IOException
{
    ServerSocketChannel selectable = ServerSocketChannel.open();
    selectable.configureBlocking(false);

    ServerSocket ss = selectable.socket();
    
    if (address == null)
        ss.bind(new InetSocketAddress(tcpPort));
    else
        ss.bind(new InetSocketAddress(address, tcpPort));
    
    selectable.register(_selector, SelectionKey.OP_ACCEPT);
}
 

private ServerSocketChannelThread(String name) {
    super(name);
    try {
        ssc = ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress((0)));
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
}
 

private ConnectionResetByPeerServer(int port) {
	super(1);
	this.port = port;
	try {
		server = ServerSocketChannel.open();
	}
	catch (IOException e) {
		throw new RuntimeException(e);
	}
}
 

private ServerSocketChannelThread(String name) {
    super(name);
    try {
        ssc = ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress((0)));
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
}
 

private void start() throws Exception {
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.socket().bind(new InetSocketAddress(port));
    serverSocketChannel.configureBlocking(false);

    selector = Selector.open();
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    while (true) {
        selector.select(); // 此处的select方法是阻塞的
        // 对所有的key做一次遍历，由key本身判断此事件是否与自己有关
        selector.selectedKeys().forEach((this::handleKey));
    }
}