devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Mongodb GridFS中对文件的上传、下载、删除_docker mongodb gridfs文件下载命令

作者：羊村懒王 | 2024-03-11 23:52:34

赞

踩

docker mongodb gridfs文件下载命令

  因为公司之前电商系统的图片存储用的是mongodb，所以昨天讨论后把原定的fastfds改用为mongodb的gridfs。

 mongodb的分片机制也是高可用，高可扩展的。

 mongodb3.2 api地址

 maven地址：

 

  1. <dependency>
  2.     <groupId>org.mongodb</groupId>
  3.     <artifactId>mongo-java-driver</artifactId>
  4.     <version>3.2.2</version>
  5. </dependency>

 

 

 

下面是工具类

 

  1. package com.yjy.dg.app.log.mongo;  
  2. import com.mongodb.MongoClient; 
  3. import com.mongodb.MongoClientOptions; 
  4. import com.mongodb.MongoCredential; 
  5. import com.mongodb.ServerAddress; 
  6. import com.mongodb.client.MongoDatabase; 
  7. import com.mongodb.client.gridfs.GridFSBucket; 
  8. import com.mongodb.client.gridfs.GridFSBuckets; 
  9. import com.mongodb.client.gridfs.GridFSDownloadStream; 
  10. import com.mongodb.client.gridfs.model.GridFSFile; 
  11. import com.yjy.dg.app.log.utils.CommonUtil; 
  12. import org.bson.types.ObjectId; 
  13. import org.slf4j.Logger; 
  14. import org.slf4j.LoggerFactory;  
  15. import java.io.*; 
  16. import java.net.URL; 
  17. import java.util.ArrayList; 
  18. import java.util.List; 
  19. import java.util.Properties; 
  20. import java.util.UUID; 
  21. import java.util.regex.Pattern;  
  22. /**  
  23.  * MongoDbUtil use mongo-java-driver-3.2.2 gridfs  *  
  24.  * @author littlehow  
  25.  * @time 2016-07-19 9:18  
  26. */ 
  27. public class MongoDbUtil { 
  28.     private MongoDbUtil(){} 
  29.     private final static Properties properties = new Properties();  
  30.     private static Logger log = LoggerFactory.getLogger(MongoDbUtil.class);  
  31.     static { 
  32.         try { 
  33.             URL url = MongoDbUtil.class.getClassLoader().getResource("mongo_db.properties");  
  34.             if (url != null) { 
  35.                 log.info("Found 'mongo_db.properties' file in local classpath");
  36.                 InputStream in = url.openStream();  
  37.                 try { 
  38.                     properties.load(in);  
  39.                 } finally { 
  40.                     in.close();  
  41.                 } 
  42.              } 
  43.         } catch (IOException e) { 
  44.             log.info("Could not load 'mongo_db.properties' file from local classpath: " + e);  
  45.         } 
  46.     }
  47.  
  48.     /**  
  49.       * config file info  
  50.       */  
  51.     private static class Config { 
  52.         //mongodb connection properties  
  53.         public static String ip = null; 
  54.         //default port is 27017 
  55.         public static int port = 27017;
  56.         public static String database = null;
  57.         //mongodb connection pool properties  
  58.         public static int connectionsPerHost = 10;  
  59.         public static int maxWaitTime = 120000;  
  60.         public static int connectTimeout = 0;  
  61.         public static MongoClientOptions options = null;  
  62.         //author  
  63.         public static List<MongoCredential> credential = new ArrayList<>();  
  64.         static { 
  65.             ip = properties.getProperty("mongo_ip");  
  66.             database = properties.getProperty("mongo_database");  
  67.             int _port = CommonUtil.getIntValue(properties.getProperty("mongo_port"));  
  68.             if (_port != -1) port = _port;  int _conn = CommonUtil.getIntValue(properties.getProperty("connections_per_host"));  
  69.             if (_conn != -1) connectionsPerHost = _conn;  
  70.             int _waittime = CommonUtil.getIntValue(properties.getProperty("max_wait_time"));  
  71.             if (_waittime != -1) maxWaitTime = _waittime;  
  72.             int _timeout = CommonUtil.getIntValue(properties.getProperty("connect_timeout"));  
  73.             if (_timeout != -1) connectTimeout = _timeout;  
  74.             options = MongoClientOptions.builder().connectTimeout(connectTimeout) .maxWaitTime(maxWaitTime).connectionsPerHost(connectionsPerHost).build(); 
  75.             MongoCredential credential1 = MongoCredential.createCredential(properties.getProperty("mongo_user"),  database, properties.getProperty("mongo_pass").toCharArray());  
  76.             credential.add(credential1);  
  77.         } 
  78.     } 
  79.     private static final class MongoInstance { 
  80.         public final static MongoClient client;  
  81.         static { 
  82.             client = new MongoClient(new ServerAddress(Config.ip, Config.port), Config.credential, Config.options);  
  83.         } 
  84.     }
  85.  
  86.     /**  
  87.       * destroy pool  
  88.       */  
  89.     public static final void destroy() { 
  90.         MongoInstance.client.close();  
  91.     } 
  92.  
  93.     /**  
  94.       * get a MongoDatabase  
  95.       * @return  
  96.       */  
  97.     public static MongoDatabase getDatabase() { 
  98.         return MongoInstance.client.getDatabase(Config.database);  
  99.     } 
  100.  
  101.     /**  
  102.       * get a MongoDatabase by Name  
  103.       * @param databaseName  
  104.       * @return  
  105.       */  
  106.     public static MongoDatabase getDatabase(String databaseName) { 
  107.         return MongoInstance.client.getDatabase(databaseName);  
  108.     } 
  109.  
  110.     /**  
  111.       * upload file to mongo  
  112.       * @param filename  
  113.       * @param in  
  114.       * @return  
  115.       */  
  116.     public static String uploadFileToGridFS(String filename, InputStream in) {
  117.         //default bucket name is fs  
  118.         GridFSBucket bucket = GridFSBuckets.create(getDatabase());  
  119.         ObjectId fileId = bucket.uploadFromStream(filename, in);  
  120.         return fileId.toHexString();  
  121.     } 
  122.  
  123.     /**  
  124.       * upload file to mongo, if close is true then close the inputstream  
  125.       * @param filename  
  126.       * @param in  
  127.       * @param close  
  128.       * @return  
  129.       */  
  130.     public static String uploadFileToGridFS(String filename, InputStream in, boolean close) { 
  131.         String returnId = null;  
  132.         try { 
  133.             returnId = uploadFileToGridFS(filename, in);  
  134.         } finally { 
  135.             if (close) { 
  136.                 try { 
  137.                     in.close();  
  138.                 } catch (IOException e) { 
  139.                     log.info("close inputstream fail:" + e);  
  140.                 } 
  141.             } 
  142.         } 
  143.         return returnId;  
  144.     } 
  145.  
  146.     /**  
  147.       * upload file to mongo  
  148.       * @param fileName  
  149.       * @param file  
  150.       * @return  
  151.       */  
  152.     public static String uploadFileToGridFs(String fileName, File file) {
  153.         InputStream in = null;  
  154.         try { 
  155.             in = new FileInputStream(file);  
  156.             String returnId = uploadFileToGridFS(fileName, in, true);  
  157.             return returnId;  
  158.         } catch (IOException e) { 
  159.             log.info("upload fail:" + e);  
  160.         } 
  161.         return null;  
  162.     } 
  163.  
  164.     /**  
  165.       * set filename = file name  
  166.       * @param file  
  167.       * @return  
  168.       */  
  169.     public static String uploadFileToGridFs(File file) { 
  170.         return uploadFileToGridFs(file.getName(), file);  
  171.     } 
  172.     
  173.     /**  
  174.       * set filename = uuid  
  175.       * @param file  
  176.       * @return  
  177.       */  
  178.     public static String uploadFileToGridFSByUUID(File file) { 
  179.         return uploadFileToGridFs(UUID.randomUUID().toString(), file);  
  180.     } 
  181.  
  182.     /**  
  183.       * download file for gridfs by objectid  
  184.       * @param objectId  
  185.       * @param out  
  186.       */  
  187.     public static void downloadFile(String objectId, OutputStream out) { 
  188.         GridFSBucket bucket = GridFSBuckets.create(getDatabase());      
  189.         bucket.downloadToStream(new ObjectId(objectId), out);  
  190.     } 
  191.  
  192.     /**  
  193.       * download file for gridfs by objectid  
  194.       * @param objectId  
  195.       * @param file  
  196.       */  
  197.     public static void downloadFile(String objectId, File file) { 
  198.         OutputStream os = null;  
  199.         try { 
  200.             os = new FileOutputStream(file);  
  201.             downloadFile(objectId, os);  
  202.         } catch (IOException e) { 
  203.             log.info("download fail:" + e);  
  204.         } finally { 
  205.             if (os != null) { 
  206.                 try { 
  207.                     os.close();  
  208.                 } catch (IOException e) { 
  209.                     log.info("close outputstream fail:" + e);  
  210.                 } 
  211.             } 
  212.         } 
  213.     } 
  214.  
  215.     /**  
  216.       * download file for gridfs by objectid  
  217.       * @param objectId  
  218.       * @param filename  
  219.       */  
  220.     public static void downloadFile(String objectId, String filename) { 
  221.         File file = new File(filename);  
  222.         downloadFile(objectId, file);  
  223.     } 
  224.  
  225.     /**  
  226.       * download file for gridfs by filename  
  227.       * @param filename  
  228.       * @param out  
  229.       */  
  230.     public static void downloadFileByName(String filename, OutputStream out) { 
  231.         GridFSBucket bucket = GridFSBuckets.create(getDatabase());  
  232.         bucket.downloadToStreamByName(filename, out);  
  233.     } 
  234.  
  235.     /**  
  236.       * download file for gridfs use stream  
  237.       * 如果一次性读取所有字节，大于chunk size的可能会出现乱序，导致文件损坏  
  238.       * @param objectId  
  239.       * @param out  
  240.       */  
  241.     public static void downloadFileUseStream(String objectId, OutputStream out) { 
  242.         GridFSBucket bucket = GridFSBuckets.create(getDatabase());  
  243.         GridFSDownloadStream stream = null;  
  244.         try { 
  245.             stream = bucket.openDownloadStream(new ObjectId(objectId));  
  246.             /** gridfs file */  
  247.             GridFSFile file = stream.getGridFSFile();  
  248.             /** chunk size */  
  249.             int size = file.getChunkSize();  
  250.             int len = (int)file.getLength();  
  251.             /** loop time */  
  252.             int cnt = len / size + (len % size == 0 ? 0 : 1);  
  253.             byte[] bts = new byte[Math.min(len, size)];  
  254.             try { 
  255.                 while (cnt-- > 0) { 
  256.                     int tmp = stream.read(bts);  
  257.                     out.write(bts, 0, tmp);  
  258.                 } 
  259.                 out.flush();  
  260.             } catch (IOException e) { 
  261.                 log.info("download fail:");  
  262.             } 
  263.         } finally { 
  264.             if (stream != null) stream.close();  
  265.         } 
  266.     } 
  267.  
  268.     /**  
  269.       * download file for gridfs use stream  
  270.       * @param objectId  
  271.       * @param fileName  
  272.       */  
  273.     public static void downloadFileUseStream(String objectId, String fileName) { 
  274.         File file = new File(fileName);  
  275.         downloadFileUseStream(objectId, file);  
  276.     } 
  277.  
  278.     /**  
  279.       * download file for gridfs use stream  
  280.       * @param objectId  
  281.       * @param file  
  282.       */  
  283.     public static void downloadFileUseStream(String objectId, File file) { 
  284.         OutputStream os = null;  
  285.         try { 
  286.             os = new FileOutputStream(file);  
  287.             downloadFileUseStream(objectId, os);  
  288.         } catch (IOException e) { 
  289.             log.info("download fail:" + e);  
  290.         } finally { 
  291.             if (os != null) { 
  292.                 try { 
  293.                     os.close();  
  294.                 } catch (IOException e) { 
  295.                     // skip  
  296.                 } 
  297.             } 
  298.         } 
  299.     } 
  300.  
  301.     /**  
  302.       * 将mongo gridfs的文件下载到内存  
  303.       * @param objectId  
  304.       * @return  
  305.       */  
  306.     public static byte[] downloadFileUseStream(String objectId) { 
  307.         GridFSBucket bucket = GridFSBuckets.create(getDatabase());
  308.         GridFSDownloadStream stream = null;  
  309.         try { 
  310.             stream = bucket.openDownloadStream(new ObjectId(objectId));  
  311.             /** gridfs file */  
  312.             GridFSFile file = stream.getGridFSFile();  
  313.             /** chunk size */  
  314.             int size = file.getChunkSize();  
  315.             int len = (int)file.getLength();  
  316.             int readSize = Math.min(len, size);  
  317.             byte[] returnBts = new byte[len];  
  318.             /** offset num */  
  319.             int offset = 0;  
  320.             while (len > 0) { 
  321.                 int tmp;  
  322.                 if (len > readSize) { 
  323.                     tmp = stream.read(returnBts, offset, readSize);  
  324.                     offset += tmp;  
  325.                 } else { 
  326.                     tmp = stream.read(returnBts, offset, len);  
  327.                 } 
  328.                 len -= tmp;  
  329.             } 
  330.             return returnBts;  
  331.         } finally { 
  332.             if (stream != null) stream.close();  
  333.         } 
  334.     } 
  335.  
  336.     /**  
  337.       * delete file from gridfs by objectId  
  338.       * @param objectId  
  339.       */  
  340.     public static void deleteByObjectId(String objectId) { 
  341.         GridFSBucket bucket = GridFSBuckets.create(getDatabase());  
  342.         bucket.delete(new ObjectId(objectId));  
  343.     } 
  344. }


 

 

 

 

简单的测试调用：

 

  1. package littlehow.test;
  2.  
  3. import littlehow.utils.MongoDbUtil;
  4.  
  5. import java.io.File;
  6.  
  7. /**
  8.  * MongoDbTest
  9.  *
  10.  * @author littlehow
  11.  * @time 2016-07-19 15:13
  12.  */
  13. public class MongoDbTest {
  14.     public static void main(String[] args) {
  15. //        upload();
  16. //        download();
  17.         delete();
  18.     }
  19.  
  20.     /**
  21.      * 先上传
  22.      */
  23.     public static void upload() {
  24.         File file = new File("E:\\before\\myself.zip");
  25.         String objectId = MongoDbUtil.uploadFileToGridFSByUUID(file);
  26.         System.out.println(objectId);//578dccf8b585d81928e6ba62
  27.     }
  28.  
  29.     /**
  30.      * 再测试下载
  31.      */
  32.     public static void download() {
  33.         File file = new File("C:\\Users\\Administrator\\Desktop\\linshi\\new.zip");
  34.         MongoDbUtil.downloadFile("578dccf8b585d81928e6ba62", file);
  35.     }
  36.  
  37.     /**
  38.      * 最后将上传的信息删除
  39.      */
  40.     public static void delete() {
  41.         MongoDbUtil.deleteByObjectId("578dccf8b585d81928e6ba62");
  42.     }
  43. }

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/220853
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号