A Guide to Apache CXF with Spring

Apache CXF is a popular open - source framework for building web services. It supports various web service standards such as SOAP, REST, and XML - based protocols. Spring, on the other hand, is a comprehensive Java framework that provides a wide range of features for building enterprise - level applications. Combining Apache CXF with Spring allows developers to leverage the strengths of both frameworks, enabling the creation of robust, scalable, and maintainable web services.

In this guide, we will explore how to use Apache CXF with Spring. We will cover topics such as setting up the development environment, creating a simple web service, and integrating it with Spring.

Table of Contents#

  1. Prerequisites
  2. Setting up the Project
  3. Creating a Simple Web Service
  4. Integrating CXF with Spring
  5. Deploying the Web Service
  6. Common Practices and Best Practices
  7. Example Usage
  8. Conclusion
  9. References

1. Prerequisites#

  • Java Development Kit (JDK): You need to have JDK 8 or higher installed on your system.
  • Maven: Maven is a build automation tool used for managing dependencies and building projects. Install it from the official Apache Maven website.
  • IDE: You can use any Java - based IDE such as IntelliJ IDEA or Eclipse.

2. Setting up the Project#

Create a Maven Project#

  1. Open your terminal or command prompt.
  2. Navigate to the directory where you want to create your project.
  3. Run the following command to create a new Maven project:
mvn archetype:generate -DgroupId=com.example -DartifactId=cxf -Dversion=1.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Add Dependencies#

Open the pom.xml file in your project and add the following dependencies:

<dependencies>
    <!-- Apache CXF -->
    <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>
    <!-- Spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.18</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.3.18</version>
    </dependency>
    <dependency>
        <groupId>org.apache.cxf</groupId>
        <artifactId>cxf-rt-features-logging</artifactId>
        <version>3.4.4</version>
    </dependency>
</dependencies>

3. Creating a Simple Web Service#

Define the Service Interface#

Create a new Java interface named HelloService in the com.example package:

package com.example;
 
import javax.jws.WebService;
 
@WebService
public interface HelloService {
    String sayHello(String name);
}

Implement the Service Interface#

Create a new Java class named HelloServiceImpl that implements the HelloService interface:

package com.example;
 
import javax.jws.WebService;
 
@WebService(endpointInterface = "com.example.HelloService")
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

4. Integrating CXF with Spring#

Create a Spring Configuration File#

Create a new XML file named cxf-spring-context.xml in the src/main/resources directory:

<?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:cxf="http://cxf.apache.org/core"
       xmlns:jaxws="http://cxf.apache.org/jaxws"
       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.HelloServiceImpl"/>
 
    <cxf:bus>
        <cxf:features>
            <cxf:logging/>
        </cxf:features>
    </cxf:bus>
 
    <jaxws:endpoint id="helloEndpoint"
                    implementor="#helloService"
                    address="/hello"/>
</beans>

Configure the Servlet in web.xml#

Create a web.xml file in the src/main/webapp/WEB-INF directory:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
 
    <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>
 
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:cxf-spring-context.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

5. Deploying the Web Service#

Package the Project#

Run the following Maven command to package the project:

mvn clean package

Deploy to a Servlet Container#

Deploy the generated WAR file to a servlet container such as Apache Tomcat. Start the server and access the web service at http://localhost:8080/cxf/services/hello?wsdl.

6. Common Practices and Best Practices#

Common Practices#

  • Logging: Use logging frameworks such as Log4j or SLF4J to log important events and errors in your web service. This helps in debugging and monitoring the application.
  • Error Handling: Implement proper error handling in your web service to provide meaningful error messages to the clients.
  • Configuration Management: Use external configuration files to manage the configuration of your web service. This makes it easier to change the configuration without modifying the code.

Best Practices#

  • Use Interceptors: Apache CXF provides interceptors that can be used to perform pre - and post - processing tasks such as authentication, logging, and validation.
  • Security: Implement security measures such as authentication and authorization to protect your web service from unauthorized access.
  • Testing: Write unit tests and integration tests for your web service to ensure its functionality and reliability.

7. Example Usage#

Using the Web Service in a Java Client#

import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import java.net.URL;
 
public class HelloServiceClient {
    public static void main(String[] args) throws Exception {
        URL url = new URL("http://localhost:8080/cxf/services/hello?wsdl");
        QName qname = new QName("http://example.com/", "HelloServiceService");
        Service service = Service.create(url, qname);
        HelloService helloService = service.getPort(HelloService.class);
        String response = helloService.sayHello("John");
        System.out.println(response);
    }
}

8. Conclusion#

In this guide, we have learned how to use Apache CXF with Spring to create and deploy a simple web service. We covered the process of setting up the project, creating the web service, integrating it with Spring, and deploying it to a servlet container. We also discussed common practices and best practices for developing web services using Apache CXF and Spring.

9. References#

2026-07