Spring整合CXF发布Web Services

最新推荐文章于 2020-11-27 11:45:17 发布
最新推荐文章于 2020-11-27 11:45:17 发布
阅读量542 收藏
点赞数
分类专栏： WebService 文章标签： cxf web services
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jclpc/article/details/48930403
版权

Spring的Web项目搭建不再描述，主要介绍Web项目整合CXF发布Web Services

1.导入CXF需要的jar包

cxf-2.7.2.jar

httpasyncclient-4.0-beta3.jar

httpclient-4.2.1.jar

httpcore-4.2.2.jar

httpcore-nio-4.2.2.jar

neethi-3.0.2.jar

wsdl4j-1.6.2.jar

xmlschema-core-2.0.3.jar

2.web.xml文件添加下面内容

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:beans.xml,classpath:applicationContext.xml</param-value>
</context-param>

<!-- 部署CXFServlet -->
<servlet>
<servlet-name>CXFServlet</servlet-name>
<servlet-class>
org.apache.cxf.transport.servlet.CXFServlet
  </servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>CXFServlet</servlet-name>
<url-pattern>/webservice/*</url-pattern>
</servlet-mapping>

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: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">
<!-- 导入cxf.jar解压出来的文件 -->        
<import resource="classpath:META-INF/cxf/cxf.xml"/>
<import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>
<bean id="testWebServiceImpl" class="com.cName.pName.webservice.impl.TestWebServiceImpl"/>
<jaxws:endpoint id="testWebService" address="/testWebService" implementorClass="com.cName.pName.webservice.impl.TestWebServiceImpl">
    <jaxws:implementor ref="testWebServiceImpl"/>
</jaxws:endpoint>
</beans>

4.提供服务的接口TestWebService.java

package com.cName.pName.webservice;
import javax.jws.WebParam;
import javax.jws.WebService;
@WebService
public interface TestWebService {
/**
* 
* @param xmlStr
* @return String
* 
*/
public String testRequest(@WebParam(name = "xmlStr") String xmlStr);
}

4.服务的接口实现类TestWebServiceImpl.java

package com.cName.pName.webservice.impl;
import javax.jws.WebService;
import com.cName.pName.webservice.TestWebService;
@WebService
public class TestWebServiceImpl implements TestWebService {
public String testRequest(String xmlStr) {
System.out.println(xmlStr);
String resultXml = "resultXml";
return resultXml;
}
}

5.调用接口的客户端TestWebServiceClient.java

import java.rmi.RemoteException;
import javax.xml.namespace.QName;
import javax.xml.rpc.ParameterMode;
import javax.xml.rpc.ServiceException;
import javax.xml.rpc.encoding.XMLType;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
public class TestWebServiceClient {
public static void main(String[] args) throws ServiceException,
RemoteException {
String xmlStr = "test";
Service service = new Service();
Call call = (Call) service.createCall();
call.setTargetEndpointAddress("http://localhost:8080/pName/webservice/testWebService?wsdl");
QName qName = new QName("http://webservice.pName.cName.com/",
"testRequest");
call.setOperationName(qName);
call.setUseSOAPAction(true);
// 这下面两行一定要加上，否则接收在服务器端收不到。
call.addParameter("xmlStr", XMLType.XSD_STRING, ParameterMode.IN);
call.setReturnType(XMLType.XSD_STRING);
String result = (String) call.invoke(new Object[] { xmlStr });
System.out.println("aa" + result);
}
}

到目前CXF就整合到Spring项目中了，启动Web，访问http://localhost:8080/pName/webservice/testWebService?wsdl就可以看到wsdl的描述文件了。

注意：

将Spring的容器初始化交给了DispatcherServlet，在applicationContext.xm配置了webService

运行部署后发现提示错误No Service have found。原因是因为cxf的spring容器必须使用ContextLoadListener来启动，而spring MVC采用的DispatcherServlet来启动的，所以无法加载cxf的服务。

以下注意事项来自博文http://kyfxbl.iteye.com/blog/1432920

Spring MVC是通过DispatcherServlet来加载Spring配置文件的，因此不需要在web.xml中配置ContextLoaderListener。但是CXF却需要通过ContextLoaderListener来加载Spring。 

这样就产生了一个矛盾，如果不配置ContextLoaderListener，CXF就无法正常使用。但如果配置ContextLoaderListener，又会造成Spring的重复加载（DispatcherServlet一次，ContextLoaderListener一次） 

在网上查了一下资料，只看到一个国外的程序员提出不配置ContextLoaderListener，通过写一个CXFController，来替代默认的CXFServlet。但是这种HACK的方式总是不太好 

所以我采用一种折中的方式，来解决Spring MVC和cxf并存的问题。但是也不是很优雅，希望有人能给出更好的办法 

首先是web.xml的配置 

Xml代码   收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xmlns="http://java.sun.com/xml/ns/javaee"  
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
  5.     id="MyFramework" version="3.0">  
  6.       
  7.     <display-name>MyFramework</display-name>  
  8.       
  9.     <context-param>  
  10.         <param-name>contextConfigLocation</param-name>  
  11.         <param-value>   
  12.             WEB-INF/beans.xml,   
  13.             WEB-INF/cxf.xml  
  14.         </param-value>   
  15.     </context-param>  
  16.       
  17.     <listener>    
  18.         <listener-class>    
  19.             org.springframework.web.context.ContextLoaderListener    
  20.         </listener-class>    
  21.     </listener>    
  22.       
  23.     <servlet>  
  24.         <servlet-name>framework</servlet-name>  
  25.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  26.         <init-param>    
  27.             <param-name>contextConfigLocation</param-name>    
  28.             <param-value>WEB-INF/spring-mvc.xml</param-value>    
  29.         </init-param>    
  30.         <load-on-startup>1</load-on-startup>  
  31.     </servlet>  
  32.   
  33.     <servlet-mapping>  
  34.         <servlet-name>framework</servlet-name>  
  35.         <url-pattern>/</url-pattern>  
  36.     </servlet-mapping>  
  37.       
  38.     <servlet>    
  39.         <servlet-name>CXFServlet</servlet-name>    
  40.         <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>    
  41.         <load-on-startup>2</load-on-startup>    
  42.     </servlet>    
  43.     
  44.     <servlet-mapping>    
  45.         <servlet-name>CXFServlet</servlet-name>    
  46.         <url-pattern>/webservice/*</url-pattern>    
  47.     </servlet-mapping>    
  48.       
  49. </web-app>  

在ContextLoaderListener里面，加载cxf和spring的公共配置信息。然后在DispatcherServlet中加载spring mvc所需的信息。利用Spring配置文件拆分的方式，既实现spring mvc和cxf的共存，又避免spring配置信息的重复加载 

然后是公共的配置信息，beans.xml 
Xml代码   收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xmlns:context="http://www.springframework.org/schema/context"  
  6.     xmlns:tx="http://www.springframework.org/schema/tx"  
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  8.                             http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
  9.                             http://www.springframework.org/schema/context   
  10.                             http://www.springframework.org/schema/context/spring-context-3.1.xsd  
  11.                             http://www.springframework.org/schema/tx  
  12.                             http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">  
  13.   
  14.     <context:component-scan base-package="com.huawei.framework" />  
  15.   
  16.     <bean id="propertyConfigurer"  
  17.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  18.         <property name="locations">  
  19.             <list>  
  20.                 <value>classpath:jdbc.properties</value>  
  21.             </list>  
  22.         </property>  
  23.     </bean>  
  24.   
  25.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
  26.         <property name="driverClass" value="${jdbc.driver}" />  
  27.         <property name="jdbcUrl" value="${jdbc.url}" />  
  28.         <property name="user" value="${jdbc.username}" />  
  29.         <property name="password" value="${jdbc.password}" />  
  30.         <property name="minPoolSize" value="10" />  
  31.         <property name="maxPoolSize" value="50" />  
  32.     </bean>  
  33.   
  34.     <bean id="sessionFactory"  
  35.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  36.         <property name="dataSource" ref="dataSource" />  
  37.         <property name="mappingLocations"  
  38.             value="classpath:/com/huawei/framework/model/**/*.hbm.xml" />  
  39.         <property name="hibernateProperties">  
  40.             <props>  
  41.                 <prop key="hibernate.dialect">org.hibernate.dialect.OracleDialect</prop>  
  42.                 <prop key="hibernate.show_sql">true</prop>  
  43.                 <prop key="hibernate.format_sql">true</prop>  
  44.                 <prop key="hibernate.jdbc.fetch_size">50</prop>  
  45.                 <prop key="hibernate.jdbc.batch_size">25</prop>  
  46.                 <prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>  
  47.             </props>  
  48.         </property>  
  49.     </bean>  
  50.   
  51.     <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">  
  52.         <property name="sessionFactory" ref="sessionFactory" />  
  53.         <property name="fetchSize" value="10" />  
  54.     </bean>  
  55.   
  56.     <bean id="transactionManager"  
  57.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  58.         <property name="sessionFactory" ref="sessionFactory" />  
  59.     </bean>  
  60.   
  61.     <tx:annotation-driven transaction-manager="transactionManager" />  
  62.   
  63. </beans>  

然后是cxf所需的信息，cxf.xml 
Xml代码   收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.                             http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
  7.                             http://cxf.apache.org/jaxws   
  8.                             http://cxf.apache.org/schemas/jaxws.xsd">  
  9.   
  10.     <import resource="classpath:META-INF/cxf/cxf.xml" />  
  11.     <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />  
  12.   
  13.     <jaxws:endpoint id="helloWorld"  
  14.         implementorClass="com.huawei.framework.webservice.HelloWorldImpl"  
  15.         address="/HelloWorld" />  
  16.   
  17. </beans>  

最后是spring mvc所需的信息，spring-mvc.xml 
Xml代码   收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
  5.     xmlns:p="http://www.springframework.org/schema/p"  
  6.     xmlns:context="http://www.springframework.org/schema/context"  
  7.     xmlns:mvc="http://www.springframework.org/schema/mvc"   
  8.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  9.                             http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
  10.                             http://www.springframework.org/schema/context   
  11.                             http://www.springframework.org/schema/context/spring-context-3.1.xsd  
  12.                             http://www.springframework.org/schema/mvc  
  13.                             http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">  
  14.   
  15.     <context:component-scan base-package="com.huawei.framework" />  
  16.   
  17.     <mvc:annotation-driven />  
  18.   
  19.     <mvc:default-servlet-handler />  
  20.   
  21.     <bean  
  22.         class="org.springframework.web.servlet.view.InternalResourceViewResolver"  
  23.         p:prefix="/WEB-INF/view/" p:suffix=".jsp"  
  24.         p:viewClass="org.springframework.web.servlet.view.JstlView" />  
  25.   
  26. </beans>  

这顺便还带来一个附带的好处，即进行单元测试的时候，可以仅加载必须的类，比如做DAO组件的单元测试，就不需要加载spring-mvc.xml和cxf.xml了 
Java代码   收藏代码
  1. @RunWith(SpringJUnit4ClassRunner.class)  
  2. @ContextConfiguration(locations = { "file:WebContent/WEB-INF/beans.xml" })  
  3. public class UserDaoHibernateTest {  
  4.   
  5.     @Autowired  
  6.     private UserDao dao;  
  7.   
  8.     private static String ID;  
  9.   
  10.     @Test  
  11.     public void testInsert() {  
  12.         User user = new User();  
  13.         user.setName("fme001");  
  14.         user.setAge(23);  
  15.         dao.insert(user);  
  16.     }  
  17.   
  18.     @Test  
  19.     public void testQueryByName() {  
  20.         String name = "fme001";  
  21.         User user = dao.queryByName(name);  
  22.         assertEquals(23, user.getAge());  
  23.         ID = user.getId();  
  24.     }  
  25.   
  26.     @Test  
  27.     public void testQueryByAge() {  
  28.         int age = 23;  
  29.         List<User> result = dao.queryByAge(age);  
  30.         assertEquals(1, result.size());  
  31.     }  
  32.   
  33.     @Test  
  34.     public void testQueryAll() {  
  35.         List<User> result = dao.queryAll();  
  36.         assertEquals(1, result.size());  
  37.     }  
  38.   
  39.     @Test  
  40.     public void testQuery() {  
  41.         User user = dao.query(ID);  
  42.         assertEquals(23, user.getAge());  
  43.         assertEquals("fme001", user.getName());  
  44.     }  
  45.   
  46.     @Test  
  47.     public void testUpdate() {  
  48.         User user = dao.query(ID);  
  49.         user.setAge(24);  
  50.         dao.update(user);  
  51.         user = dao.query(ID);  
  52.         assertEquals(24, user.getAge());  
  53.     }  
  54.   
  55.     @Test  
  56.     public void testDelete() {  
  57.         User user = dao.query(ID);  
  58.         dao.delete(user);  
  59.     }  
  60.   
  61. }  

可以看到，集成cxf和spring mvc确实不算很方便，需要绕一绕。上述方法只是一个折中的方案，希望新版本的cxf可以提供一个CXFController，这样的话就可以统一用DispatcherServlet来加载Spring，不配置ContextLoaderListener。这样的话web.xml可以简洁很多。


刘尐
关注
专栏目录
Spring整合CXF
抛弃幻想，准备斗争
04-25 2793
一、分布式开发： 在现实的开发环境中，可能一个项目会被部署到不同的区域上，例如银行系统。省，城市都有各自的服务器。 所有的服务器都有可能调用一个业务中心，这样如果单独将业务中心抽取出来，做业务的处理过程，只要中心的业务修改了， 那么其他服务器也会产生变化。 现在的分布式开发，更多情况是将业务中心的操作分步处理，给所有的客户端提供支持。 技术的过渡: -》 -》 ...
Cxf - Spring集成Cxf暴露WebServices
袭冷
04-19 1187
一、Spring集成Cxf暴露Web Services     1、新建Web工程，导入Spring Core、Spring Web和Cxf的jar包     2、配置web.xml <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLS
五、CXF整合Spring
hoojo
03-30 2772
首先，CXF和spring整合需要准备如下jar包文件： 这边我是用Spring的jar包是Spring官方提供的，并没有使用CXF中的Spring的jar文件。 添加这么多文件后，首先在web.xml中添加如下配置： org.springframework.web.context.ContextLoaderListener contextConf
spring 整合cxf
疯狂的芒果
11-27 279
https://www.cnblogs.com/hoojo/archive/2011/03/30/1999563.html https://blog.csdn.net/yhahaha_/article/details/81395397 https://www.cnblogs.com/maggieq8324/p/13060968.html <import resource="classpath:META-INF/cxf/cxf.xml"/> <...
spring整合CXF
qq_41603209的博客
06-03 749
spring整合CXF 1.如何用Spring来整合CXF，来发布WebService服务 首先我们来建一个Maven项目 WebService_CXF 建好项目第一步，我们打开pom.xml 我们来添加下Spring支持： <!-- 添加Spring支持 --> <dependency> <groupId>org.springframework<...
Spring集成Cxf调用WebServices
04-19
总之，Spring集成CXF调用Web Services是一个强大的组合，它提供了灵活的配置方式和强大的功能，使开发者能够更高效地构建和维护Web服务应用。通过理解并实践上述知识点，开发者可以更好地驾驭这一技术栈。
Spring集成Cxf暴露WebServices示例
04-19
本示例将探讨如何通过Spring集成Cxf来暴露Web服务，帮助开发者更好地理解和实现这一功能。 首先，我们需要了解Spring与Cxf的基本概念。Spring框架提供了一个全面的编程和配置模型，用于简化企业级Java应用程序的...
Springboot整合CXF发布Web service和客户端调用（用户和密码验证）
10-16
本教程将详细介绍如何利用Spring Boot与CXF进行集成，以发布Web服务并实现用户和密码验证的客户端调用。 首先，我们需要在Spring Boot项目中引入CXF的依赖。这通常通过在`pom.xml`文件中添加对应的Maven依赖来完成...
Spring和CXF整合发布WebService(服务端、客户端)
热门推荐
yhahaha_的博客
08-06 4万+
目录 一、服务端 1、依赖 1.1 第一种方式 1.2 第二种方式 2、测试代码 3、配置文件 3.1 第一种配置方式 3.2 第二种配置方式 4、运行 二、生成客户端 第一种方式wsdl2java 第二种方式 wsimport 三、测试 工作上遇到了，所以自己琢磨了一下，也是第一次想到用博客来记录，平时也有用word文档记录，怕忘了。所以在这里来一个详细总结，那些关于...
CXF Spring 整合
07-31
Web Service学习-CXF与Spring整合为JavaEE应用发布WebService（三）
spring整合CXF开发webService接口所需的全部jar包
04-19
花费了1天整理的jar包，spring的版本较低，但是可以用。
CXF和spring整合所需jar包
06-29
CXF和spring整合所需jar包
Spring 整合CXF
Wayne_y的博客
04-16 193
CXF依赖：&lt;!-- 添加cxf支持 --&gt; &lt;dependency&gt; &lt;groupId&gt;org.apache.cxf&lt;/groupId&gt; &lt;artifactId&gt;cxf-core&lt;/artifactId&gt; &lt;version&gt;3.1.5&lt;/version&gt; &a
Spring与CXF整合
shumago的博客
11-03 478
1. Eclipse工具New 选择Dynamic Web Project 点击下一步，注意勾选xml文件生成选项 在src中建立包com.itheima.webservice 可以看到项目的文件层级如下图 2. 创建最简单的HelloWorld接口 package com.itheima.webserver; import javax.jws.WebServic
spring与cxf的整合
heihei
05-27 1948
1.倒入cxf所需要的包（其中包括spring的支持） 2.编写SEI与服务 package cn.itcast.ws.pojo; import java.util.Date; public class WeatherModel { //天气概况 private String detail; //日期 private Date data; //最高温度 pr
Spring整合CXF实现Web服务
ganmaotong的博客
11-13 316
Apache CXF 是Apache旗下一个优秀的 Web服务（WS）开源框架，具备轻量级的特性。CXF可以用来构建和开发 WebService，这些服务可以支持多种协议，比如：SOAP、POST/HTTP、HTTP ，CXF 大大简化了WebService并且可以和 Spring 进行无缝集成。CXF是 Celtrix （ESB框架）和 XFire（webserivice） 合并...
cxf与spring的整合
weixin_34377919的博客
07-26 218
cxf与spring的整合： 一：服务端相关配置（配置好后启动tomocat就自动发布了接口，浏览器打开验证下） 1：导入cxf以及spring的相关jar包; 2:在web.xml中增加配置： 代码： 1 <!--添加cxf配置文件--> 2 3 <context-param> 4 5 &l...
Spring+CXF整合：发布RESTful WebService教程
首先，对于Spring整合CXF的基础设置，文章假设读者已经熟悉了《Spring整合CXFWebService详解》(http://www.cnblogs.com/hoojo/archive/2011/03/30/1999563.html)和《Spring MVC对RESTful的支持》...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值