微服務框架：如果不用 Spring Boot，還可以選擇誰？

前言

在 Java 和 Kotlin 中, 除了使用Spring Boot創建微服務外，還有很多其他的替代方案，

本文，基于這些微服務框架，創建了五個服務，并使用Consul的服務發現模式實作服務間的 相互通信，因此，它們形成了異構微服務架構（Heterogeneous Microservice Architecture, 以下簡稱 MSA）：

本文簡要考慮了微服務在各個框架上的實作（更多細節請查看源代碼：https : //github.com/rkudryashov/heterogeneous-microservices）

• 技術堆疊：

• JDK 13
• Kotlin
• Gradle (Kotlin DSL)
• JUnit 5

• 功能介面（HTTP API）：

• GET /application-info{?request-to=some-service-name}
• GET /application-info/logo

• 實作方式：

• 使用文本檔案的配置方式
• 使用依賴注入
• HTTP API

• MSA：

• 使用服務發現模式（在Consul中注冊，通過客戶端負載均衡的名稱請求另一個微服務的HTTP API）
• 構建一個 uber-JAR

先決條件

• JDK 13
• Consul

從頭開始創建應用程式

要基于其中一個框架上生成新專案，你可以使用web starter 或其他選項（例如，構建工具或 IDE）：

Helidon服務

該框架是在 Oracle 中創建以供內部使用，隨后成為開源，Helidon 非常簡單和快捷，它提供了兩個版本：標準版（SE）和MicroProfile（MP），在這兩種情況下，服務都是一個常規的 Java SE 程式，（在Helidon上了解更多資訊）

Helidon MP 是 Eclipse MicroProfile的實作之一，這使得使用許多 API 成為可能，包括 Java EE 開發人員已知的（例如 JAX-RS、CDI等）和新的 API（健康檢查、指標、容錯等），在 Helidon SE 模型中，開發人員遵循“沒有魔法”的原則，例如，創建應用程式所需的注解數量較少或完全沒有，

Helidon SE 被選中用于微服務的開發，因為Helidon SE 缺乏依賴注入的手段，因此為此使用了Koin，

以下代碼示例，是包含 main 方法的類，為了實作依賴注入，該類繼承自KoinComponent，

首先，Koin 啟動，然后初始化所需的依賴并呼叫startServer()方法—-其中創建了一個WebServer型別的物件，應用程式配置和路由設定傳遞到該物件；

啟動應用程式后在Consul注冊：

object HelidonServiceApplication : KoinComponent {
?
    @JvmStatic
    fun main(args: Array<String>) {
        val startTime = System.currentTimeMillis()
        startKoin {
            modules(koinModule)
        }
?
        val applicationInfoService: ApplicationInfoService by inject()
        val consulClient: Consul by inject()
        val applicationInfoProperties: ApplicationInfoProperties by inject()
        val serviceName = applicationInfoProperties.name
?
        startServer(applicationInfoService, consulClient, serviceName, startTime)
    }
}
?
fun startServer(
    applicationInfoService: ApplicationInfoService,
    consulClient: Consul,
    serviceName: String,
    startTime: Long
): WebServer {
    val serverConfig = ServerConfiguration.create(Config.create().get("webserver"))
?
    val server: WebServer = WebServer
        .builder(createRouting(applicationInfoService))
        .config(serverConfig)
        .build()
?
    server.start().thenAccept { ws ->
        val durationInMillis = System.currentTimeMillis() - startTime
        log.info("Startup completed in $durationInMillis ms. Service running at: http://localhost:" + ws.port())
        // register in Consul
        consulClient.agentClient().register(createConsulRegistration(serviceName, ws.port()))
    }
?
    return server
}

路由配置如下：

private fun createRouting(applicationInfoService: ApplicationInfoService) = Routing.builder()
    .register(JacksonSupport.create())
    .get("/application-info", Handler { req, res ->
        val requestTo: String? = req.queryParams()
            .first("request-to")
            .orElse(null)
?
        res
            .status(Http.ResponseStatus.create(200))
            .send(applicationInfoService.get(requestTo))
    })
    .get("/application-info/logo", Handler { req, res ->
        res.headers().contentType(MediaType.create("image", "png"))
        res
            .status(Http.ResponseStatus.create(200))
            .send(applicationInfoService.getLogo())
    })
    .error(Exception::class.java) { req, res, ex ->
        log.error("Exception:", ex)
        res.status(Http.Status.INTERNAL_SERVER_ERROR_500).send()
    }
    .build()

該應用程式使用HOCON格式的組態檔：

webserver {
  port: 8081
}
?
application-info {
  name: "helidon-service"
  framework {
    name: "Helidon SE"
    release-year: 2019
  }
}

還可以使用 JSON、YAML 和properties 格式的檔案進行配置（在Helidon 配置檔案中了解更多資訊），

Ktor服務

該框架是為 Kotlin 撰寫和設計的，和 Helidon SE 一樣，Ktor 沒有開箱即用的 DI，所以在啟動服務器依賴項之前應該使用 Koin 注入：

val koinModule = module {
    single { ApplicationInfoService(get(), get()) }
    single { ApplicationInfoProperties() }
    single { ServiceClient(get()) }
    single { Consul.builder().withUrl("https://localhost:8500").build() }
}
?
fun main(args: Array<String>) {
    startKoin {
        modules(koinModule)
    }
    val server = embeddedServer(Netty, commandLineEnvironment(args))
    server.start(wait = true)
}

應用程式需要的模塊在組態檔中指定（HOCON格式；更多配置資訊參考Ktor配置檔案 ），其內容如下：

ktor {
  deployment {
    host = localhost
    port = 8082
    environment = prod
    // for dev purpose
    autoreload = true
    watch = [io.heterogeneousmicroservices.ktorservice]
  }
  application {
    modules = [io.heterogeneousmicroservices.ktorservice.module.KtorServiceApplicationModuleKt.module]
  }
}
?
application-info {
  name: "ktor-service"
  framework {
    name: "Ktor"
    release-year: 2018
  }
}

在 Ktor 和 Koin 中，術語“模塊”具有不同的含義，

在 Koin 中，模塊類似于 Spring 框架中的應用程式背景關系，Ktor的模塊是一個用戶定義的函式，它接受一個 Application型別的物件，可以配置流水線、注冊路由、處理請求等：

fun Application.module() {
    val applicationInfoService: ApplicationInfoService by inject()
?
    if (!isTest()) {
        val consulClient: Consul by inject()
        registerInConsul(applicationInfoService.get(null).name, consulClient)
    }
?
    install(DefaultHeaders)
    install(Compression)
    install(CallLogging)
    install(ContentNegotiation) {
        jackson {}
    }
?
    routing {
        route("application-info") {
            get {
                val requestTo: String? = call.parameters["request-to"]
                call.respond(applicationInfoService.get(requestTo))
            }
            static {
                resource("/logo", "logo.png")
            }
        }
    }
}

此代碼是配置請求的路由，特別是靜態資源logo.png，

下面是基于Round-robin演算法結合客戶端負載均衡實作服務發現模式的代碼：

class ConsulFeature(private val consulClient: Consul) {
?
    class Config {
        lateinit var consulClient: Consul
    }
?
    companion object Feature : HttpClientFeature<Config, ConsulFeature> {
        var serviceInstanceIndex: Int = 0
?
        override val key = AttributeKey<ConsulFeature>("ConsulFeature")
?
        override fun prepare(block: Config.() -> Unit) = ConsulFeature(Config().apply(block).consulClient)
?
        override fun install(feature: ConsulFeature, scope: HttpClient) {
            scope.requestPipeline.intercept(HttpRequestPipeline.Render) {
                val serviceName = context.url.host
                val serviceInstances =
                    feature.consulClient.healthClient().getHealthyServiceInstances(serviceName).response
                val selectedInstance = serviceInstances[serviceInstanceIndex]
                context.url.apply {
                    host = selectedInstance.service.address
                    port = selectedInstance.service.port
                }
                serviceInstanceIndex = (serviceInstanceIndex + 1) % serviceInstances.size
            }
        }
    }
}

主要邏輯在install方法中：在Render請求階段（在Send階段之前執行）首先確定被呼叫服務的名稱，然后consulClient請求服務的實體串列，然后通過回圈演算法定義一個實體正在呼叫，因此，以下呼叫成為可能：

fun getApplicationInfo(serviceName: String): ApplicationInfo = runBlocking {
    httpClient.get<ApplicationInfo>("http://$serviceName/application-info")
}

Micronaut 服務

Micronaut 由Grails框架的創建者開發，靈感來自使用 Spring、Spring Boot 和 Grails 構建服務的經驗，該框架目前支持 Java、Kotlin 和 Groovy 語言，依賴是在編譯時注入的，與 Spring Boot 相比，這會導致更少的記憶體消耗和更快的應用程式啟動，

主類如下所示：

object MicronautServiceApplication {
?
    @JvmStatic
    fun main(args: Array<String>) {
        Micronaut.build()
            .packages("io.heterogeneousmicroservices.micronautservice")
            .mainClass(MicronautServiceApplication.javaClass)
            .start()
    }
}

基于 Micronaut 的應用程式的某些組件與它們在 Spring Boot 應用程式中的對應組件類似，例如，以下是控制器代碼：

@Controller(
    value = "https://www.cnblogs.com/application-info",
    consumes = [MediaType.APPLICATION_JSON],
    produces = [MediaType.APPLICATION_JSON]
)
class ApplicationInfoController(
    private val applicationInfoService: ApplicationInfoService
) {
?
    @Get
    fun get(requestTo: String?): ApplicationInfo = applicationInfoService.get(requestTo)
?
    @Get("/logo", produces = [MediaType.IMAGE_PNG])
    fun getLogo(): ByteArray = applicationInfoService.getLogo()
}

Micronaut 中對 Kotlin 的支持建立在kapt編譯器插件的基礎上（參考Micronaut Kotlin 指南了解更多詳細資訊），

構建腳本配置如下：

plugins {
    ...
    kotlin("kapt")
    ...
}
?
dependencies {
    kapt("io.micronaut:micronaut-inject-java:$micronautVersion")
    ...
    kaptTest("io.micronaut:micronaut-inject-java:$micronautVersion")
    ...
}

以下是組態檔的內容：

micronaut:
  application:
    name: micronaut-service
  server:
    port: 8083
?
consul:
  client:
    registration:
      enabled: true
?
application-info:
  name: ${micronaut.application.name}
  framework:
    name: Micronaut
    release-year: 2018

JSON、properties和 Groovy 檔案格式也可用于配置（參考Micronaut 配置指南查看更多詳細資訊），

Quarkus服務

Quarkus是作為一種應對新部署環境和應用程式架構等挑戰的工具而引入的，在框架上撰寫的應用程式將具有低記憶體消耗和更快的啟動時間，此外，對開發人員也很友好，例如，開箱即用的實時重新加載，

Quarkus 應用程式目前沒有 main 方法，但也許未來會出現（GitHub 上的問題），

對于熟悉 Spring 或 Java EE 的人來說，Controller 看起來非常熟悉：

@Path("/application-info")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
class ApplicationInfoResource(
    @Inject private val applicationInfoService: ApplicationInfoService
) {
?
    @GET
    fun get(@QueryParam("request-to") requestTo: String?): Response =
        Response.ok(applicationInfoService.get(requestTo)).build()
?
    @GET
    @Path("/logo")
    @Produces("image/png")
    fun logo(): Response = Response.ok(applicationInfoService.getLogo()).build()
}

如你所見，bean 是通過@Inject注解注入的，對于注入的 bean，你可以指定一個范圍，例如：

@ApplicationScoped
class ApplicationInfoService(
    ...
) {
...
}

為其他服務創建 REST 介面，就像使用 JAX-RS 和 MicroProfile 創建介面一樣簡單：

@ApplicationScoped
@Path("/")
interface ExternalServiceClient {
    @GET
    @Path("/application-info")
    @Produces("application/json")
    fun getApplicationInfo(): ApplicationInfo
}
?
@RegisterRestClient(baseUri = "http://helidon-service")
interface HelidonServiceClient : ExternalServiceClient
?
@RegisterRestClient(baseUri = "http://ktor-service")
interface KtorServiceClient : ExternalServiceClient
?
@RegisterRestClient(baseUri = "http://micronaut-service")
interface MicronautServiceClient : ExternalServiceClient
?
@RegisterRestClient(baseUri = "http://quarkus-service")
interface QuarkusServiceClient : ExternalServiceClient
?
@RegisterRestClient(baseUri = "http://spring-boot-service")
interface SpringBootServiceClient : ExternalServiceClient

但是它現在缺乏對服務發現 ( Eureka和Consul ) 的內置支持，因為該框架主要針對云環境，因此，在 Helidon 和 Ktor 服務中， 我使用了Java類別庫方式的Consul 客戶端，

首先，需要注冊應用程式：

@ApplicationScoped
class ConsulRegistrationBean(
    @Inject private val consulClient: ConsulClient
) {
?
    fun onStart(@Observes event: StartupEvent) {
        consulClient.register()
    }
}

然后需要將服務的名稱決議到其特定位置；

決議是通過從 Consul 客戶端獲得的服務的位置替換 requestContext的URI 來實作的：

@Provider
@ApplicationScoped
class ConsulFilter(
    @Inject private val consulClient: ConsulClient
) : ClientRequestFilter {
?
    override fun filter(requestContext: ClientRequestContext) {
        val serviceName = requestContext.uri.host
        val serviceInstance = consulClient.getServiceInstance(serviceName)
        val newUri: URI = URIBuilder(URI.create(requestContext.uri.toString()))
            .setHost(serviceInstance.address)
            .setPort(serviceInstance.port)
            .build()
?
        requestContext.uri = newUri
    }
}

Quarkus也支持通過properties 或 YAML 檔案進行配置（參考Quarkus 配置指南了解更多詳細資訊），

Spring Boot服務

創建該框架是為了使用 Spring Framework 生態系統，同時有利于簡化應用程式的開發，這是通過auto-configuration實作的，

Spring Boot 基礎就不介紹了，推薦下這個實戰教程：
https://github.com/javastacks/javastack

以下是控制器代碼：

@RestController
@RequestMapping(path = ["application-info"], produces = [MediaType.APPLICATION_JSON_VALUE])
class ApplicationInfoController(
    private val applicationInfoService: ApplicationInfoService
) {
?
    @GetMapping
    fun get(@RequestParam("request-to") requestTo: String?): ApplicationInfo = applicationInfoService.get(requestTo)
?
    @GetMapping(path = ["/logo"], produces = [MediaType.IMAGE_PNG_VALUE])
    fun getLogo(): ByteArray = applicationInfoService.getLogo()
}

微服務由 YAML 檔案配置：

spring:
  application:
    name: spring-boot-service
?
server:
  port: 8085
?
application-info:
  name: ${spring.application.name}
  framework:
    name: Spring Boot
    release-year: 2014

也可以使用properties檔案進行配置（更多資訊參考Spring Boot 配置檔案），

啟動微服務

在啟動微服務之前，你需要安裝Consul和 啟動代理-例如，像這樣：consul agent -dev，

你可以從以下位置啟動微服務：

IDE中啟動微服務IntelliJ IDEA 的用戶可能會看到如下內容：

要啟動 Quarkus 服務，你需要啟動quarkusDev的Gradle 任務，

console中啟動微服務在專案的根檔案夾中執行：

java -jar helidon-service/build/libs/helidon-service-all.jar

java -jar ktor-service/build/libs/ktor-service-all.jar

java -jar micronaut-service/build/libs/micronaut-service-all.jar

java -jar quarkus-service/build/quarkus-service-1.0.0-runner.jar

java -jar spring-boot-service/build/libs/spring-boot-service.jar

啟動所有微服務后，訪問http://localhost:8500/ui/dc1/services，你將看到：

API測驗

以Helidon服務的API測驗結果為例：

GET http://localhost:8081/application-info

{
  "name": "helidon-service",
  "framework": {
    "name": "Helidon SE",
    "releaseYear": 2019
  },
  "requestedService": null
}

GET http://localhost:8081/application-info?request-to=ktor-service

{
  "name": "helidon-service",
  "framework": {
    "name": "Helidon SE",
    "releaseYear": 2019
  },
  "requestedService": {
    "name": "ktor-service",
    "framework": {
          "name": "Ktor",
          "releaseYear": 2018
    },
    "requestedService": null
  }
}

GET http://localhost:8081/application-info/logo回傳logo資訊

你可以使用Postman 、IntelliJ IDEA HTTP 客戶端 、瀏覽器或其他工具測驗微服務的 API介面 ，

不同微服務框架對比

不同微服務框架的新版本發布后，下面的結果可能會有變化；你可以使用此GitHub專案自行檢查最新的對比結果 ，

程式大小

為了保證設定應用程式的簡單性，構建腳本中沒有排除傳遞依賴項，因此 Spring Boot 服務 uber-JAR 的大小大大超過了其他框架上的類似物的大小（因為使用 starters 不僅匯入了必要的依賴項；如果需要，可以通過排除指定依賴來減小大小）：

備注：什么是 maven的uber-jar

在maven的一些檔案中我們會發現 “uber-jar”這個術語，許多人看到后感到困惑，其實在很多編程語言中會把super叫做uber （因為super可能是關鍵字）， 這是上世紀80年代開始流行的，比如管superman叫uberman，所以uber-jar從字面上理解就是super-jar，這樣的jar不但包含自己代碼中的class ，也會包含一些第三方依賴的jar，也就是把自身的代碼和其依賴的jar全打包在一個jar里面了，所以就很形象的稱其為super-jar ，uber-jar來歷就是這樣的，

啟動時長

每個應用程式的啟動時長都是不固定的：

值得注意的是，如果你將 Spring Boot 中不必要的依賴排除，并注意設定應用的啟動引數（例如，只掃描必要的包并使用 bean 的延遲初始化），那么你可以顯著地減少啟動時間，

記憶體使用情況

對于每個微服務，確定了以下內容：

• 通過-Xmx引數，指定微服務所需的堆記憶體大小
• 通過負載測驗服務健康的請求(能夠回應不同的請求)
• 通過負載測驗50 個用戶 * 1000 個的請求
• 通過負載測驗500 個用戶 * 1000 個的請求

堆記憶體只是為應用程式分配的總記憶體的一部分，例如，如果要測量總體記憶體使用情況，可以參考本指南，

對于負載測驗，使用了Gatling和Scala腳本 ，

1、負載生成器和被測驗的服務在同一臺機器上運行（Windows 10、3.2 GHz 四核處理器、24 GB RAM、SSD），

2、服務的埠在 Scala 腳本中指定，

3、通過負載測驗意味著微服務已經回應了所有時間的所有請求，

需要注意的是，所有微服務都使用 Netty HTTP 服務器，

結論

通過上文，我們所需的功能——一個帶有 HTTP API 的簡單服務和在 MSA 中運行的能力——在所有考慮的框架中都取得了成功，

是時候開始盤點并考慮他們的利弊了，

Helidon標準版

優點

創建的應用程式，只需要一個注釋（@JvmStatic）

缺點

開發所需的一些組件缺少開箱即用（例如，依賴注入和與服務發現服務器的互動）

Helidon MicroProfile

微服務還沒有在這個框架上實作，所以這里簡單說明一下，

優點

1、Eclipse MicroProfile 實作

2、本質上，MicroProfile 是針對 MSA 優化的 Java EE，因此，首先你可以訪問各種 Java EE API，包括專門為 MSA 開發的 API，其次，你可以將 MicroProfile 的實作更改為任何其他實作（例如：Open Liberty、WildFly Swarm 等）

Ktor

優點

1、輕量級的允許你僅添加執行任務直接需要的那些功能

2、應用引數所有引數的良好結果

缺點

1、依賴于Kotlin，即用其他語言開發可能是不可能的或不值得的

2、微框架：參考Helidon SE

3、目前最流行的兩種 Java 開發模型（Spring Boot/Micronaut）和 Java EE/MicroProfile）

4、中沒有包含該框架，這會導致：

• 難以尋找專家

• 由于需要顯式配置所需的功能，因此與 Spring Boot 相比，執行任務的時間有所增加

Micronaut

優點

1、AOT如前所述，與 Spring Boot 上的模擬相比，AOT 可以減少應用程式的啟動時間和記憶體消耗

2、類Spring開發模式有 Spring 框架經驗的程式員不會花太多時間來掌握這個框架

3、Micronaut for Spring可以改變現有的Spring Boot應用程式的執行環境到Micronaut中（有限制）

Quarkus

優點

1、Eclipse MicroProfile 的實作

2、該框架為多種 Spring 技術提供了兼容層：DI、 Web、Security、Data JPA

Spring Boot

優點

1、平臺成熟度和生態系統對于大多數日常任務，Spring的編程范式已經有了解決方案，也是很多程式員習慣的方式，此外，starter和auto-configuration的概念簡化了開發

2、專家多，檔案詳細

我想很多人都會同意 Spring 在不久的將來仍將是 Java/Kotlin開發領域領先的框架，

缺點

• 應用引數多且復雜但是，有些引數，如前所述，你可以自己優化，還有一個Spring Fu專案的存在，該專案正在積極開發中，使用它可以減少引數，

Helidon SE 和 Ktor 是 微框架，Spring Boot 和 Micronaut 是全堆疊框架，Quarkus 和 Helidon MP 是 MicroProfile 框架，微框架的功能有限，這會減慢開發速度，

我不敢判斷這個或那個框架會不會在近期“大更新”，所以在我看來，目前最好繼續觀察，使用熟悉的框架解決作業問題，

同時，如本文所示，新框架在應用程式引數設定方面贏得了 Spring Boot，如果這些引數中的任何一個對你的某個微服務至關重要，那么也許值得關注，但是，我們不要忘記，Spring Boot 一是在不斷改進，二是它擁有龐大的生態系統，并且有相當多的 Java 程式員熟悉它，此外，還有未涉及的其他框架：Vert.x、Javalin 等，也值得關注，

譯文：https://www.kubernetes.org.cn/9526.html

原文：https://dzone.com/articles/not-only-spring-boot-a-review-of-alternatives

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2022最新版)

2.勁爆！Java 協程要來了，，，

3.Spring Boot 2.x 教程，太全了！

4.別再寫滿屏的爆爆爆炸類了，試試裝飾器模式，這才是優雅的方式！！

5.《Java開發手冊（嵩山版）》最新發布，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！

標籤：Java

上一篇：愛上原始碼，重學Spring MVC深入

下一篇：分布式事務框架 Seata 入門案例