微服务框架：如果不用Spring Boot，还可以选择谁（微服务不用docker）

　　本篇文章为你整理了微服务框架：如果不用Spring Boot，还可以选择谁（微服务不用docker）的详细内容，包含有微服务不需要tomcat 微服务不用docker 微服务除了springcloud 微服务用什么框架微服务框架：如果不用Spring Boot，还可以选择谁，希望能帮助你了解微服务框架：如果不用Spring Boot，还可以选择谁。

　　使用服务发现模式（在Consul中注册，通过客户端负载均衡的名称请求另一个微服务的HTTP API）

　　构建一个 uber-JAR

　　
从头开始创建应用程序

　　要基于其中一个框架上生成新项目，你可以使用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 {

　　 framework {

　　 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 {

　　 framework {

　　 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 = "/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:

　　 server:

　　 port: 8083

　　consul:

　　 client:

　　 registration:

　　 enabled: true

　　application-info:

　　 framework:

　　 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实现的。

　　以下是控制器代码：

@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:

　　server:

　　 port: 8085

　　application-info:

　　 framework:

　　 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脚本。

　　
负载生成器和被测试的服务在同一台机器上运行（Windows 10、3.2 GHz 四核处理器、24 GB RAM、SSD）。

　　服务的端口在 Scala 脚本中指定。

　　通过负载测试意味着微服务已经响应了所有时间的所有请求。

　　
通过上文，我们所需的功能——一个带有 HTTP API 的简单服务和在 MSA 中运行的能力——在所有考虑的框架中都取得了成功。

　　是时候开始盘点并考虑他们的利弊了。

　　Helidon标准版

　　创建的应用程序，只需要一个注释（@JvmStatic）

　　开发所需的一些组件缺少开箱即用（例如，依赖注入和与服务发现服务器的交互）

　　Helidon MicroProfile

　　微服务还没有在这个框架上实现，所以这里简单说明一下。

　　Eclipse MicroProfile 实现

　　本质上，MicroProfile 是针对 MSA 优化的 Java EE。因此，首先你可以访问各种 Java EE API，包括专门为 MSA 开发的 API，其次，你可以将 MicroProfile 的实现更改为任何其他实现（例如：Open Liberty、WildFly Swarm 等）

　　
目前最流行的两种 Java 开发模型（Spring Boot/Micronaut）和 Java EE/MicroProfile）中没有包含该框架，这会导致：

　　难以寻找专家

　　由于需要显式配置所需的功能，因此与 Spring Boot 相比，执行任务的时间有所增加

　　
AOT如前所述，与 Spring Boot 上的模拟相比，AOT 可以减少应用程序的启动时间和内存消耗

　　类Spring开发模式有 Spring 框架经验的程序员不会花太多时间来掌握这个框架

　　
Micronaut for Spring可以改变现有的Spring Boot应用程序的执行环境到Micronaut中（有限制）

　　
平台成熟度和生态系统对于大多数日常任务，Spring的编程范式已经有了解决方案，也是很多程序员习惯的方式。此外，starter和auto-configuration的概念简化了开发

　　专家多，文档详细

　　
我想很多人都会同意 Spring 在不久的将来仍将是 Java/Kotlin开发领域领先的框架。

　　应用参数多且复杂但是，有些参数，如前所述，你可以自己优化。还有一个Spring Fu项目的存在，该项目正在积极开发中，使用它可以减少参数。

　　Helidon SE 和 Ktor 是微框架，Spring Boot 和 Micronaut 是全栈框架，Quarkus 和 Helidon MP 是 MicroProfile 框架。微框架的功能有限，这会减慢开发速度。

　　我不敢判断这个或那个框架会不会在近期“大更新”，所以在我看来，目前最好继续观察，使用熟悉的框架解决工作问题。

　　同时，如本文所示，新框架在应用程序参数设置方面赢得了 Spring Boot。如果这些参数中的任何一个对你的某个微服务至关重要，那么也许值得关注。但是，我们不要忘记，Spring Boot 一是在不断改进，二是它拥有庞大的生态系统，并且有相当多的 Java 程序员熟悉它。此外，还有未涉及的其他框架：Vert.x、Javalin 等，也值得关注。

　　参考链接: https://dzone.com/articles/not-only-spring-boot-a-review-of-alternatives

　　
#1Contact him for any type of hacking, he is a professional hacker that specializes in exposing cheating spouses, and every other hacking related issues. he is a cyber guru, he helps catch cheating spouses by hacking their communications like call, Facebook, text, emails, Skype, whats-app and many more. I have used this service before and he did a very good job, he gave me every proof I needed to know that my fiancee was cheating. You can contact him on his email to help you catch your cheating spouse, or for any other hacking related problems, like hacking websites, bank statement, grades and many more. he will definitely help you, he has helped a lot of people, contact him on, Henryclarkethicalhacker@gmail.com, and you can Text/Call WhatsApp: +1 (262)-236-7526, and figure out your relationship status. I wish you the best.

　　Lucy Janet4个月前 (11-13)回复

　　
Kubernetes 1.18 版本我们很高兴宣布Kubernetes 1.18的交付，这是我们2020年的第一版！Kubernetes 1.18包含38个增强功能：其中15个功能已趋于稳定，beta版本中有11个，alpha版本中有12个。

　　最新文章Affair is actually a well-known you to definitely focuses on informal intercourse dating and you will most other kinks2023-03-21评论()

　　Mexican Adult dating sites: How to avoid Frauds?2023-03-20评论()

　　Dictate of Social networking into Instructional Overall performance off Pupils when you look at the Government College regarding Studies Omuku Canals Condition, Nigeria2023-03-20评论()

　　10 Best Payday cash Improves for Bad credit2023-03-20评论()

　　热门推荐你的微服务还差个容错机制2020-03-26

　　Kubernetes 1.18GA，15个稳定11个beta，引入kubectl debug命令2020-03-26

　　英国Monzo银行，用K8s管理1600个微服务实践2020-03-21

　　Java vs. Go 微服务负载测试 (复赛)2020-03-20

　　与时俱进为什么要使用云原生数据库？2020-03-15

　　2020年Service Mesh 三大发展方向2019-12-13

　　社区标签BoCloud博云

　　CI/CD

　　CNCF

　　DevOps

　　Docker

　　Dubbo

　　Helm

　　Istio

　　JAVA

　　Jenkins

　　k8s代码解读

　　kubeadm

　　Kubernetes

　　Kubernetes1.5

　　Kubernetes1.6

　　Kubernetes1.7

　　Kubernetes1.9

　　PaaS

　　Prometheus

　　Rainbond

　　Rancher

　　Serverless

　　service mesh

　　Spring Cloud

　　中间件

　　云原生

　　云计算

　　企业案例

　　存储

　　安全

　　容器

　　容器云

　　开源

　　微服务

　　日志

　　架构

　　灵雀云

　　监控

　　程序员

　　网络

　　边缘计算

　　运维

　　阿里云

　　阿里巴巴

　　Kubernetes 版本资讯Kubernetes v1.21 正式版已发布

　　Kubernetes v1.18 正式版已发布

　　Kubernetes v1.17 正式版已发布

　　Kubernetes v1.16 正式版已发布

　　Kubernetes v1.15 正式版已发布

　　最新评论 Jonathan Reynolds 10小时前说：
I want to advice everyone here ,please be careful when choosing a broker or Account manager to inves Lynn Kidd 12小时前说：
I lost my MacBook some time ago alongside my i phone, in that process all my crypto wallet accounts James 12小时前说：
I highly recommend this fair recovery services of Gavin ray, did a fantastic job by recovering my li James 12小时前说：
I highly recommend this fair recovery services of Gavin ray, did a fantastic job by recovering my li James 12小时前说：
I highly recommend this fair recovery services of Gavin ray, did a fantastic job by recovering my li Freddie Martins 15小时前说：
They are heartless scammers, they ruined my life, by making me develop interest to invest my hard ea Brett Cusack 18小时前说：
My name is Lovisa from Sweden, Am here to testify how my relationship was restored back by the great Gunter Stefan 19小时前说：
I saw an opportunity to invest in cryptocurrency about two months ago and I took my chance. I contac Christiane Cahue 23小时前说：
I had access to 6 different phones belonging to my workers who were planning to steal over $120,000 Clara James 23小时前说：
REAL LOVE SPELL CASTER PRIEST WISDOM THAT HELP ME SAVE MY RELATIONSHIP.TEXT OR ADD HIM UP ON WHATSAP

　　以上就是微服务框架：如果不用Spring Boot，还可以选择谁（微服务不用docker）的详细内容，想要了解更多微服务框架：如果不用Spring Boot，还可以选择谁的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读