Shulou(Shulou.com)06/03 Report--

This article introduces you how to understand http and mysql in Go language, the content is very detailed, interested friends can refer to, hope to be helpful to you.

Http programming

Go natively supports http:

Import "net/http"

The http service performance of Go is similar to that of nginx:

That is to say, the Web program written in Go is online, the Web server of nginx no longer needs to be deployed in front of the program, and the Web server is omitted here. If multiple Web applications are deployed on the server, you still need to reverse proxy, which is usually nginx or apache.

A web service can be implemented in a few lines of code:

Package mainimport ("fmt"net/http") func Hello (w http.ResponseWriter, r * http.Request) {fmt.Println (* r) fmt.Fprintf (w, "Hello World")} func main () {http.HandleFunc ("/", Hello) err: = http.ListenAndServe ("0.0.0.0net/http 8000", nil) if err! = nil {fmt.Println ("http Listen failed")} http client

Common request methods for http:

Get request

Post request

Put request

Delete request

Head request

Get request

An example of using Get to request a website:

Package mainimport ("fmt"io/ioutil"net/http") func main () {res, err: = http.Get ("http://edu.51cto.com") if err! = nil {fmt.Println (" http get ERRPR: ", err) return} data, err: = ioutil.ReadAll (res.Body) if err! = nil {fmt.Println (" get data ERROR: " Err) return} fmt.Println (string (data))}

Head request

The Head request returns only the response header. If you just want to get some status information, you can use Head to request it. In this way, it avoids returning the response body, which has more data and is suitable for monitoring. An example of a Head request:

Package mainimport ("fmt"net/http") var urls = [] string {"http:// × × × w.baidu.com", "http:// × × × w.google.com", "http:// × × × w.sina.com.cn", "http:// × × × w.163.com",} func main () {for _, v: = range urls {resp Err: = http.Head (v) if err! = nil {fmt.Println ("Head request ERROR:", err) continue} fmt.Println (resp.Status)}} http Common status Code

Http.StatusContinue = 100

Http.StatusOK = 200

Http.StatusFound = 302Jump

Http.StatusBadRequest = 400illegal request

Http.StatusUnanthorized = 401 has no permission

Http.StatusForbidden = 403 forbids access

Http.Status.NotFound = 404 page does not exist

Http.StatusInternalServerError = 500Internal error

Processing form forms package mainimport ("fmt"io"net/http") const form = ``func FormServer (w http.ResponseWriter, request * http.Request) {w.Header () .Set ("content-Type", "text/html") switch request.Method {case "GET": io.WriteString (w, form) case "POST": request.ParseForm () io.WriteString (w) Request.Form ["in"] [0]) / / notice that the name of the above two input is the same io.WriteString (w, request.Form ["in"] [1]) / / so this is an array io.WriteString (w, ") io.WriteString (w, request.FormValue (" in ")) / / generally goes to a value. Use this method}} func main () {http.HandleFunc ("/ form", FormServer) if err: = http.ListenAndServe (": 8000", nil) Err! = nil {fmt.Println ("listening port ERROR:", err)}} panic processing

If there is panic in the handler, it will cause the entire program to crash, so you have to defer revoer () to deal with panic. Defer an anonymous function at the beginning of the handler:

Func FormServer (w http.ResponseWriter, request * http.Request) {/ / add a defer to handle panic defer func () {if x: = recover () X! = nil {log.Println (request.RemoteAddr, "catch exception:", x)} () / the content of the original handler w.Header () .Set ("content-Type", "text/html") switch request.Method {case "GET": io.WriteString (w, form) case "POST": request.ParseForm () io.WriteString (w) Request.FormValue ("in") / / generally go to a value Use this method} / / create a panic zero: = 0 tmp: = 1 / zero io.WriteString (w, string (tmp))}

Optimize unified processing

According to the above practice, add panic processing to the beginning of each handler. Because each handler has the same panic handling method, you can write a custom handler:

/ / the function func logPanics (handle http.HandlerFunc) http.HandlerFunc {return func (writer http.ResponseWriter, request * http.Request) {defer func () {if x: = recover () handled by custom panic X! = nil {log.Println (request.RemoteAddr, "catch exception:", x)}} () / / deal with panic first Then call the business logic handle (writer, request)}} func main () {/ / http.HandleFunc ("/ form", FormServer) / / modify the method http.HandleFunc ("/ form", logPanics (FormServer)) that calls the handler function / / pass the handler function to if err: = http.ListenAndServe (": 8000", nil) in the function that encapsulates panic processing written by yourself. Err! = nil {fmt.Println ("listening port ERROR:", err)}}

The handler was originally called directly. Now call the custom function and pass the handler in. Load defer in a custom function, and then call to execute the original handler. The logic is very simple, that is, pass the handler function as an argument to the custom function, and then call the handler function in the custom function. Write defer in the custom function, which means that all handlers have defer.

Template

The "text/template" package is required to use templates. Then call the template's t.Execute () method to output.

Replace

Prepare a simple template first:

Hello {{.Name}}

Age: {{.Age}}

Then use the template in Go:

Package mainimport ("fmt"os"text/template") type Person struct {Name string Age int} func main () {t, err: = template.ParseFiles ("index.html") if err! = nil {fmt.Println ("template parsing exception:", err) return} p: = Person {"Bob", 32} if err: = t.Execute (os.Stdout, p) Err! = nil {fmt.Println ("template loading data exception:", err)}} / * execution result PS H:\ Go\ src\ go_dev\ day10\ http\ use_template > go run main.go

Hello Bob

Age: 32

PS H:\ Go\ src\ go_dev\ day10\ http\ use_template > * /

If you directly use {{.}} without the field name, it is the effect of printing the output structure.

Output to browser

To output to the browser, just replace the output to the terminal with the w http.ResponseWriter type output to the handler in t.Execute (os.Stdout, p).

The content of the html template remains the same. Here is the code for go:

Package mainimport ("fmt"net/http"text/template") func Hello (w http.ResponseWriter, r * http.Request) {fmt.Fprintf (w, "Hello World")} type Person struct {Name string Age int} func Index (w http.ResponseWriter, r * http.Request) {p: = Person {"Cara", 18} t Err: = template.ParseFiles ("index.html") if err! = nil {fmt.Println ("load template ERROR:", err) return} t.Execute (w, p)} func main () {http.HandleFunc ("/", Hello) http.HandleFunc ("/ index", Index) err: = http.ListenAndServe ("0.0.0.0index.html 8000" Nil) if err! = nil {fmt.Println ("http Listen failed")}} judgment

Usage example:

{{if gt .Age 18}}

Come of age

{{else}}

Underage

{{end}}

More judgment logic:

Not is not

{{if not .condition}}

{{end}}

And vs.

{{if and .condition1 .condition2}}

{{end}}

Or or

{{if or .condition1 .condition2}}

{{end}}

Eq equals

{{if eq .var1 .var2}}

{{end}}

Ne is not equal to

{{if ne .var1 .var2}}

{{end}}

Lt is less than

{{if lt .var1 .var2}}

{{end}}

Le is less than or equal to

{{if le .var1 .var2}}

{{end}}

Gt is greater than

{{if gt .var1 .var2}}

{{end}}

Ge is greater than or equal to

{{if ge .var1 .var2}}

{{end}}

With encapsulation

The with statement is to create a closed scope in which {{.}} represents the variable of with and has nothing to do with the outer {{.}}, but only related to the parameters of with:

{{with .Name}}

{{.}}

{{end}}

The package above is in {{with .Var}}, and the {.} in with represents the variable Var.

With can encapsulate constants:

{{with "world"}} Now the dot is set to {. } {{end}} Loop (traversal)

Golang's template supports range loops to traverse the contents of map and slice. Within the range loop, you can also use $to set loop variables, and we can access the traversal values through $I $v. The syntax is:

{{range $I, $v: = .slice}} key: {{$key}}, value: {{$value}} {{end}}

This is another traversal method. In this way, the value of index or key cannot be accessed. You need to access the corresponding value through a point:

{{range .slice}} {{.field}} {{end}}

Within the loop, the point is the value that represents the traversal. For variables that are originally accessed using points, use $inside the loop. To visit. The following example shows how the variable in-loop and out-of-loop ArticleConten is accessed:

{{.ArticleContent}} {{range .slice}} {{$.ArticleContent}} {{end}} define variables

The parameters of the template can be basic data types in go, such as strings, numbers, Boolean values, array slices, or a structure. You can use $variable: = value to set variables in the template. We used the method of setting variables in the range iteration process.

{{$article: = "hello"}} {{$name: = .Name}} mysql use

Here is only a brief talk about the addition, deletion, modification and query of the data, so you need to prepare the database before testing the code.

First create a database and specify the code, so that it should be able to support Chinese:

CREATE DATABASE library name CHARSET "utf8"

Then create two tables:

CREATE TABLE person (user_id int primary key auto_increment, username varchar, gender varchar, email varchar); CREATE TABLE place (country varchar, city varchar, telcode int); Import database driver

The sql package provides a general SQL (or SQL-like) database interface.

The sql package must be used in conjunction with the database driver.

The driver package needs to be installed:

Go get-u github.com/go-sql-driver/mysql

Before using it, import the package of mysql:

Import ("database/sql" _ "github.com/go-sql-driver/mysql")

Two packages are imported into it. The first is the sql package, which we use to invoke and manipulate the database.

The second is the driver package, which is preceded by a placeholder, so this package is just introduced, but does not use it. And if you want to manipulate other databases, you only need to modify the driver package. In fact, only the initialization init function in this package is executed.

Connect to the database

Build a connection in the format: "user name: password @ tcp (IP: Port) / database? charset=utf8":

Package mainimport ("fmt"time"database/sql" _ "github.com/go-sql-driver/mysql") var DB * sql.DBfunc init () {database, err: = sql.Open ("mysql", "admin:admin123@tcp (192.168.3.103 database/sql 3306) / Golang_week10") if err! = nil {fmt.Println ("failed to connect to database:" Err) return} DB = database} func main () {fmt.Println (DB) DB.SetMaxIdleConns (16) / set the number of idle connections DB.SetMaxOpenConns / / set the maximum number of connections DB.SetConnMaxLifetime (100*time.Second) / / maximum connection cycle Close fmt.Println (DB)} insert data for connections that exceed the time limit

The following is an example of inserting data and getting the id:

The init function of the database connection omits func insert () {r, err: = DB.Exec ("insert into person (username,gender,email) values (?,?)", "Barry", "Male", "Barry@go.net") if err! = nil {fmt.Println ("insert data ERROR:", err) return} fmt.Println (r) id Err: = r.LastInsertId () if err! = nil {fmt.Println ("get id ERROR:", err) return} fmt.Println (id)} func main () {insert ()}

The above values (? The question mark in is a placeholder, and the specific value can be written in the following parameters. Of course, if you don't use placeholders, it's okay to just pass a string as an argument.

Query

Query a single field:

Func query () {row: = DB.QueryRow ("select username from person where user_id=?", 1) var name string / / create a variable to store the queried data if err: = row.Scan (& name); err! = nil {fmt.Println ("Scan Failed:", err) return} fmt.Println (name)} func main () {query ()}

You can also query multiple or all fields at a time. Before the query, you can create a structure according to the type of the table, and assign values to the structure with the queried data:

Type Person struct {ID int `db: "user_id" `Username sql.NullString `db: "username" `Gender sql.NullString `db: "gender" `Email sql.NullString `db: "email" `} func query () {row: = DB.QueryRow ("select * from person where user_id=?", 6) var person = new (Person) / / row.scan must be in the order in which the fields are stored in the database Otherwise, if err: = row.Scan (& person.ID, & person.Username, & person.Gender, & person.Email) Err! = nil {fmt.Println ("Scan Failed:", err) return} fmt.Println (person)} func main () {query ()}

The data model is the structure defined above. The type here can be the standard data type of Go. However, if the field in the database is allowed to be empty, and the value of the field is also empty, the field will return nil after the query. If it is of type string, you cannot receive nil, but sql.NullString can receive Nil values.

In addition, the tag tag in the structure has no meaning here. However, the above tag marks the corresponding field name of the field in the database, which may be useful elsewhere.

Query multiple rows

Func query () {rows, err: = DB.Query ("select * from person where user_id >?", 1) defer func () {if rows! = nil {rows.Close ()} () if err! = nil {fmt.Println ("Query query ERROR:" Err) return} var person = new (Person) for rows.Next () {if err = rows.Scan (& person.ID, & person.Username, & person.Gender, & person.Email) Err! = nil {fmt.Println ("Scan Failed:", err) return} fmt.Println (person)}} func main () {query ()}

The query is still not very useful, but you can also choose other third-party libraries, where there will be some good extensions. Examples will be given later.

Other actions

Since most of the operations are performed with SQL commands, there are no examples of other operations.

Update updates data

Result, err: = DB.Exec ("UPDATE person set email=? where username=?", "Cara", "Cara@catco.org")

Delete delete data

Result,err: = DB.Exec ("DELETE FROM person where id=?", 1)

Note: update data does not return LastInsertID, so result.LastInsertID is always 0. Delete data can be obtained to LastInsertID, the use of the same as inserting data.

Third-party library sqlx

Sqlx is a go language package that adds many extensions to the built-in database/sql package to simplify the writing of database operation code.

Because the database/sql interface is a subset of sqlx, all uses of database/sql can also be used in sqlx. However, sqlx has more extensions and is easier to use.

Installation:

Go get github.com/jmoiron/sqlx

Query the Select () method

Select is a very time-saving extension. They combine query with the very flexible scan syntax. Select is used to obtain the result slice:

/ / the tag tag here makes sense. The following Select () method should be the type Person struct {ID int `db: "user_id" `Username sql.NullString `db: "username" `Gender sql.NullString `db: "gender" `Email sql.NullString `db: "email" `} func select () {var persons [] Person / / the slice if err: = DB.Select (& person, "select * from person where userid >?", 1) is created here to store the structure. Err! = nil {fmt.Println ("Select ERROR:", err) return} fmt.Println (person)}

Select can improve coding efficiency, and there are more extensions. Sqlx is known as the golang database development artifact, so I'll mention it here and wait until I really use it to learn more about it.

Mysql transaction

The characteristics of the transaction:

Atomicity

Consistency

Isolation

Persistence

Steps to implement a transaction

Import "github.com/jmoiron/sqlx": import third-party library sqlx

Db.Begin (): declare the transaction. Write at the beginning of the operation

Db.Submit (): commit the transaction after all transactions are completed. Write at the end of the operation

Db.Rollback (): if there is a failure, roll back. Write it in the judgment statement that returns err

After the Db.Begin () method returns conn, the subsequent operation is to operate on the conn object:

Func main () {conn, err: = Db.Begin () if err! = nil {return} r, err: = conn.Exec ("insert into person (username, sex, email) values", "stu001", "man", "stu01@qq.com" if err! = nil {fmt.Println ("exec failed," Err) conn.Rollback () return} id, err: = r.LastInsertId () if err! = nil {fmt.Println ("exec failed,", err) conn.Rollback () return} r, err: = conn.Exec ("insert into person (username, sex, email) values", "stu001", "man" "stu01@qq.com") if err! = nil {fmt.Println ("exec failed,", err) conn.Rollback () return} fmt.Println ("insert succ:", id) conn.Commit ()} on how to understand http and mysql in the Go language, that's all. I hope the above content can be of some help to you and learn more knowledge. If you think the article is good, you can share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.