引言

所谓网络编程，指的就是通过编写程序使得计算机可以相互通信，生活中很多软件都是融合了网络编程的，比如QQ 等通信app。网络编程通常是为现有App增强连接到服务端的能力，但是有些事基于TCP,有些是基于HTTP。狭义的网络编程，指的是通信聊天类型的应用，广义的是凡是接入网络的程序，都是网络编程。

一.网络基础知识

1.1 网络模型

网络通信最初的设计模型为OSI 7层通信模型，所谓网络模型就是科学家对应如何实现网络通信的一种设计和设想。一个科学领域的某些技术往往都是先建立问题模型，然后再做实现。

1.1.1 OSI模型

image.png

1.1.2 TCP/IP模型

image.png

1.2 IP地址

IP 也就是IP地址协议，它的作用就是标记网络中每台计算机的身份。网络中的每个计算机都有唯一的一个地址。

1.2.1 IP地址表示

  • IPv4

它是由一个4字节32位的整数表示，为了方便记忆，使用点分10进制表示D.D.D.D，每8位使用一个0-255表示，用 . 分隔。 平时见到的 如192.128.1.12 这种就是 IPv4地址表示。

由于 表示容量的 问题 ，IPv4 早已不够使用，它的下一个版本IPv6 拥有更大的表示范围。

  • IPv6

它是由一个16字节128位的整数表示，表示的范围更大，也就意味着IP地址越多，夸张到 沙漠中每一粒沙子都可以分配到一个IP,它使用8段16进制表示，每段0-65535。X.X.X.X.X.X.X.X 。

1.2.2 IP地址分类

image.png

1.3 端口

端口，计算机上通信程序的唯一标识，计算机中存在多网络软件，如何区分开不同的软件，就需要使用端口。不同的应用只通过固定端口收发数据。
端口的范围 0-65535

1.3.1 常见默认端口

MySQL-> 3306
Tomcat->8080
HTTP->80
SSH->22
FTP->21

1.4 TCP/UDP

1.4.1 TCP 特点

1）TCP是面向连接的运输层协议。应用程序在使用TCP协议之前，必须先建立TCP连接，在传送数据完毕后，必须释放已经建立的TCP连接。
（2）每一条TCP连接只能有两个端点，即点对点的。
（3）TCP提供可靠交付的服务。通过TCP连接传送的数据，无差错、不丢失、不重复、并且按序到达。
（4）TCP提供全双工通信。TCP允许通信双方的应用进程在任何时候都能发送数据。
（5）面向字节流。TCP中的“流”指的是流入到进程或从进程流出的字节序列。面向字节流的含义是：虽然应用程序和TCP的交互是一次一个数据块（大小不等），但是TCP把应用程序交下来的数据仅仅看成是一连串的无结构的字节流。

1.4.2 UDP 特点

（1）UDP是无连接的，即发送数据之前不需要建立连接（当然，发送数据结束时也没有连接可以释放），因此减少了开销和发送数据之前的时延。
（2）UDP使用尽最大努力交付，即不保证可靠交付，因此主机不需要维持复杂的连接状态表（这里面有很多参数）。
（3）UDP是面向报文的。发送方的UDP对应用程序交下来的报文，在添加首部后就向下交付IP层。UDP对应用层交下来的报文，既不合并，也不拆分，而是保留这些报文的边界。这就是说，应用层交给UDP多长 的报文，UDP就照样发送，即一次发送一个报文。
（4）UDP没有拥塞控制，因此网络出现的拥塞不会使源主机的发送速率降低。但是不使用拥塞控制功能的UDP有可能会引起网络产生严重的拥塞问题。
（5）UDP支持一对一、一对多、多对一和多对多的交互通信。
（6）UDP的首部开销小，只有8个字节，比TCP的20个字节的首部还要短。
UDP也用在路由信息协议RIP（Routing Information Protocol）中修改路由表。在这些应用场合下，如果有一个消息丢失，在几秒之后另一个新的消息就会替换它。UDP广泛用在多媒体应用中。

1.4.3 三次握手

src=http___nimg.ws.126.net__url=http%3A%2F%2Fdingyue.ws.126.net%2F2021%2F0328%2F12865b7ej00qqo1ob000uc000hs00bag.jpg&thumbnail=650x2147483647&quality=80&type=jpg&refer=http___nimg.ws.126.jpg

1.4.5 四次挥手

src=http___nimg.ws.126.net__url=http%3A%2F%2Fdingyue.ws.126.net%2F2021%2F0328%2Fe3887080j00qqo1oc000yc000hs00bsg.jpg&thumbnail=650x2147483647&quality=80&type=jpg&refer=http___nimg.ws.126 (1).jpg

二.Socket编程

2.1 Socket 编程流程

  • 服务器端使用ServerSocket套接字 并绑定监听端口
  • 服务端 阻塞等待连接
  • 客户端使用 Socket 并指定服务端IP 和 端口

服务端：

  1. //1. 服务器端套接字
  2. ServerSocket server = new ServerSocket(8848);
  3. //2. 监听客户端连接
  4. Socket socket = server.accept();

客户端

  1. //1. 创建客户端套接字
  2. Socket socket = new Socket(  "127.0.0.1"  , 8848);

2.2 Socket 收发数据

从Socket中读数据

  1. InputStream is = socket.getInputStream();
  2. byte[] buff = new byte[1024];
  3. int len=0;
  4. while ( (len=is.read(buff))!=-1){
  5.     //读到了客户端发的字节信息
  6.     System.out.println( new String(buff,0,len) );
  7. }

从写数据到Socket中

  1. //发送数据给服务端
  2. BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
  3. bos.write("hello".getBytes());

2.3 多客户端连接

  1. while (true) {
  2.     System.out.println("等待连接中.......");
  3.     //接收客户端连接
  4.     Socket socket = server.accept();
  5. }

2.4 多客户端通信

  2. //服务端
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  7. import java.util.ArrayList;
  8. import java.util.List;
  10. @SuppressWarnings("all")
  11. public class sever {
  12.     public static List<Socket> socketList = new ArrayList<>();
  14.     public static void main(String[] args) throws IOException {
  15.         ServerSocket serverSocket = new ServerSocket(7777);
  16.         while (true){
  17.             System.out.println("等待客户端连接");
  18.             Socket socket = serverSocket.accept();
  19.             socketList.add(socket);
  20.             //在这里读数据阻塞线程，在这里启动一个新的线程单独处理读取这个客户端的信息
  21.             new Thread(new serverThread(socket)).start();
  23.         }
  24.     }
  25. }
  27. class serverThread implements Runnable{
  28.     private Socket socket;
  29.     //构建任务时初始化客户端
  30.     public serverThread(Socket socket) {
  31.         this.socket = socket;
  32.     }
  33.     @Override
  34.     public void run() {
  35.         try{
  36.             InputStream is = socket.getInputStream();
  37.             byte[] bs = new byte[1024];
  38.             int len;
  39.             while (( len=is.read(bs))!=-1){
  40.                 String msg = new String(bs,0,len);
  41.                 for (Socket socket1 : sever.socketList) {
  42.                     if (socket1==this.socket)continue;
  43.                     socket1.getOutputStream().write(msg.getBytes());
  44.                 }
  45.             }
  46.         }catch(IOException e){
  47.             e.printStackTrace();
  48.         }
  49.     }
  50. }
  52. //客户端
  54. package NET3;
  55. import java.io.IOException;
  56. import java.io.InputStream;
  57. import java.io.OutputStream;
  58. import java.net.Socket;
  59. import java.util.Scanner;
  60. public class client {
  61.     public static void main(String[] args) throws IOException {
  62.         Socket socket = new Socket("127.0.0.1",7777);
  63.         OutputStream outputStream = socket.getOutputStream();
  64.         new Thread(new clientThread(socket)).start();
  67.         //防止客户端关闭 服务端接收不了 socket  写个while()
  68.         while (true){
  69.             Scanner sc = new Scanner(System.in);
  70.             String str= sc.nextLine();
  71.             outputStream.write(str.getBytes());
  72.         }
  74.     }
  75. }
  78. class client2{
  79.     public static void main(String[] args) throws IOException {
  80.         Socket socket = new Socket("127.0.0.1",7777);
  81.         OutputStream outputStream = socket.getOutputStream();
  82.         new Thread(new clientThread(socket)).start();
  84.         //防止客户端关闭 服务端接收不了 socket  写个while()
  85.         while (true){
  86.             Scanner sc = new Scanner(System.in);
  87.             String str= sc.nextLine();
  88.             outputStream.write(str.getBytes());
  89.         }
  90.     }
  91. }
  93. class client3{
  94.     public static void main(String[] args) throws IOException {
  95.         Socket socket = new Socket("127.0.0.1",7777);
  96.         OutputStream outputStream = socket.getOutputStream();
  97.         new Thread(new clientThread(socket)).start();
  100.         //防止客户端关闭 服务端接收不了 socket  写个while()
  101.         while (true){
  102.             Scanner sc = new Scanner(System.in);
  103.             String str= sc.nextLine();
  104.             outputStream.write(str.getBytes());
  105.         }
  106.     }
  107. }
  111. class clientThread implements Runnable{
  112.     private Socket socket;
  113.     public clientThread(Socket socket) {
  114.         this.socket = socket;
  115.     }
  116.     @Override
  117.     public void run() {
  118.         try {
  119.             InputStream is = socket.getInputStream();
  120.             byte[] bs = new byte[1024];
  121.             int len;
  122.             while ((len = is.read(bs))>0){
  123.                 String msg = new String(bs,0,len);
  124.                 System.out.println(msg);
  126.             }
  127.         } catch (IOException e) {
  128.             e.printStackTrace();
  129.         }
  130.     }
  131. }

案例：

客户端与服务端 形成翻译软件类型

  1. package cidian;
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6. import java.util.Properties;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.PrintStream;
  10. import java.net.Socket;
  11. import java.util.Scanner;
  13. //客户端
  15. class client {
  16.     public static void main(String[] args) throws IOException {
  17.         Socket socket =  new Socket("127.0.0.1",2345);
  19.         Scanner sc = new Scanner(System.in);
  20.         System.out.println("请输入单词：");
  21.         String filename = sc.next();
  23.         PrintStream ps = new PrintStream(socket.getOutputStream());
  24.         ps.println(filename);
  26.         InputStream is = socket.getInputStream();
  27.         byte[] bs = new byte[1024];
  28.         int len;
  29.         while((len=is.read(bs))>0){
  30.             String msg = new String(bs,0,len);
  31.             System.out.println(msg);
  32.         }
  33.         System.out.println("传输完毕");
  34.     }
  35. }
  40. //服务器端
  41. public class server {
  42.     public static void main(String[] args) throws IOException {
  43.         ServerSocket serverSocket = new ServerSocket(2345);
  44.         while (true){
  45.             System.out.println("等待连接......");
  46.             Socket socket = serverSocket.accept();
  47.             new Thread(new serverThread(socket)).start();
  48.         }
  49.         //接受客户端发的文件名
  50.     }
  51. }
  53. class serverThread implements Runnable{
  54.     private Socket socket;
  56.     public serverThread(Socket socket) {
  57.         this.socket = socket;
  58.     }
  59.     @Override
  60.     public void run() {
  61.         try {
  62.             //读到单词
  63.             BufferedReader bf = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  64.             String keywords = bf.readLine();
  66.             Properties properties = new Properties();
  67.             properties.load(new FileReader("C:\\Users\\杨嘿嘿\\.IntelliJIdea2019.3\\config\\scratches\\words.properties"));
  68.             String value = properties.getProperty(keywords);
  69.             if (value!=null){
  70.                 socket.getOutputStream().write(value.getBytes());
  71.             }else {
  72.                 socket.getOutputStream().write("词典里面没有这个词".getBytes());
  74.             }
  76.         } catch (IOException e) {
  77.             e.printStackTrace();
  78.         }
  79.     }
  80. }

作业：

客户端输入一个文件名 服务端接受 然后查找本地有没有这个文件 有的话 就把文件返回给客户端
//服务端

  1. package net4;
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6. import java.util.ArrayList;
  7. import java.util.Arrays;
  9. public class server {
  10.     public static void main(String[] args) throws IOException {
  11.         ServerSocket serverSocket = new ServerSocket(2345);
  12.         while (true){
  13.             System.out.println("等待连接......");
  14.             Socket socket = serverSocket.accept();
  15.             new Thread(new serverThread(socket)).start();
  16.         }
  17.         //接受客户端发的文件名
  18.     }
  19. }
  21. class serverThread implements Runnable{
  22.     private Socket socket;
  24.     public serverThread(Socket socket) {
  25.         this.socket = socket;
  26.     }
  27.     @Override
  28.     public void run() {
  29.         try {
  30.             File file = new File("C:\\Users\\杨嘿嘿\\Desktop");
  31.             BufferedReader bf = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  32.             //读出文件名
  33.             String filename = bf.readLine();
  34.             //获取文件夹下的文件名数组
  35.             String[] list = file.list();
  36.             //将它转为list
  37.             ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(list)) ;
  38.             if (arrayList.contains(filename)){
  39.                 FileInputStream fis = new FileInputStream("C:\\Users\\杨嘿嘿\\Desktop\\"+filename);
  40.                 byte[] bs = new byte[2048];
  41.                 int len;
  42.                 while ((len=fis.read(bs))>0){
  43.                     socket.getOutputStream().write(bs,0,len);
  44.                 }
  45.                 System.out.println("传输完毕");
  46.                 socket.close();
  47.             }
  48.         } catch (IOException e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  52. }

//客户端

  1. package net4;
  3. import java.io.*;
  4. import java.net.Socket;
  5. import java.util.Scanner;
  7. public class client {
  8.     public static void main(String[] args) throws IOException {
  9.         Socket socket =  new Socket("127.0.0.1",2345);
  11.         Scanner sc = new Scanner(System.in);
  12.         System.out.println("请输入文件名：");
  13.         String filename = sc.next();
  15.         PrintStream ps = new PrintStream(socket.getOutputStream());
  16.         ps.println(filename);
  18.         InputStream is = socket.getInputStream();
  20.         FileOutputStream ous = new FileOutputStream("server_"+filename);
  21.         byte[] bs = new byte[1024];
  22.         int len;
  23.         while((len=is.read(bs))>0){
  24.             ous.write(bs,0,len);
  25.         }
  26.         System.out.println("传输完毕");
  27.         ous.close();
  28.     }
  29. }