精华内容
下载资源
问答
  • 项目搭一个webservice

    2018-07-20 14:37:30
    -- webservice服务配置 --> <servlet> <servlet-name>cxf</servlet-name> <servlet-class>org.apache.cxf.transport.servlet.CXFServlet&lt...

    1.在web.xml文件中加入这段代码:

    <!-- webservice服务配置 -->
    <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>/xinbo_hip/bm_Services/*</url-pattern>
    </servlet-mapping> 
      
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/dorado-home/webService.xml</param-value>
    </context-param>
    <!-- webservice服务配置 -->

    2.maven的pom文件中加入:

    <dependency>
        <groupId>org.apache.cxf</groupId>
    	<artifactId>cxf-rt-frontend-jaxws</artifactId>
    	<version>2.5.1</version>
    	<exclusions>
    	    <exclusion>
    		    <artifactId>jaxb-impl</artifactId>
    			<groupId>com.sun.xml.bind</groupId>
    		</exclusion>
    	</exclusions>
    </dependency>
    <dependency>
    	<groupId>com.sun.xml.bind</groupId>
    	<artifactId>jaxb-xjc</artifactId>
    	<version>2.1</version>
    </dependency>

    3.配置文件中webService.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:jaxws="http://cxf.apache.org/jaxws"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://cxf.apache.org/jaxws
            http://cxf.apache.org/schemas/jaxws.xsd">
       <import resource="classpath:META-INF/cxf/cxf.xml"/>
       <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/> 
       <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/> 
    
        <bean id="dataWebServiceProvider" class="com.xinbo.ws.Impl.DataWebServiceProviderImpl"/>
     
         <bean id="inMessageInterceptor" class="org.apache.cxf.interceptor.LoggingInInterceptor"/>
         
        <bean id="outLoggingInterceptor" class="org.apache.cxf.interceptor.LoggingOutInterceptor"/>
    <!--     注意下面的address,这里的address的名称就是访问的WebService的name -->
        
        <jaxws:server id="iDataWebServiceProvider" serviceClass="com.xinbo.ws.IDataWebServiceProvider" address="/wsDataServiceProvider">
            <jaxws:serviceBean>
                <ref bean="dataWebServiceProvider"/>
            </jaxws:serviceBean>
            <jaxws:inInterceptors>
                <ref bean="inMessageInterceptor"/>
            </jaxws:inInterceptors>
            <jaxws:outInterceptors>
                <ref bean="outLoggingInterceptor"/>
            </jaxws:outInterceptors>
        </jaxws:server>  
    </beans>

    jaxws:server   个人理解就是在配置文件中实例化一个JaxWsServerFactoryBean对象。这个类是发布服务的作用。上面的配置意思相当于:

    public static void main(String[] args) {
        JaxWsServerFactoryBean jsfb = new JaxWsServerFactoryBean();
        //1.服务提供者实现的接口
        jsfb.setServiceClass(IDataWebServiceProvider.class);
        //2.指定访问路径
        jsfb.setAddress("http://localhost:8083/xinbo_hip/bm_Services/wsDataServiceProvider");
        //3.指定服务实现类
        jsfb.setServiceBean(new DataWebServiceProviderImpl());
        jsfb.getInInterceptors().add(new LoggingInInterceptor());
        jsfb.getOutInterceptors().add(new LoggingOutInterceptor());
        //4.发布
        jsfb.create();
        System.out.println("发布成功...");
    }

    4.load-on-startup什么意思?

    1. load-on-startup 元素标记容器是否应该在web应用程序启动的时候就加载这个servlet,(实例化并调用其init()方法)。
    2. 它的值必须是一个整数,表示servlet被加载的先后顺序。
    3. 如果该元素的值为负数或者没有设置,则容器会当Servlet被请求时再加载。
    4. 如果值为正整数或者0时,表示容器在应用启动时就加载并初始化这个servlet,值越小,servlet的优先级越高,就越先被加载。值相同时,容器就会自己选择顺序来加载。

    5.@WebParam(name="request")作用?

    接口在被编译为class文件的时候不能保存参数名 ,所以需要这个标签保留名字,自己在开发中吃过这个亏,记录一下,不要再犯了。所以如果没有加注解,参数将被命名为arg0。

    6.webservice接口

    @WebService(targetNamespace="http://ws.xinbo.com/",name = "dataWebServiceProvider", serviceName = "DataWebServiceProvider")
    public interface IDataWebServiceProvider {
        @WebResult(name="return",targetNamespace="http://ws.xinbo.com/")   
        @WebMethod
        public String refund(@WebParam(name="request") String request);
        @WebMethod
    	public String getMedicationRecord(@WebParam(name="request") String request);
        @WebMethod
    	public String sendWxMsg(@WebParam String code, @WebParam String paramJson);
    }

    7.webservice实现类

    @Component
    public class DataWebServiceProviderImpl implements IDataWebServiceProvider{
       
        /**
         * 发送消息
         */
    
        @Override
        public String getMedicationRecord(String request) {
           String result="调用失败";
        	MobileSyshealthOrgInfo mobileSyshealthOrgInfo=systemService.getMbInfo("400686566");
    		if(mobileSyshealthOrgInfo!=null)		{
    			RequestBean requestBean=new RequestBean();
    		    requestBean.setAddress(mobileSyshealthOrgInfo.getWsurl());
    			requestBean.setId("getMedicationRecord");
    			requestBean.setXml(request);
    			ResponseBean responseBean = SendConnect.sendXmlMethod(requestBean);
    			result=responseBean.getResult();
    		}
        	
           	
           return result;
           
        }
    
    
    	@Override
    	public String sendWxMsg(String code, String paramJson) {
    		Gson gson = new Gson();
    		Map<String, Object> map = null;
    		try{
    			map = gson.fromJson(paramJson, new TypeToken<Map<String, Object>>() {}.getType());
    		}catch(Exception e){
    			return "参数解析失败";
    		}
    		String content = StringUtil.parseString(map.get("content"));
    		String Id_No = StringUtil.parseString(map.get("Id_No"));
    		TPatientUser user = mobileDbService.getTPatientUserByParams(null,null,Id_No,null);
    		if(user==null){
    			return "根据身份证号查无此人";
    		}
    		WxMpKefuMessage message=new WxMpKefuMessage();
    		message.setMsgType(WxConsts.KefuMsgType.TEXT);
    		message.setContent(content);
    		message.setToUser(user.getWxId());
    		wxMpService.setWxMpConfigStorage(WeiXinMpInit.defaultStorage);
    		try {
    			wxMpService.getKefuService().sendKefuMessage(message);
    		} catch (WxErrorException e) {
    			return "微信错误代码:"+e.getError().getErrorCode()+";微信错误描述:"+e.getError().getErrorMsg();
    		}
    		return "发送成功";
    	}
        
    }

    8.用soupUI测试接口。

    在摸索中前进。。。。。

     

    展开全文
  • 搭建一个WebService实例

    2017-03-08 10:54:20
    、准备工作(以下为本实例使用工具) 1、MyEclipse10.7.1 2、JDK 1.6.0_22   二、创建服务端 1、创建【Web Service Project】,命名为【TheService】。       2、创建【Class】类,命名为...

    一、准备工作(以下为本实例使用工具)

    1、MyEclipse10.7.1

    2、JDK 1.6.0_22

     

    二、创建服务端

    1、创建【Web Service Project】,命名为【TheService】。



     

     

     

    2、创建【Class】类,命名为【ServiceHello】,位于【com.hyan.service】包下。



     

     

     

    3、编写供客户端调用的方法,即编译方法代码。



     

     

    4、进行编译

    说明:编译失败的话,请将该项目引用的jdk设置为1.6.0_17版本或更高版本



     

     

     

    5、测试结果

    测试地址:http://localhost:9001/Service/ServiceHello?wsdl



     

     

    三、生成客户端

    1、创建【Web Service Project】,命名为【TheClient】。



     

     

     

     

    2、命令提示窗口执行生成命令。

    格式:wsimport -s "src目录" -p “生成类所在包名” -keep “wsdl发布地址”

    示例:

    wsimport -s G:\\workspace\\webService\\TheClient\\src -p com.hyan.client -keep http://localhost:9001/Service/ServiceHello?wsdl

    说明:

    1)"src目录"地址不可含空格

    2)“wsdl发布地址”不要漏了“?wsdl”



     

     

    3、刷新项目,检查生成类



     

     
     

     

    四、最终测试

    1、创建【Class】类,命名为【ServiceTest】,位于【com.hyan.test】包下。





      

     

     

    2、编写测试方法,调用服务端方法,并打印返回的结果。



     

     

     

    五、注意事项

    1、JDK版本过低问题

    报类似如下的异常:runtime modeler error: Wrapper class com.hyan.service.jaxws.GetValue is not found. Have you run APT to generate them?



     

    原因:JDK版本低于1.6.0_17

    解决方法:调整该服务端项目所引用的JDK版本为安装的高版本JDK



     

     

     

     

     

     

     

     

     






     

     

     

    2、生成命令路径含空格问题

    报类似如下的异常:directory not found: G:\SVN_FILE\GB\05



     

    原因:客户端src路径不可含有空格

    解决方法:在不含空格路径的文件夹下重新创建客户端即可。

     

    3、生成命令不完整问题

    报类似如下的异常:[ERROR] failed.noservice=Could not find wsdl:service in the provided WSDL(s):



     

    原因:生成命令末尾缺少“?wsdl”

    解决方法:补上即可。

    错误不完整的命令示例:

    wsimport -s G:\\workspace\\webService\\TheClient\\src -p com.hyan.client -keep http://localhost:9001/Service/ServiceHello

    正确完整的命令示例:

    wsimport -s G:\\workspace\\webService\\TheClient\\src -p com.hyan.client -keep http://localhost:9001/Service/ServiceHello?wsdl



    原文地址:http://www.cnblogs.com/yisheng163/p/4524808.html?utm_source=tuicool


    展开全文
  • WebService

    2020-04-16 20:45:02
    1 前言 1.1 Web Service应用 webservice是开发中比较常用的技术。 由于企业中的开发平台,或平台下...Web services 把 Web 应用程序提升到了另外一个层面: Web Service平台需支持XML + HTTP,HTTP协议是最常用的因...

    1 前言

    1.1 Web Service应用

    webservice是开发中比较常用的技术。

    由于企业中的开发平台,或平台下所有的系统,均可通过Web浏览器访问,那么就涉及到不同平台下的系统之间的交互协同工作。webservice为此提供了技术支持。

    Web services 把 Web 应用程序提升到了另外一个层面:

    1. Web Service平台需支持XML + HTTP,HTTP协议是最常用的因特网协议,XML提供了一种可用于不同平台和编程语言之间的语言。
    2. Web Services能够解决不同平台、不同语言编写的应用之间如何相互调用问题。
    3. 使用 Web Services,我们的应用程序可以向全世界发布信息,或提供某项功能。

    1.2 Web Service简介

    Web Service所使用的是Internet上统一、开放的标准,如HTTP、XML、SOAP(简单对象访问协议)、WSDL等,所以Web Service可以在任何支持这些标准的环境(Windows,Linux)中使用。

    这有助于大量异构程序和平台之间的互操作性,从而使存在的应用程序能够被广泛的用户访问。

    从应用来说,Web Service是一件值得企业特别注意的事情。Web Service的应用范围目前包括两个方面:企业之间的应用、以及企业内部的应用。

    企业之间的应用主要包括人们熟悉的企业间的电子商务(B2B)和企业与消费者之间的电子商务(B2C)。
    Web Service在B2B的应用包括:以企业采购、物流和分销为内容的供应链;以及涉及到零售、B2C以及中间业务的支付系统。

    而相对来说,企业内部的应用比企业之间的电子商务应用要成熟一些,并得到广泛的采用。最为普遍的应用是:采用中间件应用服务器软件作为工具将企业各项应用都进行改造和开发,开发目标是以Web为基础的应用,或者称为应用软件的网络化。目前企业内部这种网络应用还包括现在流行的ERP以及CRM等等。

    2 webservice基本概念

    2.1 什么是web服务

    常见的web服务:

    1. 手机淘宝、京东….
    2. 天气预报(一般网站获取天气预报信息都是通过调用气象局的接口获取相关城市的天气信息
    3. 手机号归属地
    4. 股票查询
    5. 发手机短消息
    6. 手机充值功能
    7. 中英文翻译
    8. 银行转账业务
    9. 公司的“进销存系统”在某商品缺货时自动给供应商下订单

    2.2 简介

    1. webservice 即web服务,它是一种跨编程语言和跨操作系统平台的远程调用技术,适用于多个系统之间的调用,数据传递。

      如图:在这里插入图片描述

    2. JAVA 中共有三种WebService 规范,分别是JAX-WS(JAX-RPC)(常用)、JAXM&SAAJ、JAX-RS(常用)。

      • JAX-WS(JAX-RPC):使用soap协议,传输xml文件
      • JAX-RS:基于REST风格,使用http协议,传输xml文件或者json文件
    3. webService三要素:soap、wsdl、uddi

    2.3 术语

    2.3.1 webservice开发规范

    JAVA 中共有三种WebService规范,分别是JAXM&SAAJ、JAX-WS(JAX-RPC)、JAX-RS。

    2.3.1.1 JAX-WS(常用)

    ​ JAX-WS(Java API For XML-WebService),JDK1.6 自带的版本为JAX-WS2.1,其底层支持为JAXB。JAX-WS(JSR 224)规范的API 位于javax.xml.ws.*包,其中大部分都是注解,提供API 操作Web 服务(通常在客户端使用的较多,由于客户端可以借助SDK 生成,因此这个包中的API 我们较少会直接使用)。

    2.3.1.2 JAXM&SAAJ

    ​ JAXM(JAVA API For XML Message)主要定义了包含了发送和接收消息所需的API,相当于Web 服务的服务器端,其API 位于javax.messaging.*包,它是JAVA EE 的可选包,因此你需要单独下载。SAAJ(SOAP With Attachment API For Java,JSR 67)是与JAXM 搭配使用的API,为构建SOAP 包和解析SOAP 包提供了重要的支持,支持附件传输,它在服务器端、客户端都需要使用。这里还要提到的是SAAJ 规范,其API 位于javax.xml.soap.*包。JAXM&SAAJ 与JAX-WS 都是基于SOAP 的Web 服务,相比之下JAXM&SAAJ暴漏了SOAP更多的底层细节,编码比较麻烦,而JAX-WS 更加抽象,隐藏了更多的细节,更加面向对象,实现起来你基本上不需要关心SOAP 的任何细节。那么如果你想控制SOAP 消息的更多细节,可以使用JAXM&SAAJ,目前版本为1.3。

    2.3.1.3 JAX-RS(常用)

    ​ JAX-RS 是JAVA 针对REST(RepresentationState Transfer)风格制定的一套Web 服务规范,由于推出的较晚,该规范(JSR 311,目前JAX-RS 的版本为1.0)并未随JDK1.6 一起发行,你需要到JCP 上单独下载JAX-RS 规范的接口,其API 位于javax.ws.rs.*包。这里的JAX-WS 和JAX-RS 规范我们采用Apache CXF 作为实现,CXF 是Objectweb Celtix和Codehaus XFire 合并而成。CXF 的核心是org.apache.cxf.Bus(总线),类似于Spring 的ApplicationContext,Bus 由BusFactory 创建,默认是SpringBusFactory 类,可见默认CXF是依赖于Spring 的,Bus 都有一个ID,默认的BUS 的ID 是cxf。你要注意的是Apache CXF2.2 的发行包中的jar 你如果直接全部放到lib 目录,那么你必须使用JDK1.6,否则会报JAX-WS 版本不一致的问题。对于JAXM&SAAJ 规范我们采用JDK 中自带的默认实现。

    2.3.2 SOAP协议

    1. SOAP即简单对象访问协议(Simple Object Access Protocol),主要用于客户端和服务端通信使用的数据协议。它是用于交换XML(标准通用标记语言下的一个子集)编码信息的轻量级协议。它有三个主要方面:XML-envelope为描述信息内容和如何处理内容定义了框架,将程序对象编码成为XML对象的规则,执行远程过程调用(RPC)的约定。SOAP可以运行在任何其他传输协议上。
    2. SOAP作为一个基于XML语言的协议用于有网上传输数据。
    3. SOAP = 在HTTP的基础上+XML数据。(JAX-WS)。
    4. SOAP是基于HTTP的。
    5. SOAP的组成如下。

    2.3.3 wsdl说明书

    Web Service描述语言WSDL(SebService Definition Language)就是用机器能阅读的方式提供的一个正式描述文档而基于XML(标准通用标记语言下的一个子集)的语言,用于描述Web Service及其函数、参数和返回值。因为是基于XML的,所以WSDL既是机器可阅读的,又是人可阅读的。

    wsdl说明书:

    1. 通过wsdl说明书,就可以描述webservice服务端对外发布的服务;
    2. wsdl说明书是一个基于xml文件,通过xml语言描述整个服务;
    3. 在wsdl说明中,描述了:
      • 对外发布的服务名称(类)
      • 接口方法名称(方法)
      • 接口参数(方法参数)
      • 服务返回的数据类型(方法返回值)

    2.3.4 UDDI

    ​ Web 服务提供商又如何将自己开发的 Web 服务公布到因特网上,这就需要使用到 UDDI 了,UDDI的话,是一个跨产业,跨平台的开放性架构,可以帮助Web 服务提供商在互联网上发布 Web 服务的信息。UDDI 是一种目录服务,企业可以通过 UDDI 来注册和搜索 Web 服务。简单来时候话,UDDI 就是一个目录,只不过在这个目录中存放的是一些关于 Web 服务的信息而已。
    ​ 并且 UDDI 通过SOAP 进行通讯,构建于 . Net 之上。UDDI 即 Universal Description,Discovery andIntegration,也就是通用的描述,发现以及整合。UDDI 的目的是为电子商务建立标准;UDDI是一套基于Web的、分布式的、为WebService提供的、信息注册中心的实现标准规范,同时也包含一组使企业能将自身提
    供的Web Service注册,以使别的企业能够发现的访问协议的实现标准。

    2.4 应用场景

    Web Service 可以适用于应用程序集成、软件重用、跨防火墙通信等需求。不同的
    业务要求不同。具体如下:
    在这里插入图片描述

    • 跨防火墙通信
    • 应用系统集成
    • 软件和数据重用

    简单来说,如果一个功能,需要被多个系统使用可以使用webservice开发一个服务端接口,供不同的客户端应用。主要应用在企业内部系统之间的接口调用、面向公网的webservice服务。

    2.5 优缺点

    2.5.1 优点

    • 异构平台的互通性

      理论上, Web Service 最大的优势是提供了异构平台的无缝街接技术手段。由于不同的用户使用不同的硬件平台,不同的操作平台,不同的操作系统,不同的软件,不同的协议通信,这就产生了互相通信的需求。 Web Service 使任何两个应用程序,只要能读写XML,那么就能互相通信。

    • 更广泛的软件复用(例如手机淘宝可以复用已有淘宝的业务逻辑.)

      软件的复用技术通过组合已有模块来搭建应用程序,能大幅度提高软件的生产效率和质量。用户只要获得了描述 Web Service 的 WSDL 文件,就可以方便地生成客户端代理,并通过代理访问 Web Service 。

    • 成本低、可读性强、应用范围广

      Web Service 可用基于 XML 的 SOAP 来表示数据和调用请求。并且通过 HTTP 协议传输XML 格式的数据

    • 迅捷的软件发行方式

      (每个web Service称为一个生产者.不同的生产者可以相互协同合作完成整个应用)Web Service 将彻底地改变软件的发行方式。软件供应商可以把软件分解成若Web Service 模块构成的系统,直接在 Web 上发布。

    • 最重要的一点

      客户端与服务端可能是用不同的语言开发的,但是,通过webservice提供服务接口,客户端与服务端之前可以传递对象。(基于soap协议)
      在这里插入图片描述

    2.5.2 缺点

    • 由于soap是基于xml传输,本身使用xml传输会传输一些无关内容从而影响效率,随着soap协议的完善,soap协议增加了许多内容,这样就导致了使用soap去完成简单的数据传输而携带的信息更多效率再受影响;

    • Web Service作为web跨平台访问的标准技术,很多公司都限定要求使用Web Service,但如果是简单的接口可以直接使用http传输自定义数据格式,开发更快捷。

    2.6 面向服务架构SOA

    SOA(Service-OrientedArchitecture)面向服务架构是一种思想,它将应用程序的不同功能单元通过中立的契约(独立于硬件平台、操作系统和编程语言)联系起来,使得各种形式的功能单元更好的集成。目前来说,WebService 是SOA 的一种较好的实现方WebService 采用HTTP 作为传输协议,SOAP(Simple Object Access Protocol)作为传输消息的格式。但WebService 并不是完全符合SOA 的概念,因为SOAP 协议是WebService 的特有协议,并未符合SOA 的传输协议透明化的要求。SOAP 是一种应用协议,早期应用于RPC 的实现,传输协议可以依赖于HTTP、SMTP 等。

    SOA 的产生共经历了如下过程:
    20200101152836807

    通常采用SOA 的系统叫做服务总线(BUS),结构如下图所示:
    在这里插入图片描述

    3 ApacheCXF 框架介绍

    3.1 关于 Apache CXF(对web service的实现框架)

    Apache CXF = Celtix + XFire,ApacheCXF 的前身叫 Apache CeltiXfire,现在已经正式更名为 Apache CXF 了,以下简称为 CXF。CXF 继承了 Celtix 和XFire 两大开源项目的精华,提供了对 JAX-WS 全面的支持,并且提供了多种 Binding 、DataBinding、Transport 以及各种 Format 的支持,并且可以根据实际项目的需要,采用代码优先
    (Code First)或者 WSDL 优先(WSDL First)来轻松地实现 Web Services 的发布和使用。目前它仍只是 Apache 的一个孵化项目。
    Apache CXF 是一个开源的 Services 框架,CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ,像 JAX-WS 。这些 Services 可以支持多种协议,比如:SOAP、XML/HTTP、RESTfulHTTP 或者 CORBA ,并且可以在多种传输协议上运行,比如:HTTP、JMS 或者 JBI,CXF 大大简化了 Services 的创建,同时它继承了 XFire 传统,一样可以天然地和 Spring 进行无缝集成。

    3.2 功能特性

    CXF 包含了大量的功能特性,但是主要集中在以下几个方面:

    • 支持 Web Services 标准:CXF 支持多种 Web Services 标准,包含 SOAP、BasicProfile、WS-Addressing、WS-Policy、WS-ReliableMessaging 和 WS-Security。
    • Frontends:CXF 支持多种“Frontend”编程模型,CXF 实现了 JAX-WS API (遵循JAX-WS 2.0 TCK 版本),它也包含一个“simple frontend”允许客户端和 EndPoint 的创建,而不需要 Annotation 注解。CXF 既支持 WSDL 优先开发,也支持从 Java 的代码优先开发模式。
    • 容易使用: CXF 设计得更加直观与容易使用。有大量简单的 API 用来快速地构建代码优先的 Services,各种 Maven 的插件也使集成更加容易,支持 JAX-WS API ,支持Spring 2.0 更加简化的 XML 配置方式,等等。
    • 支持二进制和遗留协议:CXF 的设计是一种可插拨的架构,既可以支持 XML ,也可以支持非 XML 的类型绑定,比如:JSON 和 CORBA。

    4 ApacheCXF 实现WebService(Jax-ws)

    4.1 服务端

    4.1.1 创建项目

    • file—>new —>module…
      20200101154146390
    • next 在这里插入图片描述
    • next
      在这里插入图片描述

    4.1.2 添加cxf依赖

    • 项目的pom.xml 添加如下依赖

      <?xml version="1.0" encoding="UTF-8"?>
      
      <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
          <modelVersion>4.0.0</modelVersion>
      
          <groupId>com.itheima</groupId>
          <artifactId>01_jaxws_server</artifactId>
          <packaging>pom</packaging>
          <version>1.0-SNAPSHOT</version>
          <modules>
              <module>../03_jaxws_spring_server</module>
          </modules>
      
          <name>01_jaxws_server</name>
          <dependencies>
              <!-- 要进行jaxws 服务开发 -->
              <dependency>
                  <groupId>org.apache.cxf</groupId>
                  <artifactId>cxf-rt-frontend-jaxws</artifactId>
                  <version>3.0.1</version>
              </dependency>
      
              <!-- 内置jetty web服务器  -->
              <dependency>
                  <groupId>org.apache.cxf</groupId>
                  <artifactId>cxf-rt-transports-http-jetty</artifactId>
                  <version>3.0.1</version>
              </dependency>
      
              <!-- 日志实现 -->
              <dependency>
                  <groupId>org.slf4j</groupId>
                  <artifactId>slf4j-log4j12</artifactId>
                  <version>1.7.12</version>
              </dependency>
              <dependency>
                  <groupId>junit</groupId>
                  <artifactId>junit</artifactId>
                  <version>4.10</version>
                  <scope>test</scope>
              </dependency>
          </dependencies>
      
          <build>
              <pluginManagement>
                  <plugins>
                      <plugin>
                          <groupId>org.apache.maven.plugins</groupId>
                          <artifactId>maven-compiler-plugin</artifactId>
                          <version>3.2</version>
                          <configuration>
                              <source>1.8</source>
                              <target>1.8</target>
                              <encoding>UTF-8</encoding>
                              <showWarnings>true</showWarnings>
                          </configuration>
                      </plugin>
                  </plugins>
              </pluginManagement>
          </build>
      </project>
      

    4.1.3 写服务接口

    接口使用@WebService注解
    在这里插入图片描述

    4.1.4 写服务接口实现

    在这里插入图片描述

    4.1.5 发布服务

    运行该函数发布服务

    import com.itheima.service.impl.HelloServiceImpl;
    import org.apache.cxf.interceptor.LoggingInInterceptor;
    import org.apache.cxf.interceptor.LoggingOutInterceptor;
    import org.apache.cxf.jaxws.JaxWsServerFactoryBean;
    
    public class Server {
        public static void main(String[] args) {
            //  发布服务的工厂
            JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean();
            //  设置服务地址
            factory.setAddress("http://localhost:8000/ws/hello");
            //  设置服务类
            factory.setServiceBean(new HelloServiceImpl());
            //  添加日志输入、输出拦截器,观察soap请求、soap响应内容
            factory.getInInterceptors().add(new LoggingInInterceptor());
            factory.getOutInterceptors().add(new LoggingOutInterceptor());
            //  发布服务
            factory.create();
            System.out.println("发布服务成功,端口8000.....");
        }
    }
    

    4.1.6 访问wsdl说明书

    • 服务发布成功:
      在这里插入图片描述
    • 访问wsdl说明书
    • 在这里插入图片描述
      阅读顺序,从下往上读。

    wsdl说明书为:服务地址+?wsdl
    在这里插入图片描述

    4.2 客户端

    写客户端之前要先明确:

    1. 服务端地址
    2. 服务端接口、接口方法(方法参数、返回值)

    4.2.1 创建项目

    创建项目:02_jaxws_client

    4.2.2 添加依赖

    与服务端项目依赖一致。

    4.2.3 服务接口(必须与服务端的接口一致,最好直接拷贝)

    在这里插入图片描述

    4.2.4 远程访问服务端

    在这里插入图片描述
    在这里插入图片描述

    4.3 添加日志拦截器,观察soap协议内容

    4.3.1 服务端

    在服务端添加日志输入输出拦截器

    20200101173111063

    4.3.2 客户端调用,观察日志

    查看soap请求、soap响应传输的xml数据

    2018‐04‐10 10:52:30,439 72440 [tp2017085051‐18] INFO
    serServiceImplPort.UserService ‐ Inbound Message
    ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
    ID: 4
    Address: http://192.168.95.62:8000/userService
    Encoding: UTF‐8
    Http‐Method: POST soap请求
    Content‐Type: text/xml; charset=UTF‐8
    Headers: {Accept=[*/*], Cache‐Control=[no‐cache], connection=[keepalive],
    Content‐Length=[193], content‐type=[text/xml; charset=UTF‐8],
    Host=[192.168.95.62:8000], Pragma=[no‐cache], SOAPAction=[""], User‐
    Agent=[Apache CXF 3.0.1]}
    Payload: <soap:Envelope
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body>
    <ns2:welcome xmlns:ns2="http://service.itcast.cn/"><arg0>请求数据</arg0>
    </ns2:welcome></soap:Body></soap:Envelope>
    ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
    2018‐04‐10 10:52:30,442 72443 [tp2017085051‐18] INFO
    serServiceImplPort.UserService ‐ Outbound Message
    ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
    ID: 4
    Response‐Code: 200 soap响应
    Encoding: UTF‐8
    Content‐Type: text/xml
    Headers: {}
    Payload: <soap:Envelope
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body>
    <ns2:welcomeResponse xmlns:ns2="http://service.itcast.cn/"><return>响应数
    据</return></ns2:welcomeResponse></soap:Body></soap:Envelope>
    ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
    

    5 Spring 整合 ApacheCXF 实WebService(Jax-ws)

    5.1 服务端

    5.1.1 创建web项目

    • file—>new —>module… 在这里插入图片描述
    • next 在这里插入图片描述
    • next
      在这里插入图片描述
    • next 在这里插入图片描述 在这里插入图片描述

    5.1.2 添加依赖

    pom.xml

    <dependencies>
        <!-- CXF WS开发  -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>3.0.1</version>
        </dependency>
    
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                    <showWarnings>true</showWarnings>
                </configuration>
            </plugin>
            <!-- 运行tomcat7方法:tomcat7:run -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <!-- 指定端口 -->
                    <port>8080</port>
                    <!-- 请求路径 -->
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
    ``
    ### 5.1.3 web.xml 配置CXFServlet
    ```xml
    <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
            "http://java.sun.com/dtd/web-app_2_3.dtd" >
    
    <web-app>
      <display-name>Archetype Created Web Application</display-name>
      <!--1. cxfsevlet配置-->
      <!--  webservice服务端,发布服务需要配置CXFServlet -->
      <!--  这里配置的servlet路径,最为最终服务路径的一部分-->
      <!--  服务访问路径:http://localhost:8080/ws/hello配置路径/spring配置的路径-->
      <servlet>
        <servlet-name>cxfservlet</servlet-name>
        <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
      </servlet>
      <servlet-mapping>
        <servlet-name>cxfservlet</servlet-name>
        <url-pattern>/ws/*</url-pattern>
      </servlet-mapping>
      <!--2.spring容器配置-->
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
      </context-param>
      <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
    </web-app>
    

    5.1.4 服务接口、服务实现

    在这里插入图片描述

    • 接口 在这里插入图片描述
    • 实现类
      在这里插入图片描述

    5.1.5 Spring 整合 ApacheCXF

    Spring的配置文件applicationContext.xml
    在这里插入图片描述

    <?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:cxf="http://cxf.apache.org/core"
           xmlns:jaxws="http://cxf.apache.org/jaxws"
           xmlns:jaxrs="http://cxf.apache.org/jaxrs"
           xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://cxf.apache.org/core
            http://cxf.apache.org/schemas/core.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">
    
            <!--
                Spring整合cxf发布服务,关键点:
                1. 服务地址
                2. 服务类
                服务完整访问地址:协议://ip:port/web.xml配置路径/applicationContext.xml配置路径
                    即:http://localhost:8080/ws/hello
            -->
        <jaxws:server address="/hello">
            <jaxws:serviceBean>
                <bean class="com.itheima.service.impl.HelloServiceImpl"></bean>
            </jaxws:serviceBean>
        </jaxws:server>
    </beans>
    

    5.1.6 启动服务,发布服务在这里插入图片描述

    5.1.7 访问wsdl说明书

    地址:http://localhost:8080/ws/hello?wdll
    在这里插入图片描述

    5.2 客户端

    5.2.1 创建项目

    创建04_jaxws_spring_client项目
    在这里插入图片描述
    web.xml配置内容可以删除。服务实现也删除。

    5.2.2 添加依赖

    与服务端相同

    5.2.3 service接口在这里插入图片描述

    5.2.4 Spring 整合 ApacheCXF 配置

    <?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:cxf="http://cxf.apache.org/core"
           xmlns:jaxws="http://cxf.apache.org/jaxws"
           xmlns:jaxrs="http://cxf.apache.org/jaxrs"
           xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://cxf.apache.org/core
            http://cxf.apache.org/schemas/core.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">
            <!--
                Spring整合ApacheCXF,客户端配置
                通过Spring整合ApacheCXF,创建客户端的代理对象,远程访问服务端。
                jaxws:client
                id:应用中注入的接口的代理对象的名称(http://localhost:8080/ws/hello)
                address:服务端访问地址
                serviceClass 指定接口路径,会根据该类型生成代理对象
            -->
        <jaxws:client
                id="helloService"
                serviceClass="com.itheima.service.HelloService"
                address="http://localhost:8080/ws/hello">
        </jaxws:client>
    </beans>
    

    5.2.5 junit测试

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class Client {
        // 注入对象
        @Resource
        private HelloService helloService;
    
        @Test
        public void remote(){
            // 查看接口的代理对象类型
            // class com.sun.proxy.$Proxy45
            System.out.println(helloService.getClass());
            // 远程访问服务端方法
            System.out.println(helloService.sayHello("Jerry"));
        }
    }
    

    效果:
    在这里插入图片描述

    6.Restful 风格

    一种软件架构风格,设计风格而不是标准,只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制

    REST(英文:Representational State Transfer,简称REST)描述了一个架构样式的网络系统,比如 web 应用程序。它首次出现在 2000 年 Roy Fielding 的博士论文中,他是HTTP 规范的主要编写者之一。在目前主流的三种Web服务交互方案中,REST相比于SOAP(Simple Object Access protocol,简单对象访问协议)以及XML-RPC更加简单明了,无论是对URL的处理还是对Payload的编码,REST都倾向于用更加简单轻量的方法设计和实现。值得注意的是REST并没有一个明确的标准,而更像是一种设计的风格。

    所谓"资源",就是网络上的一个实体,或者说是网络上的一个具体信息。它可以是一段文本、一张图片、一首歌曲、一种服务,总之就是一个具体的实在。你可以用一个URI指向它,每种资源对应一个特定的URI。要获取这个资源,访问它的URI就可以,因此URI就成了每一个资源的地址或独一无二的识别符。所谓"上网",就是与互联网上一系列的"资源"互动,调用它的URI。

    表现层,我们把"资源"具体呈现出来的形式,叫做它的"表现层"(Representation)。

    比如,文本可以用txt格式表现,也可以用HTML格式、XML格式、JSON格式表现,甚至可以采用二进制格式;图片可以用JPG格式表现,也可以用PNG格式表现。

    Restful 风格: http://bbs.csdn.net/topics/390908212

    非resfull风格:http://bbs.csdn.net/topics?tid=390908212

    严格地说,有些网址最后的".html"后缀名是不必要的,因为这个后缀名表示格式,属于"表现层"范畴,而URI应该只代表"资源"的位置。它的具体表现形式,应该在HTTP请求的头信息中用Accept和Content-Type字段指定,这两个字段才是对"表现层"的描述。

    状态转化(State Transfer)

    访问一个网站,就代表了客户端和服务器的一个互动过程。在这个过程中,势必涉及到数据和状态的变化。互联网通信协议HTTP协议,是一个无状态协议。这意味着,所有的状态都保存在服务器端。因此,如果客户端想要操作服务器,必须通过某种手段,让服务器端发生"状态转化"(StateTransfer)。而这种转化是建立在表现层之上的,所以就是"表现层状态转化"。客户端用到的手段,只能是HTTP协议。具体来说,就是HTTP协议里面,四个表示操作方式的动词:GET、POST、PUT、DELETE。它们分别对应四种基本
    操作:

    • GET用来获取资源
    • POST用来新建资源
    • PUT用来更新资源
    • DELETE用来删除资源

    访问服务器资源,通过不同的http请求方式,服务器就知道对CRUD的哪个操作。JAX-RS 发布服务就是使用RESTFUL风格。

    • Restful编程风格

      访问url地址更加简洁、更有层次感、更易于浏览器缓存。

    • 举例

      基于restful风格的url: https://miaosha.jd.com/#2357091

      访问后台curd方法,url地址怎么写:

      传统做法:

      ​ http://localhost:8080/prj/userAction?type=add

      ​ http://localhost:8080/prj/userAction?type=update

      ​ http://localhost:8080/prj/userAction?type=delete

    ​ 基于restful风格的url:

    ​ http://localhost:8080/prj/userAction 系统一个地址对应后台的crud四个方法。

    ​ 添加

    ​ http://localhost:8080/prj/userAction

    ​ 请求方式:post

    ​ 修改

    ​ http://localhost:8080/prj/userAction

    ​ 请求方式:put

    ​ 删除

    ​ http://localhost:8080/prj/userAction

    ​ 请求方式:delete

    @Path("/userService")
    @Produces("*/*")
    public interface IUserService {
    
    	@POST
    	@Path("/user")
    	@Consumes({ "application/xml", "application/json" })
    	public void saveUser(User user);
    
    	@PUT
    	@Path("/user")
    	@Consumes({ "application/xml", "application/json" })
    	public void updateUser(User user);
    
    	@GET
    	@Path("/user")
    	@Produces({ "application/xml", "application/json" })
    	public List<User> findAllUsers();
    
    	@GET
    	@Path("/user/{id}")
    	@Consumes("application/xml")
    	@Produces({ "application/xml", "application/json" })
    	public User finUserById(@PathParam("id") Integer id);
    
    	@DELETE
    	@Path("/user/{id}")
    	@Consumes({"application/xml", "application/json"})
    	public void deleteUser(@PathParam("id") Integer id);
    }
    

    7 ApacheCXF 实现webservice(Jax-rs)

    基于restful风格的webservice,请求使用的是http协议,可以传递xml/json数据

    7.1 服务端

    7.1.1 创建项目

    • 创建项目 在这里插入图片描述
    • next 在这里插入图片描述
    • next
      在这里插入图片描述

    7.1.2 添加依赖

    pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
        <groupId>com.itheima</groupId>
        <artifactId>05_jaxrs_server</artifactId>
        <version>1.0-SNAPSHOT</version>
        <modelVersion>4.0.0</modelVersion>
        <name>05_jaxrs_server</name>
    
        <dependencies>
            <!-- jaxrs 支持包 -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-frontend-jaxrs</artifactId>
                <version>3.0.1</version>
            </dependency>
    
            <!-- 内置的jetty服务器 -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-transports-http-jetty</artifactId>
                <version>3.0.1</version>
            </dependency>
    
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>1.7.12</version>
            </dependency>
    
            <!-- 客户端调用时候使用的包(WebClient工具类调用服务端) -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-rs-client</artifactId>
                <version>3.0.1</version>
            </dependency>
    
            <!-- 基于restful风格的webservice,客户端与服务端之间可以传递json,这个就是json支持相关包 -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-rs-extension-providers</artifactId>
                <version>3.0.1</version>
            </dependency>
            <dependency>
                <groupId>org.codehaus.jettison</groupId>
                <artifactId>jettison</artifactId>
                <version>1.3.7</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.10</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
        <build>
          <pluginManagement>
              <plugins>
                  <!-- maven的jdk编译插件 -->
                  <plugin>
                      <groupId>org.apache.maven.plugins</groupId>
                      <artifactId>maven-compiler-plugin</artifactId>
                      <version>3.2</version>
                      <configuration>
                          <source>1.8</source>
                          <target>1.8</target>
                          <encoding>UTF-8</encoding>
                          <showWarnings>true</showWarnings>
                      </configuration>
                  </plugin>
              </plugins>
          </pluginManagement>
      </build>
    </project>
    

    7.1.3 服务接口、实现、实体类

    1. User类

      package com.itheima.entity;
      
      import javax.xml.bind.annotation.XmlRootElement;
      import java.util.ArrayList;
      import java.util.List;
      
      /**
       *  基于restful风格的webservice,客户端与服务端之间通讯可以传递xml数据、json数据
       *  @XmlRootElement 指定对象序列化为xml或json数据时根节点的名称
       *  xml:
       *       <User>
       *           <id></id>
       *           <username></username>
       *           <city></city>
       *       </User>
       *   json:
       *   {"User":  {"id":100,  "username":"jack","city":"广州" }}
       *
       */
      @XmlRootElement(name = "User")
      public class User {
      	private Integer id;
      	private String username;
      	private String city;
      
      	private List<Car> cars = new ArrayList<Car>();
      
      	public Integer getId() {
      		return id;
      	}
      
      	public void setId(Integer id) {
      		this.id = id;
      	}
      
      	public String getUsername() {
      		return username;
      	}
      
      	public void setUsername(String username) {
      		this.username = username;
      	}
      
      	public String getCity() {
      		return city;
      	}
      
      	public void setCity(String city) {
      		this.city = city;
      	}
      
      	public List<Car> getCars() {
      		return cars;
      	}
      
      	public void setCars(List<Car> cars) {
      		this.cars = cars;
      	}
      
      	@Override
      	public String toString() {
      		return "User [id=" + id + ", username=" + username + ", city=" + city + ", cars=" + cars + "]";
      	}
      }
      
    2. Car类

      package com.itheima.entity;
      
      import javax.xml.bind.annotation.XmlRootElement;
      
      @XmlRootElement(name = "Car")
      public class Car {
      	private Integer id;
      	private String carName;
      	private Double price;
      
      	public Integer getId() {
      		return id;
      	}
      
      	public void setId(Integer id) {
      		this.id = id;
      	}
      
      	public String getCarName() {
      		return carName;
      	}
      
      	public void setCarName(String carName) {
      		this.carName = carName;
      	}
      
      	public Double getPrice() {
      		return price;
      	}
      
      	public void setPrice(Double price) {
      		this.price = price;
      	}
      
      	@Override
      	public String toString() {
      		return "Car [id=" + id + ", carName=" + carName + ", price=" + price + "]";
      	}
      
      }
      
    3. Service接口

      package com.itheima.service;
      
      import com.itheima.entity.User;
      
      import javax.ws.rs.*;
      import java.util.List;
      
      //  访问当前服务接口对应的路径
      @Path("/userService")
      @Produces("*/*")  // 服务器支持的返回的数据格式类型
      public interface IUserService {
      
      	// 表示处理的请求的类型,post 对应的是insert新增操作
      	@POST
      	// 访问当前服务接口方法对应的路径。 【.../userService/user】
      	@Path("/user")
      	//  服务器支持的请求的数据格式类型
      	@Consumes({"application/xml", "application/json" })
      	public void saveUser(User user);
      
      	// 表示处理的请求的类型,put 对应的是update修改操作
      	@PUT
      	@Path("/user")
      	@Consumes({ "application/xml", "application/json" })
      	public void updateUser(User user);
      
      	// 表示处理的请求的类型,get 对应的是查询修改操作
      	@GET
      	@Path("/user")
      	// 服务器支持的返回的数据格式类型
      	@Produces({ "application/xml", "application/json" })
      	public List<User> findAllUsers();
      
      	@GET
      	@Path("/user/{id}")
      	@Consumes("application/xml")
      	@Produces({ "application/xml", "application/json" })
      	public User finUserById(@PathParam("id") Integer id);
      
      	// 表示处理的请求的类型,delete 对应的是删除操作
      	@DELETE
      	@Path("/user/{id}")
      	@Consumes({"application/xml", "application/json"})
      	public void deleteUser(@PathParam("id") Integer id);
      }
      

      使用的注解分析

      使用的注解:

      1. @XmlRootElement
        指定根元素,
        作用:客户端与服务端传递对象数据时候,序列化为xml或json的根元素的名称
      2. @Path("/userService")
        路径;访问当前服务接口时候的路径、接口方法的路径。
      3. @POST insert操作
      4. @PUT update操作
      5. @GET select 查询操作
      6. @DELETE delete删除操作
      7. @Consumes 服务端支持的请求的数据格式(xml、json)
      8. @Produces 服务端支持的响应的数据格式
    4. Service实现类

      package com.itheima.service;
      
      import com.itheima.entity.Car;
      import com.itheima.entity.User;
      
      import java.util.ArrayList;
      import java.util.List;
      
      public class UserServiceImpl implements IUserService {
      
      	public void saveUser(User user) {
      		System.out.println("save user:" + user);
      	}
      
      	public void updateUser(User user) {
      		System.out.println("update user:" + user);
      	}
      
      	public List<User> findAllUsers() {
      		List<User> users = new ArrayList<User>();
      		User user1 = new User();
      		user1.setId(1);
      		user1.setUsername("小明");
      		user1.setCity("北京");
      
      		List<Car> carList1 = new ArrayList<Car>();
      		Car car1 = new Car();
      		car1.setId(101);
      		car1.setCarName("保时捷");
      		car1.setPrice(1000000d);
      		carList1.add(car1);
      		Car car2 = new Car();
      		car2.setId(102);
      		car2.setCarName("宝马");
      		car2.setPrice(400000d);
      		carList1.add(car2);
      		user1.setCars(carList1);
      
      		users.add(user1);
      
      		User user2 = new User();
      		user2.setId(2);
      		user2.setUsername("小丽");
      		user2.setCity("上海");
      		users.add(user2);
      
      		return users;
      	}
      
      	public User finUserById(Integer id) {
      		if (id == 1) {
      			User user1 = new User();
      			user1.setId(1);
      			user1.setUsername("小明");
      			user1.setCity("北京");
      			return user1;
      		}
      		return null;
      	}
      
      	public void deleteUser(Integer id) {
      		System.out.println("delete user id :" + id);
      	}
      }
      

    7.1.4 发布服务

    public class Server {
     public static void main(String[] args) {
         // 创建发布服务的工厂
         JAXRSServerFactoryBean factory = new JAXRSServerFactoryBean();
         // 设置服务地址
         factory.setAddress("http://localhost:8001/ws/");
         // 设置服务类
         factory.setServiceBean(new UserServiceImpl());
         // 添加日志输入输出拦截器
         factory.getInInterceptors().add(new LoggingInInterceptor());
         factory.getOutInterceptors().add(new LoggingOutInterceptor());
         // 发布服务
         factory.create();
         System.out.println("发布服务成功,端口8001");
     }
    }
    

    7.2 客户端

    7.2.1 创建项目

    在这里插入图片描述

    7.2.2 实体类

    7.2.3 添加依赖

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
        <groupId>com.itheima</groupId>
        <artifactId>06_jaxrs_client</artifactId>
        <version>1.0-SNAPSHOT</version>
        <modelVersion>4.0.0</modelVersion>
        <name>06_jaxrs_client</name>
    
        <dependencies>
            <!-- jaxrs 支持包 -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-frontend-jaxrs</artifactId>
                <version>3.0.1</version>
            </dependency>
    
            <!-- 内置的jetty服务器 -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-transports-http-jetty</artifactId>
                <version>3.0.1</version>
            </dependency>
    
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>1.7.12</version>
            </dependency>
    
            <!-- 客户端调用时候使用的包(WebClient工具类调用服务端) -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-rs-client</artifactId>
                <version>3.0.1</version>
            </dependency>
    
            <!-- 基于restful风格的webservice,客户端与服务端之间可以传递json,这个就是json支持相关包 -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-rs-extension-providers</artifactId>
                <version>3.0.1</version>
            </dependency>
            <dependency>
                <groupId>org.codehaus.jettison</groupId>
                <artifactId>jettison</artifactId>
                <version>1.3.7</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.10</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
    
        <build>
            <pluginManagement>
                <plugins>
                    <!-- maven的jdk编译插件 -->
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <version>3.2</version>
                        <configuration>
                            <source>1.8</source>
                            <target>1.8</target>
                            <encoding>UTF-8</encoding>
                            <showWarnings>true</showWarnings>
                        </configuration>
                    </plugin>
                </plugins>
            </pluginManagement>
        </build>
    </project>
    

    7.2.4 写junit,远程访问服务端

    WebClient
    .create() 指定服务端地址
    .type() 指定请求数据格式(xml、json)
    .accept() 指定响应数据格式
    .post()/put()/delete()/get() 指定请求类型

    public class Client {
        @Test
        public void testSave(){
            User user = new User();
            user.setId(100);
            user.setUsername("Jerry");
            user.setCity("gz");
            // 通过WebClient对象远程调用服务端
            WebClient
                        .create("http://localhost:8001/ws/userService/user")
                        .type(MediaType.APPLICATION_JSON)  // 指定请求的数据格式为json
                        .post(user);
        }
    
        @Test
        public void testGet(){
            // 查询一个
            User user =
                WebClient
                        .create("http://localhost:8001/ws/userService/user/1")
                       .accept(MediaType.APPLICATION_JSON)
                        .get(User.class);
            System.out.println(user);
        }
    }
    

    保存操作,服务端打印日志
    在这里插入图片描述
    查询操作,服务端打印日志

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传在这里插入图片描述

    8 Sping整合CXF实现基于Restful风格的webservice(jax-rs)

    8.1 服务端

    8.1.1 创建web项目

    在这里插入图片描述

    8.1.2 添加依赖

    <?xml version="1.0" encoding="UTF-8"?>
    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.itheima</groupId>
        <artifactId>07_jaxrs_spring_server</artifactId>
        <version>1.0-SNAPSHOT</version>
        <modules>
            <module>../08_jaxrs_spring_client</module>
        </modules>
        <packaging>pom</packaging>
    
        <name>07_jaxrs_spring_server Maven Webapp</name>
        <dependencies>
            <!-- cxf 进行rs开发 必须导入  -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-frontend-jaxrs</artifactId>
                <version>3.0.1</version>
            </dependency>
            <!-- 日志引入  -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>1.7.12</version>
            </dependency>
    
            <!-- 客户端 -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-rs-client</artifactId>
                <version>3.0.1</version>
            </dependency>
    
            <!-- 扩展json提供者 -->
            <dependency>
                <groupId>org.apache.cxf</groupId>
                <artifactId>cxf-rt-rs-extension-providers</artifactId>
                <version>3.0.1</version>
            </dependency>
    
            <!-- 转换json工具包,被extension providers 依赖 -->
            <dependency>
                <groupId>org.codehaus.jettison</groupId>
                <artifactId>jettison</artifactId>
                <version>1.3.7</version>
            </dependency>
    
            <!-- spring 核心 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>4.2.4.RELEASE</version>
            </dependency>
            <!-- spring web集成 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>4.2.4.RELEASE</version>
            </dependency>
            <!-- spring 整合junit  -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>4.2.4.RELEASE</version>
            </dependency>
            <!-- junit 开发包 -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.2</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>UTF-8</encoding>
                        <showWarnings>true</showWarnings>
                    </configuration>
                </plugin>
                <!-- 运行tomcat7方法:tomcat7:run -->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.2</version>
                    <configuration>
                        <!-- 指定端口 -->
                        <port>8080</port>
                        <!-- 请求路径 -->
                        <path>/</path>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </project>
    

    8.1.3 配置applicationContext.xml

    <?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:cxf="http://cxf.apache.org/core"
           xmlns:jaxws="http://cxf.apache.org/jaxws"
           xmlns:jaxrs="http://cxf.apache.org/jaxrs"
           xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://cxf.apache.org/core
            http://cxf.apache.org/schemas/core.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">
    
            <!--
                Spring整合cxf发布基于restful风格的服务,关键点:
                1. 服务地址
                2. 服务类
                服务完整访问地址:
                    http://localhost:8080/ws/hello
            -->
            <jaxrs:server address="/userService">
                    <jaxrs:serviceBeans>
                        <bean class="com.itheima.service.UserServiceImpl"></bean>
                    </jaxrs:serviceBeans>
            </jaxrs:server>
    </beans>
    

    8.1.4 web.xml

    <!DOCTYPE web-app PUBLIC
            "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
            "http://java.sun.com/dtd/web-app_2_3.dtd" >
    <web-app>
        <display-name>Archetype Created Web Application</display-name>
        <servlet>
            <servlet-name>cxfservlet</servlet-name>
            <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>cxfservlet</servlet-name>
            <url-pattern>/ws/*</url-pattern>
        </servlet-mapping>
        <!--2.spring容器配置-->
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </context-param>
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
    </web-app>
    

    8.1.5 服务接口、实现、实体类

    同7.1.3
    在这里插入图片描述

    8.1.6 发布服务

    8.2 客户端

    8.2.1 创建项目

    创建服务端
    在这里插入图片描述

    8.2.2 添加依赖

    8.2.3 实体类

    8.2.4 测试

    public class Client {
        @Test
        public void testSave(){
            User user = new User();
            user.setId(100);
            user.setUsername("Jerry");
            user.setCity("gz");
            // 通过WebClient对象远程调用服务端
            WebClient.create("http://localhost:8080/ws/userService/userService/user")
                        .type(MediaType.APPLICATION_JSON)  // 指定请求的数据格式为json
                        .post(user);
        }
        @Test
        public void testGet(){
            // 查询一个
            User user =
                WebClient
                        .create("http://localhost:8080/ws/userService/userService/user/1")
                       .accept(MediaType.APPLICATION_JSON)
                        .get(User.class);
            System.out.println(user);
        }
    }
    

    保存操作,服务端打印日志
    在这里插入图片描述
    查询操作,服务端打印日志

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
    在这里插入图片描述

    9.总结

    所以,以后如果在开发中涉及多个系统之间的交互,webservice是不错的选择。使用service最大的好处是客户端与服务端语言的兼容性及交互时候可以传递对象。
    内容梳理:

    1. webservice 概念
      • 简介
      • 术语(开发规范、soap协议、UDDI)
    2. 应用场景、优缺点
    3. Apache CXF 框架介绍
    4. jax-ws 规范下的webservice开发、与spring整合
    5. jax-rs 风格下的webservice开发、与spring整合
    展开全文
  • 搭建一个Web服务,实现一个服务端,怎么样来实现一个客户端,并相互传递数据。就算调用别人的服务时,也能知道大概是怎么样实现的。
  • webservice

    2017-07-31 20:17:16
    前面大致将了一些cxf实现webservice服务,此次对webservice一个更为详细的总结.  webservice的应用场景:  1.用户公共接口的接口服务.  面向互联网公开的接口,例如:某公司产品促销介绍、股票信息查询等,因为...

         前面大致将了一些cxf实现webservice服务,此次对webservice作一个更为详细的总结.

         webservice的应用场景:

     1.用户公共接口的接口服务.

           面向互联网公开的接口,例如:某公司产品促销介绍、股票信息查询等,因为webservice使用的soap协议是一个标准协议,其它公司使用标准协议通信,方便系统开发和维护。比如:便民网站的天气查询接口、火车时刻查询接口等。

    2.用户内部接口服务.

            一个大的系统平台是由若干个系统组成,系统与系统之间存在数据访问需求,为了减少系统与系统之间的耦合性可以将接口抽取出来提供单独的接口服务供它系统调用,如下图是企业ERP系统的接口服务图.


           webservice能够优点:

    1 、采用xml支持跨平台远程调用。

    2、基于http的soap协议,可跨越防火墙。

    3、支持面向对象开发。

    4、有利于软件和数据重用,实现松耦合。

           webservice缺点

            由于soap是基于xml传输,本身使用xml传输会传输一些无关的东西从而效率不高,随着soap协议的完善,soap协议增加了许多内容,这样就导致了使用soap协议进行数据传输的效率不高。

             Webservice简介

    • Web service 即web服务,它是一种跨编程语言和跨操作系统平台的远程调用技术即跨平台远程调用技术。
    • 采用标准SOAP(Simple Object Access Protocol)  协议传输,soap属于w3c标准。Soap协议是基于http的应用层协议,soap协议传输是xml数据。采用wsdl作为描述语言即webservice使用说明书,wsdl属w3c标准。
    • xml是webservice的跨平台的基础,XML主要的优点在于它既与平台无关,又与厂商无关。
    • XSD,W3C为webservice制定了一套传输数据类型,使用xml进行描述,即XSD(XML Schema Datatypes),任何编程语言写的webservice接口在发送数据时都要转换成webservice标准的XSD发送。
    • 当前非SOAP协议的webService以轻量为首要目标,比如http rest方式也是webservice的一种方式,或者直接使用http自定义数据协议,比如http传输json数据,http传输xml数据等。

           Webservice三要素:

            1.soap

             SOAP即简单对象访问协议(Simple Object Access Protocal) 是一种简单的基于 XML 的协议,它使应用程序通过 HTTP 来交换信息,简单理解为soap=http+xml。

    Soap协议版本主要使用soap1.1、soap1.2。

            SOAP不是webservice的专有协议,其他应用协议也使用soap传输数据。例如,SMTP、tr069等

              2.wsdl

              WSDL 是基于 XML的用于描述Web Service及其函数、参数和返回值。通俗理解Wsdlwebservice的使用说明书。

              3.uddi

            UDDI 是一种目录服务,通过它,企业可注册并搜索 Web services。企业将自己提供的Web Service注册在UDDI,也可以使用别的企业在UDDI注册的web service服务,从而达到资源共享。 UDDI旨在将全球的webservcie资源进行共享,促进全球经济合作。

            目前大部分企业使用webservice并不是必须使用UDDI,因为用户通过WSDL知道了web service的地址,可以直接通过WSDL调用webservice。

         Webservice开发规范

           JAVA 中共有三种WebService 规范,分别是JAX-WS(JAX-RPC)、JAXM&SAAJ、JAX-RS。

           1.JAX-WS

            JAX-WS  的全称为 Java API for XML-Based Webservices,早期的基于SOAPJAVAWeb服务规范JAX-RPCJava API For XML-Remote Procedure Call)目前已经被JAX-WS规范取代。从java5开始支持JAX-WS2.0版本,Jdk1.6.0_13以后的版本支持2.1版本,jdk1.7支持2.2版本。

          2.AXM&SAAJ

           JAXM(JAVA API For XML Message)主要定义了包含了发送和接收消息所需的API,SAAJ(SOAP With Attachment API For Java,JSR 67)是与JAXM 搭配使用的API,为构建SOAP 包和解析SOAP 包提供了重要的支持,支持附件传输等,JAXM&SAAJ 与JAX-WS 都是基于SOAP 的Web 服务,相比之下JAXM&SAAJ 暴漏了SOAP更多的底层细节,编码比较麻烦,而JAX-WS 更加抽象,隐藏了更多的细节,更加面向对象,实现起来你基本上不需要关心SOAP 的任何细节.

          3.JAX-RS

        JAX-RS JAVA针对REST(Representation StateTransfer)风格制定的一套Web服务规范,由于推出的较晚,该规范(JSR 311,目前JAX-RS的版本为1.0)并未随JDK1.6一起发行。

         Webservice与Socket(Socket与Webservice的区别、TCP/IP协议、HTTP协议)

           

         

            Webservice采用soap协议进行通信,底层基于socket通信,webservice不需专门针对数据流的发送和接收进行处理,是一种跨平台的面向对象远程调用技术。

    • Socket  是基于TCP/ip的传输层协议
    • Webservice是基于http协议传输数据,http是基于tcp的应用层协议
    • Webservice采用了基于httpsoap协议传输数据。
    • Socket接口通过操作流编程传输数据,不支持面向对象。
    • Webservice 接口支持面向对象,最终webservice将对象进行序列化后通过流传输
       Socket优点:
    • Socket采用tcp、udp底层协议通信,传输速度快,适用于传输大数量的数据。
    • socket具有平台无关性,java写的socket的客户端可以访问c写的socket服务端。
       Socket缺点

      接口传输的数据需要手动解析,socket通信的接口协议需要自定义,比如:自定义一种字符串拼接的格式,比如自定义的xml数据,自定义麻烦之处在接口调用方和接口服务端需要互相讨论确定接口的协议内容,不方便,好处:适用于传输大数量的数据。



          webservice技术拓展

            虽然java中定义webservice开发规范采用soap协议,但由于soap协议本身的缺点现在更多的webservice接口则直接采用http+自定义协议通信,比如http传输json串、http传输自定义格式的数据,因为这样做比soap协议更快捷,例如某些第三方支付公司的支持接口就直接采用http原始协议通信、http rest方式通信。

            webservice即web服务,只要这个计算机在互联网内,它对外提供的服务接口都可以认为是一个webservice,除了使用http、soap进行通信外如果要保证性能可以直接使用tcp,比如采用socket方式,但是socket方式需要手动通过流编程解析数据,有些麻烦,如果有保证传输速度及跨平台的前提下基于面向对象开发服务接口及客户端程序的技术最好不过,hessian框架就可以保证传输速度及在跨平台的前提下基于面向对象开发远程调用接口。

            总结:webservice可以实现的技术有好多,socket、http、soap方式、hessian等,在实际应用时根据具体的需求和场景去选择应用技术。

          webservice技术选型

              1. 协议约定

             你作为客户端要调用别人的接口,对方服务接口用的是什么协议客户端一般也用什么协议,比如服务端采用socket,客户端使用socket方式通信,服务端使用对外提供soap方式的webservice,客户端使用soap协议与服务端通信。

              2. 通用性

             对于一个webservice主要考虑接口的通用性时,在不要求性能的前提下可以使用soap协议。

    如果要考虑接口的通用性还要考虑接口的性能可以采用http+自定义协议,比如http+json串,因为http本身就是web应用中的基础协议,json格式的数据也成为当前web开发中流行数据格式。

             3.高性能

             对于一个webservice主要作为内部系统之间通信使用,比如:联通、移动公司内部的若干系统之间进行数据传输,这类接口主要考虑的是性能,可以直接采用socket通信、hessian等,几种技术性能从高到低是:socket>hessian>http>soap。

            4.开发规范

            当然要注意,有些正规的公司会制定自己公司的开发规范,比如内部系统接口统一采用hessian,统一采用http,并不总是使用性能最高的方式,因为公司会综合考虑自己的人力资源情况在有限的成本下使用最合适的技术才是公司在进行技术选型时所遵循的原则。

          webservice 与http关系

         http与webservice之间的关系,可以用一句话描述:Webservice采用了基于http的soap协议传输数据。
          webservice的三要素soap,wsdl,uddi并未涉及网络通信(soap协议与http通信协议是有本质区别的),soap只是应用协议,并非通信协议,它所依赖的下层通信方式不单单是HTTP,也有SOAP over SMTP, SOAP over TCP,由于HTTP协议群众基础广,开发调试方便,所以,成了WebService中最为流行的方式(HTTP也是TCP上性能比较差的协议,因为HTTP是基于TCP的,有3次握手,再加上HTTP是个文本传输协议(虽然也可以传二进制的附件,但业务逻辑还是文本用的多),又有很多复杂的HEADER。所以人们发明了一些更高效的通信协议来做远程调用,比如ACE、ICE、Corba、淘宝的HSF)。
            http协议传输的都是字符串了,webservice则是包装成了更复杂的对象.webservice就是使用soap协议得到你想要的东西,相比httpservice能处理些更加复杂的数据类型.
            soap基于http通信(见下文soap),发送的就是一个post的http请求,请求内容格式text/xml(soap1.2是application/soap+xml),返回text/xml.webservice接受xml格式的请求进行解析,印射到相应的server方法中进行出处理.用jdk的wsimport或者cxf的wsdl2java生产的客户端,其主要的代码就是将请求封装成xml,解析返回的xml数据.(reference)
            jaxws是一个标准的webservice服务,jaxrs一些get或者post更像是httpservice(post中soap的xml请求更像webservice)
           webservice Examples

    1.jax-ws

          jaxws注解的作用主要是用来规范webservice的接口,使用注解可以指定服务名称、portType名称、接口参数名称等。

         WebService的注解都位于javax.jws包下:

        @WebService-定义服务,在public class上边

    • targetNamespace:指定命名空间
    • name:portType的名称
    • portName:port的名称
    • serviceName:服务名称
    • endpointInterface:SEI接口地址,如果一个服务类实现了多个接口,只需要发布一个接口的方法,可通过此注解指定要发布服务的接口。

           @WebMethod-定义方法,在公开方法上边

    • operationName:方法名
    • exclude:设置为true表示此方法不是webservice方法,反之则表示webservice方法

           @WebResult-定义返回值,在方法返回值前边

    • name:返回结果值的名称

           @WebParam-定义参数,在方法参数前边

    • name:指定参数的名称

    作用:

             通过注解,可以更加形像的描述Web服务。对自动生成的wsdl文档进行修改,为使用者提供一个更加清晰的wsdl文档。

    当修改了WebService注解之后,会影响客户端生成的代码。调用的方法名和参数名也发生了变化

    注意事项

          @WebMethod对所有非静态的公共方法对外暴露为服务.

    • 对于静态方法或非public方法是不可以使用@WebMethod注解的.
    • 对public方法可以使用@WebMethod(exclude=true)定义为非对外暴露的服务。

           如果修改webservice的接口内容,比如namespaceportType,必须要重新生成客户端调用代码。

     服务端(新建jar项目)

    sei

    package service;
    
    /*编写SEI(Service Endpoint Interface),SEI在webservice中称为portType,在java中称为接口*/
    public interface WeatherInterface {
    	//根据城市名称查询天气信息
    	public String queryWeather(String cityName)throws Exception;
    
    }
    sei impl

    package service;
    
    import javax.jws.WebService;
    
    //@WebService标识此类可以发布为webservice服务
    @WebService
    public class WeatherInterfaceImpl implements WeatherInterface {
    
    	//如果此方法被调用执行说明客户端请求天气查询
    	@Override
    	public String queryWeather(String cityName) throws Exception {
    		System.out.println("from client..."+cityName);
    		//查询天气 
    		//使用静态数据表示查询天气结果
    		//...
    		//天气查询结果
    		String result="晴";
    		//如果方法返回值,说明服务端向客户端响应查询结果
    		return result;
    	}
    
    }
    server

    package service;
    
    import javax.xml.ws.Endpoint;
    
    public class WeatherServer {
    	public static void main(String[] args) {
    		//发布天气查询服务
    		//第一个参数:服务地址
    		//第二个参数:提供的java对象,实现SEI的实现类对象
    		Endpoint.publish("http://127.0.0.1:12345/weather", new WeatherInterfaceImpl());
    	}
    
    }

    访问http://127.0.0.1:12345/weather?wsdl 返回

    This XML file does not appear to have any style information associated with it. The document tree is shown below.
    <!--
     Published by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.2.4-b01. 
    -->
    <!--
     Generated by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.2.4-b01. 
    -->
    <definitions xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://www.w3.org/ns/ws-policy" xmlns:wsp1_2="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:wsam="http://www.w3.org/2007/05/addressing/metadata" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://service/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.xmlsoap.org/wsdl/" targetNamespace="http://service/" name="WeatherInterfaceImplService">
    <types>
    <xsd:schema>
    <xsd:import namespace="http://service/" schemaLocation="http://127.0.0.1:12345/weather?xsd=1"/>
    </xsd:schema>
    </types>
    <message name="queryWeather">
    <part name="parameters" element="tns:queryWeather"/>
    </message>
    <message name="queryWeatherResponse">
    <part name="parameters" element="tns:queryWeatherResponse"/>
    </message>
    <message name="Exception">
    <part name="fault" element="tns:Exception"/>
    </message>
    <portType name="WeatherInterfaceImpl">
    <operation name="queryWeather">
    <input wsam:Action="http://service/WeatherInterfaceImpl/queryWeatherRequest" message="tns:queryWeather"/>
    <output wsam:Action="http://service/WeatherInterfaceImpl/queryWeatherResponse" message="tns:queryWeatherResponse"/>
    <fault message="tns:Exception" name="Exception" wsam:Action="http://service/WeatherInterfaceImpl/queryWeather/Fault/Exception"/>
    </operation>
    </portType>
    <binding name="WeatherInterfaceImplPortBinding" type="tns:WeatherInterfaceImpl">
    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document"/>
    <operation name="queryWeather">
    <soap:operation soapAction=""/>
    <input>
    <soap:body use="literal"/>
    </input>
    <output>
    <soap:body use="literal"/>
    </output>
    <fault name="Exception">
    <soap:fault name="Exception" use="literal"/>
    </fault>
    </operation>
    </binding>
    <service name="WeatherInterfaceImplService">
    <port name="WeatherInterfaceImplPort" binding="tns:WeatherInterfaceImplPortBinding">
    <soap:address location="http://127.0.0.1:12345/weather"/>
    </port>
    </service>
    </definitions>
           解析wsdl

          简述wsdl

    • WSDL 指网络服务描述语言(Web Services Description Language)。
    • WSDL是一种使用 XML 编写的文档。这种文档可描述某个 Web service。它可规定服务的位置,以及此服务提供的操作(或方法)。
    • WSDL 是一种 XML 文档
    • WSDL 用于描述网络服务
    • WSDL 也可用于定位网络服务
            wsdl结构

    <service>    服务视图,webservice的服务结点,它包括了服务端点

    <binding>     为每个服务端点定义消息格式和协议细节

    <portType>   服务端点,描述 web service可被执行的操作方法,以及相关的消息,通过binding指向portType

    <message>   定义一个操作(方法)的数据参数(可有多个参数)

    <types>        定义 web service 使用的全部数据类型

           建议阅读习惯:从下往上读先找到服务视图,通过binging找到protType,找到了protType就找到了我们要调用的webservice方法。

    客户端
           运用jdk自带的webservice生成工具Wsimport
           wsimport是jdk自带的webservice客户端工具,可以根据wsdl文档生成客户端调用代码(java代码).当然,无论服务器端的WebService是用什么语言写的,都可以生成调用webservice的客户端代码,服务端通过客户端代码调用webservice。 

           wsimport.exe位于JAVA_HOME\bin目录下.

           常用参数为:

    -d<目录>  - 将生成.class文件。默认参数。

    -s<目录> - 将生成.java文件。

    -p<生成的新包名> -将生成的类,放于指定的包下。

    (wsdlurl) - http://server:port/service?wsdl,必须的参数。

            示例:

    C:/> wsimport –s . http://127.0.0.1:1234/weather?wsdl

    注意:-s不能分开,-s后面有个小点

    运行后会在指定目录下(如上述命令就是c盘下)生成一大坨代码,新建一个client客户端jar(客户端一般和服务端是分开的),复制生成的代码





    编写WeatherClient

    package service;
    
    import service.Exception_Exception;
    import service.WeatherInterfaceImpl;
    import service.WeatherInterfaceImplService;
    
    public class WeatherClient {
    
    	public static void main(String[] args) throws Exception_Exception {
    
    		// 使用生成的调用代码创建代理对象,代理对象就是portType的代理对象,代理对象内部最终发起socket请求
    
    		// 创建一个服务视图的对象
    		WeatherInterfaceImplService weatherInterfaceImplService = new WeatherInterfaceImplService();
    
    		// 通过服务视图创建portType的代理对象
    		WeatherInterfaceImpl weatherInterfaceImplPort = weatherInterfaceImplService
    				.getWeatherInterfaceImplPort();
    
    		// 调用portType的方法
    		String resultString = weatherInterfaceImplPort.queryWeather("北京");
    
    		System.out.println("天气查询结果:" + resultString);
    
    	}
    
    }
           运行client,结果----天气查询结果:晴

           查看上面的生成的代码中,访问通过"http://127.0.0.1:12345/weather?wsdl"获取wsdl(xml结构),根据其说明去访问相应的接口,返回值有诸多注解都带xml,也就是说返回也是xml, 也就验证了上面的基于xml的数据传输.值得一提的是,此处不同于jaxrs,jaxrs进行了rest风格的印射,是可以通过url(或http请求)直接访问

    2.调用公网查询天气预报

          天气预报公网http://www.webxml.com.cn/WebServices/WeatherWebService.asmx?wsdl

          直接使用wsimport -s . url会报s:schema出错(jaxb不支持),需要将wsdl下载下来(另存为C:\Users\admin\Desktop\temp\WeatherWebService.xml)进行更改

          <s:element ref="s:schema" /><s:any />改成 <s:any minOccurs="2" maxOccurs="2"/>,一共有三处需要修改,建议查找<s:element ref="s:schema" />,修改时把<s:any />也要删掉,执行cmd进入C:\Users\admin\Desktop\temp\,执行wsimport -s . WeatherWebService.xml,将生产代码拷入新建的jar中

    新建client访问

    package cn.com.webxml;
    
    import java.io.IOException;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.List;
    
    import javax.xml.namespace.QName;
    import javax.xml.ws.Service;
    
    import cn.com.webxml.ArrayOfString;
    import cn.com.webxml.WeatherWebService;
    import cn.com.webxml.WeatherWebServiceSoap;
    
    public class WeatherClient {
    
    	public static void main(String[] args) throws IOException {
    
    		 //######################通过Wsimport访问####################
    		// 创建服务视图对象
    		WeatherWebService weatherWebService = new WeatherWebService();
    
    		// 通过服务视图对象创建portType的代理对象
    		WeatherWebServiceSoap weatherWebServiceSoap = weatherWebService
    				.getWeatherWebServiceSoap();
    		
    		//调用portType的方法
    		ArrayOfString arrayOfString = weatherWebServiceSoap.getWeatherbyCityName("北京");
    		//遍历公网天气查询服务返回的类型
    		for(String message:arrayOfString.getString()){
    			System.out.println(message);
    		}
    		
    		 //######################通过service访问####################
    /*		//定义url,参数为wsdl地址
    		URL url = new URL("file:/C:/Users/admin/Desktop/temp/WeatherWebService.xml");
    		//定义qname,第一个参数是命名空间,第二个参数名称是wsdl里边的服务名
    		QName qName = new QName("http://WebXml.com.cn/", "WeatherWebService");
    		//创建服务视图
    		Service service = Service.create(url, qName);
    		//通过服务视图得到服务端点
    		WeatherWebServiceSoap weatherWebServiceSoap =service.getPort(WeatherWebServiceSoap.class);
    		//调用webservice
    		ArrayOfString arrayOfString = weatherWebServiceSoap.getWeatherbyCityName("郑州");
    		List<String> resultlist = arrayOfString.getString();
    		//查询天气查询结果
    		for(String result:resultlist){
    			System.out.println(result);
    		}*/
    		
    /*		######################通过service访问与通过Wsimport访问的区别####################
    		Wsimport生成代码调用webservice无法指定webservice的地址,使用生成的服务视图类获取服务端点(postType)实例。
    		Service调用Webservice可以指定webservice的地址,只需要服务端点的接口即可获取服务端点实例。*/
    		
    
    	}
    
    }
    
    运行ok.

    3.soap协议

    1.soap协议(1.1版本)

         使用TCP/IP Monitor可以监视tcp/ip协议的报文内容,由于http是基于Tcp的应用协议,而webservice是基于http实现,所以通过tcp/ip monitor可以监视webservice请求及响应的内容。以案例1为例.

          eclipse设置tcp/ip monitor

         

         tcp/ip monitor监控的基本原理就是通过端口转发(上述12345就是目的端口,999是转发端口).

         启动客户端访问

    				URL url = new URL("http://127.0.0.1:999/weather?wsdl");
    				//定义qname,第一个参数是命名空间,第二个参数名称是wsdl里边的服务名
    				QName qName = new QName("http://service/", "WeatherInterfaceImplService");
    				//创建服务视图
    				Service service = Service.create(url, qName);
    				//通过服务视图得到服务端点
    				WeatherInterfaceImpl weatherInterfaceImpl =service.getPort(WeatherInterfaceImpl.class);
    				//调用webservice
    				System.out.println(weatherInterfaceImpl.queryWeather("郑州"));

    request监控

    GET /weather?wsdl HTTP/1.1
    User-Agent: Java/1.7.0_72
    Host: 127.0.0.1:999
    Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
    Connection: keep-alive
    ###########以上是转发,以下是监控内容###############
    POST /weather HTTP/1.1
    Accept: text/xml, multipart/related
    Content-Type: text/xml; charset=utf-8
    SOAPAction: "http://service/WeatherInterfaceImpl/queryWeatherRequest"
    User-Agent: JAX-WS RI 2.2.4-b01
    Host: 127.0.0.1:999
    Connection: keep-alive
    Content-Length: 200
    
    <?xml version="1.0" ?><S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/"><S:Body><ns2:queryWeather xmlns:ns2="http://service/"><arg0>郑州</arg0></ns2:queryWeather></S:Body></S:Envelope>
    response

    HTTP/1.1 200 OK
    Transfer-encoding: chunked
    Content-type: text/xml;charset=utf-8
    Date: Mon, 31 Jul 2017 11:14:33 GMT
    
    8cc
    <?xml version='1.0' encoding='UTF-8'?><!-- Published by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.2.4-b01. --><!-- Generated by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.2.4-b01. --><definitions xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://www.w3.org/ns/ws-policy" xmlns:wsp1_2="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:wsam="http://www.w3.org/2007/05/addressing/metadata" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://service/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.xmlsoap.org/wsdl/" targetNamespace="http://service/" name="WeatherInterfaceImplService">
    <types>
    <xsd:schema>
    <xsd:import namespace="http://service/" schemaLocation="http://127.0.0.1:999/weather?xsd=1"/>
    </xsd:schema>
    </types>
    <message name="queryWeather">
    <part name="parameters" element="tns:queryWeather"/>
    </message>
    <message name="queryWeatherResponse">
    <part name="parameters" element="tns:queryWeatherResponse"/>
    </message>
    <message name="Exception">
    <part name="fault" element="tns:Exception"/>
    </message>
    <portType name="WeatherInterfaceImpl">
    <operation name="queryWeather">
    <input wsam:Action="http://service/WeatherInterfaceImpl/queryWeatherRequest" message="tns:queryWeather"/>
    <output wsam:Action="http://service/WeatherInterfaceImpl/queryWeatherResponse" message="tns:queryWeatherResponse"/>
    <fault message="tns:Exception" name="Exception" wsam:Action="http://service/WeatherInterfaceImpl/queryWeather/Fault/Exception"/>
    </operation>
    </portType>
    <binding name="WeatherInterfaceImplPortBinding" type="tns:WeatherInterfaceImpl">
    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document"/>
    <operation name="queryWeather">
    <soap:operation soapAction=""/>
    <input>
    <soap:body use="literal"/>
    </input>
    <output>
    <soap:body use="literal"/>
    </output>
    <fault name="Exception">
    <soap:fault name="Exception" use="literal"/>
    </fault>
    </operation>
    </binding>
    <service name="WeatherInterfaceImplService">
    <port name="WeatherInterfaceImplPort" binding="tns:WeatherInterfaceImplPortBinding">
    <soap:address location="http://127.0.0.1:999/weather"/>
    </port>
    </service>
    </definitions>
    0
    
    HTTP/1.1 200 OK
    Transfer-encoding: chunked
    Content-type: text/xml; charset=utf-8
    Date: Mon, 31 Jul 2017 11:14:33 GMT
    
    6e
    <?xml version='1.0' encoding='UTF-8'?><S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/"><S:Body>
    7b
    <ns2:queryWeatherResponse xmlns:ns2="http://service/"><return>晴 </return></ns2:queryWeatherResponse></S:Body></S:Envelope>
    0
         可以看出request与reponse 的content-type都是text/xml

         soap协议包含的元素

    • 必需有 Envelope 元素,此元素将整个 XML文档标识为一条SOAP消息
    • 可选的 Header 元素,包含头部信息
    • 必需有Body 元素,包含所有的调用和响应信息
    • 可选的 Fault 元素,提供有关在处理此消息所发生错误的信息
      soap消息基本结构

    <?xml version="1.0"?>
    <soap:Envelope xmlns:soap="http://www.w3.org/2001/12/soap-envelope" soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
    <soap:Header>
     ... ...
    </soap:Header>
    <soap:Body>
     ... ...
     <soap:Fault>
     ... ...
    </soap:Fault>
    </soap:Body>
     </soap:Envelope>

    soap协议(1.2版本)

      Jaxws实现soap1.2需要加入jaxws扩展包,从sun下载jaxws-ri-2.2.8,解压jaxws-ri-2.2.8并将lib下的jar包加载到java工程中。

      在SEI实现类上添加如下注解@BindingType(javax.xml.ws.soap.SOAPBinding.SOAP12HTTP_BINDING)

    request

    GET /weather?wsdl HTTP/1.1
    User-Agent: Java/1.7.0_72
    Host: 127.0.0.1:999
    Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
    Connection: keep-alive
    
    POST /weather HTTP/1.1
    Accept: application/soap+xml, multipart/related
    Content-Type: application/soap+xml; charset=utf-8;action="http://service/WeatherInterfaceImpl/queryWeatherRequest"
    User-Agent: JAX-WS RI 2.2.4-b01
    Host: 127.0.0.1:999
    Connection: keep-alive
    Content-Length: 198
    
    <?xml version="1.0" ?><S:Envelope xmlns:S="http://www.w3.org/2003/05/soap-envelope"><S:Body><ns2:queryWeather xmlns:ns2="http://service/"><arg0>郑州</arg0></ns2:queryWeather></S:Body></S:Envelope>
    response

    HTTP/1.1 200 OK
    Transfer-encoding: chunked
    Content-type: text/xml;charset=utf-8
    Date: Mon, 31 Jul 2017 11:49:32 GMT
    
    8d8
    <?xml version='1.0' encoding='UTF-8'?><!-- Published by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.2.8 svn-revision#13980. --><!-- Generated by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.2.8 svn-revision#13980. --><definitions xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://www.w3.org/ns/ws-policy" xmlns:wsp1_2="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:wsam="http://www.w3.org/2007/05/addressing/metadata" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:tns="http://service/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.xmlsoap.org/wsdl/" targetNamespace="http://service/" name="WeatherInterfaceImplService">
    <types>
    <xsd:schema>
    <xsd:import namespace="http://service/" schemaLocation="http://127.0.0.1:999/weather?xsd=1"/>
    </xsd:schema>
    </types>
    <message name="queryWeather">
    <part name="parameters" element="tns:queryWeather"/>
    </message>
    <message name="queryWeatherResponse">
    <part name="parameters" element="tns:queryWeatherResponse"/>
    </message>
    <message name="Exception">
    <part name="fault" element="tns:Exception"/>
    </message>
    <portType name="WeatherInterfaceImpl">
    <operation name="queryWeather">
    <input wsam:Action="http://service/WeatherInterfaceImpl/queryWeatherRequest" message="tns:queryWeather"/>
    <output wsam:Action="http://service/WeatherInterfaceImpl/queryWeatherResponse" message="tns:queryWeatherResponse"/>
    <fault message="tns:Exception" name="Exception" wsam:Action="http://service/WeatherInterfaceImpl/queryWeather/Fault/Exception"/>
    </operation>
    </portType>
    <binding name="WeatherInterfaceImplPortBinding" type="tns:WeatherInterfaceImpl">
    <soap12:binding transport="http://schemas.xmlsoap.org/soap/http" style="document"/>
    <operation name="queryWeather">
    <input>
    <soap12:body use="literal"/>
    </input>
    <output>
    <soap12:body use="literal"/>
    </output>
    <fault name="Exception">
    <soap12:fault name="Exception" use="literal"/>
    </fault>
    </operation>
    </binding>
    <service name="WeatherInterfaceImplService">
    <port name="WeatherInterfaceImplPort" binding="tns:WeatherInterfaceImplPortBinding">
    <soap12:address location="http://127.0.0.1:999/weather"/>
    </port>
    </service>
    </definitions>
    0
    
    HTTP/1.1 200 OK
    Transfer-encoding: chunked
    Content-type: application/soap+xml; charset=utf-8
    Date: Mon, 31 Jul 2017 11:49:32 GMT
    
    6c
    <?xml version='1.0' encoding='UTF-8'?><S:Envelope xmlns:S="http://www.w3.org/2003/05/soap-envelope"><S:Body>
    7b
    <ns2:queryWeatherResponse xmlns:ns2="http://service/"><return>晴 </return></ns2:queryWeatherResponse></S:Body></S:Envelope>
    0

    soap1.1与1.2的比较

         相同之处:

    • soap1.1和soap1.2都是使用post方法
    • 都包括Envelope和body

     

         内容类型context-type不同:

    • soap1.1使用text/xml
    • soap1.2使用application/soap+xml

     

          命名空间Envelope xmlns不同:

    http测试

    package service;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    
    public class HttpRequestSoap {
    	
    	public static void main(String[] args) throws IOException {
    		//webservice地址
    		String webservice_url = "http://127.0.0.1:12345/weather";
    		//发送的soap协议内容
    		String soap_xml = soap_xml("郑州");
    		System.out.println(soap_xml);
    		//创建url
    		URL url = new URL(webservice_url);
    		//创建http链接对象
    		HttpURLConnection httpURLConnection = (HttpURLConnection)url.openConnection();
    		//设置请求方法
    		httpURLConnection.setRequestMethod("POST");
    		//设置Content-type
    		httpURLConnection.setRequestProperty("Content-type", "text/xml;charset=\"utf-8\"");
    		//使用http进行输出
    		httpURLConnection.setDoOutput(true);
    		//使用http进行输入
    		httpURLConnection.setDoInput(true);
    		
    		//通过输出流发送数据
    		OutputStream outputStream = httpURLConnection.getOutputStream();
    		outputStream.write(soap_xml.getBytes());
    		outputStream.close();
    		
    		//接收服务端响应数据
    		InputStream inputStream =  httpURLConnection.getInputStream();
    		
    		//使用buffer存在读取的数据
    		byte[] buffer = new byte[1024];
    		
    		//使用字节输出流存储读取的数据
    		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    		while(true){
    			int len = inputStream.read(buffer);
    			//如果流水读取完则退出循环
    			if(len == -1){
    				break;
    			}
    			byteArrayOutputStream.write(buffer,0,len);
    		}
    
    		//得到响应数据
    		String response_string = byteArrayOutputStream.toString();
    		
    		System.out.println(response_string);
    	}
    	//soap协议内容
    	public static String soap_xml(String cityName){
    		String soap_xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
    				+ "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">"
    				+ "<S:Body>"
    				+ "<ns2:queryWeather xmlns:ns2=\"http://service/\">"
    				+ "<arg0>"+ cityName  + "</arg0>"
    				+ "</ns2:queryWeather>"
    				+ "</S:Body>"
    				+ "</S:Envelope>";
    		
    		return soap_xml;
    	}
    
    
    	
    }

    4.spring+webservice+jaxrs

    5.spring+webservice+jaxws

    jax-ws的配置与jaxrs的配置十分相似,此处照搬的官网给的源码例子(参考cxf+spring).新建一个maven的web项目
    pom.xml
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>stu</groupId>
    		<artifactId>stu</artifactId>
    		<version>0.0.1-SNAPSHOT</version>
    	</parent>
    	<artifactId>cxf</artifactId>
    	<packaging>war</packaging>
    	<dependencies>
    		<dependency>
    			<groupId>org.apache.cxf</groupId>
    			<artifactId>cxf-rt-frontend-jaxws</artifactId>
    			<version>3.1.12</version>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.cxf</groupId>
    			<artifactId>cxf-rt-transports-http</artifactId>
    			<version>3.1.12</version>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.cxf</groupId>
    			<artifactId>cxf-rt-transports-http-jetty</artifactId>
    			<version>3.1.12</version>
    		</dependency>
    		<dependency>
    			<groupId>org.eclipse.jetty</groupId>
    			<artifactId>jetty-webapp</artifactId>
    			<version>9.2.21.v20170120</version>
    		</dependency>
    
    		<!-- spring -->
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    			<version>4.3.4.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-web</artifactId>
    			<version>4.3.4.RELEASE</version>
    		</dependency>
    
    	</dependencies>
    </project>
    service
    /**
     * Licensed to the Apache Software Foundation (ASF) under one
     * or more contributor license agreements. See the NOTICE file
     * distributed with this work for additional information
     * regarding copyright ownership. The ASF licenses this file
     * to you under the Apache License, Version 2.0 (the
     * "License"); you may not use this file except in compliance
     * with the License. You may obtain a copy of the License at
     *
     * http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing,
     * software distributed under the License is distributed on an
     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
     * KIND, either express or implied. See the License for the
     * specific language governing permissions and limitations
     * under the License.
     */
    // START SNIPPET: service
    package demo.spring.service;
    
    import javax.jws.WebService;
    
    @WebService
    public interface HelloWorld {
        String sayHi(String text);
    }
    // END SNIPPET: service
    serviceImpl
    /**
     * Licensed to the Apache Software Foundation (ASF) under one
     * or more contributor license agreements. See the NOTICE file
     * distributed with this work for additional information
     * regarding copyright ownership. The ASF licenses this file
     * to you under the Apache License, Version 2.0 (the
     * "License"); you may not use this file except in compliance
     * with the License. You may obtain a copy of the License at
     *
     * http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing,
     * software distributed under the License is distributed on an
     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
     * KIND, either express or implied. See the License for the
     * specific language governing permissions and limitations
     * under the License.
     */
    // START SNIPPET: service
    package demo.spring.service;
    
    import javax.jws.WebService;
    
    @WebService(endpointInterface = "demo.spring.service.HelloWorld")
    public class HelloWorldImpl implements HelloWorld {
    
        public String sayHi(String text) {
            System.out.println("sayHi called");
            return "Hello " + text;
        }
    }
    // END SNIPPET: service
    server
    /**
     * Licensed to the Apache Software Foundation (ASF) under one
     * or more contributor license agreements. See the NOTICE file
     * distributed with this work for additional information
     * regarding copyright ownership. The ASF licenses this file
     * to you under the Apache License, Version 2.0 (the
     * "License"); you may not use this file except in compliance
     * with the License. You may obtain a copy of the License at
     *
     * http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing,
     * software distributed under the License is distributed on an
     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
     * KIND, either express or implied. See the License for the
     * specific language governing permissions and limitations
     * under the License.
     */
    package demo.spring.service;
    
    import org.eclipse.jetty.server.Handler;
    import org.eclipse.jetty.server.handler.DefaultHandler;
    import org.eclipse.jetty.server.handler.HandlerCollection;
    import org.eclipse.jetty.webapp.WebAppContext;
    
    public class Server {
    
        protected Server() throws Exception {
            System.out.println("Starting Server");
    
            /**
             * Important: This code simply starts up a servlet container and adds
             * the web application in src/webapp to it. Normally you would be using
             * Jetty or Tomcat and have the webapp packaged as a WAR. This is simply
             * as a convenience so you do not need to configure your servlet
             * container to see CXF in action!
             */
            org.eclipse.jetty.server.Server server = new org.eclipse.jetty.server.Server(9002);
    
            WebAppContext webappcontext = new WebAppContext();
            webappcontext.setContextPath("/");
    
            //此处对应你的war包
            webappcontext.setWar("target/cxf-0.0.1-SNAPSHOT.war");
    
            HandlerCollection handlers = new HandlerCollection();
            handlers.setHandlers(new Handler[] {webappcontext, new DefaultHandler()});
    
            server.setHandler(handlers);
            server.start();
            System.out.println("Server ready...");
            server.join();
        }
    
        public static void main(String args[]) throws Exception {
            new Server();
        }
    
    }
    client
    /**
     * Licensed to the Apache Software Foundation (ASF) under one
     * or more contributor license agreements. See the NOTICE file
     * distributed with this work for additional information
     * regarding copyright ownership. The ASF licenses this file
     * to you under the Apache License, Version 2.0 (the
     * "License"); you may not use this file except in compliance
     * with the License. You may obtain a copy of the License at
     *
     * http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing,
     * software distributed under the License is distributed on an
     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
     * KIND, either express or implied. See the License for the
     * specific language governing permissions and limitations
     * under the License.
     */
    package demo.spring.client;
    
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import demo.spring.service.HelloWorld;
    
    
    public final class Client {
    
        private Client() {
        }
    
        public static void main(String args[]) throws Exception {
            // START SNIPPET: client
            ClassPathXmlApplicationContext context 
                = new ClassPathXmlApplicationContext(new String[] {"client-beans.xml"});
    
            HelloWorld client = (HelloWorld)context.getBean("client");
    
            String response = client.sayHi("Joe");
            System.out.println("Response: " + response);
            System.exit(0);
            // END SNIPPET: client
        }
    }
    web-info 下的两个xml
    web.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <!--
      Licensed to the Apache Software Foundation (ASF) under one
      or more contributor license agreements. See the NOTICE file
      distributed with this work for additional information
      regarding copyright ownership. The ASF licenses this file
      to you under the Apache License, Version 2.0 (the
      "License"); you may not use this file except in compliance
      with the License. You may obtain a copy of the License at
    
      http://www.apache.org/licenses/LICENSE-2.0
    
      Unless required by applicable law or agreed to in writing,
      software distributed under the License is distributed on an
      "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
      KIND, either express or implied. See the License for the
      specific language governing permissions and limitations
      under the License.
    -->
    <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.5" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee           http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
        <display-name>cxf</display-name>
        <servlet>
            <description>Apache CXF Endpoint</description>
            <display-name>cxf</display-name>
            <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>/services/*</url-pattern>
        </servlet-mapping>
        <session-config>
            <session-timeout>60</session-timeout>
        </session-config>
    </web-app>
    
    cxf-servlet.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <!--
            Licensed to the Apache Software Foundation (ASF) under one
            or more contributor license agreements. See the NOTICE file
            distributed with this work for additional information
            regarding copyright ownership. The ASF licenses this file
            to you under the Apache License, Version 2.0 (the
            "License"); you may not use this file except in compliance
            with the License. You may obtain a copy of the License at
            
            http://www.apache.org/licenses/LICENSE-2.0
            
            Unless required by applicable law or agreed to in writing,
            software distributed under the License is distributed on an
            "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
            KIND, either express or implied. See the License for the
            specific language governing permissions and limitations
            under the License.
    -->
    <!-- START SNIPPET: beans -->
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 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">
    <!--     <import resource="classpath:META-INF/cxf/cxf.xml"/>
        <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/> -->
        <jaxws:endpoint id="helloWorld" implementor="demo.spring.service.HelloWorldImpl" address="/HelloWorld"/>
    </beans>
    <!-- END SNIPPET: beans -->
    
    resource目录下的client-beans.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <!--
            Licensed to the Apache Software Foundation (ASF) under one
            or more contributor license agreements. See the NOTICE file
            distributed with this work for additional information
            regarding copyright ownership. The ASF licenses this file
            to you under the Apache License, Version 2.0 (the
            "License"); you may not use this file except in compliance
            with the License. You may obtain a copy of the License at
            
            http://www.apache.org/licenses/LICENSE-2.0
            
            Unless required by applicable law or agreed to in writing,
            software distributed under the License is distributed on an
            "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
            KIND, either express or implied. See the License for the
            specific language governing permissions and limitations
            under the License.
    -->
    <!-- START SNIPPET: beans -->
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 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/schema/jaxws.xsd">
        <bean id="client" class="demo.spring.service.HelloWorld" factory-bean="clientFactory" factory-method="create"/>
        <bean id="clientFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">
            <property name="serviceClass" value="demo.spring.service.HelloWorld"/>
            <property name="address" value="http://localhost:9002/services/HelloWorld"/>
        </bean>
    </beans>
    <!-- END SNIPPET: beans -->
    测试:先运行server ,然后运行client,打印Response: Hello Joe  ok.
    webservice使用总结:

           Webservice发送xml数据其实是将xml数据作为大字符串发送,工作量主要在解析xml数据上。虽然解析xml数据比较麻烦但是webservice接口简单,大家遵守xml格式开发接口,这种方式在企业中也较常用。

           数据量大的xml建议使用SAX解析提高解析速度。

          soap协议支持面向对象开发,传输对象比传输xml方便,但是之所以企业中开发webservice采用xml描述请求和响应的数据是因为xml数据格式是一种跨平台的标准数据格式,企业在开发中会选择一些标准的数据格式作为接口协议,比如:xml、json。

        实际应用时根据企业中的开发需求确定是传输java对象还是xml串以及json串等。

    展开全文
  • webService

    2018-07-05 14:36:44
    webService使用Http发送使用SOAP协议(也有一些非SOAP协议,例如http rest)的数据的种远程调用技术,它是跨编程语言和跨操作系统平台。2.webService三要素 (1) SOAP即简单对象访问协议(Simple Object Access ...
  • webservice是一种基于XML的跨平台的远程调用服务技术,同时他也能跨编程语言,即不同编程语言的客户端与服务端能够实现远程连接,为整个企业甚至多个组织之间的业务流程的集成提供了一个通用机制。 1.Webservice...
  • 因为工作关系需要从事Webservice的开发工作,公司的webserivce是由Apache的AXIS来实现的,以前对这了解不算多,不过经过几天的研究,特奉上小小的心得篇。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&...
  •  /* 调用方法  * //创建web服务代理工厂   JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();  //设置要调用的web服务服务端发布地址   factory.setAddress("  ...
  • webservice

    2020-12-09 16:42:21
    webservice天什么是webservice案例使用Socket做远程方法调用 什么是webservice 服务:部署在服务器中为我们提供请求响应的程序 案例使用Socket做远程方法调用 service服务代码 public class PersonService ...
  • 后面提供 一个独立的webservice不依赖其他框架的自动扫描注册 1.InitWebService package com.ld.admin.listener; import java.util.HashMap; import java.util.Map; import javax.jws.WebServic...
  • WebService技术详解 ()

    万次阅读 多人点赞 2017-07-25 18:01:18
    WebServiceWebService简介Web Service技术, 能使得运行在不同机器上的不同应用无须借助附加的、专门的第三... 简单的说,WebService就是种跨编程语言和跨操作系统平台的远程调用技术。所谓跨编程语言和跨操作平台,
  •  因为工作关系需要从事Webservice的开发工作,公司的webserivce是由Apache的AXIS来实现的,以前对这了解不算多,不过经过几天的研究,特奉上小小的心得篇。  先介绍下本人开发环境吧。 JDK 1.4.2 + ...
  • webservice初识

    2020-05-05 11:10:36
    1、webservice简介 2、webservice相关术语 2.1、AX-WS(JAX-RPC) 2.2、JAXM&SAAJ 2.3、JAX-RS 2.4、SOAP 2.5、WSDL 2.6、UDDI 3、webservice应用场景 4、webservice优缺点 4.1、优点 4.2、缺点 5、...
  • 因为工作关系需要从事Webservice的开发工作,公司的webserivce是由Apache的AXIS来实现的,以前对这了解不算多,不过经过几天的研究,特奉上小小的心得篇。  先介绍下本人开发环境吧。 jdk1.5.0_22 + ...
  • Java WebService介绍

    千次阅读 2013-11-05 11:26:12
    Java WebService介绍
  • 2、WebService要素 SOAP: SOAP即简单对象访问协议(Simple Object Access Protocal) 是种简单的基于 XML 的协议,它使应用程序通过 HTTP 来交换信息,简单理解为soap=http+xml。Soap协议版本主要使用soap1.1...
  • WebService实例

    2011-09-09 00:58:00
    首先创建用eclipse创建一个web工程,我命名为store. 二.导入我下载好的xfire文件夹下的lib文件夹的所有包还有一个xfire-all-1.2.6.jar包 xfire的下载地址:http://xfire.codehaus.org/Download 三.环境好了...
  • 先介绍下本人开发环境吧。 JDK 1.4.2 + Myeclipse 6.0(实在经不起诱惑,尝尝鲜) + Tomcat 5.0.28 + AXIS 1.4。 AXIS 1.4包可以在http://ws.apache.org/axis/ ... 假设所有的环境你已经好,并且AXIS包也已经下...
  • @Bean public ServletRegistrationBean dispatcherServlet()... ServletRegistrationBean bean = new ServletRegistrationBean(new CXFServlet(), "/webservice/*"); bean.setLoadOnStartup(5); return bean; }加了此
  • webservice接口

    2019-03-27 16:58:00
     大家或多或少都听过 WebService(Web服务),有段时间很多计算机期刊、书籍和网站都大肆的提及和宣传WebService技术,其中不乏很多吹嘘和做广告的成 分。但是不得不承认的是WebService真的是一门新兴和有前途的...
  • 随着互联网技术的发展,WebService的使用也越来越广泛,WebService的常用...今天主要是使用CXF框架结合Spring搭一个WebService服务端和客户端。 首先新建一个Web项目WebService_CXF_Server,web.xml配置如下: web.xml
  • Android 调用 WebService

    2017-10-17 16:18:00
    PS:如果看完上面简介还不是很清楚的话,那么就算了,之前公司就用C#一个WebService! 本节我们并不讨论如何去搭建一个WebService,我们仅仅知道如何去获取WebService提供的服务, 然后解析返回的XML数据,然后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,918
精华内容 767
关键字:

自己搭一个webservice