Wie kann ich in Spring MVC den MIME-Header festlegen, wenn ich @ResponseBody verwende?

Ich habe einen Spring MVC Controller, der einen JSON-String zurückgibt, und ich möchte den Mimetyp auf application / json setzen. Wie kann ich das machen?

@RequestMapping(method=RequestMethod.GET, value="foo/bar")
@ResponseBody
public String fooBar(){
    return myService.getJson();
}

Die Geschäftsobjekte sind bereits als JSON-Zeichenfolgen verfügbar, daher MappingJacksonJsonViewist die Verwendung für mich nicht die Lösung. @ResponseBodyist perfekt, aber wie kann ich den Mimetyp einstellen?

Ich würde in Betracht ziehen, den Dienst so umzugestalten, dass Ihr Domänenobjekt anstelle von JSON-Zeichenfolgen zurückgegeben wird, und Spring die Serialisierung übernehmen zu lassen (über das, MappingJacksonHttpMessageConverterwährend Sie schreiben). Ab Frühjahr 3.1 sieht die Implementierung recht ordentlich aus:

@RequestMapping(produces = MediaType.APPLICATION_JSON_VALUE, 
    method = RequestMethod.GET
    value = "/foo/bar")
@ResponseBody
public Bar fooBar(){
    return myService.getBar();
}

Bemerkungen:

Zunächst wird der <mvc:annotation-driven />oder die @EnableWebMvcmuss hinzugefügt , um Ihre Anwendung Config.

Als Nächstes wird das Erzeugungsattribut der @RequestMappingAnmerkung verwendet, um den Inhaltstyp der Antwort anzugeben. Folglich sollte es auf MediaType.APPLICATION_JSON_VALUE (oder "application/json") gesetzt werden.

Zuletzt muss Jackson hinzugefügt werden, damit jede Serialisierung und De-Serialisierung zwischen Java und JSON automatisch von Spring verarbeitet wird (die Jackson-Abhängigkeit wird von Spring erkannt und MappingJacksonHttpMessageConverterbefindet sich unter der Haube).

Verwenden Sie ResponseEntityanstelle von ResponseBody. Auf diese Weise haben Sie Zugriff auf die Antwortheader und können den entsprechenden Inhaltstyp festlegen. Laut den Frühlingsdokumenten :

Das HttpEntityist ähnlich wie @RequestBodyund @ResponseBody. Neben dem Zugriff auf den Anforderungs- und Antworttext HttpEntity(und die antwortspezifische Unterklasse ResponseEntity) können Sie auch auf die Anforderungs- und Antwortheader zugreifen

Der Code sieht folgendermaßen aus:

@RequestMapping(method=RequestMethod.GET, value="/fooBar")
public ResponseEntity<String> fooBar2() {
    String json = "jsonResponse";
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.setContentType(MediaType.APPLICATION_JSON);
    return new ResponseEntity<String>(json, responseHeaders, HttpStatus.CREATED);
}

Möglicherweise können Sie dies nicht mit @ResponseBody tun, aber so etwas sollte funktionieren:

package xxx;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class FooBar {
  @RequestMapping(value="foo/bar", method = RequestMethod.GET)
  public void fooBar(HttpServletResponse response) throws IOException {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    out.write(myService.getJson().getBytes());
    response.setContentType("application/json");
    response.setContentLength(out.size());
    response.getOutputStream().write(out.toByteArray());
    response.getOutputStream().flush();
  }
}

Ich denke nicht, dass das möglich ist. Es scheint eine offene Jira dafür zu geben:

SPR-6702: Setzen Sie den Inhaltstyp der Antwort in @ResponseBody explizit

Registrieren Sie sich org.springframework.http.converter.json.MappingJacksonHttpMessageConverterals Nachrichtenkonverter und geben Sie das Objekt direkt von der Methode zurück.

<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
  <property name="webBindingInitializer">
    <bean class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer"/>
  </property>
  <property name="messageConverters">
    <list>
      <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"/>
    </list>
  </property>
</bean>

und der Controller:

@RequestMapping(method=RequestMethod.GET, value="foo/bar")
public @ResponseBody Object fooBar(){
    return myService.getActualObject();
}

Dies erfordert die Abhängigkeit org.springframework:spring-webmvc.

Ich glaube nicht, dass du es kannst, abgesehen davon response.setContentType(..)

Meine Version der Realität. Laden einer HTML-Datei und Streaming in den Browser.

@Controller
@RequestMapping("/")
public class UIController {

    @RequestMapping(value="index", method=RequestMethod.GET, produces = "text/html")
    public @ResponseBody String GetBootupFile() throws IOException  {
        Resource resource = new ClassPathResource("MainPage.html");
        String fileContents = FileUtils.readFileToString(resource.getFile());
        return fileContents;
    }
}