SpringBoot2.x集成MongonDB gridFs实现文件的上传下载与常用API工具类

之前我们详细介绍了如何搭建、配置一个mongoDB服务器，今天主要就是介绍一下如何在我们的代码开发中去使用它了，不知道如何搭建的同学可以看一下之前的文章：MongonDB下载、安装(Windows)、配置详解

开始今天的内容：
首先新建一个Demo来实现今天的课程，新建项目过程不在介绍，大家自行百度即可

MongoDB gridFs集成

1） 引入依赖

   <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.6</version>
        </dependency>
    </dependencies>

2. 编写配置文件

server:
  port: 8088

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/netty?useSSL=false&serverTimezone=UTC&useUnicode=true
    username: root
    password: 123456
  #mongodb配置
  data:
    mongodb:
      host: localhost
      port: 27017
      database: test

mybatis:
  mapper-locations: classpath:/mapping/*.xml
  type-aliases-package: com.tl.model

3）新建配置类mongondbConfig

@Configuration
public class MongoConfig {

    @Autowired
    private MongoDbFactory mongoDbFactory;

    @Bean
    public GridFSBucket getGridFSBuckets() {
        MongoDatabase db = mongoDbFactory.getDb();
        return GridFSBuckets.create(db);
    }

}

4)实现使用 gridFs 上传/下载文件

@RestController
public class MongoController {

    @Autowired
    private GridFsTemplate gridFsTemplate;
    @Autowired
    private GridFSBucket gridFSBucket;
    
    @GetMapping("/filePush")
    public void filePush() throws FileNotFoundException {
        File file = new File("F:\\tupian\\test.jpg");
        System.out.println("文件路径：" + file.getPath());
        FileInputStream fio = new FileInputStream(file);
        ObjectId objectId = gridFsTemplate.store(fio,file.getName(), StandardCharsets.UTF_8);
        System.out.println("文件保存ID：" + objectId);

    }

    @GetMapping("/fileDel")
    public void fileDel() throws FileNotFoundException {
        String id = "5f056cd2c10f011ddc488514";
        Query query = Query.query(Criteria.where("_id").is(id));
        gridFsTemplate.delete(query);
    }

    @GetMapping("/getFile")
    public void getFile(HttpServletResponse response) throws Exception {
        String id = "5f056cd2c10f011ddc488514";
        Query query = Query.query(Criteria.where("_id").is(id));
        GridFSFile file = gridFsTemplate.findOne(query);
        if(null != file){
            GridFSDownloadStream in = gridFSBucket.openDownloadStream(file.getObjectId());
            GridFsResource resource = new GridFsResource(file,in);
            InputStream inputStream = resource.getInputStream();
            byte[] f = getBytes(inputStream);
            OutputStream out = response.getOutputStream();
            out.write(f);
        }
    }

    private byte[] getBytes(InputStream inputStream) throws  Exception{
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] b = new byte[1024];
        int  i = 0;
        while (-1!=(i=inputStream.read(b))){
            bos.write(b,0,i);
        }
        return bos.toByteArray();
    }
}

== 至此我们就完成了SpringBoot集成MongoDB gridFs文件上传、下载功能==

MongoDB gridFs简介

GridFS用于存储和恢复那些超过16M（BSON文件限制）的文件(如：图片、音频、视频等)。文件存储的一种方式，但是它是存储在MonoDB的集合中。会将大文件对象分割成多个小的chunk(文件片段),一般为256k/个,每个chunk将作为MongoDB的一个文档(document)被存储在chunks集合中。

GridFS 用两个集合来存储一个文件：fs.files与fs.chunks。
每个文件的实际内容被存在chunks(二进制数据)中,和文件有关的meta数据(filename,content_type,还有用户自定义的属性)将会被存在files集合中。

以下是简单的 fs.files 集合文档：

{
   "filename": "test.txt",
   "chunkSize": NumberInt(261120),
   "uploadDate": ISODate("2014-04-13T11:32:33.557Z"),
   "md5": "7b762939321e146569b07f72c62cca4f",
   "length": NumberInt(646)
}

以下是简单的 fs.chunks 集合文档：

{
   "files_id": ObjectId("534a75d19f54bfec8a2fe44b"),
   "n": NumberInt(0),
   "data": "Mongo Binary Data"
}

MongoDB 常用api工具类

因为MongoDB提供的方法较多，所以这里只是给大家提供一个常用api的工具类集成，有需要的同学可以自行添加其他api,本工具类主要实现对数据的CRUD操作

@Component
public class MongoDbUtil {

    @Autowired
    private static MongoTemplate mongoTemplate;

    /**
     * 保存数据对象
     * @param obj 集合为数据对象中@Document 注解所配置的collection
     */
    public static void save(Object obj){
        mongoTemplate.save(obj);
    }

    /**
     * 指定集合保存数据
     * @param obj 数据对象
     * @param collectionName 集合名
     */
    public static void save(Object obj,String collectionName){
        mongoTemplate.save(obj,collectionName);
    }

    /**
     * 根据数据对象ID删除数据
     * @param obj 数据对象
     */
    public static void remove(Object obj){
        mongoTemplate.remove(obj);
    }

    /**
     * 指定集合，根据数据对象ID删除数据
     * @param obj 数据对象
     * @param collName 集合名
     */
    public static void remove(Object obj,String collName){
        mongoTemplate.remove(obj, collName);
    }

    /**
     * 指定集合，根据key-value删除数据
     * @param key 数据对象
     * @param value 数据对象
     * @param collName 集合名
     */
    public static void removeById(String key,Object value,String collName){
        Criteria criteria = Criteria.where(key).is(value);
        criteria.and(key).is(value);
        Query query = Query.query(criteria);
        mongoTemplate.remove(query, collName);
    }

    /**
     * 指定集合修改数据，且仅修改找到的第一条数据
     * @param key 修改条件key
     * @param value 修改条件value
     * @param updateKeys 修改内容keys
     * @param updateValues 修改内容values
     * @param collName 集合名称
     */
    public static void updateFirst(String key,Object value
            ,String [] updateKeys,Object [] updateValues,String collName){
        Criteria criteria = Criteria.where(key).is(value);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i = 0; i < updateKeys.length; i++) {
            update.set(updateKeys[i],updateValues[i]);
        }
        mongoTemplate.updateFirst(query,update,collName);
    }

    /**
     * 指定集合修改数据，且仅修改找到的所有数据
     * @param key 修改条件key
     * @param value 修改条件value
     * @param updateKeys 修改内容keys
     * @param updateValues 修改内容values
     * @param collName 集合名称
     */
    public static void updateMulti(String key,Object value
            ,String [] updateKeys,Object [] updateValues,String collName){
        Criteria criteria = Criteria.where(key).is(value);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i = 0; i < updateKeys.length; i++) {
            update.set(updateKeys[i],updateValues[i]);
        }
        mongoTemplate.updateMulti(query,update,collName);
    }

    /**
     * 根据条件查询出所有结果集
     * @param obj 数据对象
     * @param keys 查询条件key
     * @param values 查询条件value
     */
    public static List<? extends Object> find(Object obj,String [] keys
            ,Object [] values){
        Criteria criteria = null;
        for (int i = 0; i < keys.length; i++) {
            if (i == 0){
                criteria = Criteria.where(keys[i]).is(values[i]);
            }else{
                criteria.and(keys[i]).is(values[i]);
            }
        }
        Query query = Query.query(criteria);
        List<? extends Object> result = mongoTemplate.find(query,Object.class);
        return result;
    }

    /**
     * 根据条件查询出所有结果集
     * @param obj 数据对象
     * @param keys 查询条件key
     * @param values 查询条件value
     * @param collName 集合名
     */
    public static List<? extends Object> find(Object obj,String [] keys
            ,Object [] values,String collName){
        Criteria criteria = null;
        for (int i = 0; i < keys.length; i++) {
            if (i == 0){
                criteria = Criteria.where(keys[i]).is(values[i]);
            }else{
                criteria.and(keys[i]).is(values[i]);
            }
        }
        Query query = Query.query(criteria);
        List<? extends Object> result = mongoTemplate.find(query,Object.class,collName);
        return result;
    }

    /**
     * 根据条件查询出所有结果集
     * @param obj 数据对象
     * @param keys 查询条件key
     * @param values 查询条件value
     * @param collName 集合名
     * @param sort 排序字段
     */
    public static List<? extends Object> find(Object obj,String [] keys
            ,Object [] values,String collName,String sort){
        Criteria criteria = null;
        for (int i = 0; i < keys.length; i++) {
            if (i == 0){
                criteria = Criteria.where(keys[i]).is(values[i]);
            }else{
                criteria.and(keys[i]).is(values[i]);
            }
        }
        Query query = Query.query(criteria);
        query.with(new Sort(Sort.Direction.DESC, sort));
        List<? extends Object> result = mongoTemplate.find(query,Object.class,collName);
        return result;
    }

    /**
     * 根据条件查询出符合的第一条数据
     * @param obj 数据对象
     * @param keys 查询条件key
     * @param values 查询条件value
     */
    public static Object findOne(Object obj,String [] keys,Object [] values){
        Criteria criteria = null;
        for (int i = 0; i < keys.length; i++) {
            if (i == 0){
                criteria = Criteria.where(keys[i]).is(values[i]);
            }else{
                criteria.and(keys[i]).is(values[i]);
            }
        }
        Query query = Query.query(criteria);
        Object result = mongoTemplate.findOne(query,Object.class);
        return result;
    }

    /**
     * 根据条件查询出符合的第一条数据
     * @param obj 数据对象
     * @param keys 查询条件key
     * @param values 查询条件value
     * @param collName 集合名
     */
    public static Object findOne(Object obj,String [] keys
            ,Object [] values,String collName){
        Criteria criteria = null;
        for (int i = 0; i < keys.length; i++) {
            if (i == 0){
                criteria = Criteria.where(keys[i]).is(values[i]);
            }else{
                criteria.and(keys[i]).is(values[i]);
            }
        }
        Query query = Query.query(criteria);
        Object result = mongoTemplate.findOne(query,Object.class,collName);
        return result;
    }

    /**
     * 根据查询出所有数据
     * @param obj 数据对象
     */
    public static List<? extends Object> findAll(Object obj){
        List<? extends Object> result = mongoTemplate.findAll(obj.getClass());
        return result;
    }

    /**
     * 指定集合 查询出所有数据
     * @param obj 数据对象
     */
    public static List<? extends Object> findAll(Object obj,String collName){
        List<? extends Object> result = mongoTemplate.findAll(obj.getClass(),collName);
        return result;
    }
}