`

webservice cxf soap RESTfull

springwebservicesoap 
阅读更多
    
java webservice CXF JAX-WS(SOAP) + JAX-RS(RESTfull)

一、环境说明:

1>.在ssh(Struts2+Spring+Hibernate)架构中加入webservice服务,web服务使用Apache CXF,采用cxf+spring的方式发布web服务

2>.Apache CXF Releases 2.7.5, apache-cxf-2.7.5.zip 下载地址http://www.apache.org/dyn/closer.cgi?path=/cxf/2.7.5/apache-cxf-2.7.5.zip

二、环境配置

1>.导入jar依赖 
cxf-2.7.5.jar
neethi-3.0.2.jar
spring-asm-3.0.7.RELEASE.jar
spring-beans-3.0.7.RELEASE.jar
spring-context-3.0.7.RELEASE.jar
spring-core-3.0.7.RELEASE.jar
spring-expression-3.0.7.RELEASE.jar
spring-web-3.0.7.RELEASE.jar
spring-aop-3.0.7.RELEASE.jar

slf4j-api-1.7.5.jar
xmlschema-core-2.0.3.jar

httpasyncclient-4.0-beta3.jar
httpclient-4.2.1.jar
httpcore-4.2.2.jar
httpcore-nio-4.2.2.jar
wsdl4j-1.6.3.jar
javax.ws.rs-api-2.0-m10.jar
jaxb-impl-2.2.6.jar

jettison-1.3.3.jar

wss4j-1.6.10.jar

woodstox-core-asl-4.2.0.jar
stax2-api-3.1.1.jar


2>.web.xml  中的配置(spring和cxf的servlet) 

	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			<!-- webservice -->
			classpath:/applicationContext_ws.xml
		</param-value>
	</context-param>

	<!-- webservice -->
	<servlet>    
		<servlet-name>CXFService</servlet-name>    
		<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet> 
	<servlet-mapping>    
		<servlet-name>CXFService</servlet-name>    
		<url-pattern>/cxfservlet/*</url-pattern>
	</servlet-mapping>

3>.struts.xml 配置  webservice servlet ,要不然请把struts的url-pattern尽量带上后缀,比如  *.action,而不要配置为  /* 拦截所有请求，不然就需要有这一步在struts.xml的文件里配置放过webservice servlet 的请求 
	<!-- webservice -->
	<package name="cxf" extends="struts-default">
		<action name="cxfservlet/*">
			<result>cxfservlet/{1}</result>
		</action>
	</package>

4>.定义DTO,用户请求和返回xml或者json和javaBean的相互转换 
package com.emcs.dm.bean;

import java.util.List;

import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

/**
 *  使用cxf默认自带的jettison-1.3.3.jar对json支持
 *  需要返回List集合时需要使用一个包装对象
 *
*/
@XmlRootElement
@XmlType(name="",propOrder="hosts")
public class DMHostMachines
{
	private List<DMHostMechine> hosts;

	public List<DMHostMechine> getHosts()
	{
		return hosts;
	}

	public void setHosts(List<DMHostMechine> hosts)
	{
		this.hosts = hosts;
	}
}

package com.emcs.dm.bean;

import java.io.Serializable;
import java.util.Date;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

@XmlRootElement    //将类或枚举类型映射到 XML 元素
@XmlType(name="DMHostMechine")
@XmlAccessorType(XmlAccessType.FIELD)
public class DMHostMechine implements Serializable
{

	/**
	 * 
	 */
	private static final long serialVersionUID = 8206718006545121379L;
	
	private Integer hostId;
	private String enterpriseName;
	private Date lastUploadTime;
	
	public DMHostMechine()
	{
		
	}
	
	public DMHostMechine(Integer hostId,String enterpriseName,Date lastUploadTime)
	{
		this.hostId = hostId;
		this.enterpriseName = enterpriseName;
		this.lastUploadTime = lastUploadTime;
	}

	public Integer getHostId()
	{
		return hostId;
	}

	public void setHostId(Integer hostId)
	{
		this.hostId = hostId;
	}

	public String getEnterpriseName()
	{
		return enterpriseName;
	}

	public void setEnterpriseName(String enterpriseName)
	{
		this.enterpriseName = enterpriseName;
	}

	public Date getLastUploadTime()
	{
		return lastUploadTime;
	}

	public void setLastUploadTime(Date lastUploadTime)
	{
		this.lastUploadTime = lastUploadTime;
	}

	@Override
	public String toString()
	{
		return super.toString();
	}
}



5>.定义发布接口 
package com.ws.service;

import java.util.List;

import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.emcs.dm.bean.DMHostMachines;
import com.emcs.dm.bean.DMHostMechine;
import com.framework.exception.BaseException;

@WebService(targetNamespace="com.ws.service")  //for SOAP
@SOAPBinding(style=Style.RPC)                  //for SOAP
@Produces("*/*")                               //for REST
public interface IDMRequestService
{
	@WebMethod(operationName="request")    //for SOAP
	@GET                                   //for REST
	@Path("/{name}/request")
	@Produces(MediaType.TEXT_PLAIN)
	String request(@PathParam("name") String name);
	
	@WebMethod(operationName="getAllHostMachine")
	@GET
	@Path("/hostmachine")
	@Produces({MediaType.APPLICATION_XML,MediaType.APPLICATION_JSON})
	List<DMHostMechine> getAllHostMachine() throws BaseException;
	
	@WebMethod(operationName="getHosts")
	@GET
	@Path("/hosts")
	@Produces({MediaType.APPLICATION_XML,MediaType.APPLICATION_JSON})
	DMHostMachines getHosts() throws BaseException;
}


6>.定义实现类 
package com.ws.service.impl;

import java.util.List;

import javax.jws.WebService;

import com.emcs.dm.bean.DMHostMachines;
import com.emcs.dm.bean.DMHostMechine;
import com.framework.base.service.impl.DBServiceImpl;
import com.framework.exception.BaseException;
import com.ws.service.IDMRequestService;

/**
 * @author Admin
 * @description Expose CXF Service With REST And SOAP
 * 
 * @Consumes annotation specifies, the request is coming from the client
 *			you can specify the Mime type as @Consumes("application/xml"), if the request is in xml format
 *
 * @Produces annotation specifies, the response is going to the client
 *			you can specify the Mime type as @Produces ("application/xml"), if the response need to be in xml format
 * 
 */
@WebService(endpointInterface="com.ws.service.IDMRequestService")
public class DmRequestServiceImpl extends DBServiceImpl implements IDMRequestService
{

	@Override
	public List<DMHostMechine> getAllHostMachine() throws BaseException
	{
		String hql = "select new com.emcs.dm.bean.DMHostMechine(v.id,b.enterpriseName,v.lastUploadTime) " +
				"from DmVideo v,BbEnterprise b where v.enterpriseId=b.id";
		
		@SuppressWarnings("unchecked")
		List<DMHostMechine> ts = this.getDao().query(hql);
		
		return ts;
	}

	@Override
	public String request(String name)
	{
		return "hello world";
	}

	@Override
	public DMHostMachines getHosts() throws BaseException
	{
		List<DMHostMechine> ts = this.getAllHostMachine();
		
		DMHostMachines hosts = new DMHostMachines();
		hosts.setHosts(ts);
		
		return hosts;
	}	
}


7>.在classpath下新建webservice的受spring管理的配置文件applicationContext_ws.xml(在web.xml中加入,请参照环境配置第二步)，并加入spring的上下文管理位置 contextConfigLocation 
<?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:tx="http://www.springframework.org/schema/tx"
	xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:cxf="http://cxf.apache.org/core"
	xmlns:jaxrs="http://cxf.apache.org/jaxrs" xmlns:wsa="http://cxf.apache.org/ws/addressing"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="      
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.1.xsd   
     http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd   
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd   
    http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd 
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd  
    http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

	<!-- REST -->
	<import resource="classpath:META-INF/cxf/cxf.xml" />

	<!-- SOAP -->
	<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
	<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />

	<!-- 注入实现类 -->
	<bean id="hello" class="com.ws.service.impl.DmRequestServiceImpl" scope="prototype">
		<property name="dao" ref="baseDao"></property>
		<property name="entity" ref="dmVideoBean"></property>
	</bean>
	
	<util:list id="jsonKeys">
		<value>hosts</value>
	</util:list>
	
	<!-- 对json提供支持 
	-->
	<bean id="jsonProvider" class="org.apache.cxf.jaxrs.provider.json.JSONProvider"> 
        <property name="dropRootElement" value="true"/> 
        <property name="dropCollectionWrapperElement" value="true"/> 
        <property name="serializeAsArray" value="true"/> 
        <!-- 
        <property name="arrayKeys" ref="jsonKeys"/>
         -->
	</bean> 
	<cxf:bus>
		<cxf:inInterceptors>
			<bean class="org.apache.cxf.interceptor.LoggingInInterceptor" />
		</cxf:inInterceptors>
	</cxf:bus>

	<!-- Expose CXF Service With REST And SOAP -->

	<!-- SOAP SERVER(JAX-WS) 
	<jaxws:endpoint id="soapService" address="/soap"
		implementor="#hello" publish="true" />
	-->
	<jaxws:server serviceClass="com.ws.service.IDMRequestService" serviceBean="#hello" 
	address="/soap">
	</jaxws:server>

	<!-- REST SERVER(restful/JAX-RS) -->
	<jaxrs:server address="/rest" id="base" publishedEndpointUrl="http://外网IP地址:8000/cxfservlet/rest">
		<jaxrs:serviceBeans>
			<ref bean="hello" />
		</jaxrs:serviceBeans>
		<!-- 
		 -->
			<jaxrs:providers>         
				<ref local="jsonProvider"/>
			</jaxrs:providers>
	</jaxrs:server>

	<cxf:bus>
		<cxf:features>
			<cxf:logging />
		</cxf:features>
	</cxf:bus>
</beans>

8>.这里使用tomcat服务器，启动服务器在浏览器里输入
http://localhost:8080/cxfservlet/   访问webservice服务，出现下面画面说明发布成功


发布成功的SOAP,也可以通过http://localhost:8080/cxfservlet/soap?wsdl查看wsdl


发布成功的REST,也可以通过http://127.0.0.1:8080/cxfservlet/rest?_wadl查看wadl

9>.客户端调用，远程调用
[list]
  • 导入cxfjar依赖,
  • SOAP访问
    •   ①.通过cxf SDK 生成客户端
        操作步骤：
        DOS命令窗口→切换到cxf SDK bin目录
        通过执行wsdl2java -h 命令查看各参数作用
        执行命令

    wsdl2java -p soap.client –d E:\ http://localhost:8080/cxfservlet/soap?wsdl

    在E盘下生成soap.client文件夹，并在文件夹中生成客户端代码


    其中package-info.java、ObjectFactory.java 是JAXB 需要的文件；IDMRequestServiceService.java
    继承自 javax.xml.ws.Service   类，用于提供 WSDL          的客户端视图 
    package com.ws.service.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.ws.rs.core.MediaType;

import org.apache.cxf.jaxrs.client.WebClient;
import org.apache.cxf.jaxrs.provider.json.JSONProvider;

import com.emcs.dm.bean.DMHostMechine;

public class WsClient
{
	public static void main(String[] args)
	{	
		/* ----------------------标准 JAX-WS API-----------------------------------*/
		/**
		 * new QName(arg0,arg1)
		 * arg0 -------------------- targetNamespace
		 * arg1 -------------------- 对应<wsdl:service 的那么属性,也就是在发布service是的serviceName
		 */
		QName qname = new QName("com.ws.service","IDMRequestServiceService");
		String wsdlLocation = "http://localhost:8080/cxfservlet/soap?wsdl";
		try
		{
			IDMRequestServiceService serviceName = new IDMRequestServiceService(new URL(wsdlLocation),qname);
			IDMRequestService jaxWsService = serviceName.getIDMRequestServicePort();
			DMHostMechineArray arr = jaxWsService.getAllHostMachine();
			List<DMHostMechine> list = arr.getItem();
			if(list.size() > 0)
			{
				System.out.println(list.size());
			}
		}
		catch (MalformedURLException e)
		{
			e.printStackTrace();
		}
		catch (BaseException_Exception e)
		{
			e.printStackTrace();
		}

	/* ----------------------------CXF-----------------------------------
		JaxWsProxyFactoryBean jwpf = new JaxWsProxyFactoryBean(); 
		
		jwpf.setAddress("http://localhost:8080/cxfservlet/soap");
		jwpf.setServiceClass(IDMRequestService.class);
		Object o = jwpf.create();
		IDMRequestService service = (IDMRequestService)o;
		
		try
		{
			DMHostMechineArray arr = service.getAllHostMachine();
			List<DMHostMechine> list = arr.getItem();
			if(list.size() > 0)
			{
				System.out.println(list.size());
			}
		}
		catch (BaseException_Exception e)
		{
			e.printStackTrace();
		}
		--------------------------------------------------------------------------*/
	}
}


  • REST访问 
    • package com.ws.service.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.ws.rs.core.MediaType;

import org.apache.cxf.jaxrs.client.WebClient;
import org.apache.cxf.jaxrs.provider.json.JSONProvider;

import com.emcs.dm.bean.DMHostMechine;

public class WsClient
{
	public static void main(String[] args)
	{
		String restBaseUrl = "http://localhost:8080/cxfservlet/rest";
		
		WebClient client = WebClient.create(restBaseUrl);		client.type(MediaType.APPLICATION_XML).accept(MediaType.APPLICATION_XML);
	
		Collection<? extends DMHostMechine> c = client.path("hostmachine").getCollection(DMHostMechine.class);
		

		if(!c.isEmpty())
		{
			System.out.println(c.size());
		}
/*
		String restBaseUrl = "http://localhost:8080/cxfservlet/rest";
		
		WebClient client = WebClient.create(restBaseUrl);		client.type(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON);
		

		DMHostMachines c = client.path("hosts").get(DMHostMachines.class);
		
		if(c != null)
		{
			List<DMHostMechine> l = c.getHosts();
		}
*/
	}
}


    RESTFull  使用http协议，可以在浏览器里直接访问
    比如可以通过后缀?_type=xml 或者 ?_type=json  来请求响应  XML数据 或者  json 数据,比如：
    http://localhost:8080/cxfservlet/rest/hosts?_type=xml


    [/list]
    • 大小: 122.2 KB
    • 大小: 275.8 KB
    • 大小: 224.2 KB
    • 大小: 19.5 KB
    • 大小: 13.6 KB
    分享到：
    | oracle 数据库迁移
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

    相关推荐

      基于 cxf 2.7.5 开发的 webservice [soap restful]

      【标题】基于CXF 2.7.5开发的WebService：SOAP与RESTful详解 【描述】本项目是使用Apache CXF 2.7.5版本实现的WebService服务，包括了SOAP和RESTful两种常见的Web服务接口。Apache CXF是一个开源的Java框架，它为...

      在同一个系统里用cxf 实现SOAP 协议和RESTful风格 两种类型的webservice接口

      在提供的压缩包文件“cxf-ws-restful-spring-server”中，包含了使用CXF、SOAP和RESTful的示例项目。通过访问“http://localhost:8080/cxf-ws-restful-spring-server/ws63”，我们可以看到这些服务的实际运行效果。...

      cxf webservice restful实现

      它支持多种Web服务规范，包括SOAP和RESTful。本项目聚焦于利用CXF与Spring框架集成，实现RESTful风格的Web服务。REST（Representational State Transfer）是一种轻量级、基于HTTP协议的架构风格，适用于构建可伸缩的...

      cxf_restful_webservice

      本项目“cxf_restful_webservice”着重于使用CXF来创建RESTful风格的Web服务。REST（Representational State Transfer）是一种轻量级的Web服务设计模式，它强调通过HTTP协议暴露资源，使得服务更易于理解和使用。 ...

      WebService CXF 详细教程

      CXF不仅支持SOAP，还支持RESTful风格的服务。它提供了丰富的功能，包括WS-*协议栈支持、客户端和服务端的生成工具、多种传输方式（HTTP、JMS等）、以及与其他Java EE组件的集成。 **三、CXF的主要特性** 1. **强大...

      webservice cxf_demo

      在Web服务的世界里，CXF是一个流行的开源工具，它支持SOAP和RESTful风格的服务，用于构建和消费Web服务。这个"CXF_demo"很可能是为了展示如何用CXF来开发一个简单的"Hello World"应用。 【描述】"cxf写的一个hello...

      RestFul(一)WebService之CXF的RestFul风格开发

      Apache CXF是一个开源的服务框架，它支持多种Web服务标准，包括SOAP和RESTful。CXF提供了一套全面的工具，帮助开发者快速、方便地创建和部署Web服务。 **3. 创建RESTful服务** - **项目配置**：首先，需要在项目中...

      利用CXF发布restful WebService 研究

      【标题】：“利用CXF发布RESTful WebService研究” 在当今的互联网开发中，RESTful Web Service已经成为一种广泛采用的接口设计模式，它基于HTTP协议，以资源为中心，通过统一的URI（Uniform Resource Identifier）...

      WebService CXF 对象传递 附

      CXF支持SOAP、RESTful等多种通信模式，并且能够处理复杂的对象传递，使得Web服务的数据交换更加灵活。本文将深入探讨如何在CXF中进行对象传递，并结合相关代码实例来帮助理解。 1. **CXF简介** CXF（Code first ...

      webservice cxf.jar 相关包

      CXF允许开发者通过SOAP、RESTful、XML以及HTTP等方式来创建和使用Web服务。 标题中的“cxf.jar”指的是Apache CXF的核心库文件，它是Apache CXF框架的基础，包含了处理Web服务请求和响应所需的所有核心组件。这个...

      webService（基于cxf）的完整例子

      例如，可以使用`@WebService`注解标记一个Java类为Web服务接口，并使用`@Path`注解来定义RESTful服务的URL路径。 4. **CXF服务部署**：CXF提供多种部署方式，包括独立服务器、Tomcat等应用服务器，以及Spring容器。...

      spring,cxf,restful发布webservice传递List,Map,List&lt;Map&gt;

      其次，CXF是一个开源的服务框架，它支持多种Web服务标准，如SOAP和RESTful。在Spring应用中集成CXF，可以方便地创建和消费Web服务。通过CXF，我们能够定义服务接口，实现服务逻辑，并将其暴露为Web服务。 RESTful...

      用CXF开发RESTful风格WebService

      【标题】：“用CXF开发RESTful风格WebService” 在Web服务的世界中，REST（Representational State Transfer，表现层状态转移）已经成为一种广泛采用的架构风格，它强调资源的表示和通过HTTP方法进行操作。CXF，...

      cxf发布RestFul接口。 maven

      在IT行业中，CXF是一个广泛使用的开源框架，用于构建和开发Web服务，包括SOAP和RESTful接口。本篇文章将深入探讨如何使用CXF、Spring、Maven等技术栈来发布一个支持HTTP请求和SOAP调用的RestFul接口。 首先，我们...

      spring + cxf + restful + soap 集成小项目

      spring + cxf + restful + soap 方便初学者很快上手。 注解描述 @Path注解的值是一个相对的URI路径，这个路径指定了该Java类的位置，例如/helloworld。在这个URI中可以包含变量，例如可以获取用户的姓名然后作为参数...

      cxf集成Spring的restful WebService接口

      本教程将深入探讨如何在Spring环境中集成CXF以实现RESTful WebService接口。 首先，我们需要理解REST（Representational State Transfer）的概念。REST是一种软件架构风格，用于设计网络应用程序。它的核心思想是...

      WebService CXF --- 传输文件MTOM

      它支持多种协议和规范，包括SOAP、RESTful、XML以及Web服务标准如WS-*。在"WebService CXF --- 传输文件MTOM"这个主题中，我们将深入探讨CXF框架如何利用Message Transmission Optimization Mechanism (MTOM)高效地...

      Java webservice cxf客户端调用demo和服务端

      Java WebService CXF客户端调用和服务端的实现是企业级应用程序中常见的通信方式，它基于标准的SOAP（Simple Object Access Protocol）协议，提供了一种在分布式环境中交换信息的方法。CXF是一个开源框架，它简化了...

      webservice-cxf-spring-jar.zip

      CXF支持多种Web服务标准，包括SOAP、RESTful、WS-*等。同时，"spring"标签表明了它与Spring框架的整合，Spring框架是一个广泛使用的Java企业级应用开发框架，提供依赖注入、事务管理等功能，可以简化CXF的配置和使用...

      webservice cxf jar包

      【标签】"webservice cxf jar包"强调了这是关于CXF框架的Web服务开发工具包，CXF是一个广泛使用的Java框架，它允许开发者通过SOAP和RESTful接口创建和消费Web服务。 以下是一些主要的jar文件及其在Web服务开发中的...

    Magicbox
    Global site tag (gtag.js) - Google Analytics