CXF Rest Server

研究了两天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;
3. import javax.xml.bind.annotation.XmlRootElement;
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. }
22. }

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

Java代码

1. import java.util.Map;
3. import javax.xml.bind.annotation.XmlRootElement;
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;
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;
3. import java.util.HashMap;
4. import java.util.Map;
6. public class RoomDAO {
7. private static Map<String, Room> rooms;
8. static {
9. rooms = new HashMap<String, Room>();
11. //this room is for testing
12. Person p1=new Person();
13. p1.setName("Boris");
14. p1.setSex("male");
18. Room r=new Room();
19. r.setId("001");
20. r.getPersons().put(p1.getName(), p1);
21. rooms.put("001", r);
22. }
24. public static void addRoom(Room room) {
25. rooms.put(room.getId(), room);
26. }
28. public static void deleteRoom(String id) {
29. if (rooms.containsKey(id)) {
30. rooms.remove(id);
31. }
33. }
35. public static void updateRoom(String id,Room room) {
36. rooms.remove(id);
37. rooms.put(room.getId(), room);
38. }
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. }
56. public static Rooms getRooms()
57. {
58. return new Rooms();
59. }
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. }
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;
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;
12. import com.DAO.Person;
13. import com.DAO.Room;
14. import com.DAO.RoomDAO;
15. import com.DAO.Rooms;
17. @Path("/roomservice")
18. @Produces("application/xml")
19. public class RoomService {
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. }
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;
3. import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;
5. import com.DAO.Person;
6. import com.DAO.Room;
7. import com.DAO.Rooms;
9. public class Server {
11. public static void main(String[] args) {
12. RoomService service = new RoomService();
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;
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