java 如何调cxf

要在Java中调用CXF，可以使用CXF框架来创建和消费Web服务、使用CXF生成客户端代码、通过WSDL文件生成客户端代码、配置CXF客户端安全性。以下将详细描述如何在Java中调动CXF。

一、使用CXF框架创建和消费Web服务

Apache CXF 是一个开源的服务框架，支持多种协议和数据绑定。要使用CXF框架创建和消费Web服务，可以按照以下步骤操作：

1. 设置开发环境

首先，你需要在项目中引入CXF库。你可以使用Maven来管理依赖项，在pom.xml中添加以下依赖：

<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>

2. 创建Web服务接口

定义一个Web服务接口，该接口将被公开为SOAP或REST Web服务：

import javax.jws.WebService;
@WebService
public interface HelloWorld {
    String sayHi(String text);
}

3. 实现Web服务

创建实现该接口的服务类：

import javax.jws.WebService;
@WebService(endpointInterface = "com.example.HelloWorld")
public class HelloWorldImpl implements HelloWorld {
    @Override
    public String sayHi(String text) {
        return "Hello, " + text;
    }
}

4. 发布Web服务

使用CXF来发布Web服务：

import org.apache.cxf.jaxws.JaxWsServerFactoryBean;
public class Server {
    public static void main(String[] args) {
        HelloWorldImpl implementor = new HelloWorldImpl();
        JaxWsServerFactoryBean svrFactory = new JaxWsServerFactoryBean();
        svrFactory.setServiceClass(HelloWorld.class);
        svrFactory.setAddress("http://localhost:8080/HelloWorld");
        svrFactory.setServiceBean(implementor);
        svrFactory.create();
    }
}

二、使用CXF生成客户端代码

CXF提供了工具来生成客户端代码，可以直接调用Web服务。以下是生成客户端代码的步骤：

1. 使用wsdl2java工具

使用CXF的wsdl2java工具可以根据WSDL文件生成客户端代码。你可以在命令行中运行以下命令：

wsdl2java -p com.example.client -d src/main/java http://localhost:8080/HelloWorld?wsdl

2. 调用生成的客户端代码

生成的客户端代码可以直接在Java应用程序中使用：

import com.example.client.HelloWorld;
import com.example.client.HelloWorldService;
public class Client {
    public static void main(String[] args) {
        HelloWorldService service = new HelloWorldService();
        HelloWorld port = service.getHelloWorldPort();
        String response = port.sayHi("World");
        System.out.println(response);
    }
}

三、通过WSDL文件生成客户端代码

1. 获取WSDL文件

确保你已经有了Web服务的WSDL文件。你可以通过访问Web服务的URL来获取WSDL文件，例如http://localhost:8080/HelloWorld?wsdl。

2. 使用wsdl2java工具生成客户端代码

使用wsdl2java工具生成客户端代码：

wsdl2java -p com.example.client -d src/main/java http://localhost:8080/HelloWorld?wsdl

3. 在项目中使用生成的代码

将生成的代码引入到你的项目中，并使用它来调用Web服务：

import com.example.client.HelloWorld;
import com.example.client.HelloWorldService;
public class Client {
    public static void main(String[] args) {
        HelloWorldService service = new HelloWorldService();
        HelloWorld port = service.getHelloWorldPort();
        String response = port.sayHi("World");
        System.out.println(response);
    }
}

四、配置CXF客户端安全性

在实际应用中，Web服务通常需要进行安全配置。以下是配置CXF客户端安全性的一些常见方法：

1. 配置HTTP基本认证

可以通过以下方式在CXF客户端中配置HTTP基本认证：

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.apache.cxf.transport.http.auth.HttpAuthSupplier;
import org.apache.cxf.transport.http.auth.HttpBasicAuthSupplier;
import org.apache.cxf.transport.http.auth.HttpConduit;
public class ClientWithAuth {
    public static void main(String[] args) {
        JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
        factory.setServiceClass(HelloWorld.class);
        factory.setAddress("http://localhost:8080/HelloWorld");
        HelloWorld client = (HelloWorld) factory.create();
        Client proxy = org.apache.cxf.frontend.ClientProxy.getClient(client);
        HttpConduit conduit = (HttpConduit) proxy.getConduit();
        HttpAuthSupplier supplier = new HttpBasicAuthSupplier();
        conduit.getAuthorization().setAuthorizationType("Basic");
        conduit.getAuthorization().setUserName("username");
        conduit.getAuthorization().setPassword("password");
        String response = client.sayHi("World");
        System.out.println(response);
    }
}

2. 配置WS-Security

WS-Security 是一种用于保护SOAP消息的标准。你可以通过以下方式配置WS-Security：

配置客户端的ws-security

首先，在项目中添加WS-Security相关的依赖：

<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-ws-security</artifactId>
    <version>3.4.4</version>
</dependency>

然后，在客户端代码中配置WS-Security：

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.frontend.ClientProxy;
import org.apache.cxf.ws.security.wss4j.WSS4JOutInterceptor;
import org.apache.wss4j.common.ext.WSPasswordCallback;
import org.apache.wss4j.dom.handler.WSHandlerConstants;
import java.util.HashMap;
import java.util.Map;
public class ClientWithWSSecurity {
    public static void main(String[] args) {
        HelloWorldService service = new HelloWorldService();
        HelloWorld client = service.getHelloWorldPort();
        Client proxy = ClientProxy.getClient(client);
        Map<String, Object> outProps = new HashMap<>();
        outProps.put(WSHandlerConstants.ACTION, WSHandlerConstants.USERNAME_TOKEN);
        outProps.put(WSHandlerConstants.USER, "username");
        outProps.put(WSHandlerConstants.PW_CALLBACK_CLASS, ClientPasswordCallback.class.getName());
        WSS4JOutInterceptor wssOut = new WSS4JOutInterceptor(outProps);
        proxy.getOutInterceptors().add(wssOut);
        String response = client.sayHi("World");
        System.out.println(response);
    }
    public static class ClientPasswordCallback implements WSPasswordCallback {
        @Override
        public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
            for (Callback callback : callbacks) {
                if (callback instanceof WSPasswordCallback) {
                    WSPasswordCallback pc = (WSPasswordCallback) callback;
                    pc.setPassword("password");
                }
            }
        }
    }
}

通过上述步骤，你可以在Java中成功调用使用CXF框架的Web服务，并通过生成客户端代码、配置安全性等方式，实现对Web服务的安全调用。

五、使用Spring配置CXF客户端

1. 引入Spring和CXF依赖

在pom.xml中添加Spring和CXF的依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.8</version>
</dependency>
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
    <version>3.4.4</version>
</dependency>

2. 配置Spring上下文

创建一个Spring配置文件，例如applicationContext.xml，配置CXF客户端：

<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">
    <bean id="helloWorldClient" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">
        <property name="serviceClass" value="com.example.client.HelloWorld"/>
        <property name="address" value="http://localhost:8080/HelloWorld"/>
    </bean>
</beans>

3. 在Java代码中使用Spring上下文

使用Spring上下文来获取CXF客户端并调用Web服务：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringClient {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloWorld client = (HelloWorld) context.getBean("helloWorldClient");
        String response = client.sayHi("World");
        System.out.println(response);
    }
}

通过使用Spring配置CXF客户端，你可以更灵活地管理CXF客户端的配置，并利用Spring的依赖注入功能简化代码。

六、使用CXF客户端进行异步调用

CXF支持异步调用Web服务，这可以提高客户端应用程序的性能。以下是使用CXF客户端进行异步调用的示例：

1. 配置异步调用

在生成的客户端代码中，CXF会自动生成异步调用的方法。例如，如果你的接口有一个方法sayHi，CXF会生成一个名为sayHiAsync的方法。

2. 调用异步方法

使用生成的异步方法进行异步调用：

import com.example.client.HelloWorld;
import com.example.client.HelloWorldService;
import javax.xml.ws.AsyncHandler;
import javax.xml.ws.Response;
import java.util.concurrent.ExecutionException;
public class AsyncClient {
    public static void main(String[] args) {
        HelloWorldService service = new HelloWorldService();
        HelloWorld port = service.getHelloWorldPort();
        // 异步调用并等待结果
        Response<String> response = port.sayHiAsync("World");
        try {
            System.out.println("Response: " + response.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        // 使用回调处理异步结果
        port.sayHiAsync("World", new AsyncHandler<String>() {
            @Override
            public void handleResponse(Response<String> res) {
                try {
                    System.out.println("Async Response: " + res.get());
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

通过异步调用，你可以在等待Web服务响应的同时继续执行其他任务，从而提高应用程序的性能和响应性。

七、使用CXF日志记录和调试

1. 配置日志记录

CXF提供了多种日志记录和调试功能，可以帮助你在开发和调试过程中更好地了解Web服务的调用情况。你可以通过以下方式配置CXF日志记录：

配置log4j日志记录

在项目中添加log4j依赖：

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

创建log4j配置文件log4j.properties：

log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

2. 启用CXF日志拦截器

在客户端代码中启用CXF日志拦截器：

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.frontend.ClientProxy;
import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
public class LoggingClient {
    public static void main(String[] args) {
        HelloWorldService service = new HelloWorldService();
        HelloWorld client = service.getHelloWorldPort();
        Client proxy = ClientProxy.getClient(client);
        proxy.getInInterceptors().add(new LoggingInInterceptor());
        proxy.getOutInterceptors().add(new LoggingOutInterceptor());
        String response = client.sayHi("World");
        System.out.println(response);
    }
}

通过配置日志记录和启用日志拦截器，你可以更好地监控Web服务的请求和响应消息，从而更容易地进行调试和故障排除。

八、使用CXF客户端进行文件传输

1. 配置文件传输

Web服务可以用于传输文件。以下是使用CXF客户端进行文件传输的示例：

定义文件传输接口

import javax.jws.WebService;
import javax.activation.DataHandler;
@WebService
public interface FileTransfer {
    void uploadFile(String fileName, DataHandler fileData);
    DataHandler downloadFile(String fileName);
}

实现文件传输服务

import javax.activation.DataHandler;
import javax.jws.WebService;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
@WebService(endpointInterface = "com.example.FileTransfer")
public class FileTransferImpl implements FileTransfer {
    @Override
    public void uploadFile(String fileName, DataHandler fileData) {
        try (FileOutputStream fos = new FileOutputStream(new File(fileName))) {
            fileData.writeTo(fos);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public DataHandler downloadFile(String fileName) {
        try {
            return new DataHandler(new FileDataSource(new File(fileName)));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

2. 调用文件传输服务

使用CXF客户端调用文件传输服务：

import com.example.client.FileTransfer;
import com.example.client.FileTransferService;
import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import java.io.File;
public class FileTransferClient {
    public static void main(String[] args) {
        FileTransferService service = new FileTransferService();
        FileTransfer port = service.getFileTransferPort();
        // 上传文件
        File fileToUpload = new File("path/to/local/file.txt");
        DataHandler fileData = new DataHandler(new FileDataSource(fileToUpload));
        port.uploadFile("uploadedFile.txt", fileData);
        // 下载文件
        DataHandler downloadedFileData = port.downloadFile("uploadedFile.txt");
        try (FileOutputStream fos = new FileOutputStream(new File("path/to/downloaded/file.txt"))) {
            downloadedFileData.writeTo(fos);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

通过上述步骤，你可以使用CXF客户端实现文件的上传和下载功能，从而扩展Web服务的应用场景。

总结

在Java中调用CXF涉及多个步骤和配置，包括创建和消费Web服务、生成客户端代码、配置安全性、使用Spring配置CXF客户端、进行异步调用、日志记录和调试、以及文件传输等。通过详细了解和掌握这些步骤和配置，你可以在Java应用程序中高效地使用CXF框架来调用和管理Web服务。