Go发布自定义包

1、初始化go.mod

1. go mod init github.com/xumeng03/images

复制代码

2、编写包内容

   这里只是一个简单的压缩jpg/jpeg图片例子，代码参考 https://github.com/disintegration/imaging
  2.1、fs.go

1. package images
3. import (
4.         "image"
5.         "io"
6.         "os"
7.         "path"
8.         "strings"
9. )
11. type FileSystem interface {
12.         Create(string) (io.WriteCloser, error)
13.         Open(string) (io.ReadCloser, error)
14. }
16. type LocalFileSystem struct{}
18. func (fs LocalFileSystem) Create(name string) (io.WriteCloser, error) {
19.         return os.Create(name)
20. }
22. func (fs LocalFileSystem) Open(name string) (io.ReadCloser, error) {
23.         return os.Open(name)
24. }
26. var fs FileSystem = LocalFileSystem{}
28. func Open(filename string) (image.Image, error) {
29.         file, err := fs.Open(filename)
30.         if err != nil {
31.                 return nil, err
32.         }
33.         defer file.Close()
34.         return Decode(file)
35. }
37. func Close(img image.Image, filename string, quality int) error {
38.         file, err := fs.Create(filename)
39.         if err != nil {
40.                 return err
41.         }
42.         ext := path.Ext(filename)
43.         err = Encode(file, img, strings.ReplaceAll(ext, ".", ""), quality)
44.         if err != nil {
45.                 return err
46.         }
47.         err = file.Close()
48.         return err
49. }

复制代码

2.2、image.go

1. package images
3. import (
4.     "fmt"
5.     "image"
6.     "image/jpeg"
7.     _ "image/jpeg"
8.     _ "image/png"
9.     "io"
10. )
12. func Decode(reader io.Reader) (image.Image, error) {
13.     // 数据写入 PipeWriter 对象后，可以通过相应的 PipeReader 对象进行读取；
14.     pr, pw := io.Pipe()
15.     // 创建了一个新的 io.Reader 对象，这个对象能够将从其读取的数据同时写入到另一个 io.Writer 中（如同包装类）
16.     reader = io.TeeReader(reader, pw)
17.     done := make(chan struct{})
18.     var orient orientation
19.     go func() {
20.        defer close(done)
21.        orient = readOrientation(pr)
22.        io.Copy(io.Discard, pr)
23.     }()
24.     img, _, err := image.Decode(reader)
25.     pw.Close()
26.     <-done
27.     fmt.Println(orient)
28.     if err != nil {
29.        return nil, err
30.     }
31.     return img, nil
32. }
34. func Encode(w io.Writer, img image.Image, t string, quality int) error {
35.     switch t {
36.     case "jpg":
37.        fallthrough
38.     case "jpeg":
39.        if nrgba, ok := img.(*image.NRGBA); ok && nrgba.Opaque() {
40.           rgba := &image.RGBA{
41.              Pix:    nrgba.Pix,
42.              Stride: nrgba.Stride,
43.              Rect:   nrgba.Rect,
44.           }
45.           return jpeg.Encode(w, rgba, &jpeg.Options{Quality: quality})
46.        }
47.        return jpeg.Encode(w, img, &jpeg.Options{Quality: quality})
48.     default:
49.        println("type error!")
50.        return nil
51.     }
52. }

复制代码

2.3、exif.go

1. package images
3. import (
4.         "encoding/binary"
5.         "io"
6. )
8. type orientation int
10. const (
11.         // 方向未指定
12.         orientationUnspecified = 0
13.         // 正常方向
14.         orientationNormal = 1
15.         // 需水平翻转
16.         orientationFlipH = 2
17.         // 需旋转180度
18.         orientationRotate180 = 3
19.         // 需垂直翻转
20.         orientationFlipV = 4
21.         // 需对角线翻转（左上到右下）
22.         orientationTranspose = 5
23.         // 需逆时针旋转270度
24.         orientationRotate270 = 6
25.         // 需对角线翻转（右上到左下）
26.         orientationTransverse = 7
27.         // 需顺时针旋转90度
28.         orientationRotate90 = 8
29. )
31. const (
32.         // Start Of Image：表示 JPEG 图片流的起始
33.         markerSOI = 0xffd8
34.         // Application Segment 1：表示 APP1 区块，EXIF 信息通常存储在 APP1 区块内
35.         markerAPP1 = 0xffe1
36.         // Exif Header：表示 APP1 区块确实包含了 EXIF 信息（紧跟在 APP1 区块标识后），且后面通常跟着两个填充字节
37.         exifHeader = 0x45786966
38.         // Big Endian byte order mark：如果 EXIF 段使用大端字节序，那么其字节序标记为 'MM' (0x4D4D)，即（高位字节排在前）
39.         byteOrderBE = 0x4d4d
40.         // Little Endian byte order mark：如果 EXIF 段使用小端字节序，那么其字节序标记为 'II' (0x4949)，即（低位字节排在前）
41.         byteOrderLE = 0x4949
42.         // Orientation Tag：表示图像的方向
43.         orientationTag = 0x0112
44. )
46. func readOrientation(reader io.Reader) orientation {
47.         // 检查 JPEG 开始标记（PNG 和 GIF 等格式不是传统意义上的摄影，图像元数据一般不包括拍摄方向信息。处理这些图像文件时，通常没有必要读取或调整图像方向）
48.         var soi uint16
49.         if binary.Read(reader, binary.BigEndian, &soi) != nil {
50.                 return orientationUnspecified
51.         }
52.         if soi != markerSOI {
53.                 return orientationUnspecified
54.         }
56.         for {
57.                 var marker, size uint16
58.                 if err := binary.Read(reader, binary.BigEndian, &marker); err != nil {
59.                         return orientationUnspecified
60.                 }
61.                 if err := binary.Read(reader, binary.BigEndian, &size); err != nil {
62.                         return orientationUnspecified
63.                 }
64.                 // 检查是否是有效的 JPEG 标记
65.                 if marker>>8 != 0xff {
66.                         return orientationUnspecified
67.                 }
68.                 // 检查是否为 APP1 标记
69.                 if marker == markerAPP1 {
70.                         break
71.                 }
72.                 // 对于任何 JPEG 数据块，其报告的大小应至少为2字节
73.                 if size < 2 {
74.                         return orientationUnspecified
75.                 }
76.                 // 这里的减2表示减去size本身占用的2字节（size表示的是从size开始这个段还有几个字节）
77.                 if _, err := io.CopyN(io.Discard, reader, int64(size-2)); err != nil {
78.                         return orientationUnspecified
79.                 }
80.         }
82.         // 检查 exifHeader 标记
83.         var header uint32
84.         if err := binary.Read(reader, binary.BigEndian, &header); err != nil {
85.                 return orientationUnspecified
86.         }
87.         if header != exifHeader {
88.                 return orientationUnspecified
89.         }
90.         if _, err := io.CopyN(io.Discard, reader, 2); err != nil {
91.                 return orientationUnspecified
92.         }
94.         // 从文件中读取的字节序标识
95.         var byteOrderTag uint16
96.         var byteOrder binary.ByteOrder
97.         if err := binary.Read(reader, binary.BigEndian, &byteOrderTag); err != nil {
98.                 return orientationUnspecified
99.         }
100.         switch byteOrderTag {
101.         case byteOrderBE:
102.                 byteOrder = binary.BigEndian
103.         case byteOrderLE:
104.                 byteOrder = binary.LittleEndian
105.         default:
106.                 return orientationUnspecified
107.         }
108.         if _, err := io.CopyN(io.Discard, reader, 2); err != nil {
109.                 return orientationUnspecified
110.         }
112.         // 跳过 exif 段
113.         var offset uint32
114.         if err := binary.Read(reader, binary.BigEndian, &offset); err != nil {
115.                 return orientationUnspecified
116.         }
117.         if offset < 8 {
118.                 // 在 TIFF 格式中，如果 offset 小于 8（byteOrderTag、填充字节、offset字节），那么它指向的位置是不合逻辑的，表明可能是一个损坏或非法格式的文件。
119.                 return orientationUnspecified
120.         }
121.         if _, err := io.CopyN(io.Discard, reader, int64(offset-8)); err != nil {
122.                 return orientationUnspecified
123.         }
125.         // 获取标签数
126.         var numTags uint16
127.         if err := binary.Read(reader, byteOrder, &numTags); err != nil {
128.                 return orientationUnspecified
129.         }
131.         for i := 0; i < int(numTags); i++ {
132.                 var tag uint16
133.                 if err := binary.Read(reader, binary.BigEndian, &tag); err != nil {
134.                         return orientationUnspecified
135.                 }
136.                 if tag != orientationTag {
137.                         // 10 = 2（数据类型）+ 4（计数）+ 4（值或值偏移量）
138.                         if _, err := io.CopyN(io.Discard, reader, 10); err != nil {
139.                                 return orientationUnspecified
140.                         }
141.                         continue
142.                 }
144.                 // 跳过2字节（数据类型）+ 4字节（计数）
145.                 if _, err := io.CopyN(io.Discard, reader, 6); err != nil {
146.                         return orientationUnspecified
147.                 }
149.                 // 读取方向值（在 TIFF 中，实际的方向值可以直接存放在“值或值偏移量”的位置，并且仅占用前两字节，剩余的两字节则不会包含任何重要信息）
150.                 var direction uint16
151.                 if err := binary.Read(reader, binary.BigEndian, &direction); err != nil {
152.                         return orientationUnspecified
153.                 }
155.                 if direction < 1 || direction > 8 {
156.                         // EXIF 规范定义的图像方向值应该在 1 到 8 之间
157.                         return orientationUnspecified
158.                 }
159.                 return orientation(direction)
160.         }
161.         return orientationUnspecified
162. }

复制代码

3、测试

3.1、fs_test.go

1. package images
3. import (
4.         "fmt"
5.         "testing"
6. )
8. func TestOpen(t *testing.T) {
9.         fileName := "test.jpeg"
10.         _, err := Open(fileName)
11.         if err != nil {
12.                 fmt.Println(err)
13.                 return
14.         }
15.         fmt.Println(fileName, "读取成功")
16. }
18. func TestClose(t *testing.T) {
19.         fileName := "test.jpeg"
20.         quality := 50
21.         img, err := Open(fileName)
22.         if err != nil {
23.                 fmt.Println(err)
24.                 return
25.         }
26.         err = Close(img, "compress_"+fileName, quality)
27.         if err != nil {
28.                 fmt.Println(err)
29.                 return
30.         }
31.         fmt.Println(fileName, "保存成功")
32. }

复制代码

4、发布

创建一个新的tag：v0.0.1

5、使用

1. go get -u github.com/xumeng03/images

复制代码

1. package main
3. import (
4.         "fmt"
5.         "github.com/xumeng03/images"
6. )
8. func main() {
9.         fileName := "test.jpeg"
10.         quality := 50
11.         img, err := images.Open(fileName)
12.         if err != nil {
13.                 fmt.Println(err)
14.                 return
15.         }
16.         err = images.Close(img, "compress_"+fileName, quality)
17.         if err != nil {
18.                 fmt.Println(err)
19.                 return
20.         }
21.         fmt.Println(fileName, "压缩成功")
22. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。