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 objectfunc Marshal(v interface{}) ([]byte, error)Marshal函数返回v的json编码。Marshal函数会递归的处理值。如果一个值实现了Marshaler接口且非nil指针，会调用其MarshalJSON方法来生成json编码。否则，Marshal函数使用默认编码格式。（1）结构体编码json包通过反射机制来实现编解码，因此结构体必须导出所转换的字段，不导出的字段不会被json包解析。

package mainimport (   "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 mainimport (   "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 mainimport (   "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 mainimport (   "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 mainimport (   "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) *EncoderNewEncoder创建一个将数据写入w的*Encoder。func (enc *Encoder) Encode(v interface{}) errorEncode将v的json编码写入输出流，并会写入一个换行符。使用示例如下：

package mainimport (   "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{}) errorUnmarshal函数解析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 mainimport (   "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 mainimport (   "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 mainimport (   "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 mainimport (   "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 mainimport (   "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) *DecoderNewDecoder创建一个从r读取并解码json对象的*Decoder，Decoder有自己的缓冲，并可能超前读取部分json数据。func (dec *Decoder) Buffered() io.ReaderBuffered方法返回保存在dec缓存里数据的读取器，该返回值在下次调用Decode方法前有效。func (dec *Decoder) UseNumber()UseNumber方法将dec设置为当接收端是interface{}接口时将json数字解码为Number类型而不是float64类型。func (dec *Decoder) Decode(v interface{}) errorDecode从输入流读取下一个json编码值并保存在v指向的值里

package mainimport (   "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中的若干节点场景。

    
    
     raw text
    

上述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 []bytefunc (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数据，创建一个Decoder

func NewTokenDecoder(t TokenReader) *DecoderNewTokenDecoder使用底层Token流创建一个XML解析器func (d *Decoder) Token() (Token, error)Token返回解析器的下一个Token，解析结束返回io.EOF

type Encoder struct {   p printer}func NewEncoder(w io.Writer) *Encoder

创建编码器，参数为io.Writer

func (enc *Encoder) EncodeToken(t Token) error 编码Tokenfunc (enc *Encoder) Flush() error 刷新缓冲区，将已经编码内容写入io.Writerfunc (enc *Encoder) Indent(prefix, indent string)缩进示例如下：

package mainimport (   "bytes"   "encoding/xml"   "fmt"   "io")var file string = `
    
     
      
       John
      
      
       Doe
      
     
     
      42
     
     
      false
     
     
      Hanga Roa
     
     
      Easter Island
     
     
    `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
    \n", indent, tok.Name.Local)      case xml.CharData: // 原始字符串，直接打印         fmt.Printf("%s%s\n", indent, tok)      case xml.Comment: // 注释，直接打印         fmt.Printf("%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，内容如下：

    
        
             
      
       John
              
      
       Doe
          
         
     
      42
         
     
      false
         
     
      Hanga Roa
         
     
      Easter Island
     
    

示例如下：

package mainimport (   "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 mainimport (   "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("https://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=   // https://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) boolFullRune检测p中第一个字符的UTF-8编码是否完整（完整并不表示有效）。一个无效的编码也被认为是完整字符，将被转换为一个RuneError字符。func FullRuneInString(s string) boolFullRune检测s中第一个字符的UTF-8编码是否完整（完整并不表示有效）。func RuneCount(p []byte) int返回p中的字符个数错误的UTF8编码和长度不足的UTF8编码将被当作单字节的RuneError处理func RuneCountInString(s string) (n int)返回s中的字符个数func RuneLen(r rune) intRuneLen返回需要多少字节来编码字符r，如果r是无效的字符，则返回-1func RuneStart(b byte) bool判断b是否为UTF8字符的首字节编码，最高位(bit)是不是10的字节就是首字节。func Valid(p []byte) boolValid判断p是否为完整有效的UTF8编码序列。func ValidString(s string) boolValid判断s是否为完整有效的UTF8编码序列。func ValidRune(r rune) boolValidRune判断r能否被正确的转换为UTF8编码。超出Unicode范围的码点或UTF-16代理区中的码点不能转换。

2、utf-8示例

package mainimport (   "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) errorT、T1和T2类型必须能被encoding/gob包编解码。

2、rpc常用接口

net/rpc定义了一个缺省的DefaultServer，实现一个简单的Server，可以直接调用Server的很多方法。

var DefaultServer = NewServer()func HandleHTTP() {   DefaultServer.HandleHTTP(DefaultRPCPath, DefaultDebugPath)}

如果需要配置不同的Server，如不同的监听地址或端口，需要自己创建Server。

func NewServer() *ServerServer的监听方式如下：

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) *Clientfunc 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{}) errorfunc (server *Server) RegisterName(name string, rcvr interface{}) error

3、基于HTTP的RPC

Server.go：

package mainimport (   "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 mainimport (   "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 mainimport (   "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 mainimport (   "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 mainimport (   "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 mainimport (   "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