### 回答1：
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 My
WebService {
@
WebMethod
String sayHello(String name);
}
```
3. 创建一个实现类来实现接口中定义的操作：
```
@
Service
@
WebService(endpointInterface = "com.example.My
WebService")
public class My
WebServiceImpl implements My
WebService {
@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 My
WebService my
WebService;
@GetMapping("/hello/{name}")
public String sayHello(@PathVariable String name) {
return my
WebService.sayHello(name);
}
}
```
6. 启动应用程序并访问
Web服务：
```
http://localhost:8080/
services/My
WebServiceImpl?wsdl
```
以上就是使用Spring Boot和
CXF调用Web服务的步骤。
### 回答2：
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
JaxWsProxy
FactoryBean
jaxWsProxy
FactoryBean;
private HelloPortType helloPortType;
public String sayHello(final String name) {
initPortType();
return helloPortType.sayHello(name);
}
private void initPortType() {
if (helloPortType == null) {
jaxWsProxy
FactoryBean.set
ServiceClass(HelloPortType.class);
jaxWsProxy
FactoryBean.setAddress("http://localhost:8080/hello");
helloPortType = (HelloPortType)
jaxWsProxy
FactoryBean.create();
}
}
}
```
3. 编写
WebService
通过
CXF创建
web服务，并实现接口提供服务，返回接口需要的数据。
```
@javax.jws.
WebService(
serviceName = "Hello
Service", portName = "HelloPort", targetNamespace = "http://www.example.org/Hello
Service/", endpointInterface = "org.example.
service.HelloPortType")
public class HelloPortTypeImpl implements HelloPortType {
private final static Logger LOGGER = Logger
Factory.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，提供服务的代码也可以很容易地进行编写。
### 回答3：
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 Student
WebService {
@
WebMethod
List<Student> getStudents();
}
```
我们使用
CXF的
JAX-WS Frontend创建了一个接口，同时使用@
WebService注解来标记该接口。然后我们就可以创建一个实现类来实现该接口：
```java
@
Service
public class Student
WebServiceImpl implements Student
WebService {
@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 ServletRegistration
Bean<
CXFServlet>
cxfServlet() {
return new ServletRegistration
Bean<
CXFServlet>(new
CXFServlet(), "/soap/*");
}
@
Bean
public Student
WebService student
WebService() {
return new Student
WebServiceImpl();
}
@
Bean
public Endpoint endpoint() {
EndpointImpl endpoint = new EndpointImpl(springBus(), student
WebService());
endpoint.publish("/Student
WebService");
return endpoint;
}
}
```
在上述代码中，我们创建了一个
CXFServlet，并将其映射到/soap/*路径下，同时创建了一个
WebService的实现类，在SpringBoot启动时通过Endpoint暴露出来。这样我们就可以在客户端中通过
CXF框架来访问
Webservice了。
总结一下，SpringBoot与
CXF框架结合使用
调用Webservice可以非常方便地完成。我们只需要提供一个接口，实现其方法并使用
CXF暴露出去，就可以在客户端通过
CXF框架来访问了。同时，我们还可以使用
CXF的一些特性来定制化我们的
调用过程，包括定制连接超时、读取超时、日志记录等。
最低0.47元/天 解锁文章
4946
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
