Why are you putting your list into Map? Code looks weird. If you want to return a list, just do it:

@RequestMapping("/getGodowns")
public @ResponseBody List<CscGodownBean> getGodownsBasedOnDistrict(@RequestParam(value="district_code") String dist_code) {
    List<CscGodownBean> godown_list = null;
    String exception = null;
    try {
        //getting name and codes here
        godown_list = scm_service.getGodownListBesedOnDistCode(dist_code);
    } catch (Exception ex) {
        ex.printStackTrace();
        exception = ex.getMessage();
    }
    return godown_list;
}

It seems to me that the issue is that you are trying to pass something like the following JSON to the content:

[
  {
    "compania1_list": "Compania1 list",
    "name1": "name1",
    "s": "---",
    "s1": "---",
    "o": null,
    "o1": null
  },
  {
    "compania1_list": "Compania2 list",
    "name1": "name2",
    "s": "---",
    "s1": "---",
    "o": null,
    "o1": null
  }
]

This is a JSON Array with 2 JSON Objects and not a JSON Object with a JSON Array with 2 JSON Objects. My guess is that MockHttpServletRequestBuilder.content() method is not expecting JSON like this.

With this being said, I would change your Controller to accept an Object and not a Collection as follows:

@ResponseStatus(HttpStatus.CREATED)
@PostMapping("/lista")
public Map<String, Object> createCompanias(@RequestBody CompaniasCreationRequest companiasCreationRequest) {
    return companiaService.postListCompanias(companiasCreationRequest.getCompanias());
}

Being CompaniasCreationRequest as follows:

public class CompaniasCreationRequest {
    private List<Compania> companias;

    public CompaniasCreationRequest(List<Compania> companias) {
        this.companias = companias;
    }

    public List<Compania> getCompanias() {
        return companias;
    }

    public void setCompanias(List<Compania> companias) {
        this.companias = companias;
    }
}

In your test this would mean the following changes:

@Test
void successSavePostCompaniaLista() throws Exception {
    Compania c1 = new Compania("Compania1 list",
        "name1",
        "---",
        "---",
        null,
        null);
    Compania c2 = new Compania("Compania2 list",
        "name2",
        "---",
        "---",
        null,
        null);

    CompaniasCreationRequest companiasCreationRequest = new CompaniasCreationRequest(List.of(c1,c2));
    
    when(companiaRepository.save(any(Compania.class))).then(returnsFirstArg());

    this.mockMvc.perform(
            post("/companias/lista")
                .header("authorization", "Bearer " + token)
                .content(asJsonString(companiasCreationRequest))
                .contentType(MediaType.APPLICATION_JSON))
        .andDo(print())
        .andExpect(status().isCreated())
        .andExpect(jsonPath("$.result[0].success[0]").isNotEmpty())
        .andExpect(jsonPath("$.result[0].success[0].name").value(c1.getName()))
        .andExpect(jsonPath("$.result[0].success[1].name").value(c2.getName()));
}

Now your request body will look like the following (which is a somewhat more standard JSON format):

{
  "companias": [
    {
      "compania1_list": "Compania1 list",
      "name1": "name1",
      "s": "---",
      "s1": "---",
      "o": null,
      "o1": null
    },
    {
      "compania1_list": "Compania2 list",
      "name1": "name2",
      "s": "---",
      "s1": "---",
      "o": null,
      "o1": null
    }
  ]
}

You need to assign returned json value to String object and then pass it to ModelAndView. Refer Gson.toJson() and also make sure your class(EmployeeBean) is serializable.

@RequestMapping(value = "/employees1", method = RequestMethod.GET)
public ModelAndView employeelist() {
    Gson gson = new Gson();
    String json = gson.toJson(employeeService.listEmployeess());

    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject(json);

    return modelAndView;
}

Finally I got solution using Jackson library along with Spring MVC. I got this solution from an example of Journal Dev( http://www.journaldev.com/2552/spring-restful-web-service-example-with-json-jackson-and-client-program )

So, the code changes I have done are:

• Include the library in Maven.
• Add JSON conversion Servlet into servlet-context.xml.
• Change the Model into Serializable.

I didn't made any changes to my REST service controller. By default it converts into JSON.

If you are using Spring Boot Starter Web, you can see that it's using Spring Boot Starter JSON through the compile dependencies, and Jackson is the dependency of the Start JSON library. So, you're assumption is right (Spring is using Jackson for JSON conversion by default)

Spring use it's AOP mechanism to intercept the mapping methods in @Controller (you can see that @RestController is actually a @Controller with @ResponseBody), spring create a proxy object (using JDK proxy or through cglib) for the class that annotated with @Controller.

When the request flow is processing, the program who really call the mapping method will be lead to the proxy first, the proxy will invoke the real @Controller object's method and convert it's returning value to JSON String using Jackson Library (if the method is annotated with @ResponseBody) and then return the JSON String back to the calling program.

That might be because of no @RequestMapping annotation on controller. Spring boot needs mapping to figure out which method needs to be called when a REST API request is sent. E.g. You need the following on UnitController class:

@RestController
@RequestMapping(produces = MediaType.APPLICATION_JSON_UTF8_VALUE, value = "/units")
public class UnitController {

If your controller class already has that, then you need to define another mapping for methods, specifying request method and optionally, mapping. E.g.

@RestController
@RequestMapping(produces = MediaType.APPLICATION_JSON_UTF8_VALUE, value = "/units")
public class UnitController {

   @RequestMapping(method = RequestMethod.GET)
   public List<Unit> method1(){..}

   @RequestMapping(method = RequestMethod.POST)
   public List<Unit> method2(){..}

   @RequestMapping(method = RequestMethod.GET, value = "/unit")
   public List<Unit> method3(){..}
}

For the above example:

• Sending a GET request to /units will result in invocation of method1
• Sending a POST request to /units will result in invocation of method2
• Sending a GET request to /units/unit will result in invocation of method3

If your application.properties file has server.contextPath property defined then it needs to be appended to the baseurl, e.g. <host>:<port>/<contextPath>

You probably don't need custom deserializer to get this json. Just add @JsonFormat(shape = JsonFormat.Shape.OBJECT) annotation to your class:

@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public static class PagedList<E> implements List<E>  {
    @JsonProperty
    private List<E> list;

    @JsonProperty // no need for this if you have getter-setters 
    private long totalRecords; 

    @JsonIgnore
    @Override
    public boolean isEmpty() {
        return false;
    }

...

Here is full demo: https://gist.github.com/varren/35c4ede769499b1290f98e39a2f85589

Update after comments:

I think Spring uses Jacksons return mapper.writerFor(List.class).writeValueAsString(new MyList()); Here is demo:

@RestController
@RequestMapping(value="/")
public static class MyRestController  {
    private static final ObjectMapper mapper = new ObjectMapper();

    //returns [] for both 0 and 1
    @RequestMapping(value="test", method = RequestMethod.GET)
    public List test(@RequestParam int user) {
        return user == 0 ? new ArrayList(): new MyList();
    }

    //returns [] for 0 and expected custom {"empty": true} for 1
    @RequestMapping(value="testObj", method = RequestMethod.GET)
    public Object testObj(@RequestParam int user) {
        return user == 0 ? new ArrayList(): new MyList();
    }

    // returns expected custom {"empty": true}
    @RequestMapping(value="testMyList", method = RequestMethod.GET)
    public MyList testMyList() {
        return new MyList();
    }

    // returns expected custom {"empty": true}
    @RequestMapping(value="testMyListMapper", method = RequestMethod.GET)
    public String testMyListMapper() throws JsonProcessingException {
        return mapper.writeValueAsString(new MyList());
    }

    // returns []
    @RequestMapping(value="testMyListMapperListWriter", method = RequestMethod.GET)
    public String testMyListMapperListWriter() throws JsonProcessingException {
        return mapper.writerFor(List.class).writeValueAsString(new MyList());
    }
}
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public static class MyList extends ArrayList {}

So you have to Option 1) return Object instead of List or Option 2) register custom serialifer for List (and not for PageList) builder.serializerByType(List.class, new PagedListSerializer()); like this:

public class PagedListSerializer extends JsonSerializer<List> {
  @Override
  public void serialize(List valueObj, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
    if (valueObj instanceof PagedList) {
      PagedList value = (PagedList) valueObj;
      gen.writeStartObject();
      gen.writeNumberField("totalRecords", value.getTotalRecords());
      gen.writeObjectField("list", value.getList());
      gen.writeEndObject();
    }else{
      gen.writeStartArray();
      for(Object obj : valueObj)
        gen.writeObject(obj);
      gen.writeEndArray();
    }
  }
}

Just return the list from the controller method

@RequestMapping(value = "/all", method = RequestMethod.GET)
@ResponseBody
public List<Object[]> getAllDeps() {
    List<Object[]> list  = departmentService.getAllDepartments();
    return list;
}

The @ResponseBody annotation does the transformation for you.

Use GSON library for that. Here is the sample code

List<String> foo = new ArrayList<String>();
foo.add("A");
foo.add("B");
foo.add("C");

String json = new Gson().toJson(foo );

Here is the maven dependency for Gson

<dependencies>
    <!--  Gson: Java to Json conversion -->
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.2.2</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

Or you can directly download jar from here and put it in your class path

http://code.google.com/p/google-gson/downloads/detail?name=gson-1.0.jar&can=4&q=

To send Json to client you can use spring or in simple servlet add this code

response.getWriter().write(json);

For whatever reason, it works using List instead of ArrayList. Also, I would get rid of the addFormatters method. You just need the bean declaration.

Spring Boot:

@SpringBootApplication
public class TheApplication extends WebMvcConfigurerAdapter {

  public static void main(String[] args) {
    SpringApplication.run(PageServiceApplication.class, args);
  }

  @Bean
  public Converter<List<String>, String> converter() {
    return new Converter<List<String>, String>() {
      public String convert(List<String> source) {
        return new JSONArray(source).toString();
      }
    };
  }
}

Thymeleaf (double bracket for tags)

<some-webcomponent xmlns:th="http://www.thymeleaf.org"
    th:attrappend="tags=${{data.tags}} ...">
</some-webcomponent>