Carregar e recuperar arquivos usando o MongoDB e o Spring Boot

1. Visão geral

Neste tutorial, discutiremos como fazer upload e recuperar arquivos usando MongoDB e Spring Boot.

Usaremos MongoDBBSON para arquivos pequenos eGridFS para os maiores.

2. Configuração do Maven

Primeiro, vamos adicionar a dependênciaspring-boot-starter-data-mongodb ao nossopom.xml:


    org.springframework.boot
    spring-boot-starter-data-mongodb

Além disso, precisaremos das dependênciasspring-boot-starter-webespring-boot-starter-thymeleaf para exibir a interface do usuário de nosso aplicativo. Essas dependências também são mostradas em nossoGuide to Spring Boot with Thymeleaf.

Neste tutorial, estamos usando Spring Boot versão 2.x.

3. Propriedades do Spring Boot

A seguir, vamos configurar as propriedades necessárias do Spring Boot.

Vamos começar comthe MongoDB properties:

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=springboot-mongo

Também definiremos as propriedades Servlet Multipart para permitir o upload de arquivos grandes:

spring.servlet.multipart.max-file-size=256MB
spring.servlet.multipart.max-request-size=256MB
spring.servlet.multipart.enabled=true

4. Carregando arquivos pequenos

Agora, discutiremos como fazer upload e recuperar arquivos pequenos (tamanho <16 MB) usando MongoDBBSON.

Aqui, temos uma classeDocument simples -Photo.We’ll store our image file in a BSON Binary:

@Document(collection = "photos")
public class Photo {
    @Id
    private String id;

    private String title;

    private Binary image;
}

E teremos umPhotoRepository simples:

public interface PhotoRepository extends MongoRepository { }

Agora, paraPhotoService, teremos apenas dois métodos:

addPhoto() - para fazer upload de umPhoto para MongoDB
getPhoto() - para recuperar umPhoto com um determinado id

@Service
public class PhotoService {

    @Autowired
    private PhotoRepository photoRepo;

    public String addPhoto(String title, MultipartFile file) throws IOException {
        Photo photo = new Photo(title);
        photo.setImage(
          new Binary(BsonBinarySubType.BINARY, file.getBytes()));
        photo = photoRepo.insert(photo); return photo.getId();
    }

    public Photo getPhoto(String id) {
        return photoRepo.findById(id).get();
    }
}

5. Carregando arquivos grandes

Agora, usaremosGridFS para fazer upload e recuperar arquivos grandes.

Primeiro, definiremos um DTO simples -Video - para representar um arquivo grande:

public class Video {
    private String title;
    private InputStream stream;
}

Semelhante aoPhotoService, teremos umVideoService com dois métodos -addVideo()egetVideo():

@Service
public class VideoService {

    @Autowired
    private GridFsTemplate gridFsTemplate;

    @Autowired
    private GridFsOperations operations;

    public String addVideo(String title, MultipartFile file) throws IOException {
        DBObject metaData = new BasicDBObject();
        metaData.put("type", "video");
        metaData.put("title", title);
        ObjectId id = gridFsTemplate.store(
          file.getInputStream(), file.getName(), file.getContentType(), metaData);
        return id.toString();
    }

    public Video getVideo(String id) throws IllegalStateException, IOException {
        GridFSFile file = gridFsTemplate.findOne(new Query(Criteria.where("_id").is(id)));
        Video video = new Video();
        video.setTitle(file.getMetadata().get("title").toString());
        video.setStream(operations.getResource(file).getInputStream());
        return video;
    }
}

Para obter mais detalhes sobre como usarGridFS com Spring, verifique nosso artigoGridFS in Spring Data MongoDB.

6. Controladores

Agora, vamos dar uma olhada nos controladores -PhotoControllereVideoController.

6.1. PhotoController

Primeiro,we have the PhotoController, which will use our PhotoService to add/get photos.

Vamos definir o métodoaddPhoto() para fazer upload e criar um novoPhoto:

@PostMapping("/photos/add")
public String addPhoto(@RequestParam("title") String title,
  @RequestParam("image") MultipartFile image, Model model)
  throws IOException {
    String id = photoService.addPhoto(title, image);
    return "redirect:/photos/" + id;
}

Também temosgetPhoto() para recuperar uma foto com um determinado id:

@GetMapping("/photos/{id}")
public String getPhoto(@PathVariable String id, Model model) {
    Photo photo = photoService.getPhoto(id);
    model.addAttribute("title", photo.getTitle());
    model.addAttribute("image",
      Base64.getEncoder().encodeToString(photo.getImage().getData()));
    return "photos";
}

Observe que, como temos os dados da imagem retornados comobyte[], vamos convertê-los emBase64String para exibi-los no front-end.

6.2 VideoController

A seguir, vamos dar uma olhada em nossoVideoController.

Isso terá um método semelhante,addVideo(), para fazer upload de umVideo para nosso MongoDB:

@PostMapping("/videos/add")
public String addVideo(@RequestParam("title") String title,
  @RequestParam("file") MultipartFile file, Model model) throws IOException {
    String id = videoService.addVideo(title, file);
    return "redirect:/videos/" + id;
}

E aqui temosgetVideo() para recuperar umVideo com um determinadoid:

@GetMapping("/videos/{id}")
public String getVideo(@PathVariable String id, Model model) throws Exception {
    Video video = videoService.getVideo(id);
    model.addAttribute("title", video.getTitle());
    model.addAttribute("url", "/videos/stream/" + id);
    return "videos";
}

Também podemos adicionar um métodostreamVideo() que criará um URL de streaming a partir deVideoInputStream:

@GetMapping("/videos/stream/{id}")
public void streamVideo(@PathVariable String id, HttpServletResponse response) throws Exception {
    Video video = videoService.getVideo(id);
    FileCopyUtils.copy(video.getStream(), response.getOutputStream());
}

7. A parte dianteira

Finalmente, vamos ver nosso front-end. Vamos começar comuploadPhoto.html, que fornece um formulário simples para fazer upload de uma imagem:



Upload new Photo

    Title:
    Image:

A seguir, adicionaremos a visualizaçãophotos.html para exibir nossas fotos:



    View Photo
    Title: name

Da mesma forma, temosuploadVideo.html para fazer upload de umVideo:



Upload new Video

    Title:
    Video:

Evideos.html para exibir vídeos:



    View Video
    Title: title

8. Conclusão

Neste artigo, aprendemos como fazer upload e recuperar arquivos usando o MongoDB e o Spring Boot. UsamosBSON eGridFS para fazer upload e recuperar arquivos.

Como sempre, o código-fonte completo está disponível emGitHub project.

TOC

Carregar e recuperar arquivos usando o MongoDB e o Spring Boot