CXF整合Spring发布WebService实例

最新推荐文章于 2018-07-26 12:24:00 发布

kris234seth

最新推荐文章于 2018-07-26 12:24:00 发布

阅读量7.9k

点赞数 1

分类专栏： WebService 文章标签： cxf spring webservice 发布调用

本文链接：https://blog.csdn.net/kris234seth/article/details/50509053

版权

WebService 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、说明：

上一篇简单介绍了CXF以及如何使用CXF来发布一个简单的WebService服务，并且介绍了客户端的调用。

这一篇介绍如何使用CXF与spring在Web项目中来发布WebService服务，CXF版本为3.1.4 ，Spring版本为4.1.7 ，JDK版本 1.7 ，Tomcat 7

二、WebService发布实例实现过程：

首先略过CXF、以及spring的下载过程。

① 新建 Java Dynamic Web project 工程，导入CXF与spring的相关jar包，具体用到的包如下：

aopalliance-1.0.jar
asm-5.0.4.jar
cxf-core-3.1.4.jar
cxf-rt-bindings-soap-3.1.4.jar
cxf-rt-bindings-xml-3.1.4.jar
cxf-rt-databinding-jaxb-3.1.4.jar
cxf-rt-frontend-jaxws-3.1.4.jar
cxf-rt-frontend-simple-3.1.4.jar
cxf-rt-transports-http-3.1.4.jar
cxf-rt-ws-addr-3.1.4.jar
cxf-rt-ws-policy-3.1.4.jar
cxf-rt-wsdl-3.1.4.jar
jaxb-core-2.2.11.jar
jaxb-impl-2.2.11.jar
jaxb-xjc-2.2.11.jar 
jcl-over-slf4j-1.7.12.jar
neethi-3.0.3.jar
slf4j-api-1.7.12.jar
slf4j-jdk14-1.7.12.jar
spring-aop-4.1.7.RELEASE.jar
spring-beans-4.1.7.RELEASE.jar
spring-context-4.1.7.RELEASE.jar
spring-core-4.1.7.RELEASE.jar
spring-expression-4.1.7.RELEASE.jar
spring-web-4.1.7.RELEASE.jar
stax2-api-3.1.4.jar
woodstox-core-asl-4.4.1.jar
wsdl4j-1.6.3.jar
xml-resolver-1.2.jar
xmlschema-core-2.2.1.jar

② 在工程的web.xml文件中增加支持spring与CXF的配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>CXFWebDemo</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  
   <!-- 加入CXF支持 -->
   <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>
   
   <!-- 加入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>

③ 新建com.elgin.cxf.service包以及 com.elgin.cxf.service.impl ,并增加提供webservice服务的接口类以及其实现：

HelloService :

package com.elgin.cxf.service;
import javax.jws.WebParam;
import javax.jws.WebService;

import com.elgin.cxf.entities.User;

@WebService
public interface HelloService {
   
	public String sayHello(@WebParam(name="text")String text);
	
	public User getUserByName(String name);
}

HelloServiceImpl :

package com.elgin.cxf.service.impl;
import javax.jws.WebService;

import com.elgin.cxf.entities.User;
import com.elgin.cxf.service.HelloService;


@WebService(endpointInterface="com.elgin.cxf.service.HelloService")
public class HelloServiceImpl implements HelloService {

	@Override
	public String sayHello(String text ) {
		return "hello " + text;
	}

	@Override
	public User getUserByName(String name) {
		User user=new User(name);
		return user;
	}

}

User 类：

package com.elgin.cxf.entities;

public class User {
    private String name;

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

	public User(String name) {
		super();
		this.name = name;
	}
    
	@Override
	public String toString() {
		return "User [name=" + name + "]";
	}
	
}

④ . 配置CXF配置文件来发布webservice服务：

新建package ：CXFConfig （用来保存CXF相关的配置文件）。并在此包下新建xml配置文件：CXFServices.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:jaxws="http://cxf.apache.org/jaxws"
	xmlns:soap="http://cxf.apache.org/bindings/soap"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
		http://cxf.apache.org/bindings/soap http://cxf.apache.org/schemas/configuration/soap.xsd">
  
   <!-- 
        1.使用jaxws:endpoint标签的配置发布一个 webservice 
        2.服务提供实现类为 com.elgin.cxf.service.impl.HelloServiceImpl，用implementor属性配置
        3.address属性配置外部访问的相对路径
        4.使用  jaxws:inInterceptors 标签配置2个日志拦截器，用来打印调用时的日志信息
        5.注意：在此配置文件中，需加入jaxws与soap命名空间
   -->
   <jaxws:endpoint id="helloService" 
                   implementor="com.elgin.cxf.service.impl.HelloServiceImpl" 
                   address="/hello" > 
        <jaxws:inInterceptors >
		   <bean id="inMessageInterceptor" class="org.apache.cxf.interceptor.LoggingInInterceptor"/>  
		   <bean id="outLoggingInterceptor" class="org.apache.cxf.interceptor.LoggingOutInterceptor"/>  
        </jaxws:inInterceptors>
   </jaxws:endpoint>
   
</beans>

⑤ . 在src 下新建spring的配置文件：applicationContext.xml ,并导入CXF的配置到此文件中：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   
   <!-- CXF服务端发布配置 -->
   <import resource="/CXFConfig/CXFServices.xml"/>
   
   <!-- 项目中其它bean配置 -->
   <!-- 
        ....
    -->
</beans>

⑥ . 测试发布情况：

经过以上5个步骤，CXF的相关配置完成，将项目加载到Tomcat ，并启动，访问如下URL：http://localhost:8080/CXFWebDemo/services/hello?wsdl ，出现下面的xml数据，说明发布成功：

三、使用 CXF的WebService 服务调用实例：

首先另外新建一个web工程，将发布时候所使用的jar包导入

① 、客户端调用方法一（使用wsdl2Java工具手动生成服务端接口代码）：

A、在src新工程的src下新建一个配置文件：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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   
   <!-- 客户端调用配置 -->
   
   <!-- service bean配置 -->
   <bean id="helloService" class="com.elgin.cxf.service.HelloService"
                           factory-bean="clientFactory" factory-method="create"/>
   
   <!-- client 工厂 ，用来产生service实例 -->
   <bean id="clientFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean" >
      <property name="serviceClass" value="com.elgin.cxf.service.HelloService"/>
      <property name="address" value="http://localhost:8080/CXFWebDemo/services/hello"></property>
   </bean>

</beans>

说明：

1）、上述的配置文件中，指定了一个bean工厂：org.apache.cxf.jaxws.JaxWsProxyFactoryBean ，该工厂可以通过 serviceClass中的值来产生对应的服务端接口 service bean

2）、同时 address 属性，指定了webservice服务的调用地址

3）、同时我们注意到，有一个类：com.elgin.cxf.service.HelloService ，其实这个类就是服务端的Helloservice接口。在客户端，这个类从何而来呢？这就是我们接下来要说的如何使用 wsdl2java工具了

B、通过调用地址，利用CXF的wsdl2java工具生成服务端接口代码：

1）、配置CXF环境变量：

在环境变量path加入 CXF 包中bin目录的位置，如我的是：C:\Users\zqkj001\Desktop\常用文档或文件\A学习文档\webservice\apache-cxf-3.1.4\bin

在cmd命令中输入wsdl2java，如果有提示usage，就表明配置成功

2）、打开 Cmd 控制台，切换到CXF的bin目录下，输入如下格式的命令：

wsdl2java -p com -d D:\\src -all  xx.wsdl

-p  指定其wsdl的命名空间，也就是要生成代码的包名:

-d  指定要产生代码所在目录

-client 生成客户端测试web service的代码

-server 生成服务器启动web  service的代码

-impl 生成web service的实现代码

-ant  生成build.xml文件

这里我需要生成上述已发布webservice服务端的代码，需要输入的命令如下：

wsdl2java -d D:\\src -client http://localhost:8080/CXFWebDemo/services/hello?wsdl

运行之后，在d盘的src目录下，会发现相关的代码：

这样，我们服务端的接口代码就生成成功啦！

C、将上述自动生成的代码拷贝到src下，之后项目结构为：

代码复制之后，再在client包下新建一个Client类,如下：

package com.elgin.cxf.client;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.elgin.cxf.service.HelloService;
import com.elgin.cxf.service.User;


public class Client {	
	public static void main(String[] args) {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
		HelloService helloService=(HelloService) ctx.getBean("helloService");
		String  result = helloService.sayHello("World");
		System.out.println(result);    
		User obj=helloService.getUserByName("Jack");
		System.out.println(obj);
	}
}

运行client类，结果为：

出现上面的结果，说明客户端调用成功。

② 客户端调用方法二（用JaxWsDynamicClientFactory创建动态的客户端）

这种方法调用的优点就是不需要使用wsdl2java来生成服务端的代码

在client包下新建类：ClientDynamic

package com.elgin.cxf.client;

import javax.xml.namespace.QName;

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;

import com.elgin.cxf.service.User;

public class ClientDynamic {
    
	public static void main(String[] args) {
	 method2();
	}

	public static void method2() {
		//创建 JaxWsDynamicClientFactory 工厂实例
            JaxWsDynamicClientFactory factory=JaxWsDynamicClientFactory.newInstance();
		//根据服务地址创建客户端
            Client client=factory.createClient("http://localhost:8080/CXFWebDemo/services/hello?wsdl");
		Object [] result;
		try {
			result=client.invoke("sayHello", "World");
			System.out.println(result[0]);
			result=client.invoke("getUserByName", "Jack");
			User user=(User) result[0];
			System.out.println(user);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

运行此类：Run as ------》JavaApplication ，控制台报错，信息为：

一月 14, 2016 11:48:18 上午 org.apache.cxf.common.jaxb.JAXBUtils logGeneratedClassNames
INFO: Created classes: com.elgin.cxf.service.GetUserByName, com.elgin.cxf.service.GetUserByNameResponse, com.elgin.cxf.service.ObjectFactory, com.elgin.cxf.service.SayHello, com.elgin.cxf.service.SayHelloResponse, com.elgin.cxf.service.User
Exception in thread "main" java.lang.NullPointerException
	at org.apache.cxf.common.util.Compiler.useJava6Compiler(Compiler.java:187)
	at org.apache.cxf.common.util.Compiler.compileFiles(Compiler.java:141)
	at org.apache.cxf.common.util.Compiler.compileFiles(Compiler.java:136)
	at org.apache.cxf.endpoint.dynamic.DynamicClientFactory.compileJavaSrc(DynamicClientFactory.java:611)
	at org.apache.cxf.endpoint.dynamic.DynamicClientFactory.createClient(DynamicClientFactory.java:370)
	at org.apache.cxf.endpoint.dynamic.DynamicClientFactory.createClient(DynamicClientFactory.java:241)
	at org.apache.cxf.endpoint.dynamic.DynamicClientFactory.createClient(DynamicClientFactory.java:234)
	at org.apache.cxf.endpoint.dynamic.DynamicClientFactory.createClient(DynamicClientFactory.java:189)
	at com.elgin.cxf.client.ClientDynamic.method2(ClientDynamic.java:40)
	at com.elgin.cxf.client.ClientDynamic.main(ClientDynamic.java:14)

错误产生的原因：

JaxWsDynamicClientFactory是一个动态代理类，，执行到这里的时候需要编译生成java类，但是JRE是指可以运行class文件，并没有编译的能力，所以需要修改eclipse中的编译环境。

产生的原因是没有获得编译环境，也就是JRE设置的问题，需要在eclipse里面把jre设置为jdk下的jre。

打开Java的安装路径，发现会有2个jre目录，比我我自己的2个目录分别是：

C:\Program Files\Java\jre7

C:\Program Files\Java\jdk1.7.0_17\jre

现在需要把jre 为jdk下的jre目录，也就是上面的第二个，具体在eclipse的操作：

windows---》preference--》Java --》Installed Jres --》add --》Standard VM --》add

然后再jre home填入第上述第二个路径，jre name 填入 JdkJre7 ，保存。

选中客户端项目，右键--》Build Path --》Configure Build path 把工程使用的 jre 切换为刚才新建的 JdkJre

然后重新运行 ClientDynamic 类，这时会发现上面的错误信息不见了，而是换成了另外一个异常信息：

<span style="font-size:14px;">一月 14, 2016 1:27:19 下午 org.apache.cxf.common.jaxb.JAXBUtils logGeneratedClassNames
INFO: Created classes: com.elgin.cxf.service.GetUserByName, com.elgin.cxf.service.GetUserByNameResponse, com.elgin.cxf.service.ObjectFactory, com.elgin.cxf.service.SayHello, com.elgin.cxf.service.SayHelloResponse, com.elgin.cxf.service.User
org.apache.cxf.common.i18n.UncheckedException: No operation was found with the name {http://impl.service.cxf.elgin.com/}sayHello.
	at org.apache.cxf.endpoint.ClientImpl.invoke(ClientImpl.java:289)
	at org.apache.cxf.endpoint.ClientImpl.invoke(ClientImpl.java:283)
	at com.elgin.cxf.client.ClientDynamic.method2(ClientDynamic.java:43)
	at com.elgin.cxf.client.ClientDynamic.main(ClientDynamic.java:14)</span>

对于这条错误，根据报错信息来看：在 http://impl.service.cxf.elgin.com/ 命名空间下没有 sayHello 这个操作，这是为什么呢？

因为：

CXF发布用的是业务类(HelloServiceImpl.java)，那么默认的命名空间就会是业务类所在包（路径），而对外界暴露的则是接口类(HelloService.java)，那么对于客户端（第三方）调用访问时，需要按照接口类所在包（路径）进行命名空间的定义。

在上述错误的情况下，我们有2种方式来处理，一种是在客户端调用时，指定接口的命名空间，另一种是在服务端发布WebService服务的时候，明确的指定命名空间，这样就不存在不统一的问题了。

方案一客户端调用代码：

package com.elgin.cxf.client;

import javax.xml.namespace.QName;

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;

import com.elgin.cxf.service.User;

public class ClientDynamic {
    
	public static void main(String[] args) {
	         method1();
	}
	
	public static void method1(){
		//创建 JaxWsDynamicClientFactory 工厂实例
		JaxWsDynamicClientFactory factory=JaxWsDynamicClientFactory.newInstance();
		//创建客户端
		Client client=factory.createClient("http://localhost:8080/CXFWebDemo/services/hello?wsdl");
		Object [] result;
		QName qname;
		try {
			//根据指定的命名空间（接口类包名）、方法名新建QName对象
			qname=new QName("http://service.cxf.elgin.com/", "sayHello");
			result=client.invoke(qname, "World");
			System.out.println(result[0]);
			qname=new QName("http://service.cxf.elgin.com/", "getUserByName");
			result=client.invoke(qname, "Jack");
			User user=(User) result[0];
			System.out.println(user);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

运行此类，控制台打印结果正确：

方案二：在服务端指定命名空间

修改服务端的HelloServiceImpl 类：

ckage com.elgin.cxf.service.impl;

import javax.jws.WebService;
import com.elgin.cxf.entities.User;
import com.elgin.cxf.service.HelloService;

@WebService(endpointInterface="com.elgin.cxf.service.HelloService",
            targetNamespace="http://service.cxf.elgin.com/")
public class HelloServiceImpl implements HelloService {

	@Override
	public String sayHello(String text ) {
		return "hello " + text;
	}

	@Override
	public User getUserByName(String name) {
		User user=new User(name);
		return user;
	}
}

修改之后，保存，重新启动Tomcat，查看链接内容：http://localhost:8080/CXFWebDemo/services/hello?wsdl ，发布成功，并且发现命名空间已变为我们指定的名字：

之后重新执行method2()方法的内容：

package com.elgin.cxf.client;

import javax.xml.namespace.QName;

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;

import com.elgin.cxf.service.User;

public class ClientDynamic {
    
	public static void main(String[] args) {
		     method2();
	}
	public static void method2() {
		JaxWsDynamicClientFactory factory=JaxWsDynamicClientFactory.newInstance();
		Client client=factory.createClient("http://localhost:8080/CXFWebDemo/services/hello?wsdl");
		Object [] result;
		try {
			result=client.invoke("sayHello", "World");
			System.out.println(result[0]);
			result=client.invoke("getUserByName", "Jack");
			User user=(User) result[0];
			System.out.println(user);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

调用正确，返回正确结果：

kris234seth

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
CXF整合Spring发布WebService实例

一、说明：上一篇简单介绍了CXF以及如何使用CXF来发布一个简单的WebService服务，并且介绍了客户端的调用。这一篇介绍如何使用CXF与spring在Web项目中来发布WebService服务，CXF版本为3.1.4 ，Spring版本为4.1.7 ，JDK版本 1.7 ，Tomcat 7二、实例实现过程：首先略过CXF、以及spring的下载过程。① 新建 J
复制链接

扫一扫