构建自己的轻量级文件服务器

http, java, 文件服务器

前言

现在的WEB应用基本上都离不开文件服务器，各种图片，视频，文档等资源文件的存取一直WEB应用的一部分，对于这种资源的处理一般是通过独立的一个文件服务器来进行处理，文件服务器会提供upload，download等操作分别进行文件的存储和获取，比较完备的还会提供delete操作，但是一般不需要。
我希望用Java构建一个轻量级的文件服务器应用，这个应用要能满足这么几个需求：

  • 最少依赖，最好只依赖Web容器（例如Tomcat）环境

  • 对外接口至简

  • 相对成熟，上传操作使用标准表单模式，下载操作支持断点续传

对于这些需求，我是这么考量的：

1. 依赖性

java处理文件上传往往需要引入一个org.apache.commons.fileupload-1.2.0.jar这个依赖库，就算引入了还是有一堆的API调用要去写，比较繁琐，SpringMVC在它的基础上做了进一步的封装，相对比较好用了。但是引入Spring就重了，这个不予考量。
如果不想引入第三方的lib，Servlet3给了非常好的解决方案，只是要求Web容器支持Servlet3（Tomcat7.0++）。这个就确认使用Servlet3了。

2. 简易性

接口的简易性我希望的目标是这么想的，尽量简单，尽量做到不依赖参数信息。

2.1 对于upload接口

  • 支持多文件批量上传

  • 不依赖文件参数名，客户端上传时可以任意命名文件名参数

2.2 对于download接口

  • 客户获取文件时只需要传入文件名参数即可

  • 支持Rest风格。（我发现Servlet的url-pattern不支持正则表达式，无法天然支持这种风格，现在是通过编码解析Url进行实现的）

2.3 成熟性

对于成熟性的考虑我主要是考虑通用。upload就是使用标准的表单上传处理，这个大家最容易理解，表单是很视觉化的东西嘛，测试也方便。download最基本的就是要支持断点续传，因为有的视频文件可能比较大，下载需要一点时间，如果网络中断了，在下次在线的时候能继续下载而不用重新来过。还有就是现在一些Html5的音频，视频组件对于源的要求也是断点续传的兼容性是最好的，这个在公司的产品中有测试过，简单的Servlet有时候这些HTML5组件识别不了，或者报一些莫名其妙的错误（例如音频不能重复播放，或者压根不能播放）。而支持断点续传的Servlet基本上没有问题。

好了，做了这么多铺垫，我直接上代码吧。

Upload 

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
@WebServlet("/upload")
@MultipartConfig(location = Defs.temp_path, maxRequestSize = 1024L * 10000)
public class UploadServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.reset();
        resp.setContentType("text/plain; charset=utf-8");
        PrintWriter writer = resp.getWriter();
        writer.write("不支持Get操作！");
        writer.flush();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        Collection<Part> parts = null;
        resp.reset();
        resp.setContentType("text/plain; charset=utf-8");
        PrintWriter writer = resp.getWriter();
        // 获取上传的文件列表，Part对象就是Servlet3对文件上传支持中对文件数据的抽象结构
        try {
            parts = req.getParts();
        } catch (Exception e) {
            System.out.println("======>get file part error");
            e.printStackTrace();
            writer.write("上传文件出现错误！" + e.getMessage());
            writer.flush();
            return;
        }
        if(parts == null || parts.isEmpty()){
            writer.write("上传文件为空！");
            writer.flush();
            return;
        }
        List<String> fileNameList = new ArrayList<String>();
        for (Part part : parts) {
            if(part == null){
                continue;
            }
            FileUtil.logPartInfo(part);
            String fileName = FileUtil.getFileName(part);
            String ext = FileUtil.getFileExt(fileName);
            InputStream is = part.getInputStream();
            //创建全局唯一的文件名
            String newName =new ObjectId().toString()+ext;
            String newFileName = Defs.file_path+newName;
            try {
                // 将文件保存指硬盘
                IOUtil.copyInputStreamToFile(is,newFileName);
                fileNameList.add(newName);
            } catch (Exception e) {
                e.printStackTrace();
                continue;
            }
        }

        Map<String,Object> data = new HashMap<String,Object>();
        data.put("fileNames",fileNameList);
        data.put("result",1);
        writer.write(data.toString());
        writer.flush();
    }


}

上传的逻辑很简单，基本上没有注释的必要。稍微提一下文件名的产生机制，我这里偷了个懒，直接套用了mongodb的ObjectId来生成。这里在依赖性方面做了妥协，但是我只把ObjectId的源码给拷贝过来，所以还可以接受。为啥要用ObjectId来产生文件名，主要是它很好的做到了分布式环境中同一时间的产生的差异性。一个ObjectId由 时间戳+机器码+进程号+计数器组成，简单而强大，我懒得重复造轮子了，这里直接移过来。

Download

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
@WebServlet("/download/*")
public class DownloadServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String fileName=null;
        String requestUri = req.getRequestURI();
        int lastIndex = requestUri.lastIndexOf("/");
        if (lastIndex > 0) {
            fileName = requestUri.substring(lastIndex + 1);
        }
        if (fileName == null || fileName.trim().length() == 0) {
            resp.reset();
            resp.setContentType("text/plain;charset=utf-8");
            PrintWriter writer = resp.getWriter();
            writer.write("error:can't get the file name! 不能获取文件名");
            writer.flush();
            return;
        }
        fileName = Defs.file_path + fileName;
        File file = new File(fileName);
        if (!file.exists()) {
            resp.reset();
            resp.setContentType("text/plain;charset=utf-8");
            PrintWriter writer = resp.getWriter();
            writer.write("error: file not exist! 文件不存在");
            writer.flush();
        }

        long length = file.length();
        long start = 0;
        resp.reset();
        resp.setHeader("Accept-Ranges", "byte");
        //断点续传的信息就存储在这个Header属性里面： range:bytes=3-100;200 （从3开始，读取长度为100，总长度为200）
        String range = req.getHeader("Range");
        if (range != null) {
            //SC_PARTIAL_CONTENT 206 表示服务器已经成功处理了部分 GET 请求。类似于 FlashGet 或者迅雷这类的 HTTP下载工具都是使用此类响应实现断点续传或者将一个大文档分解为多个下载段同时下载。
            resp.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
            range = range.substring("bytes=".length());
            String[] rangeInfo = range.split("-");
            start = new Long(rangeInfo[0]);
            if (start > file.length()) {
                resp.sendError(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);
                return;
            }
            if (rangeInfo.length > 1) {
                length = Long.parseLong(rangeInfo[1]) - start + 1;
            } else {
                length = length - start;
            }
            if (length + start > file.length()) {
                length = file.length() - start;
            }
        }

        resp.setHeader("Content-Type", FileUtil.getMime(fileName));
        resp.setHeader("Content-Length", new Long(length).toString());
        if (range != null) {
            resp.setHeader("Content-Range", "bytes " + new Long(start).toString() + "-" + new Long(start + length - 1).toString() + "/" + new Long(file.length()).toString());
        }
        resp.setContentType(FileUtil.getMime(fileName));
        resp.setHeader("Content-Disposition", "attachment;filename=" + new String(file.getName().getBytes(), "utf-8"));
        long k = 0;
        int ibuffer = 65536;
        byte[] bytes = new byte[ibuffer];
        FileInputStream fileinputstream = new FileInputStream(file);
        try {
            if (start != 0) {
                fileinputstream.skip(start);
            }
            OutputStream os = resp.getOutputStream();
            while (k < length) {
                int j = fileinputstream.read(bytes, 0, (int) (length - k < ibuffer ? length - k : ibuffer));
                if (j < 1) {
                    break;
                }
                os.write(bytes, 0, j);
                k += j;
            }
            os.flush();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            fileinputstream.close();
        }
    }
}

下载的逻辑其实也不复杂，只是很繁琐。我也稍微解释一下。
把这段代码翻译成汉语是这样的：

  1. 通过解析Url获取文件名
  2. 判断文件是否存在，及时反馈
  3. 如果文件存在，判断请求的Header信息中是否存在Range信息，分断下载的信息就存储在range里面，这里就需要繁琐的解析 range信息，并于相应的文件信息比较判断，最终获取下载文件的分段起止位置进行下载。
  4. 将读取好文件信息通过byte数组返回。

Test

测试代码的提供也很重要，因为对外发布的接口往往需要提供调用范例。因为是Http请求测试，这里我也偷了个懒，基于httpclient4做了下测试，过程通畅，把代码列一下。

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
public class TestFileServer {


    @Test
    public void testUpload() throws Exception {
        String url = "http://127.0.0.1:8080/file/upload";
        File file = new File("/Users/por/yee/temp/a.jpg");
        postFile(file, url);

    }

    @Test
    public void testDownload() throws Exception {
        String url = "http://127.0.0.1:8080/file/download/52f2f9ac036495c277b2e13d.jpg";
        HttpClient httpclient = new DefaultHttpClient();
        HttpGet httpGet = new HttpGet(url);
        HttpResponse response = httpclient.execute(httpGet);
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            HttpEntity entity = response.getEntity();
            byte[] datas = EntityUtils.toByteArray(entity);
            System.out.println("data_length="+datas.length);
        }

    }


    public String postFile(File file, String url) throws ClientProtocolException, IOException {
        HttpClient httpclient = new DefaultHttpClient();

        HttpPost httppost = new HttpPost(url);
        FileBody fileBody = new FileBody(file);
        MultipartEntity reqEntity = new MultipartEntity();
        reqEntity.addPart("data", fileBody);
        httppost.setEntity(reqEntity);
        System.out.println("执行: " + httppost.getRequestLine());
        HttpResponse response = httpclient.execute(httppost);
        int statusCode = response.getStatusLine().getStatusCode();
        System.out.println("statusCode is " + statusCode);
        if (statusCode == 200) {
            HttpEntity resEntity = response.getEntity();
            if (resEntity != null) {
                byte[] resData = EntityUtils.toByteArray(resEntity);
                String content = new String(resData, "utf-8");
                System.out.println(content);
                return content;
            }
        }
        return "";
    }
}

文件服务器代码量不大，但是确实WEB应用中不可缺少的一个组成部分。同时，相关的逻辑基本上把Servlet，Http等知识都走了一遍，属于麻雀虽小五脏俱全的知识专区，值得好好探索一下。