java - receive - Carga de archivos multiparte Spring Boot
upload file spring mvc (6)
En Controller, tu método debe ser;
@RequestMapping(value = "/upload", method = RequestMethod.POST)
public ResponseEntity<SaveResponse> uploadAttachment(@RequestParam("file") MultipartFile file, HttpServletRequest request) {
....
Además, debe actualizar application.yml (o application.properties) para admitir el tamaño máximo de archivo y el tamaño de solicitud.
spring:
http:
multipart:
max-file-size: 5MB
max-request-size: 20MB
Estoy usando Spring Boot y quiero usar un Controlador para recibir una carga de archivos de varias partes. Al enviar el archivo, sigo recibiendo el error 415 respuesta de tipo de contenido no compatible y nunca se llegó al controlador
There was an unexpected error (type=Unsupported Media Type, status=415).
Content type ''multipart/form-data;boundary=----WebKitFormBoundary1KvzQ1rt2V1BBbb8'' not supported
He intentado enviar mediante form: action en la página html / jsp y también en una aplicación cliente independiente que usa RestTemplate. Todos los intentos dan el mismo resultado.
multipart/form-data;boundary=XXXXX not supported.
De la documentación de varias partes parece que el parámetro de límite se debe agregar a la carga de múltiples partes, sin embargo, esto parece no coincidir con el controlador que recibe "multipart/form-data"
Mi método de controlador se configura de la siguiente manera
@RequestMapping(value = "/things", method = RequestMethod.POST, consumes = "multipart/form-data" ,
produces = { "application/json", "application/xml" })
public ResponseEntity<ThingRepresentation> submitThing(HttpServletRequest request,
@PathVariable("domain") String domainParam,
@RequestParam(value = "type") String thingTypeParam,
@RequestBody MultipartFile[] submissions) throws Exception
Con Bean Setup
@Bean
public MultipartConfigElement multipartConfigElement() {
return new MultipartConfigElement("");
}
@Bean
public MultipartResolver multipartResolver() {
org.springframework.web.multipart.commons.CommonsMultipartResolver multipartResolver = new org.springframework.web.multipart.commons.CommonsMultipartResolver();
multipartResolver.setMaxUploadSize(1000000);
return multipartResolver;
}
Como puede ver, he establecido el tipo de consumo en "multipart / form-data" pero cuando se envía el multipart, debe tener un parámetro de límite y colocar una cadena de límite aleatoria.
¿Puede alguien decirme cómo puedo configurar el tipo de contenido en el controlador para que coincida o cambiar mi solicitud para que coincida con la configuración de mi controlador?
Mis intentos de enviar ... Intento 1 ...
<html lang="en">
<body>
<br>
<h2>Upload New File to this Bucket</h2>
<form action="http://localhost:8280/appname/domains/abc/things?type=abcdef00-1111-4b38-8026-315b13dc8706" method="post" enctype="multipart/form-data">
<table width="60%" border="1" cellspacing="0">
<tr>
<td width="35%"><strong>File to upload</strong></td>
<td width="65%"><input type="file" name="file" /></td>
</tr>
<tr>
<td> </td>
<td><input type="submit" name="submit" value="Add" /></td>
</tr>
</table>
</form>
</body>
</html>
Intento 2 ....
RestTemplate template = new RestTemplate();
MultiValueMap<String, Object> parts = new LinkedMultiValueMap<String, Object>();
parts.add("file", new FileSystemResource(pathToFile));
try{
URI response = template.postForLocation(url, parts);
}catch(HttpClientErrorException e){
System.out.println(e.getResponseBodyAsString());
}
Intento 3 ...
FormHttpMessageConverter formHttpMessageConverter = new FormHttpMessageConverter();
formHttpMessageConverter.setCharset(Charset.forName("UTF8"));
RestTemplate restTemplate = new RestTemplate();
restTemplate.getMessageConverters().add( formHttpMessageConverter );
restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory());
MultiValueMap<String, Object> map = new LinkedMultiValueMap<String, Object>();
map.add("file", new FileSystemResource(path));
HttpHeaders imageHeaders = new HttpHeaders();
imageHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
HttpEntity<MultiValueMap<String, Object>> imageEntity = new HttpEntity<MultiValueMap<String, Object>>(map, imageHeaders);
ResponseEntity e= restTemplate.exchange(uri, HttpMethod.POST, imageEntity, Boolean.class);
System.out.println(e.toString());
La última versión de SpringBoot hace que cargar múltiples archivos también sea muy fácil. En el navegador, solo necesita el formulario de carga HTML estándar, pero con varios elementos de entrada (uno por archivo para cargar, lo que es muy importante), todos con el mismo nombre de elemento (nombre = "archivos" para el ejemplo a continuación)
Luego, en su clase Spring @Controller en el servidor, todo lo que necesita es algo como esto:
@RequestMapping(value = "/upload", method = RequestMethod.POST)
public @ResponseBody ResponseEntity<?> upload(
@RequestParam("files") MultipartFile[] uploadFiles) throws Exception
{
...now loop over all uploadFiles in the array and do what you want
return new ResponseEntity<>(HttpStatus.OK);
}
Esas son las partes difíciles. Es decir, saber crear múltiples elementos de entrada, cada uno llamado "archivos", y saber usar un MultipartFile [] (array) como parámetro de solicitud son cosas difíciles de saber, pero es así de simple. No voy a entrar en cómo procesar una entrada de MultipartFile, porque ya hay muchos documentos sobre eso.
Simplemente puedes usar un método de control como este:
@RequestMapping(value = "/uploadFile", method = RequestMethod.POST)
@ResponseBody
public ResponseEntity<?> uploadFile(
@RequestParam("file") MultipartFile file) {
try {
// Handle the received file here
// ...
}
catch (Exception e) {
return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
}
return new ResponseEntity<>(HttpStatus.OK);
} // method uploadFile
Sin ninguna configuración adicional para Spring Boot.
Usando el siguiente lado del cliente en formato html :
<html>
<body>
<form action="/uploadFile" method="POST" enctype="multipart/form-data">
<input type="file" name="file">
<input type="submit" value="Upload">
</form>
</body>
</html>
Si desea establecer límites en el tamaño de los archivos , puede hacerlo en application.properties :
# File size limit
multipart.maxFileSize = 3Mb
# Total request size for a multipart/form-data
multipart.maxRequestSize = 20Mb
Además, para enviar el archivo con Ajax, eche un vistazo aquí: http://blog.netgloo.com/2015/02/08/spring-boot-file-upload-with-ajax/
@RequestBody MultipartFile[] submissions
debiera ser
@RequestParam("file") MultipartFile[] submissions
Los archivos no son el cuerpo de la solicitud, son parte de él y no hay un HttpMessageConverter que pueda convertir la solicitud en una matriz de MultiPartFile .
También puede reemplazar HttpServletRequest con MultipartHttpServletRequest , que le da acceso a los encabezados de las partes individuales.
@RequestMapping(value="/add/image", method=RequestMethod.POST)
public ResponseEntity upload(@RequestParam("id") Long id, HttpServletResponse response, HttpServletRequest request)
{
try {
MultipartHttpServletRequest multipartRequest=(MultipartHttpServletRequest)request;
Iterator<String> it=multipartRequest.getFileNames();
MultipartFile multipart=multipartRequest.getFile(it.next());
String fileName=id+".png";
String imageName = fileName;
byte[] bytes=multipart.getBytes();
BufferedOutputStream stream= new BufferedOutputStream(new FileOutputStream("src/main/resources/static/image/book/"+fileName));;
stream.write(bytes);
stream.close();
return new ResponseEntity("upload success", HttpStatus.OK);
} catch (Exception e) {
e.printStackTrace();
return new ResponseEntity("Upload fialed", HttpStatus.BAD_REQUEST);
}
}
@Bean
MultipartConfigElement multipartConfigElement() {
MultipartConfigFactory factory = new MultipartConfigFactory();
factory.setMaxFileSize("5120MB");
factory.setMaxRequestSize("5120MB");
return factory.createMultipartConfig();
}
ponlo en clase donde estás definiendo frijoles