Vijesh
Exploring Golang and Beego: A Beginner’s Guide with Examples. Part:1. 😊
...
While this blog provides an introduction to Golang and Beego 😊, it is not intended for complete beginners and assumes some prior knowledge of Golang programming. 🧐
...
Beego is an open-source web framework for Go that follows the MVC pattern. 😊 It includes built-in support for session management, caching, validation, and internationalization, as well as support for various databases. 📊 Beego also provides a command-line tool for generating code scaffolding and running tasks. 🛠️
...
Beego is an easy-to-learn web framework for Go that is scalable, flexible, and cross-platform. 😊 It has built-in features for performance optimization and can be customized to meet specific needs. 🛠️ Beego also has an active community of developers who contribute to its development and provide support. 👨💻👩💻
...
Beego provides a more opinionated and feature-rich framework 😊, while Gin and Echo provide more flexibility and focus on speed and performance. 🚀
Without wasting time, it’s time to jump into coding… 🤓
Let’s import the necessary packages 😊
go get -u github.com/astaxie/beego go get -u github.com/beego/bee/v2
To check whether the `bee` CLI is successfully installed in your system, give this command: `bee version` 🐝
To create a new project, give this command: `bee new beegoexample` 🎉
This command will create a new project with all the files required for a Beego project and the module
name will be beegoexample.
😊 Now you can enter into the project directory and give the go mod tidy
command to import the required packages. 📦
To start the Beego application, give the below command 😊 bee run
This will start the Beego server and your application will be accessible at http://localhost:8080.
That’s it! 😃 You have now installed and set up Go and Beego for web development and created a new Beego project. 🎉
...
Beego follows the Model-View-Controller (MVC) architectural pattern. 😊. Inside the controllers/default.go make these changes
package controllers
import (
"github.com/astaxie/beego"
)
type MainController struct {
beego.Controller
}
func (c *MainController) Get() {
c.Ctx.WriteString("hello world 🤓")
}
This controller code is responsible for the root URL (‘/’). Now refresh the page… 😊
Voila! The changes have been reflected. 😊
In the MVC architectural pattern followed by Beego 😊, the model represents the data and business logic of the application and handles data storage, retrieval, and manipulation. The view is responsible for displaying data to the user and receiving user input. The controller acts as a bridge between the model and the view, receiving requests from the user, manipulating data through the model, and rendering the appropriate view. 🌉”
We are going to use MySQL in this example. 😊 Let’s use docker-compose
to run a MySQL instance.
Create a file named docker-compose.yaml and add the below code.
To start the MySQL instance, give the docker-compose up -d command. 🚀.
version: '3.9'
services:
database:
image: mysql
volumes:
- mysql:/var/lib/mysql
restart: always
environment:
- MYSQL_ROOT_PASSWORD=core
- MYSQL_DATABASE=core
- MYSQL_USER=core
- MYSQL_PASSWORD=core
ports:
- '3306:3306'
networks:
- intranet
networks:
intranet:
volumes:
mysql:
name: mysqldb
Once the above step is done, proceed with this. 😊 Add this code in models/models.go.
This defines the books model, which represents a book in the
application.
📚 Stop the Beego application once and start again with the bee run
command. 🚀.
package models
type Books struct {
Id int `json:"id"`
Title string `json:"title"`
Author string `json:"author"`
}
then add the below code in main.go
package main
import (
"github.com/astaxie/beego"
"github.com/astaxie/beego/orm"
_ "github.com/go-sql-driver/mysql"
"beegoexample/models"
)
func init() {
orm.RegisterDriver("mysql", orm.DRMySQL)
orm.RegisterDataBase("default", "mysql", "core:core@/core?charset=utf8")
orm.RegisterModel(new(models.Books))
}
func main() {
orm.RunSyncdb("default", false, true)
beego.Run()
}
The above code will automatically create a table in the MySQL instance. 😊 It will automatically execute this SQL:
CREATE TABLE IF NOT EXISTS `books` ( `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `title` varchar(255) NOT NULL DEFAULT ‘’ , `author` varchar(255) NOT NULL DEFAULT ‘’ ) ENGINE=InnoDB;
The beauty is that there’s no need to write raw queries to create the tables. 😍 Consider if you have a number of tables, this can save you a lot of time and effort!
Now create a Books controller. create a new file books.go in controller.
package controllers
import (
"beegoexample/models"
"github.com/astaxie/beego"
"github.com/beego/beego/orm"
)
type BookController struct {
beego.Controller
}
func (c *BookController) Get() {
o := orm.NewOrm()
var books []*models.Books
num, err := o.QueryTable("books").All(&books)
if err != nil {
c.Ctx.WriteString(err.Error())
} else {
c.Data["books"] = books
c.Data["num"] = num
c.TplName = "book/index.html"
}
}
This code defines the BookController, which retrieves all books from the database and renders them in the `book/index. template.
create a Book view. create a new file in view/book/index.tpl and add the below code.
<html>
<head>
<title>Books</title>
</head>
<body>
<h1>Books</h1>
<table>
<tr>
<th>Id</th>
<th>Title</th>
<th>Author</th>
</tr>
{{range .books}}
<tr>
<td>{{.Id}}</td>
<td>{{.Title}}</td>
<td>{{.Author}}</td>
</tr>
{{end}}
</table>
<p>Total number of books: {{.num}}</p>
</body>
</html>
This code defines the book view, which displays a table of books retrieved from the database.
add the below code in the router/router.go. This code defines the routes for the application, mapping the root route to the MainController and the /books route to the BookController
package routers
import (
"beegoexample/controllers"
"github.com/astaxie/beego"
)
func init() {
beego.Router("/", &controllers.MainController{})
beego.Router("/books", &controllers.BookController{})
}
...
Now you can run the Beego application using the bee run command.
This will start the Beego server and run your application. Open a web browser and go to
http://localhost:8080/books to view the list of books. Congratulations! You have built a complete web
application with Beego and Go,
using the Model-View-Controller (MVC) architecture. 😊
Thank you everyone for reading my blog hope you found this usefull. Lets meet in the part 2 …… 😊