==========开始调用jax-ws接口===========
三月 30, 2020 12:22:07 下午 org.apache.cxf.services.UserServiceService.UserServicePort.UserService
信息: Outbound Message
---------------------------
ID: 1
Address: http://localhost:8086/spring-webservice/ws/userService
Encoding: UTF-8
Http-Method: POST
Content-Type: text/xml
Headers: {Accept=[*/*], SOAPAction=[""]}
Payload: <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><ns2:sayHello xmlns:ns2="http://service.ws.cxf.com/"/></soap:Body></soap:Envelope>
--------------------------------------
三月 30, 2020 12:22:07 下午 org.apache.cxf.services.UserServiceService.UserServicePort.UserService
信息: Inbound Message
----------------------------
ID: 1
Response-Code: 200
Encoding: UTF-8
Content-Type: text/xml; charset=UTF-8
Headers: {content-type=[text/xml; charset=UTF-8], Date=[Mon, 30 Mar 2020 04:22:07 GMT], Server=[Jetty(9.2.11.v20150529)], transfer-encoding=[chunked]}
Payload: <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><ns2:sayHelloResponse xmlns:ns2="http://service.ws.cxf.com/"><return>=============hello jax-ws!!!=================</return></ns2:sayHelloResponse></soap:Body></soap:Envelope>
--------------------------------------
=============hello jax-ws!!!=================
至此WebService基于CXF框架实现JAX-WS服务成功，是不是非常简单了，在不同公司/应用之间调取服务，使用WebService技术是非常常用的。
                    什么是服务中间件WebService中间件是一种独立的系统软件或服务程序，分布式应用软件借助这种软件在不同的技术之间共享资源。中间件位于客户机/ 服务器的操作系统之上，管理计算机资源和网络通讯。是连接两个独立应用程序或独立系统的软件。WebService作用是什么基于Web的服务：服务器端提供一些资源让客户端应用访问一个跨语言、跨平台的规范多个跨平台、跨语言的应用间通信整合的方案W...
#CXF框架
Apache
CXF=Celtix+Xfire.是一个开源的一个webservice，可以与spring无缝集成。支持soap1.1、1.2、RESTtful或者CORBA。
##使用CXF实现jax-ws规范的webservice
1、创建java工程，把cxf的jar包导入工程中
2、编写SEI，在SEI上添加@WebService注解
3、编写SEI实现类，需要实现SEI接口
4、发布服务
4.1、创建一个JaxWsServerFactoryBean对象
4.2、设置服务的发布地址，是一个httpurl
4.3、设置SEI接口
4.4、设置SEI实现类对象
4.5、调用create方法发布服务。
public
class
WeatherService
	public
static
main(String[]
args)
		//创建一个JaxWsServerFactoryBean对象
		JaxWsServerFactoryBean
前文提到了WebService是一种跨语言和操作系统的远程调用技术，WebService如此强大，市面上关于它的技术也是层出不穷，下面便是WebService的JAVA原生实现–JAX-WS：
JAX-WS(Java API for XML Web Services)规范是一组XML web services的JAVA
API，JAX-WS允许开发者可以选择RPC-oriented或者me...
1.3、spring配置——applicationContent.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"
				
基于jax-ws 实现的web service client和server端的demo程序。
注:如果使用的是 myeclipse 时 server 部署到tomcat 启动的时候会报错 解决办法:找到myeclipse安装目录下的 plugins 目录里 查找 webservices-rt.jar，然后将webservices-rt.jar
外层的 lib目录里删除，或者备份的其他地方，就ok了。
				
第二种发布方式: 发布一个带接口的webservice  
 使用cxf 框架提供的类 jaxWsServerFactoryBean 发布webService  
 jaxWsServerFactoryBean 是 ServerFactoryBean 的子类...    
 接口类需要...
二、CXF是什么？
　　CXF是目前最主流Web Service 开源的开发框架，由Apache提供。支持JAX-WS 和 JAX-RS。
三、CXF-JAX-WS入门案例
				
<h3>回答1：</h3><br/>Spring Boot集成CXF框架可以方便地调用Web服务。以下是使用Spring Boot和CXF调用Web服务的步骤：
1. 在pom.xml文件中添加CXF依赖：
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
    <version>3.3.6</version>
</dependency>
2. 创建一个接口来定义Web服务的操作：
@WebService
public interface MyWebService {
    @WebMethod
    String sayHello(String name);
3. 创建一个实现类来实现接口中定义的操作：
@Service
@WebService(endpointInterface = "com.example.MyWebService")
public class MyWebServiceImpl implements MyWebService {
    @Override
    public String sayHello(String name) {
        return "Hello " + name + "!";
4. 在应用程序的配置文件中添加CXF配置：
cxf:
  servlet:
    path: /services/*
  jaxws:
    properties:
      javax.xml.ws.soap.http.soapaction.use: "false"
5. 在控制器中注入Web服务并调用它：
@RestController
public class MyController {
    @Autowired
    private MyWebService myWebService;
    @GetMapping("/hello/{name}")
    public String sayHello(@PathVariable String name) {
        return myWebService.sayHello(name);
6. 启动应用程序并访问Web服务：
http://localhost:8080/services/MyWebServiceImpl?wsdl
以上就是使用Spring Boot和CXF调用Web服务的步骤。   
<h3>回答2：</h3><br/>Spring Boot是一个使用习惯优秀的Web应用开发框架，它可以帮助我们快速构建应用，提高开发效率。而CXF是一个开源的WebService框架，它提供了一系列的API和工具来帮助开发人员可以很轻易地实现一个基于SOAP的Web服务。
在Spring Boot中调用CXF框架中的WebService，需要进行以下步骤：
1. 添加依赖
在pom.xml中添加CXF和Spring Boot Web依赖：
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.cxf</groupId>
        <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
        <version>3.3.1</version>
    </dependency>
</dependencies>
2. 编写WebService客户端类
编写一个类来调用CXF产生的webservice服务，其中包括Endpoint指向和需要调用的方法等信息。
@Service
public class WebServiceClient {
    @Autowired
    private JaxWsProxyFactoryBean jaxWsProxyFactoryBean;
    private HelloPortType helloPortType;
    public String sayHello(final String name) {
        initPortType();
        return helloPortType.sayHello(name);
    private void initPortType() {
        if (helloPortType == null) {
            jaxWsProxyFactoryBean.setServiceClass(HelloPortType.class);
            jaxWsProxyFactoryBean.setAddress("http://localhost:8080/hello");
            helloPortType = (HelloPortType) jaxWsProxyFactoryBean.create();
3. 编写WebService
通过CXF创建web服务，并实现接口提供服务，返回接口需要的数据。
@javax.jws.WebService(serviceName = "HelloService", portName = "HelloPort", targetNamespace = "http://www.example.org/HelloService/", endpointInterface = "org.example.service.HelloPortType")
public class HelloPortTypeImpl implements HelloPortType {
    private final static Logger LOGGER = LoggerFactory.getLogger(HelloPortTypeImpl.class);
    @Resource
    private WebServiceContext webServiceContext;
    @Override
    public String sayHello(final String name) {
        final MessageContext mc = webServiceContext.getMessageContext();
        final HttpServletRequest req = (HttpServletRequest) mc.get(MessageContext.SERVLET_REQUEST);
        LOGGER.info("服务SayHello calling, name: {}, IP addr:{}, sessionId: {}", name, req.getRemoteAddr(), req.getSession().getId());
        return String.format("Hello, %s!", name);
4. 进行测试
在控制器中注入WebService客户端类，并进行测试。
@RestController
@RequestMapping("/test")
public class TestController {
    @Autowired
    private WebServiceClient webServiceClient;
    @GetMapping("/sayHello")
    public String sayHello(@RequestParam(value = "name") final String name) {
        return webServiceClient.sayHello(name);
总的来说，Spring Boot和CXF框架结合起来使用，可以很方便地调用WebService，提供服务的代码也可以很容易地进行编写。   
<h3>回答3：</h3><br/>SpringBoot是一个非常受欢迎的Java框架，其有很多优秀的特性让使用者更方便地进行应用的开发。其中，SpringBoot与CXF框架结合使用来调用Webservice可以非常简单地完成。本文将介绍SpringBoot与CXF框架结合使用来调用Webservice。
首先，我们需要在pom.xml文件中加入CXF及相关依赖。
```xml
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-frontend-jaxws</artifactId>
    <version>3.2.14</version>
</dependency>
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-transport-http</artifactId>
    <version>3.2.14</version>
</dependency>
然后，我们需要在配置文件中设置一些参数，具体如下：
```yaml
cxf:
  client:
    simple.frontend: true
    logging.enabled: true
    timeout:
      connect: 2000
      receive: 5000
  path: /ws
  servlet:
    url-pattern: /soap/*
在上述配置中，我们开启了日志记录，设置了连接超时和读取超时时间，以及指明了Webservice的路径。
接下来就可以创建一个接口来调用我们的Webservice。例如，我们想要调用一个返回学生列表的Webservice：
```java
@WebService
public interface StudentWebService {
    @WebMethod
    List<Student> getStudents();
我们使用CXF的JAX-WS Frontend创建了一个接口，同时使用@WebService注解来标记该接口。然后我们就可以创建一个实现类来实现该接口：
```java
@Service
public class StudentWebServiceImpl implements StudentWebService {
    @Override
    public List<Student> getStudents() {
        // 调用Webservice，返回学生列表
        return new ArrayList<>();
在上述实现类中，我们使用@Service注解来标记该类为SpringBoot的一个服务，同时实现了我们在接口中声明的getStudents()方法，去调用Webservice并返回学生列表。在该方法中，我们可以使用Spring提供的RestTemplate或者使用CXF的Client接口来进行调用。
然后我们同样使用CXF开放一个服务端口，供客户端调用：
```java
@Configuration
public class CxfConfig {
    @Bean(name = Bus.DEFAULT_BUS_ID)
    public SpringBus springBus() {       
        return new SpringBus();
    @Bean
    public ServletRegistrationBean<CXFServlet> cxfServlet() {
        return new ServletRegistrationBean<CXFServlet>(new CXFServlet(), "/soap/*");
    @Bean
    public StudentWebService studentWebService() {
        return new StudentWebServiceImpl();
    @Bean
    public Endpoint endpoint() {
        EndpointImpl endpoint = new EndpointImpl(springBus(), studentWebService());
        endpoint.publish("/StudentWebService");
        return endpoint;
在上述代码中，我们创建了一个CXFServlet，并将其映射到/soap/*路径下，同时创建了一个WebService的实现类，在SpringBoot启动时通过Endpoint暴露出来。这样我们就可以在客户端中通过CXF框架来访问Webservice了。
总结一下，SpringBoot与CXF框架结合使用调用Webservice可以非常方便地完成。我们只需要提供一个接口，实现其方法并使用CXF暴露出去，就可以在客户端通过CXF框架来访问了。同时，我们还可以使用CXF的一些特性来定制化我们的调用过程，包括定制连接超时、读取超时、日志记录等。