背景

想把自己的一个SpringBoot应用打包成可执行文件。看看Golang是如何做到的。

Go 的 go:embed 功能介绍与打包 JAR 文件示例

1. go:embed

复制代码

是 Go 1.16 引入的一个强大功能，它允许在编译时将外部文件或目录嵌入到 Go 程序中。下面介绍如何使用

1. go:embed

复制代码

来嵌入 JAR 文件。

1. go:embed 基础介绍

基本特性

• 编译时嵌入文件内容
  
• 支持嵌入单个文件、多个文件或整个目录
  
• 支持三种嵌入类型：
  
  
  
  • 1. string

    复制代码
    - 用于文本文件
    
  • 1. []byte

    复制代码
    - 用于二进制文件
    
  • 1. embed.FS

    复制代码
    - 用于文件系统（支持多个文件/目录）
    
  
  

基本语法

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

复制代码

2. 嵌入 JAR 文件示例

假设你有一个需要嵌入的

1. app.jar

复制代码

文件，以下是完整示例：
项目结构

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

复制代码

代码实现

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

复制代码

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

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

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

复制代码

4. 使用注意事项

路径规则：

• 1. go:embed

  复制代码
  路径是相对于包含该指令的Go源文件的
  
• 不能包含
  1. .

  复制代码
  或
  1. ..

  复制代码
  等路径组件
  
• 不能匹配到父目录中的文件
  

文件大小限制：

• Go 1.16+ 对嵌入文件大小没有硬性限制
  
• 但非常大的文件可能会增加编译时间和二进制大小
  

构建约束：

• 嵌入的文件必须在构建时可用
  
• 如果文件不存在，构建会失败
  

安全考虑：

• 提取嵌入文件时要注意目标路径的权限
  
• 考虑使用临时目录并在程序退出时清理
  

5. 实际应用场景

• 打包Java应用：将依赖的JAR文件嵌入Go程序，然后通过
  1. exec.Command

  复制代码
  调用Java运行
  
• 嵌入式数据库：如SQLite数据库文件
  
• Web服务器资源：HTML/CSS/JS等前端资源
  
• 配置文件：默认配置模板
  

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

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

复制代码

通过这种方式，你可以将Java应用程序打包到Go二进制文件中，然后通过Go程序来分发和启动它。
到此这篇关于使用Golang打包jar应用的文章就介绍到这了,更多相关Golang打包jar应用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！