Java033-网络编程

moc

1、简介
1. 网络编程含义：
         用Java语言实现计算机间数据的信息传递和资源共享。
2. 网络编程模型：
        ① OSI（Open System Interconnection开放系统互连）参考模型（7 层模型）
                应用层 》表示层 》会话层 》传输层 》网络层 》数据链路层 》物理层
        ② TCP/IP参考模型
                应用层 》传输层 》网际层 》链路层 》物理层
3. 网络编程三要素：
        ① IP地址
                》点分十进制记法，私有地址不在互联网上使用，用于局域网。
                》A类地址： 1.0.0.1—126.255.255.254     --- 保留给政府机构{10.X.X.X是私有地址}
                》B类地址：128.0.0.1—191.255.255.254  --- 中等规模的公司{172.16.0.0—172.31.255.255是私有地址、169.254.X.X是保留地址}
                》C类地址：192.0.0.1—223.255.255.254  --- 任何需要的人{192.168.X.X是私有地址}
                》D类地址：224.0.0.1—239.255.255.254  
                》E类地址：240.0.0.1—255.255.255.254
                》127.X.X.X为保留地址，用做循环测试用的。
        ② 端口
                同一个主机内不同应用程序的标识，范围：0-65535。其中0-1024不建议使用。
        ③ 协议
                》TCP：建立数据通道，全双工，无边界流，效率低，面向连接，可靠
                》UDP：无数据通道，全双工，数据打包，效率高，无连接，不可靠
4. Socket机制
        ① 通信两端都应该有Socket对象；
        ② 客户端和服务器通过对 Socket 对象的写入和读取来进行通信；
2、UDP通讯
1. 相关API
InetAddress类: --- 互联网协议 (IP) 地址
public static InetAddress getByName(String host) ----> 在给定主机名的情况下确定主机的 IP 地址; 主机名可以是机器名，也可是其 IP 地址的文本表示形式。
public String getHostName()  ---------------------------->  获取此 IP 地址的主机名。
public String getHostAddress() -------------------------->  返回 IP 地址字符串（文本表现形式）。
DatagramSocket类: --- 表示用来发送和接收数据报包(UDP)的套接字
public DatagramSocket()  ----------------------------------- -->  构造数据报套接字并将其绑定到本地主机上任何可用的端口。
public DatagramSocket(int port)  ----------------------------->  创建数据报套接字并将其绑定到本地主机上的指定端口，IP 地址由内核选择。
public DatagramSocket(int port, InetAddress laddr) ------>  创建数据报套接字，将其绑定到指定的本地地址。
public void receive(DatagramPacket p)  --------------------->  从此套接字接收数据报包。
public void send(DatagramPacket p) ------------------------>  从此套接字发送数据报包。
DatagramPacket类: --- 表示数据报包，用来实现无连接包投递服务。
public DatagramPacket(byte[] buf, int length)  ------------>  构造 DatagramPacket，用来接收长度为 length 的数据包。
public DatagramPacket(byte[] buf, int length, InetAddress address, int port)  -----> 构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
public InetAddress getAddress()  ----------------------------->  返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。
public byte[] getData()    -------------------------------------->   返回将要发送或接收到的数据缓冲区内容。
public int getLength()  ------------------------------------------>  返回将要发送或接收到的数据的长度。
2. UDP协议发送数据
步骤：
        ① 创建发送端Socket对象；
        ② 创建数据，并把数据打包；
        ③ 调用Socket对象的发送方法发送数据包；
        ④ 释放资源。

1. public class UdpSendDemo {
   
2.         public static void main(String[] args) throws IOException {
   
3.                 // 创建发送端Socket对象
   
4.                 DatagramSocket ds = new DatagramSocket();
   
5. 
   
6.                 // 创建数据，并把数据打包
   
7.                 byte[] bys = "UDP,你好！".getBytes();  // 创建数据
   
8.                 int length = bys.length;  // 长度
   
9.                 InetAddress address = InetAddress.getByName("192.168.12.92");  // IP地址对象
   
10.                 int port = 10086;        // 端口
    
11.                 DatagramPacket dp = new DatagramPacket(bys, length, address, port);
    
12. 
    
13.                 // 调用Socket对象的发送方法发送数据包
    
14.                 ds.send(dp);
    
15. 
    
16.                 // 释放资源
    
17.                 ds.close();
    
18.         }
    
19. }

复制代码

3. UDP协议接受数据
步骤：
        ① 创建接收端Socket对象；
        ② 创建一个数据包(接收容器)；
        ③ 调用Socket对象的接收方法接收数据；
        ④ 解析数据包，并显示在控制台；
        ⑤ 释放资源。

1. public class UdpReceiveDemo {
   
2.         public static void main(String[] args) throws IOException {
   
3.                 // 创建接收端Socket对象
   
4.                 DatagramSocket ds = new DatagramSocket(10086);
   
5. 
   
6.                 // 创建一个数据包(接收容器)
   
7.                 byte[] bys = new byte[1024];
   
8.                 int length = bys.length;
   
9.                 DatagramPacket dp = new DatagramPacket(bys, length);
   
10. 
    
11.                 // 调用Socket对象的接收方法接收数据
    
12.                 ds.receive(dp); // 阻塞式
    
13. 
    
14.                 // 解析数据包，并显示在控制台
    
15.                 InetAddress address = dp.getAddress();  // 获取对方的ip
    
16.                 String ip = address.getHostAddress();
    
17.                 byte[] bys2 = dp.getData();   // 获取数据缓冲区
    
18.                 int len = dp.getLength();     // 获取数据的实际长度
    
19.                 String s = new String(bys2, 0, len);
    
20.                 System.out.println(ip + "传递的数据是:" + s);
    
21. 
    
22.                 // 释放资源
    
23.                 ds.close();
    
24.         }
    
25. }

复制代码

4. 多线程结合收发UDP数据包

1. // ***********发送UDP数据报类
   
2. public class UdpSendThread implements Runnable {
   
3.         private DatagramSocket ds;
   
4.         public SendThread(DatagramSocket ds) {
   
5.                 this.ds = ds;
   
6.         }
   
7. 
   
8.         @Override
   
9.         public void run() {
   
10.                 try {
    
11.                         // 封装键盘录入数据
    
12.                         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
13.                         String line = null;
    
14.                         while ((line = br.readLine()) != null) {
    
15.                                 if ("886".equals(line)) {
    
16.                                         break;
    
17.                                 }
    
18. 
    
19.                                 // 创建数据并打包
    
20.                                 byte[] bys = line.getBytes();
    
21.                                 DatagramPacket dp = new DatagramPacket(bys, bys.length,
    
22.                                                                         InetAddress.getByName("192.168.12.255"), 12306);
    
23. 
    
24.                                 // 发送数据
    
25.                                 ds.send(dp);
    
26.                         }
    
27. 
    
28.                         // 释放资源
    
29.                         ds.close();
    
30.                 } catch (IOException e) {
    
31.                         e.printStackTrace();
    
32.                 }
    
33.         }
    
34. }
    
35. // ***********接受UDP数据报类
    
36. public class ReceiveThread implements Runnable {
    
37.         private DatagramSocket ds;
    
38.         public ReceiveThread(DatagramSocket ds) {
    
39.                 this.ds = ds;
    
40.         }
    
41. 
    
42.         @Override
    
43.         public void run() {
    
44.                 try {
    
45.                         while (true) {
    
46.                                 // 创建一个包裹
    
47.                                 byte[] bys = new byte[1024];
    
48.                                 DatagramPacket dp = new DatagramPacket(bys, bys.length);
    
49. 
    
50.                                 // 接收数据
    
51.                                 ds.receive(dp);
    
52. 
    
53.                                 // 解析数据
    
54.                                 String ip = dp.getAddress().getHostAddress();
    
55.                                 String s = new String(dp.getData(), 0, dp.getLength());
    
56.                                 System.out.println("from " + ip + " data is : " + s);
    
57.                         }
    
58.                 } catch (IOException e) {
    
59.                         e.printStackTrace();
    
60.                 }
    
61.         }
    
62. }
    
63. // ***********测试类
    
64. public class ChatRoom {
    
65.         public static void main(String[] args) throws IOException {
    
66.                 DatagramSocket dsSend = new DatagramSocket();
    
67.                 DatagramSocket dsReceive = new DatagramSocket(12306);
    
68. 
    
69.                 SendThread st = new SendThread(dsSend);
    
70.                 ReceiveThread rt = new ReceiveThread(dsReceive);
    
71. 
    
72.                 Thread t1 = new Thread(st);
    
73.                 Thread t2 = new Thread(rt);
    
74. 
    
75.                 t1.start();
    
76.                 t2.start();
    
77.         }
    
78. }

复制代码

3、TCP通讯
1. 相关API
Socket类: --- TCP客户端套接字
public Socket(InetAddress address, int port) --------> 创建一个流套接字并将其连接到指定 IP 地址的指定端口号
public InetAddress getInetAddress()  ----------------->  返回套接字连接的地址。
public InputStream getInputStream()  ---------------->  返回此套接字的输入流。
public OutputStream getOutputStream()  ------------>  返回此套接字的输出流。
public void shutdownOutput()  -------------------------->   通知对方套接字写入结束。
ServerSocket类: --- TCP服务器套接字
public ServerSocket(int port)  -------------------------->  创建绑定到特定端口的服务器套接字。
public Socket accept() ---------------------------------->  侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。
2. TCP客户端实现
步骤：
        ① 创建发送端的Socket对象；
        ② 这一步如果成功，就说明连接已经建立成功；
        ③ 获取输出流写数据，获取输入流读数据 ；
        ④ 释放资源；
以下以客户端向服务器上传文件为例：
注意：
        读取文本文件时可以以null作为结束信息的，TCP流通道不能以null结束；
        于是① 自定义结束标记；
              ② Socket对象提供了一种解决方案，public void shutdownOutput()

1. public class UdpUploadClient {
   
2.          public static void main(String[] args) throws IOException {
   
3.                 // 创建客户端Socket对象
   
4.                 Socket s = new Socket("192.168.12.92", 11111);
   
5. 
   
6.                 // 封装文本文件
   
7.                 BufferedReader br = new BufferedReader(new FileReader("123.txt"));
   
8.                 // 封装通道内流
   
9.                 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
   
10. 
    
11.                 String line = null;
    
12.                 while ((line = br.readLine()) != null) { // 阻塞
    
13.                         bw.write(line);
    
14.                         bw.newLine();
    
15.                         bw.flush();
    
16.                 }
    
17.                 //自定义一个结束标记
    
18.                 //bw.write("over");
    
19.                 //bw.newLine();
    
20.                 //bw.flush();
    
21.                
    
22.                 //Socket提供了一个终止，它会通知服务器：客户端数据传输已结束
    
23.                 s.shutdownOutput();
    
24. 
    
25.                 // 接收反馈
    
26.                 BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
    
27.                 String client = brClient.readLine();   // 阻塞
    
28.                 System.out.println(client);
    
29. 
    
30.                 // 释放资源
    
31.                 br.close();
    
32.                 s.close();
    
33.         }
    
34. }

复制代码

3. TCP服务器实现
步骤：
        ① 创建接收端的Socket对象；
        ② 监听客户端连接。返回一个对应的Socket对象；
        ③ 获取输出流写数据，获取输入流读数据 ；
        ④ 释放资源。

1. public class UploadServer {
   
2.         public static void main(String[] args) throws IOException {
   
3.                 // 创建服务器端的Socket对象，并绑定端口
   
4.                 ServerSocket ss = new ServerSocket(11111);
   
5. 
   
6.                 // 监听客户端连接
   
7.                 Socket s = ss.accept(); // 阻塞
   
8. 
   
9.                 // 封装通道内的流
   
10.                 BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
    
11.                 // 封装文本文件
    
12.                 BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.txt"));
    
13. 
    
14.                 String line = null;
    
15.                 while ((line = br.readLine()) != null) { // 阻塞
    
16.                         // if("over".equals(line)){   // 采用自定义“over”结束符
    
17.                         // break;
    
18.                         // }
    
19.                         bw.write(line);
    
20.                         bw.newLine();
    
21.                         bw.flush();
    
22.                 }
    
23. 
    
24.                 // 给出反馈
    
25.                 BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
    
26.                 bwServer.write("文件上传成功");
    
27.                 bwServer.newLine();
    
28.                 bwServer.flush();
    
29. 
    
30.                 // 释放资源
    
31.                 bw.close();
    
32.                 s.close();
    
33.         }
    
34. }

复制代码

4. TCP服务器多线程实现并发
支持服务器能够被多个客户端连接。

1. // **********  服务器线程类
   
2. public class UserUdpThread implements Runnable {
   
3.         private Socket s;
   
4.         public UserUdpThread (Socket s) {
   
5.                 this.s = s;
   
6.         }
   
7. 
   
8.         @Override
   
9.         public void run() {
   
10.                 try {
    
11.                         // 封装通道内的流
    
12.                         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
    
13.                         // 封装文本文件
    
14.                         // BufferedWriter bw = new BufferedWriter(newFileWriter("Copy.txt"));
    
15. 
    
16.                         // 为了防止名称冲突
    
17.                         String newName = System.currentTimeMillis() + ".txt";
    
18.                         BufferedWriter bw = new BufferedWriter(new FileWriter(newName));
    
19. 
    
20.                         String line = null;
    
21.                         while ((line = br.readLine()) != null) { // 阻塞
    
22.                                 bw.write(line);
    
23.                                 bw.newLine();
    
24.                                 bw.flush();
    
25.                         }
    
26. 
    
27.                         // 给出反馈
    
28.                         BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
    
29.                         bwServer.write("文件上传成功");
    
30.                         bwServer.newLine();
    
31.                         bwServer.flush();
    
32. 
    
33.                         // 释放资源
    
34.                         bw.close();
    
35.                         s.close();
    
36.                 } catch (IOException e) {
    
37.                         e.printStackTrace();
    
38.                 }
    
39.         }
    
40. }
    
41. // **********  服务器
    
42. public class UploadUdpServer {
    
43.         public static void main(String[] args) throws IOException {
    
44.                 // 创建服务器Socket对象
    
45.                 ServerSocket ss = new ServerSocket(11111);
    
46. 
    
47.                 while (true) {
    
48.                         Socket s = ss.accept();
    
49.                         new Thread(new UserUdpThread(s)).start();
    
50.                 }
    
51.         }
    
52. }

复制代码

ALWAYS浩然

琴长不过时光

不错的内容 能写多一点就好了

erh

public class UserUdpThread implements Runnable {
        private Socket s;
        public UserThread(Socket s) {
                this.s = s;
        }

构造函数拼写错误l

moc

erh 发表于 2019-8-27 21:07
public class UserUdpThread implements Runnable {
        private Socket s;
&#1 ...

谢谢提醒，已修正。