• 什么是网络编程？

    可以让设备中的程序与网络上的其他设备中的成勋数据交互（实现网络通讯）

    java提供了哪些网络编程的解决方案

    java.net.*包下提供了网络编程的解决方案

    基本通讯架构

    • CS架构：（Client客户端   /   Server服务端）
    • BS架构： （Browser浏览器  /  Server服务端）

    网络通讯的三要素

    ip地址：（cmd -> ipconfig:IPv4（32字节））

            设备在网络中的唯一标识（上网设备上的身份号码）

            IP地址的两种形式：IPv4（32字节）、IPv6（128位）：号称可以为地球上每一粒沙子编号

            IP域名：记录了服务器的ip

            公网IP：是可以链接互联网的IP地址

            内网ip也局域网ip，只能组织机构内部使用

            192.168.开头的都是常见的局域网地址

            192.168.00--192.168.255.255专门为组织机构内部使用

            127.0.0.1 、 localhost本机IP，只会寻找当前所在主机

    •  IP常见命令：

      •  ipconfig：查看IP地址

      •  ping IP地址：看链接通不通

    • IP地址相关的类：

      • InetAddress的常用方法如下：

    1. import java.io.IOException;
    2. import java.net.InetAddress;
    3.  
    4.  
    5. public class InetAddressText {
    6.     public static void main(String[] args) throws IOException {
    7.         //获取本机的IP地址对象
    8.         InetAddress ip1 = InetAddress.getLocalHost();
    9.         System.out.println(ip1.getHostName());
    10.         System.out.println(ip1.getHostAddress());
    11.  
    12.         ///获取指定的ip或则域名的IP地址对象
    13.         InetAddress ip2 = InetAddress.getByName("www.baidu.com");
    14.         System.out.println(ip2.getHostName());
    15.         System.out.println(ip2.getHostAddress());
    16.  
    17.         //相当于ping
    18.         System.out.println(ip2.isReachable(6000));
    19.     }
    20. }

    端口：（可以标志0-65535个应用程序）（自己开发的程序用注册端口号）

    应用程序在设备中唯一的标识

    周知端口：0-1023，被预先定义的知名应用占用（http80、ftp21）
    注册端口：1024-49151，分配给用户进程或某些应用程序
    动态端口：49152-65535，之所以被称为动态端口，是因为她一般不固定分配某种进程，而是动态分配

    协议：

    链接和数据在网络中传输的规则

    开放式网络互连标准：（）

    osi网络参考模型：全球网络互联网标准

    TCP/IP网络模型:事实上的国际标准

    传输层2个通讯协议

    UDP（用户数据协议），TCP传输控制协议

    UDP协议：

    • 特点：无连接，不可靠通讯
    • 不事先建立链接，数据按照包发，一包数据包含：自己的ip、程序端口、目的IP、程序端口和数据（限制在64KB内）等等。
    • 发送不管对方是否在线，数据在中间丢失也不管，如果接受方收到数据也不返回确认
    • 通讯效率高，视频，通话应用

    TCP协议：

    • 特点：面向链接，可靠通讯
    • tcp的最终目的：要保证在不可靠的信道上实现可靠传输 
    • YCP主要有三个步骤实现可靠传输：三次握手建立链接，传输数据进行确认。四次挥手断开连接
    • 三次握手：发出链接请求、返回一个响应、发出确认信息，确认链接、
    • 四次挥手：发出断开请求、返回一个响应：稍等、返回一个响应，确认断开、发出正式确认断开链接

    UDP通讯

    java提供了Java.net.DatagramSocket类来实现UDP通讯

    DatagramSocket类：用于创建客户端、服务端：

    客户端：

    1. package com.Game_All.UDP;
    2.  
    3. import java.io.IOException;
    4. import java.net.*;
    5.  
    6. public class Client {
    7.     public static void main(String[] args) throws IOException {
    8.         //1、创建客户端对象
    9.         DatagramSocket socket = new DatagramSocket();
    10.         //2、创建数据包对象
    11.         /*public DatagramPacket(byte buf[], int length,
    12.         InetAddress address, int port) {
    13.             this(buf, 0, length, address, port);*/
    14.  
    15.         byte[] bytes = "我是快乐的客户端，我爱你黄洁".getBytes();
    16.        /*
    17.         参数一:封装要发出去的数据。
    18.         参数二:发送出去的数据大小(字节个数)
    19.         参数三:服务端的TP地址(找到服务端主机)
    20.         参数四:服务端程序的端口
    21.         */
    22.         DatagramPacket packet = new DatagramPacket(bytes,bytes.length,InetAddress.getLocalHost(),6666);
    23.  
    24.         //3、发送
    25.         socket.send(packet);
    26.         System.out.println("客户端发送完毕");
    27.         socket.close();//释放资源
    28.     }
    29. }

    服务端:

    1. package com.Game_All.UDP;
    2.  
    3. import java.io.IOException;
    4. import java.net.DatagramPacket;
    5. import java.net.DatagramSocket;
    6. import java.net.SocketException;
    7.  
    8. public class Server {
    9.     public static void main(String[] args) throws IOException {
    10.         //1、创建一个服务端（注册端口）
    11.         DatagramSocket socket = new DatagramSocket(6666);
    12.  
    13.         //2、创建一个数据包对象，用于接收数据的
    14.         byte[] buffer = new byte[1024*64];//64kb
    15.         DatagramPacket packet = new DatagramPacket(buffer,buffer.length);
    16.  
    17.         //3、接收
    18.         socket.receive(packet);
    19.  
    20.         //4、从字节数组中，吧即受到的数据直接打印出来
    21.         //接收到多少就到处多少
    22.         int len = packet.getLength();
    23.         String rs = new String(buffer,0,len);
    24.         System.out.println(rs);
    25.         System.out.println(packet.getAddress().getHostAddress());
    26.         System.out.println(packet.getPort());
    27.  
    28.         socket.close();
    29.  
    30.     }
    31. }

    先运行服务端！！！！

    多发多收

    1. package com.Game_All.UDP;
    2.  
    3. import java.io.IOException;
    4. import java.net.*;
    5. import java.util.Scanner;
    6.  
    7. public class Client {
    8.     public static void main(String[] args) throws IOException {
    9.         //1、创建客户端对象
    10.         DatagramSocket socket = new DatagramSocket();
    11.         //2、创建数据包对象
    12.         /*public DatagramPacket(byte buf[], int length,
    13.         InetAddress address, int port) {
    14.             this(buf, 0, length, address, port);*/
    15.        /*
    16.         参数一:封装要发出去的数据。
    17.         参数二:发送出去的数据大小(字节个数)
    18.         参数三:服务端的TP地址(找到服务端主机)
    19.         参数四:服务端程序的端口
    20.         */
    21.         Scanner scan = new Scanner(System.in);
    22.         while (true){
    23.             System.out.println("请说：");
    24.             String msg = scan.nextLine();
    25.  
    26.             if ("exit".equals(msg)){
    27.                 System.out.println("欢迎下次光临！退出成功");
    28.                 socket.close();
    29.                 break;
    30.             }
    31.             byte[] bytes = msg.getBytes();
    32.             DatagramPacket packet = new DatagramPacket(bytes,bytes.length,InetAddress.getLocalHost(),6666);
    33.             //3、发送
    34.             socket.send(packet);
    35.         }
    36.     }
    37. }
    38.  
    39.  
    40.  
    41. package com.Game_All.UDP;
    42.  
    43. import java.io.IOException;
    44. import java.net.DatagramPacket;
    45. import java.net.DatagramSocket;
    46. import java.net.SocketException;
    47.  
    48. public class Server {
    49.     public static void main(String[] args) throws IOException {
    50.         //1、创建一个服务端（注册端口）
    51.         DatagramSocket socket = new DatagramSocket(6666);
    52.  
    53.         //2、创建一个数据包对象，用于接收数据的
    54.         byte[] buffer = new byte[1024*64];//64kb
    55.         DatagramPacket packet = new DatagramPacket(buffer,buffer.length);
    56.  
    57.         while (true) {
    58.             //3、接收
    59.             socket.receive(packet);
    60.  
    61.             //4、从字节数组中，吧即受到的数据直接打印出来
    62.             //接收到多少就到处多少
    63.  
    64.             int len = packet.getLength();
    65.             String rs = new String(buffer,0,len);
    66.             System.out.println(rs);
    67.             System.out.println(packet.getAddress().getHostAddress());
    68.             System.out.println(packet.getPort());
    69.             System.out.println("=======================");
    70.         }
    71.  
    72.     }
    73. }
    74.  
    75.  
    76.

    TCP

    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataOutputStream;
    4. import java.io.IOException;
    5. import java.io.OutputStream;
    6. import java.net.Socket;
    7.  
    8. public class Client {
    9.     public static void main(String[] args) throws IOException {
    10.         //1、创建Socket对象，并同时请求与服务端程序的链接
    11.         Socket socket = new Socket("127.0.0.1",8888);
    12.  
    13.         //2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序
    14.         OutputStream os = socket.getOutputStream();
    15.  
    16.         //3、把低级的字节输出流包装成数据输出流
    17.         DataOutputStream dos = new DataOutputStream(os);
    18.  
    19.         //4、开始写数据出去了
    20.         dos.writeUTF("在一起，好嘛");
    21.         dos.close();
    22.  
    23.         socket.close();
    24.     }
    25. }

    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataOutputStream;
    4. import java.io.IOException;
    5. import java.io.OutputStream;
    6. import java.net.Socket;
    7.  
    8. public class Client {
    9.     public static void main(String[] args) throws IOException {
    10.         //1、创建Socket对象，并同时请求与服务端程序的链接
    11.         Socket socket = new Socket("127.0.0.1",8888);
    12.  
    13.         //2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序
    14.         OutputStream os = socket.getOutputStream();
    15.  
    16.         //3、把低级的字节输出流包装成数据输出流
    17.         DataOutputStream dos = new DataOutputStream(os);
    18.  
    19.         //4、开始写数据出去了
    20.         dos.writeUTF("在一起，好嘛");
    21.         dos.close();
    22.  
    23.         socket.close();
    24.     }
    25. }
    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.DataOutputStream;
    5. import java.io.IOException;
    6. import java.io.InputStream;
    7. import java.net.ServerSocket;
    8. import java.net.Socket;
    9.  
    10. public class Server {
    11.     public static void main(String[] args) throws IOException {
    12.         //1、创建ServerSocket的对象，同时为服务端的注册端口
    13.         ServerSocket serverSocket = new ServerSocket(8888);
    14.  
    15.         //2、使用ServerSocket对象，调用一个accpte方法等待对象的客户链接请求
    16.         Socket socket = serverSocket.accept();
    17.  
    18.         //3、从socke通信管道中的一个字节输入流
    19.         InputStream is = socket.getInputStream();
    20.  
    21.         //4、把原始的字节输入流包装成数据输入流
    22.         DataInputStream dis = new DataInputStream(is);
    23.  
    24.         //5、使用数据输入流读取客户端发送过来的消息
    25.         String re = dis.readUTF();
    26.  
    27.         System.out.println(re);
    28.         //获取客户端IP地址
    29.         System.out.println(socket.getRemoteSocketAddress());
    30.         dis.close();
    31.         socket.close();
    32.     }
    33. }

    多发多收

    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.DataOutputStream;
    5. import java.io.IOException;
    6. import java.io.InputStream;
    7. import java.net.ServerSocket;
    8. import java.net.Socket;
    9.  
    10. public class Server {
    11.     public static void main(String[] args) throws IOException {
    12.         //1、创建ServerSocket的对象，同时为服务端的注册端口
    13.         ServerSocket serverSocket = new ServerSocket(8888);
    14.  
    15.         //2、使用ServerSocket对象，调用一个accpte方法等待对象的客户链接请求
    16.         Socket socket = serverSocket.accept();
    17.  
    18.         //3、从socke通信管道中的一个字节输入流
    19.         InputStream is = socket.getInputStream();
    20.  
    21.         //4、把原始的字节输入流包装成数据输入流
    22.         DataInputStream dis = new DataInputStream(is);
    23.  
    24.         while (true){
    25.             try {
    26.                 //5、使用数据输入流读取客户端发送过来的消息
    27.                 String re = dis.readUTF();
    28.  
    29.                 System.out.println(re);
    30.                 //获取客户端IP地址
    31.                 System.out.println(socket.getRemoteSocketAddress());
    32.                 System.out.println("---------------------");
    33.             } catch (IOException e) {
    34.                 System.out.println(socket.getRemoteSocketAddress()+"离线了");
    35.                 dis.close();
    36.                 socket.close();
    37.                 break;
    38.             }
    39.         }
    40.  
    41.     }
    42. }
    43.  
    44.  
    45.  
    46. package com.Game_All.TCP;
    47.  
    48. import java.io.DataOutputStream;
    49. import java.io.IOException;
    50. import java.io.OutputStream;
    51. import java.net.Socket;
    52. import java.util.Scanner;
    53.  
    54. public class Client {
    55.     public static void main(String[] args) throws IOException {
    56.         //1、创建Socket对象，并同时请求与服务端程序的链接
    57.         Socket socket = new Socket("127.0.0.1",8888);
    58.  
    59.         //2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序
    60.         OutputStream os = socket.getOutputStream();
    61.  
    62.         //3、把低级的字节输出流包装成数据输出流
    63.         DataOutputStream dos = new DataOutputStream(os);
    64.  
    65.         Scanner scanner = new Scanner(System.in);
    66.         //4、开始写数据出去了
    67.         while (true){
    68.             System.out.println("请说：");
    69.             String msg = scanner.nextLine();
    70.  
    71.             if ("exit".equals(msg)){
    72.                 dos.close();
    73.                 socket.close();
    74.                 break;
    75.             }
    76.             dos.writeUTF(msg);
    77.             dos.flush();
    78.         }
    79.  
    80.  
    81.     }
    82. }
    83.

    不支持多个客户一个服务器

    TCP通信-多线程

    服务端

    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.DataOutputStream;
    5. import java.io.IOException;
    6. import java.io.InputStream;
    7. import java.net.ServerSocket;
    8. import java.net.Socket;
    9.  
    10. public class Server {
    11.     public static void main(String[] args) throws IOException {
    12.         //1、创建ServerSocket的对象，同时为服务端的注册端口
    13.         ServerSocket serverSocket = new ServerSocket(8888);
    14.  
    15.  
    16.         while (true) {
    17.             try {
    18.                 //2、使用ServerSocket对象，调用一个accpte方法等待对象的客户链接请求
    19.                 Socket socket = serverSocket.accept();
    20.                 System.out.println("有人上线了"+socket.getRemoteSocketAddress());
    21.                 //3、把这个客户端对应的socket通信管道，交给一个独立的线程负责处理
    22.                 new ServiceReaderThread(socket).start();
    23.             } catch (IOException e) {
    24.                 throw new RuntimeException(e);
    25.             }
    26.  
    27.         }
    28.  
    29.     }
    30. }
    31.  
    32.  
    33. package com.Game_All.TCP;
    34.  
    35. import java.io.DataInputStream;
    36. import java.io.IOException;
    37. import java.io.InputStream;
    38. import java.net.Socket;
    39.  
    40. public class ServiceReaderThread extends Thread{
    41.     private Socket socket;
    42.     public ServiceReaderThread(Socket socket) {
    43.         this.socket = socket;
    44.     }
    45.  
    46.     @Override
    47.     public void run() {
    48.         InputStream is = null;
    49.         try {
    50.             is = socket.getInputStream();
    51.             DataInputStream dis = new DataInputStream(is);
    52.             while (true){
    53.                 try {
    54.                     String msg = dis.readUTF();
    55.                     System.out.println(msg);
    56.                 } catch (IOException e) {
    57.                     System.out.println("有人下线了"+socket.getRemoteSocketAddress());
    58.                     dis.close();
    59.                     socket.close();
    60.                     break;
    61.                 }
    62.             }
    63.         } catch (IOException e) {
    64.             throw new RuntimeException(e);
    65.         }
    66.  
    67.     }
    68. }

    客户端两个：

    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataOutputStream;
    4. import java.io.IOException;
    5. import java.io.OutputStream;
    6. import java.net.Socket;
    7. import java.util.Scanner;
    8.  
    9. public class Client {
    10.     public static void main(String[] args) throws IOException {
    11.         //1、创建Socket对象，并同时请求与服务端程序的链接
    12.         Socket socket = new Socket("127.0.0.1",8888);
    13.  
    14.         //2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序
    15.         OutputStream os = socket.getOutputStream();
    16.  
    17.         //3、把低级的字节输出流包装成数据输出流
    18.         DataOutputStream dos = new DataOutputStream(os);
    19.  
    20.         Scanner scanner = new Scanner(System.in);
    21.         //4、开始写数据出去了
    22.         while (true){
    23.             System.out.println("请说：");
    24.             String msg = scanner.nextLine();
    25.  
    26.             if ("exit".equals(msg)){
    27.                 dos.close();
    28.                 socket.close();
    29.                 break;
    30.             }
    31.             dos.writeUTF(msg);
    32.             dos.flush();
    33.         }
    34.  
    35.  
    36.     }
    37. }
    38.  
    39.  
    40. package com.Game_All.TCP;
    41.  
    42. import java.io.DataOutputStream;
    43. import java.io.IOException;
    44. import java.io.OutputStream;
    45. import java.net.Socket;
    46. import java.util.Scanner;
    47.  
    48. public class Client1 {
    49.     public static void main(String[] args) throws IOException {
    50.         //1、创建Socket对象，并同时请求与服务端程序的链接
    51.         Socket socket = new Socket("127.0.0.1",8888);
    52.  
    53.         //2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序
    54.         OutputStream os = socket.getOutputStream();
    55.  
    56.         //3、把低级的字节输出流包装成数据输出流
    57.         DataOutputStream dos = new DataOutputStream(os);
    58.  
    59.         Scanner scanner = new Scanner(System.in);
    60.         //4、开始写数据出去了
    61.         while (true){
    62.             System.out.println("请说：");
    63.             String msg = scanner.nextLine();
    64.  
    65.             if ("exit".equals(msg)){
    66.                 dos.close();
    67.                 socket.close();
    68.                 break;
    69.             }
    70.             dos.writeUTF(msg);
    71.             dos.flush();
    72.         }
    73.  
    74.  
    75.     }
    76. }

    TCP-端口转发

    客户端

    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataOutputStream;
    4. import java.io.IOException;
    5. import java.io.OutputStream;
    6. import java.net.Socket;
    7. import java.util.Scanner;
    8.  
    9. public class Client {
    10.     public static void main(String[] args) throws IOException {
    11.         //1、创建Socket对象，并同时请求与服务端程序的链接
    12.         Socket socket = new Socket("127.0.0.1",8888);
    13.  
    14.         //创建一个独立的线程，随机负责从socket中获取服务端发送过拉力的信息
    15.         new ClientReaderThread(socket).start();
    16.  
    17.         //2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序
    18.         OutputStream os = socket.getOutputStream();
    19.  
    20.         //3、把低级的字节输出流包装成数据输出流
    21.         DataOutputStream dos = new DataOutputStream(os);
    22.  
    23.         Scanner scanner = new Scanner(System.in);
    24.         //4、开始写数据出去了
    25.         while (true){
    26.             System.out.println("请说：");
    27.             String msg = scanner.nextLine();
    28.  
    29.             if ("exit".equals(msg)){
    30.                 dos.close();
    31.                 socket.close();
    32.                 break;
    33.             }
    34.             dos.writeUTF(msg);
    35.             dos.flush();
    36.         }
    37.  
    38.  
    39.     }
    40. }
    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.net.Socket;
    7.  
    8. public class ClientReaderThread extends Thread{
    9.     private Socket socket;
    10.  
    11.     public ClientReaderThread(Socket socket) {
    12.         this.socket = socket;
    13.     }
    14.  
    15.     @Override
    16.     public void run() {
    17.         try {
    18.             InputStream is = socket.getInputStream();
    19.             DataInputStream dis = new DataInputStream(is);
    20.  
    21.  
    22.             while (true){
    23.                 try {
    24.                     String msg = dis.readUTF();
    25.                     System.out.println(msg);
    26.                 } catch (IOException e) {
    27.                     System.out.println("有人下线了"+socket.getRemoteSocketAddress());
    28.                     Server.onLineSocket.remove(socket);
    29.                     dis.close();
    30.                     socket.close();
    31.                     break;
    32.                 }
    33.             }
    34.         } catch (IOException e) {
    35.             e.printStackTrace();
    36.         }
    37.     }
    38. }

    服务端

    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.DataOutputStream;
    5. import java.io.IOException;
    6. import java.io.InputStream;
    7. import java.net.ServerSocket;
    8. import java.net.Socket;
    9. import java.util.ArrayList;
    10. import java.util.List;
    11.  
    12. public class Server {
    13.  
    14.  
    15.     public static List onLineSocket = new ArrayList<>();
    16.  
    17.     public static void main(String[] args) throws IOException {
    18.         //1、创建ServerSocket的对象，同时为服务端的注册端口
    19.         ServerSocket serverSocket = new ServerSocket(8888);
    20.  
    21.  
    22.         while (true) {
    23.             try {
    24.                 //2、使用ServerSocket对象，调用一个accpte方法等待对象的客户链接请求
    25.                 Socket socket = serverSocket.accept();
    26.                 System.out.println("有人上线了"+socket.getRemoteSocketAddress());
    27.  
    28.                 onLineSocket.add(socket);
    29.                 //3、把这个客户端对应的socket通信管道，交给一个独立的线程负责处理
    30.                 new ServiceReaderThread(socket).start();
    31.             } catch (IOException e) {
    32.                 throw new RuntimeException(e);
    33.             }
    34.  
    35.         }
    36.  
    37.     }
    38. }
    1. package com.Game_All.TCP;
    2.  
    3. import java.io.*;
    4. import java.net.Socket;
    5. import java.util.ArrayList;
    6. import java.util.List;
    7.  
    8. public class ServiceReaderThread extends Thread{
    9.     private Socket socket;
    10.  
    11.     public ServiceReaderThread(Socket socket) {
    12.         this.socket = socket;
    13.     }
    14.  
    15.     @Override
    16.     public void run() {
    17.         InputStream is = null;
    18.         try {
    19.             is = socket.getInputStream();
    20.             DataInputStream dis = new DataInputStream(is);
    21.             while (true){
    22.                 try {
    23.                     String msg = dis.readUTF();
    24.                     System.out.println(msg);
    25.                     //把这个信息分发给所有客户端接收
    26.                     sendMsgToAll(msg);
    27.                 } catch (IOException e) {
    28.                     System.out.println("有人下线了"+socket.getRemoteSocketAddress());
    29.                     Server.onLineSocket.remove(socket);
    30.                     dis.close();
    31.                     socket.close();
    32.                     break;
    33.                 }
    34.             }
    35.         } catch (IOException e) {
    36.             throw new RuntimeException(e);
    37.         }
    38.  
    39.     }
    40.  
    41.     private void sendMsgToAll(String msg) throws IOException {
    42.         //发送给全部在线的socket管道接收
    43.         for (Socket onlineSocket : Server.onLineSocket) {
    44.             OutputStream os = onlineSocket.getOutputStream();
    45.             DataOutputStream dos = new DataOutputStream(os);
    46.             dos.writeUTF(msg);
    47.             dos.flush();
    48.  
    49.         }
    50.  
    51.     }
    52. }

    BS架构原理

    1. package com.Game_All.TCP;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.DataOutputStream;
    5. import java.io.IOException;
    6. import java.io.InputStream;
    7. import java.net.ServerSocket;
    8. import java.net.Socket;
    9. import java.util.ArrayList;
    10. import java.util.List;
    11. import java.util.concurrent.ArrayBlockingQueue;
    12. import java.util.concurrent.Executors;
    13. import java.util.concurrent.ThreadPoolExecutor;
    14. import java.util.concurrent.TimeUnit;
    15.  
    16. public class Server {
    17.  
    18.  
    19.  
    20.  
    21.     public static void main(String[] args) throws IOException {
    22.         //1、创建ServerSocket的对象，同时为服务端的注册端口
    23.         ServerSocket serverSocket = new ServerSocket(8888);
    24.  
    25.         //创建一个县城其，负责处理铜鼓县你管道任务
    26.         ThreadPoolExecutor pool = new ThreadPoolExecutor(16*2,16*2,0, TimeUnit.SECONDS,
    27.                 new ArrayBlockingQueue<>(8), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
    28.  
    29.         while (true) {
    30.  
    31.             //2、使用ServerSocket对象，调用一个accpte方法等待对象的客户链接请求
    32.             Socket socket = serverSocket.accept();
    33.  
    34.  
    35.  
    36.             //3、把这个客户端对应的socket通信管道，交给一个独立的线程负责处理
    37.             pool.execute(new ServiceReaderRunnable(socket));
    38.  
    39.  
    40.         }
    41.  
    42.     }
    43. }
    1. package com.Game_All.TCP;
    2.  
    3. import java.io.*;
    4. import java.net.Socket;
    5.  
    6. public class ServiceReaderRunnable implements Runnable {
    7.     private Socket socket;
    8.  
    9.     public ServiceReaderRunnable(Socket socket) {
    10.         this.socket = socket;
    11.     }
    12.  
    13.     @Override
    14.     public void run() {
    15.         try {
    16.             OutputStream os = socket.getOutputStream();
    17.             PrintWriter out = new PrintWriter(os, true);
    18.  
    19.             out.println("HTTP/1.1 200 OK");
    20.             out.println("Content-Type: text/html; charset=UTF-8");
    21.             out.println();
    22.             out.println("
      Hello, World!
      "      );
    23.  
    24.             out.close();
    25.         } catch (IOException e) {
    26.             e.printStackTrace();
    27.         } finally {
    28.             try {
    29.                 socket.close();
    30.             } catch (IOException e) {
    31.                 e.printStackTrace();
    32.             }
    33.         }
    34.     }
    35. }

  • 相关阅读:
    [已解决]react打包部署
    Java应用的混淆、加密以及加壳
    自动化测试---即selenium
    JAVA整理学习实例（四）数据结构
    C#知识|通过ADO.NET实现应用程序对数据库的增、删、改操作。
    代码随想录第43天|416. 分割等和子集，1049. 最后一块石头的重量 II， ​494.目标和，​ 474.一和零（一窍不通）
    [数组中等题] LeetCode 969. 煎饼排序
    按键检测|中断检测
    torch.nn.Conv3d()
    神经平面分布图怎么看,面部神经网络 分布图
  • 原文地址：https://blog.csdn.net/weixin_71942139/article/details/138106723