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

 package cn.temptation;

 import java.net.InetAddress;

 public class Sample01 {
     public static void main(String[] args) throws Exception {
         /*
          * OSI模型：Open System Interconnection，开放系统互联
          * 分为七层：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层
          *
          * TCP/IP模型：
          * 分为四层：应用层、传输层、网际层、主机至网络层
          *
          * OSI模型的会话层、表示层、应用层        对应        TCP/IP模型的应用层
          * OSI模型的传输层                        对应        TCP/IP模型的传输层
          * OSI模型的网络层                        对应        TCP/IP模型的网际层
          * OSI模型的物理层、数据链路层            对应        TCP/IP模型的主机至网络层
          *
          * 常用协议：
          * 应用层：HTTP协议、HTTPS协议、FTP协议
          * 传输层：TCP协议、UDP协议
          * 网络层：IP协议
          *
          * 网络编程的三要素：地址、端口、协议
          * 类比：人  和   人  的交流
          *
          * 类 InetAddress：此类表示互联网协议 (IP) 地址。
          *
          * InetAddress类的常用成员方法：
          * 1、static InetAddress getByName(String host)：在给定主机名的情况下确定主机的 IP 地址。
          * 2、String getHostName()：获取此IP地址的主机名。
          * 3、String getHostAddress()：返回 IP地址字符串（以文本表现形式）。
          */

         // 命令行窗口下输出hostname，可以查看到本机的名称
         InetAddress address = InetAddress.getByName("temptation");
         System.out.println(address);        // temptation/192.168.137.2

         String hostname = address.getHostName();
         System.out.println(hostname);        // temptation

         String ip = address.getHostAddress();
         System.out.println(ip);                // 192.168.137.2
     }
 }

 package cn.temptation;

 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;

 public class Sample02 {
     public static void main(String[] args) throws IOException {
         /*
          * 传输协议：人们为了通信而制定的规则
          * 常用协议：UDP、TCP
          *
          * 套接字Socket的机制：
          * 1、进行通信的双方都有Socket
          * 2、网络通信实际是Socket之间的通信
          * 3、数据在Socket之间通过IO流进行传输
          *
          * Java语言中对UDP协议使用Socket进行了封装，提供了DatagramPacket类  和  DatagramSocket类
          *
          * 类 DatagramPacket：数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。
          *             从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。不对包投递做出保证。
          *
          * DatagramPacket类的常用构造函数：
          * 1、DatagramPacket(byte[] buf, int length)：构造 DatagramPacket，用来接收长度为 length 的数据包。
          * 2、DatagramPacket(byte[] buf, int length, InetAddress address, int port)：构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
          *
          * 类 DatagramSocket：此类表示用来发送和接收数据报包的套接字。
          * 数据报套接字是包投递服务的发送或接收点。每个在数据报套接字上发送或接收的包都是单独编址和路由的。
          *             从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。
          * 在 DatagramSocket上总是启用 UDP 广播发送。为了接收广播包，应该将DatagramSocket绑定到通配符地址。
          * 在某些实现中，将 DatagramSocket绑定到一个更加具体的地址时广播包也可以被接收。
          *
          * DatagramSocket类的常用成员方法：
          * 1、void send(DatagramPacket p)：从此套接字发送数据报包。
          * 2、void close()：关闭此数据报套接字。
          *
          * UDP协议的发送数据：
          * 1、创建发送端Socket对象
          * 2、创建数据，把数据进行打包
          * 3、调用Socket对象的发送方法发送数据包
          * 4、释放资源
          */

         // 1、创建发送端Socket对象
         DatagramSocket ds = new DatagramSocket();

         // 2、创建数据，把数据进行打包
         // A：创建数据
         byte[] arr = ("Hello, UDP").getBytes();
         // B：获取地址对象
         InetAddress address = InetAddress.getByName("temptation");
         // C：打包数据
         DatagramPacket dp = new DatagramPacket(arr, arr.length, address, 1234);

         // 3、调用Socket对象的发送方法发送数据包
         ds.send(dp);

         // 4、释放资源
         ds.close();
     }
 }

 package cn.temptation;

 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;

 public class Sample03 {
     public static void main(String[] args) throws IOException {
         /*
          * DatagramSocket类的常用构造函数：
          * DatagramSocket(int port)：创建数据报套接字并将其绑定到本地主机上的指定端口。
          *
          * DatagramSocket类的常用成员方法：
          * 1、void receive(DatagramPacket p)：从此套接字接收数据报包。
          *
          * DatagramPacket类的常用成员方法：
          * 1、byte[] getData()：返回数据缓冲区。
          * 2、int getLength()：返回将要发送或接收到的数据的长度。
          * 3、InetAddress getAddress()：返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。
          *
          * UDP协议的接收数据：
          * 1、创建接收端Socket对象
          * 2、创建一个数据包接收容器
          * 3、调用Socket对象的接收方法进行接收
          * 4、释放资源
          */

         // 1、创建接收端Socket对象
         DatagramSocket ds = new DatagramSocket(1234);

         // 2、创建一个数据包接收容器
         byte[] arr = new byte[1024];
         DatagramPacket dp = new DatagramPacket(arr, arr.length);

         // 3、调用Socket对象的接收方法进行接收
         ds.receive(dp);

         // 获取到的数据包内容可以使用
         byte[] temp = dp.getData();
         int length = dp.getLength();
         String result = new String(temp, 0, length);
         InetAddress address = dp.getAddress();

         System.out.println(address.getHostAddress() + "接收到的数据为：" + result);

         // 4、释放资源
         ds.close();
     }
 }

 package cn.temptation;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;

 public class Sample04 {
     public static void main(String[] args) throws IOException {
         // 需求：基于UDP协议，实现从键盘录入内容进行发送，如果输入886，则发送端结束输入；发送内容在接收端显示出来

         // 发送端

         // 创建Socket对象
         DatagramSocket ds = new DatagramSocket();

         // 键盘输入的标准输入流进行封装
         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

         String temp = null;

         while ((temp = reader.readLine()) != null) {
             if ("886".equals(temp)) {    // 终止循环
                 break;
             } else {
                 // 创建发送数据并打包
                 byte[] arr = temp.getBytes();
                 InetAddress address = InetAddress.getByName("temptation");
                 DatagramPacket dp = new DatagramPacket(arr, arr.length, address, 1234);

                 // 发送
                 ds.send(dp);
             }
         }

         // 释放资源
         ds.close();
     }
 }

 package cn.temptation;

 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;

 public class Sample05 {
     public static void main(String[] args) throws IOException {
         // 需求：基于UDP协议，实现从键盘录入内容进行发送，如果输入886，则发送端结束输入；发送内容在接收端显示出来

         // 接收端

         // 创建接收端的Socket对象
         DatagramSocket ds = new DatagramSocket(1234);

         // 创建一个数据包接收容器
         byte[] arr = new byte[1024];
         DatagramPacket dp = new DatagramPacket(arr, arr.length);

         // 接收数据
         ds.receive(dp);

         // 获取到的数据包内容可以使用
         byte[] temp = dp.getData();
         int length = dp.getLength();
         String result = new String(temp, 0, length);
         InetAddress address = dp.getAddress();

         System.out.println(address.getHostAddress() + "接收到的数据为：" + result);

         // 释放资源
         ds.close();
     }
 }

 package cn.temptation;

 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.Socket;

 public class Sample06 {
     public static void main(String[] args) throws IOException {
         /*
          * Java语言对TCP协议的使用封装了Socket，提供了：Socket类  和 ServerSocket类
          *
          * 类 Socket：实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
          * 套接字的实际工作由 SocketImpl 类的实例执行。
          * 应用程序通过更改创建套接字实现的套接字工厂可以配置它自身，以创建适合本地防火墙的套接字。
          *
          * Socket类的常用构造函数：
          * 1、Socket(InetAddress address, int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
          * 2、Socket(String host, int port)：创建一个流套接字并将其连接到指定主机上的指定端口号。
          *
          * Socket类的常用成员方法：
          * 1、OutputStream getOutputStream()：返回此套接字的输出流。
          * 2、InputStream getInputStream()：返回此套接字的输入流。
          * 3、void close()：关闭此套接字。
          *
          * 类 ServerSocket：实现服务器套接字。服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。
          * 服务器套接字的实际工作由 SocketImpl 类的实例执行。
          * 应用程序可以更改创建套接字实现的套接字工厂来配置它自身，从而创建适合本地防火墙的套接字。
          *
          * ServerSocket类的常用构造函数：
          * 1、ServerSocket(int port)：创建绑定到特定端口的服务器套接字。
          *
          * ServerSocket类的常用成员方法：
          * 1、Socket accept()：侦听并接受到此套接字的连接。
          * 2、void close()：关闭此套接字。
          *
          * TCP协议的发送数据：（客户端）
          * 1、创建客户端的Socket对象
          * 2、获取输出流，写出数据
          * 3、释放资源
          */

         // 1、创建客户端的Socket对象
         Socket socket = new Socket(InetAddress.getByName("temptation"), 1234);

         // 2、获取输出流，写出数据
         OutputStream os = socket.getOutputStream();
         os.write("Hello TCP".getBytes());

         // 3、释放资源
         socket.close();

         // 注意：
         // TCP的客户端没有连接服务端时执行，会产生执行异常：java.net.ConnectException: Connection refused: connect
         // UDP的发送端没有接收端时执行，不会产生执行异常
         // 理解：TCP类似打电话（没有对应号码时提示是空号或是不存在），UDP类似广播（喊一嗓子，听见了就听见了，没听见就没听见）
     }
 }

 package cn.temptation;

 import java.io.IOException;
 import java.io.InputStream;
 import java.net.ServerSocket;
 import java.net.Socket;

 public class Sample07 {
     public static void main(String[] args) throws IOException {
         /*
          * TCP协议的接收数据：（服务端）
          * 1、创建服务端的Socket对象
          * 2、监听客户端的连接，返回一个对应的Socket对象
          * 3、获取输入流
          * 4、释放资源
          */

         // 1、创建服务端的Socket对象
         ServerSocket serverSocket = new ServerSocket(1234);

         // 2、监听客户端的连接，返回一个对应的Socket对象
         //    监听客户端的连接，如果没有客户端连接时，一直阻塞
         Socket socket = serverSocket.accept();

         // 3、获取输入流
         InputStream is = socket.getInputStream();

         byte[] arr = new byte[1024];
         int length = is.read(arr);
         String result = new String(arr, 0, length);

         System.out.println("接收到的内容为：" +result);

         // 4、释放资源
         socket.close();
         serverSocket.close();
     }
 }

 package cn.temptation;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.Socket;

 public class Sample08 {
     public static void main(String[] args) throws IOException {
         // 需求：基于TCP协议，实现从键盘录入内容进行发送，如果输入886，则客户端结束输入；发送内容在服务端显示出来

         // 客户端

         // 创建客户端Socket对象
         Socket socket = new Socket("temptation", 1234);

         // 键盘录入数据
         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

         String temp = null;

         while ((temp = reader.readLine()) != null) {
             if ("886".equals(temp)) {
                 break;
             } else {
                 writer.write(temp);
                 writer.newLine();
                 writer.flush();
             }
         }

         // 释放资源
         writer.close();
         reader.close();
         socket.close();
     }
 }

 package cn.temptation;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.net.ServerSocket;
 import java.net.Socket;

 public class Sample09 {
     public static void main(String[] args) throws IOException {
         // 需求：基于TCP协议，实现从键盘录入内容进行发送，如果输入886，则客户端结束输入；发送内容在服务端显示出来

         // 服务端

         // 创建服务端Socket对象
         ServerSocket serverSocket = new ServerSocket(1234);

         // 监听连接
         Socket socket = serverSocket.accept();

         BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

         String temp = null;

         while ((temp = reader.readLine()) != null) {
             System.out.println("接收的内容为：" + temp);
         }

         // 释放资源
         reader.close();
         socket.close();
         serverSocket.close();
     }
 }