Skip to main content

Guide : Spring Boot with Apache CXF for REST services

In this series of guide, we are going to explore writing REST services with Apache CXF using Spring Boot.
The project is build using maven. I assume that you already know how to use maven.
Step 1 : Adding dependencies for Spring Boot
By default you have to inherit the parent pom of spring boot, but that cannot be followed everytime, so I use an alternative to that. I basically add spring boot pom as dependency so that it brings all the dependencies.
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
    <spring.version>1.4.3.RELEASE</spring.version>
    <cxf.version>3.1.10</cxf.version>
</properties>

<dependencies>
    <dependency>
    <!-- Alternative to inheriting from parent spring pom -->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>${spring.version}</version>
        <type>pom</type>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <version>${spring.version}</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.cxf</groupId>
        <artifactId>cxf-spring-boot-starter-jaxrs</artifactId>
        <version>${cxf.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.jaxrs</groupId>
        <artifactId>jackson-jaxrs-json-provider</artifactId>
        <version>2.8.5</version>
    </dependency>
</dependencies>

Step 2: Package structure of application
We can create some basic packages to have an outline of what code will go where and its basically good idea to have a general outline of the application ready. Following are the packages that we will make for now
  • config
  • dao
  • models
  • rest
  • services
  • utils

Step 3 : Spring Boot Starter class
When writing spring boot, you have to create an Application class or in this case i call it Starter class. This class is main class that is the entry point of your packaged spring boot (more on this later). It looks like as below
package org.blog;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Created by Anand_Rajneesh on 3/23/2017.
 */
@SpringBootApplication
public class Starter {

    public static void main(String[] args) {
        SpringApplication.run(Starter.class, args);
    }
}

@SpringBootApplication does a bunch of stuff under the hood, it basically tells the Spring to do package scan to identify component classes, configuration classes etc.
Step 4 : Writing CXF Service
In rest package that we created in Step 2, create a new class Ping. This will be basically our health check class which would return 200 ok if everything is ok with the service.
package org.blog.rest;

import org.springframework.stereotype.Service;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.core.Response;

/**
 * Created by Anand_Rajneesh on 3/24/2017.
 */
@Path("/ping")
@Service
public class Ping {

    @GET
    public Response health(){
        return Response.ok().build();
    }
}
Ping class has two annotations : @Service to register it as Spring component. @Path – to specify the url on which the service will be accessible
Step 6 : Enabling CXF
Create an application.properties file in resources folder. Add below line to it
cxf.jaxrs.component-scan=true
This tells cxf to look for Spring components which might act as JAX-RS resources, providers and other extensions.
That’s it, you have basic REST application set up here.
Now package your jar by running mvn package and then start it.
Use url http://localhost:8080/services/ping and it should give a 200 ok back in response.
What you can do on your own is look at the various JAX-RS annotations, play with status codes and http methods. Create more services and experiment.
More on the cxf servlet path configuration and more features of cxf later..

Comments

Post a Comment

Popular posts from this blog

Enabling CXF goodies in Spring Boot

In this post we are going to add some of the CXF features to our existing app that we developed in previous post. These features are : ID LoggingJackson Provider for POJO to JSON conversionSwagger 2 documentationStep 1: Configuration class Create a RestServer class in config package as shown below
package org.blog.config;importcom.fasterxml.jackson.jaxrs.json.JacksonJsonProvider;importorg.apache.cxf.feature.LoggingFeature;importorg.apache.cxf.jaxrs.swagger.Swagger2Feature;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configuration;/** * Created by Anand_Rajneesh on 3/23/2017. */@ConfigurationpublicclassRestServer{@Beanpublic JacksonJsonProvider jsonProvider(){returnnewJacksonJsonProvider();}@Beanpublic LoggingFeature loggingFeature(){returnnewLoggingFeature();}@Beanpublic Swagger2Feature swagger(){ Swagger2Feature swagger =new Swagger2Feature(); swagger.setBasePath("/services"); swagger.setContact("…

Power of declarative syntax of Lambda

Since Java has introduced lambda, writing code has become a breeze especially when it comes to expressing what you want to computer to do rather than how to do it. The following is a question from Project Euler and is solved using lambdas in Java8.

Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n). If d(a) = b and d(b) = a, where ab, then a and b are an amicable pair and each of a and b are called amicable numbers. For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220. Evaluate the sum of all the amicable numbers under 10000.  A simple brute force solution is to check every number from 2 to 10000 and if its  an amicable number then add it to sum. Listing it in steps you are basically doing 3 things: Take numbers from 2 to 10000If number is amicableAdd it In Java 7 one will basically start a for loop, mak…