网络编程

1.1 网络概念

把多台计算机通过物理线路连接起来，就形成了网络。目的在于交换数据和共享信息。

1.1.1 网络通信的三要素

【1】IP地址:唯一标识网络上的每一台计算机。两台计算机之间通信的必备有素

【2】端口号:计算机中应用的标号(代表一个应用程序)

0-1024系统使用或保留端口

常见端口:http:80 stmp: 25 ftp:21

有效端口0-65536,开发者可以的端口是1025-65536之间。一些第三方引用如mysql:3306 oracle:1251。

【3】通信协议:通信的规则 TCP,UDP

1.1.2 网络通信模型

IP地址分类

特殊IP

0.0.0.0：本机
127.0.0.1：本机回环地址，用于本机测试
255.255.255.255：当前子网，一般用于向当前子网广播信息

1.2 InetAddress

InetAddress 表示IP地址。

 1 public class Test01 {
 2 
 3 public static void main(String[] args) {
 4 
 5 // 获取本机IP地址
 6 
 7 InetAddress ip1;
 8 
 9 try {
10 
11 ip1 = InetAddress.getLocalHost();
12 
13 // USER-20180113BT/192.168.2.56
14 
15 System.out.println(ip1.toString());
16 
17  
18 
19 // 获取主机名称
20 
21 System.out.println(ip1.getHostName());
22 
23 System.out.println(ip1.getHostAddress());
24 
25  
26 
27 } catch (UnknownHostException e) {
28 
29 e.printStackTrace();
30 
31 }
32 
33 }
34 
35 }

1.3 TCP 编程

TCP编程中，如果要完成通信，通信双方必须要创建socket，通过socket完成通信。

TCP通信步骤

[1] 服务器启动ServerSocket作为通信的Server端，等待客户端链入。

[2] 客户端创建Socket作为通信的Client端

[3] Client端链入Server端后建立可靠的、双向的、持续性的、点对点的通讯连接，即可通信。

案例:完成一次单向通信。

服务器端

 1 package cn.sxt01.net01;
 2 
 3  
 4 
 5 import java.io.IOException;
 6 
 7 import java.io.OutputStream;
 8 
 9 import java.net.ServerSocket;
10 
11 import java.net.Socket;
12 
13  
14 
15 public class Server01 {
16 
17 public static void main(String[] args) {
18 
19  
20 
21 System.out.println("服务器启动...");
22 
23  
24 
25 // 【1】创建server socket
26 
27 ServerSocket serverSocket = null;
28 
29 Socket clientSocket = null;
30 
31 try {
32 
33  
34 
35 serverSocket = new ServerSocket(8000);
36 
37 // 【2】等待客户端的链入->阻塞式函数->监听8000端口，看是否有client链入
38 
39 clientSocket = serverSocket.accept();
40 
41  
42 
43 System.out.println(clientSocket.getInetAddress().getHostAddress()+"链入!");
44 
45  
46 
47 // 【3】给客户端主动发信息
48 
49 OutputStream out = clientSocket.getOutputStream();
50 
51  
52 
53 String msg = "hello 兄弟";
54 
55 byte[] buf = msg.getBytes("UTF-8");
56 
57 out.write(buf);
58 
59 clientSocket.shutdownOutput();
60 
61  
62 
63 out.close();
64 
65  
66 
67  
68 
69 } catch (IOException e) {
70 
71 e.printStackTrace();
72 
73 }
74 
75 }
76 
77 }

客户端

 1 package cn.sxt02.net01;
 2 
 3  
 4 
 5 import java.io.IOException;
 6 
 7 import java.io.InputStream;
 8 
 9 import java.net.Socket;
10 
11  
12 
13 public class Client01 {
14 
15 public static void main(String[] args) {
16 
17 System.out.println("客户端运行...");
18 
19  
20 
21 // 【1】创建客户端socket
22 
23 Socket socket = null;
24 
25 try {
26 
27 socket = new Socket("192.168.2.56", 8000);
28 
29  
30 
31 // 【2】接收来自服务器的消息
32 
33 InputStream in = socket.getInputStream();
34 
35 byte[] buf = new byte[1024];
36 
37 int len = in.read(buf);
38 
39  
40 
41 String msg = new String(buf, 0, len, "UTF-8");
42 
43 System.out.println(msg);
44 
45  
46 
47 } catch (IOException e) {
48 
49 e.printStackTrace();
50 
51 }
52 
53 }
54 
55 }

常见问题

[1] 端口被占用

java.net.BindException: Address already in use: JVM_Bind
    at java.net.DualStackPlainSocketImpl.bind0(Native Method)
    at java.net.DualStackPlainSocketImpl.socketBind(DualStackPlainSocketImpl.java:106)
    at java.net.AbstractPlainSocketImpl.bind(AbstractPlainSocketImpl.java:387)
    at java.net.PlainSocketImpl.bind(PlainSocketImpl.java:190)
    at java.net.ServerSocket.bind(ServerSocket.java:375)
    at java.net.ServerSocket.<init>(ServerSocket.java:237)
    at java.net.ServerSocket.<init>(ServerSocket.java:128)
    at cn.sxt01.net02.Server01.main(Server01.java:19)

[2] 服务器未启动

java.net.ConnectException: Connection refused: connect

at java.net.DualStackPlainSocketImpl.connect0(Native Method)

at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:79)

at cn.sxt02.net02.Client01.main(Client01.java:15)

[3] 连接超时异常 SocketTimeoutException

当网速很慢时，可能发生连接超时异常。

需求:请上传张图片到服务器。

需求:在控制台输入用户名和密码，如果输入正确提示登录成功，否则登录失败。

1.1 UDP 编程

UDP编程中，如果要完成通信，通信双方必须要创建DatagramSocket，通过DatagramSocket完成通信。

数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器

UDP步骤:

[1] 创建一个DatagramSocket用于表示发送端，通过send方法发送数据报

[2] 创建一个DatagramSocket用于表示接收端，通过receive方法发送数据报

需求:完成一次单向的UDP通信。

发送端

  1 1.4UDP 编程
  2 UDP编程中，如果要完成通信，通信双方必须要创建DatagramSocket，通过DatagramSocket完成通信。
  3 
  4 数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器
  5 
  6 UDP步骤:
  7 [1] 创建一个DatagramSocket用于表示发送端，通过send方法发送数据报
  8 [2] 创建一个DatagramSocket用于表示接收端，通过receive方法发送数据报
  9 
 10 需求:完成一次单向的UDP通信。
 11 发送端
 12 public static void main(String[] args) {
 13         
 14         // 发送端:主动发送信息
 15         System.out.println("发送端开始发送信息...");
 16         // 【1】创建socket并指定发送数据的端口
 17         DatagramSocket socket = null;
 18         try {
 19             socket = new DatagramSocket(8000);
 20             
 21             // 【2】创建数据报包
 22             String msg = "hello B";
 23             byte[] buf = msg.getBytes("UTF-8");
 24             DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 9000);
 25             
 26             // 【3】发送
 27             socket.send(dp);
 28             
 29             // 【4】关闭
 30             socket.close();
 31         } catch (SocketException e) {
 32             e.printStackTrace();
 33         } catch (UnsupportedEncodingException e) {
 34             e.printStackTrace();
 35         } catch (UnknownHostException e) {
 36             e.printStackTrace();
 37         } catch (IOException e) {
 38             e.printStackTrace();
 39         }
 40     }
 41 
 42 接收端
 43 public static void main(String[] args) {
 44         // 接收端:接收信息
 45         System.out.println("启动接收端...");
 46         // 【1】创建一个 DatagramSocket
 47         DatagramSocket socket = null;
 48         try {
 49             socket = new DatagramSocket(9000);
 50             // 【2】接收消息
 51             byte[] buf = new byte[1024];
 52             DatagramPacket dp = new DatagramPacket(buf, buf.length);
 53             System.out.println("等待接收信息...");
 54             socket.receive(dp);
 55             System.out.println("接收完成...");
 56             
 57             // 处理接收的信息
 58             String msg = new String(buf, 0, dp.getLength(), "UTF-8");
 59             System.out.println(msg);
 60             
 61         } catch (SocketException e) {
 62             e.printStackTrace();
 63         } catch (IOException e) {
 64             e.printStackTrace();
 65         }
 66     }
 67 
 68 需求：实现双向通信
 69 发送端
 70 public static void main(String[] args) {
 71         
 72         // 发送端:主动发送信息
 73         System.out.println("发送端开始发送信息...");
 74         Scanner sc = new Scanner(System.in);
 75         // 【1】创建socket并指定发送数据的端口
 76         DatagramSocket socket = null;
 77         try {
 78             socket = new DatagramSocket(8000);
 79             
 80             for(;;) {
 81                 System.out.print("A说:");
 82                 String msg = sc.nextLine();
 83                 byte[] buf = msg.getBytes("UTF-8");
 84                 DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 9000);
 85                 
 86                 // 【3】发送
 87                 socket.send(dp);
 88                 
 89                 
 90                 // 接收消息
 91                 byte[] revBuf = new byte[1024];
 92                 DatagramPacket revDp = new DatagramPacket(revBuf,revBuf.length);
 93                 socket.receive(revDp);
 94                 String revStr = new String(revBuf, 0, revDp.getLength(), "UTF-8");
 95                 System.out.println(dp.getAddress().getHostName()+":"+revStr);
 96             }
 97             
 98         } catch (SocketException e) {
 99             e.printStackTrace();
100         } catch (UnsupportedEncodingException e) {
101             e.printStackTrace();
102         } catch (UnknownHostException e) {
103             e.printStackTrace();
104         } catch (IOException e) {
105             e.printStackTrace();
106         }finally {
107             // 【4】关闭
108             socket.close();
109         }
110     }
111 
112 
113 接收端
114     public static void main(String[] args) {
115         // 接收端:接收信息
116         System.out.println("启动接收端...");
117         Scanner sc = new Scanner(System.in);
118         // 【1】创建一个 DatagramSocket
119         DatagramSocket socket = null;
120         
121         try {
122             socket = new DatagramSocket(9000);
123             
124             for(;;) {
125                 // 接收信息
126                 byte[] buf = new byte[1024];
127                 DatagramPacket dp = new DatagramPacket(buf, buf.length);
128                 socket.receive(dp);
129                 String msg = new String(buf, 0, dp.getLength(), "UTF-8");
130                 System.out.println(dp.getAddress().getHostName()+":"+msg);
131                 
132                 // 发送信息
133                 System.out.println("B说:");
134                 String sendMsg = sc.nextLine();
135                 byte[] sendBuf = sendMsg.getBytes("UTF-8");
136                 DatagramPacket sendDp = new DatagramPacket(sendBuf, 0, sendBuf.length, dp.getAddress(), dp.getPort());
137                 socket.send(sendDp);
138             }
139             
140         } catch (SocketException e) {
141             e.printStackTrace();
142         } catch (IOException e) {
143             e.printStackTrace();
144         }finally {
145             socket.close();
146         }
147     }

接收端

 1 public static void main(String[] args) {
 2 
 3 // 接收端:接收信息
 4 
 5 System.out.println("启动接收端...");
 6 
 7 // 【1】创建一个 DatagramSocket
 8 
 9 DatagramSocket socket = null;
10 
11 try {
12 
13 socket = new DatagramSocket(9000);
14 
15 // 【2】接收消息
16 
17 byte[] buf = new byte[1024];
18 
19 DatagramPacket dp = new DatagramPacket(buf, buf.length);
20 
21 System.out.println("等待接收信息...");
22 
23 socket.receive(dp);
24 
25 System.out.println("接收完成...");
26 
27  
28 
29 // 处理接收的信息
30 
31 String msg = new String(buf, 0, dp.getLength(), "UTF-8");
32 
33 System.out.println(msg);
34 
35  
36 
37 } catch (SocketException e) {
38 
39 e.printStackTrace();
40 
41 } catch (IOException e) {
42 
43 e.printStackTrace();
44 
45 }
46 
47 }

需求：实现双向通信

发送端

 1 public static void main(String[] args) {
 2 
 3  
 4 
 5 // 发送端:主动发送信息
 6 
 7 System.out.println("发送端开始发送信息...");
 8 
 9 Scanner sc = new Scanner(System.in);
10 
11 // 【1】创建socket并指定发送数据的端口
12 
13 DatagramSocket socket = null;
14 
15 try {
16 
17 socket = new DatagramSocket(8000);
18 
19  
20 
21 for(;;) {
22 
23 System.out.print("A说:");
24 
25 String msg = sc.nextLine();
26 
27 byte[] buf = msg.getBytes("UTF-8");
28 
29 DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 9000);
30 
31  
32 
33 // 【3】发送
34 
35 socket.send(dp);
36 
37  
38 
39  
40 
41 // 接收消息
42 
43 byte[] revBuf = new byte[1024];
44 
45 DatagramPacket revDp = new DatagramPacket(revBuf,revBuf.length);
46 
47 socket.receive(revDp);
48 
49 String revStr = new String(revBuf, 0, revDp.getLength(), "UTF-8");
50 
51 System.out.println(dp.getAddress().getHostName()+":"+revStr);
52 
53 }
54 
55  
56 
57 } catch (SocketException e) {
58 
59 e.printStackTrace();
60 
61 } catch (UnsupportedEncodingException e) {
62 
63 e.printStackTrace();
64 
65 } catch (UnknownHostException e) {
66 
67 e.printStackTrace();
68 
69 } catch (IOException e) {
70 
71 e.printStackTrace();
72 
73 }finally {
74 
75 // 【4】关闭
76 
77 socket.close();
78 
79 }
80 
81 }

接收端

 1 public static void main(String[] args) {
 2 
 3 // 接收端:接收信息
 4 
 5 System.out.println("启动接收端...");
 6 
 7 Scanner sc = new Scanner(System.in);
 8 
 9 // 【1】创建一个 DatagramSocket
10 
11 DatagramSocket socket = null;
12 
13  
14 
15 try {
16 
17 socket = new DatagramSocket(9000);
18 
19  
20 
21 for(;;) {
22 
23 // 接收信息
24 
25 byte[] buf = new byte[1024];
26 
27 DatagramPacket dp = new DatagramPacket(buf, buf.length);
28 
29 socket.receive(dp);
30 
31 String msg = new String(buf, 0, dp.getLength(), "UTF-8");
32 
33 System.out.println(dp.getAddress().getHostName()+":"+msg);
34 
35  
36 
37 // 发送信息
38 
39 System.out.println("B说:");
40 
41 String sendMsg = sc.nextLine();
42 
43 byte[] sendBuf = sendMsg.getBytes("UTF-8");
44 
45 DatagramPacket sendDp = new DatagramPacket(sendBuf, 0, sendBuf.length, dp.getAddress(), dp.getPort());
46 
47 socket.send(sendDp);
48 
49 }
50 
51  
52 
53 } catch (SocketException e) {
54 
55 e.printStackTrace();
56 
57 } catch (IOException e) {
58 
59 e.printStackTrace();
60 
61 }finally {
62 
63 socket.close();
64 
65 }
66 
67 }

相关阅读:
生活
 Jupyter notebook修改默认文件夹\默认路径(亲测有效)
k8s的service及相关知识
 sql count()加distinct和条件去重统计
 为什么使用Nuxt.js？
注解（Annotation）
Servlet
Java反射
 Cookie
Spring配置文件
原文地址：https://www.cnblogs.com/qq308015824/p/10847130.html