深入解析：文件上传原理与B/S服务器优化实战-优快云博客

网络编程综合案例

上传文件
模拟B/S服务器
- 需求分析
- 服务端代码实现

上传文件

文件上传原理

在这里插入图片描述

文件上传分析图解

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

在这里插入图片描述

基本实现

客户端实现

public class TCPClient {
    public static void main(String[] args) {
        try {
            //1.创建一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
            FileInputStream fis = new FileInputStream("G://zccheng.jpg");
            //2.创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
            Socket socket = new Socket("127.0.0.1",8888);
            //3.使用Socket中的方法getOutputStream,获取网络字节输出流OutputStream对象
            OutputStream os = socket.getOutputStream();
            //4.使用本地字节输入流FileInputStream对象中的方法read,读取本地文件
            byte[] buffer = new byte[1024];
            int len=0;
            while((len=fis.read(buffer))!=-1){
                //5.使用网络字节输出流OutputStream对象中的方法write,把读取到的文件上传到服务器
                os.write(buffer,0,len);
            }
            /*
            解决:上传完文件,给服务器写一个结束标记
            void shutdownOutput() 禁用此套接字的输出流。
            对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。
            */
            socket.shutdownOutput();
            os.write("dd".getBytes());

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

            //7.使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
            while((len=is.read(buffer))!=-1){
                System.out.println(new String(buffer,0,len));
            }

            //8.释放资源
            fis.close();
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端实现

package com.zcc.tcp;

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

public class TCPServer {
    public static void main(String[] args) throws IOException {
        //1.创建一个服务器ServerSocket对象,和系统要指定的端口号
        ServerSocket serverSocket = new ServerSocket(8888);
		//优化二
        while (true) {
            //2.使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象
            Socket accept = serverSocket.accept();

            /*
            优化三、使用多线程技术,提高程序的效率
            有一个客户端上传文件,就开启一个线程,完成文件的上传
            */
            new Thread(()->{

                try {
                    /*
                        优化一、自定义一个文件的命名规则:防止同名的文件被覆盖
                        规则:域名+毫秒值+随机数
                     */
                    //3.文件命名
                    String filename="zccheng"+System.currentTimeMillis()+new Random().nextInt(99999)+".jpg";

                    //4.判断G:\\upload文件夹是否存在,不存在则创建
                    File file=new File("G:\\upload");
                    if(!file.exists()){
                        file.mkdirs();
                    }

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

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

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

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

                    //10.释放资源(FileOutputStream,Socket,ServerSocket)
                    fos.close();
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }

    }
}

文件上传优化分析

1.文件名称写死的问题
服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，建议使用系统时间优化，保证文件名称唯一。
2.循环接收的问题
服务端，指保存一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断的接收不同用户的文件。
3.效率问题
服务端，在接收大文件时，可能耗费几秒钟的时间，此时不能接收其他用户上传，所以，使用多线程技术优化。

模拟B/S服务器

需求分析

在这里插入图片描述

服务端代码实现

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

        /*
            浏览器解析服务器回写的html页面,页面中如果有图片,那么浏览器就会单独的开启一个线程,读取服务器的图片
            我们就的让服务器一直处于监听状态,客户端请求一次,服务器就回写一次
         */
        while(true){
            //使用accept方法获取到请求的客户端对象(浏览器)
            Socket socket = server.accept();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();

                        //把is网络字节输入流对象,转换为字符缓冲输入流
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        //把客户端请求信息的第一行读取出来 GET /11_Net/web/index.html HTTP/1.1
                        String line = br.readLine();
                        System.out.println(line);
                        //把读取的信息进行切割,只要中间部分 /11_Net/web/index.html
                        String[] arr = line.split(" ");
                        //把路径前边的/去掉,进行截取 11_Net/web/index.html
                        String htmlpath = arr[1].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();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }).start();


        }


        //server.close();
    }
}