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

  4. Microservices with Spring Boot

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

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

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

  6. Spring boot with Apache Hive

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

  7. Spring Boot Reference Guide

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

  8. 第3章 Spring Boot 入门指南

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

  9. Spring boot参考指南

    介绍 转载自: 带目录浏览地址:http://ww ...


  1. React入门--------组件的生命周期

    Mounting/组件挂载相关: componentWillMount componentDidMount Updating/组件更新相关: componentWillReceiveProps sho ...

  2. vim编辑器编程配置

    打开/etc/vim/vimrc 添加命令: set cindent  "使用C样式的缩进 syntax on   "语法高亮 set tabstop=4 set softtabs ...

  3. 剑指offer-面试题4.替换空格

    题目:请实现一个函数,把字符串中的每个空格都替换成"%20".例如输入"We are happy." 则输出"We%20are%20happy.&qu ...

  4. ICE第三篇------一些疑难点

    1 间接代理 参考 IceGrid用于支持分布式网络服务应用,一个IceGrid域由一个注册表( ...

  5. ubuntu 16.04 的64位 安装arm-none-linux-gnueabi-gcc的步骤和问题解决

    一 首先下载arm-none-linux-gnueabi-gcc交叉编译器,根据不同的需求请在网址: ...

  6. SpringMVC系列之(二) springMVC和Struts异同

    Spring MVC属于SpringFrameWork的后续产品,已经融合在Spring Web Flow里面.Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块.使用 Spring ...

  7. BeetleX之WebSocket详解

    对于BeetleX来说编写WebSocket服务是一件非常简单的事情,当你实现一个Web Api应用的同时这些API方法也是WebSocket服务方法.接下来主要讲解如何通过JavaScript调用B ...

  8. Outlook插件开发(非VSTO),欢迎交流 联系QQ:564955427 最近写了个Outlook插件,实现了读取邮件联系人的功能, ...

  9. iOS------获取当前时间和当前时间戳

    //获取当前的时间 +(NSString*)getCurrentTimes{ NSDateFormatter *formatter = [[NSDateFormatter alloc] init]; ...

  10. SpringMVC统一转换null值为空字符串的方法 !

    在SpringMVC中,可以通过在<mvc:annotation-driven>中配置<mvc:message-converters>,把null值统一转换为空字符串,解决这个 ...