CXF系列（四）：CXF整合spring

最新推荐文章于 2024-05-13 07:38:25 发布
最新推荐文章于 2024-05-13 07:38:25 发布
阅读量223 收藏
点赞数
分类专栏： Web Service JAVA 文章标签： cxf web service java


本文将介绍CXF与spring的整合开发，整体实例还是基于前三章。不过现在wsdl服务发布到tomcat，就不用发不到jetty了，相应的一些配置和代码有所改动。

1：pom.xml

[plain]   view plain  copy
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   
  5.   <groupId>com.qqw.example</groupId>  
  6.   <artifactId>CXF_Spring</artifactId>  
  7.   <version>0.0.1-SNAPSHOT</version>  
  8.   <packaging>jar</packaging>  
  9.   
  10.   <name>CXF_Spring</name>  
  11.   <url>http://maven.apache.org</url>  
  12.   
  13.   <properties>  
  14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  15.   </properties>  
  16.   
  17.   <dependencies>  
  18.     <dependency>  
  19.       <groupId>junit</groupId>  
  20.       <artifactId>junit</artifactId>  
  21.       <version>3.8.1</version>  
  22.       <scope>test</scope>  
  23.     </dependency>  
  24.       
  25.     <!-- 添加Spring支持 -->  
  26.     <dependency>  
  27.         <groupId>org.springframework</groupId>  
  28.         <artifactId>spring-core</artifactId>  
  29.         <version>4.1.7.RELEASE</version>  
  30.     </dependency>  
  31.     <dependency>  
  32.         <groupId>org.springframework</groupId>  
  33.         <artifactId>spring-beans</artifactId>  
  34.         <version>4.1.7.RELEASE</version>  
  35.     </dependency>  
  36.     <dependency>  
  37.          <groupId>org.springframework</groupId>  
  38.          <artifactId>spring-tx</artifactId>  
  39.          <version>4.1.7.RELEASE</version>  
  40.         </dependency>  
  41.     <dependency>  
  42.         <groupId>org.springframework</groupId>  
  43.         <artifactId>spring-context</artifactId>  
  44.         <version>4.1.7.RELEASE</version>  
  45.     </dependency>  
  46.     <dependency>  
  47.         <groupId>org.springframework</groupId>  
  48.         <artifactId>spring-context-support</artifactId>  
  49.         <version>4.1.7.RELEASE</version>  
  50.     </dependency>  
  51.        
  52.     <dependency>  
  53.         <groupId>org.springframework</groupId>  
  54.         <artifactId>spring-web</artifactId>  
  55.         <version>4.1.7.RELEASE</version>  
  56.     </dependency>  
  57.        
  58.     <dependency>  
  59.         <groupId>org.springframework</groupId>  
  60.         <artifactId>spring-webmvc</artifactId>  
  61.         <version>4.1.7.RELEASE</version>  
  62.     </dependency>  
  63.        
  64.     <dependency>  
  65.         <groupId>org.springframework</groupId>  
  66.         <artifactId>spring-aop</artifactId>  
  67.         <version>4.1.7.RELEASE</version>  
  68.     </dependency>  
  69.        
  70.        
  71.     <dependency>  
  72.         <groupId>org.springframework</groupId>  
  73.         <artifactId>spring-aspects</artifactId>  
  74.         <version>4.1.7.RELEASE</version>  
  75.     </dependency>  
  76.        
  77.     <dependency>  
  78.         <groupId>org.springframework</groupId>  
  79.         <artifactId>spring-jdbc</artifactId>  
  80.         <version>4.1.7.RELEASE</version>  
  81.     </dependency>  
  82.       
  83.     <!-- 添加cxf支持  -->  
  84.     <dependency>  
  85.         <groupId>org.apache.cxf</groupId>  
  86.         <artifactId>cxf-core</artifactId>  
  87.         <version>3.1.5</version>  
  88.     </dependency>  
  89.        
  90.     <dependency>  
  91.         <groupId>org.apache.cxf</groupId>  
  92.         <artifactId>cxf-rt-frontend-jaxws</artifactId>  
  93.         <version>3.1.5</version>  
  94.     </dependency>  
  95.        
  96.     <dependency>  
  97.         <groupId>org.apache.cxf</groupId>  
  98.         <artifactId>cxf-rt-transports-http</artifactId>  
  99.         <version>3.1.5</version>  
  100.     </dependency>  
  101.       
  102.     <!--实现日志  -->  
  103.     <dependency>  
  104.         <groupId>org.slf4j</groupId>  
  105.         <artifactId>slf4j-log4j12</artifactId>  
  106.         <version>1.7.22</version>  
  107.     </dependency>  
  108.       
  109.   </dependencies>  
  110. </project>  

2:spring的配置文件：applicationContext.xml

[html]   view plain  copy
  1. <?xml version="1.0" encoding="UTF-8"?>      
  2. <beans xmlns="http://www.springframework.org/schema/beans"      
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     
  4.     xmlns:p="http://www.springframework.org/schema/p"    
  5.     xmlns:aop="http://www.springframework.org/schema/aop"     
  6.     xmlns:context="http://www.springframework.org/schema/context"    
  7.     xmlns:jee="http://www.springframework.org/schema/jee"    
  8.     xmlns:tx="http://www.springframework.org/schema/tx"    
  9.     xmlns:jaxws="http://cxf.apache.org/jaxws"  
  10.     xsi:schemaLocation="      
  11.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd    
  12.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd    
  13.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd    
  14.         http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd    
  15.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
  16.         http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">      
  17.           
  18.         <!--这两个是必须要加的-->  
  19.     <import resource="classpath:META-INF/cxf/cxf.xml"/>  
  20.         <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>  
  21.       
  22.         <!-- 自动扫描 -->  
  23.     <context:component-scan base-package="com.qqw" />  
  24.       
  25.     <!-- 定义服务提供者  -->  
  26.     <jaxws:endpoint  
  27.         implementor="#helloWorld"  //这个就是接口实现类的交给spring容器管理的bean的名称  
  28.         address="/HelloWorld">   //这个是访问的具体地址，这个任意起名  
  29.         <!-- 添加in拦截器 -->  
  30.         <jaxws:inInterceptors>  
  31.              <bean class="org.apache.cxf.interceptor.LoggingInInterceptor"/>  
  32.              <bean class="com.qqw.interceptor.MyInterceptor"/>  
  33.         </jaxws:inInterceptors>  
  34.         <!-- 添加out拦截器 -->  
  35.         <jaxws:outInterceptors>  
  36.              <bean class="org.apache.cxf.interceptor.LoggingInInterceptor"/>  
  37.         </jaxws:outInterceptors>  
  38.      </jaxws:endpoint>  
  39. </beans>  

3：把前面的cxf服务端的代码都搬过来，去掉那个main方法。接口的实现类只需加上个注释

[java]   view plain  copy
  1. package com.qqw.webserviceImpl;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.HashMap;  
  5. import java.util.List;  
  6. import java.util.Map;  
  7.   
  8. import javax.jws.WebService;  
  9.   
  10. import org.springframework.stereotype.Component;  
  11.   
  12. import com.qqw.entity.Role;  
  13. import com.qqw.entity.User;  
  14. import com.qqw.webservice.HelloWorld;  
  15.   
  16. @Component("helloWorld")//和上面配置文件对应的名称  
  17. @WebService  
  18. public class HelloWorldImpl implements HelloWorld{  
  19.   
  20.     @Override  
  21.     public String say(String str) {  
  22.           
  23.         return "hello:"+str;  
  24.     }  
  25.   
  26.     @Override  
  27.     public List<Role> getUserRole(User user) {  
  28.           
  29.         List<Role> rList=null;  
  30.         if(user!=null){  
  31.             rList=new ArrayList<Role>();  
  32.             if(user.getName().equals("qqw")){  
  33.                 rList.add(new Role(1, "总经理"));  
  34.                 rList.add(new Role(2, "技术总监"));  
  35.             }else{  
  36.                 rList.add(new Role(3, "程序呀U呢"));  
  37.             }  
  38.               
  39.         }  
  40.         return rList;  
  41.     }  
  42.   
  43.     @Override  
  44.     public Map<String, List<Role>> getMap() {  
  45.           
  46.         Map<String, List<Role>> map=new HashMap<String, List<Role>>();  
  47.         List<Role> list=new ArrayList<Role>();  
  48.         list.add(new Role(1, "总经理"));  
  49.         list.add(new Role(2, "技术总监"));  
  50.         List<Role> list1=new ArrayList<Role>();  
  51.         list1.add(new Role(3, "程序呀U呢"));  
  52.         map.put("qqw", list);  
  53.         map.put("qqw1", list1);  
  54.         return map;  
  55.     }  
  56.   
  57. }  

4：web.xml

[html]   view plain  copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 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">  
  3.   <display-name>CXF_Spring</display-name>  
  4.   <welcome-file-list>  
  5.     <welcome-file>index.html</welcome-file>  
  6.     <welcome-file>index.htm</welcome-file>  
  7.     <welcome-file>index.jsp</welcome-file>  
  8.     <welcome-file>default.html</welcome-file>  
  9.     <welcome-file>default.htm</welcome-file>  
  10.     <welcome-file>default.jsp</welcome-file>  
  11.   </welcome-file-list>  
  12.   <!-- 处理编码格式 -->  
  13.     <filter>    
  14.         <filter-name>characterEncodingFilter</filter-name>    
  15.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>    
  16.         <init-param>    
  17.             <param-name>encoding</param-name>    
  18.             <param-value>UTF-8</param-value>    
  19.         </init-param>    
  20.         <init-param>    
  21.             <param-name>forceEncoding</param-name>    
  22.             <param-value>true</param-value>    
  23.         </init-param>    
  24.     </filter>    
  25.     <filter-mapping>    
  26.         <filter-name>characterEncodingFilter</filter-name>    
  27.         <url-pattern>/*</url-pattern>    
  28.     </filter-mapping>  
  29.       
  30.     <!-- Log4J Start -->  
  31.     <context-param>  
  32.         <param-name>log4jConfigLocation</param-name>  
  33.         <param-value>classpath:log4j.properties</param-value>  
  34.     </context-param>  
  35.     <context-param>  
  36.         <param-name>log4jRefreshInterval</param-name>  
  37.         <param-value>6000</param-value>  
  38.     </context-param>  
  39.     <!-- Spring Log4J config -->  
  40.     <listener>  
  41.         <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
  42.     </listener>  
  43.       
  44.     <!-- Spring配置文件 -->  
  45.     <context-param>  
  46.         <param-name>contextConfigLocation</param-name>  
  47.         <param-value>classpath:applicationContext.xml</param-value>  
  48.     </context-param>  
  49.     <listener>  
  50.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  51.     </listener>  
  52.       
  53.         <!--这个是必须加的-->  
  54.     <servlet>    
  55.      <servlet-name>CXFServlet</servlet-name>    
  56.      <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>    
  57.     </servlet>    
  58.        
  59.     <servlet-mapping>    
  60.        <servlet-name>CXFServlet</servlet-name>    
  61.        <url-pattern>/webservice/*</url-pattern>    
  62.     </servlet-mapping>  
  63.       
  64.     
  65. </web-app>  

5：只要把项目部署到tomcat，然后启动就行了。客户端的调用这时候会有变化，把客户端的原先生成的代码删掉，重新执行自动生成命令，这里我不粘图了，具体命令参考前面的，本文只需要把后面改成wsdl2java http://localhost:8080/CXF_spring/webservice/HelloWorld?wsdl就行，刷新客户端。客户端调用

[java]   view plain  copy
  1. package com.qqw.webservice;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.apache.cxf.frontend.ClientProxy;  
  6. import org.apache.cxf.interceptor.LoggingInInterceptor;  
  7. import org.apache.cxf.interceptor.LoggingOutInterceptor;  
  8.   
  9. import com.qqw.interceptor.AddHeaderInterceptor;  
  10. import com.qqw.webserviceimpl.HelloWorldImplService;  
  11.   
  12. public class Client {  
  13.   
  14.     /** 
  15.      * @param args 
  16.      */  
  17.     public static void main(String[] args) {  
  18.         // TODO Auto-generated method stub  
  19.   
  20.         HelloWorldImplService hService=new HelloWorldImplService();  
  21.         HelloWorld helloWorld = hService.getHelloWorldImplPort();  
  22.           
  23.         org.apache.cxf.endpoint.Client client = ClientProxy.getClient(helloWorld);  
  24.         client.getOutInterceptors().add(new LoggingOutInterceptor());//out日志  
  25.         client.getInInterceptors().add(new LoggingInInterceptor());//in日志  
  26.         client.getOutInterceptors().add(new AddHeaderInterceptor("qqw","123456")); // 添加自定义拦截器  
  27.       
  28.         User user=new User();  
  29.         user.setName("qqw1");  
  30.         List<Role> roleList = helloWorld.getUserRole(user);  
  31.         for(int i=0;i<roleList.size();i++){  
  32.             System.out.println("编号："+roleList.get(i).getId()+"/角色名称："+roleList.get(i).getName());  
  33.         }  
  34.         MyRoleArray map = helloWorld.getMap();  
  35.         List<MyRole> list = map.item;  
  36.         for(int i=0;i<list.size();i++){  
  37.             System.out.print(list.get(i).getKey()+":");  
  38.             for(Role r:list.get(i).getValue()){  
  39.                 System.out.print(r.getId()+","+r.getName());  
  40.             }  
  41.             System.out.println("================");  
  42.         }  
  43.           
  44.           
  45.     }  
  46.   
  47. }  

最后运行的效果：



至此，CXF整合spring完毕！！！   完整代码

碧空独云
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CXF使用教程（一）——简介以及入门案例
东天里的冬天
03-02 929
一.简介 Apache CXF是一个开源的Service框架，可以用于简化用户的service开发，基于CXF开发的应用可提供SOAP、XML/HTTP、RESTFUL HTTP或CORBA等服务。CXF底层页可以使用不同的传输协议，包括HTTP、JMS或JBI等。 特性： 支持大量的Web Service标准，包括SOAP、WS-I Basic Profile、WSDL、WS-Ad...
cxf之一基础理论介绍_介绍CXF
cusi77914的博客
07-01 1050
CXF是来自Apache Software Foundation的另一个Web服务堆栈，位于Axis2堆栈之后。 尽管它们来自同一组织，但Axis 2和CXF在配置和交付Web服务时采用了截然不同的方法。 在本文中，您将学习将JAXB 2.x和JAX-WS 2.x用于Web服务与CXF一起使用的基础知识，并且将看到CXF与其他JAXB / JAX-WS堆栈（Axis2和地铁-在先前的文章中讨论...
（五）CXF与spring的集成
一名菜鸟攻城师
08-17 82
使用代码优先开发webservice，cxf与spring的集成   服务端：将服务的发布交给spring完成 使用cargo插件在tomcat中独立发布项目 服务端提供一个cxf的webservice服务 pom.xml &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.o...
最全java WebService CXF Spring 自定义拦截器 附实例源码，java面试金融项目技术
最新发布
2401_84103344的博客
05-13 827
关于分布式，限流+缓存+缓存，这三大技术（包含：ZooKeeper+Nginx+MongoDB+memcached+Redis+ActiveMQ+Kafka+RabbitMQ）等等。这些相关的面试也好，还有手写以及学习的笔记PDF，都是啃透分布式技术必不可少的宝藏。以上的每一个专题每一个小分类都有相关的介绍，并且小编也已经将其整理成PDF啦本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取。
什么是CXF
热门推荐
lzh657083979的博客
07-15 2万+
Apache CXF 是一个开放源代码框架，提供了用于方便地构建和开发 Web 服务的可靠基础架构。它允许创建高性能和可扩展的服务，您可以将这样的服务部署在 Tomcat 和基于 Spring 的轻量级容器中，以及部署在更高级的服务器上，例如 Jboss、IBM® WebSphere® 或 BEA WebLogic。 该框架提供了以下功能： Web 服务标准支持：CXF 支持以下 Web 服务标
WebService之CXF使用
qq_35338042的博客
08-10 2469
Apache CXF 是一个开源的 WebService 框架，CXF可以用来构建和开发 WebService，这些服务可以支持多种协议，比如：SOAP、POST/HTTP、HTTP ，CXF 大大简化了WebService并且可以天然地和 Spring 进行无缝集成。
Spring整合CXF发布服务
04-02
在整合Spring和CXF之前，我们需要确保环境配置正确。这包括安装Java JDK、Apache CXF库和Spring框架。Spring可以通过Maven或Gradle引入依赖，而CXF同样可以在构建工具中配置相关依赖。 2. **创建CXF服务接口** ...
CXF和spring整合所需jar包
06-29
在Java企业级开发中，Apache CXF和Spring框架的整合是常见的实践，它们结合可以创建高效、灵活的服务提供和消费平台。Apache CXF是一个开源的Web服务框架，它支持多种Web服务标准，如SOAP、RESTful等。而Spring框架...
cxf整合spring
03-16
本文将深入探讨如何将CXF与Spring框架整合，以构建高效且灵活的Web服务解决方案。 首先，让我们了解CXF。CXF（CXF = CXF = "CXF 是一个框架"）是一个开源的Java框架，它允许开发人员创建和消费各种Web服务，包括...
spring整合cxf框架实例
08-30
Spring整合Apache CXF框架是为了构建高效、灵活的Web服务应用。CXF是一个开源的Web服务框架，它不仅支持SOAP和RESTful服务，还能与Spring框架深度集成，简化服务的开发和部署。 **服务端配置** 1. **创建动态Web...
Spring boot 整合CXF开发web service示例
08-30
知识点四：使用Spring Boot整合CXF 使用Spring Boot整合CXF可以使得开发Web Service变得非常简单。Spring Boot提供了一个简洁的配置方式，允许开发者使用JavaConfig方式配置CXF。例如： ```java @Configuration ...
spring + cxf
水月青花
04-27 3488
整合spring 和cxf框架。 一、什么是cxf CXF是建立在SOAP协议上的一个Web service框架。 什么事SOAP协议，简单来说就是两个不同项目（开发语言不同等）通过xml文件来描述要传输的东西，然后通过HTTP协议传输，接收方把收到的xml解析成需要的对象使用，返回的时候又用xml封装又通过http协议传输，如此就是SOAP协议。而CXF就是两个项目之间为了提供服务，而开发...
掌握使用CXF快速开发webservice服务和生成client端技能
wcwmsj的博客
01-19 2312
本文主要通过示例详细介绍了如何使用CXF进行webservice服务服务端的开发和服务发布，以及如何通过CXF为已经发布的webservice服务生成客户端代码，并详细演示了通过生成的客户端代码进行服务的调用，希望对有需要的小伙伴们有所帮助！
CXF - 基本介绍
chuangbizhuan3298的博客
07-11 1180
首先呢，我们先了解关于web service方面的知识，然后在介绍下cxf的基本情况。 1 什么是web service？ web service不是框架，更不是一种技术，而是一种跨平台，跨语言的规范。 2. web service 有什么作用 ? 2.1 web ser...
CXF学习（1）——CXF框架
小隐的博客
03-16 5551
一、简介 Apache CXF是开源的，CXF是两个项目的结合：由IONA技术公司（现在是Progress的一部分）开发的Celtix和由Codehaus主持的团队开发的XFire，合并是由人们在Apache软件基金会共同完成的。CXF的名字来源于"Celtix"和"XFire"的首字母。 CXF是一个开源Service框架，支持多种协议：SOAP、XML/HTTP、RestfulHTTP和COR...
Apache CXF快速上手教程
五谷杂粮
10-11 336
  基础架构 CXF旨在为服务创建必要的基础设施，它的整体架构主要由以下几个部分组成： 1.Bus 它是C X F架构的主干，为共享资源提供了一个可配置的场所，作用非常类似于S p r i n g的ApplicationContext。这些共享资源包括WSDL管理器、绑定工厂等。通过对Bus进行扩展，可以方便地容纳自己的资源，或替换现有的资源。默认Bus实现是基于Spring...
[webservice] springboot整合cxf
七夜之家
11-18 1709
xpath常用规则(其它规则可以参考文档：https://blog.csdn.net/qq_44619675/article/details/113938171)对于XML文档的读取来说，xpath几乎是通常的选择，而在使用webservice时通常伴随着对于XML文档的解析。springboot整合Apache cxf。2.3 service发布(cxf配置)文件包的bin目录下，然后执行如下命令。访问已经发布的服务。
框架 day64 WebService(注解),CXF框架(jax-ws,Jax-rs,与spring整合)
飛白的学习笔记
06-26 6539
框架 day64 WebService(注解),CXF框架(jax-ws,Jax-rs,与spring整合) REST架构风格
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、付费专栏及课程。

余额充值