[网络协议]023Java基础之网络编程

1、 网络的相关概念

1.1、 网络通信

概念两台设备之间通过网络实现数据传输
网络通信将数据通过网络从一台设备传输到另外一台设备
java.net包下提供了一系列的类和接口，供程序员使用，完成网络通信

1.2、网络

概念两台或多台设备之间通过一定物理设备连接起来构成网络

1.3、ip地址

概念用来表示网络中的唯一一台计算机

2、 InetAddress 类

2.1、相关方法

（1）getLocalHost() 获取本机InteAddress对象
（2）getByName()根据指定主机名/域名获取ip地址对象
（3）getHostName() 获取InetAddress对象的主机名
（4）getHostAddress()获取InetAddress对象的地址

package com.francis.api;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @author Francis
 * @create 2022-03-05 6:06
 */
public class InetAddress_ {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机 InetAddress 对象 getLocalHost
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);
        //根据指定主机名/域名获取 ip 地址对象 getByName
        InetAddress host2 = InetAddress.getByName("Francis");
        System.out.println(host2);
        InetAddress host3 = InetAddress.getByName("www.baidu.com");
        System.out.println(host3);
        //获取 InetAddress 对象的主机名 getHostName
        String host3Name = host3.getHostName();
        System.out.println(host3Name);
        //获取InetAddress 对象的地址 getHostAddress
        String host3Address = host3.getHostAddress();
        System.out.println(host3Address);
    }
}

3、Socket

3.1、基本介绍

（1）套接字（Socket）开发网络应用程序被广泛应用，以至于称为事实上的标准
（2）通信的两端都要有Socket,是两台机器通信的断点
（3）Socket允许把网络连接当成一个流，数据在两个Socket间通过IO传输
（4）一般主动发起通信的一端称为客户端，等待通信请求的一端称为服务端

4、TCP 网络通信编程

4.1、基本介绍

（1）基于客户端-服务端的网络通信
（2）底层使用的是TCP/IP协议
（3）基于TCP的socket编程

4.2、应用案例 1(使用字节流)

（1） 编写一个服务端、一个客户端
（2）服务器在9999端口监听
（3）客户端连接到服务器，发送“hello server”，然后退出
（4）服务端接受到客户端发送的消息，输出并退出

package com.francis.socket;

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


/**
 * @author Francis
 * @create 2022-03-05 6:47
 */
public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端在9999端口监听，等待连接");
        //当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有客户端连接则会返回一个socket对象
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket=" + socket.getClass());
        InputStream inputStream = socket.getInputStream();
        byte[] buff = new byte[1024];
        int readLen = 0;
        String content = "";
        while ((readLen = inputStream.read(buff)) != -1) {
            System.out.println(new String(buff, 0, readLen));
            content += new String(buff, 0, readLen);
        }
        System.out.println(content);
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

package com.francis.socket;

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

/**
 * @author Francis
 * @create 2022-03-05 6:47
 */
public class Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket 返回="+socket.getClass());
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server".getBytes());
        outputStream.close();
        socket.close();
    }
}

4.3、应用案例 2(使用字节流)

（1）编写一个服务端、一个客户端
（2）服务器在9999端口监听
（3）客户端连接到服务器，发送“hello server”，并接收服务器发回的“hello client”，然后退出
（4）服务端接受到客户端发送的消息，输出，并向客户端发送“hello client” ，然后退出

package com.francis.socket;

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

/**
 * @author Francis
 * @create 2022-03-05 8:17
 */
public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器端正在监听9999端口");
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        byte[] buff = new byte[1024];
        int readLen = 0;
        while((readLen = inputStream.read(buff))!=-1){
            System.out.println(new String(buff,0,readLen));
        }
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello client".getBytes());
        // 设置结束标记,这里如果socket断开了，也可以取到结束标记的作用
        socket.shutdownOutput();
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

package com.francis.socket;

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

/**
 * @author Francis
 * @create 2022-03-05 8:17
 */
public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLoopbackAddress(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server" .getBytes());
        // 设置结束标记
        socket.shutdownOutput();
        InputStream inputStream = socket.getInputStream();
        byte[] buff = new byte[1024];
        int readLen = 0;
        while((readLen = inputStream.read(buff))!=-1){
            System.out.println(new String(buff,0,readLen));
        }
        inputStream.close();
        outputStream.close();
        socket.close();
    }
}

4.4、 应用案例 3(使用字符流)

（1）编写一个服务端、一个客户端
（2）服务器在9999端口监听
（3）客户端连接到服务器，发送“hello server 字符流”，并接收服务器发回的“hello client”，然后退出
（4）服务端接受到客户端发送的消息，输出，并向客户端发送“hello client 字符流” ，然后退出

package com.francis.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author Francis
 * @create 2022-03-05 9:24
 */
public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在 9999 端口监听，等待连接..");
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello client 字符流");
       //插入一个换行符，表示写入的内容结束, 注意，要求对方使用 readLine()!!!!
        bufferedWriter.newLine();
        // 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
        bufferedWriter.flush();
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();
    }
}

package com.francis.socket;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * @author Francis
 * @create 2022-03-05 9:24
 */
public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket 返回="+socket.getClass());
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello server 字符流");
        //插入结束标识，注意，newLine要求对方使用readLine的方式读取
        bufferedWriter.newLine();
        //刷新缓存通道
        bufferedWriter.flush();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        inputStream.close();
        outputStream.close();
        socket.close();

    }
}

4.5、复制图片

（1）编写一个服务端和客户端
（2）服务端监听8888端口
（3）服务器端接收到客户端发送的图片，保存到src下，发送“收到图片”再退出

package com.francis.socket.upload_picture;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author Francis
 * @create 2022-03-05 10:13
 */
public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {
//客户端连接服务端 8888，得到 Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //创建读取磁盘文件的输入流
        String filePath = "f:\\1.jpg";
        //String filePath="e:\\abc.mp4";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//bytes 就是 filePath 对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
//通过 socket 获取到输出流, 将 bytes 数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
         bis.close();
        // 设置写入数据的结束标记
        socket.shutdownOutput();
//=====接收从服务端回复的消息=====
        InputStream inputStream = socket.getInputStream(); //使用 StreamUtils
        // 的方法，直接将 inputStream 读取到的内容 转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);
//关闭相关的流
        inputStream.close();
        bos.close();
        socket.close();
    }
}

package com.francis.socket.upload_picture;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author Francis
 * @create 2022-03-05 10:13
 */
public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {
//1. 服务端在本机监听 8888 端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端在 8888 端口监听....");
        //2. 等待连接
        Socket socket = serverSocket.accept();
//3. 读取客户端发送的数据
// 通过 Socket 得到输入流
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //4. 将得到 bytes 数组，写入到指定的路径，就得到一个文件了
        String destFilePath = "f:\\111.jpg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();
// 向客户端回复 "收到图片"
// 通过 socket 获取到输出流(字符)
        BufferedWriter writer =
                new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到图片");
        writer.flush();//把内容刷新到数据通道 socket.shutdownOutput();//设置写入结束标记
//关闭其他资源
        writer.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}

package com.francis.socket.upload_picture;

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.io.*;

/**
 * @author Francis
 * @create 2022-03-05 10:14
 */
public class StreamUtils {
    public static byte[] streamToByteArray(InputStream is) throws IOException, Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
        byte[] b = new byte[1024];
        int len;
        while ((len = is.read(b)) != -1) {
            bos.write(b, 0, len);
        }
        byte[] array = bos.toByteArray();
        bos.close();
        return array;
    }

    /*功能：将InputStream 转换成 String
     *  @param is
     *  @return
     *  @throwsException
     */
    public static String streamToString(InputStream is) throws IOException, Exception {
        BufferedReader reader =
                new BufferedReader(new InputStreamReader(is));
        StringBuilder builder = new StringBuilder();
        String line;
        while ((line
                = reader.readLine()) != null) {
            //当读取到 null 时，就表示结束
            builder.append(line + "\r\n");
        }
        return builder.toString();

    }
}

4.6、netstat指令

（1）netstat -an可以查看当前主机的网络情况，包括端口监听情况和网络连接情况
（2）netstat -an | more 可以分页显示

5、UDP 网络通信编程

5.1、基本介绍

（1）类DatagramSocket和DatagramPacket实现了基于UDP网络协议程序
（2）UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证数据报一定能够安全的送达目的地，也不确定什么时候可以送达
（3）DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的ip地址和端口号
（4）UDP协议中每个数据报都给出了完整的地址信息，因此无需建立发送方和接接收方的连接

5.2、基本流程

5.3、UDP应用案例

package com.francis.socket.upload_picture.udp;

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

/**
 * 接收端
 * @author Francis
 * @create 2022-03-05 15:19
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //1. 创建一个DatagramSocket 对象，准备在 9999 接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2. 构建一个DatagramPacket 对象，准备接收数据
        //  UDP 协议的数据包最大 64k
        byte[] buf = new byte[64*1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //3. 调用接收方法, 将通过网络传输的 DatagramPacket 对象填充到 packet 对象
        //提示: 当有数据包发送到 本机的 9999 端口时，就会接收到数据
        // 如果没有数据包发送到 本机的 9999 端口, 就会阻塞等待.
        System.out.println("接收端 A 等待接收数据..");
        socket.receive(packet);
        //4. 可以把 packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();
        //实际接收到的数据字节长度
        byte[] data = packet.getData();
        //接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);
        //===回复信息给 B 端
        // 将需要发送的数据，封装到 DatagramPacket 对象
        data = "好的, 明天见".getBytes();
        //说明: 封装的 DatagramPacket 对象 data 内容字节数组 ,data.length, 主机(IP), 端口
        packet = new DatagramPacket(data, data.length, InetAddress.getByName(
                "192.168.5.1"), 9998);
        //发送
        socket.send(packet);
        //5. 关闭资源
        socket.close();
        System.out.println("A 端退出...");
    }

}

package com.francis.socket.upload_picture.udp;

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

/**
 * 发送端
 *
 * @author Francis
 * @create 2022-03-05 15:19
 */
public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //1.创建 DatagramSocket 对象，准备在 9998 端口 接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        //2. 将需要发送的数据，封装到 DatagramPacket 对象
        byte[] data = "hello 明天吃火锅~".getBytes();
        //说明: 封装的 DatagramPacket 对象 data 内容字节数组 ,data.length, 主机(IP), 端口
        DatagramPacket packet = new DatagramPacket(data, data.length,
                InetAddress.getByName("192.168.5.1"), 9999);
        socket.send(packet);
        //3. === 接收从 A 端回复的信息
// (1) 构建一个 DatagramPacket 对象，准备接收数据
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2) 调用// 接收方法, 将通过网络传输的 DatagramPacket 对象 // 填充到 packet 对象
        // 本机的 9998 端口时，就会接收到数据 // 如果没有数据包发送到 本机的 9998 端口, 就会阻塞等待.
        socket.receive(packet);
//(3) 可以把 packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//实际接收到的数据字节长度
        data = packet.getData();//接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);
//关闭资源
        socket.close();
        System.out.println("B 端退出");
    }

}