Comment télécharger encodé en base64 image vers le serveur à l'aide de printemps

Le code ci-dessous est utilisé pour décoder la chaîne qui est codé à l'aide de la base de 64 et utilisé pour charger l'image dans le serveur.

Cela fonctionne très bien pour moi..

@RequestMapping(value="/uploadImage2",method = RequestMethod.POST)
    public @ResponseBody String uploadImage2(@RequestParam("imageValue") String imageValue,HttpServletRequest request)
    {
        try
        {
            //This will decode the String which is encoded by using Base64 class
            byte[] imageByte=Base64.decodeBase64(imageValue);

            String directory=servletContext.getRealPath("/")+"images/sample.jpg";

            new FileOutputStream(directory).write(imageByte);
            return "success ";
        }
        catch(Exception e)
        {
            return "error = "+e;
        }

    }

OriginalL'auteur srihari

Si vous êtes à l'aide de Printemps, vous pourriez envisager d'utiliser un HttpMessageConverter pour convertir votre image à un BufferedImage avant qu'il n'atteigne vos contrôleurs. Je ne pouvais pas trouver un déjà fait un au printemps convertisseurs (peut-être que j'ai raté ça?). En tout cas c'est quelque chose que je viens d'écrire maintenant. Vous pouvez être en mesure de l'améliorer.

 package com.stuff;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.IOUtils;
import org.apache.log4j.Logger;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
/**
* @author John Deverall
*/
public class Base64EncodedImageHttpMessageConverter extends
AbstractHttpMessageConverter<BufferedImage> {
private Logger logger = Logger.getLogger(this.getClass());
public Base64EncodedImageHttpMessageConverter() {
List<MediaType> mediaTypes = new ArrayList<MediaType>();
String[] supportedMediaTypes = ImageIO.getReaderMIMETypes();
for (String supportedMediaType : supportedMediaTypes) {
String[] typeAndSubtype = supportedMediaType.split("/");
mediaTypes.add(new MediaType(typeAndSubtype[0], typeAndSubtype[1]));
}
setSupportedMediaTypes(mediaTypes);   
}
@Override
protected boolean supports(Class<?> clazz) {
return clazz.equals(BufferedImage.class);
}
/** This uses a data uri. If that's not you, 
* you'll need to modify this method to decode the base64 data
* straight. */
@Override
protected BufferedImage readInternal(Class<? extends BufferedImage> clazz,
HttpInputMessage inputMessage) throws IOException,
HttpMessageNotReadableException {
StringWriter writer = new StringWriter();
IOUtils.copy(inputMessage.getBody(), writer, "UTF-8");
String imageInBase64 = writer.toString();
int startOfBase64Data = imageInBase64.indexOf(",") + 1;
imageInBase64 = imageInBase64.substring(startOfBase64Data,
imageInBase64.length());
if (Base64.isBase64(imageInBase64) == false) {
logger.error("************************************************");
logger.error("*** IMAGE IN REQUEST IS NOT IN BASE64 FORMAT ***");
logger.error("************************************************");
}
byte[] decodeBase64 = Base64.decodeBase64(imageInBase64);
BufferedImage image = ImageIO.read(new ByteArrayInputStream(
decodeBase64));
return image;
}     
@Override
protected void writeInternal(BufferedImage t,
HttpOutputMessage outputMessage) throws IOException,
HttpMessageNotWritableException {
ImageIO.write(t, "jpeg", outputMessage.getBody());
outputMessage.getBody().flush();
}
}

Puis dans votre contrôleur, écrire quelque chose comme ceci (ou, de préférence, passer le BufferedImage à une sorte de service). Notez que la logique de conversion de base64 pour les BufferedImage est réutilisable et caché dans le HttpMessageConverter.

@RequestMapping(value = "/image", method = RequestMethod.POST)
public @ResponseBody void saveImage(@PathVariable String memberId, @RequestBody BufferedImage image)  {     
someService.setBufferedImage(image);
}
@RequestMapping(produces = MediaType.IMAGE_JPEG_VALUE, value = "/image", method = RequestMethod.GET)
public @ResponseBody BufferedImage getImage() { 
BufferedImage image = someService.getBufferedImage();
return image;
}

Si vous utilisez du printemps java configuration, configuration de HttpMessageConverters ressemble à quelque chose comme ceci

    @Configuration
@EnableWebMvc
public class ApplicationConfig extends WebMvcConfigurerAdapter {
@Override
public void configureMessageConverters(
List<HttpMessageConverter<?>> converters) {
converters.add(getJsonConverter());
converters.add(getImageConverter());
super.configureMessageConverters(converters);
}
@Bean
GsonHttpMessageConverter getJsonConverter() { 
GsonHttpMessageConverter converter = new GsonHttpMessageConverter();
return converter;
}
@Bean
Base64EncodedImageHttpMessageConverter getImageConverter() { 
Base64EncodedImageHttpMessageConverter converter = new Base64EncodedImageHttpMessageConverter();
return converter;
}
}

Si vous le souhaitez, vous pouvez éviter d'utiliser apache commons si vous n'en avez pas besoin et juste aller avec le nouveau java8 java.util.base64 classe. Le GsonHttpMessageConverter (pour la conversion de Json à mon domaine d'objets) n'est pas utilisé pour les images, de sorte que vous pouvez tirer que hors de la config si des images est tout ce que vous faites.

OriginalL'auteur John Deverall