ThinkGo

ThinkGo is a lightweight MVC framework written in Go (Golang).

Installation

The only requirement is the Go Programming Language

go get -u github.com/thinkoner/thinkgo

Quick start

package main

import (
	"github.com/thinkoner/thinkgo"
	"fmt"
	"github.com/thinkoner/thinkgo/route"
	"github.com/thinkoner/thinkgo/context"
)

func main() {
	app := thinkgo.BootStrap()
	app.RegisterRoute(func(route *route.Route) {

		route.Get("/", func(req *context.Request) thinkgo.Response {
			return thinkgo.Text("Hello ThinkGo !")
		})

		route.Get("/ping", func(req *context.Request) thinkgo.Response {
			return thinkgo.Json(map[string]string{
				"message": "pong",
			})
		})

		// Dependency injection
		route.Get("/user/{name}", func(req *context.Request, name string) thinkgo.Response {
			return thinkgo.Text(fmt.Sprintf("Hello %s !", name))
		})
	})
	// listen and serve on 0.0.0.0:9011
	app.Run()
}

Table of contents

• Routing
• Controller
• Request
• Response
• View
• HTTP Session

Routing

Basic Routing

The most basic routes accept a URI and a Closure, providing a very simple and expressive method of defining routes:

app.RegisterRoute(func(route *route.Route) {
    route.Get("/foo", func(req *context.Request) thinkgo.Response {
        return thinkgo.Text("Hello ThinkGo !")
    })
})

Available Router Methods

The router allows you to register routes that respond to any HTTP verb:

route.Get("/someGet", getting)
route.Post("/somePost", posting)
route.Put("/somePut", putting)
route.Delete("/someDelete", deleting)
route.Patch("/somePatch", patching)
route.Options("/someOptions", options)

Sometimes you may need to register a route that responds to multiple HTTP verbs. You may even register a route that responds to all HTTP verbs using the Any method:

route.Any("/someAny", any)

Parameters in path

Of course, sometimes you will need to capture segments of the URI within your route. For example, you may need to capture a user's ID from the URL. You may do so by defining route parameters:

route.Get("/user/{id}", func(req *context.Request, id string) thinkgo.Response {
	return thinkgo.Text(fmt.Sprintf("User %s", id))
})

You may define as many route parameters as required by your route:

route.Get("/posts/{post}/comments/{comment}", func(req *context.Request, postId, commentId string) thinkgo.Response {
	//
})

Controller

Basic Controller

Below is an example of a basic controller class.

package controller

import (
	"github.com/thinkoner/thinkgo"
	"github.com/thinkoner/thinkgo/context"
)

func Index(req *context.Request) thinkgo.Response {
	return thinkgo.Text("Hello ThinkGo !")
}

You can define a route to this controller like so:

route.Get("/", controller.Index)

Resource Controller

This feature will be supported in a future release.

HTTP Request

Accessing The Request

To obtain an instance of the current HTTP request via dependency injection

func Handler(req *context.Request) thinkgo.Response {
	name := req.Input("name")
}

Dependency Injection & Route Parameters

If your controller method is also expecting input from a route parameter you should list your route parameters after the request dependencies. For example, you can access your route parameter name like so:

route.Put("/user/{name}", func(req *context.Request, name string) thinkgo.Response {
	//
})

Request Path & Method

The path method returns the request's path information. So, if the incoming request is targeted at http://domain.com/foo/bar, the path method will return foo/bar:

uri := req.GetPath()

The method method will return the HTTP verb for the request.

method := req.GetMethod();

Retrieving Cookies From Requests

name, _ := request.Cookie("name")

HTTP Response

an HTTP Response Must implement the thinkgo.Response interface

Creating Responses

a simple strings or json Response:

thinkgo.Text("Hello ThinkGo !")

thinkgo.Json(map[string]string{
				"message": "pong",
			})

Attaching Cookies To Responses

response.Cookie("name", "alice")

View

views are stored in the views directory, A simple view might look something like this:

views/layout.html like this:

{{ define "layout" }}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{{ .Title }}</title>
</head>
<body>
    {{ template "content" .}}
</body>
</html>
{{ end }}

views/tpl.html like this:

{{ define "content" }}
<h2>{{ .Message }}</h2>
{{ end }}
{{ template "layout" . }}

we may return it using the Render function like so:

route.Get("/tpl", func(request *context.Request) thinkgo.Response {
	data := map[string]interface{}{"Title": "ThinkGo", "Message": "Hello ThinkGo !"}
	return thinkgo.Render("tpl.html", data)
})

HTTP Session

retrieving Data like this:

request.Session().Get("user")

storing Data like this:

request.Session().Set("user", "alice")

License

This project is licensed under the Apache 2.0 license.

Contact

If you have any issues or feature requests, please contact us. PR is welcomed.

• https://github.com/thinkoner/thinkgo/issues
• duanpier@gmail.com