Iris（Go言語フレームワーク）の使い方を最速でマスターする

$ go version
go version go1.17.6

// 新規フォルダ作成（既存フォルダにダウンロードする際は不要）
$ mkdir myapp 

// Iris をダウンロードしたいフォルダに移動
$ cd myapp

// go mod 初期化
$ go mod init myapp

// Irisのパッケージ取得
$ go get github.com/kataras/iris/v12@master
// go のバージョンが 1.17 以降
$ go install github.com/kataras/iris/v12@latest

package main

import "github.com/kataras/iris/v12"

func main() {
    app := iris.New()

    app.Handle("GET", "/", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"message": "ping"})
    })
	
    app.Listen(":8080")
}

package main

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

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, q *http.Request) {
        message := map[string]string{
            "message": "ping",
        }
        jsonMessage, err := json.Marshal(message)
        if err != nil {
            panic(err.Error())
        }
        w.Write(jsonMessage)
    })
    http.ListenAndServe("127.0.0.1:8080", mux)
}

// Context is the midle-man server's "object" dealing with incoming requests.
//
// A New context is being acquired from a sync.Pool on each connection.
// The Context is the most important thing on the iris's http flow.
//
// Developers send responses to the client's request through a Context.
// Developers get request information from the client's request a Context.
type Context struct {
    // the http.ResponseWriter wrapped by custom writer.
    writer ResponseWriter
    // the original http.Request
    request *http.Request
    // the current route registered to this request path.
    currentRoute RouteReadOnly

    // the local key-value storage
    params RequestParams  // url named parameters.
    values memstore.Store // generic storage, middleware communication.
    query  url.Values     // GET url query temp cache, useful on many URLParamXXX calls.
    // the underline application app.
    app Application
    // the route's handlers
    handlers Handlers
    // the current position of the handler's chain
    currentHandlerIndex int
    // proceeded reports whether `Proceed` method
    // called before a `Next`. It is a flash field and it is set
    // to true on `Next` call when its called on the last handler in the chain.
    // Reports whether a `Next` is called,
    // even if the handler index remains the same (last handler).
    //
    // Also it's responsible to keep the old value of the last known handler index
    // before StopExecution. See ResumeExecution.
    proceeded int
    
    // if true, caller is responsible to release the context (put the context to the pool).
    manualRelease bool
}

Request -> Route Parser -> Middleware -> Route Handler -> Middleware -> Response

package main

import (
    "net/http"

    "github.com/kataras/iris/v12"
)

func main() {
    app := iris.New()

    // こんな感じで
    // 実装の前の部分で使用！！！！！
    app.WrapRouter(routerWrapper)
    app.UseRouter(routerMiddleware)
    app.UseGlobal(globalMiddleware)
    app.Use(useMiddleware)
    app.UseError(errorMiddleware)
    app.Done(done)
    app.DoneGlobal(doneGlobal)

    app.Handle("GET", "/", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"message": "ping"})
    })
    
    // 以下 様々な処理等...

    app.Listen(":8080")
}

myapp
|- public
|- |- books
|- |- |- list.html
|- |- |- purchase.html
|- go.mod
|- main.go

package main

import "github.com/kataras/iris/v12"

func main()  {
    app := iris.New()
    
    // "public" ディレクトリ配下の ".htmlファイル" を返却するように設定
    // 上書きされバグが潜む可能性があるため基本的には一度だけ設定するようにし，
    // 指定したディレクトリ（今回は "public"）配下にディレクトリを増やしていくようにする
    app.RegisterView(iris.HTML("/public", ".html"))
    
    // GET: "/"
    app.Get("/", func(ctx iris.Context) {
        // 返却するviewファイルの指定（"/public" フォルダからのパス）
        ctx.View("index.html")
    })

    // "/books/"から始まるURLを受け取った際の処理をグループ化
    books := app.Party("/books")
    {
        // GET: "/books/"
        books.Get("/", func(ctx iris.Context) {
            // "/public" フォルダからのパスで指定
            ctx.View("/books/list.html")
        })
        // GET: "/books/buy"
        books.Get("/buy", func(ctx iris.Context) {
            // "/public" フォルダからのパスで指定
            ctx.View("/books/purchase.html")
        })
    }
    
    app.Listen(":8080")
}

package main

import "github.com/kataras/iris/v12"

func main()  {
    app := iris.New()
    
    // 静的ファイルの表示
    // "public" フォルダ以下のファイルが表示される
    app.HandleDir("/", iris.Dir("/public"))
    
    // 以下 様々な処理等...
    
    app.Listen(":8080")
}

const maxSize = 8 * iris.MB

func main() {
    app := iris.Default()

    app.Post("/upload", func(ctx iris.Context) {
        // ファイルの最大容量はあらかじめ決めておいてもいいかもしれません
        ctx.SetMaxRequestBodySize(maxSize)
        // 👆 はミドルウェアでも指定できます
        // app.Use(iris.LimitRequestBodySize(maxSize))
        // または
        // iris.WithPostMaxMemory(maxSize) なども

        file, fileHeader, err:= ctx.FormFile("file")
        if err != nil {
            ctx.StopWithError(iris.StatusBadRequest, err)
            return
        }
		    
        // 保存先を作っておく
        // ここでは "destination" に "./public/ファイル名" というパスが文字列で格納される
        destination := filepath.Join("./public", fileHeader.Filename)
		
        // 保存処理
        ctx.SaveFormFile(fileHeader, destination)
    })

    app.Listen(":8080")
}

package main

import "github.com/kataras/iris/v12"

type MyType struct {
    // "url" タグでクエリ名を指定しています
    Name string `url:"name,required"`
    Age  int    `url:"age"`
}

func main()  {
    app := iris.New()
    
    // GET: "localhost:8080/users?name=tom&?age=19"
    // パターン 1.
    app.Handle("GET", "/users", func(ctx iris.Context) {
        var t MyType
        // クエリがある場合，iris.Context の機能を使って以下のように取得できます
        // ここではクエリから受け取ったデータを構造体（struct）に格納しています
        err := ctx.ReadQuery(&t)
        
        //「t」を使った様々な処理等...
    })
    
    // もちろんメソッドへの切り出しもできます
    app.Handle("GET", "/users", getUser)
    func getUser(ctx iris.Context) {
        // 以下略
    }
    
    
    // パターン 2.
    app.Handle("GET", "/users", func(ctx iris.Context) {
        // iris.Context の機能を使って以下のようにも取得できます
        // "name" と言うクエリを取得し，変数に格納しています
        name, err := c.Ctx.URLParamInt("name")  // name => "Tom"
        
        // 「name」を使った様々な処理等...
    })
    
    app.Listen(":8080")
}

package main

import "github.com/kataras/iris/v12"

func main()  {
    app := iris.New()
    
    // GET: "localhost:8080/users/123（IDなど）"
    // パターン 1.
    app.Handle("GET", "/users/{id:int}", func(ctx iris.Context) {
        // iris.Context の機能を使ってこのように取得できます
        id, _ := ctx.Params().Get("id")
        
        // 「id」を使った様々な処理等...
    })
    
    // もちろんメソッドへの切り出しもできます
    app.Handle("GET", "/users/{id:int}", getUser)
    func getUser(ctx iris.Context) {
        // 以下略
    }
    
    // パターン 2.
    app.Handlefunc("PUT", "/users/{id:int}", updateUser) 
    func updateUser(id int) response {
        // こう書くだけで，もうパラメータの「id」が引数として取得できています
        // 「id」を使った様々な処理等...
    })
}

example-mvc-api
|- controller
|- |- users
|- |- |- users_controller.go
|- setups
|- |- configure_users_controllers.go  // DI（依存性注入）を行う部分
|- model
|- |- user.go
|- service
|- |- user.go
|- |- init.go
|- go.mod
|- main.go

$ go get github.com/go-sql-driver/mysql
$ go get github.com/go-gorp/gorp

// go 1.17 以降
$ go install github.com/go-sql-driver/mysql@latest
$ go install github.com/go-gorp/gorp@latest

package main

import (
    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/middleware/accesslog"
    "github.com/kataras/iris/v12/middleware/recover"
    "github.com/kataras/iris/v12/mvc"
	
    "go-iris-sample/setups"
)

func main() {
    app := iris.New()

    // ミドルウェアの使用
    app.Use(iris.Compression)
    app.Configure(iris.WithoutBodyConsumptionOnUnmarshal)
	
    // ログ記録（これも備え付きミドルウェア）
    ac := accesslog.File("./access.log")
    defer ac.Close()
    app.UseRouter(ac.Handler)
    app.UseRouter(recover.New())

    // "/users/"から始まるURLを受け取った際の処理をグループ化
    users := app.Party("/users")
    mvc.Configure(users, setups.ConfigureUsersControllers)

    // ポートの指定
    app.Listen(":8080")
}

import (
    "github.com/kataras/iris/v12/middleware/accesslog"
    "github.com/kataras/iris/v12/mvc"
    "go-iris-sample/controller/users"
)

// ConfigureUsersControllers
// main.go で定義したURLのグループを表す変数（ここではusers）が引数に入り，
// それに対してDI（依存性注入）を行っている
func ConfigureUsersControllers(app *mvc.Application) {
    // ログを取得してくれる機能のDIもここで行う
    app.Register(accesslog.GetFields)
    
    // URLが "/users" から始まるリクエストを受け取った際に，
    // 以下の Controllerを使用させるという指示
    app.Handle(new(users.UsersController))
}

package users

import (
    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/mvc"
    "go-iris-sample/model"
    "go-iris-sample/service"
)

type UsersController struct {
	UserService service.UserService
	Ctx         iris.Context
}

// メソッド名でパスの違い・リクエストメソッド・パラメータを受け付けます（超便利）
// [例]
// GetList()                GET: "http://localhost:8080/users/list"
// Post()                   POST: "http://localhost:8080/users"
// PutDetails()             PUT: "http://localhost:8080/users/details"
// PutDetailsBy(id uint)    PUT: "http://localhost:8080/users/details/{id:int}"
// DeleteDetails()          DELETE: "http://localhost:8080/users/details"
// DeleteDetailsBy(id uint) DELETE: "http://localhost:8080/users/details/{id:int}"
// [その他の例]
// POST: http://localhost:8080/users/details/example -> PostDetailsExample()
// PUT: http://localhost:8080/users -> Put()

func (c *UsersController) GetList() mvc.Response {
    // 一覧取得
    users, err := c.UserService.GetUserList()
    if err != nil {
        return mvc.Response{
            Code: iris.StatusInternalServerError,  // エラーハンドリング
        }
    }
    
    // Iris に備え付きのレスポンス用構造体（struct）
    return mvc.Response{
        Code:   iris.StatusOK,
        Object: users,
    }
}

func (c *UsersController) Post() mvc.Response {
    // リクエストボディのjsonデータを構造体（struct）に格納する
    var user model.User
    err := c.Ctx.ReadJSON(&user)
    
    // エラーハンドリング（Iris 備え付きのもので作れます）
    if err != nil {
        c.Ctx.StopWithError(iris.StatusBadRequest, err)
        return mvc.Response{
            Code: iris.StatusBadRequest,
        }
    }
    
    // 新規作成
    err = c.UserService.CreateUser(&user)
    if err != nil {
        return mvc.Response{
            Code: iris.StatusInternalServerError,  // エラーハンドリング
        }
    }
    
    // Iris 備え付きのレスポンス用構造体（struct）
    return mvc.Response{ Code: iris.StatusCreated }
}

func (c *UsersController) PutDetailsBy(id int) mvc.Response {
    // リクエストボディのjsonデータを構造体（struct）に格納する
    var user model.User
    err := c.Ctx.ReadJSON(&user)
    
    // エラーハンドリング（Iris 備え付きのもので作れます）
    if err != nil {
        c.Ctx.StopWithError(iris.StatusBadRequest, err)
        return mvc.Response{
            Code: iris.StatusBadRequest,
        }
    }
    
    user.Id = id
    
    // 更新
    err = userService.UpdateUser(&user)
    if err != nil {
        return mvc.Response{
            Code: iris.StatusInternalServerError,  // エラーハンドリング
        }
    }
    
    // Iris 備え付きのレスポンス用構造体（struct）
    return mvc.Response{ Code: iris.StatusOK }
}

func (c *UsersController) DeleteDetailsBy(id int) mvc.Response {
    // 削除
    err := c.UserService.DeleteUser(id)
    if err != nil {
        return mvc.Response{
            Code: iris.StatusInternalServerError,  // エラーハンドリング
        }
    }
    
    // Iris 備え付きのレスポンス用構造体（struct）
    return mvc.Response{ Code: iris.StatusOK }
}

package model

type User struct {
    Id    string  `json:"id"   db:"id"`
    Name  string  `json:"name" db:"name"`
    Age   uint32  `json:"age"  db:"age"`
}

package service

import (
    "database/sql"
    "fmt"
    "github.com/go-gorp/gorp"
    "go-iris-sample/model"
    "log"
    "os"
    
    _ "github.com/go-sql-driver/mysql"
)

// gorp初期化処理
func InitDb() *gorp.DbMap {
    dbUserName := "DB_USERNAME"
    dbPassWord := "DB_PASSWORD"
    dbHost := "DB_HOST"
    dbPort := "DB_PORT"
    dbDbName := "DB_DBNAME"
    db, err := sql.Open("mysql", fmt.Sprintf("%v:%v@tcp(%v:%v)/%v?parseTime=true", dbUserName, dbPassWord, dbHost, dbPort, dbDbName))
    if err != nil {
        fmt.Printf("error! can't open sql driver %v", err)
    }
    dbmap := &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{"InnoDB", "UTF8"}}
    
   // テーブル作成
    dbmap.AddTableWithName(model.User{}, "user").SetKeys(true, "Id")
    err = dbmap.CreateTablesIfNotExists()
    if err != nil {
        fmt.Printf("error! can't craete table: %v", err)
    }
    
    // ログの取得
    dbmap.TraceOn("[gorp]", log.New(os.Stdout, "go-iris-sample:", log.Lmicroseconds))
    
    return dbmap
}

package service

import (
    "go-iris-sample/_example-mvc-api/model"
    
    _ "github.com/go-sql-driver/mysql"
)

type UserService struct {}

func (UserService) GetUserList() ([]model.User, error) {
    // initialize the DbMap
    dbMap := InitDb()
    defer dbMap.Db.Close()
    
    var users []model.User
    
    // ユーザーを全取得
    _, err := dbMap.Select(&users, `SELECT * FROM users`)
    if err != nil {
        return []model.User{}, err
    }
    
    return users, nil
}

func (UserService) CreateUser(user *model.User) error {
    // initialize the DbMap
    dbMap := InitDb()
    defer dbMap.Db.Close()
    
    // トラン ザクションを走らせながらinsert
    tx, _ := dbMap.Begin()
    
    err := tx.Insert(user)
    if err != nil {
        tx.Rollback()
        return err
    }
    
    tx.Commit()
    
    return nil
}

func (UserService) UpdateUser(user *model.User) error {
    // initialize the DbMap
    dbMap := InitDb()
    defer dbMap.Db.Close()
    
    // トランザクションを走らせながらupdate
    tx, _ := dbMap.Begin()
    
    _, err := tx.Update(user)
    if err != nil {
        tx.Rollback()
        return err
    }
    
    tx.Commit()
    
    return nil
}

func (UserService) DeleteUser(id int) error {
    // initialize the DbMap
    dbMap := InitDb()
    defer dbMap.Db.Close()
    
    // id から削除するユーザーを取得
    var user model.User
    err := dbMap.SelectOne(&user, `SELECT * FROM users WHERE id = :id`,
        map[string]interface{}{
            "id": id,
        })
    if err != nil {
        fmt.Printf("error! can't find user by id: %v.\n", id)
        return err
    }
    
    // トランザクションを走らせながらdelete
    tx, _ := dbMap.Begin()
    
    _, err := tx.Delete(&user)
    if err != nil {
        tx.Rollback()
        return err
    }
    
    tx.Commit()
    
    return nil
}

2022-04-17 19:08:16|1.19426ms|200|GET|/|::1|0 B|10 B||
2022-04-17 19:08:16|42.803µs|404|GET|/favicon.ico|::1|0 B|0 B||
2022-04-17 19:08:21|27.538µs|404|GET|/favicon.ico|::1|0 B|0 B||
2022-04-17 19:09:36|112.584µs|404|GET|/favicon.ico|::1|0 B|0 B||
2022-04-17 19:09:40|32.466µs|404|GET|/favicon.ico|::1|0 B|0 B||
2022-04-17 19:09:44|180.006µs|200|GET|/|::1|0 B|10 B||
2022-04-17 19:09:44|25.901µs|404|GET|/favicon.ico|::1|0 B|0 B||
2022-04-17 19:09:58|168.375µs|200|GET|/users|::1|0 B|10 B||
2022-04-17 19:09:58|29.095µs|404|GET|/favicon.ico|::1|0 B|0 B||
2022-04-17 19:10:47|322.583µs|200|GET|/users|127.0.0.1|64 B|10 B|{"firstname":"Tanaka","lastname":"ryo","age":15}|