65 |
66 | Lo anterior se puede lograr para arrancar en beego en el pasado, como se demuestra en la figura es la integración de la feria se produjo después de las representaciones:
67 |
68 | 
69 |
70 | Figure 14.3 Construction site interface based bootstrap
71 |
72 | Estas plantillas y formatos oficiales de arranque tiene que ofrecer no se repetirá aquí pegar código, podemos iniciarla en el sitio web oficial para aprender a escribir las plantillas.
73 |
74 | ## Links
75 |
76 | - [Directory](preface.md)
77 | - Previous section: [Develop web framework](14.0.md)
78 | - Next section: [Session](14.2.md)
79 |
--------------------------------------------------------------------------------
/eBook/05.4.md:
--------------------------------------------------------------------------------
1 | # 5.4 PostgreSQL
2 |
3 | PostgreSQL es un sistema gestor de bases de datos objeto-relacional disponible para muchas plataformas, incluyendo Linux, FreeBSD, Solaris, Microsoft Windows y Mac OS X. Está liberado bajo una licencia de estilo MIT, y es por lo tanto software libre de código abierto. Es más grande que MySQL, pues está diseñada para un uso empresarial como Oracle. Así que es una buena opción usar PostgreSQL en proyectos empresariales.
4 |
5 | ## Drivers de PostgreSQL
6 |
7 | Hay muchos drivers para la base de datos PostgreSQL, y tres de ellos son los siguientes:
8 |
9 | - [https://github.com/bmizerany/pq](https://github.com/bmizerany/pq) suporta `database/sql`, puro código Go.
10 | - [https://github.com/jbarham/gopgsqldriver](https://github.com/jbarham/gopgsqldriver) suporta `database/sql`, puro código Go.
11 | - [https://github.com/lxn/go-pgsql](https://github.com/lxn/go-pgsql) suporta `database/sql`, puro código Go.
12 |
13 | Voy a utilizar el primero para los siguientes ejemplos.
14 |
15 | ## Ejemplos
16 |
17 | Creamos el SQL de la siguiente forma:
18 |
19 | ```sql
20 | CREATE TABLE userinfo
21 | (
22 | uid serial NOT NULL,
23 | username character varying(100) NOT NULL,
24 | departname character varying(500) NOT NULL,
25 | Created date,
26 | CONSTRAINT userinfo_pkey PRIMARY KEY (uid)
27 | )
28 | WITH (OIDS=FALSE);
29 | ```
30 |
31 | Un ejemplo:
32 |
33 | ```go
34 | package main
35 |
36 | import (
37 | "database/sql"
38 | "fmt"
39 | _ "github.com/bmizerany/pq"
40 | "time"
41 | )
42 |
43 | const (
44 | DB_USER = "postgres"
45 | DB_PASSWORD = "postgres"
46 | DB_NAME = "test"
47 | )
48 |
49 | func main() {
50 | dbinfo := fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable",
51 | DB_USER, DB_PASSWORD, DB_NAME)
52 | db, err := sql.Open("postgres", dbinfo)
53 | checkErr(err)
54 | defer db.Close()
55 |
56 | fmt.Println("# Inserting values")
57 |
58 | var lastInsertId int
59 | err = db.QueryRow("INSERT INTO userinfo(username,departname,created) VALUES($1,$2,$3) returning uid;", "astaxie", "研发部门", "2012-12-09").Scan(&lastInsertId)
60 | checkErr(err)
61 | fmt.Println("last inserted id =", lastInsertId)
62 |
63 | fmt.Println("# Updating")
64 | stmt, err := db.Prepare("update userinfo set username=$1 where uid=$2")
65 | checkErr(err)
66 |
67 | res, err := stmt.Exec("astaxieupdate", lastInsertId)
68 | checkErr(err)
69 |
70 | affect, err := res.RowsAffected()
71 | checkErr(err)
72 |
73 | fmt.Println(affect, "rows changed")
74 |
75 | fmt.Println("# Querying")
76 | rows, err := db.Query("SELECT * FROM userinfo")
77 | checkErr(err)
78 |
79 | for rows.Next() {
80 | var uid int
81 | var username string
82 | var department string
83 | var created time.Time
84 | err = rows.Scan(&uid, &username, &department, &created)
85 | checkErr(err)
86 | fmt.Println("uid | username | department | created ")
87 | fmt.Printf("%3v | %8v | %6v | %6v\n", uid, username, department, created)
88 | }
89 |
90 | fmt.Println("# Deleting")
91 | stmt, err = db.Prepare("delete from userinfo where uid=$1")
92 | checkErr(err)
93 |
94 | res, err = stmt.Exec(lastInsertId)
95 | checkErr(err)
96 |
97 | affect, err = res.RowsAffected()
98 | checkErr(err)
99 |
100 | fmt.Println(affect, "rows changed")
101 | }
102 |
103 | func checkErr(err error) {
104 | if err != nil {
105 | panic(err)
106 | }
107 | }
108 | ```
109 |
110 | Tenga en cuenta que PostgreSQL usa formato como `$1,$2` en vez de `?` como en MySQL, y tiene un formato diferente de DSN en `sql.Open`.
111 | Otra cosa es que Postgres no soporta `sql.Result.LastInsertId()`.
112 | Por eso en vez de esto,
113 |
114 | ```go
115 | stmt, err := db.Prepare("INSERT INTO userinfo(username,departname,created) VALUES($1,$2,$3);")
116 | res, err := stmt.Exec("astaxie", "研发部门", "2012-12-09")
117 | fmt.Println(res.LastInsertId())
118 | ```
119 |
120 | Usamos esto `db.QueryRow()` y esto `.Scan()` para obtener el valor del ultimo id insertado.
121 |
122 | ```go
123 | err = db.QueryRow("INSERT INTO TABLE_NAME values($1) returning uid;", VALUE1").Scan(&lastInsertId)
124 | fmt.Println(lastInsertId)
125 | ```
126 |
127 | ## Enlaces
128 |
129 | - [Indice](preface.md)
130 | - Sección anterior: [SQLite](05.3.md)
131 | - Siguiente sección: [Desarrollo de un ORM basado en beedb](05.5.md)
132 |
--------------------------------------------------------------------------------
/eBook/05.6.md:
--------------------------------------------------------------------------------
1 | # 5.6 NoSQL database
2 |
3 | Una base de datos NoSQL proporciona un mecanismo para el almacenamiento y recuperación de datos que utilizan modelos de consistencia más debiles que las base de datos relacionales para lograr una escala más horizontal y una mayor disponibilidad. Algunos autores se refieren a ellas como "No sólo SQL" para enfatizar que algunos sistemas NoSQL permiten un lenguaje de consulta similar al SQL para ser utilizado.
4 |
5 | Como el lenguaje C de siglo 21, Go tiene un buen soporte para bases de datos NoSQL, y las bases de datos NoSQL más populares incluyendo redis, mongoDB, Cassandra y Membase.
6 |
7 | ## Redis
8 |
9 | Redis es un sistema de almacenamiento clave-valor como Memcached, soporta string, list, set y zset(set ordenado) ya que evalua tipos.
10 |
11 | Acá hay algunos drivers de base de datos de Go para redis:
12 |
13 | - [https://github.com/alphazero/Go-Redis](https://github.com/alphazero/Go-Redis)
14 | - [http://code.google.com/p/tideland-rdc/](http://code.google.com/p/tideland-rdc/)
15 | - [https://github.com/simonz05/godis](https://github.com/simonz05/godis)
16 | - [https://github.com/hoisie/redis.go](https://github.com/hoisie/redis.go)
17 |
18 | Le hice un fork al ultimo y le corregí algunos bugs, lo uso en mi servicio para acortar URL(2 millones de PV cada día).
19 |
20 | - [https://github.com/astaxie/goredis](https://github.com/astaxie/goredis)
21 |
22 | Vamos a ver cómo utilizar el driver al que le realicé el fork para operar la base de datos:
23 |
24 | ```go
25 | package main
26 |
27 | import (
28 | "github.com/astaxie/goredis"
29 | "fmt"
30 | )
31 |
32 | func main() {
33 | var client goredis.Client
34 |
35 | // Set the default port in Redis
36 | client.Addr = "127.0.0.1:6379"
37 |
38 | // string manipulation
39 | client.Set("a", []byte("hello"))
40 | val, _ := client.Get("a")
41 | fmt.Println(string(val))
42 | client.Del("a")
43 |
44 | // list operation
45 | vals := []string{"a", "b", "c", "d", "e"}
46 | for _, v := range vals {
47 | client.Rpush("l", []byte(v))
48 | }
49 | dbvals,_ := client.Lrange("l", 0, 4)
50 | for i, v := range dbvals {
51 | println(i,":",string(v))
52 | }
53 | client.Del("l")
54 | }
55 | ```
56 |
57 | Podemos ver que es muy fácil de operar redis en Go, y tiene un alto rendimiento. Su cliente de comandos es casi lo mismos que los mismo comandos que incorpora redis.
58 |
59 | ## mongoDB
60 |
61 | mongoDB (de "descomunal") es un sistema de base de datos orientada a documentos, de código abierto desarrollada y apoyada por 10gen. Es parte de la familia de los sistemas de base de datos NoSQL. En lugar de almacenar datos en tablas como se hace en una base de datos relacional "clásica", MongoDB guarda los datos estructurados como documentos JSON-like con esquemas dinámicos (MongoDB llama al formato BSON), por lo que la integración de datos en ciertos tipos de aplicaciones es más fácil y más rápido.
62 |
63 | 
64 |
65 | Figura 5.1 Comparación de MongoDB con Mysql
66 |
67 | El mejor driver para mongoDB se llama `mgo`, y es posible que este en la librería estándar en el futuro.
68 |
69 | Acá un ejemplo:
70 |
71 | ```go
72 | package main
73 |
74 | import (
75 | "fmt"
76 | "labix.org/v2/mgo"
77 | "labix.org/v2/mgo/bson"
78 | )
79 |
80 | type Person struct {
81 | Name string
82 | Phone string
83 | }
84 |
85 | func main() {
86 | session, err := mgo.Dial("server1.example.com,server2.example.com")
87 | if err != nil {
88 | panic(err)
89 | }
90 | defer session.Close()
91 |
92 | session.SetMode(mgo.Monotonic, true)
93 |
94 | c := session.DB("test").C("people")
95 | err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
96 | &Person{"Cla", "+55 53 8402 8510"})
97 | if err != nil {
98 | panic(err)
99 | }
100 |
101 | result := Person{}
102 | err = c.Find(bson.M{"name": "Ale"}).One(&result)
103 | if err != nil {
104 | panic(err)
105 | }
106 |
107 | fmt.Println("Phone:", result.Phone)
108 | }
109 | ```
110 |
111 | Podemos ver que no hay grandes diferencias para operar la base de datos entre mgo y beedb, ambos están basados en struct, esto es lo que se estila en Go.
112 |
113 | ## Enlaces
114 |
115 | - [Indice](preface.md)
116 | - Sección anterior: [Desarrollo de un ORM basado en beedb](05.5.md)
117 | - Siguiente sección: [Resumen](05.7.md)
--------------------------------------------------------------------------------
/eBook/03.3.md:
--------------------------------------------------------------------------------
1 | # 3.3 Como trabaja Go con la web
2 |
3 | Hemos aprendido a utilizar el paquete `net/http` para construir un sencillo servidor web en el apartado anterior, pero todos los principios de trabajo son las mismas que hemos hablado en la primera sección de este capítulo .
4 |
5 | ## Algunos conceptos de los principios de trabajo web
6 |
7 | Request: solicitar datos de los usuarios, incluyendo la POST , GET, la Cookie y la URL.
8 |
9 | Response: datos de respuesta desde el servidor a los clientes.
10 |
11 | Conn: conexiones entre clientes y servidores.
12 |
13 | Handler: lógica para la gestión de solicitudes y respuestas de productos.
14 |
15 | ## Mecanismo de funcionamiento del paquete http
16 |
17 | La siguiente imagen muestra el flujo de trabajo del servidor web de Go.
18 |
19 | 
20 |
21 | Figura flujo de trabajo 3.9 http
22 |
23 | 1. Crear socket y escucha en un puerto, esperando a los clientes .
24 | 2. Acepta peticiones de los clientes .
25 | 3. Tramitar las solicitudes, leer el encabezado HTTP, si se utiliza el método POST, también es necesario para leer los datos en el cuerpo del mensaje y signar a los controladores. Por último , devuelve datos de respuesta a los clientes.
26 |
27 | Una vez que conocemos las respuestas a lastres preguntas siguientes , es fácil saber cómo funciona la web en Go.
28 |
29 | - ¿Cómo escuchar un puerto?
30 | - ¿Cómo aceptar peticiones de cliente ?
31 | - ¿Cómo asignar controladores ?
32 |
33 | En la sección anterior vimos que Go utiliza ListenAndServe para manejar estos problemas : inicializar un objeto de servidor , llame net.Listen ( " tcp" , addr ) para configurar un puerto TCP de escucha y escuchar a la dirección y el puerto específico.
34 |
35 | Vamos a echar un vistazo a el código fuente del paquete `http`.
36 |
37 | //Build version go1.1.2.
38 | func (srv *Server) Serve(l net.Listener) error {
39 | defer l.Close()
40 | var tempDelay time.Duration // how long to sleep on accept failure
41 | for {
42 | rw, e := l.Accept()
43 | if e != nil {
44 | if ne, ok := e.(net.Error); ok && ne.Temporary() {
45 | if tempDelay == 0 {
46 | tempDelay = 5 * time.Millisecond
47 | } else {
48 | tempDelay *= 2
49 | }
50 | if max := 1 * time.Second; tempDelay > max {
51 | tempDelay = max
52 | }
53 | log.Printf("http: Accept error: %v; retrying in %v", e, tempDelay)
54 | time.Sleep(tempDelay)
55 | continue
56 | }
57 | return e
58 | }
59 | tempDelay = 0
60 | c, err := srv.newConn(rw)
61 | if err != nil {
62 | continue
63 | }
64 | go c.serve()
65 | }
66 | }
67 |
68 | ¿Cómo aceptar peticiones de cliente después de escuchar el puerto? En el código fuente , podemos ver que se llama `srv.Serve(net.Listener)` para manejar peticiones de clientes . En el cuerpo de la función hay un `for{}`, se acepta la solicitud, se crea una nueva conexión y, a continuación, se inicia un nuevo goroutine , y pasa los datos de solicitud a esta goroutine: `go c.serve()`. Así es como Go es compatible con alta concurrencia , y cada goroutine es independiente.
69 |
70 | Ahora, la forma de utilizar las funciones específicas para controlar las solicitudes? `conn` analiza la solicitud `c.ReadRequest()` al principio, y consegui el controlador correspondiente `handler : = c.server.Handler` que es el segundo argumento que pasábamos cuando llamamos `ListenAndServe`. Porque pasamos `nil`, por lo que Go usa su manejador controlador `handler = DefaultServeMux`. Entonces, ¿qué está haciendo `DefaultServeMux` aquí ? Bueno, esta es la variable de enrutador en este momento , se llama a las funciones de controlador de URL específicas . ¿Hemos fijar esto? Sí , lo hicimos. Recuerde que en la primera línea se utilizó `http.HandleFunc("/", sayhelloName)`. Es asi como se utiliza esta función para registrar el estado del router para la ruta "/". Cuando la dirección URL es `/` , el enrutador llama a la función `sayhelloName` . DefaultServeMux llama ServerHTTP para obtener la función de controlador de ruta diferente , y llama `sayhelloName` en este caso. Por último , el servidor escribe los datos y la respuesta a los clientes.
71 | Flujo de trabajo detallado:
72 |
73 | 
74 |
75 | Figura 3.10 Flujo de trabajo de manejar una petición HTTP
76 |
77 | Creo que usted debe saber cómo Go se ejecuta servidores web ahora.
78 |
79 | ## Enlaces
80 |
81 | - [Indice](preface.md)
82 | - Sección anterior: [Armando un servidor web sencillo](03.2.md)
83 | - Siguiente sección: [Obteniendo el paquete http](03.4.md)
84 |
--------------------------------------------------------------------------------
/eBook/05.2.md:
--------------------------------------------------------------------------------
1 | # 5.2 MySQL
2 |
3 | Los framework llamados LAMP se hicieron muy popular en internet en los últimos años, y la M es de MySQL. MySQL es conocida por ser open source, sencilla de usar, por eso se convirtio en la base de datos en el back-end de muchos sitios web.
4 |
5 | ## Drivers MySQL
6 |
7 | Hay un par de drivers que soportan MySQL en Go, algunos de ellos implementados con la interfaz `database/sql`, y algunos de ellos usan su propia interfaz como estandar.
8 |
9 | - [https://github.com/go-sql-driver/mysql](https://github.com/go-sql-driver/mysql) soporta `database/sql`, puro código Go.
10 | - [https://github.com/ziutek/mymysql](https://github.com/ziutek/mymysql) soporta `database/sql` y el usuario define la interfaz, puro código Go.
11 | - [https://github.com/Philio/GoMySQL](https://github.com/Philio/GoMySQL) solo es compatible con la interfaz definida por el usuario, puro código Go.
12 |
13 | Voy a usar el primer driver en los futuros ejemplos (Utilizo tambien el mismo en mis proyectos), y recomiendo su uso por las siguientes razones:
14 |
15 | - Es un nuevo driver y soporta más características.
16 | - Soporte completo para la interfaz estandar `databse/sql`.
17 | - Soporta keepalive, largas conexiones con thread-safe.
18 |
19 | ## Ejemplos
20 |
21 | En las siguientes secciones, voy a usar la misma estuctura de tabla para las diferentes base de datos, el SQL para crearla es el siguiente:
22 |
23 | ```sql
24 | CREATE TABLE `userinfo` (
25 | `uid` INT(10) NOT NULL AUTO_INCREMENT,
26 | `username` VARCHAR(64) NULL DEFAULT NULL,
27 | `departname` VARCHAR(64) NULL DEFAULT NULL,
28 | `created` DATE NULL DEFAULT NULL,
29 | PRIMARY KEY (`uid`)
30 | );
31 | ```
32 |
33 | El siguiente ejemplo nos muestra como manejar la base de datos basado en la interfaz estandar `database/sql`.
34 |
35 | ```go
36 | package main
37 |
38 | import (
39 | _ "github.com/go-sql-driver/mysql"
40 | "database/sql"
41 | "fmt"
42 | )
43 |
44 | func main() {
45 | db, err := sql.Open("mysql", "astaxie:astaxie@/test?charset=utf8")
46 | checkErr(err)
47 |
48 | // insert
49 | stmt, err := db.Prepare("INSERT userinfo SET username=?,departname=?,created=?")
50 | checkErr(err)
51 |
52 | res, err := stmt.Exec("astaxie", "研发部门", "2012-12-09")
53 | checkErr(err)
54 |
55 | id, err := res.LastInsertId()
56 | checkErr(err)
57 |
58 | fmt.Println(id)
59 | // update
60 | stmt, err = db.Prepare("update userinfo set username=? where uid=?")
61 | checkErr(err)
62 |
63 | res, err = stmt.Exec("astaxieupdate", id)
64 | checkErr(err)
65 |
66 | affect, err := res.RowsAffected()
67 | checkErr(err)
68 |
69 | fmt.Println(affect)
70 |
71 | // query
72 | rows, err := db.Query("SELECT * FROM userinfo")
73 | checkErr(err)
74 |
75 | for rows.Next() {
76 | var uid int
77 | var username string
78 | var department string
79 | var created string
80 | err = rows.Scan(&uid, &username, &department, &created)
81 | checkErr(err)
82 | fmt.Println(uid)
83 | fmt.Println(username)
84 | fmt.Println(department)
85 | fmt.Println(created)
86 | }
87 |
88 | // delete
89 | stmt, err = db.Prepare("delete from userinfo where uid=?")
90 | checkErr(err)
91 |
92 | res, err = stmt.Exec(id)
93 | checkErr(err)
94 |
95 | affect, err = res.RowsAffected()
96 | checkErr(err)
97 |
98 | fmt.Println(affect)
99 |
100 | db.Close()
101 |
102 | }
103 |
104 | func checkErr(err error) {
105 | if err != nil {
106 | panic(err)
107 | }
108 | }
109 | ```
110 |
111 | Voy a explicar algunas funciones importantes:
112 |
113 | - `sql.Open()` abre el registro de la base de datos a travez del driver, aquí Go-MySQL-Driver registra el driver de mysql. El segundo argumento es el DSN(Data Source Name) que define información de la conexión a la base de datos, este soporta los siguientes formatos:
114 |
115 | user@unix(/path/to/socket)/dbname?charset=utf8
116 | user:password@tcp(localhost:5555)/dbname?charset=utf8
117 | user:password@/dbname
118 | user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname
119 |
120 | - `db.Prepare()` nos devuelve la operación SQL que se va a ejecutar, también nos retorna el estado despues de la ejecución del SQL.
121 | - `db.Query()` ejecuta el SQL y nos devuelve Rows de resultado.
122 | - `stmt.Exec()` ejecuta el SQL que es preparado en Stmt.
123 |
124 | Tenga en cuenta que usamos el formato `=?` para pasarle los argumentos, esto es para prevenir inyecciones SQL.
125 |
126 | ## Enlaces
127 |
128 | - [Indice](preface.md)
129 | - Sección anterior: [database/sql interfaz](05.1.md)
130 | - Siguiente sección: [SQLite](05.3.md)
--------------------------------------------------------------------------------
/eBook/06.3.md:
--------------------------------------------------------------------------------
1 | # 6.3 almacenamiento Sesión
2 |
3 | Introdujimos sobre los principios de como trabajar con en manejo de sesiones en seccón anterior, hemos definido una interfaz para el almacenamiento de sesiones. En esta sección, voy a mostrar un ejemplo de motor de almacenamiento de sesiones basado en memoria que implementa la interfaz. Usted puedrá cambiar esto a otras formas de almacenamiento de sesiones.
4 |
5 | ```go
6 | package memory
7 |
8 | import (
9 | "container/list"
10 | "github.com/astaxie/session"
11 | "sync"
12 | "time"
13 | )
14 |
15 | var pder = &Provider{list: list.New()}
16 |
17 | type SessionStore struct {
18 | sid string // unique session id
19 | timeAccessed time.Time // last access time
20 | value map[interface{}]interface{} // session value stored inside
21 | }
22 |
23 | func (st *SessionStore) Set(key, value interface{}) error {
24 | st.value[key] = value
25 | pder.SessionUpdate(st.sid)
26 | return nil
27 | }
28 |
29 | func (st *SessionStore) Get(key interface{}) interface{} {
30 | pder.SessionUpdate(st.sid)
31 | if v, ok := st.value[key]; ok {
32 | return v
33 | } else {
34 | return nil
35 | }
36 | return nil
37 | }
38 |
39 | func (st *SessionStore) Delete(key interface{}) error {
40 | delete(st.value, key)
41 | pder.SessionUpdate(st.sid)
42 | return nil
43 | }
44 |
45 | func (st *SessionStore) SessionID() string {
46 | return st.sid
47 | }
48 |
49 | type Provider struct {
50 | lock sync.Mutex // lock
51 | sessions map[string]*list.Element // save in memory
52 | list *list.List // gc
53 | }
54 |
55 | func (pder *Provider) SessionInit(sid string) (session.Session, error) {
56 | pder.lock.Lock()
57 | defer pder.lock.Unlock()
58 | v := make(map[interface{}]interface{}, 0)
59 | newsess := &SessionStore{sid: sid, timeAccessed: time.Now(), value: v}
60 | element := pder.list.PushBack(newsess)
61 | pder.sessions[sid] = element
62 | return newsess, nil
63 | }
64 |
65 | func (pder *Provider) SessionRead(sid string) (session.Session, error) {
66 | if element, ok := pder.sessions[sid]; ok {
67 | return element.Value.(*SessionStore), nil
68 | } else {
69 | sess, err := pder.SessionInit(sid)
70 | return sess, err
71 | }
72 | return nil, nil
73 | }
74 |
75 | func (pder *Provider) SessionDestroy(sid string) error {
76 | if element, ok := pder.sessions[sid]; ok {
77 | delete(pder.sessions, sid)
78 | pder.list.Remove(element)
79 | return nil
80 | }
81 | return nil
82 | }
83 |
84 | func (pder *Provider) SessionGC(maxlifetime int64) {
85 | pder.lock.Lock()
86 | defer pder.lock.Unlock()
87 |
88 | for {
89 | element := pder.list.Back()
90 | if element == nil {
91 | break
92 | }
93 | if (element.Value.(*SessionStore).timeAccessed.Unix() + maxlifetime) < time.Now().Unix() {
94 | pder.list.Remove(element)
95 | delete(pder.sessions, element.Value.(*SessionStore).sid)
96 | } else {
97 | break
98 | }
99 | }
100 | }
101 |
102 | func (pder *Provider) SessionUpdate(sid string) error {
103 | pder.lock.Lock()
104 | defer pder.lock.Unlock()
105 | if element, ok := pder.sessions[sid]; ok {
106 | element.Value.(*SessionStore).timeAccessed = time.Now()
107 | pder.list.MoveToFront(element)
108 | return nil
109 | }
110 | return nil
111 | }
112 |
113 | func init() {
114 | pder.sessions = make(map[string]*list.Element, 0)
115 | session.Register("memory", pder)
116 | }
117 | ```
118 |
119 | En el ejemplo anterior se puso en marcha un mecanismo de almacenamiento de sesiones basado en memoria, a continuación, vamos a utilizar la función `init()` para registrar este motor de almacenamiento al administrador de sesiones. Entonces, ¿cómo registramos este motor?
120 |
121 | ```go
122 | import (
123 | "github.com/astaxie/session"
124 | _ "github.com/astaxie/session/providers/memory"
125 | )
126 | ```
127 |
128 | Usamos el mecanisco import para registrar este motor en la función init() automaticamente al manejador de sesiones, entonces vamos a usar el siguiente código para inicializar el manejador de sesiones:
129 |
130 | ```go
131 | var globalSessions *session.Manager
132 |
133 | // initialize in init() function
134 | func init() {
135 | globalSessions, _ = session.NewManager("memory", "gosessionid", 3600)
136 | go globalSessions.GC()
137 | }
138 | ```
139 |
140 | ## Enlaces
141 |
142 | - [Indice](preface.md)
143 | - Sección anterior: [Como usar sesiones en Go](06.2.md)
144 | - Siguiente sección: [Prevenir hijack de la sesión](06.4.md)
--------------------------------------------------------------------------------
/eBook/07.6.md:
--------------------------------------------------------------------------------
1 | # 7.6 cadenas de texto
2 |
3 | Casi todo lo que vemos está representado por string, por lo que es una parte muy importante del desarrollo web, incluyendo las entradas de usuario, acceso a bases de datos; También tenemos que dividir, unir y convertir cadenas en muchos casos. En esta sección, vamos a introducir los paquetes `strings` and `strconv` en Go biblioteca estándar.
4 |
5 | ## strings
6 |
7 | Las siguientes funciones son del package `strings`, más detalles, ver la documentación oficial:
8 |
9 | - func Contains(s, substr string) bool
10 |
11 | Compruebe si la cadena `s` contiene string `substr`, devuelve el valor booleano.
12 |
13 | fmt.Println(strings.Contains("seafood", "foo"))
14 | fmt.Println(strings.Contains("seafood", "bar"))
15 | fmt.Println(strings.Contains("seafood", ""))
16 | fmt.Println(strings.Contains("", ""))
17 | //Output:
18 | //true
19 | //false
20 | //true
21 | //true
22 |
23 | - func Join(a []string, sep string) string
24 |
25 | Combina strings de un slice con el separador `sep`.
26 |
27 | s := []string{"foo", "bar", "baz"}
28 | fmt.Println(strings.Join(s, ", "))
29 | //Output:foo, bar, baz
30 |
31 | - func Index(s, sep string) int
32 |
33 | Encuentra el index `sep` en el string `s`, retorna -1 si no lo encuentra.
34 |
35 | fmt.Println(strings.Index("chicken", "ken"))
36 | fmt.Println(strings.Index("chicken", "dmr"))
37 | //Output:4
38 | //-1
39 |
40 | - func Repeat(s string, count int) string
41 |
42 | Repite el string `s` con `count` veces.
43 |
44 | fmt.Println("ba" + strings.Repeat("na", 2))
45 | //Output:banana
46 |
47 | - func Replace(s, old, new string, n int) string
48 |
49 | Reemplaza el string `old` con el string `new` en el string `s`, `n` ignifica tiempos de replicación, si n es menor que 0 significa reemplazar todos.
50 |
51 | fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
52 | fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
53 | //Output:oinky oinky oink
54 | //moo moo moo
55 |
56 | - func Split(s, sep string) []string
57 |
58 | Separar el string `s` con el separador `sep` en el slice.
59 |
60 | fmt.Printf("%q\n", strings.Split("a,b,c", ","))
61 | fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
62 | fmt.Printf("%q\n", strings.Split(" xyz ", ""))
63 | fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
64 | //Output:["a" "b" "c"]
65 | //["" "man " "plan " "canal panama"]
66 | //[" " "x" "y" "z" " "]
67 | //[""]
68 |
69 | - func Trim(s string, cutset string) string
70 |
71 | Remueve `cutset` del string `s` si esta a la derecha o izquierda.
72 |
73 | fmt.Printf("[%q]", strings.Trim(" !!! Achtung !!! ", "! "))
74 | Output:["Achtung"]
75 |
76 | - func Fields(s string) []string
77 |
78 | Remueve los espaciositems and split string with space in to a slice.
79 |
80 | fmt.Printf("Fields are: %q", strings.Fields(" foo bar baz "))
81 | //Output:Fields are: ["foo" "bar" "baz"]
82 |
83 |
84 | ## strconv
85 |
86 | Las siguientes funciones son del package `strconv` , más detalles, consulte la documentación oficial:
87 |
88 | - Append series convert data to string and append to current byte slice.
89 |
90 | package main
91 |
92 | import (
93 | "fmt"
94 | "strconv"
95 | )
96 |
97 | func main() {
98 | str := make([]byte, 0, 100)
99 | str = strconv.AppendInt(str, 4567, 10)
100 | str = strconv.AppendBool(str, false)
101 | str = strconv.AppendQuote(str, "abcdefg")
102 | str = strconv.AppendQuoteRune(str, '单')
103 | fmt.Println(string(str))
104 | }
105 |
106 | - Format series convertir otros datos de tipo de cadena.
107 |
108 | package main
109 |
110 | import (
111 | "fmt"
112 | "strconv"
113 | )
114 |
115 | func main() {
116 | a := strconv.FormatBool(false)
117 | b := strconv.FormatFloat(123.23, 'g', 12, 64)
118 | c := strconv.FormatInt(1234, 10)
119 | d := strconv.FormatUint(12345, 10)
120 | e := strconv.Itoa(1023)
121 | fmt.Println(a, b, c, d, e)
122 | }
123 |
124 | - Parse series convertir string a otros tipos.
125 |
126 | package main
127 |
128 | import (
129 | "fmt"
130 | "strconv"
131 | )
132 |
133 | func main() {
134 | a, err := strconv.ParseBool("false")
135 | if err != nil {
136 | fmt.Println(err)
137 | }
138 | b, err := strconv.ParseFloat("123.23", 64)
139 | if err != nil {
140 | fmt.Println(err)
141 | }
142 | c, err := strconv.ParseInt("1234", 10, 64)
143 | if err != nil {
144 | fmt.Println(err)
145 | }
146 | d, err := strconv.ParseUint("12345", 10, 64)
147 | if err != nil {
148 | fmt.Println(err)
149 | }
150 | e, err := strconv.Itoa("1023")
151 | if err != nil {
152 | fmt.Println(err)
153 | }
154 | fmt.Println(a, b, c, d, e)
155 | }
156 |
157 | ## Links
158 |
159 | - [Directory](preface.md)
160 | - Previous section: [Files](07.5.md)
161 | - Next section: [Summary](07.7.md)
162 |
--------------------------------------------------------------------------------
/code/src/apps/ch.5.5/main.go:
--------------------------------------------------------------------------------
1 | // Example code for Chapter 5.5
2 | // Purpose is to show to use BeeDB ORM for basic CRUD operations for sqlite3
3 | package main
4 |
5 | import (
6 | "database/sql"
7 | "fmt"
8 | "github.com/astaxie/beedb"
9 | _ "github.com/mattn/go-sqlite3"
10 | "time"
11 | )
12 |
13 | var orm beedb.Model
14 |
15 | type Userinfo struct {
16 | Uid int `beedb:"PK"`
17 | Username string
18 | Department string
19 | Created string
20 | }
21 |
22 | const DB_PATH = "./foo.db"
23 |
24 | func checkError(err error) {
25 | if err != nil {
26 | panic(err)
27 | }
28 | }
29 | func getTimeStamp() string {
30 | return time.Now().Format("2006-01-02 15:04:05")
31 | }
32 | func insertUsingStruct() int64 {
33 | fmt.Println("insertUsingStruct()")
34 | var obj Userinfo
35 | obj.Username = "Test Add User"
36 | obj.Department = "Test Add Department"
37 | obj.Created = getTimeStamp()
38 | checkError(orm.Save(&obj))
39 | fmt.Printf("%+v\n", obj)
40 | return int64(obj.Uid)
41 | }
42 | func insertUsingMap() int64 {
43 | fmt.Println("insertUsingMap()")
44 | add := make(map[string]interface{})
45 | add["username"] = "astaxie"
46 | add["department"] = "cloud develop"
47 | add["created"] = getTimeStamp()
48 | id, err := orm.SetTable("userinfo").Insert(add)
49 | checkError(err)
50 | fmt.Println("Last row inserted id =", id)
51 | return id
52 | }
53 |
54 | func getOneUserInfo(id int64) Userinfo {
55 | fmt.Println("getOneUserInfo()")
56 | var obj Userinfo
57 | checkError(orm.Where("uid=?", id).Find(&obj))
58 | return obj
59 | }
60 |
61 | func getAllUserInfo(id int64) []Userinfo {
62 | fmt.Println("getAllUserInfo()")
63 | var alluser []Userinfo
64 | checkError(orm.Limit(10).Where("uid>?", id).FindAll(&alluser))
65 | return alluser
66 | }
67 |
68 | func updateUserinfo(id int64) {
69 | fmt.Println("updateUserinfo()")
70 | var obj Userinfo
71 | obj.Uid = int(id)
72 | obj.Username = "Update Username"
73 | obj.Department = "Update Department"
74 | obj.Created = getTimeStamp()
75 | checkError(orm.Save(&obj))
76 | fmt.Printf("%+v\n", obj)
77 | }
78 |
79 | func updateUsingMap(id int64) {
80 | fmt.Println("updateUsingMap()")
81 | t := make(map[string]interface{})
82 | t["username"] = "updateastaxie"
83 | //update one
84 | // id, err := orm.SetTable("userinfo").SetPK("uid").Where(2).Update(t)
85 | //update batch
86 | lastId, err := orm.SetTable("userinfo").Where("uid>?", id).Update(t)
87 | checkError(err)
88 | fmt.Println("Last row updated id =", lastId)
89 | }
90 |
91 | func getMapsFromSelect(id int64) []map[string][]byte {
92 | fmt.Println("getMapsFromSelect()")
93 | //Original SQL Backinfo resultsSlice []map[string][]byte
94 | //default PrimaryKey id
95 | c, err := orm.SetTable("userinfo").SetPK("uid").Where(id).Select("uid,username").FindMap()
96 | checkError(err)
97 | fmt.Printf("%+v\n", c)
98 | return c
99 | }
100 |
101 | func groupby() {
102 | fmt.Println("groupby()")
103 | //Original SQL Group By
104 | b, err := orm.SetTable("userinfo").GroupBy("username").Having("username='updateastaxie'").FindMap()
105 | checkError(err)
106 | fmt.Printf("%+v\n", b)
107 | }
108 |
109 | func joinTables(id int64) {
110 | fmt.Println("joinTables()")
111 | //Original SQL Join Table
112 | a, err := orm.SetTable("userinfo").Join("LEFT", "userdetail", "userinfo.uid=userdetail.uid").Where("userinfo.uid=?", id).Select("userinfo.uid,userinfo.username,userdetail.profile").FindMap()
113 | checkError(err)
114 | fmt.Printf("%+v\n", a)
115 | }
116 |
117 | func deleteWithUserinfo(id int64) {
118 | fmt.Println("deleteWithUserinfo()")
119 | obj := getOneUserInfo(id)
120 | id, err := orm.Delete(&obj)
121 | checkError(err)
122 | fmt.Println("Last row deleted id =", id)
123 | }
124 |
125 | func deleteRows() {
126 | fmt.Println("deleteRows()")
127 | //original SQL delete
128 | id, err := orm.SetTable("userinfo").Where("uid>?", 2).DeleteRow()
129 | checkError(err)
130 | fmt.Println("Last row updated id =", id)
131 | }
132 |
133 | func deleteAllUserinfo(id int64) {
134 | fmt.Println("deleteAllUserinfo()")
135 | //delete all data
136 | alluser := getAllUserInfo(id)
137 | id, err := orm.DeleteAll(&alluser)
138 | checkError(err)
139 | fmt.Println("Last row updated id =", id)
140 | }
141 | func main() {
142 | db, err := sql.Open("sqlite3", DB_PATH)
143 | checkError(err)
144 | orm = beedb.New(db)
145 | var lastIdInserted int64
146 |
147 | fmt.Println("Inserting")
148 | lastIdInserted = insertUsingStruct()
149 | insertUsingMap()
150 |
151 | a := getOneUserInfo(lastIdInserted)
152 | fmt.Println(a)
153 |
154 | b := getAllUserInfo(lastIdInserted)
155 | fmt.Println(b)
156 |
157 | fmt.Println("Updating")
158 | updateUserinfo(lastIdInserted)
159 | updateUsingMap(lastIdInserted)
160 |
161 | fmt.Println("Querying")
162 | getMapsFromSelect(lastIdInserted)
163 | groupby()
164 | joinTables(lastIdInserted)
165 |
166 | fmt.Println("Deleting")
167 | deleteWithUserinfo(lastIdInserted)
168 | deleteRows()
169 | deleteAllUserinfo(lastIdInserted)
170 | }
171 |
--------------------------------------------------------------------------------