CXF學習筆記（發佈restFul）

時間  2019-11-17
標籤 cxf 學習 筆記 發佈 restful 简体版
原文   原文鏈接

1、概述

JAX-RS是Java提供用於開發RESTful Web服務基於註解(annotation)的API。JAX-RS旨在定義一個統一的規範，使得Java程序員可使用一套固定的接口來開發REST應用，避免了依賴第三方框架。同時JAX-RS使用POJO編程模型和基於註解的配置並集成JAXB，能夠有效縮短REST應用的開發週期。JAX-RS只定義RESTful API，具體實現由第三方提供，如Jersey、Apache CXF等。java

 

JAX-RS包含近五十多個接口、註解和抽象類：程序員

javax.ws.rs包含用於建立RESTful服務資源的高層次（High-level）接口和註解。web

javax.ws.rs.core包含用於建立RESTful服務資源的低層次（Low-level）接口和註解。spring

javax.ws.rs.ext包含用於擴展JAX-RS API支持類型的APIs。apache

 

JAX-RS經常使用註解：編程

@Path：標註資源類或方法的相對路徑。json

@GET、@PUT、@POST、@DELETE：標註方法的HTTP請求類型。瀏覽器

@Produces：標註返回的MIME媒體類型。tomcat

@Consumes：標註可接受請求的MIME媒體類型。restful

@PathParam、@QueryParam、@HeaderParam、@CookieParam、@MatrixParam、@FormParam：標註方法的參數來自於HTTP請求的位置。@PathParam來自於URL的路徑，@QueryParam來自於URL的查詢參數，@HeaderParam來自於HTTP請求的頭信息，@CookieParam來自於HTTP請求的Cookie。

 

2、依賴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>  

 

 

3、發佈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.二、定義發佈接口

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.三、接口實現類

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. }  

 

4、發佈RestFul接口

4.一、使用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.二、在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、客戶端調用

5.一、使用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.二、使用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>  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程