网络编程笔记

网络编程

如何实现网络的通信？

通信双方地址：

  • ip

  • 端口号

  • 192.168.0.124:5900

规则：网络通信的协议

小结：

  1. 网络编程中有两个主要的问题

    • 如何准确的定位到网络上的一台主机

    • 找到主机之后如何进行通信

  2. 网络编程中的要素

    • IP和端口号 IP

    • 网络通信协议 udp ,tcp

  3. 万物皆对象

IP

ip地址：InetAddress

  • 唯一定位一台网络上的计算机

  • 127.0.0.1:本机localhost

  • ip地址的分类

    • ipv4/ipv6

      • IPV4

      • IPV6

    • 公网/私网

      ABCD类

端口

端口表示计算机上的一个程序的进程；

  • 不同的进程有不同的端口号！用来区别软件

  • 被规定0~65535

  • TCP，UDP：65535*2 单个协议下，端口号不能冲突

  • 端口分类

    • 公有端口：0~1023

      • HTTP：80

      • HTTPS：443

      • FTP：21

      • Telent：23

    • 程序注册端口：1024~49151，分配用户或者程序

      • Tomcat:8080

      • MySQL:3306

      • Oracle:1521

    • 动态、私有：49152~65535

      netstat -ano  #查看所有端口
netstat -ano|findstr "XXX" #查看指定的端口
tasklist|findstr "XXX"  #查看指定端口的进程

通讯协议

TCP UDP对比

TCP:打电话

  • 连接，稳定

  • 三次握手，四次挥手

  • 客户端，服务端

  • 传输完成，释放连接，效率低

UDP:发信息

  • 不连接，不稳定

  • 客户端、服务端：没有明确的界限

  • 不管有没有准备好，都可以发给你

TCP

客户端

  1. 连接服务器socket

  2. 发送消息

 1  package com.study.demo02;
 2  ​
 3  import java.io.IOException;
 4  import java.io.OutputStream;
 5  import java.net.InetAddress;
 6  import java.net.Socket;
 7  import java.net.UnknownHostException;
 8  import java.nio.charset.StandardCharsets;
 9  ​
10  //客户端
11  public class TcpClientDemo01 {
12      public static void main(String[] args){
13          Socket socket = null;
14          OutputStream os = null;
15          try {
16              //1,要知道服务器的地址，端口号
17              InetAddress serverIP = InetAddress.getByName("127.0.0.1");
18              int port = 8090;
19              //2,创建一个socket连接
20              socket = new Socket(serverIP,port);
21              //3，发送消息IO流
22              os = socket.getOutputStream();
23              os.write("你好，吃了吗？".getBytes());
24          } catch (Exception e) {
25              e.printStackTrace();
26          }finally {
27              //关闭资源
28              if(os!=null){
29                  try {
30                      os.close();
31                  } catch (IOException e) {
32                      e.printStackTrace();
33                  }
34              }
35              if(socket!=null){
36                  try {
37                      socket.close();
38                  } catch (IOException e) {
39                      e.printStackTrace();
40                  }
41              }
42          }
43  ​
44      }
45  ​
46  }

服务器

  1. 建立服务的端口ServerSocket

  2. 等待用户的连接accept

  3. 接收用户的消息

 1  package com.study.demo02;
 2  ​
 3  import java.io.ByteArrayOutputStream;
 4  import java.io.IOException;
 5  import java.io.InputStream;
 6  import java.net.ServerSocket;
 7  import java.net.Socket;
 8  ​
 9  //服务端
10  public class TcpServerDemo02 {
11      public static void main(String[] args){
12          ServerSocket serverSocket = null;
13          Socket socket = null;
14          InputStream is = null;
15          ByteArrayOutputStream baos = null;
16          try {
17              //1,我得有一个地址
18              serverSocket = new ServerSocket(8090);
19             //循环监听
20              while (true){
21                 //2,等待用户的连接过来
22                 socket = serverSocket.accept();
23                 //3,接受客户端的消息
24                 is = socket.getInputStream();
25                 //管道流
26                 baos = new ByteArrayOutputStream();
27                 byte[] buf = new byte[1024];
28                 int len;
29                 while((len=is.read(buf))!=-1){
30                     baos.write(buf,0,len);
31                 }
32                 System.out.println(baos.toString());
33             }
34  ​
35               /*
36          太low了
37          byte[] buf = new byte[1024];
38          int len;
39          while((len=is.read(buf))!=-1){
40              String msg = new String(buf,0,len);
41              System.out.println(msg);
42          }
43           */
44  ​
45          } catch (IOException e) {
46              e.printStackTrace();
47          }finally {
48              //关闭资源
49              if (baos!=null){
50                  try {
51                      baos.close();
52                  } catch (IOException e) {
53                      e.printStackTrace();
54                  }
55              }
56             if (is!=null){
57                 try {
58                     is.close();
59                 } catch (IOException e) {
60                     e.printStackTrace();
61                 }
62             }
63             if (socket!=null){
64                 try {
65                     socket.close();
66                 } catch (IOException e) {
67                     e.printStackTrace();
68                 }
69             }
70             if (serverSocket!=null){
71                 try {
72                     serverSocket.close();
73                 } catch (IOException e) {
74                     e.printStackTrace();
75                 }
76             }
77  ​
78  ​
79  ​
80          }
81      }
82  }

文件上传

服务器端：

 1 package com.study.demo02.TcpPCDemo02;
 2  ​
 3  import java.io.*;
 4  import java.net.ServerSocket;
 5  import java.net.Socket;
 6  ​
 7  public class TcpServerDemo02 {
 8      public static void main(String[] args) throws IOException {
 9          //创建出服务
10          ServerSocket serverSocket = new ServerSocket(8000);
11          //等待客户端连接
12          Socket socket = serverSocket.accept();//阻塞式监听
13          //创建一个输入流
14          InputStream is = socket.getInputStream();
15          //接收文件
16          FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
17          byte[] buffer = new byte[1024];
18          int len;
19          while ((len=is.read(buffer))!=-1){
20              fos.write(buffer,0,len);
21          }
22  ​
23          //通知客户端，我已经接收完毕了
24          OutputStream os = socket.getOutputStream();
25          os.write("我已经接收完毕了，你可以断开了！".getBytes());
26  ​
27          //关闭资源
28          os.close();
29          fos.close();
30          is.close();
31          socket.close();
32          serverSocket.close();
33  ​
34  ​
35  ​
36      }
37  }

客户端

 1 package com.study.demo02.TcpPCDemo02;
 2 
 3 import java.io.*;
 4 import java.net.InetAddress;
 5 import java.net.Socket;
 6 
 7 public class TcpClientDemo02 {
 8     public static void main(String[] args) throws IOException {
 9         //1,建立连接
10         Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 8000);
11         //创建一个输出流
12         OutputStream os = socket.getOutputStream();
13         //读取文件
14         FileInputStream fis = new FileInputStream(new File("TestFile.jpg"));
15         //发送文件
16         byte[] buffer = new byte[1024];
17         int len;
18         while((len=fis.read(buffer))!=-1){
19             os.write(buffer,0,len);
20         }
21 
22         //告诉服务端我发送完毕了
23         socket.shutdownOutput();
24 
25         //确认服务端接收完毕，才能断开连接
26         InputStream is = socket.getInputStream();
27         //管道流
28         ByteArrayOutputStream baos = new ByteArrayOutputStream();
29         byte[] buffer2 = new byte[1024];
30         int len2;
31         while ((len2= is.read(buffer2))!=-1){
32             baos.write(buffer2,0,len2);
33         }
34         System.out.println(baos.toString());
35         //关闭资源
36         baos.close();
37         fis.close();
38         os.close();
39         socket.close();
40     }
41 }

Tomcat

服务器

  • 自定义 S

  • Tomcat服务器S

客户端

  • 自定义C

  • 浏览器B

UDP

发短息，不需要连接

发送端

 1 package com.study.demo02.UDPDemo01;
 2 
 3 import java.net.DatagramPacket;
 4 import java.net.DatagramSocket;
 5 import java.net.InetAddress;
 6 import java.net.SocketException;
 7 
 8 public class UdpClientDemo01 {
 9     public static void main(String[] args) throws Exception {
10         //建立一个socket
11         DatagramSocket socket = new DatagramSocket();
12         //建个包
13         String msg = "你好呀，服务器";
14         InetAddress localhost = InetAddress.getByName("localhost");
15         int port = 9090;
16         DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,port);
17         //发送包
18         socket.send(packet);
19 
20         //关闭资源
21         socket.close();
22     }
23 }

接收端

package com.study.demo02.UDPDemo01;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

//还是要等待客户端的连接
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
        socket.receive(packet);//阻塞接收

        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));

        //关闭连接
        socket.close();
    }
}

聊天实现

发送端

 1 package com.study.demo02.UdpDemo02;
 2 
 3 
 4 import java.io.BufferedReader;
 5 import java.io.InputStreamReader;
 6 import java.net.DatagramPacket;
 7 import java.net.DatagramSocket;
 8 import java.net.InetSocketAddress;
 9 import java.net.SocketException;
10 
11 public class UdpSenderDemo01 {
12     public static void main(String[] args) throws Exception {
13         DatagramSocket socket = new DatagramSocket(8000);
14 
15         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
16 
17         while (true){
18             String data = reader.readLine();
19             byte[] datas = data.getBytes();
20             DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6000));
21 
22             socket.send(packet);
23             if (data.equals("bye")){
24                 break;
25             }
26         }
27 
28 
29         socket.close();
30     }
31 }

接收端

 1 package com.study.demo02.UdpDemo02;
 2 
 3 import java.net.DatagramPacket;
 4 import java.net.DatagramSocket;
 5 import java.net.SocketException;
 6 
 7 public class UdpReceiverDemo01 {
 8     public static void main(String[] args) throws Exception {
 9         DatagramSocket socket = new DatagramSocket(6000);
10 
11         while (true){
12             byte[] container = new byte[1024];
13             DatagramPacket packet = new DatagramPacket(container,0,container.length);
14             socket.receive(packet);
15 
16             byte[] data = packet.getData();
17             String receiveDatas = new String(data,0,packet.getLength());
18             //注意String receiveDatas = new String(data,0,data.length());是不行的，是一个坑。
19             //packet.getLength==实际长度，而data.length==1024!
20             /*DatagramPacket的两个方法getData()和getLength()是不对应的。
21             getLength()反映了刚刚接收到的数据的长度，而getData()反映了DatagramPacket对应缓冲区中的新接收到的数据和未被覆盖的旧数据，
22             当我们使用DatagramPacket来处理新接收到的数据时，就容易同时触及到旧数据导致混乱。
23              */
24             System.out.println(receiveDatas);
25 
26             if (receiveDatas.equals("bye")){
27                 break;
28             }
29         }
30         sorket.close;
31     }
32 }
posted @ 2022-04-08 16:31  冰山醉酒  阅读(136)  评论(0)    收藏  举报