Hprose 2.0 for Golang 完成了

Go开源项目andot 发表了文章 • 2 个评论 • 251 次浏览 • 2016-10-13 12:49 • 来自相关话题

Hprose 2.0 for Golang 新增了许多特征:

  • 更快更稳定的序列化。
  • 增加了数据推送的支持。
  • oneway 调用支持。
  • 增加了对幂等性(idempotent)调... 查看全部

Hprose 2.0 for Golang 新增了许多特征:



  • 更快更稳定的序列化。

  • 增加了数据推送的支持。

  • oneway 调用支持。

  • 增加了对幂等性(idempotent)调用自动重试的支持。

  • 增加了异步调用支持。

  • 客户端增加了负载均衡,故障切换的支持。

  • 对客户端调用和服务器发布的 API 进行了优化,将多余的位置参数改为命名参数。

  • 增加了新的中间件处理器支持,可以实现更强大的 AOP 编程。

Docker源码分析,附阅读地址

文章分享wwdyy 发表了文章 • 3 个评论 • 228 次浏览 • 2016-10-13 11:26 • 来自相关话题

Docker是一个由GO语言写的程序运行的“容器”,开发者可以从操作系统到依赖库乱七八糟东西(tomcat,mysql等等)全给你“静态编译”到一起变成一容器中

即使不在项目中使用 Docker,本书也能够为 Go 语言程序员带来帮助。Do... 查看全部

Docker是一个由GO语言写的程序运行的“容器”,开发者可以从操作系统到依赖库乱七八糟东西(tomcat,mysql等等)全给你“静态编译”到一起变成一容器中


即使不在项目中使用 Docker,本书也能够为 Go 语言程序员带来帮助。Docker 项目
中大量采用了 Go 语言,尤其是在处理并发场景时,Docker 对 Go 语言的运用可谓出神入
化。本书可以帮助 Go 语言程序员亲身体验特大型项目中 Go 语言的威力,以及实战场景中
Golang 模式和功能的用法


推荐大家去买正版图书,工具书不同于小说,需要反反复复的学习


阅读地址(可以下载):


[网易云阅读]( http://yuedu.163.com/source/37aa61f7a4874857bf7a57d7a2410b7f_4 )


[CSDN]( http://download.csdn.net/detail/hzbooks/8943237 )

【转】Go文件操作大全

文章分享故城 发表了文章 • 2 个评论 • 454 次浏览 • 2016-10-13 09:57 • 来自相关话题

> 译者博客  查看全部
					
> 译者博客  http://colobu.com/2016/10/12/g ... erral

> 原作者博客 http://www.devdungeon.com/cont ... bytes

参考
Go官方库的文件操作分散在多个包中,比如os、ioutil包,我本来想写一篇总结性的Go文件操作的文章,却发现已经有人2015年已经写了一篇这样的文章,写的非常好,所以我翻译成了中文,强烈推荐你阅读一下。

原文: Working with Files in Go, 作者: NanoDano

介绍

万物皆文件

UNIX 的一个基础设计就是"万物皆文件"(everything is a file)。我们不必知道一个文件到底映射成什么,操作系统的设备驱动抽象成文件。操作系统为设备提供了文件格式的接口。

Go语言中的reader和writer接口也类似。我们只需简单的读写字节,不必知道reader的数据来自哪里,也不必知道writer将数据发送到哪里。
你可以在/dev下查看可用的设备,有些可能需要较高的权限才能访问。

基本操作

# 创建空文件

```go
package main
import (
"log"
"os"
)
var (
newFile *os.File
err error
)
func main() {
newFile, err = os.Create("test.txt")
if err != nil {
log.Fatal(err)
}
log.Println(newFile)
newFile.Close()
}

Truncate文件


package main
import (
"log"
"os"
)
func main() {
// 裁剪一个文件到100个字节。
// 如果文件本来就少于100个字节,则文件中原始内容得以保留,剩余的字节以null字节填充。
// 如果文件本来超过100个字节,则超过的字节会被抛弃。
// 这样我们总是得到精确的100个字节的文件。
// 传入0则会清空文件。
err := os.Truncate("test.txt", 100)
if err != nil {
log.Fatal(err)
}
}

得到文件信息


package main
import (
"fmt"
"log"
"os"
)
var (
fileInfo os.FileInfo
err error
)
func main() {
// 如果文件不存在,则返回错误
fileInfo, err = os.Stat("test.txt")
if err != nil {
log.Fatal(err)
}
fmt.Println("File name:", fileInfo.Name())
fmt.Println("Size in bytes:", fileInfo.Size())
fmt.Println("Permissions:", fileInfo.Mode())
fmt.Println("Last modified:", fileInfo.ModTime())
fmt.Println("Is Directory: ", fileInfo.IsDir())
fmt.Printf("System interface type: %T\n", fileInfo.Sys())
fmt.Printf("System info: %+v\n\n", fileInfo.Sys())
}

重命名和移动


package main
import (
"log"
"os"
)
func main() {
originalPath := "test.txt"
newPath := "test2.txt"
err := os.Rename(originalPath, newPath)
if err != nil {
log.Fatal(err)
}
}

译者按: rename 和 move 原理一样


删除文件


package main
import (
"log"
"os"
)
func main() {
err := os.Remove("test.txt")
if err != nil {
log.Fatal(err)
}
}

打开和关闭文件


package main
import (
"log"
"os"
)
func main() {
// 简单地以只读的方式打开。下面的例子会介绍读写的例子。
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
file.Close()
// OpenFile提供更多的选项。
// 最后一个参数是权限模式permission mode
// 第二个是打开时的属性
file, err = os.OpenFile("test.txt", os.O_APPEND, 0666)
if err != nil {
log.Fatal(err)
}
file.Close()
// 下面的属性可以单独使用,也可以组合使用。
// 组合使用时可以使用 OR 操作设置 OpenFile的第二个参数,例如:
// os.O_CREATE|os.O_APPEND
// 或者 os.O_CREATE|os.O_TRUNC|os.O_WRONLY
// os.O_RDONLY // 只读
// os.O_WRONLY // 只写
// os.O_RDWR // 读写
// os.O_APPEND // 往文件中添建(Append)
// os.O_CREATE // 如果文件不存在则先创建
// os.O_TRUNC // 文件打开时裁剪文件
// os.O_EXCL // 和O_CREATE一起使用,文件不能存在
// os.O_SYNC // 以同步I/O的方式打开
}

译者按:熟悉Linux的读者应该很熟悉权限模式,通过Linux命令chmod可以更改文件的权限
https://www.linux.com/learn/understanding-linux-file-permissions


补充了原文未介绍的flag


检查文件是否存在


package main
import (
"log"
"os"
)
var (
fileInfo *os.FileInfo
err error
)
func main() {
// 文件不存在则返回error
fileInfo, err := os.Stat("test.txt")
if err != nil {
if os.IsNotExist(err) {
log.Fatal("File does not exist.")
}
}
log.Println("File does exist. File information:")
log.Println(fileInfo)
}

检查读写权限


package main
import (
"log"
"os"
)
func main() {
// 这个例子测试写权限,如果没有写权限则返回error。
// 注意文件不存在也会返回error,需要检查error的信息来获取到底是哪个错误导致。
file, err := os.OpenFile("test.txt", os.O_WRONLY, 0666)
if err != nil {
if os.IsPermission(err) {
log.Println("Error: Write permission denied.")
}
}
file.Close()
// 测试读权限
file, err = os.OpenFile("test.txt", os.O_RDONLY, 0666)
if err != nil {
if os.IsPermission(err) {
log.Println("Error: Read permission denied.")
}
}
file.Close()
}

改变权限、拥有者、时间戳


package main
import (
"log"
"os"
"time"
)
func main() {
// 使用Linux风格改变文件权限
err := os.Chmod("test.txt", 0777)
if err != nil {
log.Println(err)
}
// 改变文件所有者
err = os.Chown("test.txt", os.Getuid(), os.Getgid())
if err != nil {
log.Println(err)
}
// 改变时间戳
twoDaysFromNow := time.Now().Add(48 * time.Hour)
lastAccessTime := twoDaysFromNow
lastModifyTime := twoDaysFromNow
err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime)
if err != nil {
log.Println(err)
}
}

硬链接和软链接


一个普通的文件是一个指向硬盘的inode的地方。
硬链接创建一个新的指针指向同一个地方。只有所有的链接被删除后文件才会被删除。硬链接只在相同的文件系统中才工作。你可以认为一个硬链接是一个正常的链接。


symbolic link,又叫软连接,和硬链接有点不一样,它不直接指向硬盘中的相同的地方,而是通过名字引用其它文件。他们可以指向不同的文件系统中的不同文件。并不是所有的操作系统都支持软链接。


package main
import (
"os"
"log"
"fmt"
)
func main() {
// 创建一个硬链接。
// 创建后同一个文件内容会有两个文件名,改变一个文件的内容会影响另一个。
// 删除和重命名不会影响另一个。
err := os.Link("original.txt", "original_also.txt")
if err != nil {
log.Fatal(err)
}
fmt.Println("creating sym")
// Create a symlink
err = os.Symlink("original.txt", "original_sym.txt")
if err != nil {
log.Fatal(err)
}
// Lstat返回一个文件的信息,但是当文件是一个软链接时,它返回软链接的信息,而不是引用的文件的信息。
// Symlink在Windows中不工作。
fileInfo, err := os.Lstat("original_sym.txt")
if err != nil {
log.Fatal(err)
}
fmt.Printf("Link info: %+v", fileInfo)
//改变软链接的拥有者不会影响原始文件。
err = os.Lchown("original_sym.txt", os.Getuid(), os.Getgid())
if err != nil {
log.Fatal(err)
}
}

读写


复制文件


package main
import (
"os"
"log"
"io"
)
func main() {
// 打开原始文件
originalFile, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer originalFile.Close()
// 创建新的文件作为目标文件
newFile, err := os.Create("test_copy.txt")
if err != nil {
log.Fatal(err)
}
defer newFile.Close()
// 从源中复制字节到目标文件
bytesWritten, err := io.Copy(newFile, originalFile)
if err != nil {
log.Fatal(err)
}
log.Printf("Copied %d bytes.", bytesWritten)
// 将文件内容flush到硬盘中
err = newFile.Sync()
if err != nil {
log.Fatal(err)
}
}

跳转到文件指定位置(Seek)


package main
import (
"os"
"fmt"
"log"
)
func main() {
file, _ := os.Open("test.txt")
defer file.Close()
// 偏离位置,可以是正数也可以是负数
var offset int64 = 5
// 用来计算offset的初始位置
// 0 = 文件开始位置
// 1 = 当前位置
// 2 = 文件结尾处
var whence int = 0
newPosition, err := file.Seek(offset, whence)
if err != nil {
log.Fatal(err)
}
fmt.Println("Just moved to 5:", newPosition)
// 从当前位置回退两个字节
newPosition, err = file.Seek(-2, 1)
if err != nil {
log.Fatal(err)
}
fmt.Println("Just moved back two:", newPosition)
// 使用下面的技巧得到当前的位置
currentPosition, err := file.Seek(0, 1)
fmt.Println("Current position:", currentPosition)
// 转到文件开始处
newPosition, err = file.Seek(0, 0)
if err != nil {
log.Fatal(err)
}
fmt.Println("Position after seeking 0,0:", newPosition)
}

写文件


可以使用os包写入一个打开的文件。
因为Go可执行包是静态链接的可执行文件,你import的每一个包都会增加你的可执行文件的大小。其它的包如io、`ioutil`、`bufio`提供了一些方法,但是它们不是必须的。


package main
import (
"os"
"log"
)
func main() {
// 可写方式打开文件
file, err := os.OpenFile(
"test.txt",
os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
0666,
)
if err != nil {
log.Fatal(err)
}
defer file.Close()
// 写字节到文件中
byteSlice := []byte("Bytes!\n")
bytesWritten, err := file.Write(byteSlice)
if err != nil {
log.Fatal(err)
}
log.Printf("Wrote %d bytes.\n", bytesWritten)
}

快写文件


ioutil包有一个非常有用的方法WriteFile()可以处理创建/打开文件、写字节slice和关闭文件一系列的操作。如果你需要简洁快速地写字节slice到文件中,你可以使用它。


package main
import (
"io/ioutil"
"log"
)
func main() {
err := ioutil.WriteFile("test.txt", []byte("Hi\n"), 0666)
if err != nil {
log.Fatal(err)
}
}

使用缓存写


bufio包提供了带缓存功能的writer,所以你可以在写字节到硬盘前使用内存缓存。当你处理很多的数据很有用,因为它可以节省操作硬盘I/O的时间。在其它一些情况下它也很有用,比如你每次写一个字节,把它们攒在内存缓存中,然后一次写入到硬盘中,减少硬盘的磨损以及提升性能。


package main
import (
"log"
"os"
"bufio"
)
func main() {
// 打开文件,只写
file, err := os.OpenFile("test.txt", os.O_WRONLY, 0666)
if err != nil {
log.Fatal(err)
}
defer file.Close()
// 为这个文件创建buffered writer
bufferedWriter := bufio.NewWriter(file)
// 写字节到buffer
bytesWritten, err := bufferedWriter.Write(
[]byte{65, 66, 67},
)
if err != nil {
log.Fatal(err)
}
log.Printf("Bytes written: %d\n", bytesWritten)
// 写字符串到buffer
// 也可以使用 WriteRune() 和 WriteByte()
bytesWritten, err = bufferedWriter.WriteString(
"Buffered string\n",
)
if err != nil {
log.Fatal(err)
}
log.Printf("Bytes written: %d\n", bytesWritten)
// 检查缓存中的字节数
unflushedBufferSize := bufferedWriter.Buffered()
log.Printf("Bytes buffered: %d\n", unflushedBufferSize)
// 还有多少字节可用(未使用的缓存大小)
bytesAvailable := bufferedWriter.Available()
if err != nil {
log.Fatal(err)
}
log.Printf("Available buffer: %d\n", bytesAvailable)
// 写内存buffer到硬盘
bufferedWriter.Flush()
// 丢弃还没有flush的缓存的内容,清除错误并把它的输出传给参数中的writer
// 当你想将缓存传给另外一个writer时有用
bufferedWriter.Reset(bufferedWriter)
bytesAvailable = bufferedWriter.Available()
if err != nil {
log.Fatal(err)
}
log.Printf("Available buffer: %d\n", bytesAvailable)
// 重新设置缓存的大小。
// 第一个参数是缓存应该输出到哪里,这个例子中我们使用相同的writer。
// 如果我们设置的新的大小小于第一个参数writer的缓存大小, 比如10,我们不会得到一个10字节大小的缓存,
// 而是writer的原始大小的缓存,默认是4096。
// 它的功能主要还是为了扩容。
bufferedWriter = bufio.NewWriterSize(
bufferedWriter,
8000,
)
// resize后检查缓存的大小
bytesAvailable = bufferedWriter.Available()
if err != nil {
log.Fatal(err)
}
log.Printf("Available buffer: %d\n", bytesAvailable)
}

读取最多N个字节


os.File提供了文件操作的基本功能, 而io、ioutil、bufio提供了额外的辅助函数。


package main
import (
"os"
"log"
)
func main() {
// 打开文件,只读
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
// 从文件中读取len(b)字节的文件。
// 返回0字节意味着读取到文件尾了
// 读取到文件会返回io.EOF的error
byteSlice := make([]byte, 16)
bytesRead, err := file.Read(byteSlice)
if err != nil {
log.Fatal(err)
}
log.Printf("Number of bytes read: %d\n", bytesRead)
log.Printf("Data read: %s\n", byteSlice)
}

读取正好N个字节


package main
import (
"os"
"log"
"io"
)
func main() {
// Open file for reading
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
// file.Read()可以读取一个小文件到大的byte slice中,
// 但是io.ReadFull()在文件的字节数小于byte slice字节数的时候会返回错误
byteSlice := make([]byte, 2)
numBytesRead, err := io.ReadFull(file, byteSlice)
if err != nil {
log.Fatal(err)
}
log.Printf("Number of bytes read: %d\n", numBytesRead)
log.Printf("Data read: %s\n", byteSlice)
}

读取至少N个字节


package main
import (
"os"
"log"
"io"
)
func main() {
// 打开文件,只读
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
byteSlice := make([]byte, 512)
minBytes := 8
// io.ReadAtLeast()在不能得到最小的字节的时候会返回错误,但会把已读的文件保留
numBytesRead, err := io.ReadAtLeast(file, byteSlice, minBytes)
if err != nil {
log.Fatal(err)
}
log.Printf("Number of bytes read: %d\n", numBytesRead)
log.Printf("Data read: %s\n", byteSlice)
}

读取全部字节


package main
import (
"os"
"log"
"fmt"
"io/ioutil"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
// os.File.Read(), io.ReadFull() 和
// io.ReadAtLeast() 在读取之前都需要一个固定大小的byte slice。
// 但ioutil.ReadAll()会读取reader(这个例子中是file)的每一个字节,然后把字节slice返回。
data, err := ioutil.ReadAll(file)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Data as hex: %x\n", data)
fmt.Printf("Data as string: %s\n", data)
fmt.Println("Number of bytes read:", len(data))
}

快读到内存


package main
import (
"log"
"io/ioutil"
)
func main() {
// 读取文件到byte slice中
data, err := ioutil.ReadFile("test.txt")
if err != nil {
log.Fatal(err)
}
log.Printf("Data read: %s\n", data)
}

使用缓存读


有缓存写也有缓存读。
缓存reader会把一些内容缓存在内存中。它会提供比os.File和io.Reader更多的函数,缺省的缓存大小是4096,最小缓存是16。


package main
import (
"os"
"log"
"bufio"
"fmt"
)
func main() {
// 打开文件,创建buffered reader
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
bufferedReader := bufio.NewReader(file)
// 得到字节,当前指针不变
byteSlice := make([]byte, 5)
byteSlice, err = bufferedReader.Peek(5)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Peeked at 5 bytes: %s\n", byteSlice)
// 读取,指针同时移动
numBytesRead, err := bufferedReader.Read(byteSlice)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Read %d bytes: %s\n", numBytesRead, byteSlice)
// 读取一个字节, 如果读取不成功会返回Error
myByte, err := bufferedReader.ReadByte()
if err != nil {
log.Fatal(err)
}
fmt.Printf("Read 1 byte: %c\n", myByte)
// 读取到分隔符,包含分隔符,返回byte slice
dataBytes, err := bufferedReader.ReadBytes('\n')
if err != nil {
log.Fatal(err)
}
fmt.Printf("Read bytes: %s\n", dataBytes)
// 读取到分隔符,包含分隔符,返回字符串
dataString, err := bufferedReader.ReadString('\n')
if err != nil {
log.Fatal(err)
}
fmt.Printf("Read string: %s\n", dataString)
//这个例子读取了很多行,所以test.txt应该包含多行文本才不至于出错
}

使用 scanner


Scanner是bufio包下的类型,在处理文件中以分隔符分隔的文本时很有用。
通常我们使用换行符作为分隔符将文件内容分成多行。在CSV文件中,逗号一般作为分隔符。
os.File文件可以被包装成bufio.Scanner,它就像一个缓存reader。
我们会调用Scan()方法去读取下一个分隔符,使用Text()或者Bytes()获取读取的数据。


分隔符可以不是一个简单的字节或者字符,有一个特殊的方法可以实现分隔符的功能,以及将指针移动多少,返回什么数据。
如果没有定制的SplitFunc提供,缺省的ScanLines会使用newline字符作为分隔符,其它的分隔函数还包括ScanRunes和ScanWords,皆在bufio包中。


// To define your own split function, match this fingerprint
type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)
// Returning (0, nil, nil) will tell the scanner
// to scan again, but with a bigger buffer because
// it wasn't enough data to reach the delimiter
下面的例子中,为一个文件创建了bufio.Scanner,并按照单词逐个读取:

package main
import (
"os"
"log"
"fmt"
"bufio"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
scanner := bufio.NewScanner(file)
// 缺省的分隔函数是bufio.ScanLines,我们这里使用ScanWords。
// 也可以定制一个SplitFunc类型的分隔函数
scanner.Split(bufio.ScanWords)
// scan下一个token.
success := scanner.Scan()
if success == false {
// 出现错误或者EOF是返回Error
err = scanner.Err()
if err == nil {
log.Println("Scan completed and reached EOF")
} else {
log.Fatal(err)
}
}
// 得到数据,Bytes() 或者 Text()
fmt.Println("First word found:", scanner.Text())
// 再次调用scanner.Scan()发现下一个token
}

压缩


打包(zip) 文件


// This example uses zip but standard library
// also supports tar archives
package main
import (
"archive/zip"
"log"
"os"
)
func main() {
// 创建一个打包文件
outFile, err := os.Create("test.zip")
if err != nil {
log.Fatal(err)
}
defer outFile.Close()
// 创建zip writer
zipWriter := zip.NewWriter(outFile)
// 往打包文件中写文件。
// 这里我们使用硬编码的内容,你可以遍历一个文件夹,把文件夹下的文件以及它们的内容写入到这个打包文件中。
var filesToArchive = []struct {
Name, Body string
} {
{"test.txt", "String contents of file"},
{"test2.txt", "\x61\x62\x63\n"},
}
// 下面将要打包的内容写入到打包文件中,依次写入。
for _, file := range filesToArchive {
fileWriter, err := zipWriter.Create(file.Name)
if err != nil {
log.Fatal(err)
}
_, err = fileWriter.Write([]byte(file.Body))
if err != nil {
log.Fatal(err)
}
}
// 清理
err = zipWriter.Close()
if err != nil {
log.Fatal(err)
}
}

抽取(unzip) 文件


// This example uses zip but standard library
// also supports tar archives
package main
import (
"archive/zip"
"log"
"io"
"os"
"path/filepath"
)
func main() {
zipReader, err := zip.OpenReader("test.zip")
if err != nil {
log.Fatal(err)
}
defer zipReader.Close()
// 遍历打包文件中的每一文件/文件夹
for _, file := range zipReader.Reader.File {
// 打包文件中的文件就像普通的一个文件对象一样
zippedFile, err := file.Open()
if err != nil {
log.Fatal(err)
}
defer zippedFile.Close()
// 指定抽取的文件名。
// 你可以指定全路径名或者一个前缀,这样可以把它们放在不同的文件夹中。
// 我们这个例子使用打包文件中相同的文件名。
targetDir := "./"
extractedFilePath := filepath.Join(
targetDir,
file.Name,
)
// 抽取项目或者创建文件夹
if file.FileInfo().IsDir() {
// 创建文件夹并设置同样的权限
log.Println("Creating directory:", extractedFilePath)
os.MkdirAll(extractedFilePath, file.Mode())
} else {
//抽取正常的文件
log.Println("Extracting file:", file.Name)
outputFile, err := os.OpenFile(
extractedFilePath,
os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
file.Mode(),
)
if err != nil {
log.Fatal(err)
}
defer outputFile.Close()
// 通过io.Copy简洁地复制文件内容
_, err = io.Copy(outputFile, zippedFile)
if err != nil {
log.Fatal(err)
}
}
}
}

压缩文件


// 这个例子中使用gzip压缩格式,标准库还支持zlib, bz2, flate, lzw
package main
import (
"os"
"compress/gzip"
"log"
)
func main() {
outputFile, err := os.Create("test.txt.gz")
if err != nil {
log.Fatal(err)
}
gzipWriter := gzip.NewWriter(outputFile)
defer gzipWriter.Close()
// 当我们写如到gizp writer数据时,它会依次压缩数据并写入到底层的文件中。
// 我们不必关心它是如何压缩的,还是像普通的writer一样操作即可。
_, err = gzipWriter.Write([]byte("Gophers rule!\n"))
if err != nil {
log.Fatal(err)
}
log.Println("Compressed data written to file.")
}

解压缩文件


// 这个例子中使用gzip压缩格式,标准库还支持zlib, bz2, flate, lzw
package main
import (
"compress/gzip"
"log"
"io"
"os"
)
func main() {
// 打开一个gzip文件。
// 文件是一个reader,但是我们可以使用各种数据源,比如web服务器返回的gzipped内容,
// 它的内容不是一个文件,而是一个内存流
gzipFile, err := os.Open("test.txt.gz")
if err != nil {
log.Fatal(err)
}
gzipReader, err := gzip.NewReader(gzipFile)
if err != nil {
log.Fatal(err)
}
defer gzipReader.Close()
// 解压缩到一个writer,它是一个file writer
outfileWriter, err := os.Create("unzipped.txt")
if err != nil {
log.Fatal(err)
}
defer outfileWriter.Close()
// 复制内容
_, err = io.Copy(outfileWriter, gzipReader)
if err != nil {
log.Fatal(err)
}
}

其它



临时文件和目录


ioutil提供了两个函数: TempDir() 和 TempFile()。
使用完毕后,调用者负责删除这些临时文件和文件夹。
有一点好处就是当你传递一个空字符串作为文件夹名的时候,它会在操作系统的临时文件夹中创建这些项目(/tmp on Linux)。
os.TempDir()返回当前操作系统的临时文件夹。


package main
import (
"os"
"io/ioutil"
"log"
"fmt"
)
func main() {
// 在系统临时文件夹中创建一个临时文件夹
tempDirPath, err := ioutil.TempDir("", "myTempDir")
if err != nil {
log.Fatal(err)
}
fmt.Println("Temp dir created:", tempDirPath)
// 在临时文件夹中创建临时文件
tempFile, err := ioutil.TempFile(tempDirPath, "myTempFile.txt")
if err != nil {
log.Fatal(err)
}
fmt.Println("Temp file created:", tempFile.Name())
// ... 做一些操作 ...
// 关闭文件
err = tempFile.Close()
if err != nil {
log.Fatal(err)
}
// 删除我们创建的资源
err = os.Remove(tempFile.Name())
if err != nil {
log.Fatal(err)
}
err = os.Remove(tempDirPath)
if err != nil {
log.Fatal(err)
}
}

通过HTTP下载文件


package main
import (
"os"
"io"
"log"
"net/http"
)
func main() {
newFile, err := os.Create("devdungeon.html")
if err != nil {
log.Fatal(err)
}
defer newFile.Close()
url := "http://www.devdungeon.com/archive"
response, err := http.Get(url)
defer response.Body.Close()
// 将HTTP response Body中的内容写入到文件
// Body满足reader接口,因此我们可以使用ioutil.Copy
numBytesWritten, err := io.Copy(newFile, response.Body)
if err != nil {
log.Fatal(err)
}
log.Printf("Downloaded %d byte file.\n", numBytesWritten)
}

哈希和摘要


package main
import (
"crypto/md5"
"crypto/sha1"
"crypto/sha256"
"crypto/sha512"
"log"
"fmt"
"io/ioutil"
)
func main() {
// 得到文件内容
data, err := ioutil.ReadFile("test.txt")
if err != nil {
log.Fatal(err)
}
// 计算Hash
fmt.Printf("Md5: %x\n\n", md5.Sum(data))
fmt.Printf("Sha1: %x\n\n", sha1.Sum(data))
fmt.Printf("Sha256: %x\n\n", sha256.Sum256(data))
fmt.Printf("Sha512: %x\n\n", sha512.Sum512(data))
}

上面的例子复制整个文件内容到内存中,传递给hash函数。
另一个方式是创建一个hash writer, 使用Write、WriteString、Copy将数据传给它。
下面的例子使用 md5 hash,但你可以使用其它的Writer。


```go
package main
import (
"crypto/md5"
"log"
"fmt"
"io"
"os"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
//创建一个新的hasher,满足writer接口
hasher := md5.New()
_, err = io.Copy(hasher, file)
if err != nil {
log.Fatal(err)
}
// 计算hash并打印结果。
// 传递 nil 作为参数,因为我们不通参数传递数据,而是通过writer接口。
sum := hasher.Sum(nil)
fmt.Printf("Md5 checksum: %x\n", sum)
}

10.13 每日早报

文章分享astaxie 发表了文章 • 0 个评论 • 210 次浏览 • 2016-10-13 08:16 • 来自相关话题

10.13 每日早报

新闻:

1.IMAX将于2016年底前在欧洲开设首个虚拟现实体验中心

2.饿了么、阿里旅行和51社保等企业接入阿里钉钉平台

3.网易有道与考神团队成立教育合资公司,将投入5亿元... 查看全部

10.13 每日早报


新闻:


1.IMAX将于2016年底前在欧洲开设首个虚拟现实体验中心


2.饿了么、阿里旅行和51社保等企业接入阿里钉钉平台


3.网易有道与考神团队成立教育合资公司,将投入5亿元孵化教育工作室


4.百度成立百度资本,投资泛互联网领域中后期项目,一期基金200亿


5.英特尔推出自主品牌工业无人机Falcon 8+,聚焦工业场合应用


6.亚马逊计划开设便利店和路边取货点,用户可在路边区域提取商品


7.阿里游戏、金立游戏等多家手游平台提醒开发者提供总局出版批文


8.德国航空航天中心完成高清版3D世界地图,可免费用于科研项目


资源:


2016年中国视频网站付费用户典型案例研究报告
http://report.iresearch.cn/report/201610/2653.shtml


中国的移动互联网Top 2000 APP秋季盘点
http://www.questmobile.com.cn/blog/blog_61.html


注:上述内容来源于互联网,由EGO整理

Linux进程的exit 返回码有哪些?

有问必答astaxie 回复了问题 • 3 人关注 • 2 个回复 • 428 次浏览 • 2016-10-13 08:10 • 来自相关话题

cgo有没有好的方法可以断点调试c代码

有问必答astaxie 回复了问题 • 3 人关注 • 2 个回复 • 337 次浏览 • 2016-10-13 07:09 • 来自相关话题

golang变量作用域

有问必答icoder 回复了问题 • 5 人关注 • 2 个回复 • 486 次浏览 • 2016-10-12 22:10 • 来自相关话题

map在循环中被删除或者修改会怎么样

有问必答opsnull 回复了问题 • 6 人关注 • 5 个回复 • 562 次浏览 • 2016-10-12 18:21 • 来自相关话题

如何构建一个高效的 golang web 开发环境

有问必答davidcai1993 回复了问题 • 10 人关注 • 5 个回复 • 688 次浏览 • 2016-10-12 17:27 • 来自相关话题

OPMS项目管理+OA系统

Go开源项目lock 发表了文章 • 1 个评论 • 295 次浏览 • 2016-10-12 16:16 • 来自相关话题

OPMS管理系统是意思是PMS+OA,项目+办公管理。符合日常项目和OA管理,特别适合扁平化管理的微中小企业。

OPMS采用是Beego框架和Bootstrap前端框架构建立,适合不同平台,不同的终端,简单方便实用的原则。数据库采用Mysq... 查看全部

OPMS管理系统是意思是PMS+OA,项目+办公管理。符合日常项目和OA管理,特别适合扁平化管理的微中小企业。


OPMS采用是Beego框架和Bootstrap前端框架构建立,适合不同平台,不同的终端,简单方便实用的原则。数据库采用Mysql,缓存采用Redis。在部署过程中,如果没有Redis,不影响使用。


本系统是免费开源的软件,部署很方便。


OPMS的由来:


公司之前用的项目管理软件是禅道PMS,功能是很强大,学习成本也大。


在实际的项目应用中,有许多功能点都用不到或者很少用,可能它的系统是面向不同行业项目管理吧。


结合实际的项目要求和人事的日常工作经验要求,于是OPMS管理系统诞生了!


OPMS官网:


http://opms.milu365.cn/


手册文档:


http://opms.docs.milu365.cn/


在线体验:


http://opms.demo.milu365.cn/


默认用户名:libai


默认密码:123456


开源地址:


https://github.com/lock-upme/OPMS


http://git.oschina.net/lock-upme/opms

Python 程序员的 Golang 学习指南(II): 开发环境搭建

文章分享Cloudinsight 发表了文章 • 0 个评论 • 910 次浏览 • 2016-10-12 15:44 • 来自相关话题

Authors: startover

Authors: startover





上一篇文章我们已经对 Golang 有了初步的了解,这篇主要介绍如何在 Ubuntu 14.04 上搭建 Golang 开发环境。


安装 Golang


这里就按照官方文档进行安装即可,如下:



  • 下载并解压安装包到指定目录


$ wget https://storage.googleapis.com ... ar.gz
$ tar -C /usr/local -xzf go1.6.3.linux-amd64.tar.gz


  • 设置 PATH


$ echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.bashrc
$ source ~/.bashrc


  • 验证安装


$ go version
go version go1.6.3 linux/amd64

环境变量设置


$ echo "export GOROOT=/usr/local/go" >> ~/.bashrc
$ echo "export GOPATH=$HOME/go" >> ~/.bashrc
$ source ~/.bashrc

其中,GOROOT 为 Golang 的安装目录,只有当 Golang 安装到除 /usr/local 之外的路径时需要设置,反之则不用设置,GOPATH 是 Golang 的开发目录,详细可参考官方文档


开发工具


工欲善其事,必先利其器,作为一名伪 VIMer,这里主要介绍下如何在 Vim 下配置 Golang 开发环境。


由于之前一直使用 k-vim 作为 Python 开发环境,而 k-vim 已经集成了当前使用最为广泛的用于搭建 Golang 开发环境的 vim 插件 vim-go,只是默认没有开启,需要我们手动进行相关设置。


k-vim 中开启 Golang 语言的支持,非常简单,如下:



  • 修改 ~/.vimrc.bundles(开启 golang 支持,并修改 vim-go 的默认配置,增加快捷键配置等)。


let g:bundle_groups=['python', 'javascript', 'markdown', 'html', 'css', 'tmux', 'beta', 'json', 'golang']

" vimgo {{{
let g:go_highlight_functions = 1
let g:go_highlight_methods = 1
let g:go_highlight_structs = 1
let g:go_highlight_operators = 1
let g:go_highlight_build_constraints = 1

let g:go_fmt_fail_silently = 1
let g:go_fmt_command = "goimports"
let g:syntastic_go_checkers = ['golint', 'govet', 'errcheck']

" vim-go custom mappings
au FileType go nmap <Leader>s <Plug>(go-implements)
au FileType go nmap <Leader>i <Plug>(go-info)
au FileType go nmap <Leader>gd <Plug>(go-doc)
au FileType go nmap <Leader>gv <Plug>(go-doc-vertical)
au FileType go nmap <leader>r <Plug>(go-run)
au FileType go nmap <leader>b <Plug>(go-build)
au FileType go nmap <leader>t <Plug>(go-test)
au FileType go nmap <leader>c <Plug>(go-coverage)
au FileType go nmap <Leader>ds <Plug>(go-def-split)
au FileType go nmap <Leader>dv <Plug>(go-def-vertical)
au FileType go nmap <Leader>dt <Plug>(go-def-tab)
au FileType go nmap <Leader>e <Plug>(go-rename)
au FileType go nnoremap <leader>gr :GoRun %<CR>
" }}}



  • 在 Vim 内执行 :PlugInstall,安装 vim-go




  • 在 Vim 内执行 :GoInstallBinaries,下载并安装 vim-go 依赖的二进制工具,goimportsgolint 等。



  • 安装 gotags,使 tagbar 配置生效。


$ go get -u github.com/jstemmer/gotags

我们来看一下最终效果:


Image of Golang Environment in Vim


编写第一个程序


进入工作目录,新建文件 hello.go,如下:


$ cd $GOPATH
$ vim hello.go
package main

import "fmt"

func main() {
fmt.Println("Hello, World!")
}

运行程序:


$ go run hello.go
Hello, World!



本文章为 Cloudinsight 技术团队工程师原创,更多技术文章可访问 Cloudinsight 技术博客Cloudinsight 为可视化系统监控工具,涵盖 Windows、Linux 操作系统,用 Golang 开发的 Cloudinsight Agent 正式开源了,欢迎 fork,Github:https://github.com/cloudinsight/cloudinsight-agent


golang-for-pythonistas 系列持续更新中,欢迎关注~

怎么学习golang?

技术讨论Cloudinsight 回复了问题 • 12 人关注 • 8 个回复 • 1095 次浏览 • 2016-10-12 15:35 • 来自相关话题

Python 程序员的 Golang 学习指南(I): Go 之初体验

文章分享Cloudinsight 发表了文章 • 2 个评论 • 832 次浏览 • 2016-10-12 15:27 • 来自相关话题

Authors: startover

Authors: startover





Go 语言简介


Go,又称 golang,是 Google 开发的一种静态强类型,编译型,并发型,并具有垃圾回收功能的编程语言。


Go 语言于2009年11月正式宣布推出,自2012年发布1.0,最新稳定版1.7。目前,Go的相关工具和生态已逐渐趋于完善,也不乏重量级项目,如 Docker, Kubernetes, Etcd, InfluxDB 等。


Go 语言能解决什么样的问题


同绝大多数通用型编程语言相比,Go 语言更多的是为了解决我们在构建大型服务器软件过程中所遇到的软件工程方面的问题而设计的。乍看上去,这么讲可能会让人感觉 Go 非常无趣且工业化,但实际上,在设计过程中就着重于清晰和简洁,以及较高的可组合性,最后得到的反而会是一门使用起来效率高而且很有趣的编程语言,很多程序员都会发现,它有极强的表达力而且功能非常强大。


总结为以下几点:



  • 清晰的依赖关系

  • 清晰的语法

  • 清晰的语义

  • 偏向组合而不是继承

  • 提供简单的编程模型(垃圾回收、并发)

  • 强大的内置工具(gofmt、godoc、gofix等)


建议有兴趣的同学看看 Go在谷歌:以软件工程为目的的语言设计


Go 语言相对 Python 有哪些优势


这里引用一段知乎上某大牛的回答,如下:




  • 部署简单。Go 编译生成的是一个静态可执行文件,除了 glibc 外没有其他外部依赖。这让部署变得异常方便:目标机器上只需要一个基础的系统和必要的管理、监控工具,完全不需要操心应用所需的各种包、库的依赖关系,大大减轻了维护的负担。这和 Python 有着巨大的区别。由于历史的原因,Python 的部署工具生态相当混乱【比如 setuptools, distutils, pip, buildout 的不同适用场合以及兼容性问题】。官方 PyPI 源又经常出问题,需要搭建私有镜像,而维护这个镜像又要花费不少时间和精力。




  • 并发性好。Goroutine 和 channel 使得编写高并发的服务端软件变得相当容易,很多情况下完全不需要考虑锁机制以及由此带来的各种问题。单个 Go 应用也能有效的利用多个 CPU 核,并行执行的性能好。这和 Python 也是天壤之比。多线程和多进程的服务端程序编写起来并不简单,而且由于全局锁 GIL 的原因,多线程的 Python 程序并不能有效利用多核,只能用多进程的方式部署;如果用标准库里的 multiprocessing 包又会对监控和管理造成不少的挑战【我们用的 supervisor 管理进程,对 fork 支持不好】。部署 Python 应用的时候通常是每个 CPU 核部署一个应用,这会造成不少资源的浪费,比如假设某个 Python 应用启动后需要占用 100MB 内存,而服务器有 32 个 CPU 核,那么留一个核给系统、运行 31 个应用副本就要浪费 3GB 的内存资源。




  • 良好的语言设计。从学术的角度讲 Go 语言其实非常平庸,不支持许多高级的语言特性;但从工程的角度讲,Go 的设计是非常优秀的:规范足够简单灵活,有其他语言基础的程序员都能迅速上手。更重要的是 Go 自带完善的工具链,大大提高了团队协作的一致性。比如 gofmt 自动排版 Go 代码,很大程度上杜绝了不同人写的代码排版风格不一致的问题。把编辑器配置成在编辑存档的时候自动运行 gofmt,这样在编写代码的时候可以随意摆放位置,存档的时候自动变成正确排版的代码。此外还有 gofix, govet 等非常有用的工具。



  • 执行性能好。虽然不如 C 和 Java,但通常比原生 Python 应用还是高一个数量级的,适合编写一些瓶颈业务。内存占用也非常省。


从个人对 Golang 的初步使用来说,体验还是相当不错的,但是也有下面几点需要注意:




  • 驼峰式命名风格(依据首字母大小写来决定其是否能被其他包引用),但我更喜欢 Python 的小写字母加下划线命名风格。




  • 没有好用的包管理器,Golang 官方也没有推荐最佳的包管理方案,目前公认的比较好用的有 Godeps, Govendor 及 Glide,而 Python 的包管理器 pip 已形成自己的一套标准。




  • 多行字符串的变量声明需要用反引号(`),Python 里是三个双引号("""),参考http://stackoverflow.com/questions/7933460/how-do-you-write-multiline-strings-in-go




  • Golang 中的类型匹配是很严格的,不同的类型之间通常需要手动转换,所以在字符串拼接时往往需要对整型进行显式转换,如 fmt.Println("num: " + strconv.Itoa(1))



  • Golang 语言语法里的语法糖并不多,如在 Python 中很流行的 map, reduce, range 等,在 Golang 里都没有得到支持。


另外,推荐阅读 Golang 新手开发者要注意的陷阱和常见错误


学习资料推荐


建议先把 Go 的官方文档过一遍,主要有以下几项:



官方文档看完后,基本也算入门了,这时候可以看看 Go 的示例代码,或者去 Project Euler 刷刷题。


当然也可以去知乎看看大牛们都是如何学习的,链接 https://www.zhihu.com/question/23486344


总结


虽然 Go 有很多被诟病的地方,比如 GC 和对错误的处理方式,但没有任何语言是完美的,从实用角度来讲,Go 有着不输于 Python 的开发效率,完善的第三方工具,以及强大的社区支持,这些就足够了。


相关链接:

https://golang.org/doc/

https://talks.golang.org/2012/splash.article

https://www.zhihu.com/question/21409296

https://www.zhihu.com/question/23486344

http://stackoverflow.com/questions/7933460/how-do-you-write-multiline-strings-in-go

http://devs.cloudimmunity.com/gotchas-and-common-mistakes-in-go-golang/

http://www.oschina.net/translate/go-at-google-language-design-in-the-service-of-software-engineering




本文章为 Cloudinsight 技术团队工程师原创,更多技术文章可访问 Cloudinsight 技术博客Cloudinsight 为可视化系统监控工具,涵盖 Windows、Linux 操作系统,用 Golang 开发的 Cloudinsight Agent 正式开源了,欢迎 fork,Github:https://github.com/cloudinsight/cloudinsight-agent


golang-for-pythonistas 系列持续更新中,欢迎关注~

老肖有话说:如期而至的Swarm新工具Crane开源解读

Go开源项目数人云 发表了文章 • 0 个评论 • 192 次浏览 • 2016-10-12 14:27 • 来自相关话题

中秋节前,数人云技术团队推出了一款新的基于SwarmKit技术栈的工具。大家可能都了解到数人云的容器技术栈是用Mesos驱动的,为什么在... 查看全部


中秋节前,数人云技术团队推出了一款新的基于SwarmKit技术栈的工具。大家可能都了解到数人云的容器技术栈是用Mesos驱动的,为什么在Docker刚发布最新的1.12版之后,我们要做出这个工具呢?在这里分享下我们的心路历程。


稳定可靠,还是简单易用?


时至今日,Docker技术在国内容器圈已成为实质性的应用分发标准,国内的容器公司都在以Docker作为自己的技术栈,围绕该技术进行突围。Docker Swarm技术是容器集群软件,在它发布之前,已经有Kubernetes、Mesos这两套优秀的容器编排工具,Swarm的出现让社区感到困惑,大家看不清楚Docker的方向。Docker公司当然并没有止步不前,后续又推出了SwarmKit套件,把Swarm的精华注入到Docker这个单一的二进制文件中,让开发者可以非常方便地获取原有的集群能力。


这种颠覆是非常挑战原则的——我们到底需要的是稳定可靠的基础设施,还是简单易用的基础设施?这种疑惑在容器圈炸开了锅。Docker秉承了Unix原则把每一块都做的很小巧、简单,但它又颠覆性地把模块都绑定在一起。大家知道,一个系统级程序应该是一个程序只做一件事,做到松耦合是前人的经验结晶,没有人愿意打破这个规矩。然而,Docker却在打破它,这种创新付出的代价就是Docker的架构越来越让人担心,担心它无法在生产级别中使用。在我看来,Docker技术引发的思想碰撞非常值得尊敬和学习。


最近,以红帽为代表的公司开始提供Forked版本的Docker,从社区运营的角度来看,社区的分化在一定程度上对Docker发展是有害的。因为Docker这个软件目前是由Docker公司掌握的,OCI标准实质上并没有起到开源标准的作用。这个现状把Docker公司推到了风口浪尖。从技术角度来看,激烈的竞争让Docker出现多个Forked版本,直接推动了技术的进步,亦不失为一件好事。


中国有一句成语:合久必分,分久必合,放在这个场景下描述Docker的现状是最合适不过的。从社区运营的角度来说,Docker本身的项目在Github上有3万Star,1万Forked。这种热度的开源项目已经屈指可数,我没有细查排名,但足以说明Docker是一个由全球开发者共同创造的工具。由于商业利益,无形中把开发者的贡献割裂开来,这是任何一个社区的开发者都不愿意看到的局面。所以,不管是追随Docker技术,还是打击Docker技术都会让人纠结。我本人的观点是,结合前人的经验,不管黑猫白描,只要能抓到老鼠就是好猫。


对于数人云来说,深入Docker技术本身,为企业提供有力的工具是我们高效产出的最好体现,很多技术争论的对错本身没有错,只是太耗费人的精力,最终容器技术的方向,还是让我们拭目以待看Docker公司如何应对。


更多技术栈的包容


数人云技术团队为了帮助广大技术爱好者对Docker新版本有快速直观的感受,制作了一款基于最新SwarmKit特性的容器管理工具Crane,具备一定容器开发经验的开发者可以通过它在第一时间体验Docker的新特性。数人云Crane在开发者和数人云之间建立了一条新的纽带,将集结越来越多的技术爱好者把Docker技术的推动落实到实现上。为了让企业用户了解更多Crane的原理,我们还在Github上把代码开放出来,让更多的开发者参与进来,一起推进真正的容器技术的发展。


数人云在继续专注Mesos技术栈的同时,包容更多的容器技术。数人云现有两版产品——数人云操作系统和容器管理面板Crane。数人云操作系统针对企业客户,帮助传统企业实现IT业务转型,更好地应对业务变化。而数人云容器管理面板Crane针对开发者,强调简单易用。我们认为,容器创业公司的目的就是帮助客户试错,并提供更方便的容器产品以及解决方案,这就是数人云的价值。


数人云Crane是一个极其简化的管理控制面板,它结合了国外最先进的容器技术和数人云对容器技术的认知和实践,数人云选择将它开源也是为了帮助更多的用户理解容器的好处和限制。开源的好处是用户可以参与进来一起讨论场景,帮助大家一起成长。


数人云Crane的发布是数人云迎来全容器新阶段的信号,数人云是一个容器技术驱动的公司,我们用容器技术驱动业务,未来我们会制作更多的新产品来满足不同层面的用户。


可以说,数人云Crane是在Docker技术能否持续下去的争论中发布的工具。国内容器圈对于Docker技术也是存在各种质疑和争论。但技术就是技术,毋庸争辩,Docker技术确实是一项新技术,值得我们应用起来推动自己业务的发展。所以,我推荐大家试用数人云Crane,体验一下新技术带来的改变。当然,数人云将一如既往的追求商业技术的稳定和发展,如何把Docker技术更好的结合起来,仍然是我们需要认真对待的课题。大家看看Mesos社区,就会发现Mesos技术本身也在发生巨变,原来基于HTTP socket的API,在汲取Restful的经验之后,于1.0版本全面转向了Restful JSON API。最近该社区又引入了UnifiedContainer(MESOS-2840)、Pod(MESOS-2449)等概念。很多人认为,这不是在和Docker唱反调么?其实,这就是容器技术的演进。新技术的演进在内部发展之快,正好说明容器技术的趋势是受到业界关注的。对于数人云来说,我们更关注的是产品的技术特性和使用体验,对于技术内部的演变,我们的态度是拥抱变化,为更多的应用可能提供基础。


数人云容器管理面板Crane是一个面向最终用户的工具,代表着数人云技术团队一种技术驱动的态度。我们深刻理解业界容器圈的担忧和争论,数人云期望通过务实的产出来表达一种观点,那就是数人云是一家以开源技术驱动的容器公司。期望更多的同道中人能加入我们,一起参与到容器技术的变革大潮中。

golang url解析问题

有问必答myml 回复了问题 • 5 人关注 • 2 个回复 • 379 次浏览 • 2016-10-12 14:24 • 来自相关话题