REST with Jersey and Jetty part 3

REST with Jersey and Jetty part 3

Adding JSON support.

The first two parts  in this small series of posts were about setting up the server and be able to run it with Jersey. [REST with Jersey and Jetty part 1, REST with Jersey and Jetty part 2].

This time there will be a bit more work. And I will take it step by step.

The service we will implement will handle tasks. To start with, there will only be one task list where all tasks will go.

The api will be the following.
Task class:
package model; import java.util.Date; import java.util.UUID; import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlRootElement; @XmlRootElement @XmlAccessorType(XmlAccessType.FIELD) public class Task { private String id; private String title; private String description; private Date dueDate; public Task() { } public static Task of(String title, String description, Date dueDate) { UUID randomUUID = UUID.randomUUID(); return new Task(randomUUID.toString(), title, description, dueDate); } private Task(String id, String title, String description, Date dueDate) { this.id = id; this.title = title; this.description = description; this.dueDate = dueDate; } // getters/setters @Override public String toString() { return "Task{" + "id=" + id + ", title=" + title + ", description=" + description + ", dueDate=" + dueDate + '}'; } }

To start with we add support for getting the list, there will be some hardcoding until we have the working JSON support, since the first thing we want is a working Jersey with JSON support, not to complicate things further. When we have that, we can start adding functionality. But in the end, we will try to support:

• list all
• show a single task
• create a task
• update a task
• remove a task
• show range of tasks
• get task count

But starting with some hardcoded stuff, to get the server running with JSON, this will be the stating point for the TaskResource
package rest; import java.util.Date; import java.util.ArrayList; import java.util.List; import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; import javax.ws.rs.core.MediaType; import model.Task; @Path("tasks") public class TaskResource { @GET @Produces(MediaType.APPLICATION_JSON) public List<task> getAll() { List<task> all = new ArrayList<>(); all.add(Task.of("Testtask", "Task to test", new Date())); return all; } }

If you start the server and try to surf to this [http://localhost:2001/api/tasks] will yield the following in the log.

maj 02, 2015 11:02:34 FM org.glassfish.jersey.message.internal.WriterInterceptorExecutor$TerminalWriterInterceptor aroundWriteTo SEVERE: MessageBodyWriter not found for media type=application/json, type=class java.util.ArrayList, genericType=java.util.List<model.Task>.
so we need to add some stuff to have JSON support.

Well, just a shor Googling, and it was pretty easy to add. [http://stackoverflow.com/questions/25474223/jersey-rest-messagebodywriter-not-found-for-media-type-application-jso] gives a hint. Just added moxy and it works to get JSON with the @GET.
<dependency> <groupid>org.glassfish.jersey.media</groupId> <artifactid>jersey-media-moxy</artifactId> <version>2.17</version> </dependency>
So lets go for some real coding. We will add a simple cache, To avoid having a database for this simple example it will only contain a map with the tasks.

Lets start with some simple support of the cache:

package rest; import java.util.HashMap; import java.util.Map; import java.util.Optional; import model.Task; public enum TaskCache { INST; private Map<String, Task> tasks; private TaskCache() { tasks = new HashMap<>(); } public Optional<task> getTask(String id) { return Optional.ofNullable(tasks.get(id)); } public void putTask(Task task) { tasks.put(task.getId(), task); } public void removeTask(Task task) { tasks.remove(task.getId()); } public List<task> getTasks() { return new ArrayList(tasks.values()); } }
Lets first add a method to create a task and one for getting a specific task.
@POST @Consumes(MediaType.APPLICATION_JSON) public Response create(Task task) { TaskCache.INST.addTask(task); URI id = URI.create("tasks/" + task.getId()); Response resp = Response.created(id).build(); return resp; } @GET @Produces(MediaType.APPLICATION_JSON) @Path("{id}") public Response getTask(@PathParam("id") String id) { Optional<task> task = TaskCache.INST.getTask(id); Response resp = null; if (task.isPresent()) { resp = Response.ok(task.get()).build(); } else { resp = Response.noContent().build(); } return resp; }
To test this, we will need to also add a method to get a single task and a client to test it.

First, the client.
package app; import java.net.URI; import java.util.Date; import javax.ws.rs.client.Client; import javax.ws.rs.client.ClientBuilder; import javax.ws.rs.client.Entity; import javax.ws.rs.client.WebTarget; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import model.Task; public class JerseyClient { public static void main(String[] args) { Client client = ClientBuilder.newClient(); WebTarget postTarget = client.target("http://localhost:2001").path("api").path("tasks"); Response postResponse = postTarget.request(MediaType.APPLICATION_JSON) .post(Entity.json(Task.of("Testclient", "Using test client to create", new Date()))); System.out.println(postResponse.getStatus()); URI location = postResponse.getLocation(); System.out.println(location); WebTarget getTarget = client.target(location); Response getResponse = getTarget.request(MediaType.APPLICATION_JSON).get(); System.out.println(getResponse.getStatus()); System.out.println(getResponse.readEntity(Task.class)); } }

So far the client just adds a Task, gets the URI to the created Task and then gets it using the @GET for the methods added above.

Next step, fix the getAll().
The client cannot handle a List without wrapping it in a GenericType, but that is really all there is too it, we can still return List from the method.

// TaskResource.java @GET @Produces(MediaType.APPLICATION_JSON) public List<task> getAll() { return TaskCache.INST.getTasks(); } // JerseyClient.java WebTarget allTarget = client.target("http://localhost:2001").path("api").path("tasks"); GenericType<List<task>> genericType = new GenericType<List<task>>() {}; List<task> all = allTarget.request(MediaType.APPLICATION_JSON).get(genericType); for (Task task : all) { System.out.println(task); }
The only thing we need to add now is update and delete. We will also add some code to test it in the client.
@PUT @Consumes(MediaType.APPLICATION_JSON) @Path("{id}") public Response update(Task task) { // Just replace the one there System.out.println("Updating task: " + task); TaskCache.INST.putTask(task); return Response.ok().build(); } @DELETE @Path("{id}") public Response delete(@PathParam("id") String id) { System.out.println("Deleting task: " + id); TaskCache.INST.removeTask(id); return Response.ok().build(); }
I also made some changes in the client: public static void main(String[] args) { Client client = ClientBuilder.newClient(); List<uri> locations = new ArrayList<>(); WebTarget target = client.target("http://localhost:2001").path("api").path("tasks"); Response postResponse = target.request(MediaType.APPLICATION_JSON) .post(Entity.json(Task.of("Testclient1", "Using test client to create", new Date()))); locations.add(postResponse.getLocation()); postResponse = target.request(MediaType.APPLICATION_JSON) .post(Entity.json(Task.of("Testclient2", "Using test client to create", new Date()))); locations.add(postResponse.getLocation()); postResponse = target.request(MediaType.APPLICATION_JSON) .post(Entity.json(Task.of("Testclient3", "Using test client to create", new Date()))); locations.add(postResponse.getLocation()); // Get first one WebTarget getTarget = client.target(locations.get(0)); Response getResponse = getTarget.request(MediaType.APPLICATION_JSON).get(); System.out.println(getResponse.getStatus()); System.out.println(getResponse.readEntity(Task.class)); // Change second one getTarget = client.target(locations.get(1)); getResponse = getTarget.request(MediaType.APPLICATION_JSON).get(); Task aTask = getResponse.readEntity(Task.class); aTask.setTitle("This title is changed"); client.target(locations.get(1)).request(MediaType.APPLICATION_JSON).put(Entity.json(aTask)); // Delete thirs one client.target(locations.get(2)).request().delete(); WebTarget allTarget = client.target("http://localhost:2001").path("api").path("tasks"); GenericType<List<task>> genericType = new GenericType<List<task>>() {}; List<task> all = allTarget.request(MediaType.APPLICATION_JSON).get(genericType); for (Task task : all) { System.out.println(task); } }
Enjoy your Task microservice in REST using embedded Jetty with Jersey.

Read more about Jersey [https://jersey.java.net/documentation/latest/index.html]

REST with Jersey and Jetty part 2

REST with Jersey and Jetty part 2

Getting Jersey into play

In this part, we will introduce Jetty as serving with rest. We will att a class serving a @GET request.

We will need an extra dependency for Jersey to work, and after getting a strange error under startup I ended up changing the dependency on Jetty from the previous post [http://ironicprogrammer.blogspot.se/2015/04/rest-with-jersey-and-jetty-part-1.html]. I got the following error:

2015-05-01 11:37:38.214:INFO:oejs.Server:main: jetty-9.1.1.v20140108 2015-05-01 11:37:38.224:WARN:oejuc.AbstractLifeCycle:main: FAILED org.eclipse.jetty.server.Server@7637f22: java.lang.NoSuchMethodError: org.eclipse.jetty.util.DateCache.setTimeZone(Ljava/util/TimeZone;)V java.lang.NoSuchMethodError: org.eclipse.jetty.util.DateCache.setTimeZone(Ljava/util/TimeZone;)V
When adding the dependency for Jersey 2.17 after th Jetty dependency. Actually I got it to work by moving the Jetty dependency to after the Jersey dependency. But reading the log you can see that 2.17 if Jersey used Jetty 9.1.1 so, updating Jetty dependency to 9.1.1.v20140108, the order does not matter.
This is the dependencies for this part.

<dependencies> <dependency> <groupid>org.glassfish.jersey.containers</groupId> <artifactid>jersey-container-jetty-servlet</artifactId> <version>2.17</version> </dependency> <dependency> <groupid>org.eclipse.jetty</groupId> <artifactid>jetty-servlet</artifactId> <version>9.1.1.v20140108</version> </dependency> </dependencies>

We will also create a new statup-class, It will not be much more code than the one in the previous part, but some extra stuff is needed to get Jersey into play.

package app; import java.util.logging.Level; import java.util.logging.Logger; import org.eclipse.jetty.server.Server; import org.eclipse.jetty.servlet.ServletContextHandler; import org.eclipse.jetty.servlet.ServletHolder; public class JerseyServer { public static void main(String[] args) { int port = 2001; if(args.length == 1) { port = Integer.parseInt(args[0]); } Server server = new Server(port); ServletHolder servletHolder = new ServletHolder(org.glassfish.jersey.servlet.ServletContainer.class); servletHolder.setInitParameter("com.sun.jersey.config.property.resourceConfigClass", "com.sun.jersey.api.core.PackagesResourceConfig"); servletHolder.setInitParameter("jersey.config.server.provider.packages", "rest");//Set the package where the services reside servletHolder.setInitParameter("com.sun.jersey.api.json.POJOMappingFeature", "true"); ServletContextHandler contextHandler = new ServletContextHandler(ServletContextHandler.SESSIONS); server.setHandler(contextHandler); contextHandler.addServlet(servletHolder, "/api/*"); try { server.start(); server.join(); } catch (Exception ex) { Logger.getLogger(JerseyServer.class.getName()).log(Level.SEVERE, null, ex); System.exit(1); } } }
The difference here is that we use a ServletHolder with some init parameters to set Jersey up. We also set the path to serve to "/api/*" instead of plain root "/".
That brings us to REST, we need something to show that it works. To do this we have a class under "rest" package called HelloResource.
package rest; import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; @Path("hello") public class HelloResource { @GET @Produces("text/plain") public String sayHello() { return "Hello from HelloResource!"; } }

So now the only thing you have to do is to start upp JerseyServer and surf into [http://localhost:2001/api/hello] and you should see the hello message. And there you have your first little Microservice ;)

In future post will explore how to use more than @GET and also how to add JSON support to this.

REST with Jersey and Jetty part 1

REST with Jersey and Jetty part 1

Running Jersy standalone with a Servlet.

A few days ago I started to look into how to run a REST service with an embedded container. Now a friend of Springframework will say, that is easy with Spring, but after looking at a tutorial [http://spring.io/guides/tutorials/bookmarks/] I notice a couple of things. The annotations are not the standard JSR 331/339 ones, and there is a lot of other things from spring framework coming into play. Well, sorry Spring-guys, I don’t want that. I want to go with standard JSR annotations, and no specialities from Spring.

So my ide is to use Jersey which is the reference implementation och JSR 311/339 and run it on a server that can be embedded. What I want to do is to have the following support.

• Ability to run with an embedded server (my choise: “jetty”)
• Ability to serve REST calls (my choise: “Jersey”)
• Ability to communicate wiht JSON. 

After some research I noticed that it is not easy to find any good resource on how to run Jersey with an embedded server. the bes I could find was [http://jlunaquiroga.blogspot.se/2014/01/restful-web-services-with-jetty-and.html] , but I don’t like blogs saying “you only need to include the jars necessary or use maven” but leaving out the information of which the necessary jars are or the specific maven dependencies needed.. the documentation over Jersey is scarce in examples.

I will start this “journey” by building it up step by step. In this part, I will do only what is necessary to start an embedded server.

I used the above blog as a starting point. First step I will show is how to run a servlet in an embedded Jetty.

The first thing to do is to have a dependency to Netty.

<dependency> <groupid>org.eclipse.jetty</groupId> <artifactid>jetty-servlet</artifactId> <version>9.1.1.v20140108</version> </dependency>

The server will be started in a class with a main method, 

package app; import servlet.HelloServlet; import org.eclipse.jetty.server.Server; import org.eclipse.jetty.servlet.ServletHandler; public class MiniServer { public static void main(String[] args) throws Exception { int port = 2001; if(args.length == 1) { port = Integer.parseInt(args[0]); } Server server = new Server(port); ServletHandler handler = new ServletHandler(); handler.addServletWithMapping(HelloServlet.class, "/hello"); server.setHandler(handler); server.start(); server.join(); } }

There will also be a simple servlet to run in it.

package servlet; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class HelloServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); response.setStatus(HttpServletResponse.SC_OK); response.getWriter().println("Hello from Sevlet"); } }

Next post is about how to create a REST service based on Jersey and run it in Jetty.
(Update: changed the version of Jetty dependency, since I in next post use Jersey 2.17 and there was some issues running with Jetty 9.0.2)