【原】Java学习笔记034 - 网络

 1 package cn.temptation;
 2 
 3 import java.net.InetAddress;
 4 
 5 public class Sample01 {
 6     public static void main(String[] args) throws Exception {
 7         /*
 8          * OSI模型：Open System Interconnection，开放系统互联
 9          * 分为七层：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层
10          * 
11          * TCP/IP模型：
12          * 分为四层：应用层、传输层、网际层、主机至网络层
13          * 
14          * OSI模型的会话层、表示层、应用层        对应        TCP/IP模型的应用层
15          * OSI模型的传输层                        对应        TCP/IP模型的传输层
16          * OSI模型的网络层                        对应        TCP/IP模型的网际层
17          * OSI模型的物理层、数据链路层            对应        TCP/IP模型的主机至网络层
18          * 
19          * 常用协议：
20          * 应用层：HTTP协议、HTTPS协议、FTP协议
21          * 传输层：TCP协议、UDP协议
22          * 网络层：IP协议
23          * 
24          * 网络编程的三要素：地址、端口、协议
25          * 类比：人  和   人  的交流
26          * 
27          * 类 InetAddress：此类表示互联网协议 (IP) 地址。 
28          * 
29          * InetAddress类的常用成员方法：
30          * 1、static InetAddress getByName(String host)：在给定主机名的情况下确定主机的 IP 地址。 
31          * 2、String getHostName()：获取此IP地址的主机名。
32          * 3、String getHostAddress()：返回 IP地址字符串（以文本表现形式）。  
33          */
34         
35         // 命令行窗口下输出hostname，可以查看到本机的名称
36         InetAddress address = InetAddress.getByName("temptation");
37         System.out.println(address);        // temptation/192.168.137.2
38         
39         String hostname = address.getHostName();
40         System.out.println(hostname);        // temptation
41         
42         String ip = address.getHostAddress();
43         System.out.println(ip);                // 192.168.137.2
44     }
45 }

 1 package cn.temptation;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.InetAddress;
 7 
 8 public class Sample02 {
 9     public static void main(String[] args) throws IOException {
10         /*
11          * 传输协议：人们为了通信而制定的规则
12          * 常用协议：UDP、TCP
13          * 
14          * 套接字Socket的机制：
15          * 1、进行通信的双方都有Socket
16          * 2、网络通信实际是Socket之间的通信
17          * 3、数据在Socket之间通过IO流进行传输
18          * 
19          * Java语言中对UDP协议使用Socket进行了封装，提供了DatagramPacket类  和  DatagramSocket类
20          * 
21          * 类 DatagramPacket：数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。
22          *             从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。不对包投递做出保证。
23          * 
24          * DatagramPacket类的常用构造函数：
25          * 1、DatagramPacket(byte[] buf, int length)：构造 DatagramPacket，用来接收长度为 length 的数据包。
26          * 2、DatagramPacket(byte[] buf, int length, InetAddress address, int port)：构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
27          * 
28          * 类 DatagramSocket：此类表示用来发送和接收数据报包的套接字。
29          * 数据报套接字是包投递服务的发送或接收点。每个在数据报套接字上发送或接收的包都是单独编址和路由的。
30          *             从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。
31          * 在 DatagramSocket上总是启用 UDP 广播发送。为了接收广播包，应该将DatagramSocket绑定到通配符地址。
32          * 在某些实现中，将 DatagramSocket绑定到一个更加具体的地址时广播包也可以被接收。
33          * 
34          * DatagramSocket类的常用成员方法：
35          * 1、void send(DatagramPacket p)：从此套接字发送数据报包。
36          * 2、void close()：关闭此数据报套接字。
37          * 
38          * UDP协议的发送数据：
39          * 1、创建发送端Socket对象
40          * 2、创建数据，把数据进行打包
41          * 3、调用Socket对象的发送方法发送数据包
42          * 4、释放资源
43          */
44         
45         // 1、创建发送端Socket对象
46         DatagramSocket ds = new DatagramSocket();
47         
48         // 2、创建数据，把数据进行打包
49         // A：创建数据
50         byte[] arr = ("Hello, UDP").getBytes();
51         // B：获取地址对象
52         InetAddress address = InetAddress.getByName("temptation");
53         // C：打包数据
54         DatagramPacket dp = new DatagramPacket(arr, arr.length, address, 1234);
55         
56         // 3、调用Socket对象的发送方法发送数据包
57         ds.send(dp);
58         
59         // 4、释放资源
60         ds.close();
61     }
62 }

 1 package cn.temptation;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.InetAddress;
 7 
 8 public class Sample03 {
 9     public static void main(String[] args) throws IOException {
10         /*
11          * DatagramSocket类的常用构造函数：
12          * DatagramSocket(int port)：创建数据报套接字并将其绑定到本地主机上的指定端口。
13          * 
14          * DatagramSocket类的常用成员方法：
15          * 1、void receive(DatagramPacket p)：从此套接字接收数据报包。
16          * 
17          * DatagramPacket类的常用成员方法：
18          * 1、byte[] getData()：返回数据缓冲区。
19          * 2、int getLength()：返回将要发送或接收到的数据的长度。
20          * 3、InetAddress getAddress()：返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。 
21          * 
22          * UDP协议的接收数据：
23          * 1、创建接收端Socket对象
24          * 2、创建一个数据包接收容器
25          * 3、调用Socket对象的接收方法进行接收
26          * 4、释放资源
27          */
28         
29         // 1、创建接收端Socket对象
30         DatagramSocket ds = new DatagramSocket(1234);
31         
32         // 2、创建一个数据包接收容器
33         byte[] arr = new byte[1024];
34         DatagramPacket dp = new DatagramPacket(arr, arr.length);
35         
36         // 3、调用Socket对象的接收方法进行接收
37         ds.receive(dp);
38         
39         // 获取到的数据包内容可以使用
40         byte[] temp = dp.getData();
41         int length = dp.getLength();
42         String result = new String(temp, 0, length);
43         InetAddress address = dp.getAddress();
44         
45         System.out.println(address.getHostAddress() + "接收到的数据为：" + result);
46         
47         // 4、释放资源
48         ds.close();
49     }
50 }

 1 package cn.temptation;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.net.DatagramPacket;
 7 import java.net.DatagramSocket;
 8 import java.net.InetAddress;
 9 
10 public class Sample04 {
11     public static void main(String[] args) throws IOException {
12         // 需求：基于UDP协议，实现从键盘录入内容进行发送，如果输入886，则发送端结束输入；发送内容在接收端显示出来
13         
14         // 发送端
15         
16         // 创建Socket对象
17         DatagramSocket ds = new DatagramSocket();
18         
19         // 键盘输入的标准输入流进行封装
20         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
21         
22         String temp = null;
23         
24         while ((temp = reader.readLine()) != null) {
25             if ("886".equals(temp)) {    // 终止循环
26                 break;
27             } else {
28                 // 创建发送数据并打包
29                 byte[] arr = temp.getBytes();
30                 InetAddress address = InetAddress.getByName("temptation");
31                 DatagramPacket dp = new DatagramPacket(arr, arr.length, address, 1234);
32                 
33                 // 发送
34                 ds.send(dp);
35             }
36         }
37         
38         // 释放资源
39         ds.close();
40     }
41 }

 1 package cn.temptation;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.InetAddress;
 7 
 8 public class Sample05 {
 9     public static void main(String[] args) throws IOException {
10         // 需求：基于UDP协议，实现从键盘录入内容进行发送，如果输入886，则发送端结束输入；发送内容在接收端显示出来
11 
12         // 接收端
13 
14         // 创建接收端的Socket对象
15         DatagramSocket ds = new DatagramSocket(1234);
16 
17         // 创建一个数据包接收容器
18         byte[] arr = new byte[1024];
19         DatagramPacket dp = new DatagramPacket(arr, arr.length);
20 
21         // 接收数据
22         ds.receive(dp);
23 
24         // 获取到的数据包内容可以使用
25         byte[] temp = dp.getData();
26         int length = dp.getLength();
27         String result = new String(temp, 0, length);
28         InetAddress address = dp.getAddress();
29 
30         System.out.println(address.getHostAddress() + "接收到的数据为：" + result);
31 
32         // 释放资源
33         ds.close();
34     }
35 }

 1 package cn.temptation;
 2 
 3 import java.io.IOException;
 4 import java.io.OutputStream;
 5 import java.net.InetAddress;
 6 import java.net.Socket;
 7 
 8 public class Sample06 {
 9     public static void main(String[] args) throws IOException {
10         /*
11          * Java语言对TCP协议的使用封装了Socket，提供了：Socket类  和 ServerSocket类
12          * 
13          * 类 Socket：实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。 
14          * 套接字的实际工作由 SocketImpl 类的实例执行。
15          * 应用程序通过更改创建套接字实现的套接字工厂可以配置它自身，以创建适合本地防火墙的套接字。
16          * 
17          * Socket类的常用构造函数：
18          * 1、Socket(InetAddress address, int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
19          * 2、Socket(String host, int port)：创建一个流套接字并将其连接到指定主机上的指定端口号。
20          * 
21          * Socket类的常用成员方法：
22          * 1、OutputStream getOutputStream()：返回此套接字的输出流。
23          * 2、InputStream getInputStream()：返回此套接字的输入流。
24          * 3、void close()：关闭此套接字。
25          * 
26          * 类 ServerSocket：实现服务器套接字。服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。 
27          * 服务器套接字的实际工作由 SocketImpl 类的实例执行。
28          * 应用程序可以更改创建套接字实现的套接字工厂来配置它自身，从而创建适合本地防火墙的套接字。
29          * 
30          * ServerSocket类的常用构造函数：
31          * 1、ServerSocket(int port)：创建绑定到特定端口的服务器套接字。
32          * 
33          * ServerSocket类的常用成员方法：
34          * 1、Socket accept()：侦听并接受到此套接字的连接。
35          * 2、void close()：关闭此套接字。
36          * 
37          * TCP协议的发送数据：（客户端）
38          * 1、创建客户端的Socket对象
39          * 2、获取输出流，写出数据
40          * 3、释放资源
41          */
42         
43         // 1、创建客户端的Socket对象
44         Socket socket = new Socket(InetAddress.getByName("temptation"), 1234);
45         
46         // 2、获取输出流，写出数据
47         OutputStream os = socket.getOutputStream();
48         os.write("Hello TCP".getBytes());
49         
50         // 3、释放资源
51         socket.close();
52         
53         // 注意：
54         // TCP的客户端没有连接服务端时执行，会产生执行异常：java.net.ConnectException: Connection refused: connect
55         // UDP的发送端没有接收端时执行，不会产生执行异常
56         // 理解：TCP类似打电话（没有对应号码时提示是空号或是不存在），UDP类似广播（喊一嗓子，听见了就听见了，没听见就没听见）
57     }
58 }

 1 package cn.temptation;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.net.ServerSocket;
 6 import java.net.Socket;
 7 
 8 public class Sample07 {
 9     public static void main(String[] args) throws IOException {
10         /*
11          * TCP协议的接收数据：（服务端）
12          * 1、创建服务端的Socket对象
13          * 2、监听客户端的连接，返回一个对应的Socket对象
14          * 3、获取输入流
15          * 4、释放资源
16          */
17         
18         // 1、创建服务端的Socket对象
19         ServerSocket serverSocket = new ServerSocket(1234);
20         
21         // 2、监听客户端的连接，返回一个对应的Socket对象
22         //    监听客户端的连接，如果没有客户端连接时，一直阻塞
23         Socket socket = serverSocket.accept();
24         
25         // 3、获取输入流
26         InputStream is = socket.getInputStream();
27         
28         byte[] arr = new byte[1024];
29         int length = is.read(arr);
30         String result = new String(arr, 0, length);
31         
32         System.out.println("接收到的内容为：" +result);
33         
34         // 4、释放资源
35         socket.close();
36         serverSocket.close();
37     }
38 }

 1 package cn.temptation;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.OutputStreamWriter;
 8 import java.net.Socket;
 9 
10 public class Sample08 {
11     public static void main(String[] args) throws IOException {
12         // 需求：基于TCP协议，实现从键盘录入内容进行发送，如果输入886，则客户端结束输入；发送内容在服务端显示出来
13         
14         // 客户端
15         
16         // 创建客户端Socket对象
17         Socket socket = new Socket("temptation", 1234);
18         
19         // 键盘录入数据
20         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
21         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
22         
23         String temp = null;
24         
25         while ((temp = reader.readLine()) != null) {
26             if ("886".equals(temp)) {
27                 break;
28             } else {
29                 writer.write(temp);
30                 writer.newLine();
31                 writer.flush();
32             }
33         }
34         
35         // 释放资源
36         writer.close();
37         reader.close();
38         socket.close();
39     }
40 }

 1 package cn.temptation;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.net.ServerSocket;
 7 import java.net.Socket;
 8 
 9 public class Sample09 {
10     public static void main(String[] args) throws IOException {
11         // 需求：基于TCP协议，实现从键盘录入内容进行发送，如果输入886，则客户端结束输入；发送内容在服务端显示出来
12         
13         // 服务端
14         
15         // 创建服务端Socket对象
16         ServerSocket serverSocket = new ServerSocket(1234);
17         
18         // 监听连接
19         Socket socket = serverSocket.accept();
20         
21         BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
22         
23         String temp = null;
24         
25         while ((temp = reader.readLine()) != null) {
26             System.out.println("接收的内容为：" + temp);
27         }
28         
29         // 释放资源
30         reader.close();
31         socket.close();
32         serverSocket.close();
33     }
34 }