{"id":29,"date":"2017-12-25T13:04:00","date_gmt":"2017-12-25T13:04:00","guid":{"rendered":""},"modified":"2019-03-12T20:10:16","modified_gmt":"2019-03-12T20:10:16","slug":"quick-and-dirty-java-service-template","status":"publish","type":"post","link":"https:\/\/ntlx.org\/de\/2017\/12\/quick-and-dirty-java-service-template.html","title":{"rendered":"Quick and Dirty Java Service Template"},"content":{"rendered":"

To get a java service running, you don’t always need to start a tomcat and deploy a war file, as described in an earlier blog post<\/a>. Even if tomcat gives you a number of benefits, such as user management and database connection handling, sometimes you do not need this and just want to start up a small http server to provide a bit of functionality.<\/p>\n

The template contents<\/h2>\n

To get such projects started as fast as possible, I created the quick and dirty java service template, where I collected stuff I find most useful to implement a new java service:<\/p>\n

It uses the grizzly http server<\/a> to provide the web server, which makes starting an http server running java code as easy as executing a jar file.
Often, communication between a web page and a java backend works easiest by sending a JSON document. This is why we include the gson<\/a> JSON parser in the template.
In addition to some java code, we will also package static content, such as html files or images to the jar package. All this can be accessed via the same URL after starting the jar file.<\/p>\n

Checkout the service template at https:\/\/github.com\/NautiluX\/JavaServiceTemplate<\/a>.<\/p>\n

Start up<\/h2>\n

To build and run the server, we use mvn. So compilation and start can be done using the following two maven commands:<\/p>\n

mvn clean install<\/span>

<\/span>mvn exec:java<\/span><\/p>\n

now we can access our small server at localhost:5678<\/span>.<\/p>\n

Customize<\/h2>\n

Now for some more details to show you where to put server code and static content.
The project is set up using maven. That means all our java code can be found in src\/main\/java<\/span>. When we start the server, by executing mvn exec:java<\/span>, the class org.ntlx.server.Main<\/span> will be executed, which creates the http server.

<\/span><\/p>\n

package<\/span> org.ntlx.server;<\/span><\/div>\n

<\/span><\/div>\n
import<\/span> com.sun.jersey.api.container.grizzly2.GrizzlyServerFactory;<\/span><\/div>\n
import<\/span> com.sun.jersey.api.core.*;<\/span><\/div>\n

<\/span><\/div>\n
import<\/span> java.io.IOException;<\/span><\/div>\n

<\/span><\/div>\n
import<\/span> org.glassfish.grizzly.http.server.*;<\/span><\/div>\n

<\/span><\/div>\n
public <\/span>class Main {<\/span><\/span><\/div>\n

<\/span><\/div>\n
  <\/span>public<\/span> static<\/span> void<\/span> main(String args[])<\/span><\/div>\n
      <\/span>throws<\/span> IllegalArgumentException, NullPointerException, IOException {<\/span><\/div>\n
    <\/span>Main main = new<\/span> Main();<\/span><\/div>\n
    <\/span>main.startServer();<\/span><\/div>\n
  <\/span>}<\/span><\/div>\n

<\/span><\/div>\n
  <\/span>public<\/span> void<\/span> startServer() throws<\/span> IllegalArgumentException, NullPointerException, IOException {<\/span><\/div>\n
    <\/span>ResourceConfig rc = new<\/span> PackagesResourceConfig(“org.ntlx.service”<\/span>);<\/span><\/div>\n
    <\/span>HttpServer myServer = GrizzlyServerFactory.createHttpServer(“http:\/\/0.0.0.0:9876\/calc\/”<\/span>, rc);<\/span><\/div>\n
    <\/span>HttpHandler httpHandler = new<\/span> CLStaticHttpHandler(HttpServer.class<\/span>.getClassLoader(), “\/ui\/”<\/span>);<\/span><\/div>\n
    <\/span>myServer.getServerConfiguration().addHttpHandler(httpHandler, “\/”<\/span>);<\/span><\/div>\n
    <\/span>try<\/span> {<\/span><\/div>\n
      <\/span>myServer.start();<\/span><\/div>\n
      <\/span>Thread.currentThread().join();<\/span><\/div>\n
    <\/span>} catch<\/span> (Exception e) {<\/span><\/div>\n
      <\/span>System.err.println(e);<\/span><\/div>\n
    <\/span>} finally<\/span> {<\/span><\/div>\n
      <\/span>myServer.stop();<\/span><\/div>\n
    <\/span>}<\/span><\/div>\n
  <\/span>}<\/span><\/div>\n

<\/p>\n

}<\/span><\/div>\n

The http server is listening on port 9876 and is searching for service endpoints in the package org.ntlx.service<\/span>.<\/p>\n

GET endpoint<\/h3>\n
To implement the code for our service, we take a look at the example implementation of the service template. We want our GET endpoint as heartbeat to check if the backend is up and running. Therefore we want it to just return<\/div>\n
{<\/span><\/div>\n
    “getCall”: “succeeded”<\/span><\/div>\n
}<\/span><\/div>\n
The code for this simple get endpoint can be found in the class org.ntlx.service.SumService<\/span> in the function dummyGet:<\/div>\n

<\/span><\/div>\n
<\/p>\n
package<\/span> org.ntlx.service;<\/span><\/div>\n

<\/span><\/div>\n
import<\/span> com.google.gson.*;<\/span><\/div>\n
import<\/span> javax.ws.rs.*;<\/span><\/div>\n

<\/span><\/div>\n
@Path(<\/span>“sum”<\/span>)<\/span><\/span><\/div>\n
public<\/span> class<\/span> SumService {<\/span><\/div>\n

<\/span><\/div>\n
  <\/span><\/span>@GET<\/span><\/div>\n
  <\/span><\/span>@Produces<\/span>(MediaType.<\/span>APPLICATION_JSON)<\/span><\/span><\/div>\n
  <\/span>public<\/span> String dummyGet() {<\/span><\/div>\n
    <\/span>JsonObject result<\/span> = new<\/span> JsonObject();<\/span><\/div>\n
    <\/span>result<\/span>.addProperty(“getCall”<\/span>, “succeeded”<\/span>);<\/span><\/div>\n
    <\/span>return<\/span> result<\/span>.toString();<\/span><\/div>\n
  <\/span>}<\/span><\/div>\n

<\/span><\/div>\n
  …<\/span><\/div>\n
<\/div>\n
}<\/span><\/div>\n
<\/div>\n<\/div>\n
We tell the http service, that we want requests that come in to the path \/sum to be handled by this class. With the annotation @GET<\/span> we tell it, that this function shall be called by GET http requests. With the @Produces<\/span> annotation we get the http response header application\/json<\/span>. To create this simple json string, we use the Gson library.<\/p>\n<\/div>\n

POST\/PUT\/…<\/h3>\n
To create endpoints for other type of requests, we can do the same as for get. Lets have a look at the backend for our summing service, which should sum a list of numbers coming in as JSON.<\/div>\n
<\/div>\n
<\/p>\n
  <\/span>@POST<\/span><\/div>\n
  <\/span>@Produces<\/span>(MediaType.<\/span>APPLICATION_JSON)<\/span><\/span><\/div>\n
  <\/span>public<\/span> String dummyPost(String<\/span> body<\/span>) {<\/span><\/div>\n
    <\/span>CalculatorInput input<\/span> = new<\/span> Gson().fromJson(body<\/span>, CalculatorInput.class<\/span>);<\/span><\/div>\n
    <\/span>JsonObject result<\/span> = new<\/span> JsonObject();<\/span><\/div>\n
    <\/span>result<\/span>.addProperty(“result”<\/span>, input<\/span>.calculateSum());<\/span><\/div>\n
    <\/span>return<\/span> result<\/span>.toString();<\/span><\/div>\n
  <\/span>}<\/span><\/div>\n
<\/div>\n<\/div>\n

We tell the server we are listening for POST calls (the same could be done for POST, PUT, DELETE, etc.). We add a String parameter to the function, which will be filled up with the request body of the incoming POST call. To get the input, we again use GSON to instantiate an object of the CalculatorInput<\/span> class, which executes our – very complex – workload in the function call calculateSum()<\/span>.<\/p>\n

Static Content<\/h3>\n
Static content – like html files – must be located in the class path, so the http server can find it. That means we have to rebuild the jar file any time we want to change our static content. We told the http server where to search for it (\/ui\/<\/span>) and where to place it (\/<\/span>). That means we can put our static content into the folder src\/main\/resources\/ui<\/span>, and they will be included in our jar file automatically and found by the http server under the path \/. That’s why we are routed to the file created as <\/span>src\/main\/resources\/ui\/index.html<\/span> when we visit <\/span>localhost:9876<\/span> after starting the server.<\/span><\/div>","protected":false},"excerpt":{"rendered":"To get a java service running, you don’t always need to start a tomcat and deploy a war file, as described in an earlier blog post. Even if tomcat gives you a number of benefits, such as user management and database connection handling, sometimes you do not need this and just want to start up… Artikel ansehen<\/a>","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[24,5,23],"_links":{"self":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/29"}],"collection":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/comments?post=29"}],"version-history":[{"count":1,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/29\/revisions"}],"predecessor-version":[{"id":50,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/29\/revisions\/50"}],"wp:attachment":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/media?parent=29"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/categories?post=29"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/tags?post=29"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}