Over a million developers have joined DZone.

Building Microservices with Spring Boot and Apache Thrift. Part 1

DZone's Guide to

Building Microservices with Spring Boot and Apache Thrift. Part 1

· Integration Zone
Free Resource

Today’s data climate is fast-paced and it’s not slowing down. Here’s why your current integration solution is not enough. Brought to you in partnership with Liaison Technologies.

In the modern world of microservices it's important to provide strict and polyglot clients for your service. It's better if your API is self-documented. One of the best tools for it is Apache Thrift. I want to explain how to use it with my favorite platform for microservices - Spring Boot.

All project source code is available on GitHub: https://github.com/bsideup/spring-boot-thrift

Project skeleton

I will use Gradle to build our application. First, we need our main build.gradle file:

buildscript {
    repositories {
    dependencies {

allprojects {
    repositories {

    apply plugin:'base'
    apply plugin: 'idea'

subprojects {
    apply plugin: 'java'

Nothing special for a Spring Boot project. Then we need a gradle file for thrift protocol modules (we will reuse it in next part):


import org.gradle.internal.os.OperatingSystem

repositories {
    ivy {
        artifactPattern "http://dl.bintray.com/bsideup/thirdparty/[artifact]-[revision](-[classifier]).[ext]"

buildscript {
    repositories {
    dependencies {
        classpath "ru.trylogic.gradle.plugins:gradle-thrift-plugin:0.1.1"

apply plugin: ru.trylogic.gradle.thrift.plugins.ThriftPlugin

task generateThrift(type : ru.trylogic.gradle.thrift.tasks.ThriftCompileTask) {
    generator = 'java:beans,hashcode'
    destinationDir = file("generated-src/main/java")

sourceSets {
    main {
        java {
            srcDir generateThrift.destinationDir

clean {
    delete generateThrift.destinationDir

idea {
    module {
        sourceDirs += [file('src/main/thrift'), generateThrift.destinationDir]

compileJava.dependsOn generateThrift

dependencies {
    def thriftVersion = '0.9.1';
    Map platformMapping = [
            (OperatingSystem.WINDOWS) : 'win',
            (OperatingSystem.MAC_OS) : 'osx'
    ].withDefault { 'nix' }

    thrift "org.apache.thrift:thrift:$thriftVersion:${platformMapping.get(OperatingSystem.current())}@bin"

    compile "org.apache.thrift:libthrift:$thriftVersion"

    compile 'org.slf4j:slf4j-api:1.7.7'

We're using my Thrift plugin for Gradle. Thrift will generate source to the "generated-src/main/java" directory. By default, Thrift uses slf4j v1.5.8, while Spring Boot uses v1.7.7. It will cause an error in runtime when you will run your application, that's why we have to force a slf4j api dependency.

Calculator service

Let's start with a simple calculator service. It will have 2 modules: protocol and app.We will start with protocol. Your project should look as follows:

  • calculator/
    • protocol/                               
      • src/                                      
        • main/                                             
          • thrift/                                                            
            • calculator.thrift
      • build.gradle
  • build.gradle
  • settings.gradle
  • thrift.gradle

Where calculator/protocol/build.gradle contains only one line:

apply from: rootProject.file('thrift.gradle')


Don't forget to put these lines to settings.gradle, otherwise your modules will not be visible to Gradle:

include 'calculator:protocol'
include 'calculator:app'

Calculator protocol


Even if you're not familiar with Thrift, its protocol description file (calculator/protocol/src/main/thrift/calculator.thrift) should be very clear to you:

namespace cpp com.example.calculator
namespace d com.example.calculator
namespace java com.example.calculator
namespace php com.example.calculator
namespace perl com.example.calculator
namespace as3 com.example.calculator

enum TOperation {
  ADD = 1,
  DIVIDE = 4

exception TDivisionByZeroException {

service TCalculatorService {
   i32 calculate(1:i32 num1, 2:i32 num2, 3:TOperation op) throws (1:TDivisionByZeroException divisionByZero);


Here we define TCalculatorService with only one method - calculate. It can throw an exception of type TDivisionByZeroException. Note how many languages we're supporting out of the box (in this example we will use only Java as a target, though)

Now run ./gradlew generateThrift, you will get generated Java protocol source in the calculator/protocol/generated-src/main/java/ folder.

Calculator application

Next, we need to create the service application itself. Just create calculator/app/ folder with the following structure:

  • src/        
    • main/                          
      • java/                                      
        • com/                                                   
          • example/                                                              
            • calculator/                                                                            
              • handler/                  
                • CalculatorServiceHandler.java                                       
              • service/                                                                                                            
                • CalculatorService.java                                           
              • CalculatorApplication.java
  • build.gradle

Our build.gradle file for app module should look like this:

apply plugin: 'spring-boot'

dependencies {
    compile project(':calculator:protocol')

    compile 'org.springframework.boot:spring-boot-starter-web'

    testCompile 'org.springframework.boot:spring-boot-starter-test'

Here we have a dependency on protocol and typical starters for Spring Boot web app.


CalculatorApplication is our main class. In this example I will configure Spring in the same file, but in your apps you should use another config class instead.

package com.example.calculator;

import com.example.calculator.handler.CalculatorServiceHandler;
import org.apache.thrift.protocol.*;
import org.apache.thrift.server.TServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.*;
import javax.servlet.Servlet;

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

    public TProtocolFactory tProtocolFactory() {
        //We will use binary protocol, but it's possible to use JSON and few others as well
        return new TBinaryProtocol.Factory();
    public Servlet calculator(TProtocolFactory protocolFactory, CalculatorServiceHandler handler) {
        return new TServlet(new TCalculatorService.Processor<CalculatorServiceHandler>(handler), protocolFactory);

You may ask why Thrift servlet bean is called "calculator". In Spring Boot, it will register your servlet bean in context of the bean name and our servlet will be available at /calculator/.

After that we need a Thrift handler class:

package com.example.calculator.handler;

import com.example.calculator.*;
import com.example.calculator.service.CalculatorService;
import org.apache.thrift.TException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
public class CalculatorServiceHandler implements TCalculatorService.Iface {
    CalculatorService calculatorService;
    public int calculate(int num1, int num2, TOperation op) throws TException {
        switch(op) {
            case ADD:
                return calculatorService.add(num1, num2);
            case SUBTRACT:
                return calculatorService.subtract(num1, num2);
            case MULTIPLY:
                return calculatorService.multiply(num1, num2);
            case DIVIDE:
                try {
                    return calculatorService.divide(num1, num2);
                } catch(IllegalArgumentException e) {
                    throw new TDivisionByZeroException();
                throw new TException("Unknown operation " + op);


In this example I want to show you that Thrift handler can be a normal Spring bean and you can inject dependencies in it.

Now we need to implement CalculatorService itself:

package com.example.calculator.service;

import org.springframework.stereotype.Component;

public class CalculatorService {
    public int add(int num1, int num2) {
        return num1 + num2;
    public int subtract(int num1, int num2) {
        return num1 - num2;
    public int multiply(int num1, int num2) {
        return num1 * num2;
    public int divide(int num1, int num2) {
        if(num2 == 0) {
            throw new IllegalArgumentException("num2 must not be zero");
        return num1 / num2;


That's it. Well... almost. We still need to test our service somehow. And it should be an integration test.

Usually, even if your application is providing JSON REST API, you still have to implement a client for it. Thrift will do it for you. We don't have to care about it. Also, it will support different protocols. Let's use a generated client in our test:

package com.example.calculator;

import org.apache.thrift.protocol.*;
import org.apache.thrift.transport.THttpClient;
import org.apache.thrift.transport.TTransport;
import org.junit.*;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.*;
import org.springframework.boot.test.IntegrationTest;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import static org.junit.Assert.*;

@SpringApplicationConfiguration(classes = CalculatorApplication.class)
public class CalculatorApplicationTest {
    protected TProtocolFactory protocolFactory;

    protected int port;
    protected TCalculatorService.Client client;

    public void setUp() throws Exception {
        TTransport transport = new THttpClient("http://localhost:" + port + "/calculator/");
        TProtocol protocol = protocolFactory.getProtocol(transport);
        client = new TCalculatorService.Client(protocol);

    public void testAdd() throws Exception {
        assertEquals(5, client.calculate(2, 3, TOperation.ADD));

    public void testSubtract() throws Exception {
        assertEquals(3, client.calculate(5, 2, TOperation.SUBTRACT));
    public void testMultiply() throws Exception {
        assertEquals(10, client.calculate(5, 2, TOperation.MULTIPLY));
    public void testDivide() throws Exception {
        assertEquals(2, client.calculate(10, 5, TOperation.DIVIDE));
    @Test(expected = TDivisionByZeroException.class)
    public void testDivisionByZero() throws Exception {
        client.calculate(10, 0, TOperation.DIVIDE);


This test will run your Spring Boot application, bind it to a random port and test it. All client-server communications will be performed in the same way real world clients are.

Note how easy to use our service is from the client side. We're just calling methods and catching exceptions.

Is iPaaS solving the right problems? Not knowing the fundamental difference between iPaaS and iPaaS+ could cost you down the road. Brought to you in partnership with Liaison Technologies.

java ,enterprise-integration ,tips and tricks ,thrift ,spring boot ,microservices ,apache thrift

Opinions expressed by DZone contributors are their own.


Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.


{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}