万象城娱乐备用网址-做月子可以吃鸽子粥吗

首页

AD联系:507867812

万象城娱乐备用网址

时间:2019-11-18 15:01:05 作者:宝马会国际备用网址 浏览量:44366

万象城娱乐备用网址MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux,见下图

MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等),见下图

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux,如下图

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB结合Spring存储文件(图片、音频等等)

如下图

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux,如下图

MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux,见图

万象城娱乐备用网址MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB结合Spring存储文件(图片、音频等等)

万象城娱乐备用网址

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)。

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

1.MongoDB结合Spring存储文件(图片、音频等等)

MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

2.

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

3.

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux

MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)

4.MongoDB结合Spring存储文件(图片、音频等等)。

MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linuxMongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)MongoDB结合Spring存储文件(图片、音频等等)。万象城娱乐备用网址

展开全文
相关文章
vip娱乐备用网址

MongoDB结合Spring存储文件(图片、音频等等)

假日国际娱乐备用网站

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux....

永利备用域名

MongoDB结合Spring存储文件(图片、音频等等)....

伟德国际博彩备用网站

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux....

12bet备用网址官网

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux....

相关资讯
爱赢娱乐备用网址

MongoDB 存储图片等文件有两种方式

(该文章针对的是已经可以使用MONGODB整合Spring的用户)

相关阅读:

MongoDB备份与恢复 http://www.linuxidc.com/Linux/2012-07/64113.htm

CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm

CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm

CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm

Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm

如何在MongoDB中建立新数据库和集合 http://www.linuxidc.com/Linux/2013-06/85749.htm

MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm

《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm

1.使用MongoTemplate

/** * 存储文件 * @param collectionName 集合名 * @param file 文件 * @param fileid 文件id * @param companyid 文件的公司id * @param filename 文件名称 */ public void SaveFile(String collectionName, File file, String fileid, String companyid, String filename) { try { DB db = mongoTemplate.getDb(); // 存储fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSInputFile gfs = gridFS.createFile(file); gfs.put("aliases", companyid); gfs.put("filename", fileid); gfs.put("contentType", filename.substring(filename.lastIndexOf("."))); gfs.save(); } catch (Exception e) { e.printStackTrace(); System.out.println("存储文件时发生错误!!!"); } } // 取出文件 public GridFSDBFile retrieveFileOne(String collectionName, String filename) { try { DB db = mongoTemplate.getDb(); // 获取fs的根节点 GridFS gridFS = new GridFS(db, collectionName); GridFSDBFile dbfile = gridFS.findOne(filename); if (dbfile != null) { return dbfile; } } catch (Exception e) { // TODO: handle exception } return null; }//抱歉项目案例不能给你,不过这个是向mongodb存取文件的实现代码,希望能帮助到你。//由GridFSDBFile 可以得到inputStream,这样你就明白了吧。

2.使用GridFsTemplate

网上找到的第一种方法总结的非常的不好,Spring结合的感觉不够紧密。 谷歌了下参考了下网上的文章。

参考文章

Spring 伪配置

<mongo:mongo host="127.0.0.1" port="27017"> <mongo:options connections-per-host="200" threads-allowed-to-block-for-connection-multiplier="100" connect-timeout="1000" max-wait-time="1500" auto-connect-retry="true" socket-keep-alive="true" socket-timeout="1500" slave-ok="true" write-number="1" write-timeout="0" write-fsync="true" /></mongo:mongo>

<mongo:db-factory dbname="***" username="***" password="***" mongo-ref="mongo" />

<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" />

<!-- 取图函数 --><bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory" /> <constructor-arg ref="converter" /> <constructor-arg value="****" index="2" /><!-- 表名 --></bean>

<bean id="abstractMongoDB" class="com.***.AbstractMongoDB" abstract="true"> <property name="mongoTemplate"> <ref bean="mongoTemplate" /> </property> <property name="gridFsTemplate"> <ref bean="gridFsTemplate" /> </property> </bean>

Java 伪代码

List<GridFSDBFile> files = this.getGridFsTemplate().find(null); //查询全部,查询方式和MongoTemplate一样 System.out.println("-----------------"); for (GridFSDBFile file: files) { System.out.println(file); }

MongoDB 的详细介绍:请点这里MongoDB 的下载地址:请点这里

linux....

热门资讯