apiの戻り値がMULTIPART_FORM_DATE_VALUEに指定したHttpEntityの受け取り方

Question

やりたいこと

マルチパートファイル型の戻り値のを返すAPIを呼んで、返ってきたマルチパートファイル型のファイルをローカルに保存する。

わからないこと

APIのレスポンスボディとしてバインドするクラスに何を指定すればいいかわからない

実装

呼び出し側

public void callApi() {
    RestTemplate rest = new RestTemplate();
    RequestEntity req = new RequestEntity(HttpMethod.put, new URI("xxx"))

    // 問題箇所。　バインドするクラスをHttpEntityじゃなくStringにすると、APIは起動しString型で結果も取れる。
    ResponseEntity<HttpEntity> res = rest.exchange(req, HttpEntity.class );

    //取得したファイルの保存処理

}

エラー

org.springframework.web.HttpMediaTypeNotAcceptableExcption: Could not find acceptable representation
HttpclientErrorException
status 406

やったこと

バインドするクラスを自作のクラスにする。
中にはHttpEntityのフィールドのみ（getterとsetterも）

環境・言語

Java
spring boot
eclipse

追記

API単独で叩けば成功しますので、API側の問題ではないと思っています。
バインドするクラスをStringにすると呼び出しメソッドから呼び出しても成功するため、バインドするクラスの指定が間違っているのだと思っていますが、いかがでしょうか？

マルチパート型のリクエストの方法はネットにたくさん落ちていますが、
返却されたマルチパート型を使用する方法について、なかなか見つけられなかったので、質問させて頂きました。ご教授いただけると幸いです。よろしくお願いいたします。

Comments

[dodox86]

エラーメッセージを見るとHTTPステータス406でNot Acceptable相当ですが、そもそもAPIのHTTPリクエストがサーバーに受け付けられていないのでは？従ってHTTPレスポンス中にマルチパートのファイル内容も含まれていない可能性がありますが、その辺りは大丈夫でしょうか。
Spring Bootは分からないので上記、コメントのみです。

[kou-kiri]

バインドするクラスが間違っているため、サーバーに受付けられていないと考えております。
API単独で叩いて、成功しているため、メソッド内で呼び出す方法が間違っているのかなと・・・

Answer 1

私は Spring Boot に詳しいわけではないため、色々試してみた上での結果となりますので、信憑性もその程度とお考え下さい。

ステータスコードが 406 となるのは、リクエストヘッダの Accept 値の不整合によるものの様です。RequestEntity に、ヘッダを指定できるコンストラクタがあるので、これで設定すると良いです。"Accept" をキー、MediaType.MULTIPART_FORM_DATA_VALUE を値とします。

これで 200 が返ってくるようにはなりますが、残念ながら、ローカルでのオブジェクトへのバインドには失敗します。

バインドは、RestTemplate の getMessageConverters() で取得できる、HttpMessageConverter<T> が行います。このリストのうち、バインドクラスと MediaType の双方の一致するものが基本的には選択されて、バインド処理を行う仕組みのようです。

デフォルトで登録されているもののうち、multipart/form-data を扱えるものは、
AllEncompassingFormHttpMessageConverter だけの様ですが、わざわざスーパークラスのドキュメントにも書いてある通り、なぜか multipart 系の読み取り（バインド）だけはできません。逆はできるのに。

ですので、適当な Converter を見繕い、getMessageConverters().add() する必要があります。既存のものに使えるものがあるのかどうかは分かりませんでしたが、ちなみに、自作するのであれば、まあまあ大変です。

ところで、どうしても multipart/form-data に拘らなければならないのでしょうか。デフォルトの application/json でやり取りすれば、かなり実装は楽そうなのですが・・・

折角なので、記念品（？）を残しておいてみます。

//ApiTestController.java

package com.example.demo.controllers;

import java.util.LinkedHashMap;
import java.util.Map;

import org.springframework.http.HttpEntity;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;


@Controller
public class ApiTestController {

	private static final String[] contents = {
		"あああああ", "いいいいい", "ううううう"
	};

	/**
	 * multipart/form-data な API
	 */
	@RequestMapping(path = "/api1", method = RequestMethod.GET, produces = MediaType.MULTIPART_FORM_DATA_VALUE)
	public HttpEntity<MultiValueMap<String, byte[]>> api1() {

		MultiValueMap<String, byte[]> valueMap = new LinkedMultiValueMap<>();

		byte[][] files = new byte[contents.length][];
		for (int i = 0; i < contents.length; i ++) {
			files[i] = contents[i].getBytes();
		}

		// valueMapに値を詰め込む。
		for (int i = 0; i < contents.length; i ++) {
			valueMap.add("file" + i + ".txt", files[i]);
		}

		return new HttpEntity<>(valueMap);
	}

	/**
	 * application/json な API
	 */
	@RequestMapping(path = "/api2", method = RequestMethod.GET)
	public HttpEntity<Map<String, String>> api2() {

		Map<String, String> valueMap = new LinkedHashMap<>();

		// valueMapに値を詰め込む。
		for (int i = 0; i < contents.length; i ++) {
			valueMap.put("file" + i + ".txt", contents[i]);
		}

		return new HttpEntity<>(valueMap);
	}
}

//Main.java

package com.example.demo;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.function.Consumer;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;


public class Main {

	@FunctionalInterface
	private static interface Handler<T> extends Consumer<ResponseEntity<T>> {
	}

	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws Exception {

		final String url = "http://localhost:8080";

		// multipart/form-data な API をコールする

		RestTemplate rest1 = new RestTemplate();
		rest1.getMessageConverters().add(new MultipartMessageConverter());
		String   api1    = url + "/api1";
		String   accept1 = MediaType.MULTIPART_FORM_DATA_VALUE;
		Class<?> class1  = Map.class;

		System.out.println("## multipart/form-data ##");
//		callApi(new URL(api1), accept1);
		callApi(new URI(api1), accept1, rest1, (Class<Map<String, String>>)class1, Main::handler1);
		System.out.println();

		// application/json な API をコールする

		RestTemplate rest2 = new RestTemplate();
		String   api2    = url + "/api2";
		String   accept2 = MediaType.APPLICATION_JSON_VALUE;
		Class<?> class2  = Map.class;

		System.out.println("## application/json ##");
//		callApi(new URL(api2), accept2);
		callApi(new URI(api2), accept2, rest2, (Class<Map<String, String>>)class2, Main::handler2);
		System.out.println();
	}

	/**
	 * HttpURLConnection を使って API をコールする。
	 */
	public static void callApi(URL url, String accept) throws IOException {

		HttpURLConnection conn = (HttpURLConnection)url.openConnection();
		conn.setRequestMethod("GET");
		conn.addRequestProperty("Accept", accept);

		System.out.println("## Content-Type ##");
		System.out.println(conn.getHeaderField("Content-Type"));

		System.out.println("## Messge Body ##");
		conn.getInputStream().transferTo(System.out);
	}

	/**
	 * RestTemplate を使って API をコールする。
	 */
	public static <T> void callApi(URI uri, String accept, RestTemplate rest, Class<T> clazz, Handler<T> handler) {

		MultiValueMap<String, String>headers = new LinkedMultiValueMap<>();
		headers.add("Accept", accept);
		RequestEntity<?> req = new RequestEntity<>(headers, HttpMethod.GET, uri);

		ResponseEntity<T> res = rest.exchange(req, clazz);
		handler.accept(res);
	}

	private static void handler1(ResponseEntity<Map<String, String>> res) {

		System.out.println("## Content-Type ##");
		System.out.println(res.getHeaders().getContentType());

		Map<String, String> valueMap = res.getBody();

		for (Map.Entry<String, String> entry : valueMap.entrySet()) {
			System.out.println("## " + entry.getKey() + " ##");
			System.out.println(entry.getValue());
		}
	}

	private static void handler2(ResponseEntity<Map<String, String>> res) {

		System.out.println("## Content-Type ##");
		System.out.println(res.getHeaders().getContentType());

		Map<String, String> valueMap = res.getBody();

		for (Map.Entry<String, String> entry : valueMap.entrySet()) {
			System.out.println("## " + entry.getKey() + " ##");
			System.out.println(entry.getValue());
		}
	}
}


class MultipartMessageConverter implements HttpMessageConverter<Map<String, String>> {

	private static final List<MediaType> supportedMediaTypes = Arrays.asList(
		MediaType.MULTIPART_FORM_DATA
	);

	@Override
	public List<MediaType> getSupportedMediaTypes() {
		return supportedMediaTypes;
	}

	@Override
	public boolean canRead(Class<?> clazz, MediaType mediaType) {

		if (!clazz.isAssignableFrom(LinkedHashMap.class)) {
			return false;
		}

		if (mediaType == null) {
			return false;
		}

		return supportedMediaTypes.get(0).includes(mediaType);
	}

	@Override
	public Map<String, String> read(Class<? extends Map<String, String>> clazz,
			HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {

		MediaType contentType = inputMessage.getHeaders().getContentType();

		if (!canRead(clazz, contentType)) {
			throw new HttpMessageNotReadableException("cannot read.", inputMessage);
		}

		Charset charset = contentType.getCharset();
		if (charset == null) {
			charset = Charset.defaultCharset();
		}

		String boundary = contentType.getParameter("boundary");

		Map<String, String> valueMap = new LinkedHashMap<>();
		try (Scanner sc = new Scanner(inputMessage.getBody(), charset)) {

			sc.useDelimiter("--" + boundary + "(--)?\\r\\n");

			while (sc.hasNext()) {
				readPart(sc.next(), valueMap);
			}
		}

		return valueMap;
	}

	private void readPart(String part, Map<String, String> valueMap) throws IOException {

		try (Scanner sc = new Scanner(part)) {

			HttpHeaders headers = new HttpHeaders();
			while (sc.hasNextLine()) {
				String line = sc.nextLine();
				if (line.isEmpty()) {
					break;
				}
				String[] pair = line.split(": ");
				headers.add(pair[0], pair[1]);
			}

			String name = headers.getContentDisposition().getName();

			StringWriter body = new StringWriter();
			PrintWriter  w    = new PrintWriter(body);
			while (sc.hasNextLine()) {
				w.print(sc.nextLine());
				if (sc.hasNextLine()) {
					w.println();
				}
			}
			w.flush();

			valueMap.put(name, body.toString());
		}
	}

	@Override
	public boolean canWrite(Class<?> clazz, MediaType mediaType) {
		return false;
	}

	@Override
	public void write(Map<String, String> t, MediaType contentType, HttpOutputMessage outputMessage)
			throws HttpMessageNotWritableException {
		throw new HttpMessageNotWritableException("not implemented.");
	}
}