MongodbGFS结合SpringBoot 实现大文件的简单上传与下载

痛定思痛。 2022-05-31 04:59 229阅读 0赞

###### 今天主要为大家带来SpringBoot工程中MongodbGFS的简单使用。首先，我们的思路是，用表单提交文件，直接将文件存入Mongodb数据库中，然后将文件直接从数据库下载到客户端。当然我们用的是GFS结构的存储，因此我们的文件最好大于16M以上。这也与mongodb官方的建议相一致。这里还有不清楚的可以看我之前的一篇博客《MongodbGFS存储大文件》,[链接][Link 1]。 ######

###### 首先我们做一下准备工作，初始化一个SpringBoot工程。这里我继续使用的是gradle。 ######

###### ![0_wx_fmt_png][]![0_wx_fmt_png][]    ######

添加我们需要的依赖，spring-boot-starter-test 用gradle初始化springboot工程时默认添加了，除了这个我们需要添加额外的两个依赖就是，spring-boot-starter-data-mongodb和spring-boot-starter-thymeleaf（模板引擎用来生成网页）。

添加了依赖之后，我们需要进行配置mongodb，thymeleaf。具体的配置说明可以查看官方文档 [mongodb使用说明][mongodb]，[模板引擎在springboot中的配置][springboot]。

这里可以看一下我的配置文件。

\[java\] [view plain][] [copy][view plain]

1.  \#thymeleaf start  
2.  spring.thymeleaf.mode=HTML5  
3.  spring.thymeleaf.encoding=UTF-8  
4.  spring.thymeleaf.content-type=text/html  
5.  spring.thymeleaf.cache=false  
6.  \#thymeleaf end  
7.    
8.  \#mongodb start  
9.  spring.data.mongodb.uri=mongodb://39.106.177.24:27017/zhaotong  
10. \#mongodb end  
11.   
12.   
13. \#uploadfile start  
14. spring.http.multipart.max-file-size=1024000KB  
15. spring.http.multipart.max-request-size=2048000KB  
16. \#uploadfile end

关于mongodb uri的具体格式，我建议是直接去看源码：

![0_wx_fmt_png 1][]

下面的同时也配置了让springmvc放开文件大小的限制，因为我们主要做的是大文件上传。

接下来我们学习一下Springboot提供给我们关于 mongodb的操作工具类。主要我们看3个类：MongoTemplate.class   MongodbFactory.class    GridFsTemplate.class

首先mongoFacory 其实就和hibernateFactory一样为我们提供基于Mongodb的会话工厂。这里我们看源码：

![0_wx_fmt_png 2][]

它主要给我们返回DB对象，这里要说明这个类是线程安全的，为什么是线程安全的呢？我们接着来看DB这个类

![0_wx_fmt_png 3][]

很明显DB是线程安全的，那么工厂如何让提供给我们的的db是线程安全的呢？所以就有了接下来这段代码：

![0_wx_fmt_png 4][]

大家可以看到了ConcurrentHashMap出现了，所以这里希望大家多看看源代码，是有好处的。

至于MongoTemplate.class 这个类其实和jdbcTemplate扮演的角色一样，这里就不多说了，我们今天主要用到的是GridFsTemplate.class。我们看这个类的源码，我们今天所使用的方法都是来源于这个类。

\[java\] [view plain][] [copy][view plain]

1.  /\* 
2.   \* Copyright 2011-2017 the original author or authors. 
3.   \* 
4.   \* Licensed under the Apache License, Version 2.0 (the "License"); 
5.   \* you may not use this file except in compliance with the License. 
6.   \* You may obtain a copy of the License at 
7.   \* 
8.   \*      http://www.apache.org/licenses/LICENSE-2.0 
9.   \* 
10.  \* Unless required by applicable law or agreed to in writing, software 
11.  \* distributed under the License is distributed on an "AS IS" BASIS, 
12.  \* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
13.  \* See the License for the specific language governing permissions and 
14.  \* limitations under the License. 
15.  \*/  
16. package org.springframework.data.mongodb.gridfs;  
17.   
18. import static org.springframework.data.mongodb.core.query.Query.\*;  
19. import static org.springframework.data.mongodb.gridfs.GridFsCriteria.\*;  
20.   
21. import java.io.InputStream;  
22. import java.util.ArrayList;  
23. import java.util.List;  
24.   
25. import org.springframework.core.io.support.ResourcePatternResolver;  
26. import org.springframework.data.mongodb.MongoDbFactory;  
27. import org.springframework.data.mongodb.core.convert.MongoConverter;  
28. import org.springframework.data.mongodb.core.convert.QueryMapper;  
29. import org.springframework.data.mongodb.core.query.Query;  
30. import org.springframework.util.Assert;  
31. import org.springframework.util.StringUtils;  
32.   
33. import com.mongodb.BasicDBObject;  
34. import com.mongodb.DB;  
35. import com.mongodb.DBObject;  
36. import com.mongodb.gridfs.GridFS;  
37. import com.mongodb.gridfs.GridFSDBFile;  
38. import com.mongodb.gridfs.GridFSFile;  
39. import com.mongodb.gridfs.GridFSInputFile;  
40.   
41. /\*\* 
42.  \* \{@link GridFsOperations\} implementation to store content into MongoDB GridFS. 
43.  \*  
44.  \* @author Oliver Gierke 
45.  \* @author Philipp Schneider 
46.  \* @author Thomas Darimont 
47.  \* @author Martin Baumgartner 
48.  \* @author Christoph Strobl 
49.  \* @author Mark Paluch 
50.  \*/  
51. public class GridFsTemplate implements GridFsOperations, ResourcePatternResolver \{  
52.   
53.     private final MongoDbFactory dbFactory;  
54.     private final String bucket;  
55.     private final MongoConverter converter;  
56.     private final QueryMapper queryMapper;  
57.   
58.     /\*\* 
59.      \* Creates a new \{@link GridFsTemplate\} using the given \{@link MongoDbFactory\} and \{@link MongoConverter\}. 
60.      \*  
61.      \* @param dbFactory must not be \{@literal null\}. 
62.      \* @param converter must not be \{@literal null\}. 
63.      \*/  
64.     public GridFsTemplate(MongoDbFactory dbFactory, MongoConverter converter) \{  
65.         this(dbFactory, converter, null);  
66.     \}  
67.   
68.     /\*\* 
69.      \* Creates a new \{@link GridFsTemplate\} using the given \{@link MongoDbFactory\} and \{@link MongoConverter\}. 
70.      \*  
71.      \* @param dbFactory must not be \{@literal null\}. 
72.      \* @param converter must not be \{@literal null\}. 
73.      \* @param bucket 
74.      \*/  
75.     public GridFsTemplate(MongoDbFactory dbFactory, MongoConverter converter, String bucket) \{  
76.   
77.         Assert.notNull(dbFactory, "MongoDbFactory must not be null!");  
78.         Assert.notNull(converter, "MongoConverter must not be null!");  
79.   
80.         this.dbFactory = dbFactory;  
81.         this.converter = converter;  
82.         this.bucket = bucket;  
83.   
84.         this.queryMapper = new QueryMapper(converter);  
85.     \}  
86.   
87.     /\* 
88.      \* (non-Javadoc) 
89.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#store(java.io.InputStream, java.lang.String) 
90.      \*/  
91.     public GridFSFile store(InputStream content, String filename) \{  
92.         return store(content, filename, (Object) null);  
93.     \}  
94.   
95.     /\* 
96.      \* (non-Javadoc) 
97.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#store(java.io.InputStream, java.lang.Object) 
98.      \*/  
99.   
100.     @Override  
101.     public GridFSFile store(InputStream content, Object metadata) \{  
102.         return store(content, null, metadata);  
103.     \}  
104.   
105.     /\* 
106.      \* (non-Javadoc) 
107.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#store(java.io.InputStream, com.mongodb.DBObject) 
108.      \*/  
109.     @Override  
110.     public GridFSFile store(InputStream content, DBObject metadata) \{  
111.         return store(content, null, metadata);  
112.     \}  
113.   
114.     /\* 
115.      \* (non-Javadoc) 
116.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#store(java.io.InputStream, java.lang.String, java.lang.String) 
117.      \*/  
118.     public GridFSFile store(InputStream content, String filename, String contentType) \{  
119.         return store(content, filename, contentType, (Object) null);  
120.     \}  
121.   
122.     /\* 
123.      \* (non-Javadoc) 
124.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#store(java.io.InputStream, java.lang.String, java.lang.Object) 
125.      \*/  
126.     public GridFSFile store(InputStream content, String filename, Object metadata) \{  
127.         return store(content, filename, null, metadata);  
128.     \}  
129.   
130.     /\* 
131.      \* (non-Javadoc) 
132.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#store(java.io.InputStream, java.lang.String, java.lang.String, java.lang.Object) 
133.      \*/  
134.     public GridFSFile store(InputStream content, String filename, String contentType, Object metadata) \{  
135.   
136.         DBObject dbObject = null;  
137.   
138.         if (metadata != null) \{  
139.             dbObject = new BasicDBObject();  
140.             converter.write(metadata, dbObject);  
141.         \}  
142.   
143.         return store(content, filename, contentType, dbObject);  
144.     \}  
145.   
146.     /\* 
147.      \* (non-Javadoc) 
148.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#store(java.io.InputStream, java.lang.String, com.mongodb.DBObject) 
149.      \*/  
150.     public GridFSFile store(InputStream content, String filename, DBObject metadata) \{  
151.         return this.store(content, filename, null, metadata);  
152.     \}  
153.   
154.     /\* 
155.      \* (non-Javadoc) 
156.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#store(java.io.InputStream, java.lang.String, com.mongodb.DBObject) 
157.      \*/  
158.     public GridFSFile store(InputStream content, String filename, String contentType, DBObject metadata) \{  
159.   
160.         Assert.notNull(content, "InputStream must not be null!");  
161.   
162.         GridFSInputFile file = getGridFs().createFile(content);  
163.   
164.         if (filename != null) \{  
165.             file.setFilename(filename);  
166.         \}  
167.   
168.         if (metadata != null) \{  
169.             file.setMetaData(metadata);  
170.         \}  
171.   
172.         if (contentType != null) \{  
173.             file.setContentType(contentType);  
174.         \}  
175.   
176.         file.save();  
177.         return file;  
178.     \}  
179.   
180.     /\* 
181.      \* (non-Javadoc) 
182.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#find(com.mongodb.DBObject) 
183.      \*/  
184.     public List<GridFSDBFile> find(Query query) \{  
185.   
186.         if (query == null) \{  
187.             return getGridFs().find(new BasicDBObject());  
188.         \}  
189.   
190.         DBObject queryObject = getMappedQuery(query.getQueryObject());  
191.         DBObject sortObject = getMappedQuery(query.getSortObject());  
192.   
193.         return getGridFs().find(queryObject, sortObject);  
194.     \}  
195.   
196.     /\* 
197.      \* (non-Javadoc) 
198.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#findOne(com.mongodb.DBObject) 
199.      \*/  
200.     public GridFSDBFile findOne(Query query) \{  
201.         return getGridFs().findOne(getMappedQuery(query));  
202.     \}  
203.   
204.     /\* 
205.      \* (non-Javadoc) 
206.      \* @see org.springframework.data.mongodb.gridfs.GridFsOperations\#delete(org.springframework.data.mongodb.core.query.Query) 
207.      \*/  
208.     public void delete(Query query) \{  
209.         getGridFs().remove(getMappedQuery(query));  
210.     \}  
211.   
212.     /\* 
213.      \* (non-Javadoc) 
214.      \* @see org.springframework.core.io.ResourceLoader\#getClassLoader() 
215.      \*/  
216.     public ClassLoader getClassLoader() \{  
217.         return dbFactory.getClass().getClassLoader();  
218.     \}  
219.   
220.     /\* 
221.      \* (non-Javadoc) 
222.      \* @see org.springframework.core.io.ResourceLoader\#getResource(java.lang.String) 
223.      \*/  
224.     public GridFsResource getResource(String location) \{  
225.   
226.         GridFSDBFile file = findOne(query(whereFilename().is(location)));  
227.         return file != null ? new GridFsResource(file) : null;  
228.     \}  
229.   
230.     /\* 
231.      \* (non-Javadoc) 
232.      \* @see org.springframework.core.io.support.ResourcePatternResolver\#getResources(java.lang.String) 
233.      \*/  
234.     public GridFsResource\[\] getResources(String locationPattern) \{  
235.   
236.         if (!StringUtils.hasText(locationPattern)) \{  
237.             return new GridFsResource\[0\];  
238.         \}  
239.   
240.         AntPath path = new AntPath(locationPattern);  
241.   
242.         if (path.isPattern()) \{  
243.   
244.             List<GridFSDBFile> files = find(query(whereFilename().regex(path.toRegex())));  
245.             List<GridFsResource> resources = new ArrayList<GridFsResource>(files.size());  
246.   
247.             for (GridFSDBFile file : files) \{  
248.                 resources.add(new GridFsResource(file));  
249.             \}  
250.   
251.             return resources.toArray(new GridFsResource\[resources.size()\]);  
252.         \}  
253.   
254.         return new GridFsResource\[\] \{ getResource(locationPattern) \};  
255.     \}  
256.   
257.     private DBObject getMappedQuery(Query query) \{  
258.         return query == null ? new Query().getQueryObject() : getMappedQuery(query.getQueryObject());  
259.     \}  
260.   
261.     private DBObject getMappedQuery(DBObject query) \{  
262.         return query == null ? null : queryMapper.getMappedObject(query, null);  
263.     \}  
264.   
265.     private GridFS getGridFs() \{  
266.         DB db = dbFactory.getDb();  
267.         return bucket == null ? new GridFS(db) : new GridFS(db, bucket);  
268.     \}  
269. \}

所以说不需要看文档，看他的源码我们就知道如何使用了。接下来我们实战，首先我们做一个html模板，用来上传文件，和下载文件。代码如下：

![0_wx_fmt_png 5][]

源码：

\[html\] [view plain][] [copy][view plain]

1.  <!DOCTYPE html>  
2.    
3.  <html xmlns="http://www.w3.org/1999/xhtml"  
4.        xmlns:th="http://www.thymeleaf.org">  
5.  <head>  
6.      <title>uploadForm</title>  
7.      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />  
8.  </head>  
9.  <body>  
10.     <div>  
11.         <form method="POST" enctype="multipart/form-data" action="/uploadfile">  
12.                 <input type="file" name="file" />  
13.                 <input type="submit" value="上传" />  
14.         </form>  
15.         <form method="POST" action="/downloadfile">  
16.             <p>输入文件名<input type="text" name="fname" /></p>  
17.              <input type="submit" value="下载" />  
18.         </form>  
19.     </div>  
20. </body>  
21. </html>

接着我们编写controller ，这次我们是学习，就不分层写了，如果正式开发，我们最好按照层级来写。controller代码如下：

\[java\] [view plain][] [copy][view plain]

1.  package com.example.controller;  
2.    
3.  import java.io.IOException;  
4.  import java.io.InputStream;  
5.  import javax.servlet.ServletException;  
6.  import javax.servlet.http.HttpServletRequest;  
7.  import javax.servlet.http.HttpServletResponse;  
8.  import javax.servlet.http.Part;  
9.    
10. import org.springframework.beans.factory.annotation.Autowired;  
11. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;  
12. import org.springframework.data.mongodb.core.query.Criteria;  
13. import org.springframework.data.mongodb.core.query.Query;  
14. import org.springframework.data.mongodb.gridfs.GridFsTemplate;  
15. import org.springframework.stereotype.Controller;  
16. import org.springframework.ui.Model;  
17. import org.springframework.web.bind.annotation.RequestMapping;  
18. import org.springframework.web.bind.annotation.RequestMethod;  
19. import org.springframework.web.bind.annotation.RequestParam;  
20. import org.springframework.web.bind.annotation.ResponseBody;  
21.   
22. import com.mongodb.gridfs.GridFSDBFile;  
23. import com.mongodb.gridfs.GridFSFile;  
24.   
25. @Controller  
26. @EnableAutoConfiguration  
27. public class FileUploadController \{  
28.   
29.     // 获得SpringBoot提供的mongodb的GridFS对象  
30.     @Autowired  
31.     private GridFsTemplate gridFsTemplate;  
32.   
33.     // 工程主页  
34.     @RequestMapping(value = "/", method = RequestMethod.GET)  
35.     String home(Model model) \{  
36.         return "uploadForm";  
37.     \}  
38.   
39.     // 上传文件控制器  
40.     @RequestMapping(value = "/uploadfile", method = RequestMethod.POST)  
41.     @ResponseBody  
42.     String uploadfile(HttpServletRequest request) \{  
43.         String result = "error";  
44.         try \{  
45.             /\*\* 
46.              \* Servlet3.0新增了request.getParts()/getPart(String filename) api， 
47.              \* 用于获取使用multipart/form-data格式传递的http请求的请求体， 通常用于获取上传文件。 
48.              \*/  
49.             Part part = request.getPart("file");  
50.   
51.             // 获得提交的文件名  
52.             String filename = part.getSubmittedFileName();  
53.             // 获得文件输入流  
54.             InputStream ins = part.getInputStream();  
55.             // 获得文件类型  
56.             String contenttype = part.getContentType();  
57.             // 将文件存储到mongodb中,mongodb 将会返回这个文件的具体信息  
58.             GridFSFile gfs = gridFsTemplate.store(ins, filename, contenttype);  
59.   
60.             result = gfs.toString();  
61.   
62.         \} catch (IOException e) \{  
63.         \} catch (ServletException e) \{  
64.             e.printStackTrace();  
65.         \}  
66.         return result;  
67.     \}  
68.   
69.     // 下载文件控制器  
70.     @RequestMapping(value = "/downloadfile", method = RequestMethod.POST)  
71.     @ResponseBody  
72.     String downloadfile(@RequestParam(name = "fname", required = true) String filename, HttpServletResponse response) \{  
73.   
74.         /\*\* 
75.          \* 关于Query的具体用发下面的链接给的很清楚了，这里就不多说了。 
76.          \*  
77.          \* @link\{http://www.baeldung.com/queries-in-spring-data-mongodb\} 
78.          \*/  
79.         Query query = Query.query(Criteria.where("filename").is(filename));  
80.   
81.         // 查询单个文件  
82.         GridFSDBFile gfsfile = gridFsTemplate.findOne(query);  
83.   
84.         // 通知浏览器进行文件下载  
85.         response.setContentType(gfsfile.getContentType());  
86.         response.setHeader("Content-Disposition", "attachment;filename=" + gfsfile.getFilename());  
87.   
88.         try \{  
89.             gfsfile.writeTo(response.getOutputStream());  
90.         \} catch (IOException e) \{  
91.             e.printStackTrace();  
92.         \}  
93.   
94.         return "success";  
95.     \}  
96.   
97. \}

然后我们使用gradle启动工程：

![0_wx_fmt_png 6][]

![0_wx_fmt_png 7][]

然后我们打开主页选择上传的文件：

![0_wx_fmt_png 8][]

点击上传之后，我们收到服务器返回的文件信息（我没有做处理，信息就是Mongodb返回的）：

![0_wx_fmt_png 9][]

接下来我们回到主页，去下载这个文件（输入刚才上传的文件名）：

![0_wx_fmt_png 10][]

然后点击下载就出现了下面的一幕：

![0_wx_fmt_png 11][]

浏览器已经开始下载我们的文件了。

这就是我们这次演示的过程。Mongodb为我们管理文件，特别由于Mongodb本身就是分布式数据库，我们的文件也就是分布式存储了，比自己搭建一个分布式文件服务器方便多了。但Mongodbgfs适合大文件，小文件直接存入文档，更加方便。

给一点我的建议：多看源码，多看官方的文档。

如有问题，可联系我：1427730623.

我的工程结构图（一个入口类，一个html，一个controller，再加一个配置文件，代码基本上博客都贴出来了，我就不放工程了）：

![0_wx_fmt_png 12][]

[Link 1]: http://blog.csdn.net/cher1sh_zhaotong/article/details/79192876
[0_wx_fmt_png]: /images/20220531/73de4814f0a94fe2b492a6e88bec2fc3.png
[mongodb]: https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-features-mongodb
[springboot]: https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-features-spring-mvc-template-engines
[view plain]: http://blog.csdn.net/cher1sh_zhaotong/article/details/79275956#
[0_wx_fmt_png 1]: /images/20220531/c7f0326de16542fab6c4095240f16744.png
[0_wx_fmt_png 2]: /images/20220531/2269b34e1a2649eab6945ff34d54bbda.png
[0_wx_fmt_png 3]: /images/20220531/acde0100e1c74828a484b8720606adf9.png
[0_wx_fmt_png 4]: /images/20220531/307f4d1ba5d9481791c745b6f86368ff.png
[0_wx_fmt_png 5]: /images/20220531/844064bc691e4732ba2a86833077bcbc.png
[0_wx_fmt_png 6]: /images/20220531/f5a046237f0f4bce9f5f954d1595d904.png
[0_wx_fmt_png 7]: /images/20220531/3eb603ba53bd4a30afa5c71bd1b83652.png
[0_wx_fmt_png 8]: /images/20220531/fb42d71931464ee5a637f88e9688230c.png
[0_wx_fmt_png 9]: /images/20220531/48bceec8402644d7a6fafa0029e8d63e.png
[0_wx_fmt_png 10]: /images/20220531/3080c8d260ba444ea16cc92a56cea6e1.png
[0_wx_fmt_png 11]: /images/20220531/b42c977c6cf54d7da68147b0df240454.png
[0_wx_fmt_png 12]: /images/20220531/d5fb20798f57479aa18fbace857cfbd1.png