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:

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 "[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 thecalculator/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/

              • service/                                                                                                            
  • 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) {
, 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.

Building Microservices with Spring Boot and Apache Thrift. Part 1 with servlet的更多相关文章

  1. Building Microservices with Spring Boot and Apache Thrift. Part 2. Swifty services     In previous article I showed y ...

  2. Quick Guide to Microservices with Spring Boot 2.0, Eureka and Spring Cloud ...

  3. Spring Boot 2.X(十):自定义注册 Servlet、Filter、Listener

    前言 在 Spring Boot 中已经移除了 web.xml 文件,如果需要注册添加 Servlet.Filter.Listener 为 Spring Bean,在 Spring Boot 中有两种 ...

  4. Building microservices with Spring Cloud and Netflix OSS, part 2

    In Part 1 we used core components in Spring Cloud and Netflix OSS, i.e. Eureka, Ribbon and Zuul, to ...

  5. Microservices with Spring Boot

    找到一套比较不错的Spring Boot/Cloud入门教程,推荐一下.

  6. Spring Boot 学习系列(08)—自定义servlet、filter及listener

    此文已由作者易国强授权网易云社区发布. 欢迎访问网易云社区,了解更多网易技术产品运营经验. 传统的filter及listener配置 在传统的Java web项目中,servlet.filter和li ...

  7. Spring boot with Apache Hive

      5.29.1. Maven <dependency> <groupId>org.springframework.boot</groupId> <artif ...

  8. Spring Boot Reference Guide

    Spring Boot Reference Guide Authors Phillip Webb, Dave Syer, Josh Long, Stéphane Nicoll, Rob Winch,  ...

  9. 第3章 Spring Boot 入门指南

    Part II. 入门指南 如果你刚刚开始使用Spring Boot,这是你的一部分内容! 在这里我们将会回答一些基本的“what?”, “how?” 和 “why?”的问题. 在这里你会找到一个详细 ...


  1. Delphi_05_Delphi_Object_Pascal_基本语法_03

    继续Delphi的学习之旅, 废话不多说,直接贴代码. { Delphi基本语法 1.对象 2.指针 3.类型别名 和 类型转换 } program DelphiObject; {$APPTYPE C ...

  2. CSS基础篇之选择符

    关系选择符 E F 包含选择符(Descendant combinator) CSS1 选择所有被E元素包含的F元素. <html> <head> <meta chars ...

  3. WebConfig配置文件详解

    今天看到博客园一位朋友整理的一个WebConfig配置文件详解,觉得不错,转载一下: <?xml version="1.0"?> <!--注意: 除了手动编辑此文 ...

  4. Android高仿微信图片选择功能的PhotoPicker

    类似于微信修改头像的功能基本上每个app都会有,以前公司开发的项目就有修改头像的功能,但是用的Android系统自带的图片选择器.用Android系统的图片选择器有个好处就是稳定,不会有什么问题.但也 ...

  5. 重温XML

    关于什么是XML,以及XML有什么作用,网络上很多,我就在这里不班门弄斧,写博客,是我的一个习惯,究其内容无非个人情感,心得体会,转载,技术相关的,或者一时心血来潮的个人之谈,但是我是一个小心翼翼的人 ...

  6. SUN-LDAP6.3_RHEL 5.0-卸载LDAP

    卸载LDAP 1.注销服务器 到目录/ldap/ldapinstance/dscc6/bin下 # ./dsccreg remove-server -h 主机名 /ldap/ldapinstance/ ...

  7. 代码异味---Code smell

    程序员应该竭尽全力去写那些重复的代码.以下几点是我目前最需要改进的地方. 重复代码: 相同或者相似的代码存在于一个以上的地方. 长方法: 一个非常长的方法.函数或者过程. 巨类: 一个非常庞大的类. ...

  8. jvisualvm 连接 jstatd 远程监控 jvm 或 Visual GC提示&quot;不受此JVM支持“

    Visual GC提示"不受此JVM支持",可以使用此方法解决. 一.添加配置文件 jstatd.all.policy [root@localhost /]# cd /usr/lo ...

  9. sqlserver 优化

    避免在索引列上使用计算 where子句中,如果索引列是函数的一部分,优化器将不使用索引而使用全表扫描.例如: (低效)select ... from [dept] where [sal]*12> ...

  10. python 自然语言处理(五)____WordNet

    WordNet是面向语义的英语词典,与传统辞典类似,但结构更丰富.nltk中包括英语WordNet,共有155287个单词和117659个同义词. 1.寻找同义词 这里以motorcar为例,寻找它的 ...