云原生quarkus框架專案實踐-有解無憂

寫在前面, 不知不覺上篇文章已經是好幾年前了, 回到博客園倍感親切. 總想寫點什么, 發現博客園里關于quarkus的文章不多, 故把自己在專案程序中的點滴整理如下, 希望對您有所幫助.

一、quarkus 是什么?為什么要用quarkus

quarkus是Redhat開源的云原生微服務框架, 相比較成熟的SpringCloud, 為什么要用quarkus?

主要有以下幾點原因：

Spring系列框架臃腫、復雜, 更像是一個全家桶. 而quarkus 簡單、高效, 工具先進
啟動速度, quarkus可以在5秒內啟動, 而spring對于一個golang開發者來說, 這個速度直接無法忍受.
quarkus可以熱編譯, 無需手動編譯和重啟服務, 而Spring的熱編譯..
與其他工具集成, Spring集成了大部分的工具, 但你把DI換成guice試試, quarkus可以很方便的集成工具, 雖然框架本身包含的東西不多
quarkus不依賴tomcat或jetty, 可以編譯為原生應用, 性能大幅提高
quarkus耦合低, 專案結構干凈, 適合使用代碼生成器.

二、創建一個quarkus專案

您可以使用maven或gradle來快速創建一個quarkus專案, 具體方法見quarkus網站, quarkus 只需要創建一個Resource類, 就可以啟動服務. 零配置.

另外：quarkus 對Kotlin支持極為友好, 本文將創建一個使用Kotlin+Gradle的專案. 專案的組態檔: build.gradle.kts內容如下：

plugins{
    java
    kotlin("jvm") version ("1.3.72")
    kotlin("plugin.allopen") version ("1.3.72")
    id("io.quarkus") version("1.4.2.Final")
}
allOpen {
    annotation("javax.enterprise.context.ApplicationScoped")
    annotation("javax.enterprise.context.RequestScoped")
}

repositories {
    maven("http://maven.aliyun.com/nexus/content/groups/public/")
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib"))
    implementation("io.quarkus:quarkus-kotlin:1.4.2.Final")
    implementation("io.quarkus:quarkus-resteasy:1.4.2.Final")
    implementation("io.quarkus:quarkus-resteasy-jsonb:1.4.2.Final")
    testImplementation("io.quarkus:quarkus-junit5:1.4.2.Final")
}
tasks.withType<Test> {
    useJUnitPlatform()
}
// 代碼生成器
tasks.create("generate").doFirst {
    exec{
        workingDir("./tto")
        commandLine("sh","-c","./tto.sh")
    }
}
tasks.withType<JavaCompile>().configureEach {
    options.encoding="utf-8"
    options.compilerArgs = listOf("-Xdoclint:none", "-Xlint:none", "-nowarn")
}

三、配置并啟動專案

您可以創建一個類, 并添加注解：@ApplicationScoped , 作為系統啟動類, 代碼如下：

@ApplicationScoped
class Application {
    fun onStart(@Observes event: StartupEvent?) {
        println("app started..")
    }
}

這并不是必須的, 因為上文提到了, 可能需要集成其他工具. 接著我們創建一個服務如下：

import javax.ws.rs.GET
import javax.ws.rs.Path
import javax.ws.rs.Produces
import javax.ws.rs.core.MediaType

@Path("/hello")
class HelloResource {
    @GET@Path("/{name}")
    @Produces(MediaType.APPLICATION_JSON)
    fun hello(@PathParam("name") name:String): String {
        return "hello ${name}"
    }
}

運行命令啟動服務

gradle quarkusDev

訪問服務

curl http://localhost:8080/hello/jarrysix
> hello jarrysix

三、使用資料源

通過上面的步驟, 我們已能運行quarkus, 接下來我們通過極為簡單的方式來完成資料源的訪問.

首先, 我們需要添加配置：

quarkus.datasource.db-kind=h2
quarkus.datasource.username=username-default
quarkus.datasource.jdbc.url=jdbc:h2:tcp://localhost/mem:default
quarkus.datasource.jdbc.min-size=3
quarkus.datasource.jdbc.max-size=13

創建物體類

@Entity
public class Gift {
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator="giftSeq")
    private Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    private String name;
    public String getName() {
        return name;
    }
}

創建Panachec倉儲類

@ApplicationScoped
public class PersonRepository implements PanacheRepository<Person> {
   // put your custom logic here as instance methodspublic void deletePerson(name:String){
       delete("name",name);
   }
}

在資源類中呼叫倉儲類

@Path("/person")
class HelloResource {
    @Inject
    private lateinit var repo:PersonRepository

    @DELETE@Path("/{name}")
    fun delete(@PathParam("name") name:String): String {
        this.repo.deletePerson(name);
        return "success"
    }
}

當然在實際專案中不建議直接呼叫倉儲, 就這樣我們完成人員洗掉的服務.

三：使用docker打包鏡像

quarkus可以通過GraalVM打包成原生鏡像, 以在生產環境中得到更低的CPU和記憶體占用. 如果您不想本地打包, 可以使用docker鏡像打包為原生應用.

本文為了簡化, 依然使用JVM來運行quarkus, 鏡像構建組態檔如下：

# Quarkus docker image demo
# Version 1.0
# Author : jarrysix(homepage: http://fze.net)
# Date : 2018-04-13 14:40

FROM adoptopenjdk/openjdk14-openj9:alpine-jre

MAINTAINER jarrysix

WORKDIR /data
WORKDIR /app
COPY build/*.jar ./
COPY build/lib ./lib

RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.ustc.edu.cn/g' /etc/apk/repositories && \
    apk add tzdata fontconfig ttf-dejavu && cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

EXPOSE 8080

ENTRYPOINT ["java","-jar *-runner.jar"]

四：使用代碼生成器

因為quarkus的專案結構及對框架和工具依賴較低, 甚至仔細觀察, 專案代碼里大多參考的就是JAVA自帶的工具集. 這樣對我們使用代碼生成器來生成一些格式重復的代碼是相當有利的.

我在生產環境中, 就用生成器來生成quarkus和vue.js的代碼. 極大的減少了作業量. 接下來我們一步一步的創建代碼模板并生成代碼.

注：文中使用的是go撰寫的代碼生成器：tto , 專案主頁: http://github.com/ixre/tto ; 其他工具也可以達到效果

1. 資料物體代碼模板: pojo.java

#!target:java/{{.global.Pkg}}/pojo/{{.table.Title}}Entity.java
package {{pkg "java" .global.Pkg}}.pojo;

import javax.persistence.Basic;
import javax.persistence.Id;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.GenerationType;
import javax.persistence.GeneratedValue;

/** {{.table.Comment}} */
@Entity
@Table(name = "{{.table.Name}}", schema = "{{.table.Schema}}")
public class {{.table.Title}}Entity {
    {{range $i,$c := .columns}}{{$type := type "java" $c.Type}}

    {{if $c.IsPk}}\
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY){{else}}
    @Basic{{end}}
    @Column(name = "{{$c.Name}}"{{if not $c.NotNull}}, nullable = true{{end}} {{if ne $c.Length 0}},length = {{$c.Length}}{{end}})
    private {{$type}} {{$c.Name}};

    /** {{$c.Comment}} */
    public {{$type}} get{{$c.Prop}}() {
        return this.{{$c.Name}};
    }

    public void set{{$c.Prop}}({{$type}} {{$c.Name}}){
        this.{{$c.Name}} = {{$c.Name}};
    }

    {{end}}

    /** 拷貝資料  */
    public {{.table.Title}}Entity copy({{.table.Title}}Entity src){
        {{.table.Title}}Entity dst = new {{.table.Title}}Entity();
        {{range $i,$c := .columns}}
        dst.set{{$c.Prop}}(src.get{{$c.Prop}}());{{end}}
        return dst;
    }
}

2. 倉儲代碼模板: quarkus_repo.kt

#!target:kotlin/{{.global.Pkg}}/repo/{{.table.Title}}JpaRepository.kt.gen
package {{pkg "java" .global.Pkg}}.repo;

import {{pkg "kotlin" .global.Pkg}}.pojo.{{.table.Title}}Entity
import io.quarkus.hibernate.orm.panache.PanacheRepository
import javax.enterprise.context.ApplicationScoped

{{$pkType := type "kotlin" .table.PkType}}
/** {{.table.Comment}}倉儲 */
@ApplicationScoped
class {{.table.Title}}JpaRepository : PanacheRepository<{{.table.Title}}Entity> {

}

3. 服務代碼模板：quarkus_service.kt

#!target:kotlin/{{.global.Pkg}}/service/{{.table.Title}}Service.kt.gen
package {{pkg "java" .global.Pkg}}.service

import {{pkg "java" .global.Pkg}}.pojo.{{.table.Title}}Entity
import {{pkg "java" .global.Pkg}}.repo.{{.table.Title}}JpaRepository
import javax.inject.Inject
import javax.enterprise.inject.Default
import javax.enterprise.context.ApplicationScoped
import net.fze.util.catch
import net.fze.commons.std.Types
import net.fze.commons.std.TypesConv
import net.fze.util.value
import javax.transaction.Transactional

{{$tableTitle := .table.Title}}
{{$pkName := .table.Pk}}
{{$pkProp := lower_title .table.PkProp}}
{{$pkType := type "kotlin" .table.PkType}}
/** {{.table.Comment}}服務  */
@ApplicationScoped
class {{.table.Title}}Service {
    @Inject@field:Default
    private lateinit var repo: {{$tableTitle}}JpaRepository

    fun parseId(id:Any):Long{return TypesConv.toLong(id)}

    /** 根據ID查找{{.table.Comment}} */
    fun findByIdOrNull(id:{{$pkType}}):{{$tableTitle}}Entity?{
        return this.repo.findByIdOptional(this.parseId(id))
    }

    /** 保存{{.table.Comment}} */
    @Transactional
    fun save{{$tableTitle}}(e: {{$tableTitle}}Entity):Error? {
        return catch {
            var dst: {{$tableTitle}}Entity
            if (e.{{$pkProp}} > 0) {
                dst = this.repo.findById(this.parseId(e.{{$pkProp}}))!!
            } else {
                dst = {{$tableTitle}}Entity()
                {{$c := try_get .columns "create_time"}}\
                {{if ne $c nil}}dst.createTime = Types.time.unix().toLong(){{end}}
            }
            {{range $i,$c := exclude .columns $pkName "create_time" "update_time"}}
            dst.{{lower_title $c.Prop}} = e.{{lower_title $c.Prop}}{{end}}\
            {{$c := try_get .columns "update_time"}}
            {{if ne $c nil}}dst.updateTime = Types.time.unix().toLong(){{end}}
            this.repo.persistAndFlush(dst)
            null
        }.error()
    }

    /** 批量保存{{.table.Comment}} */
    @Transactional
    fun saveAll{{$tableTitle}}(entities:Iterable<{{$tableTitle}}Entity>){
        this.repo.persist(entities)
        this.repo.flush()
    }

    /** 洗掉{{.table.Comment}} */
    @Transactional
    fun deleteById(id:{{$pkType}}):Error? {
        return catch {
            this.repo.deleteById(this.parseId(id))
        }.error()
    }

}

4. 資源類代碼模板：restful_resource.kt

#!target:kotlin/{{.global.Pkg}}/resources/{{.table.Title}}Resource.kt.gen
package {{pkg "java" .global.Pkg}}.resources

import {{pkg "java" .global.Pkg}}.pojo.{{.table.Title}}Entity
import {{pkg "java" .global.Pkg}}.service.{{.table.Title}}Service
import {{pkg "java" .global.Pkg}}.component.TinyQueryComponent
import net.fze.commons.std.Result
import net.fze.component.report.DataResult
import javax.inject.Inject
import javax.ws.rs.*
import javax.ws.rs.core.MediaType
import javax.enterprise.context.RequestScoped
import javax.annotation.security.PermitAll

{{$tableTitle := .table.Title}}
{{$pkType := type "kotlin" .table.PkType}}

/* {{.table.Comment}}資源 */
@Path("/{{.table.Name}}")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@RequestScoped
class {{.table.Title}}Resource {
    @Inject private lateinit var service:{{.table.Title}}Service
    @Inject private lateinit var queryComponent: TinyQueryComponent

    /** 獲取{{.table.Comment}} */
    @GET@Path("/{id}")
    @PermitAll
    fun get(@PathParam("id") id:{{$pkType}}): {{.table.Title}}Entity? {
        return service.findByIdOrNull(id)
    }

    /** 創建{{.table.Comment}} */
    @POST
    @PermitAll
    fun create(entity: {{.table.Title}}Entity):Result {
        val err = this.service.save{{.table.Title}}(entity)
        if(err != null)return Result.create(1,err.message)
        return Result.OK
    }

    /** 更新{{.table.Comment}} */
    @PUT@Path("/{id}")
    @PermitAll
    fun save(@PathParam("id") id:{{$pkType}},entity: {{.table.Title}}Entity):Result {
        entity.{{lower_title .table.PkProp}} = id
        val err = this.service.save{{.table.Title}}(entity)
        if(err != null)return Result.create(1,err.message)
        return Result.OK
    }


    /** 洗掉{{.table.Comment}} */
    @DELETE@Path("/{id}")
    @PermitAll
    fun delete(@PathParam("id") id:{{$pkType}}):Result {
        val err = this.service.deleteById(id)
        if(err != null)return Result.create(1,err.message)
        return Result.OK
    }

    /** {{.table.Comment}}串列 */
    @GET
    @PermitAll
    fun list(): List<{{.table.Title}}Entity> {
        return mutableListOf()
    }

    /** {{.table.Comment}}分頁資料 */
    @GET@Path("/paging")
    @PermitAll
    fun paging(@QueryParam("params") params:String,
               @QueryParam("page") page:String,
               @QueryParam("rows") rows:String
    ): DataResult {
        return this.queryComponent.fetchData("default",
                "{{.table.Title}}List", params, page, rows)
    }
}

5. VUE介面檔案代碼模板：api.ts

#!lang:ts＃!name:API和定義檔案
#!target:ts/feature/{{.table.Prefix}}/{{.table.Name}}/api.ts
import request from '@/utils/request'


// {{.table.Comment}}物件
export interface I{{.table.Title}} {
    {{range $i,$c := .columns}}// {{$c.Comment}}
    {{lower_title $c.Prop}}:{{type "ts" $c.Type}}
    {{end}}
}

export const default{{.table.Title}}:()=>I{{.table.Title}}=()=>{
    return {
        {{range $i,$c := .columns}}
        {{lower_title $c.Prop}}:{{default "ts" $c.Type}},{{end}}
    };
}

export const get{{.table.Title}} = (id: any, params: any = {}) =>
    request({
        url: `/{{.table.Name}}/${id}`,
        method: 'get',
        params:{...params}
    })

export const get{{.table.Title}}List = (params: any = {}) =>
    request({
        url: '/{{.table.Name}}',
        method: 'get',
        params:{...params}
    })

export const create{{.table.Title}} = (data: any) =>
    request({
        url: '/{{.table.Name}}',
        method: 'post',
        data
    })

export const update{{.table.Title}} = (id: any, data: any) =>
    request({
        url: `/{{.table.Name}}/${id}`,
        method: 'put',
        data
    })

export const delete{{.table.Title}} = (id: any) =>
    request({
        url: `/{{.table.Name}}/${id}`,
        method: 'delete'
    });

export const batchDelete{{.table.Title}} = (arr: any[]) =>
    request({
        url: '/{{.table.Name}}',
        method: 'delete',
        data:arr
    });


export const getPaging{{.table.Title}} = (page:number,rows:number,params: any) =>
    request({
        url: '/{{.table.Name}}/paging',
        method: 'get',
        params:{page,rows,params}
    })

運行命令將代碼生成到指定位置

gradle generate

五：寫在最后

因作者寫作水平有限, 文中以最精簡的方法介紹了quarkus的應用, 包括生成代碼等騷操作.

示例代碼打包下載地址：quarkus-kotlin-gradle-demo-feature.zip

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/184098.html

標籤：Java

上一篇：Java虛擬機常見記憶體溢位錯誤匯總，Java中常見的坑看了可以少走點彎路

下一篇：redis的快取穿透、雪崩、擊穿