upload file springboot Requiert la partie 'fichier' de la demande

Question

Je souhaite ajouter une fonction de téléchargement à mon application de démarrage de printemps; ceci est mon téléchargement Rest Controller

package org.sid.web; 

import java.io.BufferedOutputStream; 
import java.io.File; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.nio.file.Files; 
import java.nio.file.Path; 
import java.nio.file.Paths; 
import java.util.ArrayList; 
import java.util.List; 

import javax.servlet.ServletContext; 

import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.http.HttpEntity; 
import org.springframework.http.HttpHeaders; 
import org.springframework.http.HttpStatus; 
import org.springframework.http.MediaType; 
import org.springframework.http.ResponseEntity; 
import org.springframework.stereotype.Controller; 
import org.springframework.util.LinkedMultiValueMap; 
import org.springframework.web.bind.annotation.GetMapping; 
import org.springframework.web.bind.annotation.PostMapping; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RequestMethod; 
import org.springframework.web.bind.annotation.RequestParam; 
import org.springframework.web.bind.annotation.ResponseBody; 
import org.springframework.web.bind.annotation.RestController; 
import org.springframework.web.client.RestTemplate; 
import org.springframework.web.multipart.MultipartFile; 
import org.springframework.web.servlet.mvc.support.RedirectAttributes; 
import org.springframework.core.env.Environment; 
import org.springframework.core.io.ClassPathResource; 
import org.springframework.core.io.FileSystemResource; 
import org.sid.entities.FileInfo; 

@RestController 
public class UploadController { 
    @Autowired 
    ServletContext context; 

    @RequestMapping(value = "/fileupload/file", headers = ("content-type=multipart/*"), method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE) 
    public ResponseEntity<FileInfo> upload(@RequestParam("file") MultipartFile inputFile) { 
    FileInfo fileInfo = new FileInfo(); 
    HttpHeaders headers = new HttpHeaders(); 
    if (!inputFile.isEmpty()) { 
     try { 
     String originalFilename = inputFile.getOriginalFilename(); 
     File destinationFile = new File(
      context.getRealPath("C:/Users/kamel/workspace/credit_app/uploaded") + File.separator + originalFilename); 
     inputFile.transferTo(destinationFile); 
     fileInfo.setFileName(destinationFile.getPath()); 
     fileInfo.setFileSize(inputFile.getSize()); 
     headers.add("File Uploaded Successfully - ", originalFilename); 
     return new ResponseEntity<FileInfo>(fileInfo, headers, HttpStatus.OK); 
     } catch (Exception e) { 
     return new ResponseEntity<FileInfo>(HttpStatus.BAD_REQUEST); 
     } 
    } else { 
     return new ResponseEntity<FileInfo>(HttpStatus.BAD_REQUEST); 
    } 
    } 
} 

mais lors du test de ce en insérant avec postier http://localhost:8082/fileupload/file et en ajoutant un fichier au corps i obtenu cette erreur: « exception »: « org.springframework.web.multipart.support .MissingServletRequestPartException », « message »: « une partie de la demande requise « fichier » est pas présent »,

Answer 1

Voici comment votre demande en Postman devrait ressembler à:

Mon exemple de code:

application.properties

#max file and request size 
spring.http.multipart.max-file-size=10MB 
spring.http.multipart.max-request-size=11MB 

Principale application:

Application.java

import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 

@SpringBootApplication 
public class Application { 

    public static void main(String[] args) { 
     SpringApplication.run(Application.class, args); 
    } 
} 

classe contrôleur de repos:

import org.springframework.http.MediaType; 
import org.springframework.stereotype.Controller; 
import org.springframework.ui.Model; 
import org.springframework.web.bind.annotation.RequestBody; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RequestMethod; 
import org.springframework.web.bind.annotation.RequestParam; 
import org.springframework.web.bind.annotation.ResponseBody; 
import org.springframework.web.multipart.MultipartFile; 


    @Controller 
    @RequestMapping("/fileupload") 
    public class MyRestController { 

    @RequestMapping(value = "/file", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE) 
     public @ResponseBody String myService(@RequestParam("file") MultipartFile file, 
       @RequestParam("id") String id) throws Exception { 

    if (!file.isEmpty()) { 

      //your logic 
         } 
return "some json"; 

       } 
    } 

pom.xml

//... 

<parent> 
     <groupId>org.springframework.boot</groupId> 
     <artifactId>spring-boot-starter-parent</artifactId> 
     <version>1.5.2.RELEASE</version> 
     <relativePath /> <!-- lookup parent from repository --> 
    </parent> 

.... 



<dependency> 
      <groupId>org.springframework.boot</groupId> 
      <artifactId>spring-boot-starter-web-services</artifactId> 
</dependency> 

//... 

Answer 2

Dans votre méthode, vous avez spécifié comme celui-ci
@RequestParam("file"). Par conséquent, il s'attend à ce que la clé soit file. C'est assez évident dans le message d'exception. Utilisez ce nom dans le champ Key dans Postman lorsque vous téléchargez un fichier.
Plus d'informations ici integration test case and file upload

Answer 3

Sauf pour les autres réponses posté, le problème pourrait être realated à manquer de soutien multipart pour le traitement de la demande servlet (DispatcherServlet en cas de printemps de l'application de printemps).

Cela peut être corrigé en ajoutant le support en plusieurs parties de servlet répartiteur dans la déclaration web.xml ou lors de l'initialisation (en cas de configuration sur la base annotation-)

a) configuration xml web-based

<web-app xmlns="http://java.sun.com/xml/ns/javaee" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
      xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
      http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" 
      version="3.0"> 

<servlet> 
    <servlet-name>dispatcher</servlet-name> 
    <servlet-class> 
    org.springframework.web.servlet.DispatcherServlet 
    </servlet-class> 
    <init-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value>/WEB-INF/spring/dispatcher-config.xml</param-value> 
    </init-param> 
    <load-on-startup>1</load-on-startup> 
    <multipart-config> 
     <max-file-size>10485760</max-file-size> 
     <max-request-size>20971520</max-request-size> 
     <file-size-threshold>5242880</file-size-threshold> 
    </multipart-config> 
</servlet> 

</web-app> 

b) ce serait suit pour la configuration à base d'annotations:

public class AppInitializer implements WebApplicationInitializer { 

@Override 
public void onStartup(ServletContext servletContext) { 
    final AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext(); 

    final ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcher", new DispatcherServlet(appContext)); dispatcher.setLoadOnStartup(1); 

    registration.addMapping("/"); 

    File uploadDirectory = new File(System.getProperty("java.io.tmpdir"));     
    MultipartConfigElement multipartConfigElement = new MultipartConfigElement(uploadDirectory.getAbsolutePath(), 100000, 100000 * 2, 100000/2); 

    registration.setMultipartConfig(multipartConfigElement); 
} } 

Ensuite, nous devons fournir résolveur multipart qui peut résoudre les fichiers envoyés en Multipar t-demande.Pour config d'annotation, cela peut être effectué de manière suivante:

@Configuration 
public class MyConfig { 

@Bean 
public MultipartResolver multipartResolver() { 
    return new StandardServletMultipartResolver(); 
} 
} 

Pour la configuration de source basé sur XML, vous devez ajouter ce haricot au contexte par déclaration de déclaration de tag:

<bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver" /> 

Alternativement multipart standard de printemps résolveur vous pouvez utiliser l'implémentation depuis les communs. De cette façon, mais la dépendance supplémentaire est nécessaire:

<dependency> 
    <groupId>commons-fileupload</groupId> 
    <artifactId>commons-fileupload</artifactId> 
    <version>1.3.3</version> 
</dependency> 

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> 
<property name="maxUploadSize" value="100000000"/> 
</bean>