zoukankan      html  css  js  c++  java

  • CXF学习笔记（发布restFul）

    一、概述

    JAX-RS是Java提供用于开发RESTful Web服务基于注解(annotation)的API。JAX-RS旨在定义一个统一的规范，使得Java程序员可以使用一套固定的接口来开发REST应用，避免了依赖第三方框架。同时JAX-RS使用POJO编程模型和基于注解的配置并集成JAXB，可以有效缩短REST应用的开发周期。JAX-RS只定义RESTful API，具体实现由第三方提供，如Jersey、Apache CXF等。

    JAX-RS包含近五十多个接口、注解和抽象类：

    javax.ws.rs包含用于创建RESTful服务资源的高层次（High-level）接口和注解。

    javax.ws.rs.core包含用于创建RESTful服务资源的低层次（Low-level）接口和注解。

    javax.ws.rs.ext包含用于扩展JAX-RS API支持类型的APIs。

    JAX-RS常用注解：

    @Path：标注资源类或方法的相对路径。

    @GET、@PUT、@POST、@DELETE：标注方法的HTTP请求类型。

    @Produces：标注返回的MIME媒体类型。

    @Consumes：标注可接受请求的MIME媒体类型。

    @PathParam、@QueryParam、@HeaderParam、@CookieParam、@MatrixParam、@FormParam：标注方法的参数来自于HTTP请求的位置。@PathParam来自于URL的路径，@QueryParam来自于URL的查询参数，@HeaderParam来自于HTTP请求的头信息，@CookieParam来自于HTTP请求的Cookie。

    二、依赖JAR文件Maven坐标

    Java代码  收藏代码
    1. <properties>  
    2.         <cxf.version>3.0.7</cxf.version>  
    3.         <junit.version>4.11</junit.version>  
    4.     </properties>  
    5. <!-- CXF需要导入的jar包 -->  
    6.         <dependency>  
    7.             <groupId>org.apache.cxf</groupId>  
    8.             <artifactId>cxf-rt-frontend-jaxws</artifactId>  
    9.             <version>${cxf.version}</version>  
    10.         </dependency>  
    11.   
    12.         <dependency>  
    13.             <groupId>org.apache.cxf</groupId>  
    14.             <artifactId>cxf-rt-transports-http</artifactId>  
    15.             <version>${cxf.version}</version>  
    16.         </dependency>  
    17.         <!-- CXF实现RestFul接口需要用到的包 -->  
    18.         <dependency>  
    19.             <groupId>org.apache.cxf</groupId>  
    20.             <artifactId>cxf-rt-frontend-jaxrs</artifactId>  
    21.             <version>${cxf.version}</version>  
    22.         </dependency>  
    23.         <!-- 客户端调用restFul服务需要导入的包 -->  
    24.         <dependency>  
    25.             <groupId>org.apache.cxf</groupId>  
    26.             <artifactId>cxf-rt-rs-client</artifactId>  
    27.             <version>${cxf.version}</version>  
    28.         </dependency>  
    29.   
    30.         <!-- 部署至tomcat低下不会，jetty环境需要加入该包 -->  
    31.         <dependency>  
    32.             <groupId>org.apache.cxf</groupId>  
    33.             <artifactId>cxf-rt-transports-http-jetty</artifactId>  
    34.             <version>${cxf.version}</version>  
    35.         </dependency>  

    三、发布RestFul接口

    3.1实体对象

    Java代码  收藏代码
    1. /** 
    2.  * @author Ickes 
    3.  */  
    4. @XmlRootElement(name="UserInfo")  
    5. public class Users{  
    6.     private String userId;  
    7.     private String userName;  
    8.     private String userPwd;  
    9.     private Integer sex;  
    10.     private Float sal;  
    11.     private Date birthday;  
    12.          
    13.         get、set方法省略！  
    14.          
    15.     public String toJson() {  
    16.         Gson gson = new Gson();  
    17.         return gson.toJson(this);  
    18.     }  
    19. }  

    3.2、定义发布接口

    Java代码  收藏代码
    1. import javax.ws.rs.DELETE;  
    2. import javax.ws.rs.GET;  
    3. import javax.ws.rs.POST;  
    4. import javax.ws.rs.PUT;  
    5. import javax.ws.rs.Path;  
    6. import javax.ws.rs.PathParam;  
    7. import javax.ws.rs.Produces;  
    8. import javax.ws.rs.QueryParam;  
    9. import javax.ws.rs.core.MediaType;  
    10.   
    11. /** 
    12.  * 用户服务接口 
    13.  * @author Ickes 
    14.  */  
    15. @Path("/restFul")  
    16. public interface UserService {  
    17.     /** 
    18.      * 测试GET方法，传人对象、普通参数；返回对象 
    19.      *  
    20.      */  
    21.     @GET  
    22.     @Path("/get")  
    23.     @Produces({MediaType.APPLICATION_XML,MediaType.APPLICATION_JSON})  
    24.     public Users get(@QueryParam("id") String id);  
    25.       
    26.       
    27.     /** 
    28.      * 测试PUT方法，传人对象、普通参数；返回对象 
    29.      * id来源于url后面的参数 
    30.      * @param user 
    31.      * @return 
    32.      */  
    33.     @PUT  
    34.     @Path("/put/{id}")  
    35.     @Produces({MediaType.APPLICATION_XML,MediaType.APPLICATION_JSON})  
    36.     public Users put(@PathParam("id")String id,Users u);  
    37.       
    38.       
    39.     /** 
    40.      * 测试POST方法，传人对象、普通参数；返回对象 
    41.      *  
    42.      */  
    43.     @POST  
    44.     @Path("/post/{id}")  
    45.     @Produces({MediaType.APPLICATION_XML,MediaType.APPLICATION_JSON})  
    46.     public Users post(@PathParam("id") String id,Users u);  
    47.       
    48.       
    49.     /** 
    50.      * 测试DELETE方法 ,传人普通参数；返回对象 
    51.      */  
    52.     @DELETE  
    53.     @Path("/delete/{id}")  
    54.     @Produces({MediaType.APPLICATION_XML,MediaType.APPLICATION_JSON})  
    55.     public Users delete(@PathParam("id") String id);  
    56.       
    57. }  

    3.3、接口实现类

    Java代码  收藏代码
    1. import java.util.Date;  
    2. import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;  
    3. import org.apache.cxf.jaxrs.lifecycle.SingletonResourceProvider;  
    4.   
    5. /** 
    6.  * 用户服务实现类 
    7.  *  
    8.  * @author Ickes 
    9.  */  
    10. public class UserServiceRestFul implements UserService {  
    11.   
    12.     @Override  
    13.     public Users get(String id) {  
    14.         System.out.println("GET方法，id=" + id);  
    15.         Users user = new Users();  
    16.         user.setUserId("get");  
    17.         user.setUserName("ickes");  
    18.         user.setUserPwd("ices123");  
    19.         user.setSex(1);  
    20.         user.setSal(32F);  
    21.         user.setBirthday(new Date());  
    22.         return user;  
    23.     }  
    24.   
    25.     @Override  
    26.     public Users put(String id, Users u) {  
    27.         System.out.println("PUT方法，id=" + id + ",users=" + u.toJson());  
    28.         Users user = new Users();  
    29.         user.setUserId("put");  
    30.         user.setUserName("ickes");  
    31.         user.setUserPwd("ices123");  
    32.         user.setSex(1);  
    33.         user.setSal(32F);  
    34.         user.setBirthday(new Date());  
    35.         return user;  
    36.     }  
    37.   
    38.     @Override  
    39.     public Users post(String id, Users u) {  
    40.         System.out.println("POST方法，id=" + id + ",users=" + u.toJson());  
    41.         Users user = new Users();  
    42.         user.setUserId("post");  
    43.         user.setUserName("ickes");  
    44.         user.setUserPwd("ices123");  
    45.         user.setSex(1);  
    46.         user.setSal(32F);  
    47.         user.setBirthday(new Date());  
    48.         return user;  
    49.     }  
    50.   
    51.     @Override  
    52.     public Users delete(String id) {  
    53.         System.out.println("DELETE方法，id=" + id);  
    54.         Users user = new Users();  
    55.         user.setUserId("delete");  
    56.         user.setUserName("ickes");  
    57.         user.setUserPwd("ices123");  
    58.         user.setSex(1);  
    59.         user.setSal(32F);  
    60.         user.setBirthday(new Date());  
    61.         return user;  
    62.     }  
    63. }  

    四、发布RestFul接口

    4.1、使用CXF的API接口进行发布

    使用CXF的API接口进行发布的缺点很明显，就是必须指定一个端口进行发布，这个端口不能被占用，占用就会抛出异常。

    Java代码  收藏代码
    1. /** 
    2.  * 使用CXF发布RestFul服务 
    3.  *  
    4.  * @param args 
    5.  */  
    6. public static void main(String[] args) {  
    7.     JAXRSServerFactoryBean jrf = new JAXRSServerFactoryBean();  
    8.     jrf.setResourceClasses(UserServiceRestFul.class);  
    9.     jrf.setResourceProvider(UserServiceRestFul.class,  
    10.             new SingletonResourceProvider(new UserServiceRestFul()));  
    11.     jrf.setAddress("http://localhost:8080/rest/");  
    12.     jrf.create();  
    13. }  

    4.2、在spring容器中进行发布

    跟使用CXF发布JAX-WS接口一样，首先必须在web.xml中配置CXFWebServlet，代码如下：

    Java代码  收藏代码
    1. <!-- Cxf中使用 CXFServlet，发布跟当前项目端口相同的服务 -->  
    2.     <servlet>  
    3.         <servlet-name>cxfServlet</servlet-name>  
    4.         <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>  
    5.     </servlet>  
    6.     <servlet-mapping>  
    7.         <servlet-name>cxfServlet</servlet-name>  
    8.         <url-pattern>/cxf/*</url-pattern>  
    9.     </servlet-mapping>  

     然后在类路径下面新建applicationContext-cxf.xml，代码如下：

    Java代码  收藏代码
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:jaxrs="http://cxf.apache.org/jaxrs"  
    4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
    6.     http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd   
    7.     http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd ">  
    8.   
    9.     <jaxrs:server id="restUserService" address="/restFul">  
    10.         <jaxrs:serviceBeans>  
    11.             <ref bean="userServiceRestFul" />  
    12.         </jaxrs:serviceBeans>  
    13.         <jaxrs:extensionMappings>  
    14.             <entry key="json" value="application/json" />  
    15.             <entry key="xml" value="application/xml" />  
    16.         </jaxrs:extensionMappings>  
    17.     </jaxrs:server>  
    18.     <bean id="userServiceRestFul" class="com.gosun.jws.cxf.restful.UserServiceRestFul"></bean>  
    19. </beans>  

    发布后在浏览器中输入http://localhost:8080/jws/cxf，出现如下见面说明发布成功.



     

    五、客户端调用

    5.1、使用WebClient进行调用（不推荐）

    使用org.apache.cxf.jaxrs.client.WebClient调用的代码如下：

    Java代码  收藏代码
    1. import javax.ws.rs.core.MediaType;  
    2. import org.apache.cxf.jaxrs.client.WebClient;  
    3. import org.junit.Before;  
    4. import org.junit.Test;  
    5.   
    6. /** 
    7.  * @author Ickes 
    8.  */  
    9.   
    10. public class WebClientTest {  
    11.   
    12.     WebClient client = null;  
    13.   
    14.     @Before  
    15.     public void init() {  
    16.         client = WebClient.create("http://localhost:8080/rest/");  
    17.     }  
    18.   
    19.     /** 
    20.      * 调用get方法,get方式是将参数加入到URL地址后面的，所以不能传人Bean，但是可以转换为json的格式进行传递 
    21.      *  
    22.      * @param client 
    23.      */  
    24.     @Test  
    25.     public void getTest() {  
    26.         // 测试URL传递数据  
    27.         client = WebClient  
    28.                 .create("http://localhost:8080/rest/restFul/get?id=ickes");  
    29.         Users u = client.accept(MediaType.APPLICATION_XML).get(Users.class);  
    30.         System.out.println(u.toJson());  
    31.     }  
    32.   
    33.     /** 
    34.      * 调用put方法,可以看到这种方式可以传人一个JavaBean参数， 但是集合对象不行，可以将集合写在JavaBean里面进行传递 
    35.      */  
    36.     @Test  
    37.     public void putTest() {  
    38.         Users u = new Users();  
    39.         u.setUserId("1");  
    40.         u.setUserName("aa");  
    41.         u.setUserPwd("bbb");  
    42.         client.path("restFul/put/{id}", "ickes")  
    43.                 .accept(MediaType.APPLICATION_XML).put(u);  
    44.     }  
    45.   
    46.     /** 
    47.      * 调用post方法，这种方式的调用跟put方式异曲同工 
    48.      *  
    49.      */  
    50.     @Test  
    51.     public void postTest() {  
    52.         Users u = new Users();  
    53.         u.setUserId("1");  
    54.         u.setUserName("aa");  
    55.         u.setUserPwd("bbb");  
    56.         client.accept(MediaType.APPLICATION_XML)  
    57.                 .path("/restFul/post/{id}", "post").post(u);  
    58.     }  
    59.   
    60.     /** 
    61.      * 调用Delete方法,这个方法可以看到delete方法是不能传递参数的，只能通过其他方式，例如URL 
    62.      *  
    63.      */  
    64.     @Test  
    65.     public void deleteTest() {  
    66.         client.accept(MediaType.APPLICATION_XML)  
    67.                 .path("/restFul/delete/{id}", "post").delete();  
    68.     }  
    69. }  

    5.2、使用CXF的客户端工厂类JAXRSClientFactory进行调用（推荐）

    这种方式相对比WebClient要更简单，直接使用接口中的方法即可，代码如下：

    Java代码  收藏代码
    1. import org.apache.cxf.jaxrs.client.JAXRSClientFactory;  
    2. import org.junit.Before;  
    3. import org.junit.Test;  
    4.   
    5. /** 
    6.  * <pre> 
    7.  * 调用RestFul接口，除了使用WebClient意外，还可以使用org.apache.cxf.jaxrs.client.JAXRSClientFactory; 
    8.  * 这种方式相对比WebClient要更简单，直接使用接口中的方法即可 
    9.  * </pre> 
    10.  *  
    11.  * @author Ickes 
    12.  */  
    13. public class JAXRSClientFactoryTest {  
    14.     UserService us = null;  
    15.   
    16.     @Before  
    17.     public void init() {  
    18.         us = JAXRSClientFactory.create("http://localhost:8080/jws/cxf/restFul",UserService.class);  
    19.         System.out.println(us);  
    20.     }  
    21.   
    22.     /** 
    23.      * 调用get方法 
    24.      */  
    25.     @Test  
    26.     public void getTest() {  
    27.         System.out.println(us.get("a").toJson());  
    28.     }  
    29.   
    30.     /** 
    31.      * 调用put方法 
    32.      */  
    33.     @Test  
    34.     public void putTest() {  
    35.         Users u = new Users();  
    36.         u.setUserId("1");  
    37.         u.setUserName("aa");  
    38.         u.setUserPwd("bbb");  
    39.         System.out.println(us.post("a001",u));  
    40.     }  
    41.       
    42.     /** 
    43.      * 调用post方法 
    44.      *  
    45.      */  
    46.     @Test  
    47.     public void postTest() {  
    48.         Users u = new Users();  
    49.         u.setUserId("1");  
    50.         u.setUserName("aa");  
    51.         u.setUserPwd("bbb");  
    52.         us.post("POST", u);  
    53.     }  
    54.       
    55.     /** 
    56.      * 调用Delete方法 
    57.      *  
    58.      */  
    59.     @Test  
    60.     public void deleteTest() {  
    61.         us.delete("DELETE");  
    62.     }  
    63.       
    64. }  

    如果想在Spring配置文件中配置org.apache.cxf.jaxrs.client.JAXRSClientFactory，代码如下：

    Java代码  收藏代码
      1. <bean id="userService" class="org.apache.cxf.jaxrs.client.JAXRSClientFactory" factory-method="create">  
      2.         <constructor-arg type="java.lang.String" value="http://localhost:8080/rest/" />  
      3.         <constructor-arg type="java.lang.Class" value="com.gosun.jws.cxf.restful.UserService" />  
      4.     </bean>  
  • 相关阅读:
    数据流图和数据流程图的定义与组成元素
    敏捷开发3种角色
    WBS
    开发流程
    结对编程
    笔记
    登录注册界面维护2----注册界面进行Toast提示
    登录注册界面修改错误
    听说
    “学习链接篇”
  • 原文地址：https://www.cnblogs.com/baorantHome/p/7416662.html
Copyright © 2011-2022 走看看