Use Jackson JSON processor in combination with spring’s StringHttpMessageConverter

I used the Jackson JSON processor to generate a JSON string that can be written via the spring’s StringHttpMessageConverter into the HttpServletResponse response object. To use this functionality we have to add the jackson-mapper-asl.jar into our project. For maven projects we have to add following stuff into the pom.xml dependencies:

		<!-- Jackson JSON Mapper -->
		<dependency>
			<groupId>org.codehaus.jackson</groupId>
			<artifactId>jackson-mapper-asl</artifactId>
			<version>1.5.3</version>
		</dependency>

Simple Data Binding

You can use Map objects to build the JSON object graph and generate the JSON stream. In a spring web controller this could look like this:

@Controller
public class RestController {

    @RequestMapping(value = "rest/playground/json-user", method = RequestMethod.GET)
    protected void getJsonDataExampleSimpleDataBinding(HttpServletResponse response) throws JsonGenerationException, JsonMappingException, IOException {
        ObjectMapper mapper = new ObjectMapper();
        Map<String, String> nameStruct = new HashMap<String, String>();
        nameStruct.put("first", "Joe");
        nameStruct.put("last", "Sixpack");
        Map<String, Object> userData = new HashMap<String, Object>();
        userData.put("name", nameStruct);
        userData.put("gender", "MALE");
        userData.put("verified", Boolean.FALSE);
        userData.put("userImage", "Rm9vYmFyIQ==");
        String jsonString = mapper.writeValueAsString(userData);

        AbstractHttpMessageConverter<String> stringHttpMessageConverter = new StringHttpMessageConverter();
        MediaType jsonMimeType = MediaType.APPLICATION_JSON;
        if (stringHttpMessageConverter.canWrite(String.class, jsonMimeType)) {
            try {
                stringHttpMessageConverter.write(jsonString, jsonMimeType, new ServletServerHttpResponse(response));
            } catch (IOException m_Ioe) {
            } catch (HttpMessageNotWritableException p_Nwe) {
            }
        }
    }
    ...
}

Full Data Binding

In opposite to use Map objects often it makes sense to represent the JSON objects in simple bean classes (POJOs) on the server side and to marshall the POJO back to a JSON string stream. Here is an example:

    @RequestMapping(value = "rest/playground/json-user", method = RequestMethod.GET)
    protected void getJsonDataExampleFullDataBinding(HttpServletResponse response) throws JsonGenerationException, JsonMappingException, IOException {
        ObjectMapper mapper = new ObjectMapper();
        Object userData = new String("mock for the json object which have to be replaced with real one");
        String jsonString = mapper.writeValueAsString(userData);

        AbstractHttpMessageConverter<String> stringHttpMessageConverter = new StringHttpMessageConverter();
        MediaType jsonMimeType = MediaType.APPLICATION_JSON;
        if (stringHttpMessageConverter.canWrite(String.class, jsonMimeType)) {
            try {
                stringHttpMessageConverter.write(jsonString, jsonMimeType, new ServletServerHttpResponse(response));
            } catch (IOException m_Ioe) {
            } catch (HttpMessageNotWritableException p_Nwe) {
            }
        }
    }

Use the spring’s MappingJacksonHttpMessageConverter

Another solution to provide JSON response is to use the MappingJacksonHttpMessageConverter which is an implementation of HttpMessageConverter that can read and write JSON using the Jackson’s ObjectMapper. (Underneath the cover the MappingJacksonHttpMessageConverter uses Jackson as the name implied.) For propper use of this Implementation we have to add the depending artifact jason-mapper-asl.jar into our project as shown in the pom.xml example above.

Use the MappingJacksonHttpMessageConverter directly in controller’s request method

Use the MappingJacksonHttpMessageConverter class directly in the controler’s request method to build the HttpServeletResponse. This will be show in the example below:

    @RequestMapping(value = "rest/playground/json-example", method = RequestMethod.GET)
    protected void getJsonDataExample(HttpServletResponse response) {
        MappingJacksonHttpMessageConverter jsonConverter = new MappingJacksonHttpMessageConverter();
        MediaType jsonMimeType = MediaType.APPLICATION_JSON;
        Object jsonBean = new String("mock for the json object which have to be replaced with real one");
        if (jsonConverter.canWrite(jsonBean.getClass(), jsonMimeType)) {
            try {
                jsonConverter.write(jsonBean, jsonMimeType, new ServletServerHttpResponse(response));
            } catch (IOException m_Ioe) {
            } catch (HttpMessageNotWritableException p_Nwe) {
            }
        }
    }

Use the @ResponseBody Annotation

A very simple solution is to use the spring’s @RequestBody Annotation on the return value of a controller method. When using the @RequestBody the return value is indicated to be bound to a web response body which will be automatically done by the spring MVC. In this case, Spring MVC invokes a MappingJacksonHttpMessageConverter built on the Jackson JSON processor. This implementation is enabled automatically when you use the mvc:annotation-driven configuration element with Jackson present in your classpath.
So, an approch in code can look like this:

    @RequestMapping(value = "/rest/playground/google-barchart", method = RequestMethod.GET)
    public @ResponseBody
    GoogleJsonResponse getJsonDataForBarChart(HttpServletResponse response, HttpServletRequest request) {
        response.setStatus(HttpServletResponse.SC_OK);
        GoogleJsonResponse ret = new GoogleJsonResponse();
        ret.addColl("string", "Year");
        ret.addColl("number", "Austria");
        ret.addColl("number", "Bulgaria");
        ret.addColl("number", "Denmark");
        ret.addColl("number", "Greece");
        ret.addRow(new GoogleJsonResponse.Cell("2003"), new GoogleJsonResponse.Cell(1336060), new GoogleJsonResponse.Cell(400361), new GoogleJsonResponse.Cell(1001582), new GoogleJsonResponse.Cell(
                997974));
        ret.addRow(new GoogleJsonResponse.Cell("2004"), new GoogleJsonResponse.Cell(1538156), new GoogleJsonResponse.Cell(366849), new GoogleJsonResponse.Cell(1119450), new GoogleJsonResponse.Cell(
                941795));
        ret.addRow(new GoogleJsonResponse.Cell("2005"), new GoogleJsonResponse.Cell(1576579), new GoogleJsonResponse.Cell(440514), new GoogleJsonResponse.Cell(993360), new GoogleJsonResponse.Cell(
                930593));
        ret.addRow(new GoogleJsonResponse.Cell("2006"), new GoogleJsonResponse.Cell(1600652), new GoogleJsonResponse.Cell(434552), new GoogleJsonResponse.Cell(1004163), new GoogleJsonResponse.Cell(
                897127));
        ret.addRow(new GoogleJsonResponse.Cell("2007"), new GoogleJsonResponse.Cell(1968113), new GoogleJsonResponse.Cell(393032), new GoogleJsonResponse.Cell(979198), new GoogleJsonResponse.Cell(
                1080887));
        ret.addRow(new GoogleJsonResponse.Cell("2008"), new GoogleJsonResponse.Cell(1901067), new GoogleJsonResponse.Cell(517206), new GoogleJsonResponse.Cell(916965), new GoogleJsonResponse.Cell(
                1056036));
        return ret;
    }

public class GoogleJsonResponse {

    class Col {
        String id;
        final String _type;
        final String _label;

        public Col(String type, String label) {
            _type = type;
            _label = label;
        }

        public String getId() {
            return id;
        }

        public String getType() {
            return _type;
        }

        public String getLabel() {
            return _label;
        }
    };

    public static class Cell {
        private final Object _v;

        public Cell(Object v) {
            _v = v;
        }

        public Object getV() {
            return _v;
        }
    }

    class Row {
        List<Cell> _c = new ArrayList<Cell>();

        public void addCells(Cell... cells) {
            _c.addAll(Arrays.asList(cells));
        }

        public List<Cell> getC() {
            return _c;
        }
    };

    /* GoogleResonResponse attributes starts here */
    private List<Col> _cols = new ArrayList<Col>();
    
    private List<Row> _rows = new ArrayList<Row>();

    public void addColl(String type, String label) {
        Col col = new Col(type, label);
        _cols.add(col);
    }

    public void addRow(Cell... cells) {
        Row row = new Row();
        row.addCells(cells);
        _rows.add(row);
    }

    public List<Col> getCols() {
        return _cols;
    }

    public List<Row> getRows() {
        return _rows;
    }
}

Conclusion

The simplest and most straightforward solution to generate an ‘application/json’ response seemed to me to use the @ResponseBody annotation as shown above. If you need more control about the serialization of the JSON bean objects on the server side, e.g. if you need a special representation of java.util.Date attributes, you have to use Annotations as described in Jackson Core documenation.

Let’s assume following situation:

• We have a folder ˜/workshop , that contains the project on a local machine
• Our project folder workshop is not a git repository yet
• We want to have a server that hosts the workshop project and new developer can get the repository using a ‘git clone …’ command
• On server site, the new repository should be located unter ˜/gitrepos/workshop.git.

To simplify the following steps i will use the machine localhost as the server machine.

Create a working copy repository

First, create a new local git repository and add all files within this folder.

cd ˜/workshop
git init
git add .
git commit -m "initial repository creation"

Create the bare repository

Then we have to create a bare repository on the server side. Let’s assume the user ralfwehner is the repository admin user on server side. For this step i will show two alternative ways:
a) We clone the server’s repositiory on the client machine and copy it via scp up to the server:

git clone --bare .git ../workshop.git
scp -r ../workshop.git ralfwehner@localhost:/Users/ralfwehner/gitrepos/workspace.git

b) We create a new empty repository on the server side and copy the developer’s repository from client machine to server (recommended when using difference git versions on server and clients):
So, first create the bare repository on server side:

sudo -u ralfwehner mkdir -m 770 /Users/ralfwehner/gitrepos/workshop.git
cd /Users/ralfwehner/gitrepos/workshop.git
sudo -u ralfwehner git --bare init --shared=group

From client side the developer’s project must be pushed into the new bare server repository:

git remote add origin ssh://ralfwehner@dev-server/Users/ralfwehner/gitrepos/workshop.git
git push origin master

That’s it. The project ‘workshop’ is now available on the server and can be cloned using the git clone command. E.g.:

cd /tmp/
git clone ralfwehner@localhost:/Users/ralfwehner/gitrepos/workshop.git myclonedworkshop

Synconize local and server repositories

Push developers repository to server

To synchronize the changes checked in into the local developer’s project to the server repository:

git push

Pull or merge the server repository into developer’s one

This command synchronizes the server’s repository to the local developer’s one. By this step changes made from other developers that pushed their stuff up to the server will be merged into the local repository.

git pull . remotes/origin/master

Checkout a project from server

In git terminology the checkout of a projekt can be understood as a clone of a git repository from a server to the developer’s local machine. You can do this simply by:

mkdir myNewWorkspace && cd myNewWorkspace
git clone ssh://localhost/Users/ralfwehner/gitrepos/workshop.git

The new created project can be pushed and pulled with:

cd workshop
... do you changes...
git push
... merge changes made from other users...
git pull

Heads up for Mac OS X users as i’m, too

There is a problem using the ssh commands to connecto to the git server which can end in error messages like: ‘bash: git-upload-pack: command not found’ on some machines. I’ve found this article that describe the problem and the solution more precisely.

For short, the solution is to create the symbolic link .bashrc to the .profile file:

server$ cd ~
server$ ln -s .profile .bashrc

So, in this post i want to show some programming examples how to use Mockito in your JUnit test code. I don’t want to write a tutorial or a howto, this is just a summary of programming examples for JAVA programmers who are familiar with Mockito.

Capturing method arguments from Mocks for further assertions:
If you are using the version 1.8 and above you can use the ArgumentCaptor. The ArgumentCapture gives you a way to get one or more Arguments of a mocked method that was called before. Use the ArgumentCapture only if need to evaluate complex objects or objects that were created outside your junit test code. If you just want to verify the proper call of a simple mocked method, its better to use a simple verify(mock).yourMethod(). This makes your test code more readable.

So, start working with ArgumentCaptures with code:

package de.wehner.mockito.samples;

import static org.junit.Assert.assertEquals;

import static org.mockito.Matchers.any;
import static org.mockito.Matchers.argThat;

import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
public class MockitoSampleTests {

    @Test
    public void testInvideJohn() {
        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
        Party party = mock(Party.class);

        Person john = new Person("John");
        Person peter = new Person("Peter");

        // Peter invites John to the party
        peter.invideToParty(john, party);

        verify(party).addGuest(argument.capture());
        // verify John was invited
        assertEquals("John", argument.getValue().getName());
    }
}

And this is the Person:

package de.wehner.mockito.samples;

public class Person {

    private final String _name;

    public Person(String name) {
        super();
        _name = name;
    }

    public String getName() {
        return _name;
    }

    public void invideToParty(Person friend, Party party) {
        party.addGuest(friend);
    }
}

Another way to solve this problem is to use a helper class (here this this the Holder<>) that is final and must be used in combination with the BaseMatcher<> class from Mockito.

package de.wehner.mockito.samples;

import static org.junit.Assert.assertEquals;

import static org.mockito.Matchers.*;

import static org.mockito.Mockito.*;

import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.core.AnyOf;
import org.junit.Test;
import org.mockito.ArgumentCaptor;

public class MockitoSampleTests {

    @Test
    public void testInvideJohn() {
        ...
    }

    public class Holder<T> {
        private T _value;

        public Holder() {
        }

        public Holder(T value) {
            _value = value;
        }

        public T get() {
            return _value;
        }

        public void set(T value) {
            _value = value;
        }
    }

    @Test
    public void testInvideJaneAndJohn() {
        Party party = mock(Party.class);
        Person peter = new Person("Peter");
        Person jane = new Person("Jane");
        Person john = new Person("John");

        // "listen" to invocations of Party.addGuest() method
        final Holder<Person> lastInvited = new Holder<Person>();
        doNothing().when(party).addGuest(argThat(new BaseMatcher<Person>() {

            @Override
            public boolean matches(Object arg0) {
                lastInvited.set((Person) arg0);
                return true;
            }

            @Override
            public void describeTo(Description arg0) {
            }
        }));

        // Peter invites his friends
        peter.invideToParty(jane, party);
        peter.invideToParty(john, party);

        // verify 2 guests are invited and John is the last one
        verify(party, times(2)).addGuest(any(Person.class));
        assertEquals(john, lastInvited.get());
    }
}