Sekilas tentang REST
REST, singkatan bahasa Inggris dari representational
state transfer atau transfer keadaan representasi,
adalah suatu gaya arsitektur perangkat lunak untuk untuk pendistibusian sistem hipermedia seperti WWW. Istilah ini
diperkenalkan pertama kali pada tahun 2000 pada disertasi doktoral Roy
Fielding,
salah seorang penulis utama spesifikasi HTTP.
Istilah ini selanjutnya dipergunakan secara luas pada komunitas jaringan.
REST secara spesifik merujuk pada suatu koleksi
prinsip-prinsip arsitektur
jaringan yang
menggariskan pendefinisian dan pengalamatan sumber daya. Istilah ini sering
digunakan dengan longgar untuk mendeskripsikan semua antarmuka sederhana yang
menyampaikan data dalam domain spesifik melalui HTTP tanpa tambahan lapisan
pesan seperti SOAP atau pelacakan sesimenggunakan cookie HTTP. Dua pengertian ini dapat menimbulkan konflik dan
juga tumpang tindih. Dimungkinkan untuk merancang suatu sistem perangkat lunak besar sesuai dengan gaya arsitektur
REST Fielding tanpa menggunakan HTTP dan tanpa berinteraksi dengan WWW. Juga
dimungkinkan untuk merancang antarmuka XML+HTTP sederhana yang tidak
mengikuti prinsip-prinsip REST, tapi sebaliknya mengikuti model dari RPC (remote procedure
call). Perbedaan penggunaan istilah REST ini cukup menyebabkan permasalahan
dalam diskusi-diskusi teknis.
Sistem yang mengikuti prinsip REST Fielding sering
disebut sebagai "RESTful".
REST pada dasarnya setiap
URL unik adalah representasi dari beberapa objek. Kita dapat memperoleh
konten-konten objek tersebut menggunakan HTTP GET, untuk menghapusnya, kita
dapat menggunakan POST, PUT, atau DELETE untuk memodifikasi objek (dalam
praktiknya, kebanyakan service menggunakan POST untuk ini).
Kunci metodologi REST adalah untuk menulis web
service menggunakan antarmuka yang sudah tersedia dan banyak digunakan: URI.
Sebagai contoh, service/layanan untuk mengkonversi mata uang, yang mana seorang
user memasukkan simbol mata uang untuk mengembalikan harga mata uang secara
real-time, dapat dilakukan semudah membuat script yang dapat diakses melalui
web server seperti URI: http://www.ExampleCurrencyBrokerage.com/convert?=us-dollar&value=100&target=pound.
Aplikasi
client atau server dengan dukungan HTTP dapat dengan mudah memanggil service
tersebut dengan command HTTP GET. Berdasar pada bagaimana cara penyedia service
menulis script, hasil respons HTTP kan menjadi lebih simpel seperti beberapa
header standar dan string teks yang mengandung harga terkini untuk symbol yang
diberikan. Atau, dapat berupa dokumen XML.
(dikutip dari Wikipedia )
Pada tulisan kali ini akan kita coba membuat REST webservice
menggunakan framework Spring MCV dan Maven.
IDE yang digunakan adalah Spring Tools Suite. Jika belum ada
dapat didownload disini …link.
IDE ini memudahkan kita membuat aplikasi Spring MVC karena
sudah tersedia plugin nya dan kita tidak perlu susah dalam mengimport library spring
yang akan digunakan. IDE ini akan mencreate pom.xml sudah lengkap dengan
dependency library dari spring mvc. Dependency library akan otomatis didownload
begitu project di create.
Langkah pertama, buat spring mvc project dari spring tools suite. Pilih New -> Spring Project.
Maka otomatis akan tercreate project dengan struktur maven
seperti dibawah ini.
Pom.xml akan otomatis tercreate lengkap dengan dependency nya.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.sample</groupId>
<artifactId>springmvc</artifactId>
<name>sample-spring-mvc-rest</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.6</java-version>
<org.springframework-version>3.2.0.RELEASE</org.springframework-version>
<org.aspectj-version>1.6.10</org.aspectj-version>
<org.slf4j-version>1.6.6</org.slf4j-version>
</properties>
<dependencies>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.15</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
Kemudian kita buat dulu class entity yang nantinya kita
pakai sebagai contoh data akan dimanipulasi oleh REST yang nanti kita buat.
Misalnya kita buat entity Student.
public class Student {
private Integer id ;
private String firstName;
private String lastName;
private String address;
public Student(){
}
public Student(Integer id, String firstName, String lastName, String address) {
super();
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.address = address;
}
// setter getter
Selanjutnya kita buat class controller yang digunakan untuk menampung method method operation dari Rest.
Misalnya kita buat StudentController.
Method Delete
@Controller
@RequestMapping("/student")
public class StudentController {
private List<Student> students = new ArrayList<Student>();
/**
* initial sample data student
*/
private void initialStudent(){
students.add(new Student(1, "andri", "sasuke", "alamat 1"));
students.add(new Student(2, "susi", "susanti", "alamat 2"));
students.add(new Student(3, "budi", "setiawan", "alamat 3"));
}
/**
* sample update student
*/
private void updateStudent(Student student){
students.get(student.getId()).setFirstName(student.getFirstName());
students.get(student.getId()).setLastName(student.getLastName());
students.get(student.getId()).setAddress(student.getAddress());
}
Spring MVC menyediakan baberapa
annotation untuk mengatur komunikasi Http
@Controller : Deklarasi Spring
MVC Controller
@RequestMapping("/student")
--> Map URI dengan controller atau method
@PathVariable --> membaca
variable di Url dan mengirimkan nilainya ke class java
@RequestBody --> Deklarasi
Pojo (entity) yang akan dikirim ke controller
@ResponseBody --> Deklarasi
Pojo (entity) untuk generate Json content yg akan dikirim ke http client
Kita tambahkan dulu dependency JSON mapper di pom.xml untuk
generate JSON
<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-mapper-asl</artifactId>
<version>1.7.1</version>
</dependency>
Kita akan coba buat operasi Rest untuk Get, insert, update,
delete data di StudentController.
1.
Method Get data
Menggunakan RequestMethod GET
@RequestMapping(value="/findAll",method = RequestMethod.GET)
public @ResponseBody List<Student> getAllStudent(){
return students;
}
2.
Method Insert
Menggunakan RequestMethod POST
@RequestMapping(value="/add",method = RequestMethod.POST)
public @ResponseBody void addStudent(@RequestBody Student student){
// do something to add student
students.add(student);
}
3.
Method Update
Menggunakan RequestMethod PUT
@RequestMapping(value="/edit",method = RequestMethod.PUT)
public @ResponseBody void editStudent(@RequestBody Student student){
// do something to update student
updateStudent(student);
}
Method Delete
Menggunakan RequestMethod DELETE
Dengan demikian sample Rest web service kita sudah selesai, tinggal mengetesnya saja.
@RequestMapping(value="/delete/{id}",method = RequestMethod.DELETE)
public @ResponseBody void deleteStudent(@PathVariable(value="id") int id){
// do something to delete student
students.remove(id);
}
Dengan demikian sample Rest web service kita sudah selesai, tinggal mengetesnya saja.
Test method Rest
Run terlebih dulu aplikasi yang sudah kita buat dengan menggunakan jetty -> mvn jetty:run
Run terlebih dulu aplikasi yang sudah kita buat dengan menggunakan jetty -> mvn jetty:run
Untuk melakukan testing pada Rest yang sudah kita buat bisa
menggunakan addOns dari firefox : RestClient. (https://addons.mozilla.org/en-US/firefox/addon/restclient/)
Untuk method GET bisa juga kita coba langsung di
browser bisa dengan mengakses Url nya.
Misalnya untuk menampilkan semua Student (http://localhost:8087/student/findAll)
Maka akan tampil output seperti dibawah ini
Kemudian kita masukkan data student dalam format JSON di form Body.
Maka akan tampil output seperti dibawah ini
[{"id":1,"firstName":"andri","lastName":"sasuke","address":"alamat 1"},{"id":2,"firstName":"susi","lastName":"susanti","address":"alamat 2"},{"id":3,"firstName":"budi","lastName":"setiawan","address":"alamat 3"}]
Tapi untuk method POST atau PUT harus menggunakan RestClient
atau semacamnya.
Untuk test POST data lewat RestClient kita set dulu
parameter Content-Type:application/json.
Pilih
Method : POST
Kemudian kita masukkan data student dalam format JSON di form Body.
{"id":4,"firstName":"orang ke 4","lastName":"last name ke 4","address":"alamat 4"}
Kita
test lagi GET data, maka data student akan bertambah
[{"id":1,"firstName":"andri","lastName":"sasuke","address":"alamat 1"},{"id":2,"firstName":"susi","lastName":"susanti","address":"alamat 2"},{"id":3,"firstName":"budi","lastName":"setiawan","address":"alamat 3"},{"id":4,"firstName":"orang ke 4","lastName":"last name ke 4","address":"alamat 4"}]
Untuk
PUT data prosesnya juga sama. Pilih Method : POST
Kemudian
kita masukkan data student yang akan diupdate dalam format JSON di form Body.
Kita GET data lagi maka data dengan index ke-1 akan terdelete
Sekian dulu. Mudah dan simple kan buat Rest web service itu.
Selamat mencoba
Thanks :)
{"id":1,"firstName":"edit first name1","lastName":"edit last name ke 1","address":"alamat 1"}
Kalau
kita GET lagi maka data student akan berubah.
[{"id":1,"firstName":"andri","lastName":"sasuke","address":"alamat 1"},{"id":2,"firstName":"edit first name1","lastName":"edit last name ke 1","address":"alamat 1"},{"id":3,"firstName":"budi","lastName":"setiawan","address":"alamat 3"},{"id":4,"firstName":"orang ke 4","lastName":"last name ke 4","address":"alamat 4"}]
Untuk
delete data kita menggunakan @PathVariable untuk mengambil value dari Url
misalnya id
Kita GET data lagi maka data dengan index ke-1 akan terdelete
[{"id":1,"firstName":"andri","lastName":"sasuke","address":"alamat 1"},{"id":3,"firstName":"budi","lastName":"setiawan","address":"alamat 3"},{"id":4,"firstName":"orang ke 4","lastName":"last name ke 4","address":"alamat 4"}]
Sekian dulu. Mudah dan simple kan buat Rest web service itu.
Selamat mencoba
Thanks :)
