spring整合cxf实现restful webservice

最新推荐文章于 2020-11-29 04:50:56 发布
最新推荐文章于 2020-11-29 04:50:56 发布
阅读量685 收藏 3
点赞数
分类专栏： webservice 文章标签： spring web service apache cxf restful
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012454773/article/details/76910348
版权

     WebService入门

     WebService(注解),CXF框架(jax-ws,Jax-rs,与spring整合)

      闲下来研究webservice也好几天了，百度上纷繁错杂的文章令人眼花缭乱，看着都头疼，有的文章讲的更不知从何说起；好在终于找到上面两份连贯性的文章，就此让我对webservice有了系统的认识，也知道如何去进行代码的实现；

      那么既然已经了解的差不多了，那咱们就写个demo练练手吧，顺便也给自己和后来的小伙伴留下点东西，熟悉的更快点。

 一、导入支撑包到web工程的lib下

      我这没有新建maven项目，所以都是手动导包；如果你是新建的maven项目，那么添加依赖就好了，至于导入那些依赖包，我就不贴出来了，各位下载附件代码吧；

      

 二、创建实体Bean

package cn.Higgin.ws.mobile.bean;

import javax.xml.bind.annotation.XmlRootElement;

/**
 * 
 * @author Administrator
 * 如果返回值为Order、List<Order>类型，且数据格式是xml,
 * 则必须添加下面的注解。
 */
@XmlRootElement(name="order")
public class Order {
	private Integer id;
	private String name;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Order [id=" + id + ", name=" + name + "]";
	}
}

 三、服务类接口 

  javax.ws.rs.GET;
  javax.ws.rs.POST;
  javax.ws.rs.Path;
  javax.ws.rs.PathParam;
  javax.ws.rs.Produces;
  javax.ws.rs.QueryParam;
  javax.ws.rs.core.MediaType;.....

    在接口类和方法上分别利用javax.ws.rs.*包下的注解定义类路径（@Path）、方法路径（@Path）、方法请求类型（@GET,@POST..）、方法返回值响应类型（@Produces）

package cn.Higgin.ws.mobile.service;

import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;

import cn.Higgin.ws.mobile.bean.Order;

/**
 * 
 * @author Administrator
 * @Produces:响应支持多个 MIME 类型。在本例和上一个示例中，APPLICATION/XML 将是默认的 MIME 类型。</br>
 * 
 * <p>cxf restful 返回值支持数据类型:</p></br>
 * <p>(一)、基本类型：（@Produces需设置为：MediaType.TEXT_PLAIN,MediaType.APPLICATION_JSON）</p></br>
 *         </p>–int,float,boolean等</p></br>
 * <p>(二)、应用类型：String、自定义类型:Order、集合类型：数组,List, Set, Map</p></br>
 *
 */
@Path("/mo")
public interface MobileService {
	
	/**
	 * 返回基本类型数据：int
	 * 
	 * @param id
	 * @return
	 */
	@POST
	@Path("/queryOrder3/{id}")
	@Produces({ MediaType.TEXT_PLAIN, MediaType.APPLICATION_JSON })
	public int queryOrder3(@PathParam("id") Integer id);

	@GET
	@Path("/queryMobile/{phone}")
	@Produces({ MediaType.APPLICATION_JSON })
	public String queryMobile(@PathParam("phone") String phone);

	@GET
	@Path("/queryOrder/{id}")
	@Produces({ MediaType.APPLICATION_JSON })
	// http://localhost:8080/webservice_spring_mobile_server_resful/ws/mobile2/mo/queryOrder/13167173501
	public Order queryOrder(@PathParam("id") String id);

	@GET
	@Path("/queryOrderList")
	@Produces({ MediaType.APPLICATION_JSON })
	public List<Order> queryOrderList();

	@GET
	@Path("/queryMobile1")
	@Produces({ MediaType.APPLICATION_JSON })
	// http://localhost:8080/webservice_spring_mobile_server_resful/ws/mobile2/mo/queryMobile1?phone=13167173501
	public String queryMobile1(@QueryParam("phone") String phone);

	@POST
	@Path("/queryOrder1/{id}")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public Order queryOrder1(@PathParam("id") int id);

	@POST
	@Path("/queryOrder2/{id}")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public Order queryOrder2(@PathParam("id") Integer id);

	/**
	 * 集合类型：数组 基本类型
	 * 
	 * @param id
	 * @return
	 */
	@POST
	@Path("/getArray/{id}")
	@Produces({ MediaType.APPLICATION_JSON })
	public int[] getArray(@PathParam("id") Integer id);

	/**
	 * 集合类型：数组 对象类型
	 * 
	 * @param id
	 * @return
	 */
	@POST
	@Path("/getArrayObj/{id}")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public Order[] getArrayObject(@PathParam("id") Integer id);

	/**
	 * 集合类型：List
	 * 
	 * @param order
	 * @return
	 */
	@POST
	@Path("/queryOrders")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public List<Order> queryOrders(Order order);
	
	
	@POST
	@Path("/getSetObj")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public Set<Order> getSetObjSet(Order order);
	
	@POST
	@Path("/getSetBasic")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public Set<Integer> getSetBasicSet(Order order);
	
	@POST
	@Path("/getMapBasic")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public Map<Integer,Order> getSetBasicMap(Order order);
	

}
 前面两个文章只是在示例中使用了以上的类、或者方法注解，但是并没告诉大家这些注解是干嘛的，到底该怎么去使用；下面，我们就来理一下。

1、概述

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。

这些注释均可在资源、资源方法、子资源方法、子资源定位器或子资源内找到。


@Produces：返回的类型

注释代表的是一个资源可以返回的 MIME 类型

a.返回给client字符串类型（text/plain）

[java]  view plain  copy
  1. @Produces(MediaType.TEXT_PLAIN)   

b.返回给client为json类型（application/json）

[java]  view plain  copy
  1. @Produces(MediaType.APPLICATION_JSON)   

测试：

string类型：

[java]  view plain  copy
  1. @Path("/say")    
  2. @GET    
  3. @Produces(MediaType.TEXT_PLAIN)    
  4. public String say() {    
  5.     System.out.println("hello world");    
  6.     return "hello world";       
  7. }    

json和bean类型：

[java]  view plain  copy
  1. @Path("test")    
  2. @GET    
  3. @Produces(MediaType.APPLICATION_JSON)    
  4. public Result<String> test() {    
  5.     Result<String> result = new Result<String>();    
  6.     result.success("aaaaaa");    
  7.         
  8.     return result;    
  9. }    
  10.     
  11. @Path("bean")    
  12. @GET    
  13. @Produces(MediaType.APPLICATION_JSON)    
  14. public UserBean bean() {    
  15.     UserBean userBean = new UserBean();    
  16.     userBean.setId(1);    
  17.     userBean.setUsername("fengchao");    
  18.     return userBean;    
  19. }  

@Consumes
注释代表的是一个资源可以接受的 MIME 类型
@Consumes与@Produces相反，用来指定可以接受client发送过来的MIME类型，同样可以用于class或者method，也可以指定多个MIME类型，一般用于@PUT，@POST

a.接受client参数为字符串类型

[java]  view plain  copy
  1.   

@Consumes(MediaType.TEXT_PLAIN)  b.接受clent参数为json类型

@Consumes(MediaType.APPLICATION_JSON) 


@PathParam

这种注解是负责捕获URL路径中的参数值。例如：

[plain]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. http://host:port/your-service/{path-param-1}/{path-param-2}  

[java]   view plain  copy
  1. @GET    
  2. @Path("{username"})    
  3. @Produces(MediaType.APPLICATION_JSON)    
  4. public User getUser(@PathParam("username") String userName) {    
  5.     ...    
  6. }    

@QueryParam

这种注解是负责捕获URL路径中的参数值。例如：

[plain]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. http://host:port/your-service/{path-param-1}/{path-param-2}  

同时，你的服务端方法应该这样使用：

[java]  view plain  copy
  1. @GET    
  2. @Path("/user")    
  3. @Produces("text/plain")    
  4. public User getUser(@QueryParam("name") String name,    
  5.                      @QueryParam("age") int age) {    
  6.     ...    
  7. }   

如果需要为参数设置默认值，可以使用@DefaultValue，如：

[java]  view plain  copy
  1. @GET    
  2. @Path("/user")    
  3. @Produces("text/plain")    
  4. public User getUser(@QueryParam("name") String name,    
  5.                     @DefaultValue("26") @QueryParam("age") int age) {    
  6.     ...    
  7. }  

@FormParam

获取post请求中表单中的数据：

[java]  view plain  copy
  1. @POST    
  2. @Consumes("application/x-www-form-urlencoded")    
  3. public void post(@FormParam("name") String name) {    
  4.     // Store the message    
  5. }  

@BeanParam

获取请求参数中的数据，用实体Bean进行封装
[java]  view plain  copy
  1. @POST    
  2. @Consumes("application/x-www-form-urlencoded")    
  3. public void update(@BeanParam User user) {    
  4.     // Store the user data    
  5. }    

@MatrixParam

这种注解大家可能用的不多，是负责捕获URL路径中的matrix参数的值。例如：

[plain]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. http://host:port/your-service/matrix;id=1;name=tom  
同时，你的方法是这样的：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public String getMatrixParam(@MatrixParam("id") String id, @MatrixParam("name") String name);  

@HeaderParam

这种注解是负责捕获HTTP请求头中的参数的值。例如：

[plain]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. http://host:port/your-service/getHeader  
同时，你的方法是这样的：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public String getHeader(@HeaderParam("user-agent") String userAgent);


 四、接口实现类

     实现类只需实现接口，无需再添加任何注解。

package cn.Higgin.ws.mobile.service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import cn.Higgin.ws.mobile.bean.Order;

import com.cosw.juhe.JuHeUtil;

public class MobileServiceImpl implements MobileService {

	@Override
	public String queryMobile(String phone) {
		return JuHeUtil.getRequest(phone);
	}

	@Override
	public Order queryOrder(String id) {
		Order order =new Order();
		order.setId(1);
		order.setName("name");
		return order;
	}

	@Override
	public List<Order> queryOrderList() {
		List<Order> orders=new ArrayList<Order>();
		Order order1=new Order();
		order1.setId(1);
		order1.setName("name");
		orders.add(order1);
		
		Order order2=new Order();
		order2.setId(2);
		order2.setName("name2");
		orders.add(order2);
		return orders;
	}

	@Override
	public String queryMobile1(String phone) {
		return phone;
	}

	@Override
	public List<Order> queryOrders(Order order) {
		System.out.println("queryOrders:"+order);
		List<Order> orders=new ArrayList<Order>();
		Order order1=new Order();
		order1.setId(1);
		order1.setName("name");
		orders.add(order1);
		
		Order order2=new Order();
		order2.setId(2);
		order2.setName("name2");
		orders.add(order2);
		return orders;
	}

	@Override
	public Order queryOrder1(int id) {
		Order order2=new Order();
		order2.setId(id);
		order2.setName("queryOrder1=>name2");
		return order2;
	}

	@Override
	public Order queryOrder2(Integer id) {
		Order order2=new Order();
		order2.setId(id);
		order2.setName("queryOrder2=>name2");
		return order2;
	}

	@Override
	public int queryOrder3(Integer id) {
		return 25;
	}

	@Override
	public int[] getArray(Integer id) {
		int[] arrays=new int[5];
		arrays[0]=1;
		arrays[1]=2;
		arrays[2]=3;
		arrays[3]=4;
		arrays[4]=5;
		return arrays;
	}

	@Override
	public Order[] getArrayObject(Integer id) {
		Order[] os=new Order[2];
		Order order2=new Order();
		order2.setId(id);
		order2.setName("queryOrder2=>name2");
		os[0]=order2;
		
		Order order3=new Order();
		order3.setId(id);
		order3.setName("queryOrder2=>name2");
		os[1]=order3;
		return os;
	}

	@Override
	public Set<Order> getSetObjSet(Order order) {
		Set<Order> orders=new HashSet<Order>();
		orders.add(order);
		return orders;
	}

	@Override
	public Set<Integer> getSetBasicSet(Order order) {
		Set<Integer> is=new HashSet<Integer>();
		is.add(1);
		is.add(2);
		is.add(3);
		is.add(4);
		is.add(5);
		return is;
	}

	@Override
	public Map<Integer, Order> getSetBasicMap(Order order) {
		Map<Integer, Order> maps=new HashMap<Integer, Order>();
		maps.put(1, order);
		return maps;
	}
} 

 五、加入spring集成cxf的配置文件，配置cxf发布的路径

     具体注意事项不在此处罗嗦了，具体看配置文件吧。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxrs="http://cxf.apache.org/jaxrs" xmlns:jaxws="http://cxf.apache.org/jaxws"
	xsi:schemaLocation="  
        http://www.springframework.org/schema/beans  
        http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://cxf.apache.org/jaxws  
        http://cxf.apache.org/schemas/jaxws.xsd 
        http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd">

    <!-- 基础配置 -->
	<import resource="classpath:META-INF/cxf/cxf.xml" />
	<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
	
	<!-- 请求日志拦截器，将会打印请求日志 -->
	<bean id="inLogInterceptor" class="org.apache.cxf.interceptor.LoggingInInterceptor" />
	<!-- 响应日志拦截器，将会打印响应日志 -->
	<bean id="outLogInterceptor" class="org.apache.cxf.interceptor.LoggingOutInterceptor" />
	

	<!-- 配置本系统的手机号码查询service -->
	<bean id="mobileService" class="cn.Higgin.ws.mobile.service.MobileServiceImpl">
	</bean>
	
	<!-- 发布手机号查询服务 -->
	<!-- soap webservic:此种方式不支持GET请求或者是resful请求,
	               只能通过webservice客户端调用
	 -->
	<!-- <jaxws:server id="mobileService1" serviceClass="cn.Higgin.ws.mobile.service.MobileService"
		address="/mobile1">
		<jaxws:serviceBean>
			要暴露的 bean 的引用
			<ref bean="mobileService" />
		</jaxws:serviceBean>
		<jaxws:inInterceptors>
			<ref bean="inLogInterceptor" />
		</jaxws:inInterceptors>
		<jaxws:outInterceptors>
			<ref bean="outLogInterceptor" />
		</jaxws:outInterceptors> 
	</jaxws:server> -->
	
	
    <!-- restful webservice：发布restful必须使用jaxrs:server实现 -->
	<jaxrs:server id="restServiceContainer" address="/mobile2">
		<!-- Interceptors -->
		<jaxrs:inInterceptors>
			<ref bean="inLogInterceptor" />
		</jaxrs:inInterceptors>
		<jaxrs:outInterceptors>
			<ref bean="outLogInterceptor" />
		</jaxrs:outInterceptors>
		<!-- serviceBeans -->
		<jaxrs:serviceBeans>
			<ref bean="mobileService" />
		</jaxrs:serviceBeans>
		<jaxrs:extensionMappings>
			<entry key="feed" value="application/atom+xml" />
			<entry key="json" value="application/json" />
			<entry key="xml" value="application/xml" />
			<entry key="html" value="text/html" />
		</jaxrs:extensionMappings>
		<jaxrs:languageMappings>
			<entry key="en" value="en-gb" />
			<entry key="cn" value="cn-ZH"/>
		</jaxrs:languageMappings>
		<jaxrs:providers>
			<bean class="org.codehaus.jackson.jaxrs.JacksonJsonProvider" />
		</jaxrs:providers>
	</jaxrs:server>
</beans>

 六、web.xml中配置cxf servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>WebService_Spring_Mobile_Server</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>WEB-INF/applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class> org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 配置cxf servlet -->
  <servlet>
    <servlet-name>cxf</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>cxf</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>
  <filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>utf-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

到此处，一个完整的cxf整合spring的restful webservice接结束了。

七、接口调用

       虽然到这边结束了，但是我们还是得写个客户端验证下我们自己写的接口是不是按我们预想的输出数据，此处我就不一一把接口运行效果贴出来了，需要验证的小伙伴可以按例子自己做一下或者下载demo跑一下，自己验证下。

package com.cosw.test.test;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;

import com.cosw.test.bean.Order;
import com.cosw.test.util.HttpClientUtil;

public class ResfulTest {
	public static final String prefix = "http://localhost:8080/webservice_spring_mobile_server_resful/ws/mobile2/mo/";
	public static final String QUERY_ORDERS = prefix + "queryOrders?_type=xml";
	public static final String QUERY_ORDER1 = prefix + "queryOrder1/1";
	public static final String QUERY_ORDER2 = prefix + "queryOrder2/2";
	public static final String QUERY_ORDER3 = prefix + "queryOrder3/3";
	public static final String GET_ARRAY = prefix + "getArray/3";
	public static final String GET_ARRAY_OBJ = prefix + "getArrayObj/3";
	public static final String GET_ARRAY_OBJ_JSON = prefix
			+ "getArrayObj/3?_type=json";
	public static final String GET_ARRAY_OBJ_XML = prefix
			+ "getArrayObj/3?_type=xml";
	public static final String GET_SET_OBJ = prefix + "getSetObj";
	public static final String GET_SET_BASIC = prefix + "getSetBasic";
	public static final String GET_MAP_BASIC = prefix + "getMapBasic";

	public static void main(String[] args) {
		// queryOrders();

		/* queryOrder1(); */
		/* queryOrder2(); */
		/* queryOrder3(); */

		/* getArray(); */
		/*getArrayObj();*/
		getSetBasic();
		getSetObj();
		getMap();
	}

	public static void queryOrders() {
		Order order = new Order();
		order.setId(1);
		order.setName("我进来看看...");
		try {
			System.out.println(HttpClientUtil.postRequest(QUERY_ORDERS,
					objToJsonStr(order)));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void queryOrder1() {
		try {
			System.out.println(HttpClientUtil.postRequest(QUERY_ORDER1,
					new HashMap<String, Object>()));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void queryOrder2() {
		try {
			System.out.println(HttpClientUtil.postRequest(QUERY_ORDER2,
					new HashMap<String, Object>()));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void queryOrder3() {
		try {
			System.out.println(HttpClientUtil.postRequest(QUERY_ORDER3,
					new HashMap<String, Object>()));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 获取基本数据类型数组：int[]
	public static void getArray() {
		try {
			System.out.println(HttpClientUtil.postRequest(GET_ARRAY,
					new HashMap<String, Object>()));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 获取对象类型数组：order[]
	public static void getArrayObj() {
		try {
			System.out.println(HttpClientUtil.postRequest(GET_ARRAY_OBJ,
					new HashMap<String, Object>()));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void getSetBasic() {
		Order order = new Order();
		order.setId(1);
		order.setName("我进来看看...");
		try {
			System.out.println("getSetBasic:"+HttpClientUtil.postRequest(GET_SET_BASIC,
					objToJsonStr(order)));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void getSetObj() {
		Order order = new Order();
		order.setId(1);
		order.setName("我进来看看...");
		try {
			System.out.println("getSetObj:"+HttpClientUtil.postRequest(GET_SET_OBJ,
					objToJsonStr(order)));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void getMap() {
		Order order = new Order();
		order.setId(1);
		order.setName("我进来看看...");
		try {
			System.out.println("getMap:"+ HttpClientUtil.postRequest(GET_MAP_BASIC,
					objToJsonStr(order)));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static String objToJsonStr(Object obj) {
		ObjectMapper mapper = new ObjectMapper();
		String mapJakcson = null;
		try {
			mapJakcson = mapper.writeValueAsString(obj);
		} catch (JsonGenerationException e) {
			e.printStackTrace();
		} catch (JsonMappingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return mapJakcson;
	}
}

      GitHub下载地址： https://github.com/TaavettiTao/webservice.git

       

    本站地址：http://download.csdn.net/download/u012454773/9925098

     
Mrs陶
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cxf 开发restful服务
05-31
主要包括cxf开发webservice的配置，使用maven 构建项目。
Apache CXF实战之四 构建RESTful Web Service
new is I
05-02 140
本文链接：http://blog.csdn.net/kongxx/article/details/7527115 Apache CXF实战之一 Hello World Web Service Apache CXF实战之二 集成Sping与Web容器 Apache CXF实战之三 传输Java对象 这篇文章介绍一下怎么通过CXF来发布RESTful的Web Service. 1. 首先是实体类，注...
使用CXF与Spring集成实现RESTFul WebService
weixin_33898233的博客
03-12 123
以下引用与网络中！！！ 一种软件架构风格，设计风格而不是标准，只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。 REST（英文：Representational State Transfer，简称REST）描述了一个架构样式的网络系统，比如 web 应用程序。它首次出现在 2000 年 ...
Spring CXF Restful
carl.zhao的专栏
03-05 1337
Apache CXF已经是一个正式的Apache顶级项目.它继承了 Celtix 和 XFire 两大开源项目的精华，提供了对 JAX-WS 全面的支持，并且提供了多种 Binding 、DataBinding、Transport 以及各种 Format 的支持，并且可以根据实际项目的需要，采用代码优先或者 WSDL 优先来轻松地实现 Web Services 的发布和使用。
springboot整合cxf_SpringBoot2.x系列教程38--整合JAX-RS之利用Jersey框架实现RESTful
weixin_39657575的博客
11-29 305
SpringBoot2.x系列教程38--整合JAX-RS之利用Jersey框架实现RESTful作者：一一哥一. JAX-RS与Jersey简介1. JAX-RS简介在Java EE 6 中引入了对 JSR-311 的支持。JSR-311（也就是JAX-RS：Java API for RESTful Web Services）旨在定义一个统一的规范，它的核心概念是resource，也就是面向资源...
Spring整合CXF webservice restful实例详解
08-29
主要为大家详细介绍了Spring整合CXF webservice restful的实例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring Boot 实现Restful webservice服务端示例代码
08-28
主要介绍了Spring Boot 实现Restful webservice服务端示例代码,非常不错，具有参考借鉴价值，需要的朋友可以参考下
SpringBoot+Mybatis+CXF框架，实现Restful api与 WebService api接口的大实验
04-07
SpringBoot+Mybatis+CXF框架，实现Restful api与 WebService api接口的大实验
cxf集成Spring的restful WebService接口
11-22
cxf集成Spring的restful WebServ ice接口，Demo的完整代码！
cxf webservice restful实现
08-08
spring整合cxf实现restful的webservice服务，代码分为服务端和客户端两个模块；服务端为接口，客户端为接口调用。
CXF Restful服务简单例子
10-29
CXF Restful服务简单例子
cxf集成Spring的restful WebService接口以Json形式表现
11-25
cxf集成Spring的restful WebService接口以Json形式表现的完整代码，适合新入门在学WebService的小伙伴们参考，希望对你们有帮助！
Spring CXF Restful 实例
05-05
Spring CXF Restful 实例
CXF+spring+restful创建一个web的接口项目源代码
06-06
CXF+spring+restful创建一个web的接口项目源代码，添加了restful实现的配置及jar包
基于CXF开发RESTFul服务
xkmooobj的博客
09-14 219
REST也就是Representational State Transfer。REST并不特指一种技术，也不是一个标准，它仅仅是一个构架风格。REST 指的是一组架构约束条件和原则。满足这些约束条件和原则通过网络暴露资源给用户。事实上，WWW就是经典的REST架构风格。在服务器端，应用程序状态和功能可以分为各种资源。它向客户端公开。每个资源都使用 URI (Universal Resourc...
CXF+Spring搭建Restful接口服务
黄自豪的笔记本
05-13 875
之前项目中用CXF+Spring可以搭建WebService服务，后面发现cxf可以支持Restful规范的接口。于是，在接下去的练手项目中，打算用cxf+spring来搭建一个Restful接口服务。
利用spring整合cxf，实现restful webservice接口，以及接口测试
混子
05-07 2179
第一步，肯定是导入cxf相关的jar包，自行去pom.xml里面添加依赖吧，因为我的项目他们已经搭好环境了，而且就是jar包引入的，没用maven。 第二布，配置web.xml，因为需要在项目启动时就加载 第三步，编写接口和实现类 实现类也很简单，就是一个简单的查询，然后将查询结果用GSON转成JSON字符串，然后封装在ResponseModel中 public class...
Springboot整合cxf-ws发布webservice和restful接口
csweldn520的专栏
03-10 3029
Springboot整合cxf-ws 一、SOAP接口开发 1、发布webservice接口 1.1、依赖 1.2、编写接口和实现类 1.3、配置类 1.4、测试 2、 调用webservice接口 2.1、解析地址 2.2、使用hutool工具调用 2.3、解析xml 二、 Restful接口开发 1、发布restful接口 1.1、依赖 1.2、编写接口和实现类 1.3、配置类 1.4、测试 ...
用Spring+cxf 实现一个简单的restful webService
JustinMJC的博客
01-05 1946
主要就三个部分applicationContext.xml、web.xml和resource类 所需要的jar包 1applicationContext.xml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/a
springboot整合cxf实现webservice
最新发布
08-25
将Spring Boot和CXF整合起来，可以方便地实现基于CXF的Web服务。 要实现Spring Boot整合CXF，首先需要添加相应的依赖。在pom.xml文件中，引入spring-boot-starter-web和cxf-rt-frontend-jaxws等依赖。 接下来，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值