# Quick start Hey, you say you've never heard about Beego and don't know how to use it? Don't worry, after you read this section, you will know a lot about Beego. Before you start reading, make sure you installed Beego in your computer, if not, check this tutorial: [Installation](Install.md) **Navigation** - [Hello world](#hello-world) - [New project](#new-project) - [Development mode](#development-mode) - [Router](#router) - [Static files](#static-files) - [Filter and middleware](#filter-and-middleware) - [Controller](#controller) - [Template](#template) - [Handle request](#handle-request) - [Redirect and error](#-15) - [Handle response](#response) - [Sessions](#sessions) - [Cache](#cache) - [Safe map](#map) - [Log](#-16) - [Configuration](#-17) - [Beego arguments](#-18) - [Integrated third-party applications](#-19) - [Deployment](#-20) ## Hello world This is an example of "Hello world" in Beego: package main import ( "github.com/astaxie/beego" ) type MainController struct { beego.Controller } func (this *MainController) Get() { this.Ctx.WriteString("hello world") } func main() { beego.Router("/", &MainController{}) beego.Run() } Save file as "hello.go", build and run it: $ go build main.go $ ./hello Open address [http://127.0.0.1:8080](http://127.0.0.1:8080) in your browser and you will see "hello world". What happened in behind above example? 1. We import package `github.com/astaxie/beego`. As we know that Go initialize packages and runs init() function in every package(more detail [here](https://github.com/Unknwon/build-web-application-with-golang_EN/blob/master/eBook/02.3.md#main-function-and-init-function)), so Beego initializes the BeeApp application at this time. 2. Define controller. We define a struct called `MainController` with a anonymous field `beego.Controller`, so the `MainController` has all methods that `beego.Controller` has. 3. Define RESTful methods. Once we use anonymous combination, `MainController` has already had `Get`, `Post`, `Delete`, `Put` and other methods, these methods will be called when user sends corresponding request, like `Post` method for requests that are using POST method. Therefore, after we overloaded `Get` method in `MainController`, all GET requests will use `Get` method in `MainController` instead of in `beego.Controller`. 4. Define main function. All applications in Go use main function as entry point as C does. 5. Register routers, it tells Beego which controller is responsibility for specific requests. Here we register `/` for `MainController`, so all requests in `/` will be handed to `MainController`. Be aware that the first argument is the path and the second one is pointer of controller that you want to register. 6. Run application in port 8080 as default, press `Ctrl+c` to exit. ## New project Get into your $GOPATH, then use following command to setup Beego project: bee create hello It generates folders and files for your project, directory structure as follows: . ├── conf │ └── app.conf ├── controllers │ └── default.go ├── main.go ├── models ├── static │ ├── css │ ├── img │ └── js └── views └── index.tpl ## Development mode Beego uses development mode as default, you can use following code to change mode in your application: beego.RunMode = "pro" Or use configuration file in `conf/app.conf`, and input following content: runmode = pro No differences between two ways. In development mode, you have following effects: - If you don't have directory `views`, it prints following error prompt: 2013/04/13 19:36:17 [W] [stat views: no such file or directory] - It doesn't cache template and reload every time. - If panic occurs in your server, it prints information like following screen shot: ![](images/dev.png) ## Router The main function of router is to connect request URL and handler. Beego wrapped `Controller`, so it connects request URL and `ControllerInterface`. The `ControllerInterface` has following methods: type ControllerInterface interface { Init(ct *Context, cn string) Prepare() Get() Post() Delete() Put() Head() Patch() Options() Finish() Render() error } `beego.Controller` implemented all of them, so you just use this struct as anonymous field in your controller struct. Of course you have to overload corresponding methods for more specific usages. Users can use following ways to register route rules: beego.Router("/", &controllers.MainController{}) beego.Router("/admin", &admin.UserController{}) beego.Router("/admin/index", &admin.ArticleController{}) beego.Router("/admin/addpkg", &admin.AddController{}) For more convenient configure route rules, Beego references the idea from sinatra, so it supports more kinds of route rules as follows: - beego.Router("/api/:id([0-9]+)", &controllers.RController{}) Customized regular expression match // match /api/123 :id= 123 - beego.Router("/news/:all", &controllers.RController{}) Match rest of all // match /news/path/to/123.html :all= path/to/123.html - beego.Router("/user/:username([\w]+)", &controllers.RController{}) Regular expression // match /user/astaxie :username = astaxie - beego.Router("/download/`*`.`*`", &controllers.RController{}) Wildcard character // match /download/file/api.xml :path= file/api :ext=xml - beego.Router("/download/ceshi/`*`", &controllers.RController{}) wildcard character match rest of all // match /download/ceshi/file/api.json :splat=file/api.json - beego.Router("/:id:int", &controllers.RController{}) Match type int // match :id is int type, Beego uses regular expression ([0-9]+) automatically - beego.Router("/:hi:string", &controllers.RController{}) Match type string // match :hi is string type, Beego uses regular expression ([\w]+) automatically ##Static files Go provides `http.ServeFile` for static files, Beego wrapped this function and use following way to register static file folder: beego.SetStaticPath("/static","public") - The first argument is the path of your URL. - The second argument is the directory in your application path. Beego supports multiple static file directories as follows: beego.SetStaticPath("/images","images") beego.SetStaticPath("/css","css") beego.SetStaticPath("/js","js") After you setting static directory, when users visit `/images/login/login.png`,Beego accesses `images/login/login.png` in related to your application directory. One more example, if users visit `/static/img/logo.png`, Beego accesses file `public/img/logo.png`. ##Filter and middleware Beego supports customized filter and middleware, such as security verification, force redirect, etc. Here is an example of verify user name of all requests, check if it's admin. var FilterUser = func(w http.ResponseWriter, r *http.Request) { if r.URL.User == nil || r.URL.User.Username() != "admin" { http.Error(w, "", http.StatusUnauthorized) } } beego.Filter(FilterUser) You can also filter by arguments: beego.Router("/:id([0-9]+)", &admin.EditController{}) beego.FilterParam("id", func(rw http.ResponseWriter, r *http.Request) { dosomething() }) Filter by prefix is also available: beego.FilterPrefixPath("/admin", func(rw http.ResponseWriter, r *http.Request) { dosomething() }) ##Controller Use `beego.controller` as anonymous in your controller struct to implement the interface in Beego: type xxxController struct { beego.Controller } `beego.Controller` implemented`beego.ControllerInterface`, `beego.ControllerInterface` defined following methods: - Init(ct `*`Context, cn string) Initialize context, controller's name, template's name, and container of template arguments - Prepare() This is for expend usages, it executes before all the following methods. Users can overload this method for verification for example. - Get() This method executes when client sends request as GET method, 403 as default status code. Users overload this method for customized handle process of GET method. - Post() This method executes when client sends request as POST method, 403 as default status code. Users overload this method for customized handle process of POST method. - Delete() This method executes when client sends request as DELETE method, 403 as default status code. Users overload this method for customized handle process of DELETE method. - Put() This method executes when client sends request as PUT method, 403 as default status code. Users overload this method for customized handle process of PUT method. - Head() This method executes when client sends request as HEAD method, 403 as default status code. Users overload this method for customized handle process of HEAD method. - Patch() This method executes when client sends request as PATCH method, 403 as default status code. Users overload this method for customized handle process of PATCH method. - Options() This method executes when client sends request as OPTIONS method, 403 as default status code. Users overload this method for customized handle process of OPTIONS method. - Finish() This method executes after corresponding method finished, empty as default. User overload this method for more usages like close database, clean data, etc. - Render() error This method is for rendering template, it executes automatically when you set beego.AutoRender to true. Overload all methods for all customized logic processes, let's see an example: type AddController struct { beego.Controller } func (this *AddController) Prepare() { } func (this *AddController) Get() { this.Data["content"] ="value" this.Layout = "admin/layout.html" this.TplNames = "admin/add.tpl" } func (this *AddController) Post() { pkgname := this.GetString("pkgname") content := this.GetString("content") pk := models.GetCruPkg(pkgname) if pk.Id == 0 { var pp models.PkgEntity pp.Pid = 0 pp.Pathname = pkgname pp.Intro = pkgname models.InsertPkg(pp) pk = models.GetCruPkg(pkgname) } var at models.Article at.Pkgid = pk.Id at.Content = content models.InsertArticle(at) this.Ctx.Redirect(302, "/admin/index") } ##Template ###Template directory Beego uses `views` as the default directory for template files, parses and caches them as needed(cache is not enable in develop mode), but you can **change**(because only one directory can be used for template files) its directory using following code: beego.ViewsPath = "/myviewpath" ###Auto-render You don't need to call render function manually, Beego calls it automatically after corresponding methods executed. If your application is somehow doesn't need templates, you can disable this feature either in code of `main.go` or configuration file. To disable auto-render in configuration file: autorender = false To disable auto-render in `main.go`(before you call `beego.Run()` to run the application): beego.AutoRender = false ###Template data You can use `this.Data` in controller methods to access the data in templates. Suppose you want to get content of `{{.Content}}`, you can use following code to do this: this.Data["Context"] = "value" ###Template name Beego uses built-in template engine of Go, so there is no different in syntax. As for how to write template file, please visit [Template tutorial](https://github.com/Unknwon/build-web-application-with-golang_EN/blob/master/eBook/07.4.md)。 Beego parses template files in `viewpath` and render it after you set the name of the template file in controller methods. For example, Beego finds the file `add.tpl` in directory `admin` in following code: this.TplNames = "admin/add.tpl" Beego supports two kinds of extensions for template files, which are `tpl` and `html`, if you want to use other extensions, you have to use following code to let Beego know: beego.AddTemplateExt("") If you enabled auto-render and you don't tell Beego which template file you are going to use in controller methods, Beego uses following format to find the template file if it exists: c.TplNames = c.ChildName + "/" + c.Ctx.Request.Method + "." + c.TplExt Which is `/.