Go语言开发(十六)、Go语言常用标准库六
一、json
1、json简介
Go的标准包encoding/json对JSON的编解码提供了完整的支持。
2、编码
在编码过程中,json包会将Go的类型转换为JSON类型,转换规则如下:
bool 转换为JSON boolean
浮点数, 整数, Number 转换为:JSON number
string转换为:JSON string
数组、切片 转换为:JSON数组
[]byte 转换为:base64 string
struct、map转换为:JSON object
func Marshal(v interface{}) ([]byte, error)
Marshal函数返回v的json编码。Marshal函数会递归的处理值。如果一个值实现了Marshaler接口且非nil指针,会调用其MarshalJSON方法来生成json编码。否则,Marshal函数使用默认编码格式。
(1)结构体编码
json包通过反射机制来实现编解码,因此结构体必须导出所转换的字段,不导出的字段不会被json包解析。
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string
Age int
sex string
}
func main() {
bauer := Person{"Bauer", 25, "Man"}
bytes, err := json.Marshal(bauer)
if err != nil {
fmt.Println("Marshal failed.")
}
fmt.Println(string(bytes)) // {"Name":"Bauer","Age":25}
}
(2)结构体字段标签
json包在解析结构体时,如果遇到key为json的字段标签,则会按照一定规则解析该标签:第一个字段是在JSON串中使用的名字,后续字段为其它选项,例如omitempty指定空值字段不出现在JSON中。如果整个value为"-",则不解析该字段。
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string `json:"name,omitempty"`
Age int `json:"age"`
Sex string `json:"-"`
}
func main() {
bauer := Person{"Bauer", 25, "Man"}
bytes, err := json.Marshal(bauer)
if err != nil {
fmt.Println("Marshal failed.")
}
fmt.Println(string(bytes)) // {"name":"Bauer","age":25}
}
(3)匿名字段
json包在解析匿名字段时,会将匿名字段的字段当成该结构体的字段处理。
package main
import (
"encoding/json"
"fmt"
)
type Point struct{ X, Y int }
type Circle struct {
Point
Radius int
}
func main() {
data, err := json.Marshal(Circle{Point{50, 50}, 25})
if err == nil {
fmt.Println(string(data))
}
}
// output:
//{"X":50,"Y":50,"Radius":25}
(4)转换接口
在调用Marshal(v interface{})函数时,Marshal函数会判断v是否满足json.Marshaler接口或encoding.TextMarshaler接口。如果满足,则会调用json.Marshaler接口或encoding.TextMarshaler接口来进行转换(如果两个都满足,优先调用json.Marshaler)。json.Marshaler接口或encoding.TextMarshaler接口定义如下:
type Marshaler interface {
MarshalJSON() ([]byte, error)
}
type TextMarshaler interface {
MarshalText() (text []byte, err error)
}
json.Marshaler示例如下:
package main
import (
"encoding/json"
"fmt"
)
type Point struct{ X, Y int }
func (pt Point) MarshalJSON() ([]byte, error) {
return []byte(fmt.Sprintf(`{"X":%d,"Y":%d}`, pt.X, pt.Y)), nil
}
func main() {
data, err := json.Marshal(Point{50, 50})
if err == nil {
fmt.Printf("%s\n", data)
}
}
// output:
// {"X":50,"Y":50}
encoding.TextMarshaler示例如下:
package main
import (
"encoding/json"
"fmt"
)
type Point struct{ X, Y int }
func (pt Point) MarshalText() ([]byte, error) {
return []byte(fmt.Sprintf("{\"X\":%d,\"Y\":%d}", pt.X, pt.Y)), nil
}
func main() {
data, err := json.Marshal(Point{50, 50})
if err == nil {
fmt.Printf("%s\n", data)
}
}
// output:
// "{\"X\":50,\"Y\":50}"
(5)编码到输出流func NewEncoder(w io.Writer) *Encoder
NewEncoder创建一个将数据写入w的*Encoder
。func (enc *Encoder) Encode(v interface{}) error
Encode将v的json编码写入输出流,并会写入一个换行符。
使用示例如下:
package main
import (
"encoding/json"
"os"
)
type Person struct {
Name string
Age int
}
func main() {
persons := []Person{
{"Bauer", 30},
{"Bob", 20},
{"Lee", 24},
}
encoder := json.NewEncoder(os.Stdout)
for _, person := range persons {
encoder.Encode(person)
}
}
// output:
// {"Name":"Bauer","Age":30}
// {"Name":"Bob","Age":20}
// {"Name":"Lee","Age":24}
3、解码
解码将JSON转换为Go数据类型。在解码过程中,json包会将JSON类型转换为Go类型,转换规则如下:
JSON boolean 转换为 bool
JSON number 转换为 float64
JSON string 转换为 string
JSON数组 转换为 []interface{}
JSON object 转换为 map
null 转换为 nilfunc Unmarshal(data []byte, v interface{}) error
Unmarshal函数解析json编码的数据data并将结果存入v指向的值,v通常传入指针,否则解析虽不报错,但数据无法赋值到接受体中。
要将json数据解码写入一个指针对象,Unmarshal函数首先处理json数据中json字面值null的情况。此时,函数将指针设为nil;否则,函数将json数据解码写入指针指向的值;如果指针本身是nil,函数会先申请一个值并使指针指向它。
要将json数据解码写入一个结构体,函数会匹配输入对象的键和Marshal使用的键(结构体字段名或者字段标签指定的键名),优先选择精确的匹配,但也接受大小写不敏感的匹配。
如果一个JSON值不匹配给出的目标类型,或者如果一个json数字写入目标类型时溢出,Unmarshal函数会跳过该字段并尽量完成其余的解码操作。如果没有出现更加严重的错误,函数会返回一个描述第一个此类错误的详细信息的UnmarshalTypeError。
JSON的null值解码为go的接口、指针、切片时会将其值设为nil,null在json一般表示“不存在”。解码json的null值到go类型时,不会造成任何改变,也不会产生错误。
当解码字符串时,不合法的utf-8或utf-16字符不视为错误,而是将非法字符替换为unicode字符。
(1)JSON转结构体
JSON可以转换成结构体。json包通过反射机制来实现解码,因此结构体必须导出所转换的字段,不导出的字段不会被json包解析,另外解析时不区分大小写:
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string
Age int
sex string
}
func main() {
data := []byte(`{"Name":"Bauer","Age":25,"sex":"Man"}`)
var bauer Person
json.Unmarshal(data, &bauer)
fmt.Printf("Name:%s Age:%d sex:%s\n", bauer.Name, bauer.Age, bauer.sex)
}
// output:
// Name:Bauer Age:25 sex:
(2)结构体字段标签
解码时依然支持结构体字段标签,规则和编码相同。
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string `json:"name,omitempty"`
Age int `json:"age"`
Sex string `json:"-"`
}
func main() {
data := []byte(`{"name":"Bauer","age":25,"Sex":"Man"}`)
var bauer Person
json.Unmarshal(data, &bauer)
fmt.Printf("Name:%s, Age:%d, Sex:%s\n", bauer.Name, bauer.Age, bauer.Sex)
}
// output:
// Name:Bauer, Age:25, Sex:
(3)匿名字段
在解码JSON时,如果找不到字段,则查找字段的字段。
package main
import (
"encoding/json"
"fmt"
)
type Point struct {
X, Y int
}
type Circle struct {
Point
Radius int
}
func main() {
data := []byte(`{"X":80,"Y":80,"Radius":40}`)
var c Circle
json.Unmarshal(data, &c)
fmt.Printf("X:%d,Y:%d,Radius:%d\n", c.X, c.Y, c.Radius)
}
// output:
// X:80,Y:80,Radius:40
(4)转换接口
解码时根据参数类型是否满足json.Unmarshaler和encoding.TextUnmarshaler来调用相应函数(若两个函数都存在,则优先调用json.Unmarshaler)。json.Unmarshaler和encoding.TextUnmarshaler接口定义如下:
type Unmarshaler interface {
UnmarshalJSON([]byte) error
}
type TextUnmarshaler interface {
UnmarshalText(text []byte) error
}
json.Unmarshaler接口示例:
package main
import (
"encoding/json"
"fmt"
)
type Point struct{ X, Y int }
func (pt Point) UnmarshalJSON(data []byte) error {
fmt.Println(string(data))
return nil
}
func main() {
data := []byte(`{"X":50,"Y":50}`)
var point Point
json.Unmarshal(data, &point)
}
// output:
// {"X":50,"Y":50}
encoding.TextUnmarshaler接口示例:
package main
import (
"encoding/json"
"fmt"
)
type Point struct{ X, Y int }
func (pt Point) UnmarshalText(text []byte) error {
fmt.Println(string(text))
return nil
}
func main() {
data := []byte(`"{\"X\":50,\"Y\":50}"`)
var point Point
json.Unmarshal(data, &point)
}
// output:
// {"X":50,"Y":50}
(5)从输入流解码func NewDecoder(r io.Reader) *Decoder
NewDecoder创建一个从r读取并解码json对象的*Decoder
,Decoder有自己的缓冲,并可能超前读取部分json数据。func (dec *Decoder) Buffered() io.Reader
Buffered方法返回保存在dec缓存里数据的读取器,该返回值在下次调用Decode方法前有效。func (dec *Decoder) UseNumber()
UseNumber方法将dec设置为当接收端是interface{}接口时将json数字解码为Number类型而不是float64类型。func (dec *Decoder) Decode(v interface{}) error
Decode从输入流读取下一个json编码值并保存在v指向的值里
package main
import (
"encoding/json"
"fmt"
"io"
"strings"
)
type Person struct {
Name string
Age int
}
func main() {
const dataStream = `
{ "Name" : "Bauer" , "Age" : 30}
{ "Name" : "Bob" , "Age" : 24 }
{ "Name" : "Lee" , "Age": 20}
`
dec := json.NewDecoder(strings.NewReader(dataStream))
for {
var person Person
if err := dec.Decode(&person); err == io.EOF {
break
}
fmt.Printf("Name: %s, Age: %d\n", person.Name, person.Age)
}
}
// output:
// Name: Bauer, Age: 30
// Name: Bob, Age: 24
// Name: Lee, Age: 20
二、xml
1、xml简介
Go的标准库encoding/xml提供了对XML的操作。xml包提供了两种方式来操作XML,一种是高阶的方式,一种是低阶的方式。高阶的方式提供了Marshal和Unmarshal两个函数分别来编码(将Go数据结构转换成XML)和解码(将XML转换成Go数据结构)。低阶的方法则基于token来进行编码和解码。
2、低阶方式Token
低阶方法是以Token为单位操纵XML,Token有四种类型:StartElement用来表示XML开始节点;EndElement用来表示XML结束节点;CharData即为XML的原始文本(raw text);Comment表示注释。低阶方法通常用在解析XML中的若干节点场景。
<!-- comment -->
<action application="answer">raw text</action>
上述xml文件中, < action application="answer" > 为StartElement, < /action > 为EndElement,raw text为CharData, < !-- -- > 为Comment。
Go语言xml包对Token的数据结构进行了封装,代码如下:
type Name struct {
Space, Local string
}
type Attr struct {
Name Name
Value string
}
type Token interface{}
type StartElement struct {
Name Name
Attr []Attr
}
func (e StartElement) Copy() StartElement {
attrs := make([]Attr, len(e.Attr))
copy(attrs, e.Attr)
e.Attr = attrs
return e
}
func (e StartElement) End() EndElement {
return EndElement{e.Name}
}
type EndElement struct {
Name Name
}
type CharData []byte
func (c CharData) Copy() CharData { return CharData(makeCopy(c)) }
type Comment []byte
xml包提供对xml文件的编码解码常用方法如下:
type TokenReader interface {
Token() (Token, error)
}
type Decoder struct {
Strict bool
AutoClose []string
Entity map[string]string
CharsetReader func(charset string, input io.Reader) (io.Reader, error)
DefaultSpace string
r io.ByteReader
t TokenReader
buf bytes.Buffer
saved *bytes.Buffer
stk *stack
free *stack
needClose bool
toClose Name
nextToken Token
nextByte int
ns map[string]string
err error
line int
offset int64
unmarshalDepth int
}
func NewDecoder(r io.Reader) *Decoder
NewDecoder从io.Reader对象读取xml数据,创建一个Decoderfunc NewTokenDecoder(t TokenReader) *Decoder
NewTokenDecoder使用底层Token流创建一个XML解析器func (d *Decoder) Token() (Token, error)
Token返回解析器的下一个Token,解析结束返回io.EOF
type Encoder struct {
p printer
}
func NewEncoder(w io.Writer) *Encoder
创建编码器,参数为io.Writerfunc (enc *Encoder) EncodeToken(t Token) error
编码Tokenfunc (enc *Encoder) Flush() error
刷新缓冲区,将已经编码内容写入io.Writerfunc (enc *Encoder) Indent(prefix, indent string)
缩进
示例如下:
package main
import (
"bytes"
"encoding/xml"
"fmt"
"io"
)
var file string = `<person id="13"><name><first>John</first><last>Doe</last></name><age>42</age><Married>false</Married><City>Hanga Roa</City><State>Easter Island</State><!-- Need more details. --></person>`
func parseXMLFromToken(xmlFile string) {
// 创建一个io.Reader
reader := bytes.NewReader([]byte(xmlFile))
// 创建×××
dec := xml.NewDecoder(reader)
// 开始遍历解码
indent := "" // 控制缩进
sep := " " // 每层的缩进量为四个空格
for {
tok, err := dec.Token() // 返回下一个Token
// 错误处理
if err == io.EOF { // 如果读到结尾,则退出循环
break
}
switch tok := tok.(type) { // Type switch
case xml.StartElement: // 开始节点,打印名字和属性
fmt.Print(indent)
fmt.Printf("<%s ", tok.Name.Local)
s := ""
for _, v := range tok.Attr {
fmt.Printf(`%s%s="%s"`, s, v.Name.Local, v.Value)
s = " "
}
fmt.Println(">")
indent += sep // 遇到开始节点,则增加缩进量
case xml.EndElement: // 结束节点,打印名字
indent = indent[:len(indent)-len(sep)] // 遇到结束节点,则减少缩进量
fmt.Printf("%s</%s>\n", indent, tok.Name.Local)
case xml.CharData: // 原始字符串,直接打印
fmt.Printf("%s%s\n", indent, tok)
case xml.Comment: // 注释,直接打印
fmt.Printf("%s<!-- %s -->\n", indent, tok)
}
}
}
type AttrMap map[string]string // 属性的键值对容器
// start()用来构建开始节点
func start(tag string, attrs AttrMap) xml.StartElement {
var a []xml.Attr
for k, v := range attrs {
a = append(a, xml.Attr{xml.Name{"", k}, v})
}
return xml.StartElement{xml.Name{"", tag}, a}
}
func generateXMLFile() {
// 创建编码器
buffer := new(bytes.Buffer)
enc := xml.NewEncoder(buffer)
// 开始生成XML
startPerson := start("person", AttrMap{"id": "13"})
enc.EncodeToken(startPerson)
startName := start("name", AttrMap{})
enc.EncodeToken(startName)
startFirstName := start("first", AttrMap{})
enc.EncodeToken(startFirstName)
enc.EncodeToken(xml.CharData("John"))
enc.EncodeToken(startFirstName.End())
starLastName := start("last", AttrMap{})
enc.EncodeToken(starLastName)
enc.EncodeToken(xml.CharData("Doe"))
enc.EncodeToken(starLastName.End())
enc.EncodeToken(startName.End())
startAge := start("age", AttrMap{})
enc.EncodeToken(startAge)
enc.EncodeToken(xml.CharData("42"))
enc.EncodeToken(startAge.End())
startMarried := start("Married", AttrMap{})
enc.EncodeToken(startMarried)
enc.EncodeToken(xml.CharData("false"))
enc.EncodeToken(startMarried.End())
startCity := start("City", AttrMap{})
enc.EncodeToken(startCity)
enc.EncodeToken(xml.CharData("Hanga Roa"))
enc.EncodeToken(startCity.End())
startState := start("State", AttrMap{})
enc.EncodeToken(startState)
enc.EncodeToken(xml.CharData("Easter Island"))
enc.EncodeToken(startState.End())
enc.EncodeToken(xml.Comment("Need more details."))
enc.EncodeToken(startPerson.End())
// 写入XML
enc.Flush()
// 打印结果
fmt.Println(buffer)
}
func main() {
fmt.Println("Decode XML:")
parseXMLFromToken(file)
fmt.Println("Encode XML:")
generateXMLFile()
}
3、高阶方式
xml包以反射机制实现的编解码,因此自定义的结构体必须导出所要转换的字段。xml包定义了结构体和XML数据的转换规则。xml包根据字段的命名,字段的标签来映射XML元素,转换规则如下:
1、xml:"value,value,..."结构体标签为xml包所解析,第一个value对应XML中的名字(节点名、属性名)。
2、字段与XML节点名对应关系:
A、如果存在名为XMLName的字段,并且标签中存在名字值,则该名字值为节点名称,否则
B、如果存在名为XMLName的字段,并且类型为xml.Name,则该字段的值为节点名称,否则
C、结构体名称。
3、字段标签的解析
A、"-"忽略该字段
B、"name,attr"字段映射为XML属性,name为属性名
C、",attr"字段映射为XML属性,字段名为属性名
D、",chardata"字段映射为原始字符串
E、"omitempty"若包含此标签则在字段值为0值时忽略此字段
4、视匿名字段的字段为结构体的字段
xml高阶方式常用方法如下:func Marshal(v interface{}) ([]byte, error)
接收一个interface{},遍历其结构,编码为XML
type Marshaler interface {
MarshalXML(e *Encoder, start StartElement) error
}
func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
接收一个interface{},遍历其结构,编码为XML,增加缩进func Unmarshal(data []byte, v interface{}) error
将data解码为v,v通常为结构体
高阶方法适用于需要编码和解码整个XML并且需要以结构化的数据操纵XML的场景。高阶方法必须导出结构体,会破坏封装。
创建一个test.xml,内容如下:
<?xml version="1.0" encoding="UTF-8"?>
<person id="13">
<name>
<first>John</first>
<last>Doe</last>
</name>
<age>42</age>
<Married>false</Married>
<City>Hanga Roa</City>
<State>Easter Island</State>
</person>
示例如下:
package main
import (
"encoding/xml"
"fmt"
"io/ioutil"
"os"
)
type Person struct {
XMLName string `xml:"person"`
ID string `xml:"id,attr"`
Name Name
Age Age
Married Married
City City
State State
}
type Name struct {
XMLName string `xml:"name"`
First FirstName
Last LastName
}
type FirstName struct {
XMLName string `xml:"first"`
Data string `xml:",chardata"`
}
type LastName struct {
XMLName string `xml:"last"`
Data string `xml:",chardata"`
}
type Age struct {
XMLName string `xml:"age"`
Data int `xml:",chardata"`
}
type Married struct {
XMLName string `xml:"Married"`
Data bool `xml:",chardata"`
}
type City struct {
XMLName string `xml:"City"`
Data string `xml:",chardata"`
}
type State struct {
XMLName string `xml:"State"`
Data string `xml:",chardata"`
}
func generateXMLFile(xmlFile string) {
first := FirstName{"first", "John"}
last := LastName{"last", "Doe"}
name := Name{"name", first, last}
age := Age{"age", 42}
married := Married{"Married", false}
city := City{"City", "Hanga Roa"}
state := State{"State", "Easter Island"}
person := Person{"person", "13", name, age, married, city, state}
data, _ := xml.MarshalIndent(person, "", " ")
headerBytes := []byte(xml.Header) //加入XML头
outputData := append(headerBytes, data...)
ioutil.WriteFile("test.xml", outputData, os.ModeAppend)
}
func parseXMLFile(xmlFile string) {
bytes, err := ioutil.ReadFile(xmlFile)
if err != nil {
fmt.Println(err)
}
var person Person
xml.Unmarshal(bytes, &person)
fmt.Println("FirstName: ", person.Name.First.Data)
fmt.Println("LastName: ", person.Name.Last.Data)
fmt.Println("ID: ", person.ID)
fmt.Println("Married: ", person.Married.Data)
fmt.Println("Age: ", person.Age.Data)
fmt.Println("City: ", person.City.Data)
fmt.Println("State: ", person.State.Data)
}
func main() {
generateXMLFile("test.xml")
parseXMLFile("test.xml")
}
三、base64
1、base64简介
Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一。Base64编码可用于在HTTP环境下传递较长的标识信息。在Java Persistence系统Hibernate中,就采用了Base64来将一个较长的唯一标识符(一般为128-bit的UUID)编码为一个字符串,用作HTTP表单和HTTP GET URL中的参数。采用Base64编码具有不可读性,即所编码的数据不会被人用肉眼所直接看到。
2、base64常用方法
Go语言中encoding/base64提供了对base64编解码支持,encoding/base64定义了一个Encoding结构体,表示Base64的Encoding。并且导出了四个常用的Encoding对象:StdEncoding、URLEncoding、RawStdEncoding、RawURLEncoding。StdEncoding表示标准的Encoding,URLEncoding用于对URL编解码,编解码过程中会将Base64编码中的特殊标记+和/替换为-和_
,RawStdEncoding和RawURLEncoding是StdEncoding和URLEncoding的非padding版本。
type Encoding struct {
encode [64]byte
decodeMap [256]byte
padChar rune
strict bool
}
// 四个导出的编码/×××
var StdEncoding = NewEncoding(encodeStd)
var URLEncoding = NewEncoding(encodeURL)
var RawStdEncoding = StdEncoding.WithPadding(NoPadding)
var RawURLEncoding = URLEncoding.WithPadding(NoPadding)
func (enc *Encoding) Encode(dst, src []byte)
将src编码为dstfunc (enc *Encoding) EncodeToString(src []byte) string
将src编码,返回stringfunc (enc *Encoding) Decode(dst, src []byte) (n int, err error)
将src解码并写入dst,成功返回写入的字节数和errorfunc (enc *Encoding) DecodeString(s string) ([]byte, error)
将字符串s解码并返回[]bytefunc (enc Encoding) WithPadding(padding rune) *Encoding
设置enc的padding,返回Encoding指针,NoPadding表示不进行padding操作func NewDecoder(enc *Encoding, r io.Reader) io.Reader
创建一个base64的输入流×××func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser
创建一个base64的输出流编码器
3、base64示例
package main
import (
"encoding/base64"
"fmt"
"io"
"os"
"strings"
)
func StdEncodingExample() {
data := "Hello world!"
encoded := base64.StdEncoding.EncodeToString([]byte(data))
fmt.Println(encoded)
decoded, err := base64.StdEncoding.DecodeString(encoded)
if err == nil {
fmt.Println(string(decoded))
}
// Output:
// SGVsbG8gd29ybGQh
// Hello world!
}
func URLEncodingExample() {
url := []byte("http://blog.51cto.com/9291927")
encoded := base64.URLEncoding.EncodeToString(url)
fmt.Println(encoded)
decoded, err := base64.URLEncoding.DecodeString(encoded)
if err == nil {
fmt.Println(string(decoded))
}
// Output:
// aHR0cDovL2Jsb2cuNTFjdG8uY29tLzkyOTE5Mjc=
// http://blog.51cto.com/9291927
}
func ExampleStream() {
data := []byte("Hello Hyperledger Fabric")
encoder := base64.NewEncoder(base64.StdEncoding, os.Stdout)
encoder.Write(data)
encoder.Close()
fmt.Println()
input := "SGVsbG8gSHlwZXJsZWRnZXIgRmFicmlj"
reader := strings.NewReader(input)
decoder := base64.NewDecoder(base64.StdEncoding, reader)
io.Copy(os.Stdout, decoder)
// output:
// SGVsbG8gSHlwZXJsZWRnZXIgRmFicmlj
// Hello Hyperledger Fabric
}
func main() {
StdEncodingExample()
URLEncodingExample()
ExampleStream()
}
四、unicode/utf-8
1、utf-8简介
utf8实现了函数和常量来支持UTF-8编码的文本。
const (
RuneError = '\uFFFD' // 错误的 Rune 或 Unicode 代理字符
RuneSelf = 0x80 // ASCII 字符范围
MaxRune = '\U0010FFFF' // Unicode 码点的最大值
UTFMax = 4 // 一个字符编码的最大长度
)
func EncodeRune(p []byte, r rune) int
将r转换为UTF-8编码写入p中(p必须足够长,通常为4个字节)
如果r是无效的Unicode字符,则写入RuneError
返回写入的字节数func DecodeRune(p []byte) (r rune, size int)
解码p中的第一个字符,返回解码后的字符和p中被解码的字节数
如果p为空,则返回(RuneError, 0)
如果p中的编码无效,则返回(RuneError, 1)
无效编码:UTF-8 编码不正确(比如长度不够)、结果超出Unicode范围、编码不是最短的。func DecodeRuneInString(s string) (r rune, size int)
解码s中的第一个字符,返回解码后的字符和p中被解码的字节数func DecodeLastRune(p []byte) (r rune, size int)
解码p中的最后一个字符,返回解码后的字符和p中被解码的字节数
如果p为空,则返回(RuneError, 0)
如果p中的编码无效,则返回(RuneError, 1)func DecodeLastRuneInString(s string) (r rune, size int)
解码p中的最后一个字符,返回解码后的字符和p中被解码的字节数func FullRune(p []byte) bool
FullRune检测p中第一个字符的UTF-8编码是否完整(完整并不表示有效)。
一个无效的编码也被认为是完整字符,将被转换为一个RuneError字符。func FullRuneInString(s string) bool
FullRune检测s中第一个字符的UTF-8编码是否完整(完整并不表示有效)。func RuneCount(p []byte) int
返回p中的字符个数
错误的UTF8编码和长度不足的UTF8编码将被当作单字节的RuneError处理func RuneCountInString(s string) (n int)
返回s中的字符个数func RuneLen(r rune) int
RuneLen返回需要多少字节来编码字符r,如果r是无效的字符,则返回-1func RuneStart(b byte) bool
判断b是否为UTF8字符的首字节编码,最高位(bit)是不是10的字节就是首字节。func Valid(p []byte) bool
Valid判断p是否为完整有效的UTF8编码序列。func ValidString(s string) bool
Valid判断s是否为完整有效的UTF8编码序列。func ValidRune(r rune) bool
ValidRune判断r能否被正确的转换为UTF8编码。
超出Unicode范围的码点或UTF-16代理区中的码点不能转换。
2、utf-8示例
package main
import (
"fmt"
"unicode/utf8"
)
func ExampleDecodeLastRune() {
b := []byte("Hello, 世界")
for len(b) > 0 {
r, size := utf8.DecodeLastRune(b)
fmt.Printf("%c %v\n", r, size)
b = b[:len(b)-size]
}
// Output:
// 界 3
// 世 3
// 1
// , 1
// o 1
// l 1
// l 1
// e 1
// H 1
}
func ExampleDecodeLastRuneInString() {
str := "Hello, 世界"
for len(str) > 0 {
r, size := utf8.DecodeLastRuneInString(str)
fmt.Printf("%c %v\n", r, size)
str = str[:len(str)-size]
}
// Output:
// 界 3
// 世 3
// 1
// , 1
// o 1
// l 1
// l 1
// e 1
// H 1
}
func ExampleDecodeRune() {
b := []byte("Hello, 世界")
for len(b) > 0 {
r, size := utf8.DecodeRune(b)
fmt.Printf("%c %v\n", r, size)
b = b[size:]
}
// Output:
// H 1
// e 1
// l 1
// l 1
// o 1
// , 1
// 1
// 世 3
// 界 3
}
func ExampleDecodeRuneInString() {
str := "Hello, 世界"
for len(str) > 0 {
r, size := utf8.DecodeRuneInString(str)
fmt.Printf("%c %v\n", r, size)
str = str[size:]
}
// Output:
// H 1
// e 1
// l 1
// l 1
// o 1
// , 1
// 1
// 世 3
// 界 3
}
func ExampleEncodeRune() {
r := '世'
buf := make([]byte, 3)
n := utf8.EncodeRune(buf, r)
fmt.Println(buf)
fmt.Println(n)
// Output:
// [228 184 150]
// 3
}
func ExampleFullRune() {
buf := []byte{228, 184, 150} // 世
fmt.Println(utf8.FullRune(buf))
fmt.Println(utf8.FullRune(buf[:2]))
// Output:
// true
// false
}
func ExampleFullRuneInString() {
str := "世"
fmt.Println(utf8.FullRuneInString(str))
fmt.Println(utf8.FullRuneInString(str[:2]))
// Output:
// true
// false
}
func ExampleRuneCount() {
buf := []byte("Hello, 世界")
fmt.Println("bytes =", len(buf))
fmt.Println("runes =", utf8.RuneCount(buf))
// Output:
// bytes = 13
// runes = 9
}
func ExampleRuneCountInString() {
str := "Hello, 世界"
fmt.Println("bytes =", len(str))
fmt.Println("runes =", utf8.RuneCountInString(str))
// Output:
// bytes = 13
// runes = 9
}
func ExampleRuneLen() {
fmt.Println(utf8.RuneLen('a'))
fmt.Println(utf8.RuneLen('界'))
// Output:
// 1
// 3
}
func ExampleRuneStart() {
buf := []byte("a界")
fmt.Println(utf8.RuneStart(buf[0]))
fmt.Println(utf8.RuneStart(buf[1]))
fmt.Println(utf8.RuneStart(buf[2]))
// Output:
// true
// true
// false
}
func ExampleValid() {
valid := []byte("Hello, 世界")
invalid := []byte{0xff, 0xfe, 0xfd}
fmt.Println(utf8.Valid(valid))
fmt.Println(utf8.Valid(invalid))
// Output:
// true
// false
}
func ExampleValidRune() {
valid := 'a'
invalid := rune(0xfffffff)
fmt.Println(utf8.ValidRune(valid))
fmt.Println(utf8.ValidRune(invalid))
// Output:
// true
// false
}
func ExampleValidString() {
valid := "Hello, 世界"
invalid := string([]byte{0xff, 0xfe, 0xfd})
fmt.Println(utf8.ValidString(valid))
fmt.Println(utf8.ValidString(invalid))
// Output:
// true
// false
}
func main() {
ExampleDecodeLastRune()
ExampleDecodeLastRuneInString()
ExampleDecodeRune()
ExampleDecodeRuneInString()
ExampleEncodeRune()
ExampleFullRune()
ExampleFullRuneInString()
ExampleRuneCount()
ExampleRuneCountInString()
ExampleRuneLen()
ExampleRuneStart()
ExampleValid()
ExampleValidRune()
ExampleValidString()
}
五、net/rpc
1、RPC简介
RPC(Remote Procedure Call,远程过程调用)是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络细节的应用程序通信协议。在OSI网络通信模型中,RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。
RPC采用客户机/服务器模式。请求程序是一个客户机,而服务提供程序是一个服务器。首先,客户机调用进程发送一个有进程参数的调用信息到服务进程,然后等待应答信息。在服务器端,进程保持睡眠状态直到调用信息到达为止。当一个调用信息到达,服务器获得进程参数,计算结果,发送答复信息,然后等待下一个调用信息,最后,客户端调用进程接收答复信息,获得进程结果,然后调用执行继续进行。
RPC调用过程如下:
1、调用客户端句柄;执行传送参数
2、调用本地系统内核发送网络消息
3、消息传送到远程主机
4、服务器句柄得到消息并取得参数
5、执行远程过程
6、执行的过程将结果返回服务器句柄
7、服务器句柄返回结果,调用远程系统内核
8、消息传回本地主机
9、客户句柄由内核接收消息
10、客户接收句柄返回的数据
Go的rpc支持三个级别的RPC:TCP、HTTP、JSONRPC。但Go的RPC包是独一无二的RPC,与传统的RPC系统不同,只支持Go开发的服务器与客户端之间的交互,因为内部采用Gob编码。Gob是Golang包自带的一个数据结构序列化的编码/解码工具,编码使用Encoder,解码使用Decoder,其典型应用场景就是RPC。
Go RPC的函数只有符合下面的条件才能被远程访问,不然会被忽略,详细的要求如下:
(1)函数必须是导出的(首字母大写)
(2)必须有两个导出类型的参数,第一个参数是接收的参数,第二个参数是返回给客户端的参数,第二个参数必须是指针类型的。
(3)函数还要有一个返回值errorfunc (t *T) MethodName(argType T1, replyType *T2) error
T、T1和T2类型必须能被encoding/gob包编解码。
2、rpc常用接口
net/rpc定义了一个缺省的DefaultServer,实现一个简单的Server,可以直接调用Server的很多方法。
var DefaultServer = NewServer()
func HandleHTTP() {
DefaultServer.HandleHTTP(DefaultRPCPath, DefaultDebugPath)
}
如果需要配置不同的Server,如不同的监听地址或端口,需要自己创建Server。func NewServer() *Server
Server的监听方式如下:
func (server *Server) Accept(lis net.Listener)
func (server *Server) HandleHTTP(rpcPath, debugPath string)
func (server *Server) ServeCodec(codec ServerCodec)
func (server *Server) ServeConn(conn io.ReadWriteCloser)
func (server *Server) ServeHTTP(w http.ResponseWriter, req *http.Request)
func (server *Server) ServeRequest(codec ServerCodec) error
ServeHTTP 用于处理http请求的业务逻辑,首先处理http的 CONNECT请求,通过http.Hijacker创建连接conn, 然后调用ServeConn处理连接上 客户端的请求。
func (server *Server) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if req.Method != "CONNECT" {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
w.WriteHeader(http.StatusMethodNotAllowed)
io.WriteString(w, "405 must CONNECT\n")
return
}
conn, _, err := w.(http.Hijacker).Hijack()
if err != nil {
log.Print("rpc hijacking ", req.RemoteAddr, ": ", err.Error())
return
}
io.WriteString(conn, "HTTP/1.0 "+connected+"\n\n")
server.ServeConn(conn)
}
Server.HandleHTTP用于设置rpc的上下文路径,rpc.HandleHTTP使用默认的上下文路径。
当使用http.ListenAndServe启动一个http server的时,HandleHTTP设置的上下文将用作RPC传输,上下文的请求由ServeHTTP来处理。
func (server *Server) HandleHTTP(rpcPath, debugPath string) {
http.Handle(rpcPath, server)
http.Handle(debugPath, debugHTTP{server})
}
Accept用来处理一个监听器,监听客户端的连接,一旦监听器接收了一个连接,则交给ServeConn在另外一个goroutine中处理。
func (server *Server) Accept(lis net.Listener) {
for {
conn, err := lis.Accept()
if err != nil {
log.Print("rpc.Serve: accept:", err.Error())
return
}
go server.ServeConn(conn)
}
}
func (server *Server) ServeConn(conn io.ReadWriteCloser) {
buf := bufio.NewWriter(conn)
srv := &gobServerCodec{
rwc: conn,
dec: gob.NewDecoder(conn),
enc: gob.NewEncoder(buf),
encBuf: buf,
}
server.ServeCodec(srv)
}
连接最终由ServerCodec处理,默认使用gobServerCodec处理,可以使用其它的Coder。
客户端建立和服务器的连接
func Dial(network, address string) (*Client, error)
func DialHTTP(network, address string) (*Client, error)
func DialHTTPPath(network, address, path string) (*Client, error)
func NewClient(conn io.ReadWriteCloser) *Client
func NewClientWithCodec(codec ClientCodec) *Client
DialHTTP 和 DialHTTPPath通过HTTP的方式和服务器建立连接。
func DialHTTPPath(network, address, path string) (*Client, error) {
var err error
conn, err := net.Dial(network, address)
if err != nil {
return nil, err
}
io.WriteString(conn, "CONNECT "+path+" HTTP/1.0\n\n")
// Require successful HTTP response
// before switching to RPC protocol.
resp, err := http.ReadResponse(bufio.NewReader(conn), &http.Request{Method: "CONNECT"})
if err == nil && resp.Status == connected {
return NewClient(conn), nil
}
if err == nil {
err = errors.New("unexpected HTTP response: " + resp.Status)
}
conn.Close()
return nil, &net.OpError{
Op: "dial-http",
Net: network + " " + address,
Addr: nil,
Err: err,
}
}
首先发送CONNECT请求,如果连接成功则通NewClient(conn)创建client。
Dial通过TCP与服务器建立连接。
func Dial(network, address string) (*Client, error) {
conn, err := net.Dial(network, address)
if err != nil {
return nil, err
}
return NewClient(conn), nil
}
NewClient创建一个缺省codec为glob序列化库的客户端。
func NewClient(conn io.ReadWriteCloser) *Client {
encBuf := bufio.NewWriter(conn)
client := &gobClientCodec{conn, gob.NewDecoder(conn), gob.NewEncoder(encBuf), encBuf}
return NewClientWithCodec(client)
}
NewClientWithCodec创建一个codec序列化库的客户端。
func NewClientWithCodec(codec ClientCodec) *Client {
client := &Client{
codec: codec,
pending: make(map[uint64]*Call),
}
go client.input()
return client
}
客户端的调用RPC服务方法有两个方法: Go 和 Call。 Go方法是异步的,返回一个Call指针对象, 它的Done是一个channel,如果服务返回,Done就可以得到返回的对象(实际是Call对象,包含Reply和error信息)。 Go是同步的方式调用,它实际是调用Call实现的
func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error {
call := <-client.Go(serviceMethod, args, reply, make(chan *Call, 1)).Done
return call.Error
}
rpc框架默认使用gob序列化库,为了追求更好的效率或者追求更通用的序列化格式,可以采用其它序列化方式,如protobuf,,json,,xml等。
gob序列化库要求注册接口类型的具体实现类型。
func (server *Server) Register(rcvr interface{}) error
func (server *Server) RegisterName(name string, rcvr interface{}) error
3、基于HTTP的RPC
Server.go:
package main
import (
"log"
"net/http"
"net/rpc"
)
type Args struct {
Width int
Height int
}
type Rect struct{}
func (r *Rect) GetArea(p Args, ret *int) error {
*ret = p.Width * p.Height
return nil
}
func (r *Rect) GetPerimeter(p Args, ret *int) error {
*ret = (p.Width + p.Height) * 2
return nil
}
func main() {
rect := new(Rect)
//注册一个rect服务
rpc.Register(rect)
//绑定服务到HTTP协议
rpc.HandleHTTP()
err := http.ListenAndServe(":8081", nil)
if err != nil {
log.Fatal(err)
}
}
Client.go:
package main
import (
"fmt"
"log"
"net/rpc"
)
type Args struct {
Width int
Height int
}
func main() {
//连接远程RPC服务
rpc, err := rpc.DialHTTP("tcp", "127.0.0.1:8081")
if err != nil {
log.Fatal(err)
}
ret := 0
//调用服务方法
err = rpc.Call("Rect.GetArea", Args{50, 100}, &ret)
if err != nil {
log.Fatal(err)
}
fmt.Println(ret)
// 调用服务方法
err = rpc.Call("Rect.GetPerimeter", Args{50, 100}, &ret)
if err != nil {
log.Fatal(err)
}
fmt.Println(ret)
}
// output:
// 5000
// 300
4、基于TCP的RPC
Server.go:
package main
import (
"log"
"net"
"net/rpc"
)
type Args struct {
Width int
Height int
}
type Rect struct{}
func (r *Rect) GetArea(p Args, ret *int) error {
*ret = p.Width * p.Height
return nil
}
func (r *Rect) GetPerimeter(p Args, ret *int) error {
*ret = (p.Width + p.Height) * 2
return nil
}
func errorHandler(err error) {
if err != nil {
log.Fatal(err)
}
}
func main() {
rect := new(Rect)
//注册RPC服务
rpc.Register(rect)
tcpADDR, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8081")
errorHandler(err)
//监听端口
tcpListen, err := net.ListenTCP("tcp", tcpADDR)
errorHandler(err)
// 处理RPC连接请求
for {
conn, err := tcpListen.Accept()
if err != nil {
continue
}
// goroutine处理RPC连接请求
go rpc.ServeConn(conn)
}
}
Client.go:
package main
import (
"fmt"
"log"
"net/rpc"
)
type Args struct {
Width int
Height int
}
func main() {
//连接远程RPC服务
rpc, err := rpc.Dial("tcp", "127.0.0.1:8081")
if err != nil {
log.Fatal(err)
}
ret := 0
//调用服务方法
err = rpc.Call("Rect.GetArea", Args{50, 100}, &ret)
if err != nil {
log.Fatal(err)
}
fmt.Println(ret)
err = rpc.Call("Rect.GetPerimeter", Args{50, 100}, &ret)
if err != nil {
log.Fatal(err)
}
fmt.Println(ret)
}
// output:
// 5000
// 300
5、基于JSON的RPC
JSON RPC方式使用json进行数据编解码,而不是gob编码。
Server.go:
package main
import (
"log"
"net"
"net/rpc"
"net/rpc/jsonrpc"
)
type Args struct {
Width int
Height int
}
type Rect struct{}
func (r *Rect) GetArea(p Args, ret *int) error {
*ret = p.Width * p.Height
return nil
}
func (r *Rect) GetPerimeter(p Args, ret *int) error {
*ret = (p.Width + p.Height) * 2
return nil
}
func errorHandler(err error) {
if err != nil {
log.Fatal(err)
}
}
func main() {
rect := new(Rect)
//注册RPC服务
rpc.Register(rect)
tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8081")
errorHandler(err)
//监听端口
tcpListen, err := net.ListenTCP("tcp", tcpAddr)
errorHandler(err)
for {
conn, err := tcpListen.Accept()
if err != nil {
continue
}
//处理RPC连接请求
go jsonrpc.ServeConn(conn)
}
}
Client.go:
package main
import (
"fmt"
"log"
"net/rpc/jsonrpc"
)
type Args struct {
Width int
Height int
}
func main() {
//连接远程RPC服务
rpc, err := jsonrpc.Dial("tcp", "127.0.0.1:8081")
if err != nil {
log.Fatal(err)
}
ret := 0
//调用服务方法
err = rpc.Call("Rect.GetArea", Args{50, 100}, &ret)
if err != nil {
log.Fatal(err)
}
fmt.Println(ret)
err = rpc.Call("Rect.GetPerimeter", Args{50, 100}, &ret)
if err != nil {
log.Fatal(err)
}
fmt.Println(ret)
}
// output:
// 5000
// 300
有疑问加站长微信联系(非本文作者)