基于Java实现Socket编程入门

package com.marklux.socket.base;

import java.io.IOException;

import java.io.InputStream;

import java.net.ServerSocket;

import java.net.Socket;

/**

  * The very basic socket server that only listen one single message.

  */

public class BaseSocketServer {

     private ServerSocket server;

     private Socket socket;

     private int port;

     private InputStream inputStream;

     private static final int MAX_BUFFER_SIZE = 1024 ;

     public int getPort() {

         return port;

     }

     public void setPort( int port) {

         this .port = port;

     }

     public BaseSocketServer( int port) {

         this .port = port;

     }

     public void runServerSingle() throws IOException {

         this .server = new ServerSocket( this .port);

         System.out.println( "base socket server started." );

         // the code will block here till the request come.

         this .socket = server.accept();

         this .inputStream = this .socket.getInputStream();

         byte [] readBytes = new byte [MAX_BUFFER_SIZE];

         int msgLen;

         StringBuilder stringBuilder = new StringBuilder();

         while ((msgLen = inputStream.read(readBytes)) != - 1 ) {

             stringBuilder.append( new String(readBytes, 0 ,msgLen, "UTF-8" ));

         }

         System.out.println( "get message from client: " + stringBuilder);

         inputStream.close();

         socket.close();

         server.close();

     }

     public static void main(String[] args) {

         BaseSocketServer bs = new BaseSocketServer( 9799 );

         try {

             bs.runServerSingle();

         } catch (IOException e) {

             e.printStackTrace();

         }

     }

}

package com.marklux.socket.base;

import java.io.IOException;

import java.io.OutputStream;

import java.io.UnsupportedEncodingException;

import java.net.Socket;

/**

  * The very basic socket client that only send one single message.

  */

public class BaseSocketClient {

     private String serverHost;

     private int serverPort;

     private Socket socket;

     private OutputStream outputStream;

     public BaseSocketClient(String host, int port) {

         this .serverHost = host;

         this .serverPort = port;

     }

     public void connetServer() throws IOException {

         this .socket = new Socket( this .serverHost, this .serverPort);

         this .outputStream = socket.getOutputStream();

         // why the output stream?

     }

     public void sendSingle(String message) throws IOException {

         try {

             this .outputStream.write(message.getBytes( "UTF-8" ));

         } catch (UnsupportedEncodingException e) {

             System.out.println(e.getMessage());

         }

         this .outputStream.close();

         this .socket.close();

     }

     public static void main(String[] args) {

         BaseSocketClient bc = new BaseSocketClient( "127.0.0.1" , 9799 );

         try {

             bc.connetServer();

             bc.sendSingle( "Hi from mark." );

         } catch (IOException e) {

             e.printStackTrace();

         }

     }

}

public void runServer() throws IOException {

         this .serverSocket = new ServerSocket(port);

         this .socket = serverSocket.accept();

         this .inputStream = socket.getInputStream();

         String message = new String(inputStream.readAllBytes(), "UTF-8" );

         System.out.println( "received message: " + message);

         this .socket.shutdownInput(); // 告诉客户端接收已经完毕，之后只能发送

         // write the receipt.

         this .outputStream = this .socket.getOutputStream();

         String receipt = "We received your message: " + message;

         outputStream.write(receipt.getBytes( "UTF-8" ));

         this .outputStream.close();

         this .socket.close();

     }

public void sendMessage(String message) throws IOException {

         this .socket = new Socket(host,port);

         this .outputStream = socket.getOutputStream();

         this .outputStream.write(message.getBytes( "UTF-8" ));

         this .socket.shutdownOutput(); // 告诉服务器，所有的发送动作已经结束，之后只能接收

         this .inputStream = socket.getInputStream();

         String receipt = new String(inputStream.readAllBytes(), "UTF-8" );

         System.out.println( "got receipt: " + receipt);

         this .inputStream.close();

         this .socket.close();

     }

public void runServer() throws IOException {

         this .server = new ServerSocket( this .port);

         System.out.println( "base socket server started." );

         this .socket = server.accept();

         // the code will block here till the request come.

         this .inputStream = this .socket.getInputStream();

         Scanner sc = new Scanner( this .inputStream);

         while (sc.hasNextLine()) {

             System.out.println( "get info from client: " + sc.nextLine());

         } // 循环接收并输出消息内容

         this .inputStream.close();

         socket.close();

     }

public void connetServer() throws IOException {

         this .socket = new Socket( this .serverHost, this .serverPort);

         this .outputStream = socket.getOutputStream();

     }

public void send(String message) throws IOException {

         String sendMsg = message + "\n" ; // we mark \n as a end of line.

         try {

             this .outputStream.write(sendMsg.getBytes( "UTF-8" ));

         } catch (UnsupportedEncodingException e) {

             System.out.println(e.getMessage());

         }

//        this.outputStream.close();

//        this.socket.shutdownOutput();

     }

  public static void main(String[] args) {

         CycleSocketClient cc = new CycleSocketClient( "127.0.0.1" , 9799 );

         try {

             cc.connetServer();

             Scanner sc = new Scanner(System.in);

             while (sc.hasNext()) {

                 String line = sc.nextLine();

                 cc.send(line);

             }

         } catch (IOException e) {

             e.printStackTrace();

         }

     }

public void runServer() throws IOException {

         this .serverSocket = new ServerSocket( this .port);

         this .socket = serverSocket.accept();

         this .inputStream = socket.getInputStream();

         byte [] bytes;

         while ( true ) {

             // 先读第一个字节

             int first = inputStream.read();

             if (first == - 1 ) {

                 // 如果是-1，说明输入流已经被关闭了，也就不需要继续监听了

                 this .socket.close();

                 break ;

             }

             // 读取第二个字节

             int second = inputStream.read();

             int length = (first << 8 ) + second; // 用位运算将两个字节拼起来成为真正的长度

             bytes = new byte [length]; // 构建指定长度的字节大小来储存消息即可

             inputStream.read(bytes);

             System.out.println( "receive message: " + new String(bytes, "UTF-8" ));

         }

     }

public void connetServer() throws IOException {

         this .socket = new Socket(host,port);

         this .outputStream = socket.getOutputStream();

     }

public void sendMessage(String message) throws IOException {

         // 首先要把message转换成bytes以便处理

         byte [] bytes = message.getBytes( "UTF-8" );

         // 接下来传输两个字节的长度，依然使用移位实现

         int length = bytes.length;

         this .outputStream.write(length >> 8 ); // write默认一次只传输一个字节

         this .outputStream.write(length);

         // 传输完长度后，再正式传送消息

         this .outputStream.write(bytes);

     }

public static void main(String[] args) {

         LengthSocketClient lc = new LengthSocketClient( "127.0.0.1" , 9799 );

         try {

             lc.connetServer();

             Scanner sc = new Scanner(System.in);

             while (sc.hasNextLine()) {

                 lc.sendMessage(sc.nextLine());

             }

         } catch (IOException e) {

             e.printStackTrace();

         }

     }

public class ListenThread implements Runnable {

     private Socket socket;

     private InputStream inputStream;

     public ListenThread(Socket socket) {

         this .socket = socket;

     }

     @Override

     public void run() throws RuntimeException{

         try {

             this .inputStream = socket.getInputStream();

         } catch (IOException e) {

             e.printStackTrace();

             throw new RuntimeException(e.getMessage());

         }

         while ( true ) {

             try {

                 int first = this .inputStream.read();

                 if (first == - 1 ) {

                     // 输入流已经被关闭，无需继续读取

                     throw new RuntimeException( "disconnected." );

                 }

                 int second = this .inputStream.read();

                 int msgLength = (first<< 8 ) + second;

                 byte [] readBuffer = new byte [msgLength];

                 this .inputStream.read(readBuffer);

                 System.out.println( "message from [" + socket.getInetAddress() + "]: " + new String(readBuffer, "UTF-8" ));

             } catch (IOException e) {

                 e.printStackTrace();

                 throw new RuntimeException(e.getMessage());

             }

         }

     }

}

public class ChatSocket {

     private String host;

     private int port;

     private Socket socket;

     private ServerSocket serverSocket;

     private OutputStream outputStream;

     // 以服务端形式启动，创建会话

     public void runAsServer( int port) throws IOException {

         this .serverSocket = new ServerSocket(port);

         System.out.println( "[log] server started at port " + port);

         // 等待客户端的加入

         this .socket = serverSocket.accept();

         System.out.println( "[log] successful connected with " + socket.getInetAddress());

         // 启动监听线程

         Thread listenThread = new Thread( new ListenThread( this .socket));

         listenThread.start();

         waitAndSend();

     }

     // 以客户端形式启动，加入会话

     public void runAsClient(String host, int port) throws IOException {

         this .socket = new Socket(host, port);

         System.out.println( "[log] successful connected to server " + socket.getInetAddress());

         Thread listenThread = new Thread( new ListenThread( this .socket));

         listenThread.start();

         waitAndSend();

     }

     public void waitAndSend() throws IOException {

         this .outputStream = this .socket.getOutputStream();

         Scanner sc = new Scanner(System.in);

         while (sc.hasNextLine()) {

             this .sendMessage(sc.nextLine());

         }

     }

     public void sendMessage(String message) throws IOException {

         byte [] msgBytes = message.getBytes( "UTF-8" );

         int length = msgBytes.length;

         outputStream.write(length>> 8 );

         outputStream.write(length);

         outputStream.write(msgBytes);

     }

     public static void main(String[] args) {

         Scanner scanner = new Scanner(System.in);

         ChatSocket chatSocket = new ChatSocket();

         System.out.println( "select connect type: 1 for server and 2 for client" );

         int type = Integer.parseInt(scanner.nextLine().toString());

         if (type == 1 ) {

             System.out.print( "input server port: " );

             int port = scanner.nextInt();

             try {

                 chatSocket.runAsServer(port);

             } catch (IOException e) {

                 e.printStackTrace();

             }

         } else if (type == 2 ) {

             System.out.print( "input server host: " );

             String host = scanner.nextLine();

             System.out.print( "input server port: " );

             int port = scanner.nextInt();

             try {

                 chatSocket.runAsClient(host, port);

             } catch (IOException e) {

                 e.printStackTrace();

             }

         }

     }

}

public class SocketServer {

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

     // 监听指定的端口

     int port = 55533;

     ServerSocket server = new ServerSocket(port);

     // server将一直等待连接的到来

     System.out.println("server将一直等待连接的到来");

     //如果使用多线程，那就需要线程池，防止并发过高时创建过多线程耗尽资源

     ExecutorService threadPool = Executors.newFixedThreadPool(100);

     while (true) {

       Socket socket = server.accept();

       Runnable runnable=()->{

         try {

           // 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取

           InputStream inputStream = socket.getInputStream();

           byte[] bytes = new byte[1024];

           int len;

           StringBuilder sb = new StringBuilder();

           while ((len = inputStream.read(bytes)) != -1) {

             // 注意指定编码格式，发送方和接收方一定要统一，建议使用UTF-8

             sb.append(new String(bytes, 0, len, "UTF-8"));

           }

           System.out.println("get message from client: " + sb);

           inputStream.close();

           socket.close();

         } catch (Exception e) {

           e.printStackTrace();

         }

       };

       threadPool.submit(runnable);

     }

   }

}