springboot+cxf 搭建webservice接口项目
SpringBoot调用第三方WebService接口的操作技巧(.wsdl与.asmx类型)

SpringBoot调⽤第三⽅WebService接⼝的操作技巧(.wsdl与.asmx类型)依赖引⼊相关依赖:<!-- webService--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web-services</artifactId></dependency><!-- CXF webservice --><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-spring-boot-starter-jaxws</artifactId><version>3.2.1</version></dependency><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-rt-transports-http</artifactId><version>3.2.1</version></dependency>浏览webService提供的⽅法,确定⼊参顺序直接在浏览器⾥⾯访问url,如下⽤SoapUI⼯具⽤些是.asmx格式,也可以直接在浏览器访问。
会列出⽅法列表代码创建client:package com.gqzdev.sctads.configuration;import monConstant;import lombok.extern.slf4j.Slf4j;import org.apache.cxf.endpoint.Client;import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory; import org.apache.cxf.transport.http.HTTPConduit;import org.apache.cxf.transports.http.configuration.HTTPClientPolicy;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;/*** @author gqzdev* @date 2021/08/26 15:53**/@Configuration@Slf4jpublic class JaxWsClientConfig {@Bean("JaxWsClient")public Client client() {// 创建动态客户端JaxWsDynamicClientFactory clientFactory = JaxWsDynamicClientFactory.newInstance();//CommonConstant.PUBLIC_SECURITY_URL为连接的url,如http://10.189.200.170:9201/wharfWebService/services/WharfService?wsdl ("publicsecurity webService url : {}", CommonConstant.PUBLIC_SECURITY_URL);//创建clientClient client = clientFactory.createClient(CommonConstant.PUBLIC_SECURITY_URL);HTTPConduit conduit = (HTTPConduit) client.getConduit();HTTPClientPolicy policy = new HTTPClientPolicy();policy.setAllowChunking(false);// 连接服务器超时时间 10秒policy.setConnectionTimeout(10000);// 等待服务器响应超时时间 20秒policy.setReceiveTimeout(20000);conduit.setClient(policy);return client;}}有了client,便可以直接注⼊调⽤invoke。
CXF方式构建WebService服务

WebService CXF
WebService的实现方式有几种:axis、xFire、CXF,本文主要概述CXF的方式构建WebService,用spring和CXF进行整合,会使WebService的构建变得更加简单。
服务端:
1.新建项目ws,将cxf-
2.2.9.jar和spring相关的jar包放到项目中
2.
3.
4.
5.重新启动项目,在浏览器输入:http://localhost:8080/ws/userService?wsdl,如果能
正确的以xml的方式显示接口提供的方法,说明服务端启动成功。
客户端:
1.新建项目client,需要使用到以下包,
2.使用jdk的wsimport命令生成调用服务端时所以需要使用的类(前提是server端必
须已经启动),命令如果:
-s 表示生成的类放到哪个目录,目录必须先创建好,这里的目录叫tmp
后面直接加上WebService的url就行了,这样就可以将所有相关的类都生成出来,将这样java文件放到client项目中,注意:包名不能改,它生成出来的包的结构是怎样就直接到项目中,不然会调用不成功
3.在生成的java文件中,你会发现有一个UserInfoService.java,在这个UserInfoService
类中就可以直接调用服务端接口的方法了。
利用CXF框架开发webservice接口共32页文档

21、要知道对好事的称颂过于夸大,也会招来人们的反感轻蔑和嫉妒。——培根 22、业精于勤,荒于嬉;行成于思,毁于随。——韩愈
23、一切节省,归根到底都归结为时间的节省。——马克思 24、意志命运往往背道而驰,决心到最后会全部推倒。——莎士比亚
25、学习是劳动,是充满思想的劳动。——乌申斯基
谢谢!
利用CXF框架开发webservice接口
11、获得的成功越大,就越令人高兴 。野心 是使人 勤奋的 原因, 节制使 , 再有枝 叶,尔 后花实 ,好好 劳动, 不要想 太多, 那样只 会使人 胆孝懒 惰,因 为不实 践,甚 至不接 触社会 ,难道 你是野 人。(名 言网) 13、不怕,不悔(虽然只有四个字,但 常看常 新。 14、我在心里默默地为每一个人祝福 。我爱 自己, 我用清 洁与节 制来珍 惜我的 身体, 我用智 慧和知 识充实 我的头 脑。 15、这世上的一切都借希望而完成。 农夫不 会播下 一粒玉 米,如 果他不 曾希望 它长成 种籽; 单身汉 不会娶 妻,如 果他不 曾希望 有小孩 ;商人 或手艺 人不会 工作, 如果他 不曾希 望因此 而有收 益。-- 马钉路 德。
cxf+spring发布webservice接口及接口的调用

一、CXF介绍Apache CXF=Celtix+XFire,Apache CXF的前身叫Apache CeltiXfire。
CXF继承了Celtix和XFire两大开源项目的精华,提供了对JAX-WS全面的支持,并且提供了多种Binding、DataBinding、Transport以及各种Format的支持,并且可以根据实际项目的需要,采用代码优先(Code First)或者WSDL优先(WSDL First)来轻松地实现Web Services的发布和使用。
Apache CXF已经是一个正式的Apache顶级项目。
CXF支持多种协议,如:SOAP、XML/HTTP、RESTful HTTP、CORBA,并且可以在多种传输协议上运行,比如:HTTP、JMS、JBI。
CXF可以与Spring进行无缝集成。
CXF框架是一种基于Servlet技术的SOA应用开发框架,要正常运行基于CXF应用框架开发的企业应用,除了CXF框架本身之外,还需要JDK和Servlet容器的支持。
CXF下载地址:/download.html,选择“File”列中的zip格式下载。
解压后可以看到一些文件夹:└─apache-cxf-2.5.0├─bin各种工具├─docs API文档├─etc各种配置文件├─lib开发所需jar包├─licenses说明├─modules jar包└─samples使用例子samples文件夹中给提供了在各种环境下使用的例子,个人感觉只需参照样例即可。
二、使用CXF+Spring编写并发布WebService首先,新建一个Web项目,名字叫cxftest,将下载的压缩包中lib文件夹下的jar包全部拷贝到项目的WEB-INF/lib中,在web.xml中配置如下:[html]view plaincopy1.<servlet>2.<servlet-name>CXFServlet</servlet-name>3.<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>4.<load-on-startup>1</load-on-startup>5.</servlet>6.<servlet-mapping>7.<servlet-name>CXFServlet</servlet-name>8.<url-pattern>/services/*</url-pattern>9.</servlet-mapping>然后,在项目src目录下新建包:com.test,在新建的包中创建TestService.java,代码如下:[java]view plaincopy1.package com.test;2.3.import javax.jws.WebService;4.5.@WebService6.public interface TestService{7.8.public String sayHi(String name);9.10.}接着,在创建TestServiceImpl.java,代码如下:[java]view plaincopy1.package com.test;2.3.import javax.jws.WebService;4.5.@WebService(endpointInterface="com.test.TestService")6.public class TestServiceImpl implements TestService{7.8.public String sayHi(String name){9.10.return name+",welcome to here!";11.}12.}CXF中采用注解的方式声明哪些类作为WebService进行发布,@WebService:声明webservice接口;@WebService(endpointInterface="com.test.TestService"):声明这个类是TestService接口的实现类。
使用CXF开发WebService

使用Spring+CXF开发WebServiceApache CXF 提供方便的Spring整合方法,可以通过注解、Spring标签式配置来暴露Web Services和消费Web Services各种类型的Annotation。
@WebService和@WebMethod是WSDL映射Annatotion。
这些Annotation将描述Web Service的WSDL文档元素和Java源代码联系在一起。
@SOAPBinding是一个绑定的annotation用来说明网络协议和格式。
1、@WebService annotation的元素name,serviceName和targetNamespace成员用来描述wsdl:portType,wsdl:service,和targetNameSpace生成WebService中的WSDL文件。
2、@SOAPBinding是一个用来描述SOAP格式和RPC的协议的绑定Annotation。
3、@WebMethod Annotation的operationName成员描述了wsdl:operation,而且它的操作描述了WSDL文档中的SOAPAction头部。
这是客户端必须要放入到SQAPHeader中的数值,SOAP 1.1中的一种约束。
4、@WebParam Annotation的partName成员描述了WSDL文档中的wsdl:part。
5、@WebResult Annotation的partName成员描述了wsdl:part用来返回WSDL文档的值。
例如下面使用annotation定义了一个webservice:import java.util.List;import javax.jws.WebMethod;import javax.jws.WebParam;import javax.jws.WebResult;import javax.jws.WebService;import er;@WebService(targetNamespace = "/client") public interface UserService {@WebMethod(operationName="Insert")public void insert( @WebParam(name = "userId") String userid,@WebParam(name = "userName") String username,@WebParam(name = "userEmail") String useremail,@WebParam(name = "userAge") int userage);@WebMethod(operationName="GetUserById")@WebResult(name = "result")public User getUserById(@WebParam(name="userid") String userid);@WebMethod(operationName="GetAllUsers")@WebResult(name = "result")public List getAllUsers();}其实现类如下所示:import java.util.List;import javax.jws.WebService;import erDao;import er;import erService;@WebService(endpointInterface="erService")public class UserServiceImpl implements UserService {private UserDao userDao;public List getAllUsers() {return userDao.findAllUser();}public User getUserById(String userid) {return userDao.findUserById(userid);}public void insert(String userid, String username, String useremail, int userage) {User user=new User();user.setUserage(userage);user.setUseremail(useremail);user.setUserid(userid);user.setUsername(username);userDao.insert(user);System.out.println("insert successfully!");}public void setUserDao(UserDao userDao) {erDao = userDao;}}注意:实现类中的@WebService,其中的endpointInterface成员指定了该类实现的接口在Spring的配置文件中,需要对其进行配置:首先在ApplicationContext.xml(Spring的配置文件)中引入CXF的XML Scheam 配置文件),如下:<beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jaxws="/jaxws"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /jaxws/schemas/jaxws.xsd"><!—还需要引入以下3个关于CXF的资源文件,这三个文件在cxf.jar中--><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>其次就是在Spring的配置文件中配置webservice,如下所示:<jaxws:endpoint id="userManager" address="/UserManager"implementorClass="erService"><jaxws:implementor><bean id="userServiceImpl"class="erServiceImpl"><property name="userDao"><ref bean="userDao" /></property></bean></jaxws:implementor></jaxws:endpoint>注意:①、address 为webservice发布的地址②、implementorClass 为该webservice实现的接口③、<jaxws:implementor></jaxws:implementor>之间定义的是implementorClass指定接口的实现类另外,在Spring的配置文件中配置完成后,需要修改web.xml文件<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>/services/*</url-pattern></servlet-mapping>注意<url-pattern>/ services /*</url-pattern>配置,CXFServlet会拦截此类url,进行处理。
利用CXF框架开发webservice接口

写Web Service的接口
• 书写一个Web Service的接口类
写Web Service的实现
Web Service服务和使用
• Web Service服务者 • Web Service使用者
使用 Web 服务的原理
发布的 WebService
WSDL
▪Client程序(Java、 .NET)
面向服务的体系架构
• 一个组件模型
• 将应用程序的不同功能单元(服务)
通过这些服务之间定义良好的接口和 契约联系起来。
Web Service体系结构
服务提供商发布绑定Fra bibliotek服务代理商
服务注册表
查找
服务请求者
Web Service工作原理
此处的双向虚线表示一次性通信
获取类型信息(XML 模 式)
客户端 端应用程序
参数
基于 HTTP 的 SOAP 协议 XML
返回值
服务描述文件
存放 Web 服务的 Web 服务器
总结
• Web Service是一个应用程序,它能通过网络,特别是互联 网来描述、发布、定位及调用的服务
• Web Service体系结构包含三种角色:服务提供商、服务代 理商和服务请求者。这些角色之间有相互存在着一些操作 ,它们分别是:发布、查找和绑定
• Web Service 是基于XML的。它在Internet上一般使用SOAP 进行传输
• UDDI用于维护存储服务提供商及其服务信息的注册表 • WSDL是用来描述Web Service 的,客户端程序经常通过
springboot-实现WebService(CXF实现)的拦截器(Interceptor)

springboot-实现WebService(CXF实现)的拦截器(Interceptor)拦截器(Interceptor)是CXF功能最主要的扩展点,可以在不对核心模块进行修改的情况下,动态添加很多功能。
拦截器和JAX-WS Handler、Filter的功能类似,当服务被调用时,就会创建一个拦截器链(Interceptor Chain),拦截器链在服务输入(IN)或输出(OUT)阶段实现附加功能。
拦截器可以在客户端,也可以在服务端添加。
当客户端发起一个WebService请求时,在客户端会创建输出拦截器链(outinterceptor),服务端接收到客户端的后,会创建输入拦截器链(ininterceptor)。
当服务端返回响应消息时,响应消息会经过服务端的输出拦截链,客户端接收到服务端的响应时,会创建输入拦截器链,响应消息先经过输入拦截器链处理。
拦截器在服务端和客户端的作用如图所示。
注:上图来源于网络。
下面,我们以一个Header认证为例,来演示CXF的拦截器的使用。
1、客户端拦截器[java] view plain copy1.public class ClientAuthorInterceptor extends AbstractPhaseInterceptor<SoapMessage> {2.3./**4.* 客户端申请的token信息5.*/6.private String token;7.8.public ClientAuthorInterceptor(String token) {9.// 设置拦截器的时机,在发送请求到服务端之前进行拦截10.super(Phase.PREPARE_SEND);11.this.token = token;12.}13.14.@Override15.public void handleMessage(SoapMessage soap) throw s Fault {16.// 在soap消息中添加认证头信息17.List<Header> headers = soap.getHeaders();18.Document doc = DOMUtils.createDocument();19.Element auth = doc.createElement(AuthorHeader.HEA DER_NAME);20.Element token = doc.createElement(AuthorHeader.HE ADER_TOKEN);21.token.setTextContent(this.token);22.auth.appendChild(token);23.Header header = new SoapHeader(new QName(Auth orHeader.HEADER_NAME), auth);24.headers.add(header);25.}26.}注意:客户端是outinterceptor2、服务端拦截器下面,服务端对发送的消息进行拦截,并做认证[java] view plain copy1.@Slf4j2.@Component3.public class AuthInterceptor extends AbstractPhaseInterc eptor<SoapMessage> {4.5.@Autowired6.private AuthorizationRepository repository;7.8.public AuthInterceptor() {9.super(ER_LOGICAL);10.}11.12.@Override13.public void handleMessage(SoapMessage message) t hrows Fault {14.Header header = message.getHeader(new QName("a uthrity"));15.if(null == header){16.log.warn("token没有认证通过!原因为:客户端请求中不存在认证的Header");17.throw new Fault(new AuthenticationException("token 没有认证通过!原因为:客户端请求中不存在认证的Header"));18.}19.Element ele = (Element) header.getObject();20.if(null == ele){21.log.warn("token没有认证通过!原因为:客户端请求中认证的Header无认证信息");22.throw new Fault(new AuthenticationException("token 没有认证通过!原因为:客户端请求中认证的Header无认证信息"));23.}24.Node node = ele.getFirstChild();25.if(null == node){26.log.warn("token没有认证通过!原因为:客户端请求中认证的Header无认证信息");27.throw new Fault(new AuthenticationException("token 没有认证通过!原因为:客户端请求中认证的Header无认证信息"));28.}29.String token = node.getTextContent();30.if(null == token || token.isEmpty()){31.log.warn("token没有认证通过!原因为:客户端请求中认证的Header无token信息");32.throw new Fault(new AuthenticationException("token 没有认证通过!原因为:客户端请求中认证的Header无token信息"));33.}34.Authorization auth = repository.findByToken(token);35.if(null == auth){36.log.warn("token没有认证通过!原因为:客户端请求中认证的token信息无效,请查看申请流程中的正确token信息");37.throw new Fault(new AuthenticationException("token 没有认证通过!原因为:客户端请求中认证的token信息无效,请查看申请流程中的正确token信息,流程申请地址:http://127.0.0.1:8080/email"));38.}("客户端认证成功,token有效!");40.}41.}注:服务端为ininterceptor编写拦截器很简单,只需继承AbstractPhaseInterceptor类并实现handleMessage即可。
WebService案例Springboot+CXF开发WebServiceDemo

WebService案例Springboot+CXF开发WebServiceDemo ⼀、本次开发除了⽤到spring boot基础jar包外,还⽤到了cxf相关jar包:1 <!-- cxf⽀持 -->2 <dependency>3 <groupId>org.apache.cxf</groupId>4 <artifactId>cxf-rt-frontend-jaxws</artifactId>5 <version>3.1.6</version>6 </dependency>7 <dependency>8 <groupId>org.apache.cxf</groupId>9 <artifactId>cxf-rt-transports-http</artifactId>10 <version>3.1.6</version>11 </dependency>⼆、⾸先我们创建⼀个实体类,内容是关于⽤户信息的查询和记录:1 import java.io.Serializable;2 import java.util.Date;34 public class User implements Serializable {56 private static final long serialVersionUID = -5939599230753662529L;7 private String userId;8 private String username;9 private String age;10 private Date updateTime;11 //getter setter ......12 public void setUserId(String userId) {13 erId=userId;14 }15 public void setUsername(String username) {16 ername=username;17 }18 public void setAge(String age) {19 this.age=age;20 }21 public void setUpdateTime(Date updateTime) {22 this.updateTime=updateTime;23 }242526 public String getUserId() {27 return userId;28 }29 public String getUserName() {30 return username;31 }32 public String getAge() {33 return age;34 }35 public Date getUpdateTime() {36 return updateTime;37 }38 }三、接下来我们创建接⼝类:1 import javax.jws.WebMethod;2 import javax.jws.WebParam;3 import javax.jws.WebService;45 import er;678 @WebService9 public interface UserService {1011 @WebMethod12 String getName(@WebParam(name = "userId") String userId);13 @WebMethod14 User getUser(String userId);15 }四、有了接⼝类,那么接下来我们对接⼝进⾏实现,也就是接⼝实现类(也就是业务类)代码:1 package cn.paybay.demo.service.impl;23 import java.util.Date;4 import java.util.HashMap;5 import java.util.Map;6789 import javax.jws.WebService;1011 import er;12 import erService;1314 @WebService(targetNamespace="/",endpointInterface = "erService")15 public class UserServiceImpl implements UserService{1617 private Map<String, User> userMap = new HashMap<String, User>();18 public UserServiceImpl() {19 System.out.println("向实体类插⼊数据");20 User user = new User();21 user.setUserId("411001");22 user.setUsername("zhansan");23 user.setAge("20");24 user.setUpdateTime(new Date());25 userMap.put(user.getUserId(), user);2627 user = new User();28 user.setUserId("411002");29 user.setUsername("lisi");30 user.setAge("30");31 user.setUpdateTime(new Date());32 userMap.put(user.getUserId(), user);3334 user = new User();35 user.setUserId("411003");36 user.setUsername("wangwu");37 user.setAge("40");38 user.setUpdateTime(new Date());39 userMap.put(user.getUserId(), user);40 }41 @Override42 public String getName(String userId) {43 return "liyd-" + userId;44 }45 @Override46 public User getUser(String userId) {47 System.out.println("userMap是:"+userMap);48 return userMap.get(userId);49 }5051 }注释(PS):在发布服务之前,我们要在这⾥对业务实现类进⾏⼀下说明,请⼤家看下图箭头指向的⽅框部分(图⼀)下⾯我来解释⼀下加上图⽅框箭头所指代码的⽬的:/:这是我的业务类所在路径;/:这是我的接⼝类所在路径;在不加上图⽅框箭头所指代码的情况下,你最后发服务的结果是这样的(如下图):(图⼆)并且会在你进⾏客户端调⽤的时候回报错:No operation was found with the name {/}getUser.那么原因就是:在CXF发布服务的时候,发布的是业务类(UserServiceImpl.java),那么默认的命名空间就会是业务类所在包(路径),⽽对外界暴露的则是接⼝类(UserService.java),那么对于客户端调⽤的时侯,需要按照接⼝类所在路径进⾏命名空所以在发布之前我们要在业务类(UserServiceImpl.java)上增加注解,指定命名空间,然后再进⾏发布,那么我们最终在加上(图⼀)⽅框箭头所指代码情况下,发布服务的结果为下图(请看图三):(图三)五、(发布服务)接⼝类,业务类代码都已经准备好,那么我接下来我就要对webservice服务进⾏发布:代码如下:1 23 import javax.xml.ws.Endpoint;45 import org.apache.cxf.Bus;6 import org.apache.cxf.bus.spring.SpringBus;7 import org.apache.cxf.jaxws.EndpointImpl;8 import org.apache.cxf.transport.servlet.CXFServlet;9 import org.springframework.boot.web.servlet.ServletRegistrationBean;10 import org.springframework.context.annotation.Bean;11 import org.springframework.context.annotation.Configuration;1213 import erService;14 import erServiceImpl;151617 @Configuration18 public class TestConfig {1920 @Bean21 public ServletRegistrationBean dispatcherServlet() {22 return new ServletRegistrationBean(new CXFServlet(), "/test/*");23 }24 @Bean(name = Bus.DEFAULT_BUS_ID)25 public SpringBus springBus() {26 return new SpringBus();27 }28 @Bean29 public UserService userService() {30 return new UserServiceImpl();31 }32 @Bean33 public Endpoint endpoint() {34 EndpointImpl endpoint = new EndpointImpl(springBus(), userService());35 endpoint.publish("/user");36 return endpoint;37 }3839 }那么到这⾥呢,我们的所有的步骤基本完成了,启动spring boot 然后再浏览器中输⼊url:http://localhost:8080/webservice/test/user?wsdl可以看到有相关的wsdl描述信息输出了,说明服务已经发布了。
使用CXF开发WebService程序的总结(七):Spring+CXF+Mybatis+。。。

使⽤CXF开发WebService程序的总结(七):Spring+CXF+Mybatis+。
通过该demo,可以熟悉下 spring+cxf+maven+mybatis+mysql等常见后端技术整合1. 在前⾯的⽗⼯程 ws_parent 中添加依赖由于原来的项⽬是使⽤的cxf依赖,现在需要集成spring,mybatis,所以需要在⽗⼯程添加依赖,最新的⽗⼯程的pom⽂件如下:<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.lonely.webservice</groupId><artifactId>ws_parent</artifactId><version>0.0.1-SNAPSHOT</version><packaging>pom</packaging><properties><spring-version>4.1.7.RELEASE</spring-version><mybatis.version>3.4.1</mybatis.version><mybatis.spring.version>1.3.0</mybatis.spring.version><pagehelper.version>4.0.0</pagehelper.version><mysql.version>5.1.32</mysql.version><druid.version>1.0.9</druid.version><jstl.version>1.2</jstl.version><servlet-api.version>2.5</servlet-api.version><jsp-api.version>2.0</jsp-api.version><slf4j.api.version>1.7.10</slf4j.api.version><logback.version>1.1.7</logback.version><dbcp.version>1.4</dbcp.version></properties><!-- 配置依赖 --><dependencyManagement><dependencies><!-- spring依赖 --><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>${spring-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>${spring-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</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-context-support</artifactId><version>${spring-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>${spring-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</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-aspects</artifactId><version>${spring-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>${spring-version}</version></dependency><!-- cxf依赖 --><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-core</artifactId><version>3.1.6</version></dependency><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-rt-frontend-jaxws</artifactId><version>3.1.6</version></dependency><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-rt-transports-http-jetty</artifactId><version>3.1.6</version></dependency><!-- mybatis依赖 --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>${mybatis.version}</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>${mybatis.spring.version}</version></dependency><dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId><version>${pagehelper.version}</version></dependency><!-- mysql --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>${mysql.version}</version></dependency><!-- 连接池 --><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>${druid.version}</version></dependency><dependency><groupId>commons-dbcp</groupId><artifactId>commons-dbcp</artifactId><version>${dbcp.version}</version></dependency><!-- JSP相关 --><dependency><groupId>jstl</groupId><artifactId>jstl</artifactId><version>${jstl.version}</version></dependency><dependency><groupId>javax.servlet</groupId><artifactId>servlet-api</artifactId><version>${servlet-api.version}</version><scope>provided</scope></dependency><dependency><groupId>javax.servlet</groupId><artifactId>jsp-api</artifactId><version>${jsp-api.version}</version><scope>provided</scope></dependency><!-- ⽇志处理 --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>${slf4j.api.version}</version></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>${logback.version}</version></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-core</artifactId><version>${logback.version}</version></dependency></dependencies></dependencyManagement><!-- 配置插件信息 --><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding></configuration></plugin></plugins></build><modules><module>ws_server</module><module>ws_client</module><module>ws_ssm_server</module></modules></project>2. 新建⼀个maven⼦⼯程 ws_ssm_server2.1 新建⼀个⼦⼯程,打包⽅式为 war格式,因为spring的很多依赖有重复,经整理后其pom⽂件如下:<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance" xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion><parent><groupId>com.lonely.webservice</groupId><artifactId>ws_parent</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>ws_ssm_server</artifactId><packaging>war</packaging><dependencies><!-- spring依赖 --><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId></dependency><!-- 添加 cxf 依赖 --><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-core</artifactId></dependency><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-rt-frontend-jaxws</artifactId></dependency><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-rt-transports-http-jetty</artifactId></dependency><!-- mybatis依赖 --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId></dependency><!-- mysql --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><!-- 连接池 --><dependency><groupId>commons-dbcp</groupId><artifactId>commons-dbcp</artifactId></dependency><!-- ⽇志处理 --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-core</artifactId></dependency></dependencies></project>2.2 spring整合cxf2.2.1 在web.xml中添加 cxf 拦截器处理器配置,以及 spring容器启动创建配置<?xml version="1.0" encoding="UTF-8"?><web-app version="2.5"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd"><!-- 字符编码过滤器,必须放在过滤器的最上⾯ --><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>characterEncoding</param-name><param-value>UTF-8</param-value></init-param></filter><filter-mapping><filter-name>encodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring/application.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><!-- 配置cxf拦截器 --><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>/cxf/*</url-pattern></servlet-mapping><welcome-file-list><welcome-file>/index.jsp</welcome-file></welcome-file-list></web-app>2.2.2 在resource⽬录下创建⽂件夹 spring,在⾥⾯创建spring与cxf集成的配置⽂件: spring-cxf.xml这⾥注意要添加⼀个 jaxws的命名空间,以及引⼊两个 cxf中的 xml配置<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:jaxws="/jaxws"xmlns:context="/schema/context"xsi:schemaLocation="/jaxws /schemas/jaxws.xsd/schema/beans /schema/beans/spring-beans.xsd/schema/context /schema/context/spring-context.xsd"><import resource="classpath:META-INF/cxf/cxf.xml" /><import resource="classpath:META-INF/cxf/cxf-servlet.xml" /><!-- 定义服务提供者 --><jaxws:endpoint implementor="#userService" address="/UserService" ><!-- 添加⼊ in 拦截器 --><jaxws:inInterceptors><bean class="com.lonely.interceptor.AuthInterceptor"></bean><bean class="org.apache.cxf.interceptor.LoggingInInterceptor"></bean></jaxws:inInterceptors><!-- 添加出 out 拦截器 --><jaxws:outInterceptors><bean class="org.apache.cxf.interceptor.LoggingOutInterceptor"></bean></jaxws:outInterceptors></jaxws:endpoint></beans>2.2.3 jaxws:endpoint 中的 implementor:对应的服务接⼝的实现类,⽽ address :对应发布的接⼝路径,注意在实际的接⼝实现类上使⽤注解 @Component让spring 扫描发现管理,给个别名⽤于在了 implementor属性上UserServicepackage com.lonely.service;import java.util.List;import java.util.Map;import javax.jws.WebService;import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;import com.lonely.adapter.MapConvertAdapter;import com.lonely.model.Clazz;import er;@WebServicepublic interface UserService {/*** 根据班级信息返回该班级的学⽣列表** @param clazz* @return*/List<User> findUsersByClass(Clazz clazz);/*** 查看所有班级信息以及班级下的所有学⽣** @return*/@XmlJavaTypeAdapter(value = MapConvertAdapter.class)Map<String, List<User>> findAll();}UserServiceImplpackage com.lonely.service.impl;import java.util.HashMap;import java.util.List;import java.util.Map;import javax.jws.WebService;import org.springframework.beans.factory.annotation.Autowired;import ponent;import erDao;import com.lonely.model.Clazz;import er;import erService;@Component("userService")@WebServicepublic class UserServiceImpl implements UserService {@Autowiredprivate UserDao userDao;@Overridepublic List<User> findUsersByClass(Clazz clazz) {return erDao.findUsersByClass(clazz);}@Overridepublic Map<String, List<User>> findAll() {List<Clazz> clazzList = erDao.findAll();if (clazzList != null && clazzList.size() != 0) {Map<String, List<User>> map = new HashMap<>();for (Clazz clazz : clazzList) {map.put(clazz.getClassName(), clazz.getUsers());}return map;}return null;}}2.3 spring整合mybatis2.3.1 在spring⽬录下,添加 spring与mybatis集成的配置: spring-datasource.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/tx /schema/tx/spring-tx-4.1.xsd"><!-- 配置数据源 --><bean id="dataSource" class="mons.dbcp.BasicDataSource"><property name="username" value="${jdbc.jdbcUsername}"></property><property name="password" value="${jdbc.jdbcPassword}"></property><property name="url" value="${jdbc.jdbcUrl}"></property><property name="driverClassName" value="${jdbc.driverClassName}"></property></bean><!-- 配置sqlsessionfactory --><bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean"><!-- 配置数据源 --><property name="dataSource" ref="dataSource"></property><!-- 配置mybatis配置 --><property name="configuration"><bean class="org.apache.ibatis.session.Configuration"><!-- 开启驼峰命名法 --><property name="mapUnderscoreToCamelCase" value="true"></property><!-- 当检测出未知列(或未知属性)时,如何处理,默认情况下没有任何提⽰,这在测试的时候很不⽅便,不容易找到错误。
【案例】Springboot开发WebService服务端和客户端

【案例】Springboot开发WebService服务端和客户端环境说明Java JDK 1.8、Spring boot 2.1.6、Apache CXF 3.1.6POM依赖<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><version>2.1.6</version></dependency><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-rt-frontend-jaxws</artifactId><version>3.1.6</version></dependency><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-rt-transports-http</artifactId><version>3.1.6</version></dependency></dependencies>服务端webService接⼝使⽤@WebService声明式注解声明这是⼀个webService接⼝,并设置:name:服务名称targetNamespace:命名空间,通常是接⼝的包名倒序注解@WebMethod是声明接⼝⽅法,可以通过operationName为接⼝⽅法设置别名,默认是⽅法名。
CXF使用教程(二)——webService自动生成客户端代码

CXF使⽤教程(⼆)——webService⾃动⽣成客户端代码webService⾃动⽣成客户端代码有四种⽅法:⼀:使⽤Axis⽣产客户端代码(另存为bat⽂件)需要注意的是:⽬录包含空格,⽐如Axis_Lib,Output_Pathset Axis_Lib=F:\axis1.4\axis\WEB-INF\libset Java_Cmd=java -Djava.ext.dirs=%Axis_Lib%set Output_Path=D:\Workspacesset Package=com.axis.sub%Java_Cmd% org.apache.axis.wsdl.WSDL2Java -o%Output_Path% -p%Package% http://192.168.11.62:8090/rainLogin?wsdl pause⼆:使⽤JDK1.6的wsimport.exe(在jdk的bin⽬录下)产⽣客户端代码(之前要将JDK的bin添加到环境变量Path中)wsimport -keep -p com.jdk6.sub -s JavaSrc http://192.168.11.62:8090/rainLogin?wsdl1. -s(src):在当前路径下的JavaSrc(要⼿动创建)⽂件夹中⽣成客户端代码2. -p(package):定义客户端代码的包名3. -keep 保留.class⽂件三:使⽤CXF wsdl2java.bat (要先将CXF的bin⽬录添加到环境变量Path下)在cmd本项⽬SCR⽬录下运⾏下⾯代码,就会在src下⽣成客户端代码wsdl2java http://192.168.11.62:8080/FFWebservice/services/PortalServices?wsdl四:使⽤Myeclipse⾃带⼯具⽣成客户端代码finnish 就可以⽣成客户端代码了。
个⼈⼀般⽐较喜欢⽤第⼆种⽅法。
webservice学习之使用Apache CXF和spring搭建webservice

webservice学习之使用Apache CXF和spring搭建webservice分类:java 2013-04-03 15:04 285人阅读评论(0) 收藏举报[html]view plaincopy1.1. websrvice概述:(1)webservice的出现可以解决不同平台、不同语言所编写的应用之间相互调用的问题。
(2)webservice不是框架,甚至不是一种技术,而是一种跨平台、跨语言的规范。
2.webservice解决三个问题:(1)远程调用(2)跨平台调用(3)跨语言调用3.实际用途(1)同一个公司新旧系统整合(2)不同公司的业务整合。
比如不同电商调用快递公司的订单查询系统(3)内容聚合。
比如一个应用需要提供天气预报、股票查询、黄金行情等等,需要内容聚合,调用到两不同平台、不同语言开发的应用方法。
4.CXF。
apache基金会的一个开源项目,可以说是SOA框架。
5.webservice的开发:(1)引入spring与cxf需要的jar包:(2)每个webservice组件需要两个部分:接口和实现类.所以建立一个webservice业务接口,使用@WebService注解。
[html]view plaincopy1.package demo.spring.service;2.3.import javax.jws.WebService;4.5.6.@WebService7.public interface HelloWorld {8. String sayHi(String text);9.}(3)定义一个webservice的实现类,实现第二步中定义的接口,也是使用@WebService修饰,但需要指定属性,一般是两个:endpointInterface:当前实现类实现的接口,serviceName:业务名称,可以自行定义[html]view plaincopy1.package demo.spring.service;2.3.import javax.jws.WebService;4.5.import ponent;6.7.@Component("hello")8.@WebService(endpointInterface = "demo.spring.service.HelloWorld")9.public class HelloWorldImpl implements HelloWorld {10.11. public String sayHi(String text) {12. System.out.println("sayHi called");13. return "Hello " + text;14. }15.}(4)配置spring与cxf的配置文件这里定义两个,一个用于server,一个用于client:cxf-servlet.xml:红色部分的配置一定要添加,用于server配置[html]view plaincopy1.<beans xmlns="/schema/beans"2. xmlns:xsi="http://www.w/2001/XMLSchema-instance" <span style="color:#ff0000;">xmlns:jaxws="/jaxws"</span>3. xmlns:context="/schema/context"4. xsi:schemaLocation="/schema/beans5. /schema/beans/spring-beans.xsd6. <span style="color:#ff0000;">/jaxws</span> <span style="color:#ff0000;">/schemas/jaxws.x sd</span>7. /schema/context8. /schema/context/spring-context.xsd">9.10.11. <import resource="classpath:META-INF/cxf/cxf.xml" />12. <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />13. <context:annotation-config />14. <context:component-scan base-package="demo.spring" />15.16. <jaxws:endpoint id="helloWorld" implementor="#hello"17. address="/HelloWorld" />18.19.</beans>id:webservice的endpoint的id。
cxf开发webservice

用cxf开发webserviceApache CXF是一个开源的Service框架,它实现了JCP与Web Service中一些重要标准。
CXF简化了构造,集成,面向服务架构(SOA)业务组件与技术的灵活复用。
在CXF中,Service使用WSDL标准定义并能够使用各种不同的消息格式(或binding)和网络协议(transports)包括SOAP、XML(通过HTTP 或JMS)进行访问。
CXF同样支持多种model 如:JAX-WS,JBI,SCA和CORBA service。
CXF设计成可灵活部署到各种容器中包括Spring-based,JBI,SCA,Servlet和J2EE容器。
1.准备工作cxf是apache的一个正式的开源项目,目前已经更新到2.6.2版本,从下面的地址可以下载最新的版本。
/这里我用2.6.1的版本就行讲解。
需要的jar包有:cxf-2.6.1.jarcxf-manifest.jarcxf-services-sts-core-2.6.1.jarcxf-services-wsn-api-2.6.1.jarcxf-services-wsn-core-2.6.1.jarcxf-xjc-boolean-2.6.0.jarcxf-xjc-bug671-2.6.0.jarcxf-xjc-dv-2.6.0.jarcxf-xjc-runtime-2.6.0.jarcxf-xjc-ts-2.6.0.jar2.服务端配置与开发2.1.web.xml配置在<context-param>里边要加上lasspath*:applicationContext-cxf.xml一项的值:<context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:applicationContext.xml,classpath*:applicationContext-cxf.xml,classpath*:applicationContext-beans.xml,classpath*:applicationContext-service.xml,classpath*:applicationContext-beans-*.xml,classpath*:applicationContext-service-*.xml</param-value></context-param>同时还要在下面加上如下的servlet配置:<servlet><servlet-name>CXFServlet</servlet-name><display-name>CXF Servlet</display-name><servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>CXFServlet</servlet-name><url-pattern>/service/*</url-pattern></servlet-mapping>2.2.applicationContext-cxf.xml文件配置在src目录下创建一个applicationContext-cxf.xml文件,里边的内容如下:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context-3.1.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" /><context:component-scan base-package="pare.webservice" /><bean id="webServicesAgent"class="org.apache.cxf.spring.remoting.Jsr181HandlerMapping"><property name="urlPrefix"><value>/</value></property></bean></beans>其中<context:component-scan base-package="com.webservice.cxf" />是配置存放webservice服务的java文件的包路径。
CXF3.0.2+Spring3.2.14 WebService入门实例四

这次学习CXF WebService传输文件。
CXF采用的是MTOM的机制进行文件传输。
MTOM(Message Transmission Optimization Mechanism)消息优化传输机制。
消息传输优化机制(MTOM) 标准允许将消息中包含的大型数据元素外部化,并将其作为无任何特殊编码的二进制数据随消息一起传送。
MTOM 消息会打包为多部分/相关MIME 序列,放在SOAP 消息中一起传送。
但是在大量数据情况下,如果数据依然进行Base64编码,会带来33%的额外开销,这样的情况对于大量数据交换的情况是无法容忍的。
MTOM 就是针对SOAP 消息传输的基础上提出的改进办法。
对于大量数据的传递,不会进行进行Base64编码,而是直接以附件的二进制原始数据的形式封装在SOAP消息的MIME 部分,进行传输。
………此处略去1000字,自己百度补齐………首先还是要介绍一下开发工具和开发环境,jdk1.6.0_43+Tomcat6.0.29+ MyEclipse10.5,没有使用Maven进行管理!继续学习达拉斯母牛的CXF实战之传输文件(六),博客地址:/accountwcx/article/details/47165321 一、新建web工程,选择Java EE5.0二、新建文件传输类CxfFileWrapper.javapackage com.util;import javax.activation.DataHandler;import javax.xml.bind.annotation.XmlMimeType;import javax.xml.bind.annotation.XmlType;/*** 类名: CxfFileWrapper.java* 作者: 张述飞* 创建时间: 2016-1-7下午2:35:44* 版本: V1.0* 功能描述: CXF上传和下载文件对象包装类由于CXF的DataHandler无法获取文件名和文件类型,需要在上传和下载时附带文件名*/@XmlType(name = "cxfFileWrapper")public class CxfFileWrapper {//文件名private String fileName;//文件扩展名private String fileExtension;//文件二进制数据private DataHandler file;public String getFileName() {return fileName;}public void setFileName(String fileName) {this.fileName = fileName;}public String getFileExtension() {return fileExtension;}public void setFileExtension(String fileExtension) {this.fileExtension = fileExtension;}//注解该字段为二进制流@XmlMimeType("application/octet-stream")public DataHandler getFile() {return file;}public void setFile(DataHandler file) {this.file = file;}}三、新建接口类FileInterface.javapackage com.util;import javax.jws.WebMethod;import javax.jws.WebParam;import javax.jws.WebService;import javax.xml.ws.soap.MTOM;/*** 类名: FileInterface.java* 作者: 张述飞* 创建时间: 2016-1-12上午8:24:05* 版本: V1.0* 功能描述:接口类* 说明:@MTOM注解非常重要,如果不写,那么下载文件时会报内存溢出的错误!2016-1-8 15:14:29 org.apache.catalina.core.StandardWrapperValve invoke 严重: Servlet.service() for servlet CXFService threw exceptionng.OutOfMemoryError: Java heap spaceatcom.sun.xml.bind.v2.util.ByteArrayOutputStreamEx.readFrom(ByteArrayOu tputStreamEx.java:75)……………………………*/@WebService(name="fileInterface")@MTOMpublic interface FileInterface {/*** 文件上传* @param file* @return*/@WebMethodpublic boolean upload(@WebParam(name = "file") CxfFileWrapper file);/*** 文件下载* @return* @throws Exception*/@WebMethodpublic CxfFileWrapper download();}四、新建接口实现类FileInterfaceImpl.javapackage com.util;import java.io.BufferedOutputStream;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import javax.activation.DataHandler;import javax.activation.DataSource;import javax.activation.FileDataSource;import javax.jws.WebService;@WebService(endpointInterface="com.util.FileInterface",portName="FileInterPort")public class FileInterfaceImpl implements FileInterface {public boolean upload(CxfFileWrapper file) {boolean result = true;OutputStream os = null;InputStream is = null;BufferedOutputStream bos = null;try {is = file.getFile().getInputStream();/*** 注必须先在D盘新建文件夹newFilejava.io.FileNotFoundException: d:\newFile\LoginDB.bak (系统找不到指定的路径。
CXF框架webservice教程

CXF框架实现webservice教程1 使用CXF实现一个简单的WEB SERVICE首先介绍如何用CXF实现一个基本的hello world首先到apache官网去下载CXF的开发jar包//cxf/2.4.3/apache-cxf-2.4.3.zip创建cxf webservice服务器端普通java项目,叫做HelloCxfServer,把必须用到的jar文件通过构建路径引入,为了省事,可以直接把所有的jar引入此处注意:如果是jdk1.6启动服务器会发生如下错误JAXB 2.1 API is being loaded from the bootstrap classloader, but this RI (from jar:file:/E:/javaLib/cxf_all_jar/jaxb-impl-2.2.1.1.jar!/com/sun/xml/bind/v2/model/impl/ModelBuilder.class) needs 2.2 API. Use the endorsed directory mechanism to place jaxb-api.jar in the bootstrap classloader.这是由于jdk1.6的jar包和cxf的jar包冲突造成的,需要把cxf lib中的endorsed目录拷入到D:\Program Files\Java\jdk1.6.0\jre\lib目录下创建一个接口HelloWorld和一个实现类HelloWorldImpl,只提供一个成员方法,叫做sayHello,给接口和实现类添加注解@WebService,这是最基本的注解/test/HellWorld.java源码package test;import javax.jws.WebService;@WebServicepublic interface HelloWorld {String sayHello(String name);}/test/HelloWorldImpl.java源码package test;import javax.jws.WebService;@WebServicepublic class HelloWorldImpl implements HelloWorld {@Overridepublic String sayHello(String name) {System.out.println("sayHello方法被调用...");return"hello," + name;}}CXF自带了一个Web Service容器Jetty,这是一个WEB容器,类似于tomcat,能够直接发布web service,下面创建一个发布服务类MainServer,执行这个类就会运行服务器,看到控制台输出日志信息,表示启动服务成功/test/MainServier.java源码package test;import org.apache.cxf.endpoint.Server;import org.apache.cxf.jaxws.JaxWsServerFactoryBean;public class MainServer {public static void main(String[] args) {//创建一个JaxWs服务器工厂JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean();//设置发布类factory.setServiceClass(HelloWorldImpl.class);//设置服务发布的地址factory.setAddress("http://localhost:6666/MyCxfService");//根据设置创建一个服务器Server server = factory.create();//启动服务器server.start();}}发布成功以后,可以通过浏览器去查看生成的WSDL,在浏览器地址栏输入http://localhost:6666/MyCxfService?wsdl,效果如下:下面创建访问WebService的客户端,可以重新创建一个项目,也可以就在这个项目里实现,我下面在同一个项目中创建一个类HelloWorldCient/test/HelloWorldClient.java源码package test;import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;import org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean;public class HelloWorldClient {public static void main(String[] args) {//创建一个JaxWs的代理工厂JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();//设置访问地址factory.setAddress("http://localhost:6666/MyCxfService");//设置接口类型factory.setServiceClass(HelloWorld.class);//获得代理类实例HelloWorld helloWorld = (HelloWorld) factory.create();//调用方法String str = helloWorld.sayHello("张三");System.out.println(str);}}运行客户端,会看到控制台,输出:hello,张三2 WSDL结构分析主要通过上一章生成的WSDL,来对WSDL语言的标签进行解释Web Services Description Language的缩写,是一个用来描述Web服务和说明如何与Web服务通信的XML 语言。
Java通过cxf发布和调用webservices接口

Java通过cxf发布webservices接口第一步:创建一个工程如:cxfserver1注:web工程和java工程都可以第二步:把apache-cxf-2.6.1资源包中lib文件夹下所有的jar包共计75个,都拷贝到cxfserver1的lib目录下,如果你的工程师java工程自己创建一个lib文件夹第三步:创建一个包inter,在inter下创建一个发布接口,接口名HelloWorld ,并进行webservices注解package inter;import javax.jws.WebMethod;import javax.jws.WebParam;import javax.jws.WebService;/*** 发布接口* @author Administrator**/@WebServicepublic interface HelloWorld {@WebMethodpublic String sayHello(@WebParam(name="name")String name);}第四步:创建一个包impl,在impl下创建一个接口实现类,对接口中的方法进行功能实现package impl;import inter.HelloWorld;/*** 接口功能实现类* @author Administrator**/public class HelloWorldImpl implements HelloWorld {public String sayHello(String name) {// TODO Auto-generated method stubSystem.out.println("进入接口中");return name.concat(",进入接口中");}}第五步:创建一个包release,在release下创建一个接口发布主线程入口,执行该方法进行接口发布package release;import impl.HelloWorldImpl;import inter.HelloWorld;import org.apache.cxf.interceptor.LoggingInInterceptor;import org.apache.cxf.interceptor.LoggingOutInterceptor;import org.apache.cxf.jaxws.JaxWsServerFactoryBean;/*** 发布接口的主线程入口类**/public class ReleasePortMain {public static void main(String[] args) {// TODO Auto-generated method stubHelloWorldImpl implementor = new HelloWorldImpl();//初始化功能实现类JaxWsServerFactoryBean svrFactory = new JaxWsServerFactoryBean();//初始或工厂类svrFactory.setServiceClass(HelloWorld.class);//设置发布接口对象svrFactory.setAddress("http://localhost:9000/helloWorld");//自己设置发布接口在JVM 中的访问地址svrFactory.setServiceBean(implementor);//设置接口功能实现类对象svrFactory.getInInterceptors().add(new LoggingInInterceptor());//设置异常抛出svrFactory.getOutInterceptors().add(new LoggingOutInterceptor());//设置异常抛出svrFactory.create();//执行接口发布}}注:如果执行发布接口,抛出如下异常信息: Creating Service {http://inter/}HelloWorldService from class inter.HelloWorldException in thread "main" ng.LinkageError: 正在从引导类加载器加载JAXB 2.1 API, 但此 RI (来自jar:file:/D:/worke/codehy/cxfserver1/lib/jaxb-impl-2.2.5.jar!/com/sun /xml/bind/v2/model/impl/ModelBuilder.class) 需要 2.2 API。
springBoot整合CXF并实现用户名密码校验的方法

springBoot整合CXF并实现⽤户名密码校验的⽅法准备⼯作:创建springBoot项⽬webservice_server创建springBoot项⽬webservice_client分别添加CXF的依赖:<!-- CXF webservice --><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-spring-boot-starter-jaxws</artifactId><version>3.1.11</version></dependency><!-- CXF webservice -->⼀.定义要发布的接⼝和实现类接⼝:@WebServicepublic interface AppService {@WebMethodString getUserName(@WebParam(name = "id") String id) throws UnsupportedEncodingException;@WebMethodpublic User getUser(String id) throws UnsupportedEncodingException;}实现类://name暴露的服务名称, targetNamespace:命名空间,设置为接⼝的包名倒写(默认是本类包名倒写). endpointInterface接⼝地址@WebService(name = "test" ,targetNamespace ="/" ,endpointInterface = "cn.wolfcode.cxf.AppService")public class AppServiceImpl implements AppService {JSONResult jsonResult = JSONResult.getJsonResult();@Overridepublic String getUserName(String id) throws UnsupportedEncodingException {System.out.println("==========================="+id);JSONResult result= JSONResult.getJsonResult();result.setSuccess(true);result.setMessage("明哥");return result.toJsonObject();}@Overridepublic User getUser(String id)throws UnsupportedEncodingException {System.out.println("==========================="+id);return new User(1L,"明哥");}}⼆.发布服务1.定义配置类@Configurationpublic class CxfConfig {//默认servlet路径/*,如果覆写则按照⾃⼰定义的来@Beanpublic ServletRegistrationBean dispatcherServlet() {return new ServletRegistrationBean(new CXFServlet(), "/services/*");}@Bean(name = Bus.DEFAULT_BUS_ID)public SpringBus springBus() {return new SpringBus();}//把实现类交给spring管理@Beanpublic AppService appService() {return new AppServiceImpl();}//终端路径@Beanpublic Endpoint endpoint() {EndpointImpl endpoint = new EndpointImpl(springBus(), appService());endpoint.getInInterceptors().add(new AuthInterceptor());//添加校验拦截器endpoint.publish("/user");return endpoint;}}2.发布服务@SpringBootApplicationpublic class WebserviceApplication {public static void main(String[] args) {SpringApplication.run(WebserviceApplication.class, args);}}因为我添加了⽤户名和密码校验所以在发布之前还需要定义⾃⼰校验⽤户名和密码的Interceptor public class AuthInterceptor extends AbstractPhaseInterceptor<SoapMessage> {Logger logger = LoggerFactory.getLogger(this.getClass());private static final String USERNAME="root";private static final String PASSWORD="admin";public AuthInterceptor() {//定义在哪个阶段进⾏拦截super(Phase.PRE_PROTOCOL);}@Overridepublic void handleMessage(SoapMessage soapMessage) throws Fault {List<Header> headers = null;String username=null;String password=null;try {headers = soapMessage.getHeaders();} catch (Exception e) {logger.error("getSOAPHeader error: {}",e.getMessage(),e);}if (headers == null) {throw new Fault(new IllegalArgumentException("找不到Header,⽆法验证⽤户信息"));}//获取⽤户名,密码for (Header header : headers) {SoapHeader soapHeader = (SoapHeader) header;Element e = (Element) soapHeader.getObject();NodeList usernameNode = e.getElementsByTagName("username");NodeList pwdNode = e.getElementsByTagName("password");username=usernameNode.item(0).getTextContent();password=pwdNode.item(0).getTextContent();if( StringUtils.isEmpty(username)||StringUtils.isEmpty(password)){throw new Fault(new IllegalArgumentException("⽤户信息为空"));}}//校验⽤户名密码if(!(username.equals(USERNAME) && password.equals(PASSWORD))){SOAPException soapExc = new SOAPException("认证失败");logger.debug("⽤户认证信息错误");throw new Fault(soapExc);}}}现在可以发布服务了.....能够出现以下界⾯就是发布OK三.调⽤服务1.新建调⽤端项⽬,添加依赖2.因为⽰例演⽰了两种调⽤⽅式,其中⼀种需要⽤到接⼝,所以先把服务接⼝拷贝⼀份到调⽤端项⽬中(代码就是上⾯接⼝的代码)3.因为服务端添加了⽤户名密码校验,所以调⽤的时候需要添加⽤户名密码信息, 所以需要使⽤下⾯的Interceptor完成添加⽤户名密码信息/*** Created by sky on 2018/2/27.*/public class LoginInterceptor extends AbstractPhaseInterceptor<SoapMessage> {private String username="root";private String password="admin";public LoginInterceptor(String username, String password) {//设置在发送请求前阶段进⾏拦截super(Phase.PREPARE_SEND);ername=username;this.password=password;}@Overridepublic void handleMessage(SoapMessage soapMessage) throws Fault {List<Header> headers = soapMessage.getHeaders();Document doc = DOMUtils.createDocument();Element auth = doc.createElementNS("/","SecurityHeader");Element UserName = doc.createElement("username");Element UserPass = doc.createElement("password");UserName.setTextContent(username);UserPass.setTextContent(password);auth.appendChild(UserName);auth.appendChild(UserPass);headers.add(0, new Header(new QName("SecurityHeader"),auth));}}4.调⽤接⼝/*** Created by sky on 2018/2/27.*/public class Cxfclient {//webservice接⼝地址private static String address = "http://localhost:8888/services/user?wsdl";//测试public static void main(String[] args) {test1();test2();}/*** ⽅式1:使⽤代理类⼯⼚,需要拿到对⽅的接⼝*/public static void test1() {try {// 代理⼯⼚JaxWsProxyFactoryBean jaxWsProxyFactoryBean = new JaxWsProxyFactoryBean();// 设置代理地址jaxWsProxyFactoryBean.setAddress(address);//添加⽤户名密码拦截器jaxWsProxyFactoryBean.getOutInterceptors().add(new LoginInterceptor("root","admin"));;// 设置接⼝类型jaxWsProxyFactoryBean.setServiceClass(AppService.class);// 创建⼀个代理接⼝实现AppService cs = (AppService) jaxWsProxyFactoryBean.create();// 数据准备String LineId = "1";// 调⽤代理接⼝的⽅法调⽤并返回结果User result = (User)cs.getUser(LineId);System.out.println("==============返回结果:" + result);} catch (Exception e) {e.printStackTrace();}}/*** 动态调⽤⽅式*/public static void test2() {// 创建动态客户端JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();Client client = dcf.createClient(address);// 需要密码的情况需要加上⽤户名和密码client.getOutInterceptors().add(new LoginInterceptor("root","admin"));Object[] objects = new Object[0];try {// invoke("⽅法名",参数1,参数2,参数3....);System.out.println("======client"+client);objects = client.invoke("getUserName", "1");System.out.println("返回数据:" + objects[0]);} catch (Exception e) {e.printStackTrace();}}}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
基于Spring+CXF实现用户文件上传的WebService

1 引 言
A a h X 是 一 个 开 源 的 S rie p ceC F ev s框 架 。C F 帮 助 您 利 c X
{
r t r i n me; e u nfe a l
) p bi v d s t i n me S r g fe a ) u l oi e Fl a ( ti i n me c e n l {
名 称 , 使 用 @We P r 注 释 来 声 明 传 人 变 量 名 称 ,代 码 片 b aa m
段 如下 :
p bi r gg t i n me ) u l Sti e Fl a ( c n e
、
1) 鑫与 6 -
;
…
…
P O R M N U G … … … … … ~ RGA L GAE A … … …… … … … . … …… … … ~ … … … … … … … …
{
rt r i t p e u nfe y e; l
行无缝集成 。
}
2 功 能分 析
( ) 该 We Srie需 要 提 供 报 文 上 传 到 服 务 器 上 的 基 本 1 be e v
功能 。
p bl od s t i t p (tig fey e u i v i e Fl y eS r i tp ) c e n l {
…
g l
II  ̄
…
…
l
,
‘
k
1
x
H
々 ‘
H
…
十
…
t
—
‘} 实用第一 来自智慧密集 。 6 1 I … _ f { … H ,I I x 日
JavaCXF框架调用WebService接口

JavaCXF框架调⽤WebService接⼝WebService接⼝调⽤(CXF框架)maven中添加cxf依赖:<dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-rt-frontend-jaxws</artifactId><version>3.4.4</version></dependency><dependency><groupId>org.apache.cxf</groupId><artifactId>cxf-rt-transports-http</artifactId><version>3.4.4</version></dependency>版本请与依赖保持⼀直。
IDEA设置:File -> Setting -> Tools -> Web Service设置CXF为⽣成⼯具根路径,如:C:\DevKit\apache-cxf-3.4.4IDEA Project窗⼝选中要⽣成的包,⼯具栏点击Tools -> WebService -> Generate Java Code From Wsdl 填⼊WSDL地址、输出路径,Service Platform选择CXF,确定⽣成。
PS:IDEA 2019版本存在bug,没有Generate Java Code From Wsdl菜单,详见或更换IDEA版本。
追加Header认证⾸先添加⾃定义Header处理类:static class ClientAuthInterceptor extends AbstractPhaseInterceptor<SoapMessage> {/*** 认证头格式:* <tns:RequestSOAPHeader xmlns:tns="http://sys.webservice.client">* <tns:user>user</tns:user>* <tns:password>password</tns:password>* </tns:RequestSOAPHeader>*/private static final String USER = "user";private static final String PASSWORD = "password";public ClientAuthInterceptor() {super(Phase.PREPARE_SEND);}@Overridepublic void handleMessage(SoapMessage message) throws Fault {List<Header> headers = message.getHeaders();Document doc = DOMUtils.createDocument();Element header = doc.createElement("tns:RequestSOAPHeader");header.setAttribute("xmlns:tns", "http://sys.webservice.client");Element user = doc.createElement("tns:user");user.setTextContent(USER);Element password = doc.createElement("tns:password");password.setTextContent(PASSWORD);header.appendChild(user);header.appendChild(password);headers.add(new Header(new QName(""), header));}}导包详情添加⾃定义Header处理器:// 这两⾏是⼯具⽣成出来的接⼝ISysNotifyTodoWebServiceService ss = new ISysNotifyTodoWebServiceService(wsdlURL, SERVICE_NAME);ISysNotifyTodoWebService port = ss.getISysNotifyTodoWebServicePort(); // 创建接⼝时添加⾃定义Header处理器Client client = ClientProxy.getClient(port);client.getOutInterceptors().add(new ClientAuthInterceptor());。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、项目开发环境
1.jdk 1.8
2.springboot 2.0.3
3.cxf 3.2.6
注意:springboot 版本过高可能会和cxf冲突导致项目启动报错
二、搭建
1.创建项目后添加以下依赖
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.3.RELEASE</version>
<relativePath />
</parent>
<properties>
<!-- 解决高版本springboot pom.xml报Unknown -->
<maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- 服务-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- 集成CXF -->
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-spring-boot-starter-jaxws</artifactId>
<version>3.2.6</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<!-- 指定jdk版本-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
2.创建一个接口类
@WebService(targetNamespace = "http://xxx.xxx.xxx/")// 命名空间,一般是接口的包名倒序
public interface TestService {
@WebMethod
public String test(@WebParam(name = "userName") String name);
}
之后创建接口的实现类
public class TestServiceImpl implements TestService {
@Override
public String test(String name) {
// TODO Auto-generated method stub
return "hellow";
}
}
3.创建cxfconfig配置类
package com.gsww.chis.config;
import javax.xml.ws.Endpoint;
import org.apache.cxf.jaxws.EndpointImpl;
import org.apache.cxf.Bus;
import org.apache.cxf.bus.spring.SpringBus;
import org.apache.cxf.transport.servlet.CXFServlet;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.gsww.chis.webservice.TestService;
import com.gsww.chis.webservice.impl.TestServiceImpl;
@Configuration
public class CxfConfig {
@Bean(name = Bus.DEFAULT_BUS_ID)
public SpringBus springBus() {
return new SpringBus();
}
/**
* 此方法被注释后:wsdl访问地址为http://127.0.0.1:8080/services/user?wsdl * 去掉注释后:wsdl访问地址为:http://127.0.0.1:8080/soap/user?wsdl */
@SuppressWarnings({ "rawtypes", "unchecked" })
@Bean
public ServletRegistrationBean dispatcherServlet() {
return new ServletRegistrationBean(new CXFServlet(), "/soap/*");
}
@Bean
public TestService testService() {
return new TestServiceImpl();
}
/**
* 发布服务指定访问url
*
* @return
*/
@Bean
public Endpoint userEndpoint() {
EndpointImpl endpoint = new EndpointImpl(springBus(), testService());
endpoint.publish("/call");
System.out.println("发布成功");
return endpoint;
}
}
3.访问路径
ip:端口/(项目配置的context-path)/soap/call?wsdl。