cxf和spring怎么集成

不及物动词 1年前其他 61

共3条回复我来回复

worktile

Worktile官方账号

CXF和Spring集成是一种常用的技术组合，可以将CXF的Web服务框架与Spring的依赖注入和面向切面编程结合起来，实现更灵活和易于管理的应用程序开发。下面将介绍如何将CXF和Spring进行集成。

添加CXF和Spring依赖
首先，需要在项目的构建文件中添加CXF和Spring的依赖。对于Maven项目，可以在pom.xml文件中添加以下依赖：

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

创建CXF配置文件
在Spring项目的src/main/resources目录下创建一个名为cxf.xml的配置文件。在该文件中，应定义CXF服务端和客户端的相关配置，包括绑定地址、接口实现类等。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xmlns:context="http://www.springframework.org/schema/context"
    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
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <!-- CXF服务端配置 -->
    <jaxws:endpoint id="helloService"
        implementor="com.example.HelloServiceImpl"
        address="/hello">
    </jaxws:endpoint>
    
    <!-- CXF客户端配置 -->
    <jaxws:client id="helloClient"
        address="http://localhost:8080/hello"
        serviceName="helloService"
        serviceClass="com.example.HelloService">
    </jaxws:client>
    
    <!-- 扫描Spring组件 -->
    <context:component-scan base-package="com.example" />
</beans>

在上述配置文件中，helloService为服务端的配置，实现类为com.example.HelloServiceImpl，地址为/hello；helloClient为客户端的配置，地址为http://localhost:8080/hello，服务名和服务类分别为helloService和com.example.HelloService。同时，使用 context:component-scan标签扫描com.example包下的Spring组件。

创建Spring配置文件
在Spring项目的src/main/resources目录下创建一个名为applicationContext.xml的配置文件，用于加载CXF配置文件和其他Spring相关配置。

<?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:context="http://www.springframework.org/schema/context"
    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配置文件 -->
    <import resource="classpath:cxf.xml" />
    
    <!-- 其他Spring相关配置 -->
    <!-- ... -->
    
</beans>

在上述配置文件中，使用标签加载之前创建的cxf.xml配置文件，并可以在文件中加载其他的Spring相关配置。

配置Spring Boot启动类
如果项目是基于Spring Boot的，需要在启动类上添加一些注解来配置CXF和Spring集成。示例如下：

@SpringBootApplication
public class Application extends SpringBootServletInitializer {
    
    @Bean
    public ServletRegistrationBean<CXFServlet> cxfServlet() {
        return new ServletRegistrationBean<>(new CXFServlet(), "/services/*");
    }
    
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Application.class);
    }
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在上述启动类中，使用@Bean注解创建一个ServletRegistrationBean，将CXF的Servlet注册到"/services/*"路径下。通过覆盖configure方法，将Application类添加到SpringApplicationBuilder中。

开发CXF服务接口和实现类
根据需要开发CXF的服务接口和实现类。例如，定义一个HelloService接口和HelloServiceImpl实现类。

@WebService
public interface HelloService {

    @WebMethod
    String sayHello(String name);

}

@Service
public class HelloServiceImpl implements HelloService {

    @Override
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }

}

在上述代码中，使用@WebService注解标记HelloService接口，@Service注解标记HelloServiceImpl实现类。

至此，CXF和Spring的集成已经完成。可以启动项目，访问相关URL来测试CXF的服务端和客户端功能。注意确保相关依赖已经成功加载，并且服务端和客户端的地址配置正确。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

集成Apache CXF和Spring是一种常见的方式，以实现构建RESTful服务或SOAP Web服务的应用程序。下面是关于如何集成CXF和Spring的步骤：

添加依赖：首先要在项目的构建文件中添加CXF和Spring的依赖。对于Maven项目，添加以下依赖项：

<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-spring-boot-starter-jaxrs</artifactId>
    <version>3.4.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.5.0</version>
</dependency>

创建CXF配置文件：在Spring Boot应用程序的resources目录下创建一个名为cxf.xml的文件，并在文件中配置CXF相关的bean。例如：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xmlns:rs="http://cxf.apache.org/jaxrs"
    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
        http://cxf.apache.org/jaxrs
        http://cxf.apache.org/schemas/jaxrs.xsd">

    <!-- 配置JAX-WS服务 -->
    <jaxws:endpoint
        id="helloWorldService"
        implementor="com.example.HelloWorldServiceImpl"
        address="/helloWorld"/>

    <!-- 配置JAX-RS服务 -->
    <rs:server
        id="helloWorldRestService"
        address="/helloWorldRest">
        <rs:serviceBeans>
            <bean class="com.example.HelloWorldRestServiceImpl"/>
        </rs:serviceBeans>
    </rs:server>
</beans>

创建服务实现类：实现JAX-WS和JAX-RS服务的具体实现类。例如：

package com.example;

import javax.jws.WebService;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;

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

@Path("/helloWorldRest")
public interface HelloWorldRestService {
    @GET
    @Produces("text/plain")
    String sayHello();
}

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

public class HelloWorldRestServiceImpl implements HelloWorldRestService {
    public String sayHello() {
        return "Hello, World!";
    }
}

创建Spring Boot应用程序类：在应用程序的入口类上使用@ImportResource注解来导入CXF的配置文件。例如：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

@SpringBootApplication
@ImportResource("classpath:cxf.xml")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

运行应用程序：启动Spring Boot应用程序，并访问定义的Web服务接口进行测试。如：
- JAX-WS服务: http://localhost:8080/helloWorld?wsdl
- JAX-RS服务: http://localhost:8080/helloWorldRest/sayHello

以上是将Apache CXF和Spring集成的基本步骤。通过这种集成，可以轻松地构建和部署RESTful服务和SOAP Web服务，并利用Spring的强大功能来管理和配置应用程序的依赖关系和其他方面。

1年前 0条评论

不及物动词
这个人很懒，什么都没有留下～
评论
cxf是一个开源的Web服务框架，而spring是一个强大的Java应用程序框架。将cxf和spring集成可以使开发者更方便地使用cxf框架，同时也可以充分利用spring的各种功能和特性。

下面将详细介绍cxf和spring的集成步骤和操作流程。
1. 添加依赖
首先，需要在项目的pom.xml文件中添加cxf和spring的依赖。
```
<dependencies>
    
    <dependency>
        <groupId>org.apache.cxf</groupId>
        <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
        <version>3.4.3</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.5.4</version>
    </dependency>
</dependencies>
```
1. 配置cxf
在项目的配置文件中，需要配置cxf的相关属性。下面是一个示例配置：
```
# cxf配置
cxf:
  servlet:
    url-pattern: /services/*
    load-on-startup: 1
  jaxrs:
    addresses: /api/*
  logging:
    prettyRequest: true
    prettyResponse: true
```
1. 创建WebService接口和实现类
使用cxf的@WebService注解来定义WebService接口，并使用@Service注解将实现类注入到spring容器中。
```
@WebService
@Service
public interface HelloWebService {

    @WebMethod
    String sayHello(String name);
}

@WebService(endpointInterface = "com.example.demo.soap.HelloWebService")
@Service
public class HelloWebServiceImpl implements HelloWebService {

    @Override
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}
```
1. 配置spring bean
在spring的配置文件中，需要将WebService实现类注册为spring bean。
```
<bean id="helloWebService" class="com.example.demo.soap.HelloWebServiceImpl"/>
```
1. 添加WebService发布器
在项目的启动类中，添加一个WebService发布器来发布WebService。
```
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
        // 添加WebService发布器
        Endpoint.publish("/services/HelloWebService", new HelloWebServiceImpl());
    }
}
```
至此，cxf和spring的集成步骤就完成了。通过上述步骤，cxf和spring已经成功地集成在一起，可以使用cxf框架来开发和部署WebService服务，并且可以充分利用spring的各种功能和特性。

需要注意的是，上述示例只是一个简单的示例，实际应用中可能会涉及到更复杂的配置和操作。在实际开发中，可以根据具体需求进行适当调整和扩展。
1年前 0条评论