FastAPI (Python) vs Fiber (Go) vs Spring Webflux (Java)

from fastapi import FastAPI, Request
from apps.memo.router import memo_router
import aiomysql.sa

app = FastAPI(
    title="Memo API",
    description="Memo CRUD API project",
    version="0.0.1"
)

@app.on_event("startup")
async def startup():
    app.state.db_pool = await aiomysql.sa.create_engine(
        user="root", password="root", host="127.0.0.1", db="test",
        maxsize         = 50,
        autocommit      = True
    )
    
@app.on_event("shutdown")
async def shutdown():
    app.state.db_pool.close()

@app.middleware("http")
async def state_insert(request: Request, call_next):
    request.state.db_pool   = app.state.db_pool
    request.state.db_conn   = await app.state.db_pool.acquire()
    response                = await call_next(request)
    return response

app.include_router(memo_router)

from typing import List

from aiomysql.sa import SAConnection
from fastapi.param_functions import Depends
from fastapi.requests import Request
from fastapi.routing import APIRouter

from apps.memo.model import memo
from apps.memo.schema import MemoSelect
from apps.memo.schema import MemoCreate

memo_router = APIRouter()


# 디비 쿼리를 위한 종속성 주입을 위한 함수
def get_db_conn(request: Request):
    pool = request.state.db_pool
    db = request.state.db_conn
    try:
        yield db
    finally:
        pool.release(db)


@memo_router.get("/memo/list/{page}", response_model=List[MemoSelect])
async def memo_list(
        page: int = 1,
        limit: int = 10,
        db: SAConnection = Depends(get_db_conn)
):
    offset = (page - 1) * limit
    query = memo.select().offset(offset).limit(limit)
    res = await db.execute(query)
    return await res.fetchall()


@memo_router.post("/memo", response_model=None)
async def memo_write(
    item: MemoCreate,
    db: SAConnection = Depends(get_db_conn)
):
    query = memo.insert().values(
        title=item.title,
        body=item.body
    )
    res = await db.execute(query)
    return {
        "idx": res.lastrowid,
        "title": item.title,
        "body": item.body
    }

from datetime import datetime
from pydantic import BaseModel

# Pydantic을 이용한 Type Hinting
class MemoCreate(BaseModel):
    title : str
    body : str

class MemoSelect(BaseModel):
    idx : int
    regdate : datetime
    title : str
    body : str

package com.example.webfluxapi.controller;

import com.example.webfluxapi.entity.Memo;
import com.example.webfluxapi.service.MemoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("")
@Slf4j
public class MemoController {

    private final MemoService memoService;

    @Autowired
    public MemoController(MemoService memoService) {
        this.memoService = memoService;
    }

    @GetMapping("/memo/list/{page}")
    public Flux<Memo> list(
            @PathVariable("page")
            Integer page,
            @RequestParam(value = "limit", defaultValue = "10")
            Integer limit
    ) {
        return memoService.list(page, limit);
    }

    @PostMapping("/memo")
    public Mono<Memo> create(@RequestBody Memo memo) {
        return memoService.create(memo);
    }
}

package com.example.webfluxapi.entity;

import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;

import java.time.LocalDateTime;

@Table("memo")
@Builder
@Getter
@Setter
public class Memo {
    @Id
    @Column("idx")
    private Integer idx;
    @Column("title")
    private String title;
    @Column("body")
    private String body;
    @Column("regdate")
    private LocalDateTime regdate;
}

package com.example.webfluxapi.repository;

import com.example.webfluxapi.entity.Memo;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;

@Repository
public interface MemoRepository extends ReactiveCrudRepository<Memo, Integer> {
    @Query("SELECT * FROM memo LIMIT :page, :size")
    Flux<Memo> findAllBy(Integer page, Integer size);
}

package com.example.webfluxapi.service;

import com.example.webfluxapi.entity.Memo;
import com.example.webfluxapi.repository.MemoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Service
public class MemoService {

    private final MemoRepository memoRepository;

    @Autowired
    public MemoService(MemoRepository memoRepository) {
        this.memoRepository = memoRepository;
    }

    public Flux<Memo> list(Integer page, Integer size) {
        return memoRepository.findAllBy((page - 1) * size, size);
    }

    public Mono<Memo> create(Memo memo) {
        return memoRepository.save(memo);
    }
}