お題

前回、Python3で書いた簡易ツール「ローカルJSONファイルに保存するキーバリューストア」のGolang版。
シリーズ物としては、もともと複数言語で同じ内容のプログラムを書いて比較した「簡単なツール作成を通して各プログラミング言語を比較しつつ学ぶ」からの改善版。

試行Index

実装・動作確認端末

# 言語バージョン

$ go version
go version go1.11.4 linux/amd64

# IDE - Goland

GoLand 2019.2
Build #GO-192.5728.103, built on July 23, 2019

実践

要件

アプリを起動すると、キーバリュー形式でテキスト情報をJSONファイルに保存する機能を持つコンソールアプリ。
オンメモリで保持していた点だけ除けば第１回と同じ仕様なので詳細は以下参照。
https://qiita.com/sky0621/items/32c87aed41cb1c3c67ff#要件

ソース全量

解説

全ソースファイル

Golangソース	説明
main.go	アプリ起動エントリーポイント
store_info.go	キーバリュー情報を保存するストア(JSONファイル)に関する情報を扱う。現状は「ファイル名」だけ保持
commands.go	キーバリューストアからの情報取得や保存、削除といった各コマンドを管理。コマンドの増減に関する影響は、このソースに閉じる。
command.go	各コマンドに共通のインタフェース
save.go	キーバリュー情報の保存を担う。
get.go	指定キーに対するバリューの取得を担う。
list.go	全キーバリュー情報の取得を担う。
remove.go	指定キーに対するバリューの削除を担う。
clear.go	全キーバリュー情報の削除を担う。
help.go	ヘルプ情報の表示を担う。
end.go	アプリの終了を担う。

[main.go]アプリ起動エントリーポイント

[main.go]

package main

import (
    "bufio"
    "log"
    "os"
    "strings"
)

func main() {
    commands := NewCommands(NewStoreInfo("store.json"))

    println("Start!")
    for {
        s := bufio.NewScanner(os.Stdin)
        for s.Scan() {
            cmds := strings.Split(s.Text(), " ")
            commands.Exec(cmds)
        }
        if s.Err() != nil {
            log.Fatal(s.Err())
        }
    }
}

[store_info.go]ストア情報の管理

[store_info.go]

package main

// アルファベット大文字で始まると定数扱い
const DefaultStoreName = "store.json"

func NewStoreInfo(storeName string) StoreInfo {
    if storeName == "" {
        return &storeInfo{storeName: DefaultStoreName}
    }
    return &storeInfo{storeName: storeName}
}

type StoreInfo interface {
    GetName() string
}

type storeInfo struct {
    storeName string
}

func (s *storeInfo) GetName() string {
    return s.storeName
}

[commands.go]各コマンドの管理

[commands.go]

package main

import (
    "fmt"
    "os"
)

func NewCommands(storeInfo StoreInfo) *Commands {
    _, err := os.Stat(storeInfo.GetName())
    if err != nil {
        NewClearCommand(storeInfo).Exec(nil)
    }
    return &Commands{
        commands: map[string]Command{
            "end":    NewEndCommand(),
            "help":   NewHelpCommand(),
            "clear":  NewClearCommand(storeInfo),
            "save":   NewSaveCommand(storeInfo),
            "get":    NewGetCommand(storeInfo),
            "remove": NewRemoveCommand(storeInfo),
            "list":   NewListCommand(storeInfo),
        },
    }
}

type Commands struct {
    commands map[string]Command
}

func (c *Commands) Exec(cmds []string) {
    if len(cmds) < 1 {
        fmt.Println("no target")
        return
    }

    cmd := c.commands[cmds[0]]
    if cmd == nil {
        fmt.Println("no target")
        return
    }

    if len(cmds) == 1 {
        cmd.Exec(nil)
        return
    }
    cmd.Exec(cmds[1:])
}

[command.go]各コマンドの親クラス

[command.go]

package main

type Command interface {
    Exec(args []string)
}

各コマンドクラス

各コマンドについては、ストア情報がオンメモリのハッシュからJSONに変わった点以外はやることは一緒。（なので説明省く。）

■保存

[save.go]

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "os"
)

func NewSaveCommand(storeInfo StoreInfo) Command {
    return &saveCommand{storeInfo: storeInfo}
}

type saveCommand struct {
    storeInfo StoreInfo
}

func (c *saveCommand) Exec(args []string) {
    if len(args) != 2 {
        fmt.Printf("not valid: %#v\n", args)
        return
    }

    b, err := ioutil.ReadFile(c.storeInfo.GetName())
    if err != nil {
        fmt.Printf("error1: %s\n", err.Error())
        return
    }

    var d map[string]string
    err = json.Unmarshal(b, &d)
    if err != nil {
        fmt.Printf("error2: %s\n", err.Error())
        return
    }
    d[args[0]] = args[1]

    res, err := json.Marshal(d)
    if err != nil {
        fmt.Printf("error3: %s\n", err.Error())
        return
    }

    err = ioutil.WriteFile(c.storeInfo.GetName(), res, os.ModePerm)
    if err != nil {
        fmt.Printf("error4: %s\n", err.Error())
        return
    }
}

■１件取得

[get.go]

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
)

func NewGetCommand(storeInfo StoreInfo) Command {
    return &getCommand{storeInfo: storeInfo}
}

type getCommand struct {
    storeInfo StoreInfo
}

func (c *getCommand) Exec(args []string) {
    if len(args) != 1 {
        fmt.Printf("not valid: %#v\n", args)
        return
    }

    b, err := ioutil.ReadFile(c.storeInfo.GetName())
    if err != nil {
        fmt.Printf("error1: %s\n", err.Error())
        return
    }

    var d map[string]string
    err = json.Unmarshal(b, &d)
    if err != nil {
        fmt.Printf("error2: %s\n", err.Error())
        return
    }
    fmt.Println(d[args[0]])
}

■全件取得

[list.go]

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
)

func NewListCommand(storeInfo StoreInfo) Command {
    return &listCommand{storeInfo: storeInfo}
}

type listCommand struct {
    storeInfo StoreInfo
}

func (c *listCommand) Exec(args []string) {
    b, err := ioutil.ReadFile(c.storeInfo.GetName())
    if err != nil {
        fmt.Printf("error1: %s\n", err.Error())
        return
    }

    var d map[string]string
    err = json.Unmarshal(b, &d)
    if err != nil {
        fmt.Printf("error2: %s\n", err.Error())
        return
    }

    println(`"key","value"`)
    for k, v := range d {
        println("\"" + k + "\",\"" + v + "\"")
    }

}

■１件削除

[remove.go]

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "os"
)

func NewRemoveCommand(storeInfo StoreInfo) Command {
    return &removeCommand{storeInfo: storeInfo}
}

type removeCommand struct {
    storeInfo StoreInfo
}

func (c *removeCommand) Exec(args []string) {
    if len(args) != 1 {
        fmt.Printf("not valid: %#v\n", args)
        return
    }

    b, err := ioutil.ReadFile(c.storeInfo.GetName())
    if err != nil {
        fmt.Printf("error1: %s\n", err.Error())
        return
    }

    var d map[string]string
    err = json.Unmarshal(b, &d)
    if err != nil {
        fmt.Printf("error2: %s\n", err.Error())
        return
    }
    delete(d, args[0])

    res, err := json.Marshal(d)
    if err != nil {
        fmt.Printf("error3: %s\n", err.Error())
        return
    }

    err = ioutil.WriteFile(c.storeInfo.GetName(), res, os.ModePerm)
    if err != nil {
        fmt.Printf("error4: %s\n", err.Error())
        return
    }
}

■全件削除

[clear.go]

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "os"
)

func NewClearCommand(storeInfo StoreInfo) Command {
    return &clearCommand{storeInfo: storeInfo}
}

type clearCommand struct {
    storeInfo StoreInfo
}

func (c *clearCommand) Exec(args []string) {
    _, err := os.Create(c.storeInfo.GetName())
    if err != nil {
        fmt.Printf("error1: %s\n", err.Error())
        return
    }

    d := make(map[string]string, 1)
    b, err := json.Marshal(&d)
    if err != nil {
        fmt.Printf("error2: %s\n", err.Error())
        return
    }

    err = ioutil.WriteFile(c.storeInfo.GetName(), b, os.ModePerm)
    if err != nil {
        fmt.Printf("error3: %s\n", err.Error())
        return
    }
}

■ヘルプ

[help.go]

package main

func NewHelpCommand() Command {
    return &helpCommand{}
}

type helpCommand struct {
}

func (c *helpCommand) Exec(args []string) {
    msg := `

[usage]
キーバリュー形式で文字列情報を管理するコマンドです。
以下のサブコマンドが利用可能です。

list   ... 保存済みの内容を一覧表示します。
save   ... keyとvalueを渡して保存します。
get    ... keyを渡してvalueを表示します。
remove ... keyを渡してvalueを削除します。
endCommand   ... ヘルプ情報（当内容と同じ）を表示します。

`
    println(msg)
}

■アプリ終了

[end.go]

package main

import (
    "fmt"
    "os"
)

func NewEndCommand() Command {
    return &endCommand{}
}

type endCommand struct {
}

func (c *endCommand) Exec(args []string) {
    fmt.Println("End!")
    os.Exit(-1)
}

まとめ

同じことを複数言語で実装するの、だんだんしんどくなってきたな・・・。