GoWeb（下）之模板引擎、会话控制、客户端

于 2022-03-28 01:36:03 发布
阅读量493 收藏
点赞数 1
分类专栏： Golang 文章标签： Golang 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44630656/article/details/123785583
版权

GoWeb（下）之模板引擎、会话控制、客户端

一、模板引擎

  • Go 为我们提供了 text/template 库和 html/template 库这两个模板引擎，模板引擎通过将数据和模板组合在一起生成最终的 HTML，而处理器负责调用模板引擎并将引擎生成的 HTMl 返回给客户端。
  • Go 的模板都是文本文档（其中 Web 应用的模板通常都是 HTML），它们都嵌入了一些称为动作的指令。从模板引擎的角度来说，模板就是嵌入了动作的文本（这些文本通常包含在模板文件里面），而模板引擎则通过分析并执行这些文本来生成出另外一些文本。
  • text/template 库用于解析任意类型的文本格式模板，以及 html/template 库用于解析并处理 HTML 格式模板。

1.1 HelloWord

使用 Go 模板引擎通常包括以下两个步骤：

  • 解析文本模板源，可以是表单字符串、或者模板文件，用于创建解析后的模板结构体。
  • 执行解析后的模板，将 ResponseWriter 和模板所需的动态数据传递给模板引擎，被调用的模板引擎会把经过语法分析的模板和传入的数据结合起来，生成出最终的 HTML，并将这些 HTML 传递给 ResponseWriter。

下面就让我们写一个简单的 HelloWorld：

  • 创建模板文件 hello.html：

    <html>
    <head>
        <meta charset="UTF-8"/>
    </head>
    <body>
        后台传过来的数据是：{{.}}
    </body>
</html>

  • 在处理器中触发模板引擎：

    func handler(w http.ResponseWriter, r *http.Request) {
	//解析模板文件，返回Template
	t, _ := template.ParseFiles("hello.html")
	//执行模板，并将其传递个 w
	t.Execute(w, "Hello World!")
}

func main() {
	http.HandleFunc("/hello", handler)
	http.ListenAndServe(":8080", nil)
}

  • 浏览器的结果：HTML 模板解析渲染成功，对应的 {{ . }} 也别替换成 Hello World!。

    image-20220322190954213

1.2 解析模板

  • ParseFiles()方法

    func (t *Template) ParseFiles(filenames ...string) (*Template, error)

    ParseFiles()方法解析filenames指定的文件里的模板定义并将解析结果与t关联。如果发生错误，会停止解析并返回nil，否则返回(t, nil)。至少要提供一个文件。

    当我们调用 ParseFiles 函数解析模板文件时，Go 会创建一个新的模板，并将给定的模板文件的名字作为新模板的名字，如果该函数中传入了多个文件名，那么也只会返回一个模板，而且以第一个文件的文件名作为模板的名字，至于其他文件对应的模板则会被放到一个 map 中。

  • ParseGlob()方法

    func (t *Template) ParseGlob(pattern string) (*Template, error)

    方法传入的参数是模式匹配串，而不是文件名称

    t, _ := template.ParseFiles("tmpl.html")
t, _ := template.ParseGlob("*.html")

  • Must()方法

    func Must(t *Template, err error) *Template

    我们在解析模板时都没有对错误进行处理，Go 提供了一个 Must 函数专门用来处理这个错误。Must 函数可以包裹起一个函数，被包裹的函数会返回一个指向模板的指针和一个错误，如果错误不是 nil，那么 Must 函数将产生一个 panic

    t := template.Must(template.ParseFiles("tmpl.html"))	//如果解析模板过程中出现问题，则抛出 panic

1.3 执行模板

  • Execute()方法

    image-20220322193802753

    如果只有一个模板文件，调用这个方法总是可行的；但是如果有多个模板文件，调用这个方法只能得到第一个模板，如果要指定其它模板作为入口模板（或者称之为布局模板），需要调用 ExecuteTemplate 方法并将模板名作为第二个参数传递进去

  • ExecuteTemplate()方法

    image-20220322193844563

例如：

t, _ := template.ParseFiles("hello.html", "hello2.html")

变量 t 就是一个包含了两个模板的模板集合，第一个模板的名字是hello.html,第二个模板的名字是 hello2.html,如果直接调用 Execute 方法，则只有模板 hello.html 会被执行，如何想要执行模板 hello2.html，则需要调用 ExecuteTemplate 方法

t.ExecuteTemplate(w, "hello2.html", "我要在 hello2.html 中显示")

1.4 引入静态资源

对于 HTML 页面中的 css 以及 js 等静态文件，需要使用使用 net/http 包下的以下方法来处理

  • StripPrefix()函数

    image-20220323124329232

  • FileServer()函数

    image-20220323124427013

    • type FileSystem

      image-20220323145809948

    • type Dir该类型实现了FileSystem接口的方法

      image-20220323145644874

http.StripPrefix()处理静态资源示例：

  • 项目的静态文件的目录结构

    image-20220323150334082

  • index.html模板文件中引入的css样式的地址

    <link type="text/css" rel="stylesheet" href="static/css/style.css" >

  • 对静态文件的处理

    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("views/static/"))))

    说明：/static/会匹配以 /static/开头的路径，当浏览器请求index.html页面中的style.css文件时，static前缀会被替换为views/static,然后去 views/static/css目录下查找style.css文件

    package main

import (
	"html/template"
	"net/http"
)

// IndexHandler  去首页
func IndexHandler(w http.ResponseWriter, r *http.Request)  {
	//解析模板
	t := template.Must(template.ParseFiles("views/index.html"))
	//执行
	t.Execute(w, "")
}
func main() {
	//设置处理静态资源
	http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("views/static/"))))
	http.Handle("/pages/", http.StripPrefix("/pages/", http.FileServer(http.Dir("views/pages/"))))
	http.HandleFunc("/", IndexHandler)
	http.ListenAndServe(":8080", nil)
}

http.FileServer()处理静态资源示例：

http.FileServer()接受一个http.FileSystem接口类型的变量

传入http.Dir类型变量，注意http.Dir是一个类型，其底层类型为string，并不是方法。因而http.Dir("")只是一个类型转换，而非方法调用

http.Handle("/static/", http.StripPrefix("/static", http.FileServer(http.Dir("./public"))))

这时，请求localhost:8080/static/hello.html将会返回./public/hello.html文件。路径/static/index.html经过处理器http.StripPrefix去掉了前缀/static得到/index.html，然后又加上了http.Dir的起始目录./public得到文件最终路径./public/hello.html。

1.5 动作

Go 模板的动作就是一些嵌入到模板里面的命令，这些命令在模板中需要放到两个大括号里{{ 动作 }}，之前我们已经用过一个很重要的动作：点（.），它代表了传递给模板的数据。

1.5.1 {{.}}

模板语法都包含在{{和}}中间，其中{{.}}中的点表示当前对象。

当我们传入一个结构体对象时，我们可以根据.来访问结构体的对应字段。例如：

package main

import (
	"html/template"
	"log"
	"net/http"
)
type Address struct {
	Province string
	City     string
}
type User struct {
	Name string
	Age  int
	Addr Address
}

func index(w http.ResponseWriter, r *http.Request) {
	//解析指定文件生成模板对象
	tmpl, err := template.ParseFiles("./public/index.html")
	if err != nil {
		log.Fatal(err)
	}
	user := User{
		Name: "彭于晏",
		Age:  28,
		Addr: Address{Province: "台湾省", City: "澎湖县"},
	}
	//利用给定数据渲染模板，并将结果写入
	err = tmpl.Execute(w, user)
	if err != nil {
		log.Fatal(err)
	}
}

func main() {

	//1.注册给定模式的处理器函数到DefaultServeMux
	http.HandleFunc("/index", index)

	//2.设置监听的TCP地址并启动服务
	//参数1：TCP地址(IP+Port)
	//参数2：当设置为nil时表示使用DefaultServeMux
	err := http.ListenAndServe("127.0.0.1:8080", nil)
	log.Fatal(err)
}

模板文件index.html内容如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>index页面</title>
</head>
<body>
    <p>姓名：{{.Name}}</p>
    <p>年龄：{{.Age}}</p>
    <p>地址：{{.Addr.Province}}-{{.Addr.City}}</p>
    <p>你好呀{{/* 这是注释 */}}，彭于晏</p>
</body>
</html>

显示效果如下图所示：

image-20220323101552265

移除空格：

template引擎在进行替换的时候，是完全按照文本格式进行替换的。除了需要评估和替换的地方，所有的行分隔符、空格等等空白都原样保留。所以，对于要解析的内容，不要随意缩进、随意换行。

有时候我们在使用模板语法的时候会不可避免的引入一下空格或者换行符，这样模板最终渲染出来的内容可能就和我们想的不一样，这个时候可以使用{{-语法去除模板内容左侧的所有空白符号， 使用-}}去除模板内容右侧的所有空白符号。

注意：-要紧挨{{和}}，同时与模板值之间需要使用空格分隔。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>index页面</title>
</head>
<body>
    <div align="center">
        <p>姓名：{{- .Name -}} -king</p> <!-- 彭于晏-king -->
        <p>姓名：{{ .Name }} -king</p> <!-- 彭于晏 -king -->
        <img src="./img/pyy.jpeg" style="width: 10%" alt="彭于晏">
    </div>
</body>
</html>

变量：

我们还可以在模板中声明变量，用来保存传入模板的数据或其他语句生成的结果。具体语法如下：

$obj := {{.}}

其中$obj是变量的名字，在后续的代码中就可以使用该变量了。

示例：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>index页面</title>
</head>
<body>
    <div align="center">
        {{$obj := .Name}}
        <p>姓名：{{ $obj }}</p>
    </div>
</body>
</html>

1.5.2 条件动作

Go模板语法中的条件判断有以下几种：

{{if pipeline}} T1 {{end}}

{{if pipeline}} T1 {{else}} T0 {{end}}

{{if pipeline}} T1 {{else if pipeline}} T0 {{end}}

注意：pipeline为false的情况是各种数据对象的0值：数值0，指针或接口是nil，数组、slice、map或string则是len为0。

示例：

<!-- 由于.Name不是空字符串，所以可以渲染出彭于晏 -->
<p>
    姓名：{{if .Name}} 
    	彭于晏
    {{eles}}
    	没有加载到数据！！！
    {{end}}
</p>

1.5.3 迭代动作

Go的模板语法中使用range关键字进行遍历，有以下两种写法，其中pipeline的值必须是数组、切片、map或者channel。

{{range pipeline}} 
T1 
{{end}}
<!-- 如果pipeline的值其长度为0，不会有任何输出 -->

{{range pipeline}} 
T1 
{{else}} 
T0 
{{end}}
<!-- 如果pipeline的值其长度为0，则会执行T0。 -->

  • 注意：range的参数部分是pipeline，所以在迭代的过程中是可以进行赋值的。但有两种赋值情况：

    {{range $value := .}}
{{range $key,$value := .}}

    如果range中只赋值给一个变量，则这个变量是当前正在迭代元素的值。如果赋值给两个变量，则第一个变量是索引值(数组/切片是数值，map是key)，第二个变量是当前正在迭代元素的值。

  • 如果迭代之后是一个个的结构体，获取结构体中的字段值使用 .字段名 方式获取

    {{range . }}
	获取结构体的 Name 字段名 {{ .Name }}
{{ end }}

<!-- 也可以这样写，结构体不能为nil -->
{{range .Name }}
	获取结构体的 Name 字段名 {{ .}}
{{ end }}

    注意：range 后面的点代表被遍历的元素；要显示的内容里面的点代表遍历到的元素

示例：

  • 模板文件

    <html>
    <head>
        <title>模板文件</title>
        <meta charset="utf-8" />
    </head>
    <body>
        <!-- 嵌入动作，range 后面的点代表被遍历的元素；要显示的内容里面的点代表遍历到的元素 -->
        {{range .}}
        <a href="#">
            {{.}}
        </a>
        {{else}}
        没有遍历到任何内容
        {{end}}
    </body>
</html>

  • 处理器端代码：

    func handler(w http.ResponseWriter, r *http.Request) {
	//解析模板文件
	t := template.Must(template.ParseFiles("hello.html"))
	//声明一个字符串切片
	stars := []string{"马蓉", "李小璐", "白百何"}
	//执行模板
	t.Execute(w, stars)
}

  • 浏览器中的结果：

    image-20220323103903942

1.5.4 设置动作

通过with指令设置动作允许在指定的范围内对点（.）设置值

格式一：在 {{ with arg }} 和 {{ end }} 之间的 . 会被设置为 arg。

{{ with arg }}
为传过来的数据设置的新值是{{ . }}
{{ end }}

格式二：

{{ with arg }}
为传过来的数据设置的新值是{{ . }}
{{ else }}
传过来的数据仍然是{{ . }}
{{ end }}

代码示例：

  • 模板文件：

    <html>
    <head>
        <title>模板文件</title>
        <meta charset="utf-8" />
    </head>

    <body>
        <!-- 嵌入动作 -->
        <div>得到的数据是：{{.}}</div>
        {{with "太子"}}
        <div>替换之后的数据是：{{.}}</div>
        {{end}}

        <hr />

        {{with ""}}
        <div>看一下现在的数据是：{{.}}</div>
        {{else}}
        <div>数据没有被替换，还是：{{.}}</div>
        {{end}}
    </body>
</html>

  • 处理器端代码：

    func handler(w http.ResponseWriter, r *http.Request) {
	//解析模板文件
	t := template.Must(template.ParseFiles("hello.html"))
	//执行模板
	t.Execute(w, "狸猫")
}

  • 浏览器中的结果：

    image-20220323105514107

1.5.5 定义、嵌套模板

我们可以在template中嵌套其他的template。这个template可以是单独的文件，也可以是通过define定义的template。

嵌套模板：

  • 格式一：

    {{ template “name” }}

    name 为被包含的模板的名字

  • 格式二：

    {{ template “name” arg }}

    arg 是用户想要传递给被嵌套模板的数据

定义模板：

  • 对于一些网页中相同的部分，比如导航栏、版权信息、联系方式等。这些相同的布局我们可以通过定义动作在模板文件中定义模板来实现。定义模板的格式是：

    {{ define “layout” }}
	模板文件的一些内容
{{ end }}

代码示例：

  • hello.html模板文件：

    <html>
    <head>
        <title>模板文件</title>
        <meta charset="utf-8" />
    </head>
    <body>
        <!-- 嵌入动作 -->
        <div>从后台得到的数据是：{{.}}</div>

        <hr />

        <!-- 包含 hello2.html 模板 -->
        <div>hello2.html模板:</div>
        {{ template "hello2.html"}}
        
        <hr />

        <div>将 hello.html 模板文件中的数据传递给 hello2.html模板文件:</div>
        {{ template "hello2.html" . }}

        <hr />

        <div>嵌套自己定义的content模板:</div>
        {{ template "content"}}
    </body>
</html>


{{ define "content"}}
    <div style="background-color: yellow;">我是自己定义的content模板文件中的内容</div>
{{ end }}

  • hello2.html模板文件

    <html>
    <head>
        <title>hello2 模板文件</title>
        <meta charset="utf-8" />
    </head>

    <body>
        <!-- 嵌入动作 -->
        <div>hello2.html 模板文件中的数据是：{{.}}</div>
    </body>
</html>

  • 处理器端代码：

    func handler(w http.ResponseWriter, r *http.Request) {
	//解析模板文件
	t := template.Must(template.ParseFiles("hello.html", "hello2.html"))
	//执行模板
	t.Execute(w, "测试嵌套")
}

  • 浏览器中的结果：

    image-20220323113029221

1.5.6 块动作

根据官方文档的解释：block等价于define定义一个名为name的模板，并在"有需要"的地方执行这个模板，执行时将"."设置为pipeline的值。

{{block "name" pipeline}} T1 {{end}}

但应该注意，block的第一个动作是执行名为name的模板，如果不存在，则在此处自动定义这个模板，并执行这个临时定义的模板。换句话说，block可以认为是设置一个默认模板。

例如：

{{block "T1" .}} one {{end}}

它首先表示{{template "T1" .}}，也就是说先找到T1模板，如果T1存在，则执行找到的T1，如果没找到T1，则临时定义一个{{define "T1"}} one {{end}}，并执行它。

代码示例：

  • hello.html模板文件：

    <html>
    <head>
        <title>模板文件</title>
        <meta charset="utf-8" />
    </head>

    <body>
        {{ block "content.html" .}}
        没有找到content.html模板<br/>
        模板的数据是:{{.}}
        {{ end }}

        <hr/>

        {{ block "content1.html" .}}
        没有找到content1.html模板
        {{ end }}
    </body>
</html>

  • content1.html模板文件

    <html>
    <head>
        <title>content1 模板文件</title>
        <meta charset="utf-8" />
    </head>

    <body>
        <!-- 嵌入动作 -->
          <p style="color: red;">content1模板文件中的内容</p>
          模板的数据是:{{.}}
    </body>
</html>

  • 处理器端代码：

    func handler(w http.ResponseWriter, r *http.Request) {
	//解析模板文件
	t := template.Must(template.ParseFiles("hello.html", "content1.html"))
	//执行模板
	t.Execute(w, "测试block")
}

  • 浏览器中的结果：

    image-20220324160656420

1.6 修改默认的标识符

Go标准库的模板引擎使用的花括号{{和}}作为标识，而许多前端框架（如Vue和 AngularJS）也使用{{和}}作为标识符，所以当我们同时使用Go语言模板引擎和以上前端框架时就会出现冲突，这个时候我们需要修改标识符，修改前端的或者修改Go语言的。

修改Go语言模板引擎默认的标识符语法：

template.New("test").Delims("{[", "]}").ParseFiles("./t.tmpl")

代码示例：

  • main.go

    func index(w http.ResponseWriter, r *http.Request) {
	t, err := template.New("index.tmpl").Delims("{[", "]}").ParseFiles("index.tmpl")
	if err != nil {
		fmt.Printf("parse template failed,err:%v\n", err)
		return
	}
	t.Execute(w, "测试block")
}

  • index.tmpl此时使用{[.]}仍然可以解析出来

    <!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>修改模板引擎的标识符</title>
    </head>
    <body>
        <div>Hello {[.]}</div>
    </body>
</html>

二、会话控制

2.1 Cookie

Cookie 实际上就是服务器保存在浏览器上的一段信息。浏览器有了 Cookie 之后，每次向服务器发送请求时都会同时将该信息发送给服务器，服务器收到请求后，就可以根据该信息处理请求。

  • type Cookie

    type Cookie struct {
    Name       string
    Value      string
    Path       string
    Domain     string
    Expires    time.Time	//基本都是用MaxAge
    RawExpires string
    // MaxAge=0表示未设置Max-Age属性
    // MaxAge<0表示立刻删除该cookie，等价于"Max-Age: 0"
    // MaxAge>0表示存在Max-Age属性，单位是秒
    MaxAge   int
    Secure   bool
    HttpOnly bool
    Raw      string
    Unparsed []string // 未解析的“属性-值”对的原始文本
}

cookie的运行原理：

  1. 第一次向服务器发送请求时在服务器端创建cookie
  2. 将在服务器端创建的cookie以响应头的方式发送给浏览器
  3. 以后再发送请求浏览器就会携带着该cookie
  4. 服务器得到cookie之后根据cookie的信息来区分不同的用户

2.1.1 创建 Cookie 并将它发送给浏览器

在服务器创建 Cookie 并将它发送给浏览器：

  • 服务端代码：

    func handler(w http.ResponseWriter, r * http.Request) {
	cookie1: = http.Cookie {
		Name: "user1",
		Value: "admin",
		HttpOnly: true,
	}
	cookie2: = http.Cookie {
		Name: "user2",
		Value: "superAdmin",
		HttpOnly: true,
	}
	//将 Cookie 发送给浏览器,即添加第一个 Cookie
	w.Header().Set("Set-Cookie", cookie1.String())
	//再添加一个 Cookie
	w.Header().Add("Set-Cookie", cookie2.String())
}

  • 除了 Set 和 Add 方法之外，Go 还提供了一种更快捷的设置 Cookie 的方式，就是通过net/http 库中的 SetCookie() 方法

    image-20220323155329392

    func handler(w http.ResponseWriter, r * http.Request) {
	cookie1: = http.Cookie {
		Name: "user1",
		Value: "admin",
		HttpOnly: true,
	}
	cookie2: = http.Cookie {
		Name: "user2",
		Value: "superAdmin",
		HttpOnly: true,
	}
	http.SetCookie(w, & cookie1)
	http.SetCookie(w, & cookie2)
}

  • 浏览器响应报文中的内容

    HTTP/1.1 200 OK
Set-Cookie: user1=admin; HttpOnly
Set-Cookie: user2=superAdmin; HttpOnly
Date: Sun, 12 Aug 2018 07:24:49 GMT
Content-Length: 0
Content-Type: text/plain; charset=utf-8

以后每次发送请求浏览器都会携带着 Cookie：

GET /cookie HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) 
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 
Safari/537.36
Accept: 
text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/
apng,*/*;q=0.8
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Cookie: user1=admin; user2=superAdmin

2.1.2 读取Cookie

可以通过 Request 结构中的Header 字段来获取 Cookie，也可以使用net/http提供的方法

image-20220323160419614

  • 处理器端代码：

    //getCookies 获取Cookie
func getCookies(w http.ResponseWriter, r *http.Request) {
	//获取请求头中所有的Cookie
	cookies := r.Header["Cookie"]
	fmt.Println("得到的Cookie有：", cookies)	//得到的Cookie有： [user=admin; user2=admin2]
	//如果想得到某一个Cookie，可以直接调用Cookie方法
	cookie, _ := r.Cookie("user")
	fmt.Println("得到的Cookie有：", cookie)		//得到的Cookie有： user=admin
}

2.1.3 设置 Cookie 的有效时间

Cookie默认是会话级别的，当关闭浏览器之后Cookie将失效，我们可以通过Cookie结构的 MaxAge 字段设置 Cookie 的有效时间

func handler(w http.ResponseWriter, r * http.Request) {
	cookie: = http.Cookie {
		Name: "user",
		Value: "persistAdmin",
		HttpOnly: true,
		MaxAge: 60,		// Cookie 有效期设置为 60s
        // MaxAge=0表示未设置Max-Age属性
    	// MaxAge<0表示立刻删除该cookie，等价于"Max-Age: 0"
    	// MaxAge>0表示存在Max-Age属性，单位是秒
	}
	//将 Cookie 发送给浏览器
	w.Header().Set("Set-Cookie", cookie.String())
}

浏览器响应报文中的内容：

image-20220318174957970

2.2 Session

使用 Cookie 有一个非常大的局限，就是如果 Cookie 很多，则无形的增加了客户端与服务端的数据传输量。而且由于浏览器对 Cookie 数量的限制，注定我们不能再Cookie 中保存过多的信息，于是 Session 出现。

Session 的作用就是在服务器端保存一些用户的数据，然后传递给用户一个特殊的 Cookie，这个 Cookie 对应着这个服务器中的一个 Session，通过它就可以获取到保存用户信息的 Session，进而就知道是那个用户再发送请求。

Session 的运行原理：

  • 第一次向服务器发送请求时创建 Session，给它设置一个全球唯一的 ID（可以通过UUID 生成）
  • 创建一个 Cookie，将 Cookie 的 Value 设置为 Session 的 ID 值，并将 Cookie 发送给浏览器
  • 以后再发送请求浏览器就会携带着该 Cookie
  • 服务器获取 Cookie 并根据它的 Value 值找到服务器中对应的 Session，也就知道了请求是那个用户发的

注意：官方没有提供的 Session 实现。如果在 Web 应用中使用到了 Session，需要自行去实现，或者使用第三方工具包，比如 gorilla/sessions，

三、客户端（待补）

青衫白衣98
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go模板引擎
sumatch的博客
06-04 1891
Go语言内置了 text/template 和 html/template 两个模板库，专门用于处理网页html模板。 html/template 是在 text/template 模板库的基础上增加了对html输出的安全处理，主要目的是为了防止被攻击。 下面通过一个例子介绍template的用法。 模版引擎使用流程: 编写模版代码 导入包 加载模版代码 根据模版参数渲染模版 1. 快速入门 1.1 编写模版代码 将下面模版代码保存至 views/demo.tpl 文件中， 文件后缀名随意。 {{d
Vroom:建立在 Go 模板引擎之上的静态网站解决方案，形式为 Jekyll
06-26
房间 尝试使用基于默认的轻量级静态站点生成器。 也许是风格的东西。 房间选项 配置选项当前以 JSON 形式给出并从文件中读取。 截至目前，只有两个有用的选项： 选项名称 描述 默认 布局目录 使用的模板/片段的位置 模板/ 构建目录 渲染文件的目的地 建造/ 页面目录 要呈现的页面的位置 _页/ 元数据 这是所有顶级元数据所在的位置，现在未使用，但以后可用于标题、作者、url、插件名称和可从模板访问的变量。 {} 元数据 Vroom 在其模板中支持多层元数据。 级别越具体，渲染时数据的优先级就越高。 每个数据都是 *.vroom.json 格式的 JSON 文件中的一个键值对。 Vroom 将按目录解析元数据。 例如，如果结构是 根目录/ _页/ 数据.vroom.json 博文/ 博客数据.vroom.json vroom_options.json 并且密钥标题存在于
go模板引擎生成html,goweb-模板引擎
weixin_42364609的博客
06-03 503
模板引擎Go 为我们提供了 text/template 库和 html/template 库这两个模板引擎，模板引擎通过将数据和模板组合在一起生成最终的 HTML，而处理器负责调用模板引擎并将引擎生成的 HTMl 返回给客户端。Go 的模板都是文本文档(其中 Web 应用的模板通常都是 HTML)，它们都嵌入了一些称为动作的指令。从模板引擎的角度来说，模板就是嵌入了动作的文本(这些文本通常包含在模...
golang实现webservice https client端
tianshi418的专栏
03-19 3099
1.证书文件符合要求的标准pem,如果是java 的keystore或者其他格式,首先转为pfx,然后再生成对应的 pub_cert,private_key java实现keystore转为pfx格式: import java.io.FileInputStream; import java.io.FileOutputStream; import java.security.Key; impor...
重磅！《Go Web编程实战派从入门到精通》随书源码开源啦，Go语言-Web-goWebActualCombat.zip
最新发布
11-06
《Go Web编程实战派从入门到精通》是一本专注于Go语言在Web开发领域的专著，其开源的随书源码库名为"Go语言-Web-goWebActualCombat"，压缩包内的主要内容是goWebActualCombat-master目录，这代表了一个完整的Go语言...
Go-k3v作为专用的虚拟Kubernetes控制对面板运行
08-14
标题中的"Go-k3v作为专用的虚拟Kubernetes控制对面板运行"指的是一种使用Go语言编写的名为k3v的工具，它被设计为一个轻量级且专用于Kubernetes集群管理的控制台界面。K3v可能是k3s（一个轻量级的Kubernetes发行版）...
开源项目-trashhalo-go-crud.zip
09-03
模板引擎简化了视图层的构建，使得开发者能够专注于业务逻辑而不是页面布局。 最后，"sessions"是Web应用中维持用户状态的重要工具。在Go中，可以使用第三方库如gorilla/sessions来管理会话。用户登录后，会话可以...
Simple Admin 的文件上传管理服务.zip
11-02
5. **模板渲染**：为了展示文件列表和上传界面，服务可能会使用模板引擎。Go语言内置了`html/template`包，可以用于安全地生成HTML，也可以选择如`github.com/golang/gddo/httptemplate`这样的增强版模板库。 6. **...
GoWeb给客户端响应教程
weixin_46120107的博客
03-18 600
ResponseWriter 我们先来看下net/http中的ResponseWriter封装了哪些属性和方法。 1.给客户端响应一个字符串 Write([]byte)(int,error) ==>很明显，我们需要提供一个byte的切片，一个字符序列 这一点跟我们上篇文章讲到的，数据在网络中的传递时通过字符序列进行的。 2.给客户端响应一个html页面 // ``中的内容会安照原格式的方式 func Handeler4(w http.ResponseWriter, r..
Go-quicktemplate-快速功能强大易于使用的Go模板引擎
08-13
quicktemplate - 快速、功能强大、易于使用的Go模板引擎。比html/模板快20倍
golang中的http客户端
后台开发
01-20 501
http WEB客户端： 1. 获取web服务器数据： func Get(url string) (resp *Response, err error) 返回：http应答包，保存成 struct type Response struct { Status string // e.g. "200 OK" StatusCode int // e.g. 200 Proto string // e.g. "HTTP/1.0"
golang 模板(template)的常用基本语法
热门推荐
sryan的专栏
08-29 6万+
golang 模板(template)的常用基本语法模板在写动态页面的网站的时候，我们常常将不变的部分提出成为模板，可变部分通过后端程序的渲染来生成动态网页，golang提供了html/template包来支持模板渲染。这篇文章不讨论golang后端的模板读取及渲染方法，只讨论模板中嵌入变量，渲染变量、循环等一些基本用法。变量在golang渲染template的时候，可以接受一个interface{
使用golang的标准库搭建网站--2.模板解析
好好学习 天天向上
12-13 2046
模板的解析既然是搭建网站，fmt.Fprintf(w, "Hello world, this is my first page!")这种方式肯定就不能用了，得解析模板才行。
Golang 页面模板之间的嵌套定义以及静态文件的加载方式
zhengzizhi的专栏
06-29 1万+
页面模板之间的嵌套定义以及静态文件的加载方式，例如 header模板 footer模板 如何拼接成一个完整的页面，静态文件（css文件，js文件，图片等）
Go Web 编程之 模板（一）
darjun的博客
01-13 1532
概述 模板引擎是 Web 编程中必不可少的一个组件。模板能分离逻辑和数据，使得逻辑简洁清晰，并且模板可复用。引用第二篇文章《程序结构》一文中的图示，我们可以看到模板引擎在 Web 程序结构中的位置： 模板引擎按照功能可以划分为两种类型： 无逻辑模板引擎：此类模板引擎只进行字符串的替换，无其它逻辑； 嵌入逻辑模板引擎：此类模板引擎可以在模板中嵌入逻辑，实现流程控制/循环等。 这两类模板引擎...
go 模版引擎简单实例
貌似君子的专栏
09-17 1126
go语言提供了两种模版引擎，分别是html/template和text/template，两种模版引擎的语法相同，不同的地方就在于html中对标签等的处理。 模版语法参考连接：https://www.cnblogs.com/Pynix/p/4154630.html 我们这里使用text/template引擎做一个代码生成的小例子，选择生成一个java类的代码： 模版conf.templat...
Golang后端渲染整合vue单页面冲突解决
码农笔录-微信公众号博客
10-28 1912
go后端模版渲染是通过 {{}} ，但是有个恶心的问题，vue也是通过双花括号来渲染的，如果同时使用，go渲染的时候就会报错，因为分别不出来哪个是vue的，哪个是go的，今天给大家带来个解决方法，那就是修改vue的默认渲染标签 var app = new Vue({ delimiters: [’${’, ‘}’], el: ‘#vue-app’, }) 配置delimiters，就可以避免开这个冲突，当然里面的标签都是自定义的，下面是我改过之后的用法 ...
go语言html css,html – 在Golang中加载图像和CSS
weixin_39860064的博客
06-04 379
我在项目根目录的package main中的server.js中设置了一个路由http.HandleFunc( “/”,route.IndexHandler)IndexHandler在包路由中实现,如下所示：func IndexHandler(w http.ResponseWriter, r *http.Request) {data:=struct{Name string}{"My name",}...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值