golang网络编程day5
golang网络编程day5
- golang cookie实现记住我功能
- golang cookie实现购物车功能
- golang cookie CSRF防御应用
- golang session
- golang session 用户身份验证应用
- golang session应用程序中的状态管理
- golang实现在线人数统计
- golang session购物车应用
- golang session用户个性化设置应用
golang实现记住我功能
package main
import (
"fmt"
"net/http"
"time"
)
func main() {
http.HandleFunc("/login", func(w http.ResponseWriter, r *http.Request) {
// 验证用户名和密码
username := r.FormValue("username")
password := r.FormValue("password")
if username == "admin" && password == "admin123" {
// 设置记住我Cookie
cookie := &http.Cookie{
Name: "remember_me",
Value: "1",
Expires: time.Now().Add(30 * 24 * time.Hour),
}
http.SetCookie(w, cookie)
fmt.Fprint(w, "Login successful.")
return
}
http.Error(w, "Invalid username or password", http.StatusUnauthorized)
})
http.HandleFunc("/home", func(w http.ResponseWriter, r *http.Request) {
// 检查记住我Cookie
cookie, err := r.Cookie("remember_me")
if err == nil && cookie.Value == "1" {
fmt.Fprint(w, "Welcome back!")
return
}
// 显示登录页面
fmt.Fprint(w, "Please login.")
})
http.ListenAndServe(":8080", nil)
}
代码整体解读：
代码创建了一个简单的web服务器，然后具有基础的登录功能和使用Cookie实现的记住我功能。
由三个代码组成，大体是两个注册服务，最好一个启动服务。第一个实现了登录处理，第二个实现了记住我处理。
代码详细解读：
http.HandleFunc("/login", func(w http.ResponseWriter, r *http.Request) {
// 验证用户名和密码
username := r.FormValue("username")
password := r.FormValue("password")
if username == "admin" && password == "admin123" {
// 设置记住我Cookie
cookie := &http.Cookie{
Name: "remember_me",
Value: "1",
Expires: time.Now().Add(30 * 24 * time.Hour),
}
http.SetCookie(w, cookie)
fmt.Fprint(w, "Login successful.")
return
}
username := r.FormValue(“username”)
password := r.FormValue(“password”)
从请求中拿到客户端发来的登录信息：用户名和密码
if username == "admin" && password == "admin123" {
// 设置记住我Cookie
cookie := &http.Cookie{
Name: "remember_me",
Value: "1",
Expires: time.Now().Add(30 * 24 * time.Hour),
}
http.SetCookie(w, cookie)
fmt.Fprint(w, "Login successful.")
return
}
随后负责对用户和密码的验证，如果匹配就进行下一步，否则就返回错误信息。
匹配成功：
先实例化了一个Cookie对象，这个对象就对有需要的字段进行了赋值，然后添加到响应中去，添加的方法就是用http.SetCookie()，最后打印信息。结束函数。这样就完成了对客户请求进行响应的适合把用户的Cookie发送给客户端。
第二个注册函数
http.HandleFunc("/home", func(w http.ResponseWriter, r *http.Request) {
// 检查记住我Cookie
cookie, err := r.Cookie("remember_me")
if err == nil && cookie.Value == "1" {
fmt.Fprint(w, "Welcome back!")
return
}
// 显示登录页面
fmt.Fprint(w, "Please login.")
})
这个是针对访问/home这个界面的，如过访问主页，那就会调用这个处理函数。这个处理函数会找到请求中remember_me记住我的Cookie，如果这个Cookie的值为1，那就表示用户之前选择了记住我，向用户发送欢迎。如果没找到cookie，那就显示请登录。
最后一个函数就是启动服务器监听端口。
最后总结：创建了两个路由/login和/home，在用户登录成功时，我们通过http.Cookie结构体的Expires属性设置一个长期有效的Cookie，并使用http.SetCookie函数将其添加到响应中，下次用户访问/home时，通过http.Request的Cookie函数，获取Cookie，并检查Cookie的值是否为1，如果是则表示用户已经登录，否则需要显示登录界面。
golang cookie实现购物车功能
购物车功能指的是用户在网站上选择商品后，将这些商品保存在购物车中，方便用户后续进行结算或继续购物。以下是一个Cookie实现购物车功能的实例。
package main
import (
"fmt"
"net/http"
"strconv"
"strings"
)
func main() {
http.HandleFunc("/add-to-cart", func(w http.ResponseWriter, r *http.Request) {
// 获取商品ID和数量
itemID := r.FormValue("item_id")
quantity, _ := strconv.Atoi(r.FormValue("quantity"))
// 获取购物车Cookie
cookie, err := r.Cookie("cart")
if err == http.ErrNoCookie {
// 如果没有购物车Cookie，则创建一个新的购物车Cookie
cookie = &http.Cookie{
Name: "cart",
Value: "",
}
}
// 将商品添加到购物车
cart := parseCart(cookie.Value)
cart[itemID] += quantity
// 更新购物车Cookie
cookie.Value = formatCart(cart)
http.SetCookie(w, cookie)
fmt.Fprint(w, "Item added to cart.")
})
http.HandleFunc("/view-cart", func(w http.ResponseWriter, r *http.Request) {
// 获取购物车Cookie
cookie, err := r.Cookie("cart")
if err == http.ErrNoCookie {
// 如果没有购物车Cookie，则显示空购物车
fmt.Fprint(w, "Your cart is empty.")
return
}
// 显示购物车中的商品
cart := parseCart(cookie.Value)
if len(cart) == 0 {
fmt.Fprint(w, "Your cart is empty.")
return
}
fmt.Fprintln(w, "Your cart:")
for itemID, quantity := range cart {
fmt.Fprintf(w, "- Item #%s: %d\n", itemID, quantity)
}
})
http.ListenAndServe(":8080", nil)
}
// 将字符串按分隔符分割为切片
func split(s, sep string) []string {
return strings.Split(s, sep)
}
// 将切片按分隔符拼接为字符串
func join(s []string, sep string) string {
return strings.Join(s, sep)
}
// 将购物车map格式化为字符串
func formatCart(cart map[string]int) string {
items := make([]string, 0, len(cart))
for itemID, quantity := range cart {
items = append(items, itemID+":"+strconv.Itoa(quantity))
}
return join(items, ",") // 修改分隔符为逗号 ","
}
// 将购物车字符串解析为map
func parseCart(cartStr string) map[string]int {
cart := make(map[string]int)
for _, item := range split(cartStr, ",") { // 修改分隔符为逗号 ","
if item == "" {
continue
}
parts := split(item, ":")
if len(parts) != 2 {
continue
}
id := parts[0]
quantity, err := strconv.Atoi(parts[1])
if err != nil {
continue
}
cart[id] += quantity
}
return cart
}
这个代码看着很复杂，我来进行拆分
按函数来看就可以看出功能了
首先就是下面这些不在main函数里面的，这些都是一些辅助函数（也就是工具）
主要的逻辑在main函数里面
main函数解读：
可以看到由两个handlefunc服务注册函数和一个启动服务器函数组成。
注册函数1：实现的是添加到购物车功能。
先解读里面用到的函数：
itemID := r.FormValue(“item_id”)
我再解读这个函数（因为我对Form的了解也挺少的，这个是请求结构里面的一个重要字段）
Form代表了HTTP请求中的表单数去，当一个HTTP请求是POST或PUT方法，并且内容类型是application/x-www-form-urlencoded" 或 "multipart/form-data时，表单数据被包含在请求体中。FormValue 方法是 http.Request 的一个便利方法，用于从表单数据中提取指定字段的值。当你调用 r.FormValue(“item_id”)，这个方法将查找名为 “item_id” 的表单字段，并返回其值作为字符串。
这里举个例子：
假如有个html表单，用户可以在其中输入商品ID和数量：
<form action="/add-to-cart" method="post">
<input type="text" name="item_id" />
<input type="number" name="quantity" />
<input type="submit" value="Add to Cart" />
</form>
当用户填写此表单并提交时，表单数据（包括 item_id 和 quantity 字段）会被发送到服务器的 “/add-to-cart” 路径。在服务器端，
所以在服务器端使用
r.FormValue(“item_id”) 将获取用户输入的 item_id 字段的值。
注意这个函数的返回值是字符串。
quantity, _ := strconv.Atoi(r.FormValue(“quantity”))
这里时先用上面这个方法获取到了quantity的这个字段的值，这个字段表示的时添加到购物车的商品数量。
然后strconv.Atoi函数将字符串转换成了整数，这是strconv包的一个函数，Atoi是ASCII to integer的缩写。最终这个函数返回值是转换后的整数和一个error。
cookie, err := r.Cookie(“cart”)
获取购物车的Cookie，下面有个错误判断，如果cart的Cookie不存在，那么就会新创建一个购物车Cookie。
cart := parseCart(cookie.Value)
cart[itemID] += quantity
先看这个parseCart(cookie.Value)
这个函数的逻辑是解析一个代表购物车内容的字符串，然后将其转为一个map，key是商品ID，值是商品数量。
内部逻辑：
1.创建空购物车，首先创建一个空map，名为cart，用于存储商品ID和对于的数量。
2.遍历购物车项，使用split函数以，为分隔符将cartStr字符串分割成多个购物车项，每个项的格式预期为"itemID:quantity"
3.解析每个购物车项：
分割开后的项item，如果是空字符串，跳过当前迭代
再次使用split函数，这次以：为分隔符将项分割成两部分，分别是商品ID和数量
如果分割后不是两部分，说明格式不正确，跳过当前迭代。
4.使用strconv.Atoi将数量部分转换成整数。如果转换过程中错误就跳过迭代。在map中累加对于商品ID的数量。
5.返回购物车map，最后返回包含所有有效购物车项的map。
该函数总结：有效地从简单字符串格式中提取出了复杂的数据结构，使得购物车的内容可以在Cookie中以字符串形式存储和传输
cookie.Value = formatCart(cart)
http.SetCookie(w, cookie)
说说上面这个函数
这个函数实现了将购物车的内容(map[string]int)类型标识的cart格式化为一个字符串，然后下面这个函数将这个字符串赋值给cookie的value字段，这就完成了购物车的数据更新。
函数内部：这个函数内部做了将购物车map作为输入，然后map的键是商品ID，value是对于的数量，然后将每个商品ID和它的数量转换成"itemID:quantity"格式的字符串，并将这些字符串用，连接。最终形成一个单一的字符串作为返回值。然后这个拼接成的字符串就赋值给了cookie.Value使得购物车的内容可以存储在一个HTTP的Cookie中。这样当客户端发送请求时，服务器能够通过解析这个Cookie来重建用户的购物车状态。
第二个注册函数：
这个函数定义了查看购物车路径请求的响应。用于显示购物车中的商品。
1.先获取了购物车的Cookie，如果没有找到购物车的Cookie，则代表购物车为空，返回给客户端信息，”你的购物车为空“。
2.解析购物车的内容，就是将购物车对应的Cookie的内容全转成购物车map，其中键是商品id，value是数量。
3.检查购物车是否为空，检查cart的长度是0就代表购物车空，再次发送你的购物车为空的信息。
4.遍历这个cart就是显示购物车的内容，然后并把这个内容发送回客户的响应。
最后启动服务器。
总结过程：
用户访问/add-to-Cart路由时，会获取商品的ID和数量，然后通过Request的Cookie函数，获取购物车的Cookie，如果没有购物车那就创建一个新的购物车Cookie，然后将商品添加到购物车中，更新购物车，最后通过setCookie将购物车的Cookie协会客户端中。
当用户访问/view-cart路由时，会通过Request的Cookie函数获取购物车的Cookie，如果没有购物车，则显示购物车为空，发否则解析购物车Cookie并显示购物车中的商品。
购物车的数据时一个字符串，格式为"item_id1:quantity1;item_id2:quantity2;…其中前者标识商品ID后者标识商品数量，为了方便解析和格式化购物车数据，搞了很多辅助函数。
golang cookie CSRF防御应用
什么是CSRF？
在Web应用中，CSRF攻击是一种常见的威胁，攻击者利用用户登录的登录状态伪造请求来执行未授权的操作。常见的CSRF攻击恶意修改用户资料、发起转账、删除数据等。
为了防御CSRF攻击，我们可以在Cookie中添加CSRF Token，并在每次请求中验证Token的而正确性。
1.在登录成功后生成一个CSRF Token并将其保存在Cookie中
func loginHandler(w http.ResponseWriter, r *http.Request) {
// 验证用户名和密码...
// 生成 CSRF Token
csrfToken := generateCSRFToken()
// 将 CSRF Token 保存到 Cookie 中
http.SetCookie(w, &http.Cookie{
Name: "csrf_token",
Value: csrfToken,
HttpOnly: true,
Secure: true,
})
// 重定向到首页
http.Redirect(w, r, "/", http.StatusFound)
}
- 在每次请求中验证CSRF Token的正确性：
func editProfileHandler(w http.ResponseWriter, r *http.Request) {
// 获取用户提交的数据...
// 验证 CSRF Token 的正确性
csrfToken := r.FormValue("csrf_token")
if csrfToken != getCSRFTokenFromCookie(r) {
http.Error(w, "Invalid CSRF Token", http.StatusForbidden)
return
}
// 更新用户资料...
// 返回结果页面...
}
其中getCSRF…是一个复杂函数，用于从请求中获取CSRF Token的值
func getCSRFTokenFromCookie(r *http.Request) string {
cookie, err := r.Cookie("csrf_token")
if err != nil {
return ""
}
return cookie.Value
}
这个示例中我们将CSRF Token保存在Cookie中，并使用HTTPOnly和Secure选项来增强安全性，每次请求都会验证用户提交的CSRF Token和Cookie中保存的CSRF Token是否一致性来判断合法性。
golang session
在Web应用中，Session用于存储用户的会话状态，包括用户登录状态、购物车数据、表单数据等。Session通常使用Cookie来实现，在服务端保存Session数据，并在客户端保存Session ID。客户端在每次请求中通过Cookie将Session ID发送到服务端，服务端根据Session ID获取对应的Session数据。
go语言中要使用第三方库来实现Session的功能，来看示例：
1.导入这个第三方包
import (
"github.com/gorilla/sessions"
)
2.创建一个Session存储器
store := sessions.NewCookieStore([]byte("my-secret-key"))
参数是加密密钥，用来保护session数据的安全性。
3.在处理请求的函数中使用Session
func myHandler(w http.ResponseWriter, r *http.Request) {
// 获取Session
session, err := store.Get(r, "my-session")
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// 操作Session
session.Values["foo"] = "bar"
session.Save(r, w)
// 返回响应
fmt.Fprintf(w, "Session value set to %s", session.Values["foo"])
}
使用store.Get函数来获取请求中名为my-session的Session，然后通过session的方法来操作Session的数据，在操作完之后，session.Save(r, w)通过这个函数写回到Cookie中，并通过http.ResponseWriter将响应发送给客户端。
在实际应用中Session还有很多的字段。可以用来操作。比如可以设置Session的过期时间，Session的域名和路径、Session的安全选项等。
golang session 用户身份验证应用
在go语言中，使用session进行用户身份验证通常需要以下步骤：
1.创建一个session：当用户成功登录时，可以创建一个session来保存用户信息和状态。这通常涉及到生成一个唯一的会话ID，并将该ID存储在一个cookie中。
2.检查session：在处理每个请求时，应该检查cookie中是否存在会话ID。如果存在，就可以从session存储中读取用户信息和状态。如果不存在，就需要将用户重定向到登录页面。
3.验证用户：在处理请求时，需要验证session中存储的用户信息，以确保用户已经登录并具有适当的访问权限。如果验证失败，则需要将用户重定向到登录页面。
示例：
package main
import (
"net/http"
"github.com/gorilla/mux"
"github.com/gorilla/sessions"
)
var store = sessions.NewCookieStore([]byte("secret-key"))
func main() {
r := mux.NewRouter()
r.HandleFunc("/", homeHandler)
r.HandleFunc("/login", loginHandler).Methods("POST")
r.HandleFunc("/logout", logoutHandler)
http.ListenAndServe(":8080", r)
}
func homeHandler(w http.ResponseWriter, r *http.Request) {
session, _ := store.Get(r, "session-id")
// 检查是否存在会话ID
if session.Values["authenticated"] != true {
http.Redirect(w, r, "/login", 302)
return
}
// 在此处处理受保护的页面
}
func loginHandler(w http.ResponseWriter, r *http.Request) {
// 在此处执行用户验证
// 验证成功，创建session
session, _ := store.Get(r, "session-id")
session.Values["authenticated"] = true
session.Save(r, w)
// 重定向到首页
http.Redirect(w, r, "/", 302)
}
func logoutHandler(w http.ResponseWriter, r *http.Request) {
session, _ := store.Get(r, "session-id")
session.Values["authenticated"] = false
session.Save(r, w)
// 重定向到登录页面
http.Redirect(w, r, "/login", 302)
}
在上述示例中，当用户登录时，我们创建了一个session，将“authenticated”值设置为true，并将session ID保存在cookie中。在处理每个请求时，我们检查cookie中是否存在session ID。如果存在，我们从session存储中读取“authenticated”值。如果该值为true，表示用户已经登录，可以访问受保护的页面。如果该值为false或不存在，我们将用户重定向到登录页面。当用户注销时，我们将“authenticated”值设置为false，并将session ID从cookie中删除。
golang session 应用程序中的状态管理
在Go语言中，使用session进行状态管理通常需要以下步骤：
1.创建一个session：在用户开始会话时，可以创建一个session来保存会话状态。这通常涉及到生成一个唯一的会话ID，并将该ID存储在一个cookie中。
2.存储状态：在处理每个请求时，可以将任何需要跟踪的状态信息存储在session中。这可以通过向session.Values中添加键值对来完成。
3.检索状态：在处理请求时，可以从session.Values中检索保存的状态信息。
一个示例：Go语言中使用Session进行状态管理
package main
import (
"fmt"
"net/http"
"github.com/gorilla/mux"
"github.com/gorilla/sessions"
)
var store = sessions.NewCookieStore([]byte("secret-key"))
func main() {
r := mux.NewRouter()
r.HandleFunc("/", homeHandler)
r.HandleFunc("/add", addHandler).Methods("POST")
http.ListenAndServe(":8080", r)
}
func homeHandler(w http.ResponseWriter, r *http.Request) {
session, _ := store.Get(r, "session-id")
// 检索保存的状态
count := session.Values["count"]
// 如果状态不存在，初始化为0
if count == nil {
count = 0
}
// 显示状态信息
fmt.Fprintf(w, "Count: %d\n", count)
// 将状态增加1
count = count.(int) + 1
// 存储新的状态
session.Values["count"] = count
session.Save(r, w)
}
func addHandler(w http.ResponseWriter, r *http.Request) {
session, _ := store.Get(r, "session-id")
// 检索保存的状态
count := session.Values["count"]
// 如果状态不存在，初始化为0
if count == nil {
count = 0
}
// 解析请求中的参数
r.ParseForm()
value := r.Form.Get("value")
// 将参数转换为数字
num, err := strconv.Atoi(value)
if err != nil {
http.Error(w, "Invalid input", http.StatusBadRequest)
return
}
// 将状态增加传入的值
count = count.(int) + num
// 存储新的状态
session.Values["count"] = count
session.Save(r, w)
// 重定向到首页
http.Redirect(w, r, "/", 302)
}
在上述示例中，我们使用session来存储一个计数器的状态。在处理每个请求时，我们从session.Values中检索计数器的值。如果该值不存在，我们将其初始化为0。在首页中，我们显示计数器的值，并将其增加1。在addHandler中，我们从请求参数中获取一个值，并将其添加到计数器的值中。最后，我们将新的计数器值保存到session.Values中，并重定向到首页。
golang实现在线人数统计
在Go语言中实现在线人数功能，可以用session来记录在线用户
package main
import (
"fmt"
"net/http"
"github.com/gorilla/mux"
"github.com/gorilla/sessions"
)
var store = sessions.NewCookieStore([]byte("secret-key"))
func main() {
r := mux.NewRouter()
r.HandleFunc("/", homeHandler)
http.ListenAndServe(":8080", r)
}
func homeHandler(w http.ResponseWriter, r *http.Request) {
session, _ := store.Get(r, "session-id")
// 检查session中是否有userID键
if session.Values["userID"] == nil {
// 如果没有，说明用户是新的，将userID存储在session中
session.Values["userID"] = "user-" + fmt.Sprint(time.Now().UnixNano())
session.Save(r, w)
}
// 获取当前在线用户数
onlineCount := getOnlineCount()
// 显示在线用户数
fmt.Fprintf(w, "Online users: %d", onlineCount)
}
func getOnlineCount() int {
// 遍历所有session，统计在线用户数
count := 0
store := sessions.NewFilesystemStore("", []byte("secret-key"))
store.Walk(func(sess *sessions.Session, err error) error {
if err != nil {
return err
}
if sess.Values["userID"] != nil {
count++
}
return nil
})
return count
}
在上述代码中，我们定义了一个名为getOnlineCount的函数，该函数用于遍历所有session并计算在线用户数。在homeHandler中，我们检查session中是否有一个名为userID的键。如果没有，说明用户是新的，我们将一个唯一的userID存储在session中。然后我们调用getOnlineCount函数获取当前在线用户数，并将其显示给用户。
需要注意的是，在实际生产环境中，这种方式可能会有性能问题。在处理每个请求时遍历所有session会很慢，因此我们应该使用更高效的方法来记录在线用户，例如使用Redis或Memcached等内存数据库来存储session信息。
golang 实现购物车应用
在go语言中可以使用session来实现购物车功能。以下是一个基本的购物车应用实例
package main
import (
"fmt"
"net/http"
"strconv"
"github.com/gorilla/mux"
"github.com/gorilla/sessions"
)
var store = sessions.NewCookieStore([]byte("secret-key"))
type Product struct {
Name string
Price float64
}
func main() {
r := mux.NewRouter()
r.HandleFunc("/", homeHandler)
r.HandleFunc("/add-to-cart/{productID}", addToCartHandler)
r.HandleFunc("/cart", cartHandler)
http.ListenAndServe(":8080", r)
}
func homeHandler(w http.ResponseWriter, r *http.Request) {
products := []Product{
{Name: "Product 1", Price: 10.0},
{Name: "Product 2", Price: 20.0},
{Name: "Product 3", Price: 30.0},
}
// 显示商品列表和添加到购物车的链接
for _, product := range products {
fmt.Fprintf(w, "%s - $%.2f Add to Cart
", product.Name, product.Price, productID)
}
}
func addToCartHandler(w http.ResponseWriter, r *http.Request) {
session, _ := store.Get(r, "session-id")
productID, _ := strconv.Atoi(mux.Vars(r)["productID"])
cart, ok := session.Values["cart"].(map[int]int)
if !ok {
cart = make(map[int]int)
}
cart[productID]++
session.Values["cart"] = cart
session.Save(r, w)
http.Redirect(w, r, "/cart", http.StatusSeeOther)
}
func cartHandler(w http.ResponseWriter, r *http.Request) {
session, _ := store.Get(r, "session-id")
// 检查session中是否有cart键
if session.Values["cart"] == nil {
// 如果没有，说明购物车为空
fmt.Fprint(w, "Your cart is empty.")
return
}
// 显示购物车中的商品和数量
cart := session.Values["cart"].(map[int]int)
fmt.Fprintf(w, "Your cart:
")
for productID, quantity := range cart {
product := getProductByID(productID)
fmt.Fprintf(w, "%s - $%.2f x %d
", product.Name, product.Price, quantity)
}
}
func getProductByID(productID int) Product {
// 实际应用中，此处应从数据库中获取商品信息
products := []Product{
{Name: "Product 1", Price: 10.0},
{Name: "Product 2", Price: 20.0},
{Name: "Product 3", Price: 30.0},
}
for _, product := range products {
if productID == getProductID(product) {
return product
}
}
return Product{}
}
func getProductID(product Product) int {
// 实际应用中，此处应根据商品信息生成唯一的ID
return len(product.Name)
}
上述代码是一个使用Go语言实现的简单购物车应用程序，使用session来管理购物车状态。这个购物车应用程序由三个处理程序组成：
1.homeHandler：在该处理程序中，我们显示了商品列表和添加到购物车的链接，用于让用户选择商品并将其添加到购物车中。
2.addToCartHandler：在该处理程序中，我们使用session来管理购物车状态。我们从URL中获取所选商品的ID，将其添加到session的购物车中，并重定向到购物车页面。
3.cartHandler：在该处理程序中，我们从session中获取购物车状态，然后显示购物车中的商品和数量。
购物车的状态是通过session来管理的。我们使用gorilla/sessions包创建了一个新的CookieStore实例，并将其用于存储和读取session中的数据。在addToCartHandler中，我们将购物车状态保存到session.Values[“cart”]中，并将其保存到cookie中。在cartHandler中，我们从session.Values[“cart”]中获取购物车状态，并显示其中的商品和数量。
golang session用户个性化设置应用
package main
import (
"fmt"
"net/http"
"github.com/gorilla/sessions"
)
// 创建session存储实例，使用随机生成的密钥进行加密
var store = sessions.NewCookieStore([]byte("secret-key"))
func main() {
http.HandleFunc("/", indexHandler)
http.HandleFunc("/setcolor", setColorHandler)
http.HandleFunc("/setfont", setFontHandler)
http.ListenAndServe(":8080", nil)
}
func indexHandler(w http.ResponseWriter, r *http.Request) {
// 从session中获取用户的颜色和字体设置
session, _ := store.Get(r, "user-settings")
color := session.Values["color"]
font := session.Values["font"]
// 显示用户的颜色和字体设置
fmt.Fprintf(w, "Your color is %s and your font is %s", color, font)
// 显示用户设置的表单
fmt.Fprintln(w, `
`)
}
func setColorHandler(w http.ResponseWriter, r *http.Request) {
// 获取用户设置的颜色值
color := r.FormValue("color")
// 将颜色设置保存到session中
session, _ := store.Get(r, "user-settings")
session.Values["color"] = color
session.Save(r, w)
// 重定向到首页
http.Redirect(w, r, "/", http.StatusSeeOther)
}
func setFontHandler(w http.ResponseWriter, r *http.Request) {
// 获取用户设置的字体
font := r.FormValue("font")
// 将字体设置保存到session中
session, _ := store.Get(r, "user-settings")
session.Values["font"] = font
session.Save(r, w)
// 重定向到首页
http.Redirect(w, r, "/", http.StatusSeeOther)
}
这个应用程序有一个主页，显示用户的颜色和字体设置，并允许用户设置它们。当用户点击“Set Color”或“Set Font”按钮时，应用程序将用户设置保存到session中，并重定向到主页以显示新的设置。
在这个应用程序中，我们使用了gorilla/sessions包来创建一个新的CookieStore实例，并将其用于存储和读取session中的数据。我们将session的名称设置为“user-settings”，并将其传递给store.Get()和session.Save()方法，以便在处理程序之间共享session数据。
在indexHandler中，我们使用session.Values[“color”]和session.Values[“font”]从session中获取用户设置的颜色和字体，并将它们显示在网页上。我们还显示了一个表单，用于允许用户设置它们的颜色、字体。