cxf跟spring怎么整合

Cxf是一个用于构建Web服务的开源框架，而Spring是一个用于构建企业级应用程序的开源框架。为了将Cxf与Spring整合，可以按照以下步骤进行操作：

1. 添加Cxf和Spring的相关依赖：首先，在项目的构建文件中添加Cxf和Spring的相关依赖。可以使用Maven或者Gradle来管理依赖。

2. 配置CxfServlet：在web.xml文件中，配置CxfServlet。CxfServlet是一个运行在Servlet容器中的Cxf的核心组件。配置方式如下：

   <servlet>
       <servlet-name>CxfServlet</servlet-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>/services/*</url-pattern>
   </servlet-mapping>
   

   这样配置后，所有使用Cxf发布的Web服务都将映射到"/services"路径下。

3. 配置Spring和Cxf的整合：在Spring的配置文件中，配置Cxf相关的bean和配置项。可以使用XML配置或者Java配置来完成配置。以下是一个示例的Spring配置文件：

   <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                              http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd
                              http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
   
       <import resource="classpath:META-INF/cxf/cxf.xml"/>
       <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>
   
       <bean id="helloService" class="com.example.HelloService"/>
   
       <jaxws:endpoint id="helloServiceEndpoint" implementor="#helloService" address="/hello"/>
   
   </beans>
   

   在这个示例中，"helloService"是一个Spring bean，用来实现具体的Web服务。通过配置"jaxws:endpoint"，将"helloService"发布为Web服务，并指定服务的地址为"/hello"。

4. 编写具体的Web服务：根据业务需求，编写具体的Web服务实现类。在这个类中，可以使用Spring的依赖注入特性，来注入其他Spring管理的对象。

5. 启动应用程序并测试：将整合好的项目部署到Servlet容器中，启动应用程序。访问"http://localhost:8080/services/hello"，可以看到Cxf发布的Web服务的WSDL描述文档。

通过以上步骤，就可以将Cxf与Spring进行整合，实现一个完整的基于Cxf和Spring的Web服务应用程序。

要实现CXF和Spring的整合，可以按照以下步骤进行操作：

1. 导入所需的依赖：
   在项目的pom.xml文件中，添加CXF和Spring的相关依赖。例如：

   <dependency>
       <groupId>org.apache.cxf</groupId>
       <artifactId>cxf-core</artifactId>
       <version>3.4.6</version>
   </dependency>
   <dependency>
       <groupId>org.apache.cxf</groupId>
       <artifactId>cxf-rt-frontend-jaxws</artifactId>
       <version>3.4.6</version>
   </dependency>
   <dependency>
       <groupId>org.apache.cxf</groupId>
       <artifactId>cxf-rt-transports-http</artifactId>
       <version>3.4.6</version>
   </dependency>
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-web</artifactId>
       <version>5.3.12</version>
   </dependency>
   

2. 创建Spring配置文件：
   在项目的资源目录下创建一个Spring配置文件（例如applicationContext.xml），并在文件中进行配置。配置示例：

   <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
   
       <!-- CXF JAX-WS Endpoint -->
       <jaxws:endpoint id="helloWorldService"
           implementor="#helloWorldServiceImpl"
           address="/helloWorldService">
       </jaxws:endpoint>
   
       <!-- Spring Bean -->
       <bean id="helloWorldServiceImpl" class="com.example.HelloWorldServiceImpl">
       </bean>
   
   </beans>
   

3. 配置CXF Servlet：
   在web.xml文件中配置CXF的Servlet。示例配置：

   <servlet>
       <servlet-name>CXFServlet</servlet-name>
       <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>/WEB-INF/applicationContext.xml</param-value>
       </init-param>
       <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
       <servlet-name>CXFServlet</servlet-name>
       <url-pattern>/services/*</url-pattern>
   </servlet-mapping>
   

4. 配置Spring上下文监听器：
   在web.xml文件中配置Spring的上下文监听器，以确保Spring的容器在应用程序启动时正确初始化。示例配置：

   <listener>
       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
   </listener>
   

5. 实现服务类：
   创建一个Java类，实现要暴露的服务接口。例如：

   @WebService
   public interface HelloWorldService {
       @WebMethod
       String sayHello(String name);
   }
   

   然后创建该接口的实现类：

   public class HelloWorldServiceImpl implements HelloWorldService {
       public String sayHello(String name) {
           return "Hello, " + name + "!";
       }
   }
   

完成以上步骤后，CXF和Spring就成功整合在一起了。现在可以使用CXF的Servlet来发布和访问你的WebService。

CXF是一个基于Java的开发框架，用于构建Web服务和客户端。而Spring则是一个开源的应用程序框架，主要用于构建企业级Java应用程序。CXF和Spring可以相互整合，以实现更加灵活和高效的开发过程。下面将介绍如何整合CXF和Spring。

整合CXF和Spring主要包括以下几个步骤：

1. 添加CXF和Spring的依赖

首先，需要将CXF和Spring的相关依赖添加到项目的构建文件（如Maven或Gradle）中。例如，使用Maven的话，可以在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
    <version>3.4.5</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.5.5</version>
</dependency>

2. 配置CXF的服务端和客户端

接下来，需要在Spring配置文件（如application.yml或application.properties）中配置CXF的服务端和客户端。例如，可以使用以下配置来配置CXF的服务端：

cxf:
  jaxws:
    serviceClass: com.example.MyWebServiceInterface
    serviceBean: com.example.MyWebServiceImpl
    address: /mywebservice

在这个配置中，serviceClass是Web服务的接口类名，serviceBean是Web服务的实现类名，address是Web服务的访问地址。

3. 注册CXF的Spring扩展

为了让CXF能够和Spring无缝整合，需要在Spring配置文件中注册CXF的Spring扩展。通常可以使用BeanPostProcessor接口来实现这个功能。例如，可以创建一个名为CxfBeanPostProcessor的类，并实现BeanPostProcessor接口：

import org.apache.cxf.bus.spring.SpringBus;
import org.apache.cxf.jaxws.EndpointImpl;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import javax.xml.ws.Endpoint;

@Component
public class CxfBeanPostProcessor implements BeanPostProcessor, ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Autowired
    private SpringBus cxf;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MyWebServiceInterface) {
            Endpoint endpoint = new EndpointImpl(cxf, (MyWebServiceInterface) bean);
            endpoint.publish("/mywebservice");
        }
        return bean;
    }
}

在这个类中，CxfBeanPostProcessor继承了BeanPostProcessor接口和ApplicationContextAware接口，用于获取Spring的上下文。在postProcessAfterInitialization方法中，可以根据需要发布WebService服务。

4. 编写Web服务接口和实现类

在CXF和Spring整合后，可以编写Web服务接口和实现类。接口类用于定义Web服务的方法，而实现类用于实现Web服务的具体逻辑。例如：

import javax.jws.WebService;

@WebService
public interface MyWebServiceInterface {
    String sayHello(String name);
}

import javax.jws.WebService;

@WebService(endpointInterface = "com.example.MyWebServiceInterface")
public class MyWebServiceImpl implements MyWebServiceInterface {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

在以上代码中，MyWebServiceInterface是Web服务的接口类，MyWebServiceImpl是Web服务的实现类。@WebService注解用于表示这是一个Web服务。

5. 编写测试代码

最后，可以编写测试代码，验证整合结果。例如，可以创建一个名为WebServiceClient的类，用于调用Web服务：

import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;

public class WebServiceClient {
    public static void main(String[] args) {
        JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
        factory.setServiceClass(MyWebServiceInterface.class);
        factory.setAddress("http://localhost:8080/mywebservice");
        MyWebServiceInterface client = (MyWebServiceInterface) factory.create();

        String result = client.sayHello("World");
        System.out.println(result);
    }
}

在这个类中，使用JaxWsProxyFactoryBean创建一个动态代理对象，通过代理对象调用Web服务的方法。

以上就是CXF和Spring整合的基本步骤和操作流程。通过整合CXF和Spring，可以实现更加灵活和高效的Web服务开发。