• Java_网络多线程

    网络的相关概念

    • 网络通信
      1.概念:两台设备之间通过网络实现数据传输
      2.网络通信:将数据通过网络从一台设备传输到另一台设备
      3.java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信
    • 网络
      1.概念:两台或多台设备通过一定物理设备连接起来构成了网络
      2.根据网络的覆盖范围不同，对网络进行分类:
      ·局域网:覆盖范围最小,仅仅覆盖一个教室或一个机房
      ·城域网:覆盖范围较大，可以覆盖一个城市
      ·广域网:覆羔范围最大，可以覆盖全国，甚至全球,万维网是广域网的代表
    • ip地址
      1.概念:用于唯一标识网络中的每台计算机/主机
      2.查看ip地址: ipconfig
      3.ip地址的表示形式:点分十进制XX.XX.XX.XX、
      4.每一个十进制数的范围:0~255
      5.ip地址的组成=网络地址+主机地址，比如:192.168.16.69
      6.IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址。
      7.由于IPv4（4个字节(32位表示)）最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6（16个字节(128位表示)）的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍
      在这里插入图片描述
    • 域名
      1.www.baidu.com
      2.好处:为了方便记忆,解决记ip的困难
      3.概念:将ip地址映射成域名
    • 端口号
      1.概念:用于标识计算机上某个特定的网络程序
      2.表示形式:以整数形式,范围0~65535
      3.0~1024已经被占用，比如ssh 22, ftp 21, smtp 25 http 804.
      常见的网络程序端口号:
      tomcat :8080
      mysql:3306
      oracle:1521
      sqlserver:1433

    ip定位主机，端口定位服务
    在这里插入图片描述

    • 网络通信协议
      TCP/IP (Transmission Control Protocol/lnternet Protocol)的简写,中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是lnternet最基本的协议、Internet国际互联网络的基础,简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。
      在这里插入图片描述
    • TCP和UDP
      TCP协议:传输控制协议
      1.使用TCP协议前，须先建立TCP 连接,形成传输数据通道
      2.传输前，采用"三次握手"方式，是可靠的
      3.TCP协议进行通信的两个应用进程:客户端、服务端
      4、在连接中可进行大数据量的传输
      5.传输完毕，需释放已建立的连接,效率低
      UDP协议:用户数据协议
      1．将数据、源、目的封装成数据包,不需要建立连接
      2.每个数据报的大小限制在64K内,不适合传输大量数据
      3.因无需连接，故是不可靠的
      4、发送数据结束时无需释放资源(因为不是面向连接的)，速度快
      5．举例:厕所通知:发短信

    InetAdddress类

    package com.api_;

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

/**
 * @author pengyang
 * @date 2021-12-17 19:03
 * 演示InetAddress类的使用
 */

public class API {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机的InetAddress对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);  //主机名和ip地址 DESKTOP-3QG5IV1/192.168.190.1

        //根据指定主机名/域名获取 ip 地址对象 getByName
        InetAddress host2 = InetAddress.getByName("DESKTOP-3QG5IV1");
        System.out.println(host2);  //DESKTOP-3QG5IV1/192.168.190.1
        InetAddress host3 = InetAddress.getByName("www.baidu.com");
        System.out.println(host3);  //www.baidu.com/163.177.151.110

        //获取 InetAddress 对象的主机名 getHostName
        String host3Name = host3.getHostName();
        System.out.println(host3Name);  //www.baidu.com

        //获取 InetAddress 对象的地址 getHostAddress
        String host3Address = host3.getHostAddress();
        System.out.println(host3Address);   //163.177.151.110
    }
}


    • 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

    Socket

    基本介绍

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

    • 示意图
      在这里插入图片描述

    TCP网络通信编程

    基本介绍

    1.基于客户端-服务端的网络通信
    2.底层使用的是TCP/IP协议
    3.应用场景举例:客户端发送数据，服务端接受并显示控制台
    4.基于Socket的TCP编程
    在这里插入图片描述

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

    1.编写一个服务器端，和一个客户端
    2.服务器端在9999端口监听
    3.客户端连接到服务器端,发送"hello, server"，服务端收到后发出"hello, client"然后退出
    4.服务器端接收到客户端发送的信息,输出,并退出
    示意图
    在这里插入图片描述

    SocketTCP01Server.java

    package com.api_;

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

/**
 * @author pengyang
 * @date 2021-12-17 19:54
 * 服务端
 */

public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的 9999 端口监听, 等待连接
        // 细节: 要求在本机没有其它服务在监听 999
        // 细节：这个 ServerSocket 可以通过 accept() 返回多个 Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端在9999监听，等待连接。。。");

        //2. 当没有客户端连接 9999 端口时，程序会 阻塞, 等待连接
        // 如果有客户端连接，则会返回 Socket 对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端socket = " + socket.getClass());

        //3. 通过 socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();

        //4.IO读取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));    //根据读取到的实际长度，显示内容
        }

        //5.获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello, client".getBytes());
        //设置结束标记
        socket.shutdownOutput();

        //6.关闭流和socket
        outputStream.close();
        inputStream.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
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    SocketTCP01Client.java

    package com.api_;

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 pengyang
 * @date 2021-12-17 20:04
 * 客户端
 */

public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //1. 连接服务端 (ip , 端口）
        //解读: 连接主机(此处是本机)的 9999 端口, 如果连接成功，返回 Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端socket返回=" + socket.getClass());

        //2. 连接上后，生成 Socket, 通过 socket.getOutputStream()
        //   得到 和 socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();

        //3.通过输出流，写入数据到数据通道
        outputStream.write("hello, server".getBytes());
        socket.shutdownOutput();

        //4. 获取和 socket 关联的输入流. 读取数据(字节)，并显示
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));
        }

        //5.关闭对象和流，必须关闭
        inputStream.close();
        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
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    应用案例2（使用字符流）

    在这里插入图片描述
    SocketTCP02Server.java

    package com.api_;

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

/**
 * @author pengyang
 * @date 2021-12-17 19:54
 * 服务端，使用字符流方式
 */

public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的 9999 端口监听, 等待连接
        // 细节: 要求在本机没有其它服务在监听 999
        // 细节：这个 ServerSocket 可以通过 accept() 返回多个 Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端在9999监听，等待连接。。。");

        //2. 当没有客户端连接 9999 端口时，程序会 阻塞, 等待连接
        // 如果有客户端连接，则会返回 Socket 对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端socket = " + socket.getClass());

        //3. 通过 socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();

        //4.IO读取，使用字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));//使用转换流
        String s = bufferedReader.readLine();
        System.out.println(s);//输出

        //5.获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        //使用字符输出流回复信息
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));//使用转换流，将字节流转换成字符流
        bufferedWriter.write("hello, client 字符流");
        bufferedWriter.newLine();
        bufferedWriter.flush();

        //6.关闭流和socket
        bufferedWriter.close();
        bufferedReader.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
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    SocketTCP02Client.java

    package com.api_;

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

/**
 * @author pengyang
 * @date 2021-12-17 20:04
 * 客户端，使用字符流
 */

public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        //1. 连接服务端 (ip , 端口）
        //解读: 连接主机(此处是本机)的 9999 端口, 如果连接成功，返回 Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端socket返回=" + socket.getClass());

        //2. 连接上后，生成 Socket, 通过 socket.getOutputStream()
        //   得到 和 socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输出流，写入到数据通道，使用字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));//使用转换流，将字节流转换成字符流
        bufferedWriter.write("hello, server 字符流");
        bufferedWriter.newLine();//插入一个换行符，表示写入内容结束，注意，要求对方使用readLine()
        bufferedWriter.flush();

        //4. 获取和 socket 关联的输入流. 读取数据(字符)，并显示
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));//使用转换流
        String s = bufferedReader.readLine();
        System.out.println(s);//输出

        //5.关闭对象和流，必须关闭
        bufferedReader.close();
        bufferedWriter.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

    应用案例3-网络上传文件

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

    • 示意图
      在这里插入图片描述

    TCPFileUploadServer.java

    package com.api_.upload;

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

/**
 * @author py
 * @date 2022-09-01 11:09
 * 文件上传服务端
 */

public class TCPFileUploadServer {
    public static void main(String[] args) throws IOException {
        //1. 服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端在8888监听，等待连接。。。");
        //2. 等待连接
        Socket socket = serverSocket.accept();
        //3. 读取客户端发送的数据
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //4. 将得到的bytes数组，写入到指定路径
        String destFilePath = "src\\com\\api_\\upload\\qie2.png";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();

        //5. 向客户端回复“收到图片”
        //通过socket获取到输出流（字符）
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到图片");//写入
        writer.flush();//刷新
        socket.shutdownOutput();//设置写入结束标记

        //关闭其他资源
        writer.close();
        bis.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
    • 39
    • 40
    • 41
    • 42
    • 43

    TCPFileUploadClient.java

    package com.api_.upload;

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

/**
 * @author py
 * @date 2022-09-01 11:12
 */

public class TCPFileUploadClient {
    public static void main(String[] args) throws IOException {
        //1. 客户端连接服务端8888，得到socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //创建读取磁盘文件的输入流
        String filePath = "d:\\qie.png";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(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();
        String s = StreamUtils.streamtoString(inputStream);
        System.out.println(s);

        //关闭相关流
        inputStream.close();
        bos.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
    • 39

    StreamUtils.java

    package com.api_.upload;

import java.io.*;

/**
 * @author py
 * @date 2022-09-01 11:26
 */

public class StreamUtils {
    /**
     * 功能：将输入流转换成byte[],把文件的内容读取到字节数组
     * @param is
     * @return
     */
    public static byte[] streamToByteArray(InputStream is) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
        byte[] b = new byte[1024];//字节数组
        int len;
        while ((len=is.read(b)) != -1) {//循环读取
            bos.write(b, 0, len);//把读取的数据写入到bos
        }
        byte[] array = bos.toByteArray();//将bos转换成字节数组
        bos.close();
        return array;
    }

    /**
     * 将InputStream转换成String
     * @param is
     * @return
     * @throws
     */
    public static String streamtoString(InputStream is) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder builder = new StringBuilder();//StringBuilder更快
        String line;
        while ((line = reader.readLine()) != null){
            builder.append(line+"\r\n");
        }
        return builder.toString();
    }
}

    • 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

    TCP连接tips

    netstat 指令
     1. netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况
     2. netstat -an | more可以分页显示
    在这里插入图片描述
    (1) Listening表示某个端口在监听
    (2)如果有一个外部程序(客户端)连接到该端口，就会显示一条连接信息.

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

  • 相关阅读:
    python用selenium网页模拟时xpath无法定位元素解决方法2
    android 12出现 Targeting S+ (version 31 and above)问题
    2022-6-28 摆动排序II，个位数字为K的整数之和，矩阵的最大非负积，课程表，路径总和III
    C#笔记：C#程序基本内容
    ReentrantLock通过Condition实现锁对象的监视器功能
    什么是过期域名？做网站用过期域名好不好？
    竞赛 基于深度学习的人脸专注度检测计算系统 - opencv python cnn
    Android小程序 java 产品合同管理系统python nodejs php客户资源管理系统
    作用域安全的构造函数
    SSM项目小例子，SSM整合图文详细教程
  • 原文地址：https://blog.csdn.net/weixin_43752912/article/details/126566581