vuex是一个专为vue.js应用程序开发的状态管理模式+库。它采用集中式存储管理应用的所有组件的状态，并以相应的规则保证状态以一种可预测的方式发生变化

简单来说，状态管理可以理解成为了更方便的管理组件之间的数据交互，提供了一个集中式的管理方案，任何塑胶都可以按照指定的方式进行读取和改变数据

使用

安装vuex：

npm install --save vuex

配置vuex文件：

import { createStore } from 'vuex'export default createStore({    //数据放在这里    state:{        count:0    }})

在主文件中引入vuex：

import store from './store/index'createApp(App).use(store).mount('#app')

在项目中使用：

<p>count = {{ $store.state.count }}</p>

快捷读取

使用vuex提供的mapState：

<script>import { mapState } from 'vuex';export default {  //专门读取vux的数据  computed:{    ...mapState(["count"])  }}</script>

页面中使用：

<p>{{ count }}</p>

Getter

对vuex中的数据进行过滤

定义getters：

import { createStore } from 'vuex'export default createStore({    //数据放在这里    state:{        count:0    },    getters:{        getCount(state){            return state.count > 0 ? state.count : "数据异常"        }    }})

使用getters：

<template>  <p>{{ $store.getters.getCount }}</p>  <p>{{ getCount }}</p></template><script>import { mapGetters } from 'vuex';export default {  //专门读取vux的数据  computed:{    ...mapGetters(["getCount"])  }}</script>

Mutation

更改vuex的store中的状态的唯一方法是提交mutation

定义Mutation：

import { createStore } from 'vuex'export default createStore({    state:{        count:0    },    mutations:{        //参数num可选，没有使用时不填即可        addCount(state,num){            state.count+=num        }    }})

使用Mutation：

<template>  <p>hello = {{ $store.state.count }}</p>  <button @click="add">增加</button></template><script>import { mapMutations } from 'vuex';export default {  methods:{    ...mapMutations(["addCount"]),    add(){      //基本写法      // this.$store.commit("addCount",10)      //便携写法      this.addCount(20)    }  }}</script>

Action

类似于mutation，不同在于：

• action提交的是mutation，而不是直接变更状态
• action可以包含任意异步操作

定义Action：

import { createStore } from 'vuex'export default createStore({    state:{        count:0    },    mutations:{        setCount(state,num){            state.count+=num        }    },    actions:{        asyncAddCount({commit}){            commit("setCount",11)        }    }})

使用Action：

<template>  <p>hello = {{ $store.state.count }}</p>  <button @click="asyncAdd">异步增加</button></template><script>import { mapActions } from 'vuex';export default {  methods:{    ...mapActions(["asyncAddCount"]),    asyncAdd(){      // this.$store.dispatch("asyncAddCount")      this.asyncAddCount()    }  }}</script>

VueRouter是vue官方路由，与vue.js核心深度集成，让vue.js构建单页应用变得轻而易举

使用

安装：

npm install --save vue-router

定义路由文件：

import { createRouter,createWebHashHistory } from "vue-router";import aView from "../views/a-view.vue"import bView from "../views/b-view.vue"//配置信息中需要页面的相关配置const routes = [    {        path:"/",//路径        component:aView//跳转页面    },{        path:"/haha",        component:bView    }]const router = createRouter({        //createWebHashHistory:访问路径有# 。原理a标签的描点链接    //createWebHistory:访问路径没有#,此种方式需要后台配合做重定向，否则会404。原理h5的pushState()    history:createWebHashHistory(),    routes})export default router

启动路由：

import { createApp } from 'vue'import App from './App.vue'import router from "./router/index"//使用use明确路由createApp(App).use(router).mount('#app')

展示路由页面

<template>  <!-- 路由显示路口 -->   <nav>    <RouterLink to="/">首页</RouterLink>    <RouterLink to="/haha">关于</RouterLink>   </nav>     <RouterView /></template>

传递参数

配置路由，并设置key：

const routes = [{        path:"/xixi",        //异步加载方式        component:()=> import("../views/c-view.vue")    },{        path:"/hehe/:name",//通过/:设置key        component:()=> import("../views/d-view.vue")    }]

to页面：

<template>    <ul>        <li><RouterLink to="/hehe/百度">百度新闻</RouterLink></li>        <li><RouterLink to="/hehe/网易">网易新闻</RouterLink></li>        <li><RouterLink to="/hehe/头条">头条新闻</RouterLink></li>    </ul></template>

from页面：

<template>    <h3>新闻详情</h3>    <p>{{ $route.params.name }}</p></template>

嵌套路由

配置二级路由：

const routes = [{        path:"/user",        component:()=> import("../views/e-view.vue"),        children:[            {                //二级导航的路径不要加/                path:"info",                component:()=> import("../views/f-view.vue")            }        ]    }]

在一级vue中添加：

<template>    <h3>用户列表</h3>    <RouterLink to="/user/info">用户详情</RouterLink>    <RouterView /></template>

如果需要设置一级路由的默认二级展示，可以使用redirect:完整二级路径的方式设置

swiper是一个第三方轮播图组件

官网地址：https://swiperjs.com/vue#swiper-props

安装

npm i swiper

安装后package.json文件的dependencies会显示swiper的版本信息

导入

<script>import { Swiper, SwiperSlide } from 'swiper/vue';import 'swiper/css';export default {    components:{        Swiper,        SwiperSlide    }}</script>

使用

    <Swiper>        <SwiperSlide>            <img src="../assets/a.png">        </SwiperSlide>        <SwiperSlide>            <img src="../assets/b.png">        </SwiperSlide>        <SwiperSlide>            <img src="../assets/c.png">        </SwiperSlide>    </Swiper>

添加分页

额外引入：

import { Pagination } from 'swiper/modules';import 'swiper/css/pagination';

在data中声明：

data(){        return{            modules:[Pagination]        }    }

swiper标签中添加：

<Swiper :modules="modules" :pagination="{ clickable: true }">    </Swiper>

安装

npm install --save axiosnpm install --save querystring

工具类

封装request.js文件方便后续使用

//引入import axios from "axios";import querystring from "querystring"//处理响应函数const errorHandle = (status,info) =>{    switch(status){        case 400:            console.log("语意错误")            break        case 500:            console.log("服务器意外")            break        default:            console.log(info)    }}//创建实例const instance = axios.create({    //公共配置    timeout:5000})//拦截器instance.interceptors.request.use(    config=>{        if(config.method === "post"){            config.data = querystring.stringify(config.data)        }        return config    },    error=>{        return Promise.reject(error)    })//获取数据前instance.interceptors.response.use(    response => {        return response.status === 200 ? Promise.resolve(response) : Promise.reject(response)    },    error=>{        const {response} = error        //错误处理        errorHandle(response.status,response.info)    })export default instance

使用

import axios from "../utils/request"const api = {    getUrl(){        return axios.get("请求路径")    }}export default api

页面渲染后调用：

<script>import api from "../api/index"export default {    mounted(){        console.log("渲染后")        api.getUrl().then(res =>{            console.log(res.data)        })    }}</script>

解决跨域

在vue.config.js文件中添加配置：

const { defineConfig } = require('@vue/cli-service')module.exports = defineConfig({  transpileDependencies: true,  //解决跨域 proxy方式  devServer:{    proxy:{      "/api":{        target:"//产生跨越的地址（域名）",        changeOrigin:true      }    }  }})

注意：修改此配置后需要重启服务

1. 建立连接
   1. 客户端通过tcp协议和redis服务器建立连接
   2. redis的io多路复用机制监听到新的连接事件
   3. 主事件循环会分配一个连接应答处理器来处理这个连接
   4. 处理器为这个连接创建一个client结构体，用于存储所有状态
2. 读取命令
   1. 客户端发送命令（resp格式）
   2. io多路复用监听到客户端的套接字可读（数据到达内核缓冲区）
   3. 事件循环触发命令请求处理器
   4. 处理器调用函数，将数据从内核套接字缓冲区读取到该客户端专属的输入缓冲区中
3. 解析命令
   1. redis尝试从缓冲区中按照resp的格式解析数据（以\r\n作为分隔符）
   2. 解析出来的参数被保存在client结构体的argv（参数数组）和argc（参数个数）字段中
4. 查找命令
   1. 取第一个参数argv[0]作为命令名
   2. 在命令表中查找该命令名（命令表是一个字典，在服务器启动时完成初始化，值是一个redisCommand结构体）
   3. redisCommand结构体包含了命令的所有元信息，其中的proc函数指针，指向了实际实现函数
5. 执行前检查
   1. 在调用函数前，redis会进行一系列检查。如果任何一项失败，都直接返回错误。如：参数个数、认证、内存、集群、数据类型（部分）的检查
6. 调用实现函数
   1. 根据之前找到的函数，和argv中的参数，调用函数
   2. 更新服务器的统计信息，如key命中次数，内存使用量等
7. 执行后操作
   1. 命令执行完毕后，还会执行一些后续操作，如：慢查询日志、aof持久化、主从复制等
8. 回复客户端
   1. 函数将执行结果写入客户端的输出缓冲区
   2. 事件循环会监听到客户端的套接字变得可写
   3. 事件循环调用命令回复处理器
   4. 处理器将输出缓冲区的内容通过网络发送回客户端
   5. 客户端收到回复并解析
9. 持久化（可选）
   • AOF：根据appendfsync策略，由后台线程将aof缓冲区的内容刷到磁盘
   • RDB：如果满足了配置的保存条件，主进程会fork子进程来创建rdb快照，不影响主进程

在Elasticsearch中，Segment（段）是Lucene的核心数据结构，它是索引不可变的、基础的数据块

每个Segment本质上是一个独立的、微型的倒排索引，它由多个文件组成。这些文件共享一个通用的前缀（即Segment名），并使用不同的扩展名来标识其包含的数据类型

组成

1. .si (Segment Info) - 段信息文件
   • 作用：这是Segment的“元数据文件”。它描述了该Segment的基本信息，例如：
     • 该Segment包含了多少文档。
     • 使用的Lucene版本。
     • 有关该Segment的诊断信息。
     • 指向其他组件的“桥接”信息。
2. .fnm (Fields) - 字段信息文件
   • 作用：存储此Segment中所有字段（Field）的元信息。
   • 内容：对于每个字段，记录其：
     • 名称（Name）
     • 索引选项（Index Options）：是否被索引（INDEXED）、是否存储词向量（DOCS_AND_FREQS_AND_POSITIONS）等。
     • 属性：是否存储（STORED）、是否进行分词（TOKENIZED）等。
     • 使用的编解码器（Codec）信息。
3. .fdx (Field Index) 和 .fdt (Field Data) - 存储字段文件
   • 作用：如果你在映射中设置了 "store": true，文档的原始JSON内容会被存储到这里，以便于通过 stored_fields API检索。
   • 分工：
     • .fdt 文件是真正存储压缩后的文档数据的地方。
     • .fdx 文件是一个索引文件，它像一个指针簿，可以快速定位到某个文档在 .fdt 文件中的具体位置，避免扫描整个 .fdt 文件。
4. .tim (Term Dictionary) - 词项字典文件
   • 作用：这是倒排索引的核心。它包含了该Segment内所有字段的所有词项（Term） 的排序列表。
   • 内容：类似于一本字典的“所有词条列表”，例如：["apple", "banana", "elasticsearch", ...]。
5. .tip (Term Index) - 词项索引文件
   • 作用：为了快速在 .tim 文件中找到某个词项，.tip 文件存储了 .tim 文件的索引。
   • 原理：它存储了词项字典的“前缀索引”，类似于字典的“部首检字表”或“拼音索引”。通过 .tip 可以快速跳转到 .tim 的大致位置，然后再进行精细查找，极大地减少了磁盘寻址次数。
6. .doc (Postings List) - 倒排表文件
   • 作用：存储每个词项对应的倒排列表（Postings List）。
   • 内容：对于词项 "apple"，它的倒排列表会包含所有包含 "apple" 的文档ID（DocID），以及在该文档中出现的词频（Term Frequency）。
7. .pos (Positions) - 位置信息文件
   • 作用：存储词项在文档中出现的位置（Position）信息。
   • 用途：用于支持短语查询（"quick brown fox"） 和 邻近度查询（proximity queries）。如果没有这个文件，ES只能判断一个词是否在文档中出现，而无法判断多个词之间的位置关系。
8. .pay (Payloads) - 载荷文件
   • 作用：存储可选的、与每个位置相关联的额外信息（Payload），例如自定义的权重。
   • 用途：这是一个高级功能，使用相对较少。例如，可以在索引时给某个词项附加一个权重值，在查询时使用这个权重来计算相关性分数。
9. .nvd, .nvm (Norms) - 长度规范文件
   • 作用：存储规范化因子（Norms） 数据，用于在查询时对较短的字段进行奖励（Boost），实现“字段长度归一化”。
   • 原理：一个包含10个词的文档命中查询，比一个包含1000个词的文档命中查询，相关性应该更高。Norms数据就用于这种计算。
10. .dvd, .dvm (DocValues) - 列式存储文件
    • 作用：这是为排序、聚合和脚本访问字段值而设计的列式存储结构。它与倒排索引（行式存储）互为补充。
    • 原理：.dvd 文件存储所有文档某个字段的实际值（例如所有文档的 price），而 .dvm 文件存储元数据，帮助定位 .dvd 文件中的值。
    • 重要性：这是聚合操作（如 terms, avg, histogram）性能高的根本原因。
11. .liv (Live Documents) - 存活文档文件
    • 作用：标记哪些文档是被删除的。由于Segment是不可变的，删除文档并不是直接从文件中抹去数据，而是通过一个特殊的“黑名单”文件来标记该文档已被逻辑删除。
    • 后续处理：这些被标记删除的文档会在后续的Segment合并（Merge）过程中被物理清除。

总结

可以将一个Segment想象成一本完整的、不可更改的书：

这些文件共同协作，使得Elasticsearch能够高效地进行全文搜索、精确值处理、聚合分析等各种操作。Segment合并（Merge） 过程本质上就是将这些小“书”合并成大“书”，并在这个过程中物理清除被删除的文档（.liv 文件中的记录），最终优化索引结构和查询性能。

依赖

    <dependencies>        <dependency>            <groupId>org.springframework.ai</groupId>            <artifactId>spring-ai-starter-model-openai</artifactId>        </dependency>        <dependency>            <groupId>org.springframework.ai</groupId>            <artifactId>spring-ai-advisors-vector-store</artifactId>        </dependency>    </dependencies>    <dependencyManagement>        <dependencies>            <dependency>                <groupId>org.springframework.ai</groupId>                <artifactId>spring-ai-bom</artifactId>                <version>1.0.0</version>                <type>pom</type>                <scope>import</scope>            </dependency>        </dependencies>    </dependencyManagement>

配置文件

spring:  ai:    openai:      api-key: ${ALI_API_KEY}      base-url: https://dashscope.aliyuncs.com/compatible-mode      chat:        options:          model: qwen-plus      embedding:        api-key: ${ALI_API_KEY}        base-url: https://dashscope.aliyuncs.com/compatible-mode        options:          model: text-embedding-v4

向量数据库

    @Bean    public VectorStore vectorStore(@Qualifier("openAiEmbeddingModel") EmbeddingModel embeddingModel) {        //使用内存        return SimpleVectorStore.builder(embeddingModel).build();    }

初始化数据

    @Bean    public CommandLineRunner init(VectorStore vectorStore,                                  @Value("classpath:rag/data.txt")Resource resource) {        return args -> {            //加载数据            List<Document> documentList = new TextReader(resource).read();            //拆分            TextSplitter splitter = new TextSplitter() {                @Override                protected List<String> splitText(String text) {                    //按照行拆分                    return List.of(text.split("\\n"));                }            };            List<Document> transform = splitter.transform(documentList);            //存入向量数据库            vectorStore.write(transform);        };    }

检索

@RestController@RequestMapping("rag")public class RAGController {    @Autowired    private ChatClient chatClient;    @Autowired    private VectorStore vectorStore;    @GetMapping("{message}")    public String chat(@PathVariable("message") String message){        return chatClient.prompt()                .user(message)                .advisors(QuestionAnswerAdvisor.builder(vectorStore)                                .searchRequest(SearchRequest.builder()                                        .query(message)                                        .topK(1)                                        .build())                        .build())                .call()                .content();    }}

数据库表结构

    CREATE TABLE `t_user` (        `id` int NOT NULL AUTO_INCREMENT,        `username` varchar(50) DEFAULT NULL,        `password` varchar(50) DEFAULT NULL,        `age` int DEFAULT NULL,        `create_time` datetime DEFAULT NULL,        `is_deleted` int DEFAULT NULL,        PRIMARY KEY (`id`)    )

提示词

查询

根据用户需求和提供数据库表结构，生成查询sql语法要求使用mysql语法，只能生成查询的sql只返回生成的sql，不要返回其他只能查询逻辑删除字段，值为0的数据用户需求：{question}数据库表结构：{ddl}当前时间：{date}

新增

根据用户需求和提供数据库表结构，生成插入sql语法要求使用mysql语法，只能生成插入的sql只返回生成的sql，不要返回其他尽量补全字段，如果有必填字段未获取到则只返回 1新增的数据逻辑删除字段为0用户需求：{question}数据库表结构：{ddl}当前时间：{date}

修改

根据用户需求和提供数据库表结构，生成修改sql语法要求使用mysql语法，只能生成修改的sql只返回生成的sql，不要返回其他修改的sql必须有条件，否则只返回 1用户需求：{question}数据库表结构：{ddl}当前时间：{date}

删除

根据用户需求和提供数据库表结构，生成逻辑删除sql，即将逻辑删除字段设置为1语法要求使用mysql语法，只能生成逻辑删除的sql只返回生成的sql，不要返回其他删除的sql必须有条件，否则只返回 1用户需求：{question}数据库表结构：{ddl}当前时间：{date}

类型判断

根据用户的输入判断对应的操作类型类型只有一种，匹配最接近的类型只能是：SELECT,UPDATE,INSERT,DELETE只返回类型，不要返回其他东西用户输入：{question}

controller

@RestController@RequestMapping("sql")@Slf4jpublic class SqlController {    @Autowired    private ChatClient chatClient;    @Autowired    private JdbcTemplate jdbcTemplate;        @Value("classpath:sql/schema.sql")    private Resource ddl;    @Value("classpath:st/type.st")    private Resource typeTemp;    @Value("classpath:st/query.st")    private Resource queryTemp;    @Value("classpath:st/save.st")    private Resource saveTemp;    @Value("classpath:st/update.st")    private Resource updateTemp;    @Value("classpath:st/delete.st")    private Resource deleteTemp;    @SneakyThrows    @GetMapping("{message}")    public Object sql(@PathVariable String message){        //判断操作类型        String type = chatClient.prompt()                .user(us -> us.text(typeTemp).param("question", message))                .call()                .content();        log.info("sql type:{}",type);        //根据类型返回对应模板        Resource temp = switch (type){            case "SELECT" -> queryTemp;            case "INSERT" -> saveTemp;            case "UPDATE" -> updateTemp;            case "DELETE" -> deleteTemp;            default -> null;        };        //数据库表结构        String schema = ddl.getContentAsString(Charset.defaultCharset());        //生成sql        String sql = chatClient.prompt()                .user(us -> us.text(temp)//使用模板                        .param("question", message)//设置参数                        .param("ddl", schema)                        .param("date", LocalDateTime.now().toString()))                .call()                .content();        log.info("sql:{}",sql);        //执行sql        if ("SELECT".equals(type)){            //查询数据库            return jdbcTemplate.queryForList(sql);        }else {            if ("1".equals(sql)) {                return "操作异常";            }            //写数据库            jdbcTemplate.execute(sql);            return "ok";        }    }}

依赖

    <dependencyManagement>        <dependencies>            <dependency>                <groupId>org.springframework.ai</groupId>                <artifactId>spring-ai-bom</artifactId>                <version>1.0.0</version>                <type>pom</type>                <scope>import</scope>            </dependency>        </dependencies>    </dependencyManagement>    <dependencies>        <dependency>            <groupId>org.springframework.ai</groupId>            <artifactId>spring-ai-starter-model-openai</artifactId>        </dependency>    </dependencies>

配置文件

spring:  ai:    openai:      api-key: ${ALI_API_KEY}      base-url: https://dashscope.aliyuncs.com/compatible-mode      chat:        options:          model: qwen-plus

注意：需要去掉官方提供的base-url后的v1

配置ChatClient

    @Bean    public ChatClient chatClient(ChatClient.Builder builder) {        return builder.build();    }

简单对话

    @Autowired    private ChatClient chatClient;    @GetMapping("{message}")    public String chat(@PathVariable String message) {        return chatClient.prompt()                .user(message)                .call()                .content();    }

流式输出

    @GetMapping(value = "stream/{message}",produces = "text/stream;charset=utf-8")    public Flux<String> stream(@PathVariable String message) {        return chatClient.prompt()                .user(message)                .stream()                .content();    }

角色预设

    @Bean    public ChatClient chatClient(ChatClient.Builder builder) {        return builder                .defaultSystem("你是一个法律专家")                .build();    }

打印日志

添加日志Advisor

    @Bean    public ChatClient chatClient(ChatClient.Builder builder) {        return builder                .defaultAdvisors(new SimpleLoggerAdvisor())                .build();    }

设置日志等级

logging:  level:    org.springframework.ai.chat.client.advisor: debug

对话记忆

    @Autowired    private ChatMemory chatMemory; //新版本可直接使用，默认基于内存    @Bean    public ChatClient chatClient(ChatClient.Builder builder) {        return builder                .defaultAdvisors(MessageChatMemoryAdvisor                        .builder(chatMemory).build())                .build();    }

对话隔离

    @GetMapping("quarantine/{id}/{message}")    public String quarantine(@PathVariable Integer id,                             @PathVariable String message) {        return chatClient.prompt()                .user(message)                .advisors(ds -> ds.param(ChatMemory.CONVERSATION_ID,id))//根据id进行隔离                .call()                .content();    }

查看历史

    @Autowired    private ChatMemory chatMemory;@GetMapping("history/{id}")    public List<String>  history(@PathVariable Integer id) {        List<Message> messages = chatMemory.get(id.toString());        return messages.stream()                .filter(message -> MessageType.USER.equals(message.getMessageType()))//筛选类型                .map(Message::getText)                .toList();    }

使用工具

定义工具

public class MyTools {    @Tool(description = "获取城市的天气")    String getWeather(@ToolParam(description = "城市") String city){        if ("杭州".equals(city)){            return "暴雨";        }        return "晴天";    }}

配置工具

    @Bean    public ChatClient chatClient(ChatClient.Builder builder) {        return builder                .defaultTools(new MyTools())                .build();    }

使用Ollama

依赖

        <dependency>            <groupId>org.springframework.ai</groupId>            <artifactId>spring-ai-starter-model-ollama</artifactId>        </dependency>

配置

spring:  ai:    ollama:      chat:        model: deepseek-r1:1.5b      base-url: http://localhost:11434

使用

@RestController@RequestMapping("ollama")public class OllamaController {    private ChatClient chatClient;    public OllamaController(@Qualifier("ollamaChatModel") ChatModel chatModel) {        chatClient = ChatClient.builder(chatModel)                .build();    }    @GetMapping("chat/{message}")    public String chat(@PathVariable("message") String message) {        return chatClient.prompt()                .user(message)                .call()                .content();    }}

注意：如果项目中同时引入多个模型，需要使用ChatModel并使用@Qualifier进行区分，ChatClient.Builder方式会报错

依赖

implementation("io.github.resilience4j:resilience4j-spring-boot3:2.2.0")implementation("org.springframework.boot:spring-boot-starter-aop")

配置文件

resilience4j:  timelimiter: #超时    instances: #实例名      timeoutService:        timeoutDuration: 2s # 超时时间为2秒  circuitbreaker: #熔断    instances:      circuitbreakerService:        slidingWindowSize: 10 # 滑动窗口大小为10        failureRateThreshold: 50 # 失败率阈值为50%        waitDurationInOpenState: 10s # 打开状态等待时间为10秒  ratelimiter: #限流 限制请求速率    instances:      ratelimiterService:        limitForPeriod: 1 # 每个周期允许的最大请求数为1        limitRefreshPeriod: 10s # 速率限制刷新周期为10秒        timeoutDuration: 500ms # 等待许可的超时时间为500毫秒  retry: #重试    instances:      retryService:        maxAttempts: 5 # 最大重试次数为5次        waitDuration: 1000ms # 重试间隔为1000毫秒（1秒）        enableExponentialBackoff: true # 启用指数回退        exponentialBackoffMultiplier: 1.5 # 指数回退倍数为1.5        retryExceptions:          - java.lang.RuntimeException # 需要重试的异常类型  bulkhead: #批隔离 限制并发数量    instances:      bulkheadService:        maxConcurrentCalls: 3 # 批隔离允许的最大并发调用数为5        maxWaitDuration: 1s # 等待许可的最大时间为1秒

使用

@RestControllerpublic class MyController {    //重试    @Retry(name = "retryService",fallbackMethod = "fallBack")    @GetMapping("test01/{msg}")    public String test01(@PathVariable String msg){        System.out.println("ok");        if("1".equals(msg)){            throw new RuntimeException("服务调用失败");        }        return "ok";    }    //熔断    @CircuitBreaker(name = "circuitbreakerService",fallbackMethod = "fallBack")    @GetMapping("test02/{msg}")    public String test02(@PathVariable String msg){        System.out.println("ok");        if("1".equals(msg)){            throw new RuntimeException("服务调用失败");        }        return "ok";    }    //限流    @RateLimiter(name = "ratelimiterService",fallbackMethod = "fallBack")    @GetMapping("test03")    public String test03(){        System.out.println("ok");        return "ok";    }    //超时,对返回类型有要求    @TimeLimiter(name = "timeoutService",fallbackMethod = "fallBack2")    @GetMapping("test04/{i}")    public CompletableFuture<String> test04(@PathVariable int i){        return CompletableFuture.supplyAsync(()->{            System.out.println("ok");            try {                Thread.sleep(1000*i);            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }            return "ok";        });    }    //批隔离    @Bulkhead(name = "bulkheadService",fallbackMethod = "fallBack")    @SneakyThrows    @GetMapping("test05")    public String test05(){        System.out.println("ok");        Thread.sleep(5000);        return "ok";    }    public String fallBack(Throwable throwable){        System.out.println("fallBck："+throwable.getMessage());        return "error";    }    //超时使用    public CompletableFuture<String> fallBack2(int i,Throwable throwable){        return CompletableFuture.supplyAsync(()->{            System.out.println("i:"+i);            System.out.println("fallBck："+throwable.getMessage());            return "error";        });    }}

监听器

@Component@Slf4j@AllArgsConstructorpublic class ResilienceListener {    private final RetryRegistry retryRegistry;    private final TimeLimiterRegistry timeLimiterRegistry;    private final CircuitBreakerRegistry circuitBreakerRegistry;    private final RateLimiterRegistry rateLimiterRegistry;    @PostConstruct    public void postConstruct() {        //  注册 Retry 事件监听器        Retry retry = retryRegistry.retry("retryService");        retry.getEventPublisher()                .onEvent(event -> log.info("Retry event: {}", event));        // 注册 CircuitBreaker 事件监听器        CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("circuitbreakerService");        circuitBreaker.getEventPublisher()                .onEvent(event -> log.info("CircuitBreaker Event: {}", event));        // 注册 RateLimiter 事件监听器        RateLimiter rateLimiter = rateLimiterRegistry.rateLimiter("ratelimiterService");        rateLimiter.getEventPublisher()                .onEvent(event -> log.info("RateLimiter Event: {}", event));        // 注册 TimeLimiter 事件监听器        TimeLimiter timeLimiter = timeLimiterRegistry.timeLimiter("timeoutService");        timeLimiter.getEventPublisher()                .onEvent(event -> log.info("TimeLimiter Event: {}", event));    }}

工作模式

优势

1. 多模式适配：覆盖从简单查询到实时流的所有场景。
2. 背压原生支持：避免消费者被压垮（基于 Reactive Streams）。
3. 协议无关性：可运行在 TCP、WebSocket、HTTP/2 等传输层上。
4. 高性能：二进制编码、多路复用减少连接开销。

原生开发

导入依赖

implementation 'org.springframework.boot:spring-boot-starter-rsocket'

处理器

@Slf4jpublic class MessageRSocketHandler implements RSocket {    /**     * 无响应，常用于如日志等     * @param payload Request payload. 附加信息     * @return     */    @Override    public Mono<Void> fireAndForget(Payload payload) {        String message = payload.getDataUtf8();        log.info("fireAndForget message={}", message);        return Mono.empty();//返回以供空消息    }    /**     * 传统模式     * @param payload Request payload.     * @return     */    @Override    public Mono<Payload> requestResponse(Payload payload) {        String message = payload.getDataUtf8();        log.info("requestResponse message={}", message);        return Mono.just(DefaultPayload.create("[echo]"+message));    }    /**     * 返回流数据     * @param payload Request payload.     * @return     */    @Override    public Flux<Payload> requestStream(Payload payload) {        String message = payload.getDataUtf8();        log.info("requestStream message={}", message);        return Flux                .fromStream(message.chars()                        .mapToObj(c->Character.toUpperCase((char) c)))                .map(Object::toString)                .map(DefaultPayload::create);    }    /**     * 双向流     * @param payloads Stream of request payloads.     * @return     */    @Override    public Flux<Payload> requestChannel(Publisher<Payload> payloads) {        return Flux.from(payloads)                .map(Payload::getDataUtf8)                .map(msg->{                    log.info("requestStream message={}",msg);                    return msg;                })                .map(DefaultPayload::create);    }}

连接器

public class MessageRSocketAcceptor implements SocketAcceptor {    @Override    public Mono<RSocket> accept(ConnectionSetupPayload setup, RSocket sendingSocket) {        return Mono.just(new MessageRSocketHandler());//配置处理类    }}

配置服务

public class MessageServer {    //用于释放任务    private static Disposable disposable;    public static void start(){        RSocketServer rSocketServer = RSocketServer.create();        rSocketServer.acceptor(new MessageRSocketAcceptor());        //采用零拷贝        rSocketServer.payloadDecoder(PayloadDecoder.ZERO_COPY);        disposable = rSocketServer                .bind(TcpServerTransport.create(6565))//使用6565端口                .subscribe();    }    public static void stop(){        //释放        disposable.dispose();    }}

测试

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)public class MessagesTests {    private static RSocket rsocket;    @BeforeAll    public static void setUpClient(){        //服务启动        MessageServer.start();        //客户端进行链接        rsocket = RSocketConnector                .connectWith(TcpClientTransport.create(6565))                .block();    }    //测试    @Test    void testFireAndForget() {        getRequestPayload()                .flatMap(payload -> rsocket.fireAndForget(payload))                .blockLast(Duration.ofMinutes(1));    }    @Test    void testRequestAndResponse() {        getRequestPayload()                .flatMap(payload -> rsocket.requestResponse(payload))                .doOnNext(resp -> System.out.println("接收响应："+resp.getDataUtf8()))                .blockLast(Duration.ofMinutes(1));    }    @Test    void testRequestStream(){        getRequestPayload()                .flatMap(payload -> rsocket.requestStream(payload))                .doOnNext(resp -> System.out.println("接收响应："+resp.getDataUtf8()))                .blockLast(Duration.ofMinutes(1));    }    @Test    void testRequestChannel(){        rsocket.requestChannel(getRequestPayload())                        .doOnNext(resp -> System.out.println("接收响应："+resp.getDataUtf8()))                                .blockLast(Duration.ofMinutes(1));    }    //请求数据    private static Flux<Payload> getRequestPayload() {        return Flux.just("java","spring","rsocket")                .delayElements(Duration.ofSeconds(1))                .map(DefaultPayload::create);    }    @AfterAll    public static void stopServer(){        MessageServer.stop();    }}

整合SpringBoot

定义一个数据传输的实体类

@Data@AllArgsConstructor@NoArgsConstructorpublic class Message {    private String title;    private String content;}

服务端

业务类

@Servicepublic class MessageService {    public List<Message> list(){        return List.of(                new Message("java","java hhh"),                new Message("spring","spring xxxx"),                new Message("rsocket","rsocket aaa")        );    }    public Message get(String title){        return new Message(title,title+"xixi");    }    public Message echo(Message message){        message.setTitle("[echo]"+message.getTitle());        message.setContent("[echo]"+message.getContent());        return message;    }}

controller

@Controller@Slf4jpublic class MessageController {    @Autowired    private MessageService messageService;    @MessageMapping("message.echo")    public Mono<Message> echoMessage(Mono<Message> message) {        return message                .doOnNext(m->messageService.echo(m))// 响应处理                .doOnNext(msg -> log.info("接收消息：{}",msg));    }    @MessageMapping("message.delete")    public void deleteMessage(Mono<String> title) {        title.doOnNext(msg->log.info("消息删除：{}",msg)).subscribe();    }    @MessageMapping("message.list")    public Flux<Message> listMessages() {        return Flux.fromStream(messageService.list().stream());    }    @MessageMapping("message.get")    public Flux<Message> getMessages(Flux<String> title) {        return title.doOnNext(t->log.info("消息查询：{}",t))                .map(String::toUpperCase)                .map(messageService::get)                .delayElements(Duration.ofSeconds(1));    }}

配置文件

spring:  rsocket:    server:      port: 6869 #rsocket端口

客户端

配置类

@Configurationpublic class RSocketConfig {    //注册    @Bean    public RSocketStrategies rSocketStrategies(){        return RSocketStrategies.builder()                //编码器                .encoders(encoders -> encoders.add(new Jackson2CborEncoder()))                //解码器                .decoders(decoders -> decoders.add(new Jackson2CborDecoder()))                .build();    }    @Bean    public Mono<RSocketRequester> rSocketRequester(RSocketRequester.Builder builder){        return Mono.just(builder.rsocketConnector(connector ->                connector.reconnect(Retry.fixedDelay(2, Duration.ofSeconds(2))))//失败处理                .dataMimeType(MediaType.APPLICATION_CBOR)//数据的传输类型                .transport(TcpClientTransport.create(6869)));//设置链接端口    }}

测试

@SpringBootTestpublic class SocketTests {    @Autowired    private Mono<RSocketRequester> requester;    @Test    public void testEcho(){        requester.map(r->r.route("message.echo")//地址                .data(new Message("java","java haha")))//请求数据                .flatMap(r->r.retrieveMono(Message.class))                .doOnNext(System.out::println).block();    }    @Test    public void testDelete(){        requester.map(r->r.route("message.delete")                        .data("rsocket..."))                .flatMap(RSocketRequester.RetrieveSpec::send)                .block();    }    @Test    public void testList(){        requester.map(r->r.route("message.list"))                .flatMapMany(r->r.retrieveFlux(Message.class))                .doOnNext(System.out::println).blockLast();    }    @Test    public void testGet(){        Flux<String> title = Flux.just("java","spring","rsocket");        requester.map(r->r.route("message.get")                        .data(title))                .flatMapMany(r->r.retrieveFlux(Message.class))                .doOnNext(System.out::println).blockLast();    }}

文件上传

配置类

@Configurationpublic class RSocketConfig {    //策略    @Bean    public RSocketStrategies rSocketStrategies(){        return RSocketStrategies.builder()                //编码器                .encoders(e->e.add(new Jackson2CborEncoder()))                //解码器                .decoders(e->e.add(new Jackson2CborDecoder()))                //元数据注册                .metadataExtractorRegistry(registry -> {                    registry.metadataToExtract(                            MimeType.valueOf("message/x.upload.file.name"),                            String.class,                            "file.name"                    );                    registry.metadataToExtract(                            MimeType.valueOf("message/x.upload.file.extension"),                            String.class,                            "file.ext"                    );                })                .build();    }}

controller

@Controller@Slf4jpublic class UploadController {    @Value("upload")    private Path path;    @SneakyThrows    @MessageMapping("message.upload")    public Flux<String> upload(            @Headers Map<String,Object> headers, //元数据            @Payload Flux<DataBuffer> payload            ){        log.info("文件上传 path:{}",path);        //获取文件名称        var fileName = headers.get("file.name");        //获取文件后缀        var fileExt = headers.get("file.ext");        var filePath = Paths.get(fileName+"."+fileExt);        log.info("filePath:{}",filePath);        //异步文件通道        AsynchronousFileChannel channel = AsynchronousFileChannel.open(                path.resolve(filePath),//解析文件路径                StandardOpenOption.CREATE,//文件创建                StandardOpenOption.WRITE//文件写入        );        return Flux.concat(DataBufferUtils.write(payload,channel)                .map(s->"处理中"), Mono.just("处理成功"))                .doOnComplete(()-> {                    try {                        //完成后关闭通道                        channel.close();                    } catch (IOException e) {                        throw new RuntimeException(e);                    }                }).onErrorReturn("失败了");//失败处理    }}

客户端测试

@SpringBootTestpublic class SocketTests {    @Autowired    private Mono<RSocketRequester> requester;    @Value("classpath:t1.png")    private Resource resource;    @Test    public void testUpload(){        Flux<DataBuffer> flux = DataBufferUtils.read(                resource,                new DefaultDataBufferFactory(),                1024        ).doOnNext(s-> System.out.println("文件上传"+s));        Flux<String> uploadFlux = requester                .map(r->r.route("message.upload")                        .metadata(metadataSpec -> {                            System.out.println("上传文件名");                            //设置文件名称                            metadataSpec.metadata("t1", MimeType.valueOf("message/x.upload.file.name"));                            //设置文件后缀                            metadataSpec.metadata("png",MimeType.valueOf("message/x.upload.file.extension"));                        }).data(flux))//文件上传数据                .flatMapMany(r->r.retrieveFlux(String.class))                .doOnNext(s -> System.out.println("上传进度"+s));        uploadFlux.blockLast();//阻塞等待    }}

使用WebSocket

spring:  rsocket:    server:      port: 6969 #监听端口      transport: websocket #处理协议      mapping-path: /ws #映射路径

rsocket支持tcp和websocket两种协议，默认tcp

SpringBoot 3.2引入了新的 JdbcClient 用于数据库操作，JdbcClient对JdbcTemplate进行了封装，采用了 fluent API 的风格，可以进行链式调用。

对于不适合使用复杂的ORM框架，或者需要编写复杂的SQL的场景，可以使用JdbcClient自己编写SQL来操作数据库。不过JdbcClient不支持数据的批量操作和存储过程调用，对于这种情况就需要使用JdbcTemplate。

依赖

    implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'    runtimeOnly 'mysql:mysql-connector-java:8.0.33'

配置

spring:  datasource:    url: jdbc:mysql://localhost:3306/demo    username: root    password: 123456    driver-class-name: com.mysql.cj.jdbc.Driver

简单使用

    @Autowired    private JdbcClient jdbcClient;

查询

精准查询

        User user = jdbcClient.sql("select * from t_user where id = ?")                .param(1)                .query(User.class)                .single();

批量查询

        List<User> list = jdbcClient.sql("select * from t_user")                .query(User.class)                .list();

如果需要字段映射

        List<User> list = jdbcClient.sql("select username name,password pwd from t_user")                .query((rs, rowNum) ->                        new User()                                .username(rs.getString("name"))                                .password(rs.getString("pwd")))                .list();

查询数量

        Integer count = jdbcClient.sql("select count(*) from t_user")                .query(Integer.class)                .single();

新增

多参数时需要保证传入参数的顺序，也可以使用:xxx来命名

        int update = jdbcClient.sql("insert into t_user (username,password) values(:username,:password)")                .param("username", "wangwu")                .param("password", "123456")                .update();

也可以使用map进行封装

        Map<String,Object>  map = new HashMap<>();        map.put("username","tianliu");        map.put("password","abcde");        int update = jdbcClient.sql("insert into t_user (username,password) values(:username,:password)")                .params(map)                .update();

也可以直接传入pojo对象

        User user = new User().username("sunqi").password("qwe");        int update = jdbcClient.sql("insert into t_user (username,password) values(:username,:password)")                .paramSource(user)                .update();

修改

        int update = jdbcClient.sql("update t_user set username=:username where id=:id")                .param("id", 1)                .param("username", "zhangsan123")                .update();

删除

        int update = jdbcClient.sql("delete from t_user where id=:id")                .param("id", 6)                .update();

gradle中在dependencies模块中可以用多种标签来声明依赖范围

maven对应依赖范围可以查看：

maven-依赖范围 | qiNan

线程模型

Netty 采用多线程 Reactor 模型，核心线程分为两类：

1. Boss 线程组 (EventLoopGroup)
   • 负责接受客户端连接
   • 将新连接注册到 Worker 线程组
   • 通常只需要1-2个线程
2. Worker 线程组 (EventLoopGroup)
   • 处理已建立连接的I/O操作
   • 执行用户的 ChannelHandler
   • 线程数通常为 CPU 核心数×2

EventLoopGroup bossGroup = new NioEventLoopGroup(1);EventLoopGroup workerGroup = new NioEventLoopGroup();

核心组件

Channel

• 网络连接的抽象，代表一个打开的连接
• 不同类型的实现：NIO、OIO、Epoll 等

EventLoop

• 事件循环，处理 Channel 的I/O事件
• 一个 EventLoop 可服务多个 Channel
• 每个 Channel 的生命周期内只绑定一个 EventLoop

ChannelPipeline

• 处理链，包含一系列 ChannelHandler
• 入站(Inbound)和出站(Outbound)处理分开

ChannelHandler

• 实际业务逻辑处理器
• 常用实现：编解码器、业务处理器等

ChannelFuture

• 异步操作的结果通知机制
• 可以添加监听器处理操作完成事件

工作流程

典型 TCP 服务器工作流程：

1. 初始化两个 EventLoopGroup
2. 创建 ServerBootstrap 并配置参数
3. 绑定端口，启动服务
4. Boss 线程接受连接，分配给 Worker 线程
5. Worker 线程处理连接的读写事件
6. 事件在 ChannelPipeline 中流转处理

ServerBootstrap b = new ServerBootstrap();b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() {     @Override     public void initChannel(SocketChannel ch) {         ch.pipeline().addLast(new MyHandler());     } });ChannelFuture f = b.bind(port).sync();

关键设计

零拷贝

Netty 通过以下方式实现高效数据传输：

ByteBuf

• 自定义的字节容器，支持堆内存和直接内存
• 引用计数管理，减少内存拷贝
• 池化技术减少内存分配开销

CompositeByteBuf

• 合并多个 ByteBuf，逻辑上视为一个整体
• 避免合并时的内存拷贝

FileRegion

• 文件传输时使用零拷贝技术
• 直接通过 DMA 将文件内容发送到网络

内存管理

内存池化

• 预先分配大块内存，减少频繁分配/释放
• 通过 Arena 分配策略提高并发性能

引用计数

• 基于 ReferenceCounted 接口
• 当引用计数为0时自动释放资源

内存泄漏检测

• 通过采样方式检测未释放的 ByteBuf
• 开发阶段可开启严格检测模式

高性能设计

无锁化设计

• 每个 Channel 绑定固定 EventLoop
• 单线程处理 Channel 的所有事件
• 避免多线程竞争

高效序列化

• 支持 Protobuf、Thrift 等高效编解码
• 提供 LengthFieldBasedFrameDecoder 解决粘包问题

灵活的线程模型

• 支持单线程、多线程模型
• 可配置业务线程池处理耗时操作

核心机制

事件传播机制

事件在 Pipeline 中的流动方向：

• Inbound 事件：从网络到应用方向
  • 如 channelRead、channelActive 等
  • 依次调用 InboundHandler
• Outbound 事件：从应用到网络方向
  • 如 write、connect 等
  • 逆序调用 OutboundHandler

责任链模式

ChannelPipeline 采用责任链模式：

1. 每个 Handler 处理特定功能
2. 可以动态添加/移除 Handler
3. 事件依次传递，可中途终止

pipeline.addLast("decoder", new MyDecoder());pipeline.addLast("encoder", new MyEncoder());pipeline.addLast("handler", new BusinessHandler());

异步编程模型

基于 Future-Listener 机制：

1. I/O 操作返回 ChannelFuture
2. 可以同步等待或异步监听
3. 通过回调处理操作结果

ChannelFuture future = channel.write(msg);future.addListener(f -> {    if (f.isSuccess()) {        // 操作成功    } else {        // 操作失败    }});

性能优化

1. 合理配置线程数
   • BossGroup 通常1个线程足够
   • WorkerGroup 建议2-16个线程
2. 避免阻塞EventLoop
   • 耗时操作应使用业务线程池
   • 不要在执行器中执行阻塞操作
3. 合理使用内存
   • 优先使用池化的直接内存
   • 及时释放引用计数对象
4. 优化Handler设计
   • 共享无状态的Handler
   • 避免在Handler中创建大量临时对象

Spring Security 是一个功能强大且高度可定制的身份验证和访问控制框架，是保护基于 Spring 的应用程序的事实标准

过滤器链 (Filter Chain)

Spring Security 本质上是一个 Servlet 过滤器链，在 web 请求到达控制器之前进行安全处理：

• DelegatingFilterProxy：作为入口点，将请求委托给 Spring 管理的 FilterChainProxy
• FilterChainProxy：包含多个安全过滤器，按顺序处理请求
• SecurityFilterChain：决定哪些过滤器应用于当前请求

关键过滤器

1. SecurityContextPersistenceFilter：在请求间存储安全上下文
2. UsernamePasswordAuthenticationFilter：处理表单登录
3. BasicAuthenticationFilter：处理 HTTP 基本认证
4. RememberMeAuthenticationFilter：处理"记住我"功能
5. AnonymousAuthenticationFilter：为未认证用户分配匿名身份
6. SessionManagementFilter：处理会话相关功能
7. ExceptionTranslationFilter：处理安全异常
8. FilterSecurityInterceptor：进行访问控制决策

认证流程

1. 用户提交凭证(用户名/密码等)
2. 认证管理器(AuthenticationManager)委托给 AuthenticationProvider
3. Provider 使用 UserDetailsService 加载用户信息
4. 密码编码器(PasswordEncoder)验证密码
5. 认证成功后构建 Authentication 对象
6. 安全上下文(SecurityContextHolder)存储认证信息

Authentication authentication = authenticationManager.authenticate(    new UsernamePasswordAuthenticationToken(username, password));SecurityContextHolder.getContext().setAuthentication(authentication);

授权流程

1. 访问受保护资源时触发授权检查
2. AccessDecisionManager 基于投票机制做决策
3. 配置的投票器(Voter)根据安全规则投票
4. 基于投票结果允许或拒绝访问

安全上下文传播

• SecurityContextHolder：存储当前安全上下文
• ThreadLocal 策略：默认将上下文绑定到当前线程
• SecurityContextRepository：跨请求持久化上下文(通常使用 HTTP Session)

核心组件

1. Authentication：表示认证主体及其凭证
2. UserDetails：用户核心信息接口
3. UserDetailsService：加载用户特定数据
4. GrantedAuthority：授予主体的权限
5. AuthenticationManager：认证的主要接口
6. ProviderManager：AuthenticationManager 的标准实现
7. AccessDecisionManager：授权决策的核心接口

规则配置

Spring Security 的配置主要通过两个关键类：

1. WebSecurityConfigurerAdapter (旧版)或 SecurityFilterChain (新版)
2. HttpSecurity：配置具体的 HTTP 安全规则

@Configuration@EnableWebSecuritypublic class SecurityConfig {        @Bean    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {        http            .authorizeHttpRequests(auth -> auth                .requestMatchers("/public/**").permitAll()                .anyRequest().authenticated()            )            .formLogin(form -> form                .loginPage("/login")                .permitAll()            );        return http.build();    }}

安全机制

1. CSRF 防护：默认启用，防止跨站请求伪造
2. CORS 支持：跨域资源共享配置
3. Session 管理：会话固定保护、并发控制等
4. HTTP 安全头：自动添加安全相关 HTTP 头
5. 方法级安全：通过注解实现方法级别的访问控制

常用命令

lease(租约)

类似redis的TTL，etcd中的键值对可以绑定到租约上，实现存活周期控制。
应用客户端可以为etcd里的键授予租约，一旦租约到期，租约就会过期并且所有附带的键都会被删除

#授予租约 TTL为30setcdctl lease grant 30#键租约赋予keyetcdctl put --lease=694d96fdc4880b07 k1 v1#撤销租约etcdctl lease revoke 694d96fdc4880b07#刷新租期etcdctl lease keep-alive 694d96fdc4880b07#查询租约信息etcdctl lease timtolive 694d96fdc4880b07#查看租约绑定的keyetcdctl lease timtolive --keys 694d96fdc4880b07

权限管理

可以通过命令后添加--user=xxx的方式指定使用的用户，使用--password=xxx指定密码

ReadIndex

ReadIndex机制就是实现线性读功能的重要机制，当server收到一个线性读请求时，

如果自己是leader节点，则会立即返回，如果自己是follower节点的话，则会向server节点发送一个readIndex请求来获取最新的已提交日志索引（committed index）；

sever收到readIndex请求，还要向其他follower节点发送心跳来防止脑裂异常场景，一半以上节点确认leader节点身份后，leader才会把committed index返回给follower请求节点；

follower节点收到committed index后会和自己的applied index比较，如果applied index值大于committed index时，才表示自己的状态机数据是最新的，这时才会去通知读请求去状态机读取数据。

串行读和线性读

虽然etcd能保证一致性，但是保证强一致性是需要消耗性能的，会牺牲部分吞吐量。因此当出现数据一致性问题时，这时就有串行读与线性读的区别了。数据一致性问题又是由于etcd只有leader节点能处理写请求写数据导致。

（1）当收到写请求时，leader节点先将请求内容持久化到WAL日志中，并且广播给所有follower节点；

（2）如果leader节点有收到一半以上节点的持久化成功消息，那么该请求对应的日志会被标识为已提交；

（3）各个节点的server会异步从raft模块获取已提交的日志条目，应用到状态机（boltdb）。

串行读

直接读取对应server状态机（boltdb）的数据，不会经过Raft协议与集群交互，具有低延迟、高吞吐量的特点，但是可能存在读取结果不一致的情况。

线性读

etcd默认的是线性读，在读取数据时会经过raft协议与集群交互保证数据一致，所以在延迟和吞吐量方面会比串行读有所降低。但是能保证数据的一致性。

线性读保证数据一致性的原理，离不开ReadIndex机制。

MVCC

ETCD的键值存储以及版本信息涉及到一个B树treeIndex和一个B+树boltdb。

treeIndex的作用是作为辅助内存索引，加速对键的范围查询。treeIndex里面会存储key和对应的版本号。

boltdb里面保存了key的值以及历史版本信息。

读取数据时，先从treeIndex中获取key的版本号，再以版本号作为boltdb的key，从boltdb中得到具体的value的信息。

实际读取数据时，还涉及到一个buffer缓冲区，在读取数据时，并非所有请求都要经过boltdb。在访问boltdb前，ETCD会先从buffer中查找是否有key对应的值。如果有就可以直接返回而不用经过boltdb。ETCD通过buffer可以实现一部分的性能提高和数据一致性问题解决。因为buffer是将数据暂存在内存中，可以减少boltdb处理中对磁盘的读写操作；另外buffer会暂未提交的数据，此时可能boltdb里面没有，但是在buffer里面可以提前拿到。

断点是langgraph提供的在流程中供用户暂停修改的机制

基本使用

大模型

from langchain_openai import ChatOpenAIimport osllm = ChatOpenAI(    api_key=os.environ.get("ALI_API_KEY"),    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",    model="qwen-max")

工具

from langchain_core.tools import tool@tooldef multiply(a:int,b:int)->int:    """计算a乘b"""    return a*b@tooldef add(a:int,b:int)->int:    """计算a加b"""    return a+b@tooldef divide(a:int,b:int)->float:    """计算a除b"""    return a/b#绑定tools = [add,multiply,divide]# parallel_tool_calls关闭工具并行llm_with_tools = llm.bind_tools(tools,parallel_tool_calls=False)

节点和状态

from typing_extensions import TypedDictfrom typing import Annotatedfrom langgraph.graph.message import add_messagesfrom langchain_core.messages import AnyMessage, HumanMessage, SystemMessage# 提示词sys_msg = SystemMessage("你是一个乐于助人的助手，负责对一组输入进行算数运算")#状态class MessageState(TypedDict):    # 每次更新进行追加    messages : Annotated[list[AnyMessage],add_messages]# 节点def assistant(state : MessageState):    return {"messages":[llm_with_tools.invoke([sys_msg]+state["messages"])]}

定义图

from langgraph.graph import StateGraph,STARTfrom langgraph.prebuilt import ToolNode,tools_conditionfrom langgraph.checkpoint.memory import MemorySaverbuilder = StateGraph(MessageState)# 定义节点builder.add_node("assistant", assistant)builder.add_node("tools",ToolNode(tools))#定义边builder.add_edge(START,"assistant")builder.add_conditional_edges("assistant",tools_condition)# 循环工具到llm的边builder.add_edge("tools","assistant")memory = MemorySaver()#在tools节点之前进行打断graph = builder.compile(interrupt_before=["tools"],checkpointer=memory)

测试

thread = {"configurable":{"thread_id":"1"}}# 流式输出for event in graph.stream({"messages":HumanMessage("3加4是多少")},thread,stream_mode="values"):    event["messages"][-1].pretty_print()#查看图中打断的方法state = graph.get_state(thread)print(state.next)#获取用户反馈user_approval = input("是否调用工具？（是/否）：")if user_approval.lower() == "是":    #继续执行,通过传None实现    for event in graph.stream(None,thread,stream_mode="values"):        event["messages"][-1].pretty_print()else:    print("用户操作已取消")

断点时修改状态

首先修改打断的时机，在调用大模型前进行断点

#在assistant节点之前进行打断graph = builder.compile(interrupt_before=["assistant"],checkpointer=memory)

测试

thread = {"configurable":{"thread_id":"1"}}# 流式输出for event in graph.stream({"messages":"3加4是多少"},thread,stream_mode="values"):    event["messages"][-1].pretty_print()#修改状态graph.update_state(    thread,    {"messages":[HumanMessage("改成3乘4是多少")]})# 继续执行,通过传None实现for event in graph.stream(None, thread, stream_mode="values"):    event["messages"][-1].pretty_print()

用外部方式修改

创建一个空节点专门用来修改状态

空节点

def human_feedback(state : MessagesState):    pass

定义图

加入这个空节点，并添加断点

builder = StateGraph(MessagesState)# 定义节点builder.add_node("assistant", assistant)builder.add_node("tools",ToolNode(tools))builder.add_node("human_feedback",human_feedback)#定义边builder.add_edge(START,"human_feedback")builder.add_edge("human_feedback","assistant")builder.add_conditional_edges("assistant",tools_condition)builder.add_edge("tools","assistant")memory = MemorySaver()#在human_feedback节点之前进行打断graph = builder.compile(interrupt_before=["human_feedback"],checkpointer=memory)

测试

thread = {"configurable":{"thread_id":"1"}}# 流式输出for event in graph.stream({"messages":"3加4是多少"},thread,stream_mode="values"):    event["messages"][-1].pretty_print()#用户输出user_approval = input("输入你的修改")#修改状态graph.update_state(    thread,    {"messages":user_approval},    as_node="human_feedback")# 继续执行,通过传None实现for event in graph.stream(None, thread, stream_mode="values"):    event["messages"][-1].pretty_print()

动态断点

通过抛出NodeInterrupt异常可用实现动态断点的效果

定义状态和节点

from typing_extensions import TypedDictfrom langgraph.errors import NodeInterrupt#状态class State(TypedDict):    input:str#节点def step_1(state:State):    print("step_1")    return statedef step_2(state:State):    if len(state["input"]) > 5:        raise NodeInterrupt(f"收到的长度超过5个字符")    print("step_2")    return statedef step_3(state:State):    print("step_3")    return state

构建图

builder = StateGraph(State)builder.add_node("step_1",step_1)builder.add_node("step_2",step_2)builder.add_node("step_3",step_3)builder.add_edge(START,"step_1")builder.add_edge("step_1","step_2")builder.add_edge("step_2","step_3")builder.add_edge("step_3",END)memory = MemorySaver()graph = builder.compile(checkpointer=memory)

测试

thread = {"configurable":{"thread_id":"1"}}for event in graph.stream({"input":"你好123123"},thread,stream_mode="values"):    print(event)#查看下一步计划state = graph.get_state(thread)print(state.next)#查看中断状态print(state.tasks)#更新状态graph.update_state(    thread,    {"input":"你好"})#重新运行for event in graph.stream(None,thread,stream_mode="values"):    print(event)

定义状态

class InputState(TypedDict):    question : strclass OutputState(TypedDict):    answer : strclass OverallState(TypedDict):    question : str    answer : str    notes : str

节点

def thinking_node(state : InputState):    return {"answer":"你好","notes":"他是张三"}def answer_node(state : OverallState) -> OutputState:    return {"answer":"再见"}

定义图

#通过input和output参数设置进入流程和结束流程的状态类型graph = StateGraph(OverallState,input=InputState,output=OutputState)graph.add_node("thinking_node",thinking_node)graph.add_node("answer_node",answer_node)graph.add_edge(START,"thinking_node")graph.add_edge("thinking_node","answer_node")graph.add_edge("answer_node",END)g = graph.compile()

测试

s = g.invoke({"question":"hello"})print(s)

简单上手

状态

from typing_extensions import TypedDictclass State(TypedDict):    graph_state: str

节点

def node_1(state: State):    print("node 1")    return {"graph_state": state["graph_state"]+"我很"}def node_2(state: State):    print("node 2")    return {"graph_state": state["graph_state"]+"高兴！"}def node_3(state: State):    print("node 3")    return {"graph_state": state["graph_state"]+"悲伤！"}

条件边

from typing import Literalimport randomdef decide_mood(state: State) -> Literal["node_2","node_3"]:    # 通常使用状态来决定下一个要访问的节点    #user_input = state["graph_state"]    #这里随机访问    if random.random() < 0.5:        return "node_2"    return "node_3"

定义图

from langgraph.graph import StateGraph,START,ENDbuilder = StateGraph(State)#设置节点builder.add_node(node_1)builder.add_node(node_2)builder.add_node(node_3)#添加边builder.add_edge(START,"node_1")#条件边builder.add_conditional_edges("node_1",decide_mood)builder.add_edge("node_2",END)builder.add_edge("node_3",END)graph = builder.compile()

测试

s = graph.invoke({"graph_state":"你好"})print(s)

整合大模型和Tools

大模型

from langchain_openai import ChatOpenAIimport osllm = ChatOpenAI(    api_key=os.environ.get("ALI_API_KEY"),    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",    model="qwen-max")

定义工具并绑定

from langchain_core.tools import tool@tooldef multiply(a:int,b:int)->int:    """计算a乘b"""    return a*b#绑定llm_with_tools = llm.bind_tools([multiply])

状态

from typing_extensions import TypedDictfrom typing import Annotatedfrom langgraph.graph.message import add_messagesfrom langchain_core.messages import AnyMessage, HumanMessageclass MessageState(TypedDict):    # 每次更新进行追加    messages : Annotated[list[AnyMessage],add_messages]

节点

def tool_calling_llm(state : MessageState):    return {"messages":[llm_with_tools.invoke(state["messages"])]}

构建图

builder = StateGraph(MessageState)builder.add_node("tool_calling_llm", tool_calling_llm)builder.add_edge(START,"tool_calling_llm")builder.add_edge("tool_calling_llm",END)graph = builder.compile()

测试

messages = graph.invoke({"messages":HumanMessage("2*3等于多少")})for m in messages["messages"]:    m.pretty_print()

此时是无法自动调用tools的

自动调用tools

构建图时将

from langgraph.prebuilt import ToolNode,tools_conditionbuilder = StateGraph(MessageState)builder.add_node("tool_calling_llm", tool_calling_llm)#将工具封装成节点builder.add_node("tools",ToolNode([multiply]))builder.add_edge(START,"tool_calling_llm")#如果llm的结果是工具调用则路由到工具，否则路由的ENDbuilder.add_conditional_edges("tool_calling_llm",tools_condition)builder.add_edge("tools",END)graph = builder.compile()

ReAct架构

定义工具并绑定

@tooldef multiply(a:int,b:int)->int:    """计算a乘b"""    return a*b@tooldef add(a:int,b:int)->int:    """计算a加b"""    return a+b@tooldef divide(a:int,b:int)->float:    """计算a除b"""    return a/b#绑定tools = [add,multiply,divide]# parallel_tool_calls关闭工具并行llm_with_tools = llm.bind_tools(tools,parallel_tool_calls=False)

定义状态和节点

# 提示词sys_msg = SystemMessage("你是一个乐于助人的助手，负责对一组输入进行算数运算")#状态class MessageState(TypedDict):    # 每次更新进行追加    messages : Annotated[list[AnyMessage],add_messages]# 节点def assistant(state : MessageState):    return {"messages":[llm_with_tools.invoke([sys_msg]+state["messages"])]}

定义图

builder = StateGraph(MessageState)# 定义节点builder.add_node("assistant", assistant)builder.add_node("tools",ToolNode(tools))#定义边builder.add_edge(START,"assistant")builder.add_conditional_edges("assistant",tools_condition)# 循环工具到llm的边builder.add_edge("tools","assistant")graph = builder.compile()

测试

messages = graph.invoke({"messages":HumanMessage("3加4再乘2最后除以3是多少")})for m in messages["messages"]:    m.pretty_print()

实现记忆

在构建图时，设置checkpointer检查点以实现记忆功能

from langgraph.checkpoint.memory import MemorySavermemory = MemorySaver()graph = builder.compile(checkpointer=memory)

测试

#定义一个线程id 这里将记忆点写死为1config = {"configurable":{"thread_id":"1"}}#调用messages1 = graph.invoke({"messages":HumanMessage("3加4是多少")},config)for m in messages1["messages"]:    m.pretty_print()messages2 = graph.invoke({"messages":HumanMessage("再乘2是多少")},config)for m in messages2["messages"]:    m.pretty_print()

构建chain

import osfrom langchain_core.output_parsers import StrOutputParserfrom langchain_core.prompts import ChatPromptTemplatefrom langchain_openai import ChatOpenAI# 大模型llm = ChatOpenAI(    api_key=os.environ.get("ALI_API_KEY"),    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",    model="qwen-max")# 提示词模板prompt = ChatPromptTemplate.from_messages([    ("system","你是一个园区的客服"),    ("user","{text}")])#结果解析器parser = StrOutputParser()# lcelchain = prompt| llm | parser

langserve服务端

from fastapi import FastAPIfrom langserve import add_routes# 构建服务端对象app = FastAPI(title="大模型园区助手", version="1.0", description="基于langchain构建的大模型助手")# 添加路由信息add_routes(    app,    chain,    path="/langchain_demo")#启动服务if __name__ == "__main__":    import uvicorn    uvicorn.run(app, host="0.0.0.0", port=8000)

服务启动后，可用通过浏览器http://localhost:8000/langchain_demo/playground/访问

langserve客户端

from langserve import RemoteRunnableclient = RemoteRunnable("http://127.0.0.1:8000/langchain_demo")s = client.invoke({"text":"你是谁"})print(s)