• Java 第三阶段增强分析需求，代码实现能力【网络编程】

    Java 第三阶段增强分析需求，代码实现能力【网络编程】

    代码链接：https://download.csdn.net/download/qq_52354698/86405518?spm=1001.2014.3001.5501

    1. 网络的相关概念

    1. 网络通信

    1. 概念：两台设备之间通过网络实现数据传输
    2. 网络通信：将数据通过网络从一台设备传输到另一台设备
    3. java.net包下提供了一系列的类或接口
      在这里插入图片描述

    2. 网络

    1. 概念：两台或多台设备通过一定的网络设备连接起来构成了网络
    2. 根据网络的覆盖范围不同，对网络进行分类

    局域网：覆盖范围最小，仅仅覆盖一个教室或一个机房
    城域网：覆盖范围较大们可以覆盖一个城市
    广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

    在这里插入图片描述

    3. ip地址

    1. 概念：用于唯一标识网络中的每台主机/计算机
    2. 查看ip地址：ipconfig
    3. ip地址的表示形式：点分十进制 xx.xx.xx.xx
    4. 每一个十进制数的范围：0-255
    5. ip地址的组成=网络地址+主机地址，比如：192,168,16,698
    6. IPV6是互联网工程任务组设计用于替代IPV4的下一代协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址
    7. 由于IPV4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展IPV6的使用，不仅能解决网络地址资源数量有限的问题，而且也解决了多种接入设备连入互联网的障碍

    4. Ipv4地址分类

    在这里插入图片描述

    在这里插入图片描述
    127.0.0.1 表示本机地址

    5. 域名

    1. www,baidu,com
    2. 好处：为了方便记忆，解决记ip的困难
    3. 概念：将ip地址映射成域名，这里怎么映射，由HTTP协议决定

    6. 端口号

    1. 概念：用于标识计算机上某个特定的网络程序
    2. 表示形式：以整数形式，端口范围0-65535 [ 2个字节表示端口 0~2^16-1 ]
    3. 0~1024已经被占用，比如：ssh 22 ，ftp 21，smtp 25 http 80
    4. 常见的网络程序端口号：
      tomcat：8080
      mysql：3306
      oracle：1521
      sqlserver：1433

    7. 网络通信协议

    在这里插入图片描述
    协议
    TCP/IP：传输控制协议、因特网互联协议
    是Internet最基本的协议、Internet国际互联网的基础

    8. 网络通信协议

    在这里插入图片描述

    9. TCP和UDP

    TCP 协议：传输控制协议

    1. 使用TCP协议前，必须先建立TCP链接，形参传输数据通道
    2. 传输前，采用“三次握手”方式，是可靠的
    3. TCP协议进行通信的两个应用进程：客户端、服务端
    4. 在连接中可进行大数据量的传输
    5. 传输完毕，需释放已建立的链接，效率低

    UDP 协议：用户数据协议

    1. 将数据、源、目的封装成数据包，不需要建立连接
    2. 每个数据报的大小限制在64K内，不适合传输大量数据
    3. 因无需连接，故是不可靠的
    4. 发送数据结束时无需释放资源（因为不是面向连接的），速度快

    2. InetAddress类

    1. 相关方法

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

    2. 应用案例

    package com.qdu.api;

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

/**
 * @author dell
 * @version 1.0
 */
public class API_ {

    public static void main(String[] args) throws UnknownHostException {

        //获取本机的InetAddress对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);//DESKTOP-3I3I0JA/192.168.1.5 前半部分是计算机名，后半部分是IP地址
        //根据指定主机名，获取InetAddress对象
        InetAddress host1 = InetAddress.getByName("DESKTOP-3I3I0JA");
        System.out.println(host1);
        //根据域名返回InetAddress对象
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println(host2);
        //通过InetAddress对象获取对应的地址
        String hostAddress = host2.getHostAddress();
        System.out.println(hostAddress);
        //通过InetAddress获取对应的主机名或域名
        String hostName = host2.getHostName();
        System.out.println(hostName);

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    在这里插入图片描述

    3. Socket

    1. 基本介绍

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

    2. 图解示意

    在这里插入图片描述

    4. TCP网络通信编程

    1. 基本介绍

    1. 基于客户端–服务端的网络通信
    2. 底层使用的TCP/IP协议
    3. 应用场景举例：客户端发送数据，服务端接受并显示控制台
    4. 基于Socket的TCP编程

    在这里插入图片描述

    2. 应用案例1（使用字节流）

    1.编写一个服务器端，和一个客户端
    2.服务器端在9999端口监听
    3.客户端连接到服务器端，发送"hello, server"，然后退出
    4.服务器端接收到客户端发送的信息，输出，并退出

    客户端

    package com.qdu.socket;

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

/**
 * @author dell
 * @version 1.0
 */
public class SocketTCP01Client {

    public static void main(String[] args) throws IOException {

        //连接服务端（ip，端口）
        //连接本机的9999端口，如果连接成返回socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端socket返回 = " + socket.getClass());
        //连接上后，生成socket，通过socket.getOutputStream()
        //得到和socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,socket".getBytes());
        //关闭流对象和socket，必须关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    服务端

    package com.qdu.socket;

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

/**
 * @author dell
 * @version 1.0
 */
public class SocketTCP01Server {

    public static void main(String[] args) throws IOException {

        //在本机的9999端口监听，等待连接
        //要求本机没有其他服务在监听9999端口
        //ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        //当没有客户端连接9999端口，程序会堵塞，等待连接
        //如果有客户端连接，则会返回socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端socket = " + socket.getClass());
        //通过socket.getInputStream()读取客户端写入到数据通道的数据
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, readLen));
        }
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端关闭...");

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    客户端和服务端都要有一个socket

    3. 应用案例2（使用字节流）

    1.编写个服务端，和一个客户端
    2.服务器端在9999端口监听
    3.客户端连接到服务端，发送"hello, server"并接收服务器端回发的"hello,client",再退出
    4.服务器端接收到客户端发送的信息，输出，并发送"hello, client", 再退出

    服务端

    package com.qdu.socket;

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

/**
 * @author dell
 * @version 1.0
 */
public class SocketTCP01Server {

    public static void main(String[] args) throws IOException {

        //在本机的9999端口监听，等待连接
        //要求本机没有其他服务在监听9999端口
        //ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        //当没有客户端连接9999端口，程序会堵塞，等待连接
        //如果有客户端连接，则会返回socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端socket = " + socket.getClass());
        //通过socket.getInputStream()读取客户端写入到数据通道的数据
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, readLen));
        }
        //获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello, client".getBytes());
        //设置结束标记
        socket.shutdownOutput();
        inputStream.close();
        outputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端关闭...");

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    客户端

    package com.qdu.socket;

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

/**
 * @author dell
 * @version 1.0
 */
public class SocketTCP01Client {

    public static void main(String[] args) throws IOException {

        //连接服务端（ip，端口）
        //连接本机的9999端口，如果连接成返回socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端socket返回 = " + socket.getClass());
        //连接上后，生成socket，通过socket.getOutputStream()
        //得到和socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,server".getBytes());
        socket.shutdownOutput();
        //获取和socket相关联的输入流，读取数据并显示
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, readLen));
        }
        //结束标记
        socket.shutdownInput();
        //关闭流对象和socket，必须关闭
        outputStream.close();
        inputStream.close();
        socket.close();
        System.out.println("客户端退出...");

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    当连个socket服务端和客户端互相发送多条信息时，socket并不能直接确定上条消息何时发送结束，因此在上条消息发送结束后，一定要添加结束标记（socket.shutdownInput();），来告诉socket我将要发送第二条消息了

    4. 应用案例3（使用字符流）

    1.编写一个服务端，和一个客户端
    2.服务端在9999端口监听
    3.客户端连接到服务端，发送"hello, server"，并接收服务端回发的"hello,client",再退出
    4.服务端接收到客户端发送的信息，输出，并发送"hello, client", 再退出

    服务端

    package com.qdu.socket;

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

/**
 * @author dell
 * @version 1.0
 */
public class SocketTCP01Server {

    public static void main(String[] args) throws IOException {

        //在本机的9999端口监听，等待连接
        //要求本机没有其他服务在监听9999端口
        //ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        //当没有客户端连接9999端口，程序会堵塞，等待连接
        //如果有客户端连接，则会返回socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端socket = " + socket.getClass());
        //通过socket.getInputStream()读取客户端写入到数据通道的数据
        InputStream inputStream = socket.getInputStream();
        //IO读取，使用字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        //获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        //使用字节输出流的方式回复信息
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,client 字符流");
        bufferedWriter.newLine();//插入一个换行符，表示回复的内容结束
        bufferedWriter.flush();//手动刷新
        bufferedReader.close();
        bufferedWriter.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端关闭...");

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    客户端

    package com.qdu.socket;

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

/**
 * @author dell
 * @version 1.0
 */
public class SocketTCP01Client {

    public static void main(String[] args) throws IOException {

        //连接服务端（ip，端口）
        //连接本机的9999端口，如果连接成返回socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端socket返回 = " + socket.getClass());
        //连接上后，生成socket，通过socket.getOutputStream()
        //得到和socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,server 字符流");
        bufferedWriter.newLine();//插入一个换行符，表示写入内容结束，要求对方一定要使用readLine()!!!
        //如果使用字符流，一定要手动刷新，否则数据不会写入数据通道
        bufferedWriter.flush();
        //获取和socket相关联的输入流，读取数据并显示
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        //关闭流对象和socket，必须关闭
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        System.out.println("客户端退出...");

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    使用字节流，就不需要使用socket的结束标记了，写入一个换行符即可

    5. 应用案例4（图片）

    1.编写一个服务端，和一个客户端
    2.服务器端在8888端口监听
    3.客户端连接到服务端，发送一张图片e:lqie.png
    4.服务器端接收到客户端发送的图片，保存到src下，发送"收到图片”再退出
    5.客户端接收到服务端发送的"收到图片"，再退出
    6.该程序要求使用StreamUtils.java,我们直接使用

    客户端

    package com.qdu.upload;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * @author dell
 * @version 1.0
 */
public class TCPFileUploadClient {

    public static void main(String[] args) throws Exception {

        //1。客户端连接服务端
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //2.创建读取磁盘文件的输入流
        String filePath = "e:\\1.jpg";
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(filePath));
        //3.bytes就是filePath对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bufferedInputStream);
        //4.通过socket获取输出流将bytes发送给服务端
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(socket.getOutputStream());
        bufferedOutputStream.write(bytes);//将文件对应的字节数组内容写数据通道
        bufferedInputStream.close();
        socket.shutdownOutput();//写入数据的结束标记
        //5.关闭相关的流
        bufferedOutputStream.close();
        socket.close();

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    服务端

    package com.qdu.upload;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author dell
 * @version 1.0
 */
public class TCPFileUploadServer {

    public static void main(String[] args) throws Exception {

        //1.服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //2.等待连接
        Socket socket = serverSocket.accept();
        //3.读取客户端发送的数据
        //通过socket得到输入流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bufferedInputStream);
        //4.将得到的bytes数组，写入到指定的路径，就得到一个文件了
        String destPath = "src\\2.jpg";
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destPath));
        bufferedOutputStream.close();
        //5.关闭其他资源
        bufferedInputStream.close();
        socket.close();
        serverSocket.close();

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    6. netstat 指令

    1. netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况
    2. netstat -an | more 可以分页显示
    3. 要求在dos控制台下执行

    在这里插入图片描述

    Listening：表示某个端口在监听
    如果有一个外部程序（客户端）连接到该端口，就会显示一条连接信息
    可以输入Ctrl + c 退出命令

    7. TCP网络通讯不为人知的秘密

    1. 当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP来分配的，是随机的，不确定的。

    5. UDP网络通信编程【了解】

    1. 基本介绍

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

    2. 基本流程

    1. 核心的两个类/对象 DatagramSocket 与 DatagramPacket
    2. 建立发送端，接收端（没有服务端和客户端概念）
    3. 发送数据前，建立数据包/报 DatagramPacket 独享
    4. 调用 DatagramSocket 的发送，接收方法
    5. 关闭 DatagramSocket
  • 相关阅读:
    【算法训练-二叉树 一】【二叉树遍历】前序遍历、中序遍历、后续遍历、层序遍历、锯齿形层序遍历、二叉树右视图
    vue项目使用高德地图时报错：AMap is not defined
    海藻酸钠-四嗪|TZ-PEG-alginate|海藻酸钠-peg-四嗪TZ
    爬虫基础入门理论上篇
    【AI视野·今日CV 计算机视觉论文速览 第259期】Tue, 3 Oct 2023
    关系型数据库存储多维指标数据
    T8161B T8403 T8448 ICS TRIPLEX 具有支持物联网边缘的计算机视觉
    Java编译器优化逃逸分析详解
    大学生影视主题网页制作 腾龙电影网页设计模板 学生静态网页作业成品 dreamweaver电影HTML网站制作
    AOP的核心：代理模式（静态代理、动态代理）
  • 原文地址：https://blog.csdn.net/qq_52354698/article/details/126443043