本文目錄一覽：
- 1、golang三方包應該如何安裝
- 2、如何使用Go語言實現遠程執行命令
- 3、如何讓命令行程序支持管道和重定向輸入
- 4、如何Golang開發Android應用
- 5、golang排序問題求助
- 6、golang SSH客戶端三件套 – 1遠程連接 shell
golang三方包應該如何安裝
添加環境變數
GOPATH是包載入路徑的變數,根據需要設置路徑
在 /etc/profile中添加
export PATH=$PATH:/var/local/go/bin
export GOROOT=/var/local/go
export GOPATH=/home/go/gopath
使環境變數生效
source /etc/profile
使用 go env 能正常列印環境信息說明安裝成功了。
安裝第三方包
使用 go get安裝包
go get -u -v -x golang.org/x/net/http
golang.org國內安裝不了,可以使用github下載然後做個軟鏈接
go get -u -v -x github.com/golang/net/http
mkdir $GOPATH/src/golang.org
ln -s $GOPATH/src/github.com $GOPATH/src/golang.org/x
如何使用Go語言實現遠程執行命令
一般命令
所謂一般命令，就是在一定時間內會執行完的命令。比如 grep, cat 等等。 執行命令的步驟是：連接，執行，獲取結果
連接
連接包含了認證，可以使用 password 或者 sshkey 2種方式來認證。下面的示例為了簡單，使用了密碼認證的方式來完成連接。
import (
“fmt”
“time”
“golang.org/x/crypto/ssh”
)
func connect(user, password, host 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)
auth = append(auth, ssh.Password(password))
clientConfig = ssh.ClientConfig{
User: user,
Auth: auth,
Timeout: 30 * time.Second,
}
// 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
}
連接的方法很簡單，只要提供登錄主機的 用戶*， *密碼*， *主機名或者IP*， *SSH埠
執行，命令獲取結果
連接成功後，執行命令很簡單
import (
“fmt”
“log”
“os”
“time”
“golang.org/x/crypto/ssh”
)
func main() {
session, err := connect(“root”, “xxxxx”, “127.0.0.1”, 22)
if err != nil {
log.Fatal(err)
}
defer session.Close()
session.Run(“ls /; ls /abc”)
}
上面代碼運行之後，雖然命令正常執行了，但是沒有正常輸出的結果，也沒有異常輸出的結果。 要想顯示結果，需要將 session 的 Stdout 和 Stderr 重定向 修改 func main 為如下：
func main() {
session, err := connect(“root”, “xxxxx”, “127.0.0.1”, 22)
if err != nil {
log.Fatal(err)
}
defer session.Close()
session.Stdout = os.Stdout
session.Stderr = os.Stderr
session.Run(“ls /; ls /abc”)
}
這樣就能在屏幕上顯示正常，異常的信息了。
互動式命令
上面的方式無法遠程執行互動式命令，比如 top ， 遠程編輯一個文件，比如 vi /etc/nginx/nginx.conf 如果要支持互動式的命令，需要當前的terminal來接管遠程的 PTY。
func main() {
session, err := connect(“root”, “olordjesus”, “dockers.iotalabs.io”, 2210)
if err != nil {
log.Fatal(err)
}
defer session.Close()
fd := int(os.Stdin.Fd())
oldState, err := terminal.MakeRaw(fd)
if err != nil {
panic(err)
}
defer terminal.Restore(fd, oldState)
// excute command
session.Stdout = os.Stdout
session.Stderr = os.Stderr
session.Stdin = os.Stdin
termWidth, termHeight, err := terminal.GetSize(fd)
if err != nil {
panic(err)
}
// Set up terminal modes
modes := ssh.TerminalModes{
ssh.ECHO: 1, // enable echoing
ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
}
// Request pseudo terminal
if err := session.RequestPty(“xterm-256color”, termHeight, termWidth, modes); err != nil {
log.Fatal(err)
}
session.Run(“top”)
}
如何讓命令行程序支持管道和重定向輸入
管道和重定向輸入的數據都是通過標準輸入傳入程序的， os.Stdin 即為標準輸入。
可以通過 golang.org/x/crypto/ssh/terminal 的 terminal.IsTerminal(0) 判斷是否是管道和重定向輸入，為什麼是 0 ：因為標準輸入的文件描述符是 0
為 true 時表示是互動式環境
為 false 時是我們要的場景
首先需要安裝 golang.org/x/crypto/ssh/terminal 這個包（安裝時需要 VPN 的輔助）:
go get golang.org/x/crypto/ssh/terminal
也可以使用 github.com/mattn/go-isatty 這個包:
!isatty.IsTerminal(os.Stdin.Fd())
下面是示例代碼:
package mainimport (
“flag”
“fmt”
“io/ioutil”
“os”
“strings”
“golang.org/x/crypto/ssh/terminal”)func main() {
flag.Parse()
data := flag.Args()
if !terminal.IsTerminal(0) {
b, err := ioutil.ReadAll(os.Stdin)
if err == nil {
data = append(data, string(b))
}
}
fmt.Println(strings.Join(data, ” “))}
測試效果:
$ echo “hello” hello.txt
$ go run main.go hello world # 參數輸入hello world
$ cat hello.txt | go run main.go # 管道輸入hello
$ go run main.go hello.txt # 重定向輸入hello
$
如何Golang開發Android應用
環境配置好複雜，我不得不嘮叨幾句。
需要下載golang1.4rc版，下載ndk，然後編譯。 然後用go get 下載gobind這個工具， 然後，將寫好的代碼用gobind轉化下，然後使用特殊的編譯命令，將代碼編譯成.so文件，將生成的相關文件，放到android studio的項目中。然後java代碼中，利用jni調用引用的代碼。
… 好，接著往下看吧。
環境準備
一台Linux 64的機器
一個帶有AndroidStudioIDE的開發機器
因為環境配置實在複雜，所以我們引入的docker。
docker pull codeskyblue/docker-goandroid
docker run –rm -ti codeskyblue/docker-goandroid bash
cd example; echo “view example projects
docker起來之後，什麼就都配置好了，NDK啦，java啦，GO的環境變數了，等等，並且還預裝了vim,gradle,tmux,git,syncthing,svn
開始寫代碼
寫代碼之前，先約定下目錄結構
go的代碼都放在src/golib下，編譯使用make.bash編譯腳本，看下這個文件樹
.
|– app.iml
|– build.gradle
|– libs/armeabi-v7a # go編譯生成的so文件
| `– libgojni.so
|– main.go_tmpl # 一個模板文件，先不用管它
|– make.bash # 編譯腳本，用來生成.so和Java代碼
`– src
|– golib
| |– hi
| | |– go_hi�0�2�0�2�0�2 # 自動生成的代碼
| | | `– go_hi.go
| | `– hi.go # 需要編寫的代碼
| `– main.go
`– main
|– AndroidManifest.xml
|– java
| |– go # 自動生成的代碼
| | |– Go.java
| | |– Seq.java
| | `– hi
| | `– Hi.java
| `– me/shengxiang/gohello # 主要的邏輯代碼
| `– MainActivity.java
`– res
我已經寫了一個例子，先直接搞下來
編譯下，試試行不行（就算不行問題應該也不大，因為大問題都被我消滅了）
cd GoHello/app
./make.bash
../gradlew build
一切順利的話在build/outputs/apk下應該可以看到app-debug.apk這個文件。（劇透下，這個文件只有800多K）
編譯好的我放到qiniu上了，可以點擊下載看看
下面可以嘗試改改，我拋磚引玉說下
打開hi.go這個文件
hi.go的內容，比較簡單，我們寫Go代碼主要就是這部分
// Package hi provides a function for saying hello.
package hi
import “fmt”
func Hello(name string) {
fmt.Printf(“Hello, %s!\n”, name)
return “(Go)World”
}
文件末尾添加下面這行代碼
func Welcome(name string) string {
return fmt.Sprintf(“Welcome %s to the go world”, name)
}
使用./make.bash重新編譯下
打開MainActivity.java 修改下OnClickListener事件
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String message = Hi.Welcome(“yourname”);
Toast.makeText(MainActivity.this, message, Toast.LENGTH_LONG).show();
}
});
編譯運行下，把生成的apk安裝到手機上試試。
原理解讀（有興趣的接著看）
首先說下gobind這個工具。
go_hi/go_hi.go這個文件時通過gobind這個工具生成的，用來配合一個簡單的程序，生成.so文件
// go_hi.go
package go_hi
import (
“golang.org/x/mobile/bind/seq”
“example/hi”
)
func proxy_Hello(out, in *seq.Buffer) {
param_name := in.ReadUTF16()
hi.Hello(param_name)
}
func init() {
seq.Register(“hi”, 1, proxy_Hello)
}
這個簡單的程序內容是這樣的
// main.go
package main
import (
“golang.org/x/mobile/app”
_ “golang.org/x/mobile/bind/java”
_ “example/hi/go_hi”
)
func main() {
app.Run(app.Callbacks{})
}
src/MyActivity.java文件內容是這樣的
import …
import go.Go; // 引入Go這個包
import go.hi.Hi; // gobind生成的代碼
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Go.init(getApplicationContext()); // 初始化兩個線程
Hi.Hello(“world”);
}
}
其中有一句Go.init(…)這裡再看go.Go這個包是什麼樣子的
public final class Go {
// init loads libgojni.so and starts the runtime.
public static void init(Context context) {
… 判斷該函數是否該執行的代碼 — 省略 —
System.loadLibrary(“gojni”); // gojni需要這句
new Thread(“GoMain”) {
public void run() {
Go.run(); // run()是一個native方法
}
}.start();
Go.waitForRun(); // 這個也是一個native方法
// 這部分可以理解為，啟動了一個後台線程不斷的接收結果到緩存中。
new Thread(“GoReceive”) {
public void run() { Seq.receive(); }
}.start();
}
private static boolean running = false;
private static native void run();
private static native void waitForRun();
}
MyActivity.java中還有段代碼是 Hi.Hello(“world”);，打開Hi.java路徑在src/go/hi/Hi.java，這個文件也是gobind生成的，是用來給java方便的調用.so文件
// Hi.java
// File is generated by gobind. Do not edit.
package go.hi;
import go.Seq;
public abstract class Hi {
private Hi() {} // uninstantiable
public static void Hello(String name) {
go.Seq _in = new go.Seq();
go.Seq _out = new go.Seq();
_in.writeUTF16(name);
Seq.send(DESCRIPTOR, CALL_Hello, _in, _out); // 下面接著說
}
private static final int CALL_Hello = 1;
private static final String DESCRIPTOR = “hi”;
}
Seq.send這部分實際上最終調用的是一段go代碼
func Send(descriptor string, code int, req *C.uint8_t, reqlen C.size_t, res **C.uint8_t, reslen *C.size_t) {
fn := seq.Registry[descriptor][code]
in := new(seq.Buffer)
if reqlen 0 {
in.Data = (*[maxSliceLen]byte)(unsafe.Pointer(req))[:reqlen]
}
out := new(seq.Buffer)
fn(out, in)
seqToBuf(res, reslen, out)
}
轉載僅供參考，版權屬於原作者。祝你愉快，滿意請採納哦
golang排序問題求助
如果是只有這幾個的話 我們可以考慮自定義一個排序類型
func TestSort(t *testing.T) {
data := []string{“三級”, “一級”, “二級”}
rule := map[string]int{
“一級”: 1,
“二級”: 2,
“三級”: 3,
}
self := SelfSort{
Rule: rule,
Data: data,
}
sort.Sort(self)
fmt.Println(self.Data)
}
type SelfSort struct {
Rule map[string]int
Data []string
}
func (p SelfSort) Len() int { return len(p.Data) }
func (p SelfSort) Less(i, j int) bool { return p.Rule[p.Data[i]] p.Rule[p.Data[j]] }
func (p SelfSort) Swap(i, j int) { p.Data[i], p.Data[j] = p.Data[j], p.Data[i] }
如過很多 就是真的要比較中文的話， 就用這種
package mainimport ( “bytes”
“fmt”
“io/ioutil”
“sort”
“golang.org/x/text/encoding/simplifiedchinese”
“golang.org/x/text/transform”)//ByPinyin is customized sort interface to sort string by Chinese PinYintype ByPinyin []stringfunc (s ByPinyin) Len() int { return len(s) }func (s ByPinyin) Swap(i, j int) { s[i], s[j] = s[j], s[i] }func (s ByPinyin) Less(i, j int) bool {
a, _ := UTF82GBK(s[i])
b, _ := UTF82GBK(s[j])
bLen := len(b) for idx, chr := range a { if idx bLen-1 { return false
} if chr != b[idx] { return chr b[idx]
}
} return true}//UTF82GBK : transform UTF8 rune into GBK byte arrayfunc UTF82GBK(src string) ([]byte, error) {
GB18030 := simplifiedchinese.All[0] return ioutil.ReadAll(transform.NewReader(bytes.NewReader([]byte(src)), GB18030.NewEncoder()))
}//GBK2UTF8 : transform GBK byte array into UTF8 stringfunc GBK2UTF8(src []byte) (string, error) {
GB18030 := simplifiedchinese.All[0]
bytes, err := ioutil.ReadAll(transform.NewReader(bytes.NewReader(src), GB18030.NewDecoder())) return string(bytes), err
}func main() {
b := []string{“哈”, “呼”, “嚯”, “ha”, “,”}
sort.Strings(b) //output: [, ha 呼 哈 嚯]
fmt.Println(“Default sort: “, b)
sort.Sort(ByPinyin(b)) //output: [, ha 哈 呼 嚯]
fmt.Println(“By Pinyin sort: “, b)
}
copy from 網頁鏈接
golang SSH客戶端三件套 – 1遠程連接 shell
golang SSH客戶端系列文章目錄
SSH(Secure Shell)協議在遠程登錄時比較常用，但是除此之外還有一些其它的功能也很好用，比如埠映射，X11轉發，sftp文件傳輸等。
以下三篇文章將介紹golang版SSH的遠程登錄功能，埠映射功能及sftp文件傳輸功能。X11包含GUI的一些操作，沒有找到相關的包，故不做介紹
通過golang自帶的ssh包 golang.org/x/crypto/ssh 可以實現遠程登錄功能， 默認是不支持tab鍵和上下箭頭的 ，
通過導入golang.org/x/crypto/ssh/terminal來創建VT100終端可以支持tab等功能，讓golang版本的ssh客戶端體驗和平時用的其它客戶端差不多。
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/248400.html
微信掃一掃 
支付寶掃一掃 