研究了两天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，这里只有一点需要注意：
package com.DAO;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name="Person")
public class Person {
private String name;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
一定要在类的前边加上annotation ，这样才能让这个person的信息在POJO和XML之间转换。Room同理:
import java.util.Map;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name="Room")
public class Room {
public Room()
{
persons=new HashMap<String,Person>();
}
String id;
Map<String,Person> persons;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Map<String, Person> getPersons() {
return persons;
}
public void setPersons(Map<String, Person> persons) {
this.persons = persons;
}
}
POJO有了，接下来要写DAO，由于主要是为了学习restful，为了方便，不必要将数据持久化到数据库，而是存在一个静态的HashMap中：
package com.DAO;
import java.util.HashMap;
import java.util.Map;
public class RoomDAO {
private static Map<String, Room> rooms;
static {
rooms = new HashMap<String, Room>();
Person p1=new Person();
p1.setName("Boris");
p1.setSex("male");
Room r=new Room();
r.setId("001");
r.getPersons().put(p1.getName(), p1);
rooms.put("001", r);
}
public static void addRoom(Room room) {
rooms.put(room.getId(), room);
}
public static void deleteRoom(String id) {
if (rooms.containsKey(id)) {
rooms.remove(id);
}
}
public static void updateRoom(String id,Room room) {
rooms.remove(id);
rooms.put(room.getId(), room);
}
public static Room getRoom(String id) {
if (rooms.containsKey(id)) {
return rooms.get(id);
} else {
return null;
}
}
/*operations to persons*/
public static void addPerson(String id_room,Person person) {
if(rooms.containsKey(id_room))
{
Room room=rooms.get(id_room);
room.getPersons().put(person.getName(), person);
}
}
public static Rooms getRooms()
{
return new Rooms();
}
public static void deletePerson(String id_room,String name)
{
if(rooms.containsKey(id_room))
{
Room room=rooms.get(id_room);
room.getPersons().remove(name);
}
}
public static Map<String, Room> getMapOfRooms()
{
return rooms;
}
}
接下来是重点，如果想发布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：
package com.server;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import com.DAO.Person;
import com.DAO.Room;
import com.DAO.RoomDAO;
import com.DAO.Rooms;
@Path("/roomservice")
@Produces("application/xml")
public class RoomService {
@GET
@Path("/room/{id}")
@Consumes("application/xml")
public Room getRoom(@PathParam("id")String id )
{
System.out.println("get room by id= "+id);
Room room=RoomDAO.getRoom(id);
return room;
}
@GET
@Path("/room")
@Consumes("application/xml")
public Rooms getAllRoom()
{
System.out.println("get all room");
Rooms rooms=RoomDAO.getRooms();
return rooms;
}
@POST
@Path("/room")
@Consumes("application/xml")
public void addRoom(Room room)
{
System.out.println("add room which id is:"+room.getId());
RoomDAO.addRoom(room);
}
@PUT
@Path("/room/{id}")
@Consumes("application/xml")
public void updateRoom(@PathParam("id")String id,Room room)
{
System.out.println("update room which original id is:"+room.getId());
RoomDAO.updateRoom(id,room);
}
@DELETE
@Path("/room/{id}")
@Consumes("application/xml")
public void deleteRoom(@PathParam("id")String id)
{
System.out.println("remove room by id= "+id);
RoomDAO.deleteRoom(id);
}
@POST
@Path("/room/{id}")
@Consumes("application/xml")
public void addPerson(@PathParam("id") String id,Person person)
{
System.out.println("add person who's name is:"+person.getName());
RoomDAO.addPerson(id, person);
}
@DELETE
@Path("/room/{id}/{name}")
@Consumes("application/xml")
public void deletePerson(@PathParam("id")String id,@PathParam("name")String name)
{
System.out.println("remove person who's name is: "+name);
RoomDAO.deletePerson(id, name);
}
}
需要注意：每个方法之前，要用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：
package com.server;
import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;
import com.DAO.Person;
import com.DAO.Room;
import com.DAO.Rooms;
public class Server {
public static void main(String[] args) {
RoomService service = new RoomService();
// Service instance
JAXRSServerFactoryBean restServer = new JAXRSServerFactoryBean();
restServer.setResourceClasses(Room.class,Person.class,Rooms.class);
restServer.setServiceBeans(service);
restServer.setAddress("http://localhost:9999/");
restServer.create();
}
}
现在，服务已经发布成功了，在浏览器输入http://localhost:9999/roomservice/room/001 得到结果：
<room>
<id>001</id>
−
<persons>
−
<entry>
<key>Boris</key>
−
<value>
<name>Boris</name>
<sex>male</sex>
</value>
</entry>
</persons>
</room>
如果用浏览器去访问，发送的http请求只能所GET,因此如果想对数据进行操作，必须写一个客户端。
在写客户端之前，有一个问题：
在浏览器输入http://localhost:9999/roomservice/room/
什么都看不到，可是，我想要得到房间列表。但是，cxf发布restful只认你给他的类的class。所以你想让服务器返回一个room的列表给客户端，是不行的。所以，必须想别的办法，我是又写了一个POJO，这个POJO里只有一个属性，就是一个存放所有room的Map：
package com.DAO;
import java.util.Map;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name="rooms")
public class Rooms {
Map<String,Room> rooms;
public Rooms()
{
rooms=RoomDAO.getMapOfRooms();
}
public Map<String, Room> getRooms() {
return rooms;
}
public void setRooms(Map<String, Room> rooms) {
this.rooms = rooms;
}
}
这样，然后再把DAO的方法加上：
@GET
@Path("/room")
@Consumes("application/xml")
public Rooms getAllRoom()
{
System.out.println("get all room");
Rooms rooms=RoomDAO.getRooms();
return rooms;
}
这样就能以list的形式显示出所有room了。
访问http://localhost:9999/roomservice/room/
结果如下：
<rooms>
−
<rooms>
−
<entry>
<key>006</key>
−
<value>
<id>006</id>
<persons/>
</value>
</entry>
−
<entry>
<key>001</key>
−
<value>
<id>001</id>
−
<persons>
−
<entry>
<key>Boris</key>
−
<value>
<name>Boris</name>
<sex>male</sex>
</value>
</entry>
</persons>
</value>
</entry>
</rooms>
</rooms>
关于客户端
http://borissun.iteye.com/blog/766029
分享到：
相关推荐
【标题】：“利用CXF发布RESTful WebService研究” 在当今的互联网开发中，RESTful Web Service已经成为一种广泛采用的接口设计模式，它基于HTTP协议，以资源为中心，通过统一的URI（Uniform Resource Identifier）...
【CXF发布RESTful WebService】 RESTful WebService是一种基于HTTP协议的Web服务设计风格，它强调资源的表示和操作，通过HTTP方法（GET、POST、PUT、DELETE）来执行对资源的操作。Apache CXF是一个流行的开源Java...
用CXF开发RESTful风格WebService.doc
SpringBoot+Mybatis+CXF框架，实现Restful api与 WebService api接口的大实验 本实验的主要目标是使用SpringBoot、Mybatis和CXF框架来实现Restful API和WebService API接口的大实验。下面是实验的详细介绍： 标题...
通过这个项目，开发者可以学习如何在MyEclipse环境中配置和运行CXF RESTful Web服务，了解如何在Tomcat服务器上部署服务，以及如何设计和实现RESTful API。此外，还可以深入了解RESTful设计原则及其在实际项目中的...
总之，通过将CXF与Spring框架集成，我们可以利用Spring的强大功能来管理和配置服务，同时利用CXF的灵活性来快速开发RESTful接口。这种组合为Java开发者提供了一个高效且可扩展的解决方案，用于构建现代化的、基于...
本项目聚焦于利用CXF与Spring框架集成，实现RESTful风格的Web服务。REST（Representational State Transfer）是一种轻量级、基于HTTP协议的架构风格，适用于构建可伸缩的、高性能的Web应用。 首先，让我们深入理解...
服务器端的CXF会自动将这些数据反序列化为Java对象。 为了更好地理解这个过程，可以从提供的"webservice"压缩包文件中查看示例代码。通常，这个压缩包可能包含以下内容： - 服务端的Spring Boot项目，包括pom.xml...
使用cxf、spring构建的rest风格webservice，其他相关技术springmvc、mybatis、druid等。代码中使用的数据库为sybase，请根据实际环境更改，需修改pom中引用的数据库驱动，依照entity类的属性建对应表，并修改config....
首先，"5-采用CXF框架发布webservice.avi"这个视频很可能详细介绍了使用CXF的基本步骤。发布一个Web服务通常包括以下过程： 1. **环境准备**：确保你的开发环境中已经安装了Java SDK和Maven或Gradle等构建工具，...
使用CXF开发RESTful服务，我们可以利用JAX-RS（Java API for RESTful Web Services）规范，它是Java平台上的RESTful服务开发标准。 **三、CXF与JAX-RS** JAX-RS提供了一组注解，如`@Path`、`@GET`、`@POST`、`@PUT...
在IT行业中，CXF是一个广泛使用的开源框架，用于构建和开发Web服务，包括SOAP和RESTful接口。本篇文章将深入探讨如何使用CXF、Spring、Maven等技术栈来发布一个支持HTTP请求和SOAP调用的RestFul接口。 首先，我们...
将CXF与Spring集成，可以充分利用两者的优势，实现高效、灵活的RESTful服务。 本项目主要展示了如何使用CXF和Spring构建一个能够以JSON格式返回数据的RESTful WebService接口。JSON（JavaScript Object Notation）...
本文将深入探讨如何使用Spring和CXF来发布WebService服务。 首先，Spring是一个开源的Java平台，它提供了全面的编程和配置模型，用于简化企业级应用的开发。Spring框架的核心特性包括依赖注入、面向切面编程（AOP）...
1. **服务器端Web服务发布**：CXF允许开发者通过JAX-WS或JAX-RS接口定义服务，然后自动暴露为SOAP或RESTful服务。SpringBoot结合CXF，可以轻松将服务发布到内嵌的Servlet容器中。 2. **客户端Web服务调用**：CXF还...
Apache CXF是一个开源的Web服务框架，支持SOAP、RESTful等不同风格的服务。它允许开发者以Java注解或XML方式定义服务接口，并提供了丰富的客户端和服务端工具。 3. **整合过程** - 首先，我们需要在`pom.xml`中...