:::tip{title="前言"}
Go编译的程序非常适合部署，如果没有通过CGO引用其它的库的话，我们一般编译出来的可执行二进制文件都是单个的文件，非常适合复制和部署。在实际使用中，除了二进制文件，可能还需要一些配置文件，或者静态文件，比如html模板、静态的图片、CSS、javascript等文件，如何这些文件也能打进到二进制文件中，那就太美妙，我们只需复制、按照单个的可执行文件即可。
:::


# Go embed 教程

一些开源的项目很久以前就开始做这方面的工作，比如gobuffalo/packr、markbates/pkger、rakyll/statik、knadh/stuffbin等等，但是不管怎么说这些都是第三方提供的功能，如果Go官方能内建支持就好了。2019末一个提案被提出issue#35950,期望Go官方编译器支持嵌入静态文件。后来Russ Cox专门写了一个设计文档Go command support for embedded static assets, 并最终实现了它。

Go 1.16中包含了go embed的功能，而且Go1.16基本在一个月左右的时间就会发布了，到时候你可以尝试使用它，如果你等不及了，你也可以下载Go 1.16beta1尝鲜。

本文将通过例子，详细介绍go embed的各个功能。

## 嵌入

- 对于单个的文件，支持嵌入为字符串和 byte slice
- 对于多个文件和文件夹，支持嵌入为新的文件系统FS
- 比如导入 "embed"包，即使无显式的使用
- `go:embed` 指令用来嵌入，必须紧跟着嵌入后的变量名
- 只支持嵌入为string, byte slice和embed.FS三种类型，这三种类型的别名(alias)和命名类型(如type S string)都不可以

### 1. 嵌入为字符串

比如当前文件下有个hello.txt的文件，文件内容为`hello,world!`。通过`go:embed`指令，在编译后下面程序中的s变量的值就变为了`hello,world!`。

```golang
package main
import (
	_ "embed"
	"fmt"
)
//go:embed hello.txt
var s string
func main() {
	fmt.Println(s)
}
```

### 2. 嵌入为byte slice

你还可以把单个文件的内容嵌入为slice of byte，也就是一个字节数组。

```golang
package main
import (
	_ "embed"
	"fmt"
)
//go:embed hello.txt
var b []byte
func main() {
	fmt.Println(b)
}
```

### 3. 嵌入为fs.FS

甚至你可以嵌入为一个文件系统，这在嵌入多个文件的时候非常有用。
比如嵌入一个文件：

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed hello.txt
var f embed.FS
func main() {
	data, _ := f.ReadFile("hello.txt")
	fmt.Println(string(data))
}
```

嵌入本地的另外一个文件hello2.txt, 支持同一个变量上多个`go:embed`指令(嵌入为string或者byte slice是不能有多个`go:embed`指令的):

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed hello.txt
//go:embed hello2.txt
var f embed.FS
func main() {
	data, _ := f.ReadFile("hello.txt")
	fmt.Println(string(data))
	data, _ = f.ReadFile("hello2.txt")
    fmt.Println(string(data))
}
```

当前重复的`go:embed`指令嵌入为`embed.FS`是支持的，相当于一个:

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed hello.txt
//go:embed hello.txt
var f embed.FS
func main() {
	data, _ := f.ReadFile("hello.txt")
	fmt.Println(string(data))
}
```

还可以嵌入子文件夹下的文件：

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed p/hello.txt
//go:embed p/hello2.txt
var f embed.FS
func main() {
	data, _ := f.ReadFile("p/hello.txt")
	fmt.Println(string(data))
	data, _ = f.ReadFile("p/hello2.txt")
	fmt.Println(string(data))
}
```
还可以支持模式匹配的方式嵌入，下面的章节专门介绍。

### 同一个文件嵌入为多个变量

比如下面的例子，s和s2变量都嵌入hello.txt的文件。

```golang
package main
import (
	_ "embed"
	"fmt"
)
//go:embed hello.txt
var s string
//go:embed hello.txt
var s2 string
func main() {
	fmt.Println(s)
	fmt.Println(s2)
}
```

### exported/unexported的变量都支持

Go可以将文件可以嵌入为exported的变量，也可以嵌入为unexported的变量。

```golang
package main
import (
	_ "embed"
	"fmt"
)
//go:embed hello.txt
var s string
//go:embed hello2.txt
var S string
func main() {
	fmt.Println(s)
	fmt.Println(S)
}
```

### package级别的变量和局部变量都支持

前面的例子都是package一级的的变量，即使是函数内的局部变量，也都支持嵌入：

```golang
package main
import (
	_ "embed"
	"fmt"
)
func main() {
	//go:embed hello.txt
	var s string
	//go:embed hello.txt
	var s2 string
	fmt.Println(s, s2)
}
```
局部变量s的值在编译时就已经嵌入了，而且虽然s和s2嵌入同一个文件，但是它们的值在编译的时候会使用初始化字段中的不同的值：

```
0x0021 00033 (/Users/....../main.go:10)        MOVQ    "".embed.1(SB), AX
0x0028 00040 (/Users/....../main.go:10)        MOVQ    "".embed.1+8(SB), CX
0x002f 00047 (/Users/....../main.go:13)        MOVQ    "".embed.2(SB), DX
0x0036 00054 (/Users/....../main.go:13)        MOVQ    DX, "".s2.ptr+72(SP)
0x003b 00059 (/Users/....../main.go:13)        MOVQ    "".embed.2+8(SB), BX
......
"".embed.1 SDATA size=16
       0x0000 00 00 00 00 00 00 00 00 0d 00 00 00 00 00 00 00  ................
       rel 0+8 t=1 go.string."hello, world!"+0
"".embed.2 SDATA size=16
       0x0000 00 00 00 00 00 00 00 00 0d 00 00 00 00 00 00 00  ................
       rel 0+8 t=1 go.string."hello, world!"+0
```

注意s和s2的变量的值是在编译期就确定了，即使在运行时你更改了hello.txt的文件，甚至把hello.txt都删除了也不会改变和影响s和s2的值。

## 只读

嵌入的内容是只读的。也就是在编译期嵌入文件的内容是什么，那么在运行时的内容也就是什么。

FS文件系统值提供了打开和读取的方法，并没有write的方法，也就是说FS实例是线程安全的，多个goroutine可以并发使用。

```golang
type FS
    func (f FS) Open(name string) (fs.File, error)
    func (f FS) ReadDir(name string) ([]fs.DirEntry, error)
    func (f FS) ReadFile(name string) ([]byte, error)
```

### `go:embed`指令

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed hello.txt hello2.txt
var f embed.FS
func main() {
	data, _ := f.ReadFile("hello.txt")
	fmt.Println(string(data))
	data, _ = f.ReadFile("hello2.txt")
	fmt.Println(string(data))
}
```

当然你也可以像前面的例子一样写成多行`go:embed`:

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed hello.txt
//go:embed hello2.txt
var f embed.FS
func main() {
	data, _ := f.ReadFile("hello.txt")
	fmt.Println(string(data))
	data, _ = f.ReadFile("hello2.txt")
	fmt.Println(string(data))
}
```

### 支持文件夹

文件夹分隔符采用正斜杠/,即使是windows系统也采用这个模式。

```goalng
package main
import (
	"embed"
	"fmt"
)
//go:embed p
var f embed.FS
func main() {
	data, _ := f.ReadFile("p/hello.txt")
	fmt.Println(string(data))
	data, _ = f.ReadFile("p/hello2.txt")
	fmt.Println(string(data))
}
```

### 使用的是相对路径

相对路径的根路径是go源文件所在的文件夹。

支持使用双引号"或者反引号的方式应用到嵌入的文件名或者文件夹名或者模式名上，这对名称中带空格或者特殊字符的文件文件夹有用。

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed "he llo.txt" `hello-2.txt`
var f embed.FS
func main() {
	data, _ := f.ReadFile("he llo.txt")
	fmt.Println(string(data))
}
```

### 匹配模式

`go:embed`指令中可以只写文件夹名，此文件夹中除了.和_开头的文件和文件夹都会被嵌入，并且子文件夹也会被递归的嵌入，形成一个此文件夹的文件系统。

如果想嵌入.和_开头的文件和文件夹， 比如p文件夹下的.hello.txt文件，那么就需要使用*，比如`go:embed p/*`。

`*`不具有递归性，所以子文件夹下的.和_不会被嵌入，除非你在专门使用子文件夹的*进行嵌入:

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed p/*
var f embed.FS
func main() {
	data, _ := f.ReadFile("p/.hello.txt")
	fmt.Println(string(data))
	data, _ = f.ReadFile("p/q/.hi.txt") // 没有嵌入 p/q/.hi.txt
	fmt.Println(string(data))
}
```

嵌入和嵌入模式不支持绝对路径、不支持路径中包含.和..,如果想嵌入go源文件所在的路径，使用*:

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed *
var f embed.FS
func main() {
	data, _ := f.ReadFile("hello.txt")
	fmt.Println(string(data))
	data, _ = f.ReadFile(".hello.txt")
	fmt.Println(string(data))
}
```

### 文件系统

embed.FS实现了 io/fs.FS接口，它可以打开一个文件，返回fs.File:

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed *
var f embed.FS
func main() {
	helloFile, _ := f.Open("hello.txt")
	stat, _ := helloFile.Stat()
	fmt.Println(stat.Name(), stat.Size())
}
```

它还提供了ReadFileh和ReadDir功能，遍历一个文件下的文件和文件夹信息：

```golang
package main
import (
	"embed"
	"fmt"
)
//go:embed *
var f embed.FS
func main() {
	dirEntries, _ := f.ReadDir("p")
	for _, de := range dirEntries {
		fmt.Println(de.Name(), de.IsDir())
	}
}
```

因为它实现了io/fs.FS接口，所以可以返回它的子文件夹作为新的文件系统：

```goalng
package main
import (
	"embed"
	"fmt"
	"io/fs"
	"io/ioutil"
)
//go:embed *
var f embed.FS
func main() {
	ps, _ := fs.Sub(f, "p")
	hi, _ := ps.Open("q/hi.txt")
	data, _ := ioutil.ReadAll(hi)
	fmt.Println(string(data))
}
```

## 应用

### net/http

先前，我们提供一个静态文件的服务时，使用：

```goalng
http.Handle("/", http.FileServer(http.Dir("/tmp")))
```

现在，io/fs.FS文件系统也可以转换成http.FileServer的参数了:

```golang
type FileSystem
    func FS(fsys fs.FS) FileSystem
type Handler
    func FileServer(root FileSystem) Handler
```

所以，嵌入文件可以使用下面的方式:

```golang
http.Handle("/", http.FileServer(http.FS(fsys)))
```

### text/template和html/template.

同样的,template也可以从嵌入的文件系统中解析模板：

```golang
func ParseFS(fsys fs.FS, patterns ...string) (*Template, error)
func (t *Template) ParseFS(fsys fs.FS, patterns ...string) (*Template, error)
```

Go embed 教程

:::tip{title="简介"}
在常用的系统设计中，我们经常需要对系统能力和性能进行估算，因此我们需要熟悉一些常见的性能指标结合，来得出一些估算值，这些值会使得我们对系统的设计有初步的一些认识。
:::



# 一、常用的封底估算

## 1. 2 的幂

在面对分布式系统的时候，尽管数据量可能会十分庞大，但归根结底还是数学运算，为了获得正确的运算结果，了解 2 的幂所代表的数据量单位是非常重要的。如 1 字节（byte）是 8 比特（bit），一个 ASCII 字符占用 1 字节的内存（8 bit），下表描述了常见的数据量的单位。

| 2 的幂   | 近似值            | 全称       | 缩写 |
|----------|-------------------|------------|------|
| $2^{10}$ | 1000              | 1 Kilobyte | 1KB  |
| $2^{20}$ | 1,000,000         | 1 Megabyte | 1MB  |
| $2^{30}$ | 1,000,000,000     | 1 Gigabyte | 1GB  |
| $2^{40}$ | 1,000,000,000,000 | 1 Terabyte | 1TB  |

## 2. 常见的操作耗时

| 操作名称                             | 耗时                |
|--------------------------------------|---------------------|
| 3Ghz CPU时钟周期                     | 0.3 ns              |
| 执行指令                             | 1ns                 |
| 查询 L1 缓存                         | 1ns                 |
| 查询 L2 缓存                         | 3ns                 |
| 分支预测错误                         | 5ns                 |
| L3缓存访问                           | 12 - 40 ns          |
| 互斥锁定/解锁                        | 17ns                |
| 查询内存                             | 70-100ns            |
| 用 Zippy 压缩 1KB 数据               | 10,000ns=10us       |
| 通过带宽为 1Gb/s的网络发送 2KB 数据  | 20,000ns=20us       |
| 从内存中顺序读取 1MB 数据            | 250,000ns=250us     |
| 数据在同一个数据中心往返一次         | 500,000=500us       |
| getPid系统调用                       | 40 ns               |
| fread/fwrite系统调用                 | 60 - 100 ns         |
| 主(内)存访问                         | 70 - 100 ns         |
| PCIe                                 | 400-900 ns          |
| 网卡                                 | 1 us                |
| 上下文切换                           | 1-3 us              |
| SSD随机读                            | 16 us               |
| 单机房内网络                         | 0.5 - 2 ms          |
| 同城双机房光纤50KM                   | 2 - 5 ms            |
| 机械磁盘                             | 2 - 10 ms           |
| 在硬盘中查找数据                     | 10,000,000ns=10ms   |
| 在网络中顺序读取 1MB 数据            | 10,000,000ns=10ms   |
| 在硬盘中顺序读取 1MB 数据            | 30,000,000ns=30ms   |
| 数据包从加尼福利亚和荷兰之间往返一次 | 150,000,000ns=150ms |
| 阿里云异地机房(北京-广东)            | 50 - 100 ms         |
| 4G                                   | 60 ms               |
| 3G                                   | 120 ms              |
| 卫星                                 | 800 ms              |
| 重启电脑                             | 90 s                |


注: 1 ns=$10^{-9}$s, 1 us=$10^{-6}$s=1000 ns, 1 ms=$10^{-3}$s=1000us=1,000,000ns

![image.png](/static/img/0e3f8fb49185f40fd3c99844d1b01b9c.image.webp)

通过分析上述数据，我们可以得出如下结论：

1. 内存的速度快，硬盘的速度相对较慢
2. 如果有可能，经量避免在硬盘中查找数据
3. 简单的压缩算法速度更快
4. 尽可能将数据压缩之后在通过网络传输
5. 数据中心常常位于不同地区，异地传输是需要时间




主流云厂商如腾讯云国内各机房延迟值

北京到上海：38ms

上海到广州：40ms

北京到广州：53ms

| 耗时     | 状态 | 感受               |
|----------|------|--------------------|
| 1~30ms   | 极好 | 几乎察觉不出有延迟 |
| 31~50ms  | 较好 | 没有明显延迟       |
| 51~100ms | 一般 | 有明显延迟         |
| >100ms   | 差   | 丢包 ，掉线        |

## 3. 可用性相关数字

高可用性是指一个系统长时间持续运转的能力。高可用性一般是用百分比来衡量的，100% 意味着服务没有不可用时间。大部分服务的可用性在 99% 到 100% 之间。

SLA（服务水平协议）是服务提供商普遍使用的一个术语。它是你（服务提供商）和你的客户之间的协议，正式规定了你提供的服务应该正常运行的时间。云服务提供商亚马逊、谷歌和微软把它们的SLA设定为99.9%或以上。正常运行时间通常是用小数点后“9”的个数来衡量的。“9”越多则代表可用性越高。下图列出了“9”的数量与系统预计不可用时长的关系。

![image.png](/static/img/fc39aae5f6c57e3121977c64df82c1f7.image.webp)

## 4. 案例

下面来个小小的案例来尝试估算下系统的相关指标: 估算微博的QPS和存储需求

假设:
- 微博有 3 亿月活用户
- 50%的用户每天都使用微博
- 用户平均每天发两条微博
- 10%的微博包含多媒体数据
- 数据要存储5年

以下为根据上面的假设而估算出来的一些数据:

1）估算QPS（每秒查询量）
- 每日活跃用户（DAU）=300，000，000×50%=150，000，000
- 微博 QPS=150，000，000×2÷24小时÷3600秒≈3500
- 峰值QPS=2×推文QPS≈7000
2）这里仅估算多媒体数据的存储量
- 平均推文大小。
    - weibo_id：64字节
    - 文本：140字节
    - 多媒体文件：1MB
- 多媒体数据存储量=150，000，000×2×10%×1MB=30TB/天
- 5年的多媒体数据存储量=30TB×365×5≈55PB

## 5. 总结

封底估算归根结底是考查过程的。解决问题的过程比获得结果更重要。面试官可能会测试你解决问题的技巧。这里提供几个小技巧。

1. 凑整和近似。在面试中很难进行复杂的数学计算。比如，“99，987÷9.1”的结果是多少？没有必要花费宝贵的面试时间去解决复杂的数学问题，不需要算得很精确。尽可能凑整和使用近似数。例如前面的除法问题就可以简化为“100，000÷10”。
2. 写下你的假设。写下所做的假设以便之后参考是个很好的主意。
3. 标明单位。当你写下“5”时，它是代表5KB还是5MB？你可能会把自己搞糊涂。写明单位，比如“5MB”，就可以消除歧义。
4. 面试中经常被问到的封底估算指标有：QPS、峰值QPS、存储大小、缓存大小、服务器的数量等。你可以在准备面试时练习这些指标的估算，熟能生巧。

非常感谢各位大佬能看到这里，**最后希望大家都能早点下班，享受生活。**
   
![image.png](/static/img/37721d91644e5ab2c7dc890280f1e89e.image.webp)

常用的封底估算

:::tip{title="简介"}
最近几年 `AI` 一直很火，但是在 `AI` 领域，最火的语言一直是 `Python`, 但是 `Spring` 官方的一则爆炸性消息引爆了整个 `Java` 生态圈。`SpringAI` 来了，大模型方面不在是 `Python` 的单一天下了😂。Spring 对于 LLM 大模型姗姗来迟，虽迟但到，好在它来了，以至于不少人已经开始上手体验了。
:::



# Sping AI 初体验

![image.png](/static/img/3898585c2698a666b7016102cd6f6894.image.webp)

这个 Dan Vega 很多人可能不清楚他，因为我们可能从未注意过 Spring 的作者贡献榜中的名单。这个 Dan Vega 就是 Spring 开发者倡导者中的一员，在 github 上有 2.3K 的关注量，但是国内熟悉他的人真不多。

## Sping AI
Spring 官方已经把 Spring AI 已经上架到 Spring Initializr 上，它提供了一种更简洁的方式和 AI 交互，减轻 Java 程序员接入 LLM 模型应用的学习成本，目前在 https://start.spring.io/ 上可以使用并构建。

![image.png](/static/img/726b75024e92fa89c34b6331ce63b5d6.image.webp)
Spring AI Initializr 是一个工具，它允许开发者快速创建和配置 Spring Boot 项目，以便与人工智能（AI）模型进行交互。这个工具的目的是简化 Java 开发者在业务中接入大型语言模型（LLM）的过程，降低学习成本。

Spring AI 提供了跨 AI 提供商的便携式 API，支持聊天、文本到图像和嵌入模型等功能。它还支持同步和流 API 选项，并允许配置参数以访问特定的模型。

一些支持的聊天模型包括 OpenAI、Azure OpenAI、Amazon Bedrock 等，而文本到图像模型则包括 OpenAI with DALL-E 和 StabilityAI 等。此外，Spring AI 还支持在本地无 GPU 情况下运行 AI 模型，例如通过 Ollama 支持的模型。

开发者可以通过 Spring AI Initializr 创建项目，选择所需的 AI 模型依赖，并在项目中引入相应的依赖。然后，他们可以配置项目以启动和测试 AI 模型，例如通过修改 application.yml 配置文件来设置 Ollama 模型的参数。

Spring AI 的目标是将 Spring 生态系统的设计原则应用于 AI 领域，并推广使用 POJO（Plain Old Java Object）作为 AI 领域应用程序的构建块。这使得开发者可以更容易地将 AI 集成到他们的 Java 应用程序中。

## Ollama
在 Spring Initializr 网站上，搜索 AI，就会出现很多与 AI 相关的集成方案。包括热门的 OpenAI 等。

稍微往下翻一翻，就会看到 Ollama 这个项目。

❝
Spring AI support for Ollama. It allows you to run various Large Language Models (LLMs) locally and generate text from them.

我稍微翻译一下，大致意思就是说，SpringAI 支持 Ollama，它允许我们在本地运行各种大型语言模型（LLM），并从中生成文本。

这个 Ollama 就是一个开源的软件框架，它被设计用于在 Docker 容器中部署和管理大型语言模型（LLM）。Ollama 的主要功能是简化在本地运行大型语言模型的过程，使得这一过程变得非常简单。Ollama 通过将模型权重、配置和数据捆绑到一个单一的包中，由 Modelfile 定义，优化了设置和配置细节，包括 GPU 使用。

Ollama 支持 GPU/CPU 混合模式运行，允许用户根据自己的硬件条件（如 GPU、显存、CPU 和内存）选择不同量化版本的大模型。它提供了一种方式，使得即使在没有高性能 GPU 的笔记本电脑上，也能够运行大型模型。

注意上面标记深色的这句话，Ollama 能够让我们在本地运行大语言模型 LLM，而无需高性能 GPU 支持（支持本地无 GPU 情况下运行 AI 模型）。春哥还是一如既往的🐮🍺，Spring AI 让 LLM 成为大家都能够体验大模型的能力的工具。

## 支持的功能模型

根据官方文档 https://docs.spring.io/spring-ai/reference/getting-started.html 得知，Spring AI 支持众多 Embeddings Models。

![image.png](/static/img/f757188fc848b08161e3d64cb97b3015.image.webp)

其他的还有语言模型，图像生成模型，向量数据库等等。

![image.png](/static/img/36adc10e1fbb5087f2448e9672ad7a56.image.webp)

## SpringBoot+Ollama实战

首先给出本机环境：

```
Apple M1 Pro 16G 
系统 Ventura 13.6.2
```
Java 版本
![image.png](/static/img/f2909980800a8c046ca64e84455b16ca.image.webp)

我们选择https://start.spring.io/进行快速开始。

依赖项我们选择 Ollama，我们选择 Maven 来构建项目。默认选择 Java 17。

[Ollama](https://ollama.com/library) 支持众多模型，比如：gemma、llama2、mistral、mixtral 等等。

![image.png](/static/img/e2f4701355aae67413b3e3967e382898.image.webp)

项目配置完成后，参考结构如下。

![image.png](/static/img/7a31b484ef67a21b4e52b0ea1ad181db.image.webp)

pom.xml 配置文件的主要内容如下所示。

```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.3</version>
        <relativePath/> 
    </parent>
    <groupId>org.example</groupId>
    <artifactId>SpringAi</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringAi</name>
    <description>SpringAi</description>
    <properties>
        <java.version>17</java.version>
        <spring-ai.version>0.8.0</spring-ai.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.2.0</version>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.ai</groupId>
                <artifactId>spring-ai-bom</artifactId>
                <version>${spring-ai.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

</project>

```

### 启动Ollama模型

Spring AI 不仅提供了与 OpenAI 进行API交互，同样支持与 Ollama 进行API交互。Ollama 是一个发布在GitHub上的项目，专为运行、创建和分享大型语言模型而设计，可以轻松地在本地启动和运行大型语言模型。

这里我们选择使用Docker环境安装Ollama
docker 版本如下：
```
➜  SpringAi git:(master) ✗ docker version 
Client:
 Cloud integration: v1.0.35+desktop.10
 Version:           25.0.3
 API version:       1.44
 Go version:        go1.21.6
 Git commit:        4debf41
 Built:             Tue Feb  6 21:13:26 2024
 OS/Arch:           darwin/arm64
 Context:           desktop-linux

Server: Docker Desktop 4.27.2 (137060)
 Engine:
  Version:          25.0.3
  API version:      1.44 (minimum version 1.24)
  Go version:       go1.21.6
  Git commit:       f417435
  Built:            Tue Feb  6 21:14:22 2024
  OS/Arch:          linux/arm64
  Experimental:     false
 containerd:
  Version:          1.6.28
  GitCommit:        ae07eda36dd25f8a1b98dfbf587313b99c0190bb
 runc:
  Version:          1.1.12
  GitCommit:        v1.1.12-0-g51d5e94
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0
```

1. 获取Docker镜像。

`docker pull ollama/ollama`

2. 在 Docker 容器内运行 Ollama。

`docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama`

3. 现在您可以在容器内运行像 gemma:2b 这样的模型。

`docker exec -it ollama ollama run gemma:2b`

![image.png](/static/img/06d0b73935f44ff1cce324f8841dcd40.image.webp)

哇，是不是看起来非常炫酷。

需要注意的是，首次运行会先下载模型文件（大概 3G 左右，由于众所周知的原因，下载会比较耗时，具体时长取决于大家的网络情况）。

下载完模型资源后会自动启动模型，如上，可以在控制台测试和模型交互。

建议大家睡觉前下载，运气好的话，第二天早上就可以使用了。

更多模型可以在[Ollama 库](https://ollama.com/library)中找到。

接下来我们可以在 `application.yml` 中配置 `Ollama` 地址和使用的模型。

```yml

spring:
  ai:
    ollama:
      ## 默认地址无需配置
      base-url: http://localhost:11434
      chat:
        # model: llama2
        model: gemma:2b
```

## 测试

这里可以先写一个 `Controller`

```java
package org.example.springai.controller;

import jakarta.annotation.Resource;
import org.example.springai.model.Question;
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.ollama.OllamaChatClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author codejump
 */
@RestController
public class AiController {

    @Resource
    OllamaChatClient chatClient;

    @PostMapping("/question")
    public String requestQuestion(@RequestBody Question question) {
        PromptTemplate promptTemplate = new PromptTemplate(question.getMessage());
        promptTemplate.add("question", question.getMessage());
        return chatClient.call(promptTemplate.render());
    }
}

```

启动项目

![image.png](/static/img/b93508c0494b626d2937436448cf2542.image.webp)


![image.png](/static/img/5607384308884275e44bf55a9fc5dd39.image.webp)

### 流式访问

需要构建异步函数来实现流式访问

```
package org.example.springai.controller;

import static org.junit.jupiter.api.Assertions.*;

import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import org.junit.jupiter.api.Test;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.ollama.OllamaChatClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class SpringAiApplicationTests {
    @Autowired
    private OllamaChatClient chatClient;


    @Test
    public void streamClient() throws ExecutionException, InterruptedException {
        // 构建一个异步函数，实现手动关闭测试函数
        CompletableFuture<Object> future = new CompletableFuture<>();
        String message = "年终总结";
        PromptTemplate promptTemplate = new PromptTemplate("你是一个Java开发工程师，你擅长八股文，根据：{message} 背诵相关八股文，不少于 100 字");
        Prompt prompt = promptTemplate.create(Map.of("message", message));
        chatClient.stream(prompt).subscribe(chatResponse -> {
            System.out.println("response: " + chatResponse.getResult().getOutput().getContent());
        }, throwable -> {
            System.out.println("err: " + throwable.getMessage());
        }, () -> {
            System.out.println("完成！");
            // 关闭函数
            future.complete(null);
        });
        future.get();
    }
}
```

执行结果：

![image.png](/static/img/41ded319b0529c95dca028ef34b89989.image.webp)

very nice 👍。

以上就是使用 SpringAI 框架和 Ollama框架来实现的 Spring 和常用大模型的结合，大家可以感觉学起来，可以整个自己的 AI 机器人了哈哈哈

Spring AI初体验

:::tip
本文分别从七个方面来深入理解高性能消息中间件-Kafka
:::



- 1. [`Kafka`介绍](http://43.135.30.3/post/Kafka01)
  - 1.1. [概述](http://43.135.30.3/post/Kafka%E4%BB%8B%E7%BB%8D#1.%20%E6%A6%82%E8%BF%B0)
  - 1.2. [消息系统介绍](http://43.135.30.3/post/Kafka01#1.%20%E6%A6%82%E8%BF%B0)
  - 1.3. [`Kafka`的优点](http://43.135.30.3/post/Kafka01#1.2%20%E6%B6%88%E6%81%AF%E7%B3%BB%E7%BB%9F%E4%BB%8B%E7%BB%8D)
  - 1.4. [`Kafka`中的术语解释](http://43.135.30.3/post/Kafka01#1.4%20Kafka%E4%B8%AD%E7%9A%84%E6%9C%AF%E8%AF%AD%E8%A7%A3%E9%87%8A) 
- 2. [`kafka`安装和启动](http://43.135.30.3/post/Kafka02)
  - 2.1. [下载代码](http://43.135.30.3/post/Kafka02#Step%201:%20%E4%B8%8B%E8%BD%BD%E4%BB%A3%E7%A0%81)
  - 2.2. [启动服务](http://43.135.30.3/post/Kafka02#Step%202:%20%E5%90%AF%E5%8A%A8%E6%9C%8D%E5%8A%A1)
  - 2.3. [创建主题](http://43.135.30.3/post/Kafka02#Step%203:%20%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA%E4%B8%BB%E9%A2%98(topic))
  - 2.4. [发送消息](http://43.135.30.3/post/Kafka02#Step%204:%20%E5%8F%91%E9%80%81%E6%B6%88%E6%81%AF)
  - 2.5. [消费消息](http://43.135.30.3/post/Kafka02#Step%205:%20%E6%B6%88%E8%B4%B9%E6%B6%88%E6%81%AF)
  - 2.6. [设置多个`broker`集群](http://43.135.30.3/post/Kafka02#Step%206:%20%E8%AE%BE%E7%BD%AE%E5%A4%9A%E4%B8%AAbroker%E9%9B%86%E7%BE%A4)
  - 2.7. [使用`Kafka Connect`来导入/导出数据](http://43.135.30.3/post/Kafka02#Step%207:%20%E4%BD%BF%E7%94%A8%20Kafka%20Connect%20%E6%9D%A5%20%E5%AF%BC%E5%85%A5/%E5%AF%BC%E5%87%BA%20%E6%95%B0%E6%8D%AE)
  - 2.7. [使用`Kafka Stream`来处理数据](http://43.135.30.3/post/Kafka02#Step%208:%20%E4%BD%BF%E7%94%A8Kafka%20Stream%E6%9D%A5%E5%A4%84%E7%90%86%E6%95%B0%E6%8D%AE)
- 3. [`Kafka`核心`API`与设计理念详解](http://43.135.30.3/post/Kafka03)
  - 3.1 [`Kafka`的架构](http://43.135.30.3/post/Kafka03#1.Kafka%E7%9A%84%E6%9E%B6%E6%9E%84)
  - 3.2 [`Topics`和`Partition`](http://43.135.30.3/post/Kafka03#2.Topics%E5%92%8CPartition)
  - 3.3 [`Producer`消息路由](http://43.135.30.3/post/Kafka03#3.Producer%E6%B6%88%E6%81%AF%E8%B7%AF%E7%94%B1)
  - 3.4 [`Consumer Group`](http://43.135.30.3/post/Kafka03#4.Consumer%20Group)
  - 3.5 [`Push vs. Pull`](http://43.135.30.3/post/Kafka03#5.Push%20vs.%20Pull)
  - 3.6 [`Kafka delivery guarantee`](http://43.135.30.3/post/Kafka03#6.Kafka%20delivery%20guarantee)
- 4. [`Kafka`的高可用](http://43.135.30.3/post/Kafka04)
  - 4.1 [高可用的由来](http://43.135.30.3/post/Kafka04#1.%20%E9%AB%98%E5%8F%AF%E7%94%A8%E7%9A%84%E7%94%B1%E6%9D%A5)
  - 4.2 [`Kafka HA`的设计解析](http://43.135.30.3/post/Kafka04#2.%20Kafka%20HA%E7%9A%84%E8%AE%BE%E8%AE%A1%E8%A7%A3%E6%9E%90)
  - 4.3 [`Broker`保存消息](http://43.135.30.3/post/Kafka04#3.%20broker%E4%BF%9D%E5%AD%98%E6%B6%88%E6%81%AF)
- 5. [`Kafka`与其他常用`MQ`对比](http://43.135.30.3/post/Kafka05)
- 6. [`SpringBoot`整合`Kafka`](http://43.135.30.3/post/Kafka06)
  - 6.1 [引入依赖](http://43.135.30.3/post/Kafka06#1.%20%E5%9C%A8%E5%88%9B%E5%BB%BA%E5%A5%BD%E7%9A%84gradle%E5%B7%A5%E7%A8%8B%E4%B8%AD%E5%BC%95%E5%85%A5%E4%BE%9D%E8%B5%96)
  - 6.2 [编写配置文件](http://43.135.30.3/post/Kafka06#2.%20%E7%BC%96%E5%86%99%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6)
  - 6.3 [`Kafka`通用工具类](http://43.135.30.3/post/Kafka06#3.%20%E7%BC%96%E5%86%99Kafka%E9%80%9A%E7%94%A8%E5%B7%A5%E5%85%B7%E7%B1%BB)
  - 6.4 [`Kafka producer`](http://43.135.30.3/post/Kafka06#4.%20%E7%BC%96%E5%86%99Kafka%20producer)
  - 6.5 [`Kafka consumer`](http://43.135.30.3/post/Kafka06#5.%20%E7%BC%96%E5%86%99Kafka%20consumer)
  - 6.6 [测试](http://43.135.30.3/post/Kafka06#6.%20%E6%B5%8B%E8%AF%95)
- 7. [扩展](http://43.135.30.3/post/Kafka07)
  - 7.1 [`Kafka`常用命令](http://43.135.30.3/post/Kafka07#1.%20Kafka%E5%B8%B8%E7%94%A8%E5%91%BD%E4%BB%A4)
  - 7.2 [`Kafka`管理工具](http://43.135.30.3/post/Kafka07#5.%20%E5%A4%9A%E4%B8%BB%E9%A2%98%E6%8C%87%E5%AE%9A%E5%88%86%E5%8C%BA%E6%8C%87%E5%AE%9A%E5%81%8F%E7%A7%BB%E9%87%8F%E8%AE%A2%E9%98%85)
  - 7.3 [`Spring Boot Kafka`参数配置](http://43.135.30.3/post/Kafka07#5.%20%E5%A4%9A%E4%B8%BB%E9%A2%98%E6%8C%87%E5%AE%9A%E5%88%86%E5%8C%BA%E6%8C%87%E5%AE%9A%E5%81%8F%E7%A7%BB%E9%87%8F%E8%AE%A2%E9%98%85)
  - 7.4 [一些使用规范](http://43.135.30.3/post/Kafka07#4.%20%E4%B8%80%E4%BA%9B%E4%BD%BF%E7%94%A8%E8%A7%84%E8%8C%83)
  - 7.5 [参考资料](http://43.135.30.3/post/Kafka07#5.%20%E5%8F%82%E8%80%83%E8%B5%84%E6%96%99)