モバイル開発のためのGo: サーバーサイド、API、ユーティリティ

Goとは？

Go はガベージコレクションによる自動メモリ管理を備えた静的型付けコンパイル言語です。Goの主な目標：高速コンパイル、コードのシンプルさ、組み込みの並行処理サポート。Goは仮想マシンなしでネイティブバイナリにコンパイルされます — 1つの実行ファイルに依存関係も含めてすべてが含まれます。

Goの標準ライブラリはHTTPサーバー、JSONマーシャリング、コマンドラインフラグ解析、暗号化、データベース操作をカバーしています。HTTPサーバーに外部フレームワークは不要です — net/httpが組み込まれています。Go Modules（v1.16以降）が標準の依存関係管理システムです。現在のバージョンはGo 1.23（2025）で、イテレータ向けに改良されたiterパッケージを備えています。

GoはGoogleが直面したスケーリング問題を解決するために設計されました：遅いC++コンパイル、Javaの複雑さ、非効率なPythonの並行処理。その結果、Docker、Kubernetes、Prometheus、Terraform、Hugoを動かす言語が生まれました。

Goの構文

Goはミニマリストです：25個のキーワード（C++は84個）。クラス、継承、ジェネリクス（v1.18まで）、演算子オーバーロード、例外はありません。エラーはerr戻り値で明示的に処理します。構造体とインターフェースがOOPの代わりになります。

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

type User struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
}

func userHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	user := User{ID: 1, Name: "Alice", Email: "alice@example.com"}
	json.NewEncoder(w).Encode(user)
}

func main() {
	http.HandleFunc("/api/user", userHandler)
	fmt.Println("Server on :8080")
	http.ListenAndServe(":8080", nil)
}

JSONタグ付きのUser構造体がシリアライズを定義します。http.HandleFuncがハンドラを登録します。json.NewEncoder(w).Encode(user)が構造体を直接レスポンスにJSONシリアライズします。組み込みHTTPサーバーは自動的に個別のゴルーチンでリクエストを処理します。

Goroutinesとチャネル：Goの並行処理モデル

Goroutines はGoランタイムによって管理される軽量な実行スレッドです。OSスレッド（1～8MBのスタック）とは異なり、ゴルーチンは4KBのスタックで開始し、動的に拡張します。1台のサーバーで10万のゴルーチンを実行できます。ゴルーチンの起動 — go functionName().

チャネル（channels） はゴルーチン間でデータを渡すための型付きキューです。チャネルはmake(chan Type)で作成します。<-演算子がデータを送信し、<-chanが受信します。チャネルはバッファあり（容量指定）とバッファなし（同期）があります。

package main

import (
	"fmt"
	"net/http"
	"time"
)

func fetchURL(url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprintf("Error: %s", err)
		return
	}
	defer resp.Body.Close()
	elapsed := time.Since(start)
	ch <- fmt.Sprintf("%s — %dms", url, elapsed.Milliseconds())
}

func main() {
	urls := []string{"https://google.com", "https://github.com", "https://stackoverflow.com"}
	ch := make(chan string, len(urls))

	for _, url := range urls {
		go fetchURL(url, ch)
	}

	for range urls {
		fmt.Println(<-ch)
	}
}

3つのリクエストがgo fetchURLを通じて並行実行されます。chチャネルが結果を収集します。defer resp.Body.Close()が関数から戻る際のレスポンスクローズを保証します。すべてのゴルーチンがチャネルに送信するためselect {}は使用しません — メインゴルーチンは正確にlen(urls)回読み取ります。

モバイルアプリバックエンドのためのGo

Go はモバイルアプリのバックエンドに最適な言語の1つです。組み込みのHTTP/2とHTTP/3、高速なprotobuf/gRPCシリアライズ、低メモリフットプリントにより、Goは数千のモバイルクライアントにサービスを提供するAPIに理想的です。

人気のフレームワーク：Gin（Express.jsより最大10倍高速）、Echo（ミニマリスト、JWTミドルウェア）、Fiber（Expressスタイル）、Chi（net/http互換）。Ginが最も人気でGitHubで70k以上のスターを獲得。gRPCにはgoogle.golang.org/grpcを使用します。

package main

import (
	"database/sql"
	"log"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	_ "github.com/mattn/go-sqlite3"
)

func main() {
	db, err := sql.Open("sqlite3", "mobile_app.db")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	r := gin.Default()
	r.GET("/api/v1/posts", func(c *gin.Context) {
		type Post struct {
			ID        int       `json:"id"`
			Title     string    `json:"title"`
			CreatedAt time.Time `json:"created_at"`
		}
		rows, _ := db.Query("SELECT id, title, created_at FROM posts ORDER BY created_at DESC LIMIT 20")
		defer rows.Close()

		var posts []Post
		for rows.Next() {
			var p Post
			rows.Scan(&p.ID, &p.Title, &p.CreatedAt)
			posts = append(posts, p)
		}
		c.JSON(http.StatusOK, posts)
	})
	r.Run(":8080")
}

Gin.GETがハンドラ付きでルートを登録します。sql.OpenがSQLiteデータベースを開き、db.Queryがクエリを実行します。c.JSONがpostsスライスをJSON配列にシリアライズします。GET内の無名関数が外部コンテキストからdbをキャプチャします。Ginはパニックを処理し、リクエストをログし、ミドルウェアをサポートします。

GoによるマイクロサービスとAPIゲートウェイ

Go はマイクロサービスアーキテクチャの主要言語です。マイクロサービスあたりの低メモリ消費（15～30MB）により、1台のサーバーで数十のサービスを実行できます。高速起動（ミリ秒）と小さなバイナリサイズ（10～20MB）がコンテナデプロイを簡素化します。

GoのAPIゲートウェイはモバイルアプリから内部サービスへのリクエストを集約します。Goゲートウェイは認証（JWT）、レート制限、ルーティング、キャッシュを処理します。人気の実装：Kong（Goプラグイン付きOpenRestyベース）、Tyk（Go製）、Gin上のカスタムゲートウェイ。

gRPCとprotobuf

gRPC はGoogleのリモートプロシージャコールフレームワークで、シリアライズにProtocol Buffers、トランスポートにHTTP/2を使用します。Goは全言語中で最高のgRPCサポートを備えています。モバイルバックエンドにおいて、gRPCはREST/JSONより5～10倍高いスループットを提供します。

package main

import (
	"context"
	"log"
	"net"

	"google.golang.org/grpc"
	pb "example.com/proto"
)

type server struct {
	pb.UnimplementedUserServiceServer
}

func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.UserResponse, error) {
	return &pb.UserResponse{
		Id:    req.Id,
		Name:  "Alice",
		Email: "alice@example.com",
	}, nil
}

func main() {
	lis, _ := net.Listen("tcp", ":50051")
	s := grpc.NewServer()
	pb.RegisterUserServiceServer(s, &server{})
	log.Fatal(s.Serve(lis))
}

pb.UnimplementedUserServiceServerは.protoファイルからprotocによって生成されたスタブです。server構造体がGetUserメソッドをオーバーライドします。grpc.NewServer()がロギング、認証、メトリクス用のインターセプター付きでサーバーを作成します。

CLIユーティリティと開発者ツールのためのGo

Go はモバイル開発で使用されるCLIユーティリティに最適な言語です。依存関係のない単一の静的バイナリ（約10MB）がmacOS、Linux、Windowsの全プラットフォームで動作します。コンパイルは数秒です。Goユーティリティはインタプリタやランタイムのインストールを必要としません。

モバイルエコシステムにおけるGoツールの例：Migrate（DBマイグレーション）、Kubectl（モバイルバックエンドのKubernetes）、Terraform（インフラストラクチャ）、Prometheus（監視）。開発者はprotoファイルからのモデル生成、設定の検証、マイクロサービスのデプロイ用にGoユーティリティを書きます。

package main

import (
	"flag"
	"fmt"
	"os"
)

func main() {
	project := flag.String("project", "", "Project directory")
	version := flag.String("version", "1.0.0", "App version")
	verbose := flag.Bool("verbose", false, "Verbose output")
	flag.Parse()

	if *project == "" {
		fmt.Println("Usage: deploy --project=path [--version=x.x.x]")
		os.Exit(1)
	}

	if *verbose {
		fmt.Printf("Deploying project %s version %s\n", *project, *version)
	}
	// ここにデプロイロジック
	fmt.Println("Deploy complete")
}

flag.Stringが名前、デフォルト値、説明付きの文字列コマンドラインフラグを定義します。flag.Parse()がos.Argsの引数を解析します。ポインタ*projectは値を取得するためにデリファレンスされます。バイナリはgo build -o deploy deploy.goでビルドされます。

Gomobile：iOSとAndroidのネイティブライブラリにおけるGo

Gomobile はGoコードをネイティブモバイルライブラリにコンパイルするGoogleのツールです。go bind -target=androidがAndroid用の.aarを、go bind -target=iosがiOS用の.xcframeworkを生成します。これにより、共通のビジネスロジックをGoで書き、KotlinやSwiftから呼び出すことができます。

Gomobileの主な使用例：暗号化（カスタム暗号化スキーム）、ネットワーキング（カスタムWebSocketプロトコル）、データ処理（圧縮、エンコーディング、パース）。UIはGoでは書きません — その目的はクロスプラットフォームのネイティブモジュールでC++を置き換えることです。

package mobile

import "crypto/aes"

// EncryptDataはAES-256-GCMでデータを暗号化（.aarにエクスポート）
func EncryptData(key []byte, plaintext []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	ciphertext := make([]byte, len(plaintext))
	block.Encrypt(ciphertext, plaintext)
	return ciphertext, nil
}

func DecryptData(key []byte, ciphertext []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	plaintext := make([]byte, len(ciphertext))
	block.Decrypt(plaintext, ciphertext)
	return plaintext, nil
}

エクスポートされた関数（大文字）はGomobileによってJava/Swiftインターフェースにラップされます。KotlinからはMobile.encryptData(key, plaintext)のように見えます。Gomobileは自動的に型を変換します：[]byte → byte[]（Java）/ Data（Swift）。

バックエンドのためのGo vs Java・Kotlin：比較

Go はサーバー開発においてJavaやKotlinと競合します。主な違い：Goはネイティブバイナリにコンパイルされ、JVMを必要とせず、2～3倍少ないメモリを消費し、ミリ秒で起動します。Javaはエコシステムの成熟度とライブラリの数で優れています。

Goはマイクロサービス、APIゲートウェイ、ツールに選ばれます。Java/Kotlinはリッチなビジネスロジックを持つエンタープライズアプリケーション向け。モバイル開発では、最適な組み合わせは：バックエンドにGo、クライアントにKotlin/Swift。