知识点:
【http传输】
respBodyMap := bson.M{"状态码": "成功", "userId": userId, "dataSource": dataSource, "upDown": upDown, "channel": channel, "full": full, "文件详细信息": fileInfoStrSlice}
buf, err := json.Marshal(respBodyMap)
var TranspondServerUrlPath string = `http://10.60.73.152:8087/transpond/`//transpond为注册路由器的socket，8087为监听的端口
resp, err := http.Post(TranspondServerUrlPath+"TranspondAutoGetData", "application/json", bytes.NewReader(buf))
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
var data interface{}
err = json.Unmarshal(body, &data)
status := data.(map[string]interface{})["状态码"].(string)
【go调用Python】
matlabPath := "D:\\scw\\dingheng\\V2.00.20_0709_p\\HFC_UL.m"
files, _ := ioutil.ReadDir("D:\\scw\\json_Tmp")
for k, fi := range files {
cmd1 := exec.Command("python", "callMatlab.py", fi.Name(), matlabPath)//go调用python
cmd1.Dir = "D:\\scw\\dingheng\\V2.00.20_0709_p"
err := cmd1.Start()
if err != nil {
fmt.Println("err", err)
} else {
errWait := cmd1.Wait()
if errWait != nil { //exit status 1
fmt.Println("ss err", errWait)
}
}
}
python代码
/*
# -*- coding: utf-8 -*-
from pymatbridge import Matlab
import sys
if __name__ == '__main__':
jsonName = sys.argv[1].strip("'")
print jsonName
mlab = Matlab()
mlab.start()
mlab.set_plot_settings(width = 1200,height = 900,inline = True)
res = mlab.run_func("D:\\scw\\dingheng\\V2.00.20_0709_p\\HFC_UL.m",{'arg1':jsonName,'arg2':"",'arg3':""})
print res
*/
【os/exec】
//先通过系统库exec.LookPath判断可执行程序是否存在
path, err := exec.LookPath(exe)//exe可以为"ls","bee"
调用脚本文件
cmd := exec.Command("taskkill.exe", "/f", "/t", "/im", "nginx.exe")
err = cmd.Start()
if nil != err {
log.Error("pkg: service, func: KillNginxServer, method: cmd.Start, errInfo:", err)
} else {
log.Info(fmt.Sprintf("kill %s successfully", "nginx.exe"))
}
time.Sleep(3 * time.Second) //必须要暂停
获取本地IP
func GetLocalIP() {
buf, err := exec.Command("CMD", "/C", " ipconfig").Output()
fmt.Println("buf", string(buf))
if err != nil {
fmt.Println("pkg: service, func: GetLocalIP, method: exec.Command, errInfo:", err)
return
}
reg := regexp.MustCompile(`\d+\.\d+\.\d+\.\d+`)
ips := reg.FindAllString(string(buf), -1)
for _, ip := range ips {
fmt.Println("LocalIp", ip)
}
return
}
exec.Command("CMD", "/C", " ipconfig")
cmd /c dir 是执行完dir命令后封闭命令窗口
cmd /k dir 是执行完dir命令后不封闭命令窗口
cmd /c dir 会打开一个新窗口后执行dir命令,原窗口会封闭
cmd /k dir 会打开一个新窗口后执行dir命令,原窗口不会封闭
cmd := exec.Command("touch", "test_file")
err := cmd.Run()
if err != nil {
fmt.Println("Execute Command failed:" + err.Error())
return
}
fmt.Println("Execute Command finished.")
command := `./dir_size.sh .`
cmd := exec.Command("/bin/bash", "-c", command)
output, err := cmd.Output()
if err != nil {
fmt.Printf("Execute Shell:%s failed with error:%s", command, err.Error())
return
}
fmt.Printf("Execute Shell:%s finished with output:\n%s", command, string(output))
func Command(name string, arg ...string) *Cmd
//方法返回一个*Cmd， 用于执行name指定的程序(携带arg参数)
func (c *Cmd) Run() error
//执行Cmd中包含的命令，阻塞直到命令执行完成
func (c *Cmd) Start() error
//执行Cmd中包含的命令，该方法立即返回，并不等待命令执行完成
func (c *Cmd) Wait() error
//该方法会阻塞直到Cmd中的命令执行完成，但该命令必须是被Start方法开始执行的
func (c *Cmd) Output() ([]byte, error)
//执行Cmd中包含的命令，并返回标准输出的切片
func (c *Cmd) CombinedOutput() ([]byte, error)
//执行Cmd中包含的命令，并返回标准输出与标准错误合并后的切片
func (c *Cmd) StdinPipe() (io.WriteCloser, error)
//返回一个管道，该管道会在Cmd中的命令被启动后连接到其标准输入
func (c *Cmd) StdoutPipe() (io.ReadCloser, error)
//返回一个管道，该管道会在Cmd中的命令被启动后连接到其标准输出
func (c *Cmd) StderrPipe() (io.ReadCloser, error)
//返回一个管道，该管道会在Cmd中的命令被启动后连接到其标准错误
type Cmd struct {
Path string //运行命令的路径，绝对路径或者相对路径
Args []string // 命令参数
Env []string //进程环境，如果环境为空，则使用当前进程的环境
Dir string//指定command的工作目录，如果dir为空，则comman在调用进程所在当前目录中运行
Stdin io.Reader//标准输入，如果stdin是nil的话，进程从null device中读取（os.DevNull），stdin也可以时一个文件，否则的话则在运行过程中再开一个goroutine去
Stdout io.Writer //标准输出
Stderr io.Writer //错误输出，如果这两个（Stdout和Stderr）为空的话，则command运行时将响应的文件描述符连接到os.DevNull
ExtraFiles []*os.File
SysProcAttr *syscall.SysProcAttr
Process *os.Process //Process是底层进程，只启动一次
ProcessState *os.ProcessState //ProcessState包含一个退出进程的信息，当进程调用Wait或者Run时便会产生该信息．
}
func Command(name string, arg ...string) *Cmd //command返回cmd结构来执行带有相关参数的命令，它仅仅设定cmd结构中的Path和Args参数，
// 如果name参数中不包含路径分隔符，command使用LookPath来解决路径问题，否则的话就直接使用name；Args直接跟在command命令之后，所以在Args中不许要添加命令．
cmd := exec.Command("tr", "a-z", "A-Z")
cmd.Stdin = strings.NewReader("some input")
var out bytes.Buffer
cmd.Stdout = &out
err := cmd.Run()
if err != nil {
log.Fatal(err)
}
fmt.Printf("in all caps: %q\n", out.String()) //in all caps: "SOME INPUT"
func (c *Cmd) CombinedOutput() ([]byte, error) //运行命令，并返回标准输出和标准错误
cmd := exec.Command("ls") //查看当前目录下文件
out, err := cmd.CombinedOutput()
if err != nil {
fmt.Println(err)
}
fmt.Println(string(out))
func (c *Cmd) Output() ([]byte, error) //运行命令并返回其标准输出
cmd := exec.Command("ls") ///查看当前目录下文件
out, err := cmd.Output()
if err != nil {
fmt.Println(err)
}
fmt.Println(string(out))
注意:Output()和CombinedOutput()不能够同时使用,因为command的标准输出只能有一个,同时使用的话便会定义了两个,便会报错
func (c *Cmd) Run() error//开始指定命令并且等待他执行结束，如果命令能够成功执行完毕，则返回nil，否则的话边会产生错误
func (c *Cmd) Start() error//使某个命令开始执行，但是并不等到他执行结束，这点和Run命令有区别．然后使用Wait方法等待命令执行完毕并且释放响应的资源
注:一个command只能使用Start()或者Run()中的一个启动命令,不能两个同时使用.
func (c *Cmd) Wait() error//Wait等待command退出，他必须和Start一起使用，如果命令能够顺利执行完并顺利退出则返回nil，否则的话便会返回error，其中Wait会是放掉所有与cmd命令相关的资源
另一种形式
cmd := exec.Command("cmd")
in := bytes.NewBuffer(nil)
cmd.Stdin = in//绑定输入
var out bytes.Buffer
cmd.Stdout = &out //绑定输出
go func() {
in.WriteString("node E:/design/test.js\n")//写入你的命令，可以有多行，"\n"表示回车
}()
err = cmd.Start()
if err != nil {
log.Fatal(err)
}
log.Println(cmd.Args)
err = cmd.Wait()
if err != nil {
log.Printf("Command finished with error: %v", err)
}
fmt.Println(out.String())
