go杂货铺

json序列化

内存中变成可存储或传输的过程称之为序列化(dict,split,struct转string)

package main

import (
	"encoding/json"
	"fmt"
)

type Stu struct {
	Name string
	Age  int
}

func JsonDump() (ret string, err error) {
	stu1 := Stu{
		Name: "somebody",
		Age:  20,
	}
	data, err := json.Marshal(stu1)
	if err != nil {
		err = fmt.Errorf("json dump failed:", err)
		return
	}
	ret = string(data)
	fmt.Println(ret)
	return
}

func main() {
	JsonDump()
}

　　

json反序列化

磁盘读取到内存

需要先定义一个存储的数据类型(map struct)，string要转成byte

package main

import (
	"encoding/json"
	"fmt"
)

type Stu struct {
	Name string
	Age  int
}

func JsonDump() (ret string, err error) {
	stu1 := Stu{
		Name: "somebody",
		Age:  20,
	}
	data, err := json.Marshal(stu1)
	if err != nil {
		err = fmt.Errorf("json dump failed:", err)
		return
	}
	ret = string(data)
	return
}

func JsonLoad(res string) (ret interface{}, err error) {
	var stu Stu
	err = json.Unmarshal([]byte(res), &stu)
	if err != nil {
		err = fmt.Errorf("json loads failed:", err)
		return
	}
	ret = stu
	return
}

func main() {
	response, _ := JsonDump()
	res, _ := JsonLoad(response)
	fmt.Println(res)
}

　　

命令行参数的解析

flag模块

package main

import (
	"flag"
	"fmt"
)

func main() {
	var confPath string
	var command string
	var port int

	flag.StringVar(&confPath, "c", "conf", "conf file of app")//变量名　　-c   默认值　　描述
	flag.StringVar(&command, "a", "online", "command to execute")
	flag.IntVar(&port, "p", 10000, "port of service")
	flag.Parse()

	fmt.Println(confPath)
	fmt.Println(command)
	fmt.Println(port)
}

　　

slice取随机数

	var indexList []int
	for i := 0; i < chooseNum; i++ {
		//避免随机出现重复
		for {
			randIndex := rand.Intn(len(totalList))
			flag := true
			for _, v := range indexList {
				if v == randIndex {
					flag = false
				}
			}
			if flag {
				indexList = append(indexList, randIndex)
				break
			}
		}
	}

　　

远程登录执行ssh命令(支持密码、秘钥)

package main

import (
	"fmt"
	"io/ioutil"
	"net"
	"os"
	"time"

	"golang.org/x/crypto/ssh"
)

func connect(user, password, host, key string, port int) (*ssh.Session, error) {
	var (
		auth         []ssh.AuthMethod
		addr         string
		clientConfig *ssh.ClientConfig
		client       *ssh.Client
		session      *ssh.Session
		err          error
	)
	// get auth method
	auth = make([]ssh.AuthMethod, 0)
	if key == "" {
		auth = append(auth, ssh.Password(password))
	} else {
		pemBytes, err := ioutil.ReadFile(key)
		if err != nil {
			return nil, err
		}
		var singer ssh.Signer
		if password == "" {
			singer, err = ssh.ParsePrivateKey(pemBytes)
		} else {
			singer, err = ssh.ParsePrivateKeyWithPassphrase(pemBytes, []byte(password))
		}

		if err != nil {
			return nil, err
		}
		auth = append(auth, ssh.PublicKeys(singer))
	}

	clientConfig = &ssh.ClientConfig{
		User:    user,
		Auth:    auth,
		Timeout: 3 * time.Second,
		HostKeyCallback: func(hostname string, remote net.Addr, key ssh.PublicKey) error {
			return nil
		},
	}

	// connet to ssh
	addr = fmt.Sprintf("%s:%d", host, port)

	if client, err = ssh.Dial("tcp", addr, clientConfig); err != nil {
		return nil, err
	}

	// create session
	if session, err = client.NewSession(); err != nil {
		return nil, err
	}

	return session, nil
}

func main() {
	session, err := connect("admin", "", "172.20.165.161", "/home/admin/id_rsa", 22)
	if err != nil {
		fmt.Println(err)
	}
	defer session.Close()

	session.Stdout = os.Stdout
	session.Stderr = os.Stderr
	session.Run("sh /export/Packages/merger_server_ab/latest/bin/stop.sh")
}

　　

调用shell命令

阻塞方式(需要执行结果)

//阻塞式的执行外部shell命令的函数,等待执行完毕并返回标准输出
func exec_shell(s string) (string, error){
    //函数返回一个*Cmd，用于使用给出的参数执行name指定的程序
    cmd := exec.Command("/bin/bash", "-c", s)

    //读取io.Writer类型的cmd.Stdout，再通过bytes.Buffer(缓冲byte类型的缓冲器)将byte类型转化为string类型(out.String():这是bytes类型提供的接口)
    var out bytes.Buffer
    cmd.Stdout = &out

    //Run执行c包含的命令，并阻塞直到完成。  这里stdout被取出，cmd.Wait()无法正确获取stdin,stdout,stderr，则阻塞在那了
    err := cmd.Run()
    checkErr(err)


    return out.String(), err
}

　　

shell标准输出逐行实时处理

func execCommand(commandName string, params []string) bool {
    //函数返回一个*Cmd，用于使用给出的参数执行name指定的程序
    cmd := exec.Command("/bin/bash","-c",command)

    //显示运行的命令
    fmt.Println(cmd.Args)
    //StdoutPipe方法返回一个在命令Start后与命令标准输出关联的管道。Wait方法获知命令结束后会关闭这个管道，一般不需要显式的关闭该管道。
    stdout, err := cmd.StdoutPipe()

    if err != nil {
        fmt.Println(err)
        return false
    }

    cmd.Start()
    //创建一个流来读取管道内内容，这里逻辑是通过一行一行的读取的
    reader := bufio.NewReader(stdout)

    //实时循环读取输出流中的一行内容
    for {
        line, err2 := reader.ReadString('
')
        if err2 != nil || io.EOF == err2 {
            break
        }
        fmt.Println(line)
    }

    //阻塞直到该命令执行完成，该命令必须是被Start方法开始执行的
    cmd.Wait()
    return true
}

　　

 文件处理

读文件

package main

import (
	"errors"
	"fmt"
	"io/ioutil"
	"os"
)

func main() {
	inputFile, err := os.Open("ip.txt")
	if err != nil {
		err = errors.New("open file error")
		fmt.Println(err)
		return
	}
	defer inputFile.Close()
	fd, err := ioutil.ReadAll(inputFile)
	fmt.Println(string(fd))
}

　　

写文件

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	outputFile, outputError := os.OpenFile("ip.txt", os.O_WRONLY|os.O_CREATE, 0666)
	if outputError != nil {
		fmt.Println(outputError)
		return
	}
	defer outputFile.Close()
	outputWriter := bufio.NewWriter(outputFile)
	outputString := "3.3.3.3
"
	for i := 0; i < 10000; i++ {
		outputWriter.WriteString(outputString)
	}
	outputWriter.Flush()
}

　　

recover

package main

import (
	"fmt"
)

func tryRecover() {
	defer func() {
		r := recover()
		if err, ok := r.(error); ok {
			fmt.Println("error occurred:", err)
		} else {
			panic(r)
		}
	}()
	a := 5
	b := 0
	c := a / b
	fmt.Println(c)
}

func main() {
	tryRecover()
}