Lesen von HTTP-Headern in einer Spring-REST-controller

Ich versuche zu Lesen HTTP-Header im Frühjahr basierte REST-API. Ich folgte diese. Aber ich bin immer diese Fehlermeldung:

Kein message-body-reader gefunden wurden, hat man für die Klasse java.lang.String
ContentType: application/octet-stream

Ich bin neu in Java und Spring, so kann nicht dieses heraus.

Dies ist, wie mein Aufruf sieht wie folgt aus:

@WebService(serviceName = "common")
@Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public interface CommonApiService {

    @GET
    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    @Produces(MediaType.APPLICATION_JSON)
    @Path("/data")
    public ResponseEntity<Data> getData(@RequestHeader(value="User-Agent") String userAgent, @DefaultValue ("") @QueryParam("ID") String id);
}

Habe ich versucht @Context: HTTPHeader ist null in diesem Fall.

Wie, um Werte aus dem HTTP-Header?

InformationsquelleAutor der Frage Ashwani K | 2015-01-29

Den Fehler, dass Sie bekommen, scheint nicht im Zusammenhang mit der RequestHeader.

Und Sie scheinen verwirrend Spring REST-services mit JAX-RSIhre Methode, die Signatur sollte so etwas wie:

@RequestMapping(produces = "application/json", method = RequestMethod.GET, value = "data")
@ResponseBody
public ResponseEntity<Data> getData(@RequestHeader(value="User-Agent") String userAgent, @RequestParam(value = "ID", defaultValue = "") String id) {
    //your code goes here
}

Und ERHOLUNG Klasse haben sollte-Anmerkungen wie:

@Controller
@RequestMapping("/rest/")

Hinsichtlich der eigentlichen Frage, ein weiterer Weg, um HTTP-Header einfügen, die HttpServletRequest in der Methode, und dann bekommen Sie die gewünschte Kopfzeile von dort.

Beispiel:

@RequestMapping(produces = "application/json", method = RequestMethod.GET, value = "data")
@ResponseBody
public ResponseEntity<Data> getData(HttpServletRequest request, @RequestParam(value = "ID", defaultValue = "") String id) {
    String userAgent = request.getHeader("user-agent");
}

Mach dir keine sorgen über die Injektion des HttpServletRequestweil die Feder nicht, dass Magie für Sie 😉

InformationsquelleAutor der Antwort Mário Fernandes

Ich werde Ihnen ein Beispiel geben, wie ich gelesen REST-Header für meine Controller. Mein Controller nur akzeptieren, application/json, einen Antrag geben, wenn ich die Daten, die gelesen werden soll. Ich vermute, dass dein problem ist, dass Sie eine application/octet-stream, der Feder nicht umzugehen wissen.

Normal mein Controller so Aussehen:

@Controller
public class FooController {
    @Autowired
    private DataService dataService;

    @RequestMapping(value="/foo/", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<Data> getData(@RequestHeader String dataId){
        return ResponseEntity.newInstance(dataService.getData(dataId);
    }

Nun gibt es eine Menge code, der sowas macht hier im hintergrund so werde ich es brechen für Sie.

ResponseEntity ist ein benutzerdefiniertes Objekt, das jeden controller gibt. Es enthält eine statische Fabrik so dass die Schaffung neuer Instanzen. Meine Daten-Service ist ein standard, der service Klasse.

Die Magie geschieht hinter den kulissen, weil Sie die Arbeit mit JSON, müssen Sie sagen, Spring zu verwenden, Jackson Karte HttpRequest Objekte so, dass Sie weiß, was Sie zu tun haben.

Tun Sie das, indem Sie dieses in Ihrem <mvc:annotation-driven> block von deiner config

<mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper" ref="objectMapper" />
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

ObjectMapper ist einfach eine Erweiterung von com.fasterxml.jackson.databind.ObjectMapper ist und was Jackson nutzt, um tatsächlich Ihre Karte anfordern von JSON in ein Objekt.

Ich vermute, Sie bekommen Ihre Ausnahme, weil Sie noch nicht angegeben, ein mapper, der Lesen kann, ein Oktett-Stream in ein Objekt, oder etwas, dass der Frühling behandeln können. Wenn Sie versuchen, eine Datei hochladen, das ist etwas ganz anderes.

Also meine Anfrage, die gesendet wird, um mein controller sieht so etwas hat einfach eine extra header namens dataId.

Wenn Sie ändern wollte, um ein request-parameter und verwenden Sie @RequestParam String dataId zu Lesen, die ID aus der Anfrage Ihre Anfrage würde wie folgt Aussehen:

contactId : {"fooId"}

Diese request-parameter können so Komplex sein wie Sie möchten. Sie können die Serialisierung eines gesamten Objekts in JSON, senden Sie es als request-parameter und im Frühjahr wird es zu serialisieren (mit Jackson) wieder in ein Java-Objekt bereit für Sie zu nutzen.

Beispiel In Controller:

@RequestMapping(value = "/penguin Details/", method = RequestMethod.GET)
@ResponseBody
public DataProcessingResponseDTO<Pengin> getPenguinDetailsFromList(
        @RequestParam DataProcessingRequestDTO jsonPenguinRequestDTO)

Anfrage Gesendet:

jsonPengiunRequestDTO: {
    "draw": 1,
    "columns": [
        {
            "data": {
                "_": "toAddress",
                "header": "toAddress"
            },
            "name": "toAddress",
            "searchable": true,
            "orderable": true,
            "search": {
                "value": "",
                "regex": false
            }
        },
        {
            "data": {
                "_": "fromAddress",
                "header": "fromAddress"
            },
            "name": "fromAddress",
            "searchable": true,
            "orderable": true,
            "search": {
                "value": "",
                "regex": false
            }
        },
        {
            "data": {
                "_": "customerCampaignId",
                "header": "customerCampaignId"
            },
            "name": "customerCampaignId",
            "searchable": true,
            "orderable": true,
            "search": {
                "value": "",
                "regex": false
            }
        },
        {
            "data": {
                "_": "penguinId",
                "header": "penguinId"
            },
            "name": "penguinId",
            "searchable": false,
            "orderable": true,
            "search": {
                "value": "",
                "regex": false
            }
        },
        {
            "data": {
                "_": "validpenguin",
                "header": "validpenguin"
            },
            "name": "validpenguin",
            "searchable": true,
            "orderable": true,
            "search": {
                "value": "",
                "regex": false
            }
        },
        {
            "data": {
                "_": "",
                "header": ""
            },
            "name": "",
            "searchable": false,
            "orderable": false,
            "search": {
                "value": "",
                "regex": false
            }
        }
    ],
    "order": [
        {
            "column": 0,
            "dir": "asc"
        }
    ],
    "start": 0,
    "length": 10,
    "search": {
        "value": "",
        "regex": false
    },
    "objectId": "30"
}

welche bekommt automatisch serialisiert wieder in ein DataProcessingRequestDTO Objekt, bevor der controller bereit für mich zu nutzen.

Wie Sie sehen können, dies ist sehr mächtig, sodass Sie Daten serialisiert von JSON auf ein Objekt, ohne zu schreiben eine einzige Zeile code. Sie können dies tun, für @RequestParam und @RequestBody die ermöglicht Ihnen den Zugriff auf JSON-innen Ihre Parameter oder der request-body bzw.

Jetzt haben Sie ein konkretes Beispiel, um zu gehen, Sie sollten keine Probleme haben, sobald Sie ändern Ihre Anfrage geben zu application/json.

InformationsquelleAutor der Antwort JamesENL

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.