Java Day22

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量122 收藏 1
点赞数
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38689352/article/details/107694604
版权

第一章 TCP通行程序

1.1 概述

TCP通信能够实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Client）。

  • 两端通信时步骤
    • 服务端程序，需要事先启动，等待客户端的连接。
    • 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。
  • 在java中，提供了两个类用于实现TCP通信程序：
    • 客户端：java.net.Socket类表示。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
    • 服务端：java.net.ServerSocket类表示。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接。

1.2 Socket类

Socket类：TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。

1.2.1 构造方法

  • public Socket(String host, int port)：创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null，则相当于指定地址为回送地址。

1.2.2 成员方法

  • public InputStream getInputStream()：返回此套接字的输入流。
    • 如果此Socket具有相关联的通道，则生成的InputStream的所有操作也是关联该通道。
    • 关闭生成的InputStream也将关闭相关的Socket。
  • public OutputStream getOutputStream()：返回此套接字的输入流。
    • 如果此Socket具有相关联的通道，则生成的OutputStream的所有操作也是关联该通道。
    • 关闭生成的OutputStream也将关闭相关的Socket。
  • public void close()：关闭此套接字。
    • 一旦一个socket被关闭，它不可再使用。
    • 关闭此socket也将关闭相关的InputStream和OutputStream。
  • public void shutdownOutput()：禁用此套接字的输出流。
    • 任何先前写出的数据将被发送，随后终止输出流。

1.3 ServerSocket类

ServerSocket类：这个类实现了服务器套接字，该对象等待通过网络的请求。

1.3.1 构造方法

  • public ServerSocket(int port)：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。

1.3.2 成员方法

  • public Socket accept()：侦听并接受连接，返回一个新的socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

1.4 简单的TCP网络程序

1.4.1 TCP通信的图解

 1.4.2 客户端和服务器通信示例

  • 服务端实现
/*
* TCP通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据。
* 表示服务器的类：
*   java.net.ServerSocket：此类实现服务器套接字
*
* 服务器端必须明确一件事情，必须得知道是哪个客户端请求服务器
* 所以可以使用accept方法获取到请求的客户端对象Socket
* 成员方法：
*   Socket accept()：侦听并接受到此套接字的连接
*
* 服务器的实现步骤：
*   1、创建服务器ServerSocket对象和系统要指定的端口号
*   2、使用ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
*   3、使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
*   4、使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
*   5、使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
*   6、使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
*   7、释放资源（Socket，ServerSocket）
*
*
* */


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

public class TCPServer {
    public static void main(String[] args) throws IOException {
        // 创建服务器ServerSocket对象和系统要指定的端口号
        ServerSocket server = new ServerSocket(8888);

        // 使用ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
        Socket socket = server.accept();

        // 使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
        InputStream inputStream = socket.getInputStream();

        // 使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
        byte[] bytes = new byte[1024];
        int len = inputStream.read(bytes);
        System.out.println(new String(bytes, 0, len));

        // 使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
        OutputStream outputStream = socket.getOutputStream();

        // 使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
        outputStream.write("收到谢谢".getBytes());

        // 释放资源（Socket，ServerSocket）
        socket.close();
        server.close();




    }
}
  • 客户端实现
/*
* TCP通信的客户端：向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据
* 表示客户端的类：
*   java.net.Socket：此类实现客户端套接字。套接字是两台计算机间通信的端点。
*       套接字：包含了IP地址和端口号的网络单位
* 构造方法：
*   Socket(String host, int port) 创建一个流套接字并将其连接到指定主机上的指定端口号
*   参数：
*       String host：服务器主机的名称/服务器的IP地址
*       int port：服务器的端口号
*
* 实现步骤：
*   1、创建一个客户端对象socket，构造方法绑定服务器的IP地址和端口号
*   2、使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
*   3、使用网络字节输出流OutputStream对象中的方法write给服务器发送数据
*   4、使用socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
*   5、使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
*   6、释放资源（Socket）
*
* 注意：
*   1、客户端和服务器端进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
*   2、当我们创建客户端对象Socket的时候，就会去请求服务器和服务器经过3次握手建立连接通路
*           如果这时服务器没有启动，那么就会抛出异常ConnectException
*           如果服务器已经启动，那么就可以进行交互了
*
* */

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

public class TCPClient {
    public static void main(String[] args) throws IOException {
        // 创建一个客户端对象socket，构造方法绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1", 8888);

        // 使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
        OutputStream outputStream = socket.getOutputStream();

        // 使用网络字节输出流OutputStream对象中的方法write给服务器发送数据
        outputStream.write("你好服务器".getBytes());

        // 使用socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
        InputStream inputStream = socket.getInputStream();

        // 使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
        byte[] bytes = new byte[1024];
        int len = inputStream.read(bytes);
        System.out.println(new String(bytes, 0, len));

        // 释放资源（Socket）
        socket.close();

    }
}

第二章 综合案例

2.1 文件上传案例

2.1.1 文件上传分析图解

  • 【客户端】输入流，从硬盘读取文件数据到程序中。
  • 【客户端】输出流，写出文件数据到服务器。
  • 【服务器】输入流，读写文件数据到服务端程序。
  • 【服务端】输出流，写出文件数据到服务器中。

2.1.2 基本实现

  • 服务端实现
/*
* 文件上传案例服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写"上传成功"
*
* 明确：
*   数据源：客户端上传的文件
*   目的地：服务器的硬盘：/Users/shiwenhu/IdeaProjects/advance-code/src/com/it/day11code/FileUpload/Study
*
* 实现步骤：
*   1、创建一个服务器ServerSocket对象，和系统要指定的端口号
*   2、使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
*   3、使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
*   4、判断：目的地目录是否存在
*   5、创建一个本地字节输入流FileOutputStream对象，构造方法中绑定要输出的目的地
*   6、使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
*   7、使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器硬盘上
*   8、使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
*   9、使用网络字节输出流OutputStream对象中的方法write，给客户端回写"上传成功"
*   10、释放资源(FileOutputStream，Socket，ServerSocket)
* */

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

public class TCPServer {
    public static void main(String[] args) throws IOException {
        // 创建一个服务器ServerSocket对象，和系统要指定的端口号
        ServerSocket server = new ServerSocket(8888);

        // 使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
        Socket socket = server.accept();

        // 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();

        // 判断：目的地目录是否存在
        File file = new File("/Users/shiwenhu/IdeaProjects/advance-code/src/com/it/day11code/FileUpload/Study");
        if (!file.exists()) {
            file.mkdir();
        }

        // 创建一个本地字节输入流FileOutputStream对象，构造方法中绑定要输出的目的地
        FileOutputStream fos = new FileOutputStream(file + "/new.txt");

        // 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = is.read(bytes)) != -1) {
            // 使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器硬盘上
            fos.write(bytes, 0, len);
        }

        // 使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
        // 使用网络字节输出流OutputStream对象中的方法write，给客户端回写"上传成功"
        socket.getOutputStream().write("上传成功".getBytes());

        // 释放资源(FileOutputStream，Socket，ServerSocket)
        fos.close();
        socket.close();
        server.close();
    }
}
  • 客户端实现
/*
* 文件上传案例的客户端：读取本地文件，上传到服务器，读取服务器回写的数据
*
* 明确：
*   数据源：/Users/shiwenhu/IdeaProjects/advance-code/src/com/it/day11code/FileUpload/Client/new.txt
*   目的地：服务器
*
* 实现步骤：
*   1、创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
*   2、创建一个客户端Socket对象，构造方法中绑定服务器的ip地址和端口号
*   3、使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
*   4、使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
*   5、使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
*   6、使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
*   7、使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
*   8、释放资源（FileInputStream，Socket）
* */

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

public class TCPClient {
    public static void main(String[] args) throws IOException {
        // 创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("/Users/shiwenhu/IdeaProjects/advance-code/src/com/it/day11code/FileUpload/Client/new.txt");

        // 创建一个客户端Socket对象，构造方法中绑定服务器的ip地址和端口号
        Socket socket = new Socket("127.0.0.1", 8888);

        // 使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();

        // 使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fis.read(bytes)) != -1) {
            // 使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
            os.write(bytes);

        }

        // 解决：上传完文件，给服务器一个结束标记
        // void shutdownOutput() 禁用此套接字的输出流
        // 对于TCP套接字，任何以前写入的数据都将被发送，并且后跟TCP的正常连接终止序列
        socket.shutdownOutput();  // 用于解决文件上传完成后进入阻塞状态

        // 使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();

        // 使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
        while ((len = is.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }

        // 释放资源（FileInputStream，Socket）
        fis.close();
        socket.close();
    }
}

2.1.3 文件上传优化

  • 文件名称写死的问题
    • 服务端在保存文件的时，若文件名写死，那么最终会导致服务器硬盘只保留一个文件，当同名文件到达时旧的文件将会被覆盖。可以使用系统时间来优化。
  • 循环接收问题
    • 服务端在接收完一个文件后就关闭了，我们可以使用循环使服务器一直运行等待，不断接受不同的客户端的文件。
  • 效率问题
    • 服务端在收到大的文件的时候，可能耗费比较长的时间，这时候其他用户就不能上传文件了，所以我们可以使用多线程技术来优化。

2.1.4 优化实现

  • 服务端实现
/*
* 文件上传案例服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写"上传成功"
*
* 明确：
*   数据源：客户端上传的文件
*   目的地：服务器的硬盘：/Users/shiwenhu/IdeaProjects/advance-code/src/com/it/day11code/FileUpload/Study
*
* 实现步骤：
*   1、创建一个服务器ServerSocket对象，和系统要指定的端口号
*   2、使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
*   3、使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
*   4、判断：目的地目录是否存在
*   5、创建一个本地字节输入流FileOutputStream对象，构造方法中绑定要输出的目的地
*   6、使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
*   7、使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器硬盘上
*   8、使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
*   9、使用网络字节输出流OutputStream对象中的方法write，给客户端回写"上传成功"
*   10、释放资源(FileOutputStream，Socket，ServerSocket)
* */

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

public class TCPServer {
    public static void main(String[] args) throws IOException {
        // 创建一个服务器ServerSocket对象，和系统要指定的端口号
        ServerSocket server = new ServerSocket(8888);



        /*
        * 让服务器一直处于监听状态（死循环accept）
        * 有一个客户端上传文件就保存一个文件
        * */

        while (true) {
            // 使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
            Socket socket = server.accept();

            /*
            * 使用多线程技术提高程序的效率
            * 有一个客户端上传文件，就开启一个线程，完成文件上传
            * */
            new Thread(new Runnable() {
                // 文件的上传
                @Override
                public void run() {
                    try {
                        // 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();

                        // 判断：目的地目录是否存在
                        File file = new File("/Users/shiwenhu/IdeaProjects/advance-code/src/com/it/day11code/FileUpload/Study");
                        if (!file.exists()) {
                            file.mkdir();
                        }

                        /*
                         * 自定义一个文件的命名规则：防止同名的文件被覆盖
                         * 规则：域名+毫秒值+随机数
                         * */
                        String fileName = "itTiger" + System.currentTimeMillis() + new Random().nextInt(999999) + ".txt";

                        // 创建一个本地字节输入流FileOutputStream对象，构造方法中绑定要输出的目的地
                        FileOutputStream fos = new FileOutputStream(file + fileName);

                        // 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = is.read(bytes)) != -1) {
                            // 使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器硬盘上
                            fos.write(bytes, 0, len);
                        }

                        // 使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
                        // 使用网络字节输出流OutputStream对象中的方法write，给客户端回写"上传成功"
                        socket.getOutputStream().write("上传成功".getBytes());

                        // 释放资源(FileOutputStream，Socket，ServerSocket)
                        // fos.close();
                        // socket.close();
                        // server.close();
                    } catch (IOException e) {
                        System.out.println(e);
                    }
                }
            }).start();


        }


    }
}
  • 客户端时间
/*
* 文件上传案例的客户端：读取本地文件，上传到服务器，读取服务器回写的数据
*
* 明确：
*   数据源：/Users/shiwenhu/IdeaProjects/advance-code/src/com/it/day11code/FileUpload/Client/new.txt
*   目的地：服务器
*
* 实现步骤：
*   1、创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
*   2、创建一个客户端Socket对象，构造方法中绑定服务器的ip地址和端口号
*   3、使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
*   4、使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
*   5、使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
*   6、使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
*   7、使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
*   8、释放资源（FileInputStream，Socket）
* */

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

public class TCPClient {
    public static void main(String[] args) throws IOException {
        // 创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("/Users/shiwenhu/IdeaProjects/advance-code/src/com/it/day11code/FileUpload/Client/new.txt");

        // 创建一个客户端Socket对象，构造方法中绑定服务器的ip地址和端口号
        Socket socket = new Socket("127.0.0.1", 8888);

        // 使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();

        // 使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fis.read(bytes)) != -1) {
            // 使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
            os.write(bytes);

        }

        // 解决：上传完文件，给服务器一个结束标记
        // void shutdownOutput() 禁用此套接字的输出流
        // 对于TCP套接字，任何以前写入的数据都将被发送，并且后跟TCP的正常连接终止序列
        socket.shutdownOutput();  // 用于解决文件上传完成后进入阻塞状态

        // 使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();

        // 使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
        while ((len = is.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }

        // 释放资源（FileInputStream，Socket）
        fis.close();
        socket.close();
    }
}

2.2 模拟B\S服务器

模拟网站服务器，使用浏览器访问自己编写的服务端程序，查看网页效果。

2.2.1 案例实现

  • 服务端单线程版
    • 由于服务端在收到网页的html文件后服务端就关闭了，故图片显示不出来。

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

public class TCPServer {
    public static void main(String[] args) throws IOException {
        // 创建一个服务器ServerSocket，和系统要指定的端口号
        ServerSocket server = new ServerSocket(8080);

        // 使用accept方法获取到请求的客户端对象（浏览器）
        Socket socket = server.accept();

        // 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();

        // 使用网络字节输入流InputStream对象中的方法read读取客户端的请求信息
//        byte[] bytes = new byte[1024];
//        int len = 0;
//        while ((len = is.read(bytes)) != -1) {
//            System.out.println(new String(bytes, 0, len));
//        }

        // 把is网络字节输入流对象，转换为字符缓冲输入流
        BufferedReader br = new BufferedReader(new InputStreamReader(is));

        // 把客户端请求信息的第一行读取出来
        String line = br.readLine();

        // 把读取的信息进行切割，只要中间的部分
        String file = line.split(" ")[1];

        // 进行截取
        String htmlpath = file.substring(1);

        // 创建一个本地字节输入流，构造方法中绑定要读取的html路径
        FileInputStream fis = new FileInputStream(htmlpath);

        // 使用Socket中的方法getOutputStream获取网络字节输出流OutputStream
        OutputStream os = socket.getOutputStream();

        // 写入HTTP协议响应头，固定写法
        os.write("HTTP/1.1 200 OK\r\n".getBytes());
        os.write("Content-Type:text/html\r\n".getBytes());
        // 必须要写入空行，否则浏览器不解释
        os.write("\r\n".getBytes());

        // 一读一写复制文件，把服务其读取的html文件回写到客户端
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fis.read(bytes)) != -1) {
            os.write(bytes, 0, len);
        }

        // 释放资源
        fis.close();
        socket.close();
        server.close();

    }
}
  • 服务端实现多线程版
    • 为了解决上述问题，使用多线程，每请求一次打开一个线程。
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServerThread {
    public static void main(String[] args) throws IOException {
        // 创建一个服务器ServerSocket，和系统要指定的端口号
        ServerSocket server = new ServerSocket(8080);

        /*
        * 浏览器解析服务回写的html页面，页面中如果有图片，那么浏览器就会单独的开启一个线程，读取服务器的图片
        * 我们应该让服务器一直处于监听状态，客户端请求一次，服务器就回写一次
        * */

        while(true) {
            new Thread(new Runnable() {
                // 使用accept方法获取到请求的客户端对象（浏览器）
                Socket socket = server.accept();
                @Override
                public void run() {
                    try {
                        // 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();

                        // 使用网络字节输入流InputStream对象中的方法read读取客户端的请求信息
//        byte[] bytes = new byte[1024];
//        int len = 0;
//        while ((len = is.read(bytes)) != -1) {
//            System.out.println(new String(bytes, 0, len));
//        }

                        // 把is网络字节输入流对象，转换为字符缓冲输入流
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));

                        // 把客户端请求信息的第一行读取出来
                        String line = br.readLine();
                        System.out.println(line);

                        // 把读取的信息进行切割，只要中间的部分
                        String file = line.split(" ")[1];

                        // 进行截取
                        String htmlpath = file.substring(1);

                        // 创建一个本地字节输入流，构造方法中绑定要读取的html路径
                        FileInputStream fis = new FileInputStream(htmlpath);

                        // 使用Socket中的方法getOutputStream获取网络字节输出流OutputStream
                        OutputStream os = socket.getOutputStream();

                        // 写入HTTP协议响应头，固定写法
                        os.write("HTTP/1.1 200 OK\r\n".getBytes());
                        os.write("Content-Type:text/html\r\n".getBytes());
                        // 必须要写入空行，否则浏览器不解释
                        os.write("\r\n".getBytes());

                        // 一读一写复制文件，把服务其读取的html文件回写到客户端
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = fis.read(bytes)) != -1) {
                            os.write(bytes, 0, len);
                        }

                    } catch (IOException e) {
                        System.out.println(e);
                    }
                }
            }).start();
        }


    }
}

 

哈哈哈捧场王
关注
专栏目录
java day of month_Java MonthDay withDayOfMonth()用法及代码示例
weixin_31597865的博客
02-23 1747
MonthDay类的withDayOfMonth(int dayOfMonth)方法用于将传递的dayOfMonth用作参数来更改MonthDay对象的day-of-month，然后该方法返回更改后的MonthDay的副本。如果day-of-month值在指定的月份后无效，则抛出异常改变操作。用法:public MonthDay withDayOfMonth(int dayOfMonth)参数：此...
Javaday02训练
02-08
Java Day02训练是针对Java初学者或有一定基础的学习者设计的一次深入学习活动，旨在强化和巩固Java编程的基础知识。在这个训练中，你将接触到一系列关键的Java编程概念和技术，包括但不限于变量、数据类型、控制流程...
java day of month_Java中的MonthDay withDayOfMonth()方法
weixin_30300857的博客
02-19 1030
使用withDayOfMonth()Java中的MonthDay类中的方法来完成MonthDay的不可变副本，并根据需要更改月份中的日期。此方法需要一个参数，即要在MonthDay中设置的月份日期，并且它返回MonthDay，并根据需要更改月份的日期。演示此的程序如下所示-示例importjava.time.*;publicclassDemo{publicstaticvoidmain...
Day1-Java入门
热门推荐
aiains的博客
06-27 3万+
CMD常用命令； 用CMD运行电脑程序以及对应的环境配置； 用记事本编写helloworld，用CMD运行； Java环境变量的配置； Notepad++的使用； 初步了解JDK和JRE。
JAVA学习day6
qq_54395021的博客
04-30 2302
多线程：在身边的应用 可以边 看电影边 听音乐边 打游戏 JDK：java development kit （java开发者工具） JRE：java runtime environment （java运行环境） JVM：java virtual machine （java虚拟机）
# Day01-Java基础
Java厂长
07-25 8036
Day01-Java 1、Java主要特点 简单性、跨平台性、分布性、安全性、健壮性、平台独立与可移植性、多线程、动态性、面向对象的编程语言、支持垃圾自动收集处理等，可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用等多个系统中。 2、计算机的高级汇编语言类型： 编译型——c语言 解释型——html 编译型和解释型的结合——java java运行原理源程序进行编译形成字节码文件在一台电脑进行解释程序 java最核心的部分就是虚拟机JVM 3、JVM（Java Visual Machine)
java日记day01
shy的博客
03-02 7322
java小白学习之路
Java 获取 Julian Day (Calendar)
男儿不展风云志，空有天生八尺躯
11-30 2176
/** * 从Calendar获取Julian Day * 算法来源: http://stackoverflow.com/questions/32949757/get-current-julian-day-number-with-gregorian-calendar-in-android */ public static int getJulianDay(Calendar calendar) { int year = calendar.get(C...
【JAVA-Day43】Java常用类Calendar解析
沉淀、分享、成长，让自己和他人都能有所收获！
10-16 2万+
作为博主，我将带您深入探讨Java中的日期处理神器 -。我们将一探这个强大的类库，学会如何处理日期、时区、重复事件、甚至是国际假期。而且，在文章中我会用丰富的表情和Java代码案例来让您轻松掌握这些知识。无论您是初学者还是经验丰富的开发者，本文都将为您提供深刻的见解。通过本文，您已经深入了解了类以及如何在Java中进行高级日期处理。我们讨论了其基本用法、日期操作、时区处理、格式化、重复事件、国际假期、最佳实践以及与新日期时间API的比较。
java的转义字符 day3
qq_48843954的博客
07-28 1万+
从零开始学java day3 关于回车换行的一点小疑问
NextDay-Java(适用软件测试)
Clearlight's Blog
03-14 7310
输入某一天,输出下一天的日期. import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class NextDay { public static void main(String[] args) { while (true) { try { Scanner...
Java_day22上课资料.zip
04-01
本资料“Java_day22上课资料.zip”显然属于一个教学课程的一部分，旨在帮助学习者深入理解Java语言的核心概念和技术。从描述中的链接我们可以推测，这可能是一个在线教育平台的课程资源，通过视频讲解配合课件，为...
JavaDay3第1讲（函数、语法）.rar_JavaDay3第1讲（函数、语法）
09-23
本课程“JavaDay3第1讲（函数、语法）”深入浅出地介绍了Java编程的基础，包括函数的使用和语法规范，是初学者入门的宝贵资料。 函数在编程中扮演着模块化和代码重用的角色，它是一段可以独立执行的代码块，接受...
Java_day17上课资料.zip
04-01
在这个压缩包“Java_day17上课资料.zip”中，我们可以期待找到与Java相关的各种学习材料，如课件、示例代码和练习题，帮助我们巩固和提升Java技能。 首先，Java的核心特性之一是它的平台独立性，这得益于Java虚拟机...
javaday01训练
02-08
【JavaDay01训练】是针对初学者设计的一系列Java编程入门教程，旨在帮助学习者快速掌握Java语言的基础知识和核心概念。在这个训练中，我们将深入探讨Java编程语言的各个方面，为后续的学习打下坚实的基础。 首先，...
spring事务详细讲解-深入浅出
小电玩
09-08 533
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1517
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 580
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 613
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
Java MBeanInstantiator 0day 漏洞分析
"Java 0day Analysis - MBeanInstantiator.findClass 漏洞解析" 在2013年1月，Java社区面临了一个新的重大安全威胁：Java MBeanInstantiator.findClass 0day漏洞。这个漏洞的影响广泛，因为Java在当时已经广泛应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值