How to use

Socket

in

java.net

 Socket s = new Socket();

System.out.println("isConnected: " + s.isConnected() +
         " isBound: "     + s.isBound() +
         " isClosed: "    + s.isClosed());

s.connect(new InetSocketAddress("google.com", 80));

System.out.println("isConnected: " + s.isConnected() +
          " isBound: "    + s.isBound() +
          " isClosed: "   + s.isClosed());

s.close();

System.out.println("isConnected: " + s.isConnected() +
          " isBound: "    + s.isBound() +
          " isClosed: "   + s.isClosed());

private IRCClientConnection(
  StethoReporter reporter,
  Socket socket,
  String charset)
  throws IOException {
 mReporter = reporter;
 mSocket = socket;
 mInput = new BufferedReader(new InputStreamReader(socket.getInputStream(), charset));
 mOutput = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), charset));
}

/**
 * 激活网络
 */
private Socket connect(InetSocketAddress address) throws IOException {
  final Socket socket = new Socket();
  socket.setSoTimeout(0);
  socket.connect(address, _1MIN);
  socket.setKeepAlive(true);
  socketWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  socketReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  return socket;
}

private void createConnection() throws IOException {
  client = new Socket(hostName, port);
  client.setKeepAlive(true);
  client.setTcpNoDelay(true);
  outputStream = client.getOutputStream();
}

/**
 * Helper method to set socket options.
 *
 * @param sock
 *            Reference to socket
 */
private void setSockOpts(Socket sock) throws SocketException {
  sock.setTcpNoDelay(true);
  sock.setKeepAlive(tcpKeepAlive);
  sock.setSoTimeout(self.tickTime * self.syncLimit);
}

@Override
public void run() {
 try (Socket socket = new Socket(InetAddress.getLocalHost(), serverPort)) {
  OutputStream outputStream = socket.getOutputStream();
  PrintWriter writer = new PrintWriter(outputStream);
  sendLogRequests(writer, socket.getInputStream());
 } catch (IOException e) {
  LOGGER.error("error sending requests", e);
  throw new RuntimeException(e);
 }
}

BufferedReader stdIn = new BufferedReader(
    new InputStreamReader(System.in, charset));
log.info("Input some text and press RETURN to POS tag it, or just RETURN to finish.");
for (String userInput; (userInput = stdIn.readLine()) != null && ! userInput.matches("\\n?"); ) {
 try {
  Socket socket = new Socket(host, port);
  PrintWriter out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream(), charset), true);
  BufferedReader in = new BufferedReader(new InputStreamReader(
      socket.getInputStream(), charset));
  PrintWriter stdOut = new PrintWriter(new OutputStreamWriter(System.out, charset), true);
  out.println(userInput);
  in.close();
  socket.close();
 } catch (UnknownHostException e) {
  log.info("Cannot find host: ");

public void allocate() throws IOException {
  allocated = true;
  socket = new Socket(host, port);
  inReader =
    new BufferedReader(new InputStreamReader(socket.getInputStream()));
  outWriter = new PrintWriter(socket.getOutputStream(), true);
  String greeting = inReader.readLine();
  if (!greeting.equals("probserver ready")) {
    throw new IOException("Incorrect input");
  }
  cache = new LRUCache<WordSequence, Float>(1000);
}

 @Override
 public void run()
 {
  while (!Thread.currentThread().isInterrupted()) {
   try (
     Socket clientSocket = serverSocket.accept();
     BufferedReader in = new BufferedReader(
       new InputStreamReader(clientSocket.getInputStream(), StandardCharsets.UTF_8)
     );
     OutputStream out = clientSocket.getOutputStream()
   ) {
    while (!in.readLine().equals("")) {
     // skip lines
    }
    out.write("HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\nhello!".getBytes(StandardCharsets.UTF_8));
   }
   catch (Exception e) {
    // Suppress
   }
  }
 }
}

private void processRequests(ServerSocket server) throws IOException {
  Socket socket = server.accept();
  connectionsAccepted.incrementAndGet();
  try (
      BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream(), UTF_8));
      PrintWriter out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream(), UTF_8))
  ){
    synchronized (startSynchro) {
      startSynchro.notifyAll();
    }
    String line;
    while ((line = in.readLine()) != null) {
      receivedMessages.add(line);
      out.print(line);
    }
  }
}

/**
 * Listing 1.1 Blocking I/O example
 * */
public void serve(int portNumber) throws IOException {
  ServerSocket serverSocket = new ServerSocket(portNumber);
  Socket clientSocket = serverSocket.accept();
  BufferedReader in = new BufferedReader(
      new InputStreamReader(clientSocket.getInputStream()));
  PrintWriter out =
      new PrintWriter(clientSocket.getOutputStream(), true);
  String request, response;
  while ((request = in.readLine()) != null) {
    if ("Done".equals(request)) {
      break;
    }
    response = processRequest(request);
    out.println(response);
  }
}

@Test
public void testSocketSink() throws Exception {
  final ServerSocket server = new ServerSocket(0);
  final int port = server.getLocalPort();
  Socket sk = server.accept();
  BufferedReader rdr = new BufferedReader(new InputStreamReader(sk.getInputStream()));
  String value = rdr.readLine();

@BeforeClass
public void setUpGlobal() throws Exception {
 serverSocket = ServerSocketFactory.getDefault().createServerSocket(0);
 port1 = serverSocket.getLocalPort();
 executorService = Executors.newFixedThreadPool(1);
 voidFuture = executorService.submit(() -> {
   Socket socket;
   while ((socket = serverSocket.accept()) != null) {
    InputStream inputStream = socket.getInputStream();
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    String req = reader.readLine().split(" ")[1];
    int i = inputStream.available();
    long l = inputStream.skip(i);
    assertEquals(l, i);
    socket.shutdownInput();
    if (req.endsWith("MultiEnt")) {
     OutputStreamWriter outputStreamWriter = new OutputStreamWriter(socket.getOutputStream());
     outputStreamWriter.append("HTTP/1.0 200 OK\n" + "Connection: close\n" + "Content-Type: text/plain; charset=iso-8859-1\n" + "Content-Length: 2\n"
         + "Content-Length: 1\n" + "\n0\n");
     outputStreamWriter.flush();
     socket.shutdownOutput();
    } else if (req.endsWith("MultiOther")) {
     OutputStreamWriter outputStreamWriter = new OutputStreamWriter(socket.getOutputStream());
     outputStreamWriter.append("HTTP/1.0 200 OK\n" + "Connection: close\n" + "Content-Type: text/plain; charset=iso-8859-1\n" + "Content-Length: 1\n"
         + "X-Forwarded-For: abc\n" + "X-Forwarded-For: def\n" + "\n0\n");
     outputStreamWriter.flush();
     socket.shutdownOutput();

GroovyClientConnection(Script script, boolean autoOutput,Socket socket) throws IOException {
  this.script = script;
  this.autoOutputFlag = autoOutput;
  this.socket = socket;
  reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  writer = new PrintWriter(socket.getOutputStream());
  new Thread(this, "Groovy client connection - " + socket.getInetAddress().getHostAddress()).start();
}
public void run() {

  @Override
  public Void call() throws Exception {
    Socket socket = serverSocket[0].accept();
    BufferedReader reader = new BufferedReader(new InputStreamReader(
        socket.getInputStream()));
    String value = reader.readLine();
    assertEquals("0", value);
    socket.close();
    return null;
  }
};

public void connect() {
  try {
    socket.connect(address);
    socket.setSoTimeout((int) TimeUnit.SECONDS.toMillis(1));
    OutputStream outputStream = this.socket.getOutputStream();
    this.os = new PrintStream(outputStream);
    this.reader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}

@Override
public void open(Map<String, Object> conf, TopologyContext context, SpoutOutputCollector collector) {
  this.collector = collector;
  this.queue = new LinkedBlockingDeque<>();
  this.emitted = new HashMap<>();
  this.objectMapper = new ObjectMapper();
  try {
    socket = new Socket(host, port);
    in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  } catch (IOException e) {
    throw new RuntimeException("Error opening socket: host " + host + " port " + port);
  }
  readerThread = new Thread(new SocketSpout.SocketReaderRunnable());
  readerThread.start();
}

public void run() throws IOException, InterruptedException {
  PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(),"UTF-8")),true);
  out.println("Welcome");
  runCli(new Connection(socket));
}

@Override
public void run() {
  try {
    try (Socket socket = serverSocket.accept();
        PrintWriter writer = new PrintWriter(socket.getOutputStream(), true)) {
      writer.println(WordCountData.TEXT);
    }
  }
  catch (Throwable t) {
    this.error = t;
  }
}

/**
 * Terminates this session gracefully.
 */
private void close() {
 try {
  in.close();
  out.close();
  if (DEBUG) {
   log.info("Closing connection to client");
   log.info(client.getInetAddress().getHostName());
  }
  client.close();
 } catch (Exception e) {
  log.info("NERServer:Session: can't close session");
  e.printStackTrace(System.err);
 }
}