【原】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();
    }
}