TCP客户服务端

创建TCP服务端
1.创建一个ServerSocket对象。
2.调用accept（）方法接收客户端请求。
3.从Socket中获取I/O流。
4.对I/O流进行读写操作，完成与客户端的交互。
5.关闭I/O流和Socket

 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 
 public class Server {
   public static void main(String[] args) throws Exception {
     // 监听指定的端口
     int port = 55533;
     ServerSocket server = new ServerSocket(port);
 
     // server将一直等待连接的到来
     System.out.println("server将一直等待连接的到来");
     Socket socket = server.accept();
     // 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取
     InputStream inputStream = socket.getInputStream();
     byte[] bytes = new byte[1024];
     int len;
     inputStream.read(bytes);
 //    StringBuilder s = new StringBuilder();
     String s=null;
     //只有当客户端关闭它的输出流的时候，服务端才能取得结尾的-1
     while ((len = inputStream.read(bytes)) != -1) {
       // 注意指定编码格式，发送方和接收方一定要统一，建议使用UTF-8
 //      s.append(new String(bytes, 0, len, "UTF-8"));
       s= new String(bytes, 0, len,"utf-8");
     }
     System.out.println("server : I get your message   : " + s);
 
     OutputStream outputStream = socket.getOutputStream();
     outputStream.write("this is server  ".getBytes("UTF-8"));
 
     inputStream.close();
     outputStream.close();
     socket.close();
     server.close();
   }
 }

创建TCP客户端

1.创建一个Socket对象。

2.从Socket中获取I/O流。

3.对I/O流进行读写操作，完成与服务端的交互。

4.关闭I/O流和Socket

 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.Socket;
 
 public class ClientTest {
   public static void main(String args[]) throws Exception {
     // 要连接的服务端IP地址和端口
     String host = "127.0.0.1";
     int port = 55533;
     // 与服务端建立连接
     Socket socket = new Socket(host, port);
     // 建立连接后获得输出流
     OutputStream outputStream = socket.getOutputStream();
     String message = "client:   hello this is client";
     socket.getOutputStream().write(message.getBytes("UTF-8"));
     //通过shutdownOutput告诉服务器已经发送完数据，后续只能接受数据
     socket.shutdownOutput();
 
     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("client : I get your message   " + sb);
 
     inputStream.close();
     outputStream.close();
     socket.close();
   }
 }

　　在传输过程中，客户端需要给服务端发送消息告知自己发送完成，否则服务端会一直等待，直到超时。

1、 此时需要调用方法告诉服务端，自己发送完成。

socket.shutdownOutput(); 而不是 outputStream.close();

如果关闭输出流那模相应的Socket也关闭，相当于  socket.close();

　　调用shutdownOutput() ,底层会告知服务端我这边已经写完，服务端知道消息已经读取完，如果服务端有要发送的消息，会发送，如果没有直接关闭socket。

　　　　这样会使得，不能再次发送消息，如果发送需要再次建立连接。在访问频率较高时，将急需优化。

2、通过约定符号

　　双方约定一个短语或字符来当做发送完成的标识，比如约定  end　

 Socket socket = server.accept();
 // 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取
 BufferedReader read=new BufferedReader(new InputStreamReader(socket.getInputStream(),"UTF-8"));
 String line;
 StringBuilder sb = new StringBuilder();
 while ((line = read.readLine()) != null && "end".equals(line)) {
   //注意指定编码格式，发送方和接收方一定要统一，建议使用UTF-8
   sb.append(line);
 }

　　优点：不需要关闭流，当发送完一条消息可以再次发送

　　缺点：额外的结束标志占带宽，容易误判误被结束，

3、指定长度

　　现指定命令长度，然后读取指定长度的内容

　　现在首要的问题就是用几个字节指定长度呢，我们可以算一算：

• 1个字节：最大256，表示256B
• 2个字节：最大65536，表示64K
• 3个字节：最大16777216，表示16M
• 4个字节：最大4294967296，表示4G

　　　当然我们没必要使用最大长度，而使用边长方式来表示长度：

• 第一个字节首位为0：即0XXXXXXX，表示长度就一个字节，最大128，表示128B
• 第一个字节首位为110，那么附带后面一个字节表示长度：即110XXXXX 10XXXXXX，最大2048，表示2K
• 第一个字节首位为1110，那么附带后面二个字节表示长度：即110XXXXX 10XXXXXX 10XXXXXX，最大131072，表示128K
• 依次类推

• 上面提到的这种用法适合高富帅的程序员使用，一般呢，如果用作命名发送，两个字节就够了，如果还不放心4个字节基本就能满足你的所有要求

服务端程序：

 import java.io.InputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 
 public class SocketServer {
   public static void main(String[] args) throws Exception {
     // 监听指定的端口
     int port = 55533;
     ServerSocket server = new ServerSocket(port);
 
     // server将一直等待连接的到来
     System.out.println("server将一直等待连接的到来");
     Socket socket = server.accept();
     // 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取
     InputStream inputStream = socket.getInputStream();
     byte[] bytes;
     // 因为可以复用Socket且能判断长度，所以可以一个Socket用到底
     while (true) {
       // 首先读取两个字节表示的长度
       int first = inputStream.read();
       //如果读取的值为-1 说明到了流的末尾，Socket已经被关闭了，此时将不能再去读取
       if(first==-1){
         break;
       }
       int second = inputStream.read();
       int length = (first << 8) + second;
       // 然后构造一个指定长的byte数组
       bytes = new byte[length];
       // 然后读取指定长度的消息即可
       inputStream.read(bytes);
       System.out.println("get message from client: " + new String(bytes, "UTF-8"));
     }
     inputStream.close();
     socket.close();
     server.close();
   }
 }

先读取两个字节的长度，然后读取消息，客户端程序：

 import java.io.OutputStream;
 import java.net.Socket;
 
 public class SocketClient {
   public static void main(String args[]) throws Exception {
     // 要连接的服务端IP地址和端口
     String host = "127.0.0.1";
     int port = 55533;
     // 与服务端建立连接
     Socket socket = new Socket(host, port);
     // 建立连接后获得输出流
     OutputStream outputStream = socket.getOutputStream();
     String message = "the first message!";
     //首先需要计算得知消息的长度
     byte[] sendBytes = message.getBytes("UTF-8");
     //然后将消息的长度优先发送出去
     outputStream.write(sendBytes.length >>8);
     outputStream.write(sendBytes.length);
     //然后将消息再次发送出去
     outputStream.write(sendBytes);
     outputStream.flush();
     //==========此处重复发送一次，实际项目中为多个命名，此处只为展示用法
     message = "the second message!";
     sendBytes = message.getBytes("UTF-8");
     outputStream.write(sendBytes.length >>8);
     outputStream.write(sendBytes.length);
     outputStream.write(sendBytes);
     outputStream.flush();
     //==========此处重复发送一次，实际项目中为多个命名，此处只为展示用法
     message = "the third message!";
     sendBytes = message.getBytes("UTF-8");
     outputStream.write(sendBytes.length >>8);
     outputStream.write(sendBytes.length);
     outputStream.write(sendBytes);    
 
     outputStream.close();
     socket.close();
   }
 }

运用线程池处理并发：

　　　　服务端：

 import java.io.InputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 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=new Runnable() {
 //        @Override
 //        public void run() {
 //        }
 //    };
     // java8   lambda  用于简化匿名类
       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);
     }
 
   }
 }