RESTLET開發實例

本文轉載自查看原文 2013-09-03 23:27 10984 Java/ rest

1 前提

　　由於近期工作的需要，要把RESTLET應用到項目中，於是在網上參考了一些資料的基礎上，實踐了一個關於RESTLET接口的小例子。

　　Restlet的思想是：HTTP客戶端與HTTP服務器之間的差別，對架構來說無所謂。一個軟件應可以既充當Web客戶端又充當Web服務器，而無須采用兩套完全不同的APIs。

　　Restlet提供了多個版本:Java SE、Java EE、android、Google AppEngine、Google Web Toolkit、Android。這里我們使用的是jee版本。

　　RESTLET的實現可以采用JAX-RS方式，也可以采用其他方式，見：

http://www.iteye.com/topic/85928

本例子是采用JAX-RS的API開發的，這種方式提供了一種基於注解的模型來描述分布式資源，可以利用注解的功能提供資源的位置、傳遞等。可以在一個Resource類中同時對外提供多個rest接口服務。具體的實現步驟見如下章節。

2 實例開發

2.1 工程說明

此處可以建立一個web工程，也可以建立一個JAVASE工程，如何應用就UP TO YOU了，此處的例子只是為了梳理下RESTLET的開發流程，不涉及到web界面的應用，所以就建立了一個普通的JAVASE的工程。工程的結構圖如下：

我們的工程分為如下幾個部分：Server啟動模塊、Application模塊、modle模塊、REST接口實現的resource模塊和客戶端模塊。

工程所依賴的jar包，是最基本的這個6個包，因為數據的傳輸使用的JSON，所以json包是必須的，如果想擴展功能，請自行添加其余的包。

2.2 Server端啟動部分

RestJaxRsServer類的代碼如下：

 1 package com.scott.restlet;
 2 
 3 import org.restlet.Component;
 4 import org.restlet.data.Protocol;
 5 
 6 import com.scott.restlet.application.RestJaxRsApplication;
 7 
 8 public class RestJaxRsServer {
 9     
10     public static void main(String[] args) throws Exception {
11         Component component = new Component();
12         component.getServers().add(Protocol.HTTP, 8082);
13         component.getDefaultHost().attach(new RestJaxRsApplication(null));
14         component.start();
15         
16         System.out.println("The restlet server started ...");
17     }
18 }

此代碼中指定了我們的HTTP的綁定端口，地址就是本地默認的ip。另外，代碼中有一個RestJaxRsApplication，這是每個Application能夠管理一組restlet接口。

2.3 Application部分

在application包中有兩個類，一個是RestJaxRsApplication類，繼承了org.restlet.ext.jaxrs.JaxRsApplication，作為運行類，用於初始化REST的運行環境，其代碼如下：

 1 package com.scott.restlet.application;
 2 
 3 import org.restlet.Context;
 4 import org.restlet.ext.jaxrs.JaxRsApplication;
 5 
 6 
 7 public class RestJaxRsApplication extends JaxRsApplication {
 8 
 9     public RestJaxRsApplication(Context context) {
10         super(context);
11         this.add(new MyApplication());
12     }
13 
14 }

另外一個是MyApplication，作為應用類，繼承了javax.ws.rs.core.Application，這里面綁定了我們的RESTLET的接口RESOURCE類，可以將多個資源綁定在HashSet中，代碼如下：

 1 package com.scott.restlet.application;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 import javax.ws.rs.core.Application;
 7 
 8 import com.scott.restlet.resource.StudentResource;
 9 import com.scott.restlet.resource.TeacherResource;
10 
11 public class MyApplication extends Application {
12 
13     @Override
14     public Set<Class<?>> getClasses() {
15         Set<Class<?>> resources = new HashSet<Class<?>>();
16         
17         resources.add(StudentResource.class);
18         resources.add(TeacherResource.class);
19         
20         return resources;
21     }
22 
23 }

2.4 模型部分

此實例的操作模型比較簡單，就是一個Student類和一個Teacher類，代碼如下：

Student：

 1 package com.scott.restlet.modle;
 2 
 3 public class Student {
 4 
 5     private int id;
 6     private String name;
 7     private int sex;
 8     private int age;
 9     private int grade;
10 
11     public int getGrade() {
12         return grade;
13     }
14 
15     public void setGrade(int grade) {
16         this.grade = grade;
17     }
18 
19     public int getId() {
20         return id;
21     }
22 
23     public void setId(int id) {
24         this.id = id;
25     }
26 
27     public String getName() {
28         return name;
29     }
30 
31     public void setName(String name) {
32         this.name = name;
33     }
34 
35     public int getSex() {
36         return sex;
37     }
38 
39     public void setSex(int sex) {
40         this.sex = sex;
41     }
42 
43     public int getAge() {
44         return age;
45     }
46 
47     public void setAge(int age) {
48         this.age = age;
49     }
50 }

Teacher：

 1 package com.scott.restlet.modle;
 2 
 3 public class Teacher {
 4     
 5     private int id;    
 6     private String name;
 7     private int sex;
 8     private int age;
 9     private String subject;
10     
11     public int getId() {
12         return id;
13     }
14     public void setId(int id) {
15         this.id = id;
16     }
17     public String getName() {
18         return name;
19     }
20     public void setName(String name) {
21         this.name = name;
22     }
23     public int getSex() {
24         return sex;
25     }
26     public void setSex(int sex) {
27         this.sex = sex;
28     }
29     public int getAge() {
30         return age;
31     }
32     public void setAge(int age) {
33         this.age = age;
34     }
35     public String getSubject() {
36         return subject;
37     }
38     public void setSubject(String subject) {
39         this.subject = subject;
40     }
41 }

2.5 RESOURCE部分

這部分是我們的RESTLET接口實現部分，此處我們有兩個接口實現類，一個是StudentResource，一個是TeacherResource，分別對外提供不同的REST接口服務。至於StorageOperator類，把它當做一個內存數據庫好了，其實就是一個HashMap，StudentResource和TeacherResource的操作會在StorageOperator類中具體實現。代碼如下：

StudentResource：

 1 package com.scott.restlet.resource;
 2 
 3 import javax.ws.rs.DELETE;
 4 import javax.ws.rs.GET;
 5 import javax.ws.rs.POST;
 6 import javax.ws.rs.PUT;
 7 import javax.ws.rs.Path;
 8 import javax.ws.rs.PathParam;
 9 import javax.ws.rs.Produces;
10 
11 import org.restlet.data.Form;
12 import org.restlet.representation.Representation;
13 
14 import com.scott.restlet.modle.Student;
15 
16 @Path("/TestRestlet/student/")
17 public class StudentResource {
18 
19     @GET
20     @Path("{id}/json")
21     @Produces("application/json")
22     public Student getStudentJson(@PathParam("id") int id) {
23         return StorageOperator.findStudent(id);
24     }
25 
26     @POST
27     @Path("add")
28     public String addStudent(Representation entity) {
29         
30         //get parameters from client
31         Form form = new Form(entity);
32         String name = form.getFirstValue("name");
33         int grade = Integer.parseInt(form.getFirstValue("grade"));
34         int sex = Integer.parseInt(form.getFirstValue("sex"));
35         int age = Integer.parseInt(form.getFirstValue("age"));
36         
37         Student student = new Student();
38         student.setGrade(grade);
39         student.setName(name);
40         student.setSex(sex);
41         student.setAge(age);
42         
43         int id = StorageOperator.studentID + 1;
44         student.setId(id);
45         return String.valueOf(StorageOperator.addStudent(student));
46     }
47 
48     @PUT
49     @Path("update")
50     public String updateStudent(Representation entity) {
51         Form form = new Form(entity);
52 
53         int id = Integer.parseInt(form.getFirstValue("id"));
54         Student student = StorageOperator.findStudent(id);
55 
56         if (student == null) {
57             return "null";
58         }else{
59             String name = form.getFirstValue("name");
60             int grade = Integer.parseInt(form.getFirstValue("grade"));
61             int sex = Integer.parseInt(form.getFirstValue("sex"));
62             int age = Integer.parseInt(form.getFirstValue("age"));
63 
64             student.setGrade(grade);
65             student.setName(name);
66             student.setSex(sex);
67             student.setAge(age);
68 
69             return String.valueOf(StorageOperator.updateStudent(student));
70         }
71     }
72 
73     @DELETE
74     @Path("delete/{id}")
75     public String deleteStudent(@PathParam("id") int id) {
76         int status = StorageOperator.deleteStudent(id);
77         return String.valueOf(status);
78     }
79 
80 }

TeacherResource：

 1 package com.scott.restlet.resource;
 2 
 3 import javax.ws.rs.DELETE;
 4 import javax.ws.rs.GET;
 5 import javax.ws.rs.POST;
 6 import javax.ws.rs.PUT;
 7 import javax.ws.rs.Path;
 8 import javax.ws.rs.PathParam;
 9 import javax.ws.rs.Produces;
10 
11 import org.restlet.data.Form;
12 import org.restlet.representation.Representation;
13 
14 import com.scott.restlet.modle.Teacher;
15 
16 @Path("/TestRestlet/teacher/")
17 public class TeacherResource {
18     @GET
19     @Path("{id}/json")
20     @Produces("application/json")
21     public Teacher getTeacherJson(@PathParam("id") int id) {
22         return StorageOperator.findTeacher(id);
23     }
24 
25     @POST
26     @Path("add")
27     public String addTeacher(Representation entity) {
28         
29         //get parameters from client
30         Form form = new Form(entity);
31         String name = form.getFirstValue("name");
32         String subject = form.getFirstValue("subject");
33         int sex = Integer.parseInt(form.getFirstValue("sex"));
34         int age = Integer.parseInt(form.getFirstValue("age"));
35         
36         Teacher teacher = new Teacher();
37         teacher.setSubject(subject);
38         teacher.setName(name);
39         teacher.setSex(sex);
40         teacher.setAge(age);
41         
42         int id = StorageOperator.teacherID + 1;
43         teacher.setId(id);
44         return String.valueOf(StorageOperator.addTeacher(teacher));
45     }
46 
47     @PUT
48     @Path("update")
49     public String updateTeacher(Representation entity) {
50         Form form = new Form(entity);
51 
52         int id = Integer.parseInt(form.getFirstValue("id"));
53         Teacher teacher = StorageOperator.findTeacher(id);
54 
55         if (teacher == null) {
56             return "null";
57         }else{
58             String name = form.getFirstValue("name");
59             String subject = form.getFirstValue("subject");
60             int sex = Integer.parseInt(form.getFirstValue("sex"));
61             int age = Integer.parseInt(form.getFirstValue("age"));
62 
63             teacher.setSubject(subject);
64             teacher.setName(name);
65             teacher.setSex(sex);
66             teacher.setAge(age);
67 
68             return String.valueOf(StorageOperator.updateTeacher(teacher));
69         }
70     }
71 
72     @DELETE
73     @Path("delete/{id}")
74     public String deleteTeacher(@PathParam("id") int id) {
75         int status = StorageOperator.deleteTeacher(id);
76         return String.valueOf(status);
77     }
78 }

StorageOperator：

 1 package com.scott.restlet.resource;
 2 
 3 import java.util.HashMap;
 4 
 5 import com.scott.restlet.modle.Student;
 6 import com.scott.restlet.modle.Teacher;
 7 
 8 public class StorageOperator {
 9     public static int studentID = 1;
10     public static int teacherID = 1;
11     
12     public static HashMap<Integer, Student> students = new HashMap<Integer, Student>();
13     public static HashMap<Integer, Teacher> teachers = new HashMap<Integer, Teacher>();
14     
15     static {
16         Student student = new Student();
17         student.setId(1);
18         student.setGrade(3);
19         student.setName("Scott");
20         student.setSex(0);
21         student.setAge(18);
22         students.put(student.getId(), student);
23         
24         Teacher teacher = new Teacher();
25         teacher.setId(1);
26         teacher.setSubject("MATH");
27         teacher.setName("Toney");
28         teacher.setSex(1);
29         teacher.setAge(27);
30         teachers.put(teacher.getId(), teacher);
31     }
32 
33     public static Student findStudent(int id) {
34         return students.get(id);
35     }
36 
37     public static int addStudent(Student student) {
38         students.put(student.getId(), student);
39         return student.getId();
40     }
41 
42     public static int updateStudent(Student student) {
43         return addStudent(student);
44     }
45 
46     public static int deleteStudent(int id) {
47         if (students.get(id) != null) {
48             students.remove(id);
49             return 1;
50         }
51         return 0;
52     }
53     
54     public static Teacher findTeacher(int id) {
55         return teachers.get(id);
56     }
57 
58     public static int addTeacher(Teacher teacher) {
59         teachers.put(teacher.getId(), teacher);
60         return teacher.getId();
61     }
62 
63     public static int updateTeacher(Teacher teacher) {
64         return addTeacher(teacher);
65     }
66 
67     public static int deleteTeacher(int id) {
68         if (teachers.get(id) != null) {
69             teachers.remove(id);
70             return 1;
71         }
72         return 0;
73     }
74 
75 }

在類的上面標注的PATH注解，作為全局的一個路徑變量，方法上部的PATH注解都以類注解作為相對路徑。並且，Produce表示返回的數據格式，此處是JSON類型。至於GET和POST，可以簡單的理解為：

POST /uri 創建

DELETE /uri/xxx 刪除

PUT /uri/xxx 更新或創建

GET /uri/xxx 查看

2.6 客戶端部分

客戶端的訪問REST接口，可以通過瀏覽器來輸入url訪問，也可以通過代碼來訪問，通過代碼來訪問的代碼此處封裝在了Client類中，代碼如下：

StudentOperateClient：

 1 package com.scott.restlet.client;
 2 
 3 import java.io.IOException;
 4 
 5 import org.restlet.data.Form;
 6 import org.restlet.resource.ClientResource;
 7 import org.restlet.resource.ResourceException;
 8 
 9 public class StudentOperateClient {
10     public static void testGetStudent(String url) {
11         ClientResource client = new ClientResource(url + "student/1/json");
12         try {
13             System.out.println("Student get " + client.get().getText());
14         } catch (ResourceException e) {
15             e.printStackTrace();
16         } catch (IOException e) {
17             e.printStackTrace();
18         }
19     }
20 
21     public static void testAddStudent(String url) {
22         ClientResource client = new ClientResource(url + "student/add");
23         try {
24             Form form = new Form();
25             form.add("name", "Scott007");
26             form.add("grade", "3");
27             form.add("sex", "0");
28             form.add("age", "15");
29             
30             String id = client.post(form.getWebRepresentation()).getText();
31             
32             System.out.println("Student add " + id);
33         } catch (Exception e) {
34             e.printStackTrace();
35         }
36     }
37 
38     public static void testUpdateStudent(String url) {
39         ClientResource client = new ClientResource(url + "student/update");
40         try {
41             Form form = new Form();
42             form.add("name", "Scott007");
43             form.add("grade", "4");
44             form.add("sex", "0");
45             form.add("id", "1");
46             form.add("age", "16");
47             
48             String id = client.put(form.getWebRepresentation()).getText();
49             
50             System.out.println("Student update " + id);
51         } catch (Exception e) {
52             e.printStackTrace();
53         }
54     }
55 
56     public static void testDeleteStudent(String url) {
57         ClientResource client = new ClientResource(url + "student/delete/1");
58         try {
59             System.out.println("Student delete " + client.delete().getText());
60         } catch (ResourceException e) {
61             e.printStackTrace();
62         } catch (IOException e) {
63             e.printStackTrace();
64         }
65     }
66 }

TeacherOperateClient：

 1 package com.scott.restlet.client;
 2 
 3 import java.io.IOException;
 4 
 5 import org.restlet.data.Form;
 6 import org.restlet.resource.ClientResource;
 7 import org.restlet.resource.ResourceException;
 8 
 9 public class TeacherOperateClient {
10     public static void testGetTeacher(String url) {
11         ClientResource client = new ClientResource(url + "teacher/1/json");
12         try {
13             System.out.println("Teacher get " + client.get().getText());
14         } catch (ResourceException e) {
15             e.printStackTrace();
16         } catch (IOException e) {
17             e.printStackTrace();
18         }
19     }
20 
21     public static void testAddTeacher(String url) {
22         ClientResource client = new ClientResource(url + "teacher/add");
23         try {
24             Form form = new Form();
25             
26             form.add("name", "Scott008");
27             form.add("subject", "MATH");
28             form.add("sex", "0");
29             form.add("age", "27");
30             
31             String id = client.post(form.getWebRepresentation()).getText();
32             
33             System.out.println("Teacher add " + id);
34         } catch (Exception e) {
35             e.printStackTrace();
36         }
37     }
38 
39     public static void testUpdateTeacher(String url) {
40         ClientResource client = new ClientResource(url + "teacher/update");
41         try {
42             Form form = new Form();
43             
44             form.add("age", "28");
45             form.add("name", "Scott008");
46             form.add("subject", "English");
47             form.add("sex", "0");
48             form.add("id", "1");
49             
50             String id = client.put(form.getWebRepresentation()).getText();
51             System.out.println("Teacher update " + id);
52 
53         } catch (Exception e) {
54             e.printStackTrace();
55         }
56     }
57 
58     public static void testDeleteTeacher(String url) {
59         ClientResource client = new ClientResource(url + "teacher/delete/1");
60         try {
61             System.out.println("Teacher delete " + client.delete().getText());
62         } catch (ResourceException e) {
63             e.printStackTrace();
64         } catch (IOException e) {
65             e.printStackTrace();
66         }
67     }
68 }

Client：

 1 package com.scott.restlet.client;
 2 
 3 public class Client {
 4 
 5     public static final String url = "http://localhost:8082/TestRestlet/";
 6 
 7     public static void main(String args[]){
 8         
 9         StudentOperateClient.testGetStudent(url);
10         StudentOperateClient.testUpdateStudent(url);
11         
12         TeacherOperateClient.testGetTeacher(url);
13         TeacherOperateClient.testUpdateTeacher(url);
14     }
15 }

2.7 運行

運行，得到如下結果：

服務端啟動后：

2013-9-3 23:22:51 org.restlet.engine.http.connector.HttpServerHelper start
信息: Starting the internal HTTP server on port 8082
The restlet server started ...

客戶端啟動后的客戶端信息：

2013-9-3 23:24:12 org.restlet.engine.http.connector.HttpClientHelper start
信息: Starting the default HTTP client
Student get {"id":1,"sex":0,"age":18,"name":"Scott","grade":3}
2013-9-3 23:24:12 org.restlet.engine.http.connector.HttpClientHelper start
信息: Starting the default HTTP client
Student update 1
2013-9-3 23:24:12 org.restlet.engine.http.connector.HttpClientHelper start
信息: Starting the default HTTP client
Teacher get {"id":1,"sex":1,"subject":"MATH","age":27,"name":"Toney"}
2013-9-3 23:24:12 org.restlet.engine.http.connector.HttpClientHelper start
信息: Starting the default HTTP client
Teacher update 1

客戶端啟動的服務端信息：

2013-9-3 23:22:51 org.restlet.engine.http.connector.HttpServerHelper start
信息: Starting the internal HTTP server on port 8082
The restlet server started ...
2013-9-3 23:24:12 org.restlet.engine.log.LogFilter afterHandle
信息: 2013-09-03    23:24:12    127.0.0.1    -    -    8082    GET    /TestRestlet/student/1/json    -    200    -    0    70    http://localhost:8082    Restlet-Framework/2.0.6    -
2013-9-3 23:24:12 org.restlet.engine.log.LogFilter afterHandle
信息: 2013-09-03    23:24:12    127.0.0.1    -    -    8082    PUT    /TestRestlet/student/update    -    200    1    39    4    http://localhost:8082    Restlet-Framework/2.0.6    -
2013-9-3 23:24:12 org.restlet.engine.log.LogFilter afterHandle
信息: 2013-09-03    23:24:12    127.0.0.1    -    -    8082    GET    /TestRestlet/teacher/1/json    -    200    -    0    1    http://localhost:8082    Restlet-Framework/2.0.6    -
2013-9-3 23:24:13 org.restlet.engine.log.LogFilter afterHandle
信息: 2013-09-03    23:24:13    127.0.0.1    -    -    8082    PUT    /TestRestlet/teacher/update    -    200    1    47    2    http://localhost:8082    Restlet-Framework/2.0.6    -

當然，此處的例子規模和功能都很小，是在參考了[2]的基礎上稍加改造，算是可以作為學習RESTLET的第一步吧。

3 一些可參考的網址

[1]http://whui0110.iteye.com/blog/1682388

[2]http://www.infoq.com/cn/articles/rest-introduction

[3]http://www.lifeba.org/arch/restlet_develop_jax-rs_service_1.html

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 spring整合restlet開發實踐 restlet入門搭建hello world postman VS restlet client基本使用使用Restlet Client發送各種Get和Post請求 Axis2開發實例 snmp++開發實例一 cefsharp開發實例1 Operator開發實例 Hbase開發實例簡單的iOS開發實例