RESTful Web Service 与CXF 学习笔记

研究了两天CXF对restful的支持。
  现在，想实现一个以
http://localhost:9999/roomservice 为入口，
http://localhost:9999/roomservice/room为房间列表,
http://localhost:9999/roomservice/room/001/ 为001号房间的信息，
http://localhost:9999/roomservice/room/001/person 为在001号房间主的人的列表

  实现用HTTP请求对以上资源的CRUD。

  首先建立room,person的POJO，这里只有一点需要注意：

Java代码  

1. package com.DAO;  
2.   
3. import javax.xml.bind.annotation.XmlRootElement;  
4.   
5. @XmlRootElement(name="Person")  
6. public class Person {  
7.     private String name;  
8.     private String sex;  
9.     public String getName() {  
10.         return name;  
11.     }  
12.     public void setName(String name) {  
13.         this.name = name;  
14.     }  
15.     public String getSex() {  
16.         return sex;  
17.     }  
18.     public void setSex(String sex) {  
19.         this.sex = sex;  
20.     }  
21.       
22. }  

  一定要在类的前边加上annotation ，这样才能让这个person的信息在POJO和XML之间转换。Room同理:

Java代码  

1. import java.util.Map;  
2.   
3. import javax.xml.bind.annotation.XmlRootElement;  
4.   
5. @XmlRootElement(name="Room")  
6. public class Room {  
7.     public Room()  
8.     {  
9.         persons=new HashMap<String,Person>();  
10.     }  
11.     String id;  
12.     Map<String,Person> persons;  
13.       
14.     public String getId() {  
15.         return id;  
16.     }  
17.     public void setId(String id) {  
18.         this.id = id;  
19.     }  
20.     public Map<String, Person> getPersons() {  
21.         return persons;  
22.     }  
23.     public void setPersons(Map<String, Person> persons) {  
24.         this.persons = persons;  
25.     }  
26. }  

POJO有了，接下来要写DAO，由于主要是为了学习restful，为了方便，不必要将数据持久化到数据库，而是存在一个静态的HashMap中：

Java代码  

1. package com.DAO;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5.   
6. public class RoomDAO {  
7.     private static Map<String, Room> rooms;  
8.     static {  
9.         rooms = new HashMap<String, Room>();  
10.           
11.         //this room is for testing  
12.         Person p1=new Person();  
13.         p1.setName("Boris");  
14.         p1.setSex("male");  
15.           
16.           
17.           
18.         Room r=new Room();  
19.         r.setId("001");  
20.         r.getPersons().put(p1.getName(), p1);  
21.         rooms.put("001", r);  
22.     }  
23.   
24.     public static void addRoom(Room room) {  
25.         rooms.put(room.getId(), room);  
26.     }  
27.   
28.     public static void deleteRoom(String id) {  
29.         if (rooms.containsKey(id)) {  
30.             rooms.remove(id);  
31.         }  
32.   
33.     }  
34.   
35.     public static void updateRoom(String id,Room room) {  
36.         rooms.remove(id);  
37.         rooms.put(room.getId(), room);  
38.     }  
39.   
40.     public static Room getRoom(String id) {  
41.         if (rooms.containsKey(id)) {  
42.             return rooms.get(id);  
43.         } else {  
44.             return null;  
45.         }  
46.     }  
47.     /*operations to persons*/  
48.     public static void addPerson(String id_room,Person person) {  
49.         if(rooms.containsKey(id_room))  
50.         {  
51.             Room room=rooms.get(id_room);  
52.             room.getPersons().put(person.getName(), person);  
53.         }  
54.     }  
55.       
56.     public static Rooms getRooms()  
57.     {  
58.         return new Rooms();  
59.     }  
60.       
61.     public static void deletePerson(String id_room,String name)  
62.     {  
63.         if(rooms.containsKey(id_room))  
64.         {  
65.             Room room=rooms.get(id_room);  
66.             room.getPersons().remove(name);  
67.         }  
68.     }  
69.       
70.     public static Map<String, Room> getMapOfRooms()  
71.     {  
72.         return rooms;  
73.     }  
74. }  

接下来是重点，如果想发布restful webservice，要通过一个叫JAXRSServerFactoryBean的类来发布。这个类有几个方法是要了解的：

public void setResourceClasses(Class... classes);
那一系列的Class类型的参数，是告诉这个类，发布服务时，会用到的POJO（就像上边写的Room,Person）。

public void setAddress(String address)；
这个方法是告诉这个类，服务的地址，比如"http://localhost:9999"

public void setServiceBeans(Object... beans)
这里是重点，这个方法，要给这个用来发布服务的类一个Service bean.这个Bean是我们要手动编写的，作用是告诉服务，收到什么样的请求，应该怎么样处理。

现在，先来编写这个Service bean：

Java代码  

1. package com.server;  
2.   
3. import javax.ws.rs.Consumes;  
4. import javax.ws.rs.DELETE;  
5. import javax.ws.rs.GET;  
6. import javax.ws.rs.POST;  
7. import javax.ws.rs.PUT;  
8. import javax.ws.rs.Path;  
9. import javax.ws.rs.PathParam;  
10. import javax.ws.rs.Produces;  
11.   
12. import com.DAO.Person;  
13. import com.DAO.Room;  
14. import com.DAO.RoomDAO;  
15. import com.DAO.Rooms;  
16.   
17. @Path("/roomservice")  
18. @Produces("application/xml")  
19. public class RoomService {  
20.       
21.     @GET  
22.     @Path("/room/{id}")  
23.     @Consumes("application/xml")  
24.     public Room getRoom(@PathParam("id")String id )  
25.     {  
26.         System.out.println("get room by id= "+id);  
27.         Room room=RoomDAO.getRoom(id);  
28.         return room;  
29.     }  
30.     @GET  
31.     @Path("/room")  
32.     @Consumes("application/xml")  
33.     public Rooms getAllRoom()  
34.     {  
35.         System.out.println("get all room");  
36.         Rooms rooms=RoomDAO.getRooms();  
37.         return rooms;  
38.     }  
39.       
40.     @POST  
41.     @Path("/room")  
42.     @Consumes("application/xml")  
43.     public void addRoom(Room room)  
44.     {  
45.         System.out.println("add room which id is:"+room.getId());  
46.         RoomDAO.addRoom(room);  
47.     }  
48.     @PUT  
49.     @Path("/room/{id}")  
50.     @Consumes("application/xml")  
51.     public void updateRoom(@PathParam("id")String id,Room room)  
52.     {  
53.         System.out.println("update room which original id is:"+room.getId());  
54.         RoomDAO.updateRoom(id,room);  
55.     }  
56.     @DELETE  
57.     @Path("/room/{id}")  
58.     @Consumes("application/xml")  
59.     public void deleteRoom(@PathParam("id")String id)  
60.     {  
61.         System.out.println("remove room by id= "+id);  
62.         RoomDAO.deleteRoom(id);  
63.     }  
64.     @POST  
65.     @Path("/room/{id}")  
66.     @Consumes("application/xml")  
67.     public void addPerson(@PathParam("id") String id,Person person)  
68.     {  
69.         System.out.println("add person who's name is:"+person.getName());  
70.         RoomDAO.addPerson(id, person);  
71.     }  
72.     @DELETE  
73.     @Path("/room/{id}/{name}")  
74.     @Consumes("application/xml")  
75.     public void deletePerson(@PathParam("id")String id,@PathParam("name")String name)  
76.     {  
77.         System.out.println("remove person who's name is: "+name);  
78.         RoomDAO.deletePerson(id, name);  
79.     }  
80. }  

需要注意：每个方法之前，要用annotation声明http请求的method类型，比如GET,DELETE,POST, PUT.
@Produces("application/xml")我还没弄清楚到底是声明的接受格式还是返回格式，还是其他。

@Path("/room/{id}")中的id是一个参数，应该在方法的参数列表中声明：
public void deletePerson(@PathParam("id")String id,@PathParam("name")String name)
这样就能得到URL中的id了。

现在，这些房间被资源化了，id为001的房间被资源化为一个URL，那地址应该是
http:{服务器地址}:{端口}/roomservice/rrom/001  

现在，创建一个Server：

Java代码  

1. package com.server;  
2.   
3. import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;  
4.   
5. import com.DAO.Person;  
6. import com.DAO.Room;  
7. import com.DAO.Rooms;  
8.   
9. public class Server {  
10.   
11.     public static void main(String[] args) {  
12.         RoomService service = new RoomService();  
13.   
14.         // Service instance  
15.         JAXRSServerFactoryBean restServer = new JAXRSServerFactoryBean();  
16.         restServer.setResourceClasses(Room.class,Person.class,Rooms.class);  
17.         restServer.setServiceBeans(service);  
18.         restServer.setAddress("http://localhost:9999/");  
19.         restServer.create();  
20.     }  
21. }  

现在，服务已经发布成功了，在浏览器输入http://localhost:9999/roomservice/room/001  得到结果：

Xml代码  

1. <room>  
2. <id>001</id>  
3. −  
4. <persons>  
5. −  
6. <entry>  
7. <key>Boris</key>  
8. −  
9. <value>  
10. <name>Boris</name>  
11. <sex>male</sex>  
12. </value>  
13. </entry>  
14. </persons>  
15. </room>  

如果用浏览器去访问，发送的http请求只能所GET,因此如果想对数据进行操作，必须写一个客户端。
在写客户端之前，有一个问题：
在浏览器输入http://localhost:9999/roomservice/room/
什么都看不到，可是，我想要得到房间列表。但是，cxf发布restful只认你给他的类的class。所以你想让服务器返回一个room的列表给客户端，是不行的。所以，必须想别的办法，我是又写了一个POJO，这个POJO里只有一个属性，就是一个存放所有room的Map：
package com.DAO;

Java代码  

1. import java.util.Map;  
2.   
3. import javax.xml.bind.annotation.XmlRootElement;  
4. @XmlRootElement(name="rooms")  
5. public class Rooms {  
6.     Map<String,Room> rooms;  
7.     public Rooms()  
8.     {  
9.         rooms=RoomDAO.getMapOfRooms();  
10.     }  
11.     public Map<String, Room> getRooms() {  
12.         return rooms;  
13.     }  
14.     public void setRooms(Map<String, Room> rooms) {  
15.         this.rooms = rooms;  
16.     }  
17. }  

这样，然后再把DAO的方法加上：

Java代码  

1. @GET  
2.     @Path("/room")  
3.     @Consumes("application/xml")  
4.     public Rooms getAllRoom()  
5.     {  
6.         System.out.println("get all room");  
7.         Rooms rooms=RoomDAO.getRooms();  
8.         return rooms;  
9.     }  

这样就能以list的形式显示出所有room了。
访问http://localhost:9999/roomservice/room/
结果如下：

Xml代码  

1. <rooms>  
2. −  
3. <rooms>  
4. −  
5. <entry>  
6. <key>006</key>  
7. −  
8. <value>  
9. <id>006</id>  
10. <persons/>  
11. </value>  
12. </entry>  
13. −  
14. <entry>  
15. <key>001</key>  
16. −  
17. <value>  
18. <id>001</id>  
19. −  
20. <persons>  
21. −  
22. <entry>  
23. <key>Boris</key>  
24. −  
25. <value>  
26. <name>Boris</name>  
27. <sex>male</sex>  
28. </value>  
29. </entry>  
30. </persons>  
31. </value>  
32. </entry>  
33. </rooms>  
34. </rooms>  

关于客户端 http://sunbo1591.iteye.com/blog/766029

学习资源　http://cxf.apache.org/docs/overview.html