Java网络编程|基础知识及代码示例

最新推荐文章于 2024-05-21 22:53:26 发布

不想秃头的程序媛一枚~

最新推荐文章于 2024-05-21 22:53:26 发布

阅读量854

点赞数 20

文章标签：网络 java idea 信息与通信

本文链接：https://blog.csdn.net/qq_53493690/article/details/135285042

版权

1. 概念

不同计算机上运行的程序，在一套网络通信协议下，进行数据传输

2. 三要素

IP：设备的唯一标识

端口：设备中应用程序的唯一标识

协议：数据在网络上传输的规则，最常见的是UDP协议和TCP协议

3. IP分类

ipv4：32bit，4个字节，点分十进制表示（1个字节8bit）

ipv6：128bit，16个字节，冒分十六进制表示

ipv4发展到ipv6的原因：ipv4模式下IP地址总数是有限的，随着技术的发展，物联网的兴起，IP不够用了，且大部分IP地址都分配在国外。ipv6模式据说可以给世界上每一粒沙子都分配一个IP地址。

4. 常见命令

ipconfig：查看本机IP地址（ipv4）是本机地址

ping 目标IP地址/域名：检查网络的连通性

5. 通信协议

UDP协议：无连接，速度快，有大小限制（一次最多64k），不安全

TCP协议：有连接，速度慢，没有大小限制，安全

6. TCP通信应用

在通信两端都建立一个Socket对象，通信之前确保已经建立连接。注意：先运行服务端，再运行客户端
通过Socket产生的IO流来进行网络通信，客户端是输出流往外写数据，服务端是输入流往里读数据，服务端也可以通过输出流给客户端发送反馈信息，客户端也可以通过输入流接收服务端的返回信息。
三次握手是建立连接，四次挥手是终止连接

6.1 基础应用

客户端发送消息到服务端（最基础的应用，后面的应用都是在此基础上进行拓展）

客户端

public static void main(String[] args) throws IOException {
    //创建socket对象建立连接
    Socket socket = new Socket();
    InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8083);
    socket.connect(inetSocketAddress, 1500);//设置连接超时时间
    //Socket socket = new Socket("127.0.0.1", 8083);
    //创建输出流对象
    OutputStream outputStream = socket.getOutputStream();
    //写数据
    outputStream.write("hello world!".getBytes("UTF-8"));//指定编码 和服务端统一
    //写入结束标志
    socket.shutdownOutput();
    //释放资源
    outputStream.close();
    socket.close();
}

服务端

public static void main(String[] args) throws IOException {
    //创建服务端socket对象
    ServerSocket serverSocket = new ServerSocket(8083); //创建线程池
    //等待连接
    Socket accept = serverSocket.accept();
    //网络中的输入流
    InputStream inputStream = accept.getInputStream();
    //示例打印到控制台(可以创建本地输出流 保存数据到本地)
    StringBuilder sb = new StringBuilder();
    //读数据
    byte[] bytes = new byte[1024];
    int len;
    while ((len = inputStream.read(bytes)) != -1) {
        sb.append(new String(bytes, 0, len, "UTF-8"));//指定编码格式，和客户端统一
    }
    System.out.println(sb);
    //释放资源
    inputStream.close();
    accept.close();
    serverSocket.close();
}

测试结果

6.2 基础应用

双向通信，客户端发送消息到服务端并接收服务端返回的消息

public static void main(String[] args) throws IOException {
    //创建socket对象建立连接
    Socket socket = new Socket();
    InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8083);
    socket.connect(inetSocketAddress, 1500);//设置连接超时时间
    //Socket socket = new Socket("127.0.0.1", 8083);
    //创建输出流对象
    OutputStream outputStream = socket.getOutputStream();
    //写数据
    outputStream.write("hello world!".getBytes("UTF-8"));//指定编码 和服务端统一
    //写入结束标志 后续只能接受数据
    socket.shutdownOutput();
    //读取服务端返回的数据
    InputStream inputStream = socket.getInputStream();
    byte[] bytes = new byte[1024];
    int len;
    StringBuilder sb = new StringBuilder();
    while ((len = inputStream.read(bytes)) != -1) {
        sb.append(new String(bytes, 0, len, "UTF-8"));
    }
    System.out.println(sb);
    //释放资源
    outputStream.close();
    inputStream.close();
    socket.close();
}

服务端

public static void main(String[] args) throws IOException {
    //创建服务端socket对象
    ServerSocket serverSocket = new ServerSocket(8083); //创建线程池
    //等待连接
    Socket accept = serverSocket.accept();
    //网络中的输入流
    InputStream inputStream = accept.getInputStream();
    //示例打印到控制台(可以创建本地输出流 保存数据到本地)
    StringBuilder sb = new StringBuilder();
    //读数据
    byte[] bytes = new byte[1024];
    int len;
    while ((len = inputStream.read(bytes)) != -1) {
        sb.append(new String(bytes, 0, len, "UTF-8"));//指定编码格式，和客户端统一
    }
    System.out.println(sb);
    //网络中的输出流 给客户端返回消息
    OutputStream outputStream = accept.getOutputStream();
    outputStream.write("I get it.".getBytes("UTF-8"));
    //释放资源
    inputStream.close();
    outputStream.close();
    accept.close();
    serverSocket.close();
}

测试结果

6.3 变形应用

客户端上传本地文件到服务端，服务端接收文件并保存

服务端

public static void main(String[] args) throws IOException {
    //创建服务端socket对象
    ServerSocket serverSocket = new ServerSocket(8083);
    //等待客户端连接 没有连接会阻塞 死等
    Socket socket = serverSocket.accept();
    //指定文件保存路径
    String filePathStr = "D:\\Users\\Desktop\\test";
    File folder = new File(filePathStr);
    if(!folder.exists()){
        folder.mkdirs();
    }
    String fileStr = filePathStr+File.separator+"test.jpg";
    //网络中的流 从客户端读取数据
    InputStream is = socket.getInputStream();
    //创建输出流对象，把数据写入到本地
    FileOutputStream fos = new FileOutputStream(fileStr);
    //边读边写
    byte[] bytes = new byte[1024];
    int len;
    while ((len = is.read(bytes)) != -1) {
        fos.write(bytes, 0, len);
    }
    //释放资源
    is.close();
    serverSocket.close();
}

客户端

public static void main(String[] args) throws IOException {
    //创建socket对象建立连接
    Socket socket = new Socket("127.0.0.1", 8083);
    //创建输出流对象
    OutputStream outputStream = socket.getOutputStream();
    //创建本地文件对象
    String filePath = "D:\\Users\\Desktop\\20231214\\tempTest.jpg";
    File file = new File(filePath);
    //文件转byte[]
    byte[] bytes = SocketTest.FileToByte1(file);
    //写数据
    outputStream.write(bytes);
    //写入结束标志
    socket.shutdownOutput();
    //释放资源
    outputStream.close();
    socket.close();
}

6.4 如何表示发送结束

问题：如果服务端不知道客户端已经发送完消息，就会一直等待直到等待超时

有以下几种方式告知服务端消息已经发送完毕

1.关闭socket

关闭socket后服务端会收到关闭信号，从而知道输出流已经关闭了，可以进行后续的读取操作。但是这种方式导致客户端无法接受到服务端返回的消息，也无法再次发送消息（只能重新创建socket连接）。

2.socket关闭输出流

socket.shutdownOutput();

这种方式不会对socket产生影响，只是告知服务器已经写入完毕

注：如果直接outputStream.close() 关闭输出流的话相应的socket也会关闭，这和第一种方式本质一样

3.约定符号

待补充

4.指定长度

没有理解，待补充

6.5服务端优化

6.5.1 循环等待连接不关闭

public static void main(String[] args) throws IOException {
    //创建服务端socket对象
    ServerSocket serverSocket = new ServerSocket(8083);
    while (true) {
        //等待客户端连接 没有连接会阻塞 死等
        Socket socket = serverSocket.accept();
        //指定文件保存路径
        String filePathStr = "D:\\Users\\Desktop\\test";
        File folder = new File(filePathStr);
        if (!folder.exists()) {
            folder.mkdirs();
        }
        String fileStr = filePathStr + File.separator + UUID.randomUUID() + ".jpg";//生成随机文件名
        //网络中的流 从客户端读取数据
        InputStream is = socket.getInputStream();
        //创建输出流对象，把数据写入到本地
        FileOutputStream fos = new FileOutputStream(fileStr);
        //边读边写
        byte[] bytes = new byte[1024];
        int len;
        while ((len = is.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
        //释放资源
        is.close();
        socket.close();
    }
}

缺点：循环处理多个socket请求，一个一个处理，当一个请求未完成，后面的请求会阻塞

6.5.2 开启多线程处理

解决无法同时处理多个客户端的问题


    ServerSocket serverSocket = new ServerSocket(8083);
    while (true) {
        //等待客户端连接 没有连接会阻塞 死等
        Socket socket = serverSocket.accept();
        //开启线程
        ThreadSocketDemo ts = new ThreadSocketDemo(socket);
        new Thread(ts).start();
    }
}

线程处理类

public class ThreadSocketDemo implements Runnable {
    private Socket socket;

    public ThreadSocketDemo(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        //指定文件保存路径
        String filePathStr = "D:\\Users\\Desktop\\test";
        File folder = new File(filePathStr);
        if (!folder.exists()) {
            folder.mkdirs();
        }
        String fileStr = filePathStr + File.separator + UUID.randomUUID() + ".jpg";//生成随机文件名
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            //网络中的流 从客户端读取数据
            is = socket.getInputStream();
            //创建输出流对象，把数据写入到本地
            fos = new FileOutputStream(fileStr);
            //边读边写
            byte[] bytes = new byte[1024];
            int len;
            while ((len = is.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //释放资源
            try {
                if (null != is)
                    is.close();
                if (null != fos)
                    fos.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }

            if (null != socket) {
                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

6.5.3 开启线程池

改进多线程资源消耗太大的问题

public static void main(String[] args) throws IOException {
    //创建服务端socket对象
    ServerSocket serverSocket = new ServerSocket(8083); //创建线程池
       /*
       public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {...}
        */
    ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
            3,//核心线程数量
            10,//线程池总数量
            60,//临时线程空闲时间
            TimeUnit.SECONDS,//临时线程空闲时间单位
            new ArrayBlockingQueue<>(5),//阻塞队列
            Executors.defaultThreadFactory(),//创建线程的方式
            new ThreadPoolExecutor.AbortPolicy());//任务拒绝策略
    while (true) {
        //等待客户端连接 没有连接会阻塞 死等
        Socket socket = serverSocket.accept();
        //开启线程
        ThreadSocketDemo ts = new ThreadSocketDemo(socket);
        poolExecutor.submit(ts);
    }
}

参考：网络编程 - 知乎

“输出是最好的输入，完成比完美更重要”

以上是个人学习后的总结笔记，如果有不正确的地方欢迎批评指正~