利用Golang打包jar应用

背景

想把本身的一个SpringBoot应用打包成可实验文件。看看Golang是如何做到的。
Go 的 go:embed 功能介绍与打包 JAR 文件示例

go:embed 是 Go 1.16 引入的一个强大功能，它允许在编译时将外部文件或目录嵌入到 Go 程序中。下面介绍如何利用 go:embed 来嵌入 JAR 文件。
1. go:embed 底子介绍

基本特性

• 编译时嵌入文件内容
  
• 支持嵌入单个文件、多个文件或整个目录
  
• 支持三种嵌入类型：
  
  
  
  • string - 用于文本文件
    
  • []byte - 用于二进制文件
    
  • embed.FS - 用于文件系统（支持多个文件/目录）
    
  
  

基本语法

1. import "embed"
3. //go:embed filename.txt
4. var fileContent string
6. //go:embed image.png
7. var imageData []byte
9. //go:embed templates/*
10. var templatesFS embed.FS

复制代码

2. 嵌入 JAR 文件示例

假设你有一个需要嵌入的 app.jar 文件，以下是完整示例：
项目结构

1. project/
2. ├── embedded/
3. │   └── app.jar    # 要嵌入的JAR文件
4. ├── main.go
5. └── go.mod

复制代码

代码实现

1. package main
3. import (
4.         "embed"
5.         "io"
6.         "log"
7.         "os"
8.         "path/filepath"
9. )
11. //go:embed embedded/app.jar
12. var jarFile []byte
14. func main() {
15.         // 指定输出路径（可以是临时目录或特定位置）
16.         outputPath := filepath.Join(os.TempDir(), "app.jar")
17.        
18.         // 将嵌入的JAR写入文件系统
19.         err := os.WriteFile(outputPath, jarFile, 0755)
20.         if err != nil {
21.                 log.Fatalf("Failed to write JAR file: %v", err)
22.         }
23.        
24.         log.Printf("JAR file extracted to: %s", outputPath)
25.        
26.         // 现在你可以使用这个JAR文件，比如通过exec.Command运行它
27.         // exec.Command("java", "-jar", outputPath)
28. }

复制代码

3. 高级用法：嵌入多个文件或目录

假如你有多个 JAR 文件需要嵌入：

1. //go:embed embedded/*.jar
2. var jarFiles embed.FS
4. func main() {
5.         // 列出所有嵌入的JAR文件
6.         entries, err := jarFiles.ReadDir("embedded")
7.         if err != nil {
8.                 log.Fatal(err)
9.         }
10.        
11.         // 提取所有JAR文件
12.         for _, entry := range entries {
13.                 if filepath.Ext(entry.Name()) == ".jar" {
14.                         data, err := jarFiles.ReadFile("embedded/" + entry.Name())
15.                         if err != nil {
16.                                 log.Printf("Failed to read %s: %v", entry.Name(), err)
17.                                 continue
18.                         }
19.                        
20.                         outputPath := filepath.Join(os.TempDir(), entry.Name())
21.                         err = os.WriteFile(outputPath, data, 0755)
22.                         if err != nil {
23.                                 log.Printf("Failed to write %s: %v", entry.Name(), err)
24.                                 continue
25.                         }
26.                        
27.                         log.Printf("Extracted %s to %s", entry.Name(), outputPath)
28.                 }
29.         }
30. }

复制代码

4. 利用注意事项

• 路径规则：
  
  
  
  • go:embed 路径是相对于包罗该指令的Go源文件的
    
  • 不能包罗 . 或 .. 等路径组件
    
  • 不能匹配到父目录中的文件
    
  
  
• 文件巨细限制：
  
  
  
  • Go 1.16+ 对嵌入文件巨细没有硬性限制
    
  • 但非常大的文件可能会增加编译时间和二进制巨细
    
  
  
• 构建约束：
  
  
  
  • 嵌入的文件必须在构建时可用
    
  • 假如文件不存在，构建会失败
    
  
  
• 安全考虑：
  
  
  
  • 提取嵌入文件时要注意目标路径的权限
    
  • 考虑利用暂时目录并在程序退出时清算
    
  
  

5. 现实应用场景

• 打包Java应用：将依靠的JAR文件嵌入Go程序，然后通过exec.Command调用Java运行
  
• 嵌入式数据库：如SQLite数据库文件
  
• Web服务器资源：HTML/CSS/JS等前端资源
  
• 配置文件：默认配置模板
  

6. 完整示例：运行嵌入的JAR

1. package main
3. import (
4.         "embed"
5.         "log"
6.         "os"
7.         "os/exec"
8.         "path/filepath"
9. )
11. //go:embed app.jar
12. var jarFile []byte
14. func main() {
15.         // 创建临时文件
16.         tmpFile, err := os.CreateTemp("", "embedded-*.jar")
17.         if err != nil {
18.                 log.Fatal(err)
19.         }
20.         defer os.Remove(tmpFile.Name()) // 程序退出时删除
21.        
22.         // 写入JAR内容
23.         if _, err := tmpFile.Write(jarFile); err != nil {
24.                 log.Fatal(err)
25.         }
26.         if err := tmpFile.Close(); err != nil {
27.                 log.Fatal(err)
28.         }
29.        
30.         // 执行Java命令
31.         cmd := exec.Command("java", "-jar", tmpFile.Name())
32.         cmd.Stdout = os.Stdout
33.         cmd.Stderr = os.Stderr
34.        
35.         log.Println("Starting Java application...")
36.         if err := cmd.Run(); err != nil {
37.                 log.Fatalf("Java application failed: %v", err)
38.         }
39. }

复制代码

通过这种方式，你可以将Java应用程序打包到Go二进制文件中，然后通过Go程序来分发和启动它。

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