Primavera RequestMapping per i controller che producono e consumano JSON

Question

con più controller di primavera che consumano e producono application/json, il mio codice è disseminato di annotazioni lunghi come:

C'è un modo per produrre un "composito/ereditata/annotazioni aggregate" con predefinite valori per consumes e produces, in modo tale che ho potuto invece scrivere qualcosa di simile:

@JSONRequestMapping(value = "/foo", method = RequestMethod.POST) 

Come facciamo a DEFI ne qualcosa come @JSONRequestMapping sopra? Notare che lo value e lo method sono passati come nel @RequestMapping, anche se è possibile passare in consumes o produces se il valore predefinito non è adatto.

Ho bisogno di controllare quello che sto tornando. Desidero i metodi di annotazione in modo da ottenere le intestazioni appropriate di Content-Type.

Answer 1

A partire dalla primavera 4.2.x, è possibile creare annotazioni di mappatura personalizzate utilizzando @RequestMapping come meta-annotazione. Quindi:

C'è un modo per produrre un "composito ereditata/aggregato /" annotazione con i valori di default per consuma e produce, in modo tale che io potrebbe invece scrivere qualcosa di simile:

@JSONRequestMapping(value = "/foo", method = RequestMethod.POST) 

Sì, c'è un modo. È possibile creare un meta annotazione come segue:

@Target({ElementType.METHOD, ElementType.TYPE}) 
@Retention(RetentionPolicy.RUNTIME) 
@RequestMapping(consumes = "application/json", produces = "application/json") 
public @interface JsonRequestMapping { 
    @AliasFor(annotation = RequestMapping.class, attribute = "value") 
    String[] value() default {}; 

    @AliasFor(annotation = RequestMapping.class, attribute = "method") 
    RequestMethod[] method() default {}; 

    @AliasFor(annotation = RequestMapping.class, attribute = "params") 
    String[] params() default {}; 

    @AliasFor(annotation = RequestMapping.class, attribute = "headers") 
    String[] headers() default {}; 

    @AliasFor(annotation = RequestMapping.class, attribute = "consumes") 
    String[] consumes() default {}; 

    @AliasFor(annotation = RequestMapping.class, attribute = "produces") 
    String[] produces() default {}; 
} 

Quindi è possibile utilizzare le impostazioni predefinite o addirittura ignorare loro come si desidera:

@JsonRequestMapping(method = POST) 
public String defaultSettings() { 
    return "Default settings"; 
} 

@JsonRequestMapping(value = "/override", method = PUT, produces = "text/plain") 
public String overrideSome(@RequestBody String json) { 
    return json; 
} 

Si può leggere di più su AliasFor in di javadoc e github wiki primavera.

Answer 2

Ci sono 2 le annotazioni in primavera: @RequestBody e @ResponseBody. Queste annotazioni consumano, rispettivamente producono JSON. Altre informazioni here.

Answer 3

È possibile utilizzare l'annotazione @RestController anziché @Controller.

Answer 4

La semplice risposta alla tua domanda è che non c'è Annotation-Inheritance in Java. Tuttavia, c'è un modo per usare le annotazioni Spring in un modo che penso possa aiutarti a risolvere il tuo problema.

@RequestMapping è supportato sia a livello di tipo che a livello di metodo.

Quando si inserisce @RequestMapping a livello di tipo, la maggior parte degli attributi è "ereditata" per ogni metodo in quella classe. Questo è mentioned nella documentazione di riferimento Spring. Guarda lo api docs per i dettagli su come ogni attributo viene gestito quando aggiungi @RequestMapping a un tipo. Ho riassunto questo per ogni attributo di seguito:

• name: Valore a livello Type è concatenato con il valore a livello di metodo che utilizza '#' come separatore.
• value: il valore a livello di tipo viene ereditato dal metodo.
• path: il valore a livello di tipo viene ereditato dal metodo.
• method: il valore a livello di tipo viene ereditato dal metodo.
• params: il valore a livello di tipo viene ereditato dal metodo.
• headers: il valore a livello di tipo viene ereditato dal metodo.
• consumes: il valore a livello di Tipo viene sovrascritto dal metodo.
• produces: il valore a livello di Tipo viene sovrascritto dal metodo.

Qui è un controller esempio breve che mette in mostra come è possibile utilizzare questo:

package com.example; 

import org.springframework.http.MediaType; 
import org.springframework.web.bind.annotation.*; 

@RestController 
@RequestMapping(path = "/", 
     consumes = MediaType.APPLICATION_JSON_VALUE, 
     produces = MediaType.APPLICATION_JSON_VALUE, 
     method = {RequestMethod.GET, RequestMethod.POST}) 
public class JsonProducingEndpoint { 

    private FooService fooService; 

    @RequestMapping(path = "/foo", method = RequestMethod.POST) 
    public String postAFoo(@RequestBody ThisIsAFoo theFoo) { 
     fooService.saveTheFoo(theFoo); 
     return "http://myservice.com/foo/1"; 
    } 

    @RequestMapping(path = "/foo/{id}", method = RequestMethod.GET) 
    public ThisIsAFoo getAFoo(@PathVariable String id) { 
     ThisIsAFoo foo = fooService.getAFoo(id); 
     return foo; 
    } 

    @RequestMapping(path = "/foo/{id}", produces = MediaType.APPLICATION_XML_VALUE, method = RequestMethod.GET) 
    public ThisIsAFooXML getAFooXml(@PathVariable String id) { 
     ThisIsAFooXML foo = fooService.getAFoo(id); 
     return foo; 
    } 
} 

Answer 5

Non dovrebbe essere necessario per configurare le consuma o produce attributo a tutti. Spring fornirà automaticamente JSON in base ai seguenti fattori.

• Il accetta intestazione della richiesta è application/json
• @ResponseBody metodo annotato
• biblioteca Jackson sul classpath

Si dovrebbe anche seguire il suggerimento di Wim e definire il controller con l'annotazione @RestController. Ciò ti eviterà di annotare ogni metodo di richiesta con @ResponseBody

Un altro vantaggio di questo approccio sarebbe se un client desidera XML invece di JSON, lo otterrebbero. Dovrebbero solo specificare xml nell'intestazione accept.