jsonvalue - recibir json y deserializar como lista de objetos en el controlador spring mvc

spring mvc jackson example

Question

Mi código es el siguiente:

controlador

@RequestMapping(value="/setTest", method=RequestMethod.POST, consumes="application/json")
public @ResponseBody ModelMap setTest(@RequestBody List<TestS> refunds, ModelMap map) {
for(TestS r : refunds) {
System.out.println(r.getName());
}
// other codes
}

TestS pojo

public class TestS implements Serializable {
private String name;
private String age;
//getter setter
}

Solicitud de Json

var z = ''[{"name":"1","age":"2"},{"name":"1","age":"3"}]'';
$.ajax({
url: "/setTest",
data: z,
type: "POST",
dataType:"json",
contentType:''application/json''
});

Esta dando este error

java.lang.ClassCastException: java.util.LinkedHashMap no se puede convertir a com.gogoair.cidb.entities.TestS

Estoy usando spring 3.1.2 y jackson 2.0.4

Editar: quiero recibir la lista de objetos TestS en mi método de controlador y procesarlos. No puedo encontrar si estoy enviando un json incorrecto o mi firma de método es incorrecta.

Answer 1

Aquí está el código que funciona para mí. La clave es que necesitas una clase envoltura.

public class Person {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}

Una clase de PersonWrapper

public class PersonWrapper {
private List<Person> persons;
/**
* @return the persons
*/
public List<Person> getPersons() {
return persons;
}
/**
* @param persons the persons to set
*/
public void setPersons(List<Person> persons) {
this.persons = persons;
}
}

Mis métodos de controlador

@RequestMapping(value="person", method=RequestMethod.POST,consumes="application/json",produces="application/json")
@ResponseBody
public List<String> savePerson(@RequestBody PersonWrapper wrapper) {
List<String> response = new ArrayList<String>();
for (Person person: wrapper.getPersons()){
personService.save(person);
response.add("Saved person: " + person.toString());
}
return response;
}

La solicitud enviada es json en POST.

{"persons":[{"name":"shail1","age":"2"},{"name":"shail2","age":"3"}]}

Y la respuesta es.

["Saved person: Person [name=shail1, age=2]","Saved person: Person [name=shail2, age=3]"]

Answer 2

Esto no es posible de la manera en que lo intentas. El desprovisto de Jackson funciona en el código java compilado después del borrado de tipo. Entonces tus

public @ResponseBody ModelMap setTest(@RequestBody List<TestS> refunds, ModelMap map) 

es realmente solo

public @ResponseBody ModelMap setTest(@RequestBody List refunds, ModelMap map) 

(No hay genéricos en la lista arg).

El tipo predeterminado que Jackson crea cuando se desmarca una List es un LinkedHashMap .

Como lo mencionó @Saint, puede evitarlo creando su propio tipo para la lista de esta manera:

class TestSList extends ArrayList<TestS> { }

y luego modificando su firma de controlador para

public @ResponseBody ModelMap setTest(@RequestBody TestSList refunds, ModelMap map) {

Answer 3

La solución funciona muy bien,

public List<String> savePerson(@RequestBody Person[] personArray) 

Para esta firma puede pasar la matriz de Person del cartero como

[
{
"empId": "10001",
"tier": "Single",
"someting": 6,
"anything": 0,
"frequency": "Quaterly"
}, {
"empId": "10001",
"tier": "Single",
"someting": 6,
"anything": 0,
"frequency": "Quaterly"
}
]

No olvides añadir la etiqueta de consumes :

@RequestMapping(value = "/getEmployeeList", method = RequestMethod.POST, consumes="application/json", produces = "application/json")
public List<Employee> getEmployeeDataList(@RequestBody Employee[] employeearray) { ... }

Answer 4

Para mí, debajo del código funcionó, primero enviando la cadena json con los encabezados adecuados

$.ajax({
type: "POST",
url : ''save'',
data : JSON.stringify(valObject),
contentType:"application/json; charset=utf-8",
dataType:"json",
success : function(resp){
console.log(resp);
},
error : function(resp){
console.log(resp);
}
});

Y luego en el lado de la primavera -

@RequestMapping(value = "/save",
method = RequestMethod.POST,
consumes="application/json")
public @ResponseBody String save(@RequestBody ArrayList<KeyValue> keyValList) {
//Saving call goes here
return "";
}

Aquí KeyValue es un simple pojo que corresponde a su estructura JSON, también puede agregar productos como desee, simplemente estoy devolviendo una cadena.

Mi objeto json es así.

[{"storedKey":"vc","storedValue":"1","clientId":"1","locationId":"1"},
{"storedKey":"vr","storedValue":"","clientId":"1","locationId":"1"}]

Answer 5

@RequestMapping(
value="person",
method=RequestMethod.POST,
consumes="application/json",
produces="application/json")
@ResponseBody
public List<String> savePerson(@RequestBody Person[] personArray) {
List<String> response = new ArrayList<String>();
for (Person person: personArray) {
personService.save(person);
response.add("Saved person: " + person.toString());
}
return response;
}

Podemos usar Array como se muestra arriba.