WebService技术（二）

前言：学习笔记，以供参考

　　Apache CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services 。可以与Spring进行快速无缝的整合。灵活的部署，可以运行在Tomcat,Jboss,Jetty(内置),IBMWS,BeaWL上面。

　　更多CXF介绍：http://www.ibm.com/developerworks/cn/education/java/j-cxf/

1 cxf发布服务的类

用两个不同的类发布应用：

　　a. ServerFactoryBean -- FacotryBean

　　b. JaxWsServerFactoryBean(建议使用此类)

服务端与客户端类的使用映射关系如下图所示：

2 使用ServerFactoryBean类发布标准的webservice服务

　　下载cxf安装包apache-cxf-2.4.2，里面lib下jar包以供项目所有。

1 服务端

a.新建web项目，加入cxf的jar包

b.定义webservice的接口

package com.wp.service;
import javax.jws.WebService;
@WebService
public interface HelloWs {
    public String sayHello(String name);
}

c.定义webservice接口的实现类

package com.wp.service;
public class HelloWsImpl implements HelloWs {
    @Override
    public String sayHello(String name) {
        return "hello" + name;
    }
}

d.发布webservice服务

package com.wp.service;
import org.apache.cxf.frontend.ServerFactoryBean;
public class Server {
    public static void main(String[] args) {
        ServerFactoryBean sfb = new ServerFactoryBean();
        //1.服务提供者实现的接口
        sfb.setServiceClass(HelloWs.class);
        //2.指定访问路径
        sfb.setAddress("http://localhost:9090/ws");
        //3.指定服务实现类
        sfb.setServiceBean(new HelloWsImpl());
        //4.发布
        sfb.create();
        System.out.println("发布成功...");
    }
}

2 客户端

a.使用wsdl2java生成客户端代码调用服务（之前有解释，这里就不做解释了）

b.使用ClientProxyFactoryBean类调用service服务

　　客户端必须加入cxf的jar包

　　浏览器访问http://localhost:9090/ws?wsdl ，查看service和operation

　　1) 不同项目中调用

package com.wp.test;
import com.wp.client.HelloWs;
import com.wp.client.HelloWsPortType;
public class Client {
    public static void main(String[] args) {
        HelloWs hw = new HelloWs();
        HelloWsPortType h = hw.getHelloWsPort();
        String result = h.sayHello("小强");
        System.out.println(result);
    }
}

　　1) 在同一项目中调用

package com.wp.service;
import org.apache.cxf.frontend.ClientProxyFactoryBean;
public class Client {
    public static void main(String[] args) {
        ClientProxyFactoryBean cfb = new ClientProxyFactoryBean();
        cfb.setAddress("http://localhost:9090/ws");
        cfb.setServiceClass(HelloWs.class);
        HelloWs hw = (HelloWs) cfb.create();
        System.out.println(hw.sayHello("明明"));
    }
}

类似的例子在apache-cxf-2.4.2安装包下的samples中，开发的时候可以查看

3 使用JaxWsServerFactoryBean类发布服务

1 服务端

package com.wp.service;
import javax.jws.WebParam;
import javax.jws.WebService;
@WebService
public interface HelloWs {
    public String sayHello(@WebParam(name="text") String text);
}

package com.wp.service;
import javax.jws.WebService;
@WebService(endpointInterface = "com.wp.service.HelloWs")
public class HelloWsImpl implements HelloWs {
    @Override
    public String sayHello(String name) {
        return "hello  " + name;
    }
}

package com.wp.service;
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 jsfb = new JaxWsServerFactoryBean();
        //1.服务提供者实现的接口
        jsfb.setServiceClass(HelloWs.class);
        //2.指定访问路径
        jsfb.setAddress("http://localhost:9090/ws");
        //3.指定服务实现类
        jsfb.setServiceBean(new HelloWsImpl());
        //jsfb.getInInterceptors().add(new LoggingInInterceptor());
        //jsfb.getOutInterceptors().add(new LoggingOutInterceptor());
        //4.发布
        jsfb.create();
        System.out.println("发布成功...");
    }
}

2 客户端

生成客户端代码：

a.在不同项目中

package com.wp.test;
import org.apache.cxf.frontend.ClientProxyFactoryBean;
import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import com.wp.client.HelloWs;
public class Client {
    public static void main(String[] args) {
        JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
       // factory.getInInterceptors().add(new LoggingInInterceptor());
       // factory.getOutInterceptors().add(new LoggingOutInterceptor());
        factory.setAddress("http://localhost:9090/ws");
        HelloWs client = factory.create(HelloWs.class);
        System.out.println(client.sayHello("World"));
    }
}

b.在同一项目中

package com.wp.service;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
public class Client {
    public static void main(String[] args) {
        JaxWsProxyFactoryBean bean = new JaxWsProxyFactoryBean();
        bean.setAddress("http://localhost:9090/ws");
        bean.setServiceClass(HelloWs.class);
        HelloWs hw = (HelloWs) bean.create();
        System.out.println(hw.sayHello("www"));
    }
}

4 spring和cxf的集成（maven项目）

　　CXF原生支持spring，可以和Spring无缝集成。本例通过tomcat启动容器来启动cxf服务。

1 新建一个maven项目（写过一个随笔），并且加入jar包

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wp.test</groupId>
    <artifactId>cxfmaven</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>cxfmaven Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <properties>
        <spring.version>3.2.5.RELEASE_BUNDLE</spring.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-asm</artifactId>
            <version>3.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http</artifactId>
            <version>2.4.2</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>2.4.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http</artifactId>
            <version>2.4.2</version>
        </dependency>
        <!-- Jetty is needed if you‘re using the CXFServlet -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http-jetty</artifactId>
            <version>2.4.2</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>cxfmaven</finalName>
    </build>
</project>

pom.xml

2 让spring管理ServerFactoryBean

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://cxf.apache.org/jaxws
    http://cxf.apache.org/schemas/jaxws.xsd
    ">
    <!--
        1 导入cxf发布的命名空间
            xmlns:jaxws="http://cxf.apache.org/jaxws"
            http://cxf.apache.org/jaxws
            http://cxf.apache.org/schemas/jaxws.xsd
        2 通过配置发布webservice服务
            2.1 发布简单的webservice服务(不需要定义服务器的接口 ，了解)
                 <jaxws:endpoint address="" implementor="">
                 </jaxws:endpoint>
            2.2 发布标准的webservice服务
                2.2.1 发布的地址  address
                2.2.2 发布的服务器实现的接口  serviceClass
                2.2.3 指定服务具体提供者（实现类对象）  jaxws:serviceBean
     -->
     <!-- 实例化一个JaxWsServerFactoryBean对象 -->
     <jaxws:server address="/helloWs"
       serviceClass="com.wp.service.HelloWs">
         <jaxws:serviceBean>
             <bean class="com.wp.service.HelloWsImpl"></bean>
         </jaxws:serviceBean>
     </jaxws:server>
</beans>

spring.xml

3 cxf集成到web容器中

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <display-name></display-name>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <servlet>
        <servlet-name>cxf</servlet-name>
        <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
        <!-- 初始化CXFServlet -->
        <init-param>
            <param-name>config-location</param-name>
            <param-value>classpath:beans.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>cxf</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

web.xml

4 启动web容器发布webservice服务

wsdl访问地址：http://localhost:8080/wsService/helloWs?wsdl

通过Eclipse中的Web Services Explorer进行测试；
建立一个客户端项目进行测试，跟上面一样。

时间： 2024-10-26 04:47:09

WebService技术（二）的相关文章

webservice技术介绍

一.WebService到底是什么? 一言以蔽之:WebService是一种跨编程语言和跨操作系统平台的远程调用技术. 所谓跨编程语言和跨操作平台,就是说服务端程序采用java编写,客户端程序则可以采用其他编程语言编写,反之亦然!跨操作系统平台则是指服务端程序和客户端程序可以在不同的操作系统上运行. 所谓远程调用,就是一台计算机a上的一个程序可以调用到另外一台计算机b上的一个对象的方法,譬如,银联提供给商场的pos刷卡系统,商场的POS机转账调用的转账方法的代码其实是跑在银行服务器上.再比

C#线程同步技术(二) Interlocked 类

接昨天谈及的线程同步问题,今天介绍一个比较简单的类,Interlocked.它提供了以线程安全的方式递增.递减.交换和读取值的方法. 它的特点是: 1.相对于其他线程同步技术,速度会快很多. 2.只能用于简单的同步问题. 比叫好理解,不再赘述,给一个我们常用的单例模式的 Interlocked 实现: class SourceManager { private SourceManager() { } private static SourceManager sourceManager; publ

webservice技术--服务器端

1.webservice实现单点登录具体逻辑为 ①软通web端作为客户端,请求wi社区后台,进行登录请求 ②wi社区后台验证t,核实无误后,走登录逻辑,直接进入欢迎页 ③如果有错误,封装错误xml,返回给软通web端 2.wi社区后台实际上是要添加webservice服务端的代码 3.wi社区实际上也会写作为客户端的代码这是由于我在自测的时候,需要模拟软通web端的客户端进行request的xml格式数据的请求,所以,实际自测的逻辑为:通过软通提供的接口测试工具生成请求xml-在wi社区后台项

Python的Web编程[2] -> WebService技术[0] -> 利用 Python 调用 WebService 接口

WebService技术 / WebService Technology 1 关于webservice / Constants WebService是一种跨编程语言和跨操作系统平台的远程调用技术. WebService主要由以下三种技术构成,XML+XSD,SOAP和WSDL XML+XSD: WebService采用HTTP协议传输数据,采用XML格式封装数据(即XML中说明调用远程服务对象的哪个方法,传递的参数是什么,以及服务对象的返回结果是什么).XML是WebService平台中表示数据

cxf+spring+数字签名开发webservice（二）

场景上一章中的webservice接口,因为现场正式环境的项目与外部单位网络不通,是通过前置机与外部进行数据交换,所以我们将webservice部署在前置机,在使用HttpURLConnection与正式服务器上进行数据传递.这里可以使用的技术挺多的,如:java的rmi,Hessian,spring的HttpInvoker等,下面是使用HttpURLConnection的代码(实际情况是最后选择了spring的HttpInvoker): HttpURLConne

早期主流的WLAN技术(二)

4.1 802.11a IEEE 802.11a是802.11原始标准的一个修订标准,于1999年获得批准.802.11a标准采用了与原始标准相同的核心协议,工作频率为5GHz,使用52个正交频分多路复用载波,最大原始数据传输率为54Mb/s,这达到了现实网络中等吞吐量(20Mb/s)的要求.如果需要的话,数据率可降为48,36,24,18,12,9或者6Mb/s.802.11a拥有12条不相互重叠的频道,8条用于室内,4条用于点对点传输.它不能与IEEE 802.11b进行互操作,除非使用了

WebService系列二：使用JDK和CXF框架开发WebService

一.使用JDK开发WebService 服务端程序创建: 1.新建一个JDK开发webservice的服务端maven项目JDKWebServiceServer 2. 定义一个接口,使用@WebService注解标注接口,使用@WebMethod注解标注接口中定义的所有方法 1 package com.study.webservice.ws; 2 3 import javax.jws.WebMethod; 4 import javax.jws.WebService; 5 6 /** 7 * 定义

负载均衡技术(二）———常用负载均衡服务介绍

此文已由作者张小刚授权网易云社区发布. 欢迎访问网易云社区,了解更多网易技术产品运营经验. 在上一篇文章中,介绍了负载均衡服务,常用的负载均衡服务器以及负载均衡服务在公司的应用情况.这一篇文章会对上篇提到的负载均衡服务器进行较为深入的分析,对其主要功能,优缺点,使用场景进行介绍.希望可以起到抛砖引玉的左右,对大家在了解,使用不同的负载均衡服务有所帮助. LVS LVS是Linux Virtual Server的简写,意即Linux虚拟服务器,是一个基于Linux的负载均衡服务器.LVS项目在19

基于Python的Webservice开发(二)-如何用Spyne开发Webservice

一.功能需求本次案例是开发一个Item的新建的WebService.IN&OUT的类型JsonDocument. 通过传入相关的参数创建Item,且相关的参数可以被缺省. 二.实现代码引入类 from spyne import Application,rpc,ServiceBase,Iterable,Integer,Unicode #如果支持soap的协议需要用到Soap11 from spyne.protocol.soap import Soap11 #如果开发传入传出为Json需要用到J