Create Simple REST web service dengan Spring MVC + Maven

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.

 @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

 @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

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

 [{"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.

Masukkan url Restnya http://localhost:8087/student/addStudent

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

Masukkan url Restnya http://localhost:8087/student/editStudent

Kemudian kita masukkan data student yang akan diupdate dalam format JSON di form Body.

 {"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

Masukkan url http://localhost:8087/student/deleteStudent/1

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 :)

andri sasuke

Create Simple REST web service dengan Spring MVC + Maven

0 comments:

Post a Comment

Labels

About Me

Blog Archive

Life traffic