More than a decade after its introduction, REST has become one of the most important technologies for Web applications. Its importance is likely to continue growing quickly as all technologies move towards an API orientation. This simple tutorial will help you build in less than 5 minutes a REST web services implementation using JAVA.
Tools that I used:
- Netbeans
- Maven (Contained
in Netbeans)
- Spring boot (Auto
downloaded by Maven)
Step 1. Create a new project.
Open
Netbeans and select New project -> Maven -> Java Application.
Give to
your project a decent name, path, package name and hit finish.
This should
create for you an empty maven project.
In case you
want to skip Netbeans for project creation, navigate to maven and run :
mvn
archetype:generate -DgroupId=my.package -DartifactId=myProjectName
-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
Step 2. Add spring boot.
Spring boot
will actually do the whole job here. It will attach to your project Apache
Tomcat and do all the dirty work behind the scenes.
The spring
boot package that you need is spring-boot-starter-web. You can add it to your
project either from NetBeans by right clicking the dependencies folder and then selecting add dependency or just open your pom.xml and add:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>1.1.9.RELEASE</version>
</dependency>
</dependencies>
Note: You
don’t have to use the same version (1.1.9.RELEASE). I used this because it was
the last one.
After
adding spring boot, navigate to it’s website (http://projects.spring.io/spring-boot/)
and you will see there a nice sample Java class named SampleController. As you
can see the specific Class declares a simple REST web service that listens on
port 8080 on localhost/ .
Copy it as
it is into your project and modify it writing the following:
import
org.springframework.boot.*;
import
org.springframework.boot.autoconfigure.*;
import
org.springframework.http.MediaType;
import
org.springframework.stereotype.*;
import
org.springframework.web.bind.annotation.*;
@Controller
@EnableAutoConfiguration
public
class SampleController {
@RequestMapping(value = "/",
method = RequestMethod.GET,
produces =
MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
Person home() {
Person p = new Person();
p.setFirstName("Agis");
p.setLastName("Kefalinos");
return p;
}
@RequestMapping(value = "/who",
method = RequestMethod.POST,
produces =
MediaType.TEXT_PLAIN_VALUE,
consumes =
MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
String who(@RequestBody Person p,
@RequestParam(value = "action", required = false) String action) {
return action + " " +
p.getFirstName();
}
public static void main(String[] args)
throws Exception {
SpringApplication.run(SampleController.class, args);
}
}
Also Add
the following helper Class:
public
class Person {
private String firstName;
private String lastName;
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName)
{
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}
This will
actually add to your project the following:
- A REST
GET method that listens at localhost:8080/ and returns a Person POJO as JSON
like: {"firstName":"Agis","lastName":"Kefalinos"}
- A REST POST
method that listens at localhost:8080/who that consumes a Person POJO and uses
an optional query parameter named action . The response of that WS is the concatenation
of the query parameter plus the first name of the POSO Person.
Now that we
finished with a typical business logic we can actually run our project and see
the results.
Step 3. Create a runnable single Jar.
If we run
it inside Netbeans it will run without any problem and do the trick. The problem will come if we try to run it from command like “java –jar myproject.jar”.
Doing so we will have
2 problems:
1) The jar
does not know which method is the MAIN and we have to provide it to maven. To
do it just add to pom.xml under plugins:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5</version>
<configuration>
<source>${jdk.version}</source>
<target>${jdk.version}</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.5</version>
<configuration>
<archive>
<manifest>
<mainClass>my.package.SampleController</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
Note:
Replace my.package.SampleController with your main’s full Class name.
2) The
second problem is that the spring boot is not at your class path so the jar as
it is will not run. An interesting way to bypass this problem is to build your app
having all other dependencies included into your jar. Of course that will
increase the size of you jar but sometimes this is the way to go.
To do it you will need to add to pom.xml under plugins the following:
<plugin>
<groupId>org.dstovall</groupId>
<artifactId>onejar-maven-plugin</artifactId>
<version>1.4.4</version>
<executions>
<execution>
<goals>
<goal>one-jar</goal>
</goals>
</execution>
</executions>
</plugin>
Also add to
your pom.xml under project the following:
<pluginRepositories>
<pluginRepository>
<id>onejar-maven-plugin.googlecode.com</id>
<url>http://onejar-maven-plugin.googlecode.com/svn/mavenrepo</url>
</pluginRepository>
</pluginRepositories>
Rebuild
your project and you will notice that apart from your myproject.jar another jar
is created named myproject.one-jar.jar. This jar will contain all the needed
libraries for your project to run.
Open your console and hit “java –jar myproject.jar”.
Then open your favorite browser and navigate to http://localhost:8080/
.
No comments:
Post a Comment