凉介的笔记

RAG项目案例

Wed, 29 Jul 2026 14:40:49 +0800

RAG项目案例

RAG回顾

RAG即检索、增强和生成，其主要分为2条线：

离线处理：向私有知识库（向量存储）源源不断添加私有知识文档。
- 向知识库添加来自未来的知识文档（基于模型训练完成时间）
- 向模型添加私有知识文档
- 给出模型参考资料，规避模型幻觉（一本正经的胡说八道）
在线处理：用户提问会先基于私有知识库做检索，获取参考资料，同步组装新提示词询问大模型获取结果。

项目需求和思路

本次项目以"某东商品衣服"为例，以衣服属性构建本地知识。使用者可以自由更新本地知识，用户问题的答案也是基于本地知识生成的。

项目主要会实现如下代码：

离线流程

项目基础数据 - /data/xxx.txt
app_file_uploader.py

可以先按照以下步骤运行网页：

1.编写测试代码

import streamlit as st

# 添加网页标题
st.title("知识库更新服务")

2.复制文件地址到命令提示符（cmd）中，进入到当前项目目录（c盘切到d盘：d:）

D:\RAG\AI大模型RAG与智能体开发\P4_RAG项目案例>

3.在cmd中输入streamlit run app_file_uploader.py则会自动跳转到网页中

4.使用 st.file_uploader 创建文件上传组件

# file_uploader
uploader_file = st.file_uploader(
    "请上传TXT文件",
    type=['txt'],
    accept_multiple_files=False,    # False表示仅接受一个文件的上传[不接受多文件]
)

5.提取文件信息

if uploader_file is not None:
    # 提取文件的信息
    file_name = uploader_file.name
    file_type = uploader_file.type
    file_size = uploader_file.size / 1024    # KB

    st.subheader(f"文件名：{file_name}")
    st.write(f"格式：{file_type} | 大小：{file_size:.2f} KB")

    # get_value -> bytes -> decode('utf-8')
    text = uploader_file.getvalue().decode("utf-8")
    st.write(text)

完整代码如下：

"""
基于Streamlit完成WEB网页上传服务

pip install streamlit

Streamlit：当WEB页面元素发生变化，则代码重新执行一遍
"""

import streamlit as st

# 添加网页标题
st.title("知识库更新服务")

# file_uploader
uploader_file = st.file_uploader(
    "请上传TXT文件",
    type=['txt'],
    accept_multiple_files=False,    # False表示仅接受一个文件的上传[不接受多文件]
)


if uploader_file is not None:
    # 提取文件的信息
    file_name = uploader_file.name
    file_type = uploader_file.type
    file_size = uploader_file.size / 1024    # KB

    st.subheader(f"文件名：{file_name}")
    st.write(f"格式：{file_type} | 大小：{file_size:.2f} KB")

    # get_value -> bytes -> decode('utf-8')
    text = uploader_file.getvalue().decode("utf-8")
    st.write(text)

知识库服务

knowledge_base.py

工具类的实现：

"""
知识库
"""
import os
import config_data as config
import hashlib


def check_md5(md5_str: str):
    """
    检查传入的md5字符串是否已经被处理过了
        return False(md5未处理过) True(已经处理过，已有记录)
    """

    if not os.path.exists(config.md5_path):
        # if进入表示文件不存在，那肯定没有处理过这个md5
        open(config.md5_path, "w", encoding="utf-8").close()
        return False
    else:
        for line in open(config.md5_path, "r", encoding="utf-8").readlines():
            line = line.strip()     # 处理字符串前后的空格和回车
            if line == md5_str:     # 已处理过
                return True

        return  False


def save_md5(md5_str: str):
    """将传入的md5字符串，记录到文件内保存"""
    with open(config.md5_path, "a", encoding="utf-8") as f:
        f.write(md5_str + "\n")



def get_string_md5(input_str: str,encoding="utf-8"):
    """将传入的字符串转换为md5字符串"""

    # 将字符串转化为bytes字节数组
    str_bytes = input_str.encode(encoding=encoding)

    # 创建md5对象
    md5_obj = hashlib.md5()     # 得到md5对象
    md5_obj.update(str_bytes)   # 更新内容（传入即将要转换的字节数组）
    md5_hex = md5_obj.hexdigest()   # 得到md5的十六进制字符串

    return md5_hex


class KnowledgeBaseService(object):
    """知识库服务"""
    def __init__(self):
        self.chroma = None      # 向量存储的实例 Chroma向量库对象
        self.spliter = None     # 文本分割器的对象

    def upload_by_str(self,data,filename):
        """将传入的字符串，进行向量化，存入向量数据"""

同样的内容计算的md5值是一样的（16进制字符串，长度32位），不管体积多大计算出来的结果都是32位，假设文本非常非常长，只要内容相同，计算的结果都是一样的（32位），方便做记录【节省空间，效率高】

以下为测试代码（粘贴至上述代码下方）

if __name__ == '__main__':
    # 无论r1和r2里面内容多大，只要内容相同，输出结果就是一样的32位的16进制字符串
    r1 = get_string_md5("周杰伦")	
    r2 = get_string_md5("周杰伦")
    r3 = get_string_md5("周杰伦2")

    print(r1)
    print(r2)
    print(r3)

测试check_md5:

1
2

if __name__ == '__main__':
    print(check_md5("7a8941058aaf4df5147042ce104568da"))

无论运行几次都是False，怎样才能得到True呢

只需要调用save方法将内容保存至md5.text中即可

1
2
3

if __name__ == '__main__':
    save_md5("7a8941058aaf4df5147042ce104568da")
    print(check_md5("7a8941058aaf4df5147042ce104568da"))

配置文件：config_data.py

`1`	`md5_path = "./md5.txt"`

接下来继续完成知识库服务部分**(KnowledgeBaseService)**的代码编写

from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from datetime import datetime

```
此处省略mt5部分的代码
```

class KnowledgeBaseService(object):
    """知识库服务"""
    def __init__(self):
        # 如果文件夹不存在则创建，如果存在则跳过
        os.makedirs(config.persist_directory,exist_ok=True)

        self.chroma = Chroma(
            collection_name=config.collection_name,     # 数据库的表名
            embedding_function=DashScopeEmbeddings(model="text-embedding-v4"),
            persist_directory=config.persist_directory,     # 数据库本地存储文件夹
        )      # 向量存储的实例 Chroma向量库对象
        self.spliter = RecursiveCharacterTextSplitter(
            chunk_size=config.chunk_size,       # 分割后的文本段最大长度
            chunk_overlap=config.chunk_overlap,      # 连续文本段之间的字符重叠数量
            separators=config.separators,       # 自然段落划分的符号
            length_function=len,                # 使用python自带的len函数做长度统计的依据
        )     # 文本分割器的对象

    def upload_by_str(self,data,filename):
        """将传入的字符串，进行向量化，存入向量数据"""
        # 先得到传入字符串的md5值
        md5_hex = get_string_md5(data)

        if check_md5(md5_hex):
            return "[跳过]内容已经存在知识库中"

        if len(data) > config.max_split_char_number:
            # 如果传入的字符串长度大于阈值，则进行文本分割
            knowledge_chunk: list[str] = self.spliter.split_text(data)
        else:
            knowledge_chunk = [data]

            metadata = {
                "source": filename,
                # 2026-01-01 10:00:00
                "create_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                "operator": "小曹",
            }

        self.chroma.add_texts(  # 内容就加载到向量库中了
            # iterable -> list \ tuple
            knowledge_chunk,
            # 列表推导式 ：通过这个列表推导式，为每个文本块生成一份相同的元数据字典
            metadatas=[metadata for _ in knowledge_chunk],
        )

        #  保存md5
        save_md5(md5_hex)

        return "[成功]内容已经成功载入到向量库中"

补充config_data.py

# Chroma
collection_name = "rag"
persist_directory = "./chroma_db"


# spliter
chunk_size = 1000
chunk_overlap = 100
separators = ["\n\n", "\n", ".", "!", "?", "。", "！", "？", " ", ""]
max_split_char_number = 1000        # 文本分割的阈值

测试代码（删除先前创建的text文件）

if __name__ == '__main__':
    service = KnowledgeBaseService()
    r = service.upload_by_str("周杰伦","testfile")
    print(r)

再次运行

接下来将前面两个文件合并（app_file+knowledge）

我们可以在app_file文件中最下方写一行print语句

然后打开网页进行测试，可以发现不管是刷新还是添加文件，控制台都会输出一遍print里的内容，说明Streamlit：当WEB页面元素发生变化，则代码重新执行一遍

那么这个有什么问题呢？

其实问题还是挺大的，因为有了这个问题，就相当于我们整个代码都重跑了一遍，这会造成状态的丢失

我们可以来进行测试一下：

将前面的app文件代码修改为：

import streamlit as st

# 添加网页标题
st.title("知识库更新服务")

# file_uploader
uploader_file = st.file_uploader(
    "请上传TXT文件",
    type=['txt'],
    accept_multiple_files=False,    # False表示仅接受一个文件的上传[不接受多文件]
)


count = 0
if uploader_file is not None:
    # 提取文件的信息
    file_name = uploader_file.name
    file_type = uploader_file.type
    file_size = uploader_file.size / 1024    # KB

    st.subheader(f"文件名：{file_name}")
    st.write(f"格式：{file_type} | 大小：{file_size:.2f} KB")

    # get_value -> bytes -> decode('utf-8')
    text = uploader_file.getvalue().decode("utf-8")
    st.write(text)

    count += 1

print(f"上传了{count}个文件")

第一次上传文件是正常的，但是后续再上传都是相当于每次将代码从头跑了一遍，count都是从0开始，可以发现，只要每次页面发生变化，代码都是从头开始执行一遍

将content相关的代码替换为：

1
2
3

# session_state就是一个字典
if "count" not in st.session_state:
    st.session_state["count"] = 0

`1`	`st.session_state["count"] += 1`

`1`	`print(f'上传了{st.session_state["count"]}个文件')`

打开网页进行测试

这样就解决了状态维护的问题

但是这样还是有缺陷，因为只要页面一刷新，KnowledgeBaseService对象还是留不下来（接下来完整代码中出现），需要重新创建，性能消耗大

接下来就需要达成一个这样的效果：程序不停，只需要创建一个对象即可

完整代码：

"""
基于Streamlit完成WEB网页上传服务

pip install streamlit

Streamlit：当WEB页面元素发生变化，则代码重新执行一遍
"""
import time

import streamlit as st
from knowledge_base import KnowledgeBaseService

# 添加网页标题
st.title("知识库更新服务")

# file_uploader
uploader_file = st.file_uploader(
    "请上传TXT文件",
    type=['txt'],
    accept_multiple_files=False,    # False表示仅接受一个文件的上传[不接受多文件]
)

# # session_state就是一个字典
if "service" not in st.session_state:
    st.session_state["service"] = KnowledgeBaseService()


if uploader_file is not None:
    # 提取文件的信息
    file_name = uploader_file.name
    file_type = uploader_file.type
    file_size = uploader_file.size / 1024    # KB

    st.subheader(f"文件名：{file_name}")
    st.write(f"格式：{file_type} | 大小：{file_size:.2f} KB")

    # get_value -> bytes -> decode('utf-8')
    text = uploader_file.getvalue().decode("utf-8")


    # 增加一点用户体验的等待动画
    with st.spinner("载入知识库中。。。"):       # 在spinner内的代码执行过程中，会有一个转圈动画
        time.sleep(1)
        result = st.session_state["service"].upload_by_str(text, file_name)
        st.write(result)        # 可以直接在页面中显示结果

在线流程

首先先创创建一个向量存储文件

vector_stores.py

from langchain_chroma import Chroma
import config_data as config


class VectorStoreService(object):
    def __init__(self, embedding):
        """
        :param embedding: 嵌入模型的传入
        """
        self.embedding = embedding

        self.vector_store = Chroma(
            collection_name=config.collection_name,
            embedding_function=self.embedding,
            persist_directory=config.persist_directory,
        )

    def get_retriever(self):
        """返回向量检索器，方便加入chain"""
        return self.vector_store.as_retriever(search_kwargs={"k": config.similarity_threshold})


if __name__ == '__main__':
    from langchain_community.embeddings import DashScopeEmbeddings
    retriever = VectorStoreService(DashScopeEmbeddings(model="text-embedding-v4")).get_retriever()

    res = retriever.invoke("我的体重120斤，尺码推荐")
    print(res)

config_data中添加下面这一行代码：

`1`	`similarity_threshold = 1 # 检索返回匹配的文档数量`

接下来实现rag.py

基础实现：

from langchain_core.documents import Document
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough, RunnableWithMessageHistory, RunnableLambda
from vector_stores import VectorStoreService
from langchain_community.embeddings import DashScopeEmbeddings
import config_data as config
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_models.tongyi import ChatTongyi


def print_prompt(prompt):
    print("="*20)
    print(prompt.to_string())
    print("="*20)

    return prompt


class RagService(object):
    def __init__(self):

        # 向量数据库服务 - 用于检索
        self.vector_service = VectorStoreService(
            embedding=DashScopeEmbeddings(model=config.embedding_model_name)
        )

        self.prompt_template = ChatPromptTemplate.from_messages(
            [
                ("system", "以我提供的已知参考资料为主，"
                 "简洁和专业的回答用户问题。参考资料:{context}。"),
                ("user", "请回答用户提问：{input}")
            ]
        )

        self.chat_model = ChatTongyi(model=config.chat_model_name)

        self.chain = self.__get_chain()

    def __get_chain(self):
        """获取最终的执行链"""
        # 获取检索器
        retriever = self.vector_service.get_retriever()

        def format_document(docs: list[Document]):
            if not docs:
                return "无相关参考资料"

            formatted_str = ""
            for doc in docs:
                formatted_str += f"文档片段：{doc.page_content}\n文档元数据：{doc.metadata}\n\n"

            return formatted_str


        chain = (
                {
                    "input": RunnablePassthrough(),
                    "context":  retriever | format_document
                } |  self.prompt_template | print_prompt | self.chat_model | StrOutputParser()
        )

        return chain


if __name__ == '__main__':
    res = RagService().chain.invoke({"我身高170厘米，尺码推荐"}, )
    print(res)

历史会话记录功能

完整代码

from langchain_core.documents import Document
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough, RunnableWithMessageHistory, RunnableLambda
from file_history_store import get_history
from vector_stores import VectorStoreService
from langchain_community.embeddings import DashScopeEmbeddings
import config_data as config
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_models.tongyi import ChatTongyi


def print_prompt(prompt):
    print("="*20)
    print(prompt.to_string())
    print("="*20)

    return prompt


class RagService(object):
    def __init__(self):

        # 向量数据库服务 - 用于检索
        self.vector_service = VectorStoreService(
            embedding=DashScopeEmbeddings(model=config.embedding_model_name)
        )

        self.prompt_template = ChatPromptTemplate.from_messages(
            [
                ("system", "以我提供的已知参考资料为主，"
                 "简洁和专业的回答用户问题。参考资料:{context}。"),
                ("system", "并且我提供用户的对话历史记录，如下："),
                MessagesPlaceholder("history"),
                ("user", "请回答用户提问：{input}")
            ]
        )

        self.chat_model = ChatTongyi(model=config.chat_model_name)

        self.chain = self.__get_chain()

    def __get_chain(self):
        """获取最终的执行链"""
        # 获取检索器
        retriever = self.vector_service.get_retriever()

        # 将检索到的文档列表格式化为字符串
        def format_document(docs: list[Document]):
            if not docs:  # 如果没有检索到文档
                return "无相关参考资料"

            formatted_str = ""
            for doc in docs:  # 遍历每个文档片段
                formatted_str += f"文档片段：{doc.page_content}\n文档元数据：{doc.metadata}\n\n"

            return formatted_str  # 返回拼接后的字符串

        # 从检索器的输入中提取用户问题（为检索器做格式化）
        def format_for_retriever(value: dict) -> str:
            return value["input"]

        # 格式化Prompt模板所需的输入变量
        def format_for_prompt_template(value):
            # 将嵌套字典展平为 {input, context, history} 格式
            new_value = {}
            new_value["input"] = value["input"]["input"]      # 提取用户输入的问题
            new_value["context"] = value["context"]           # 提取检索到的上下文
            new_value["history"] = value["input"]["history"]  # 提取对话历史
            return new_value

        chain = (
            {
                "input": RunnablePassthrough(),
                "context": RunnableLambda(format_for_retriever) | retriever | format_document
            } | RunnableLambda(format_for_prompt_template) | self.prompt_template | print_prompt | self.chat_model | StrOutputParser()
        )

        conversation_chain = RunnableWithMessageHistory(
            chain,
            get_history,
            input_messages_key="input",
            history_messages_key="history",
        )

        return conversation_chain


if __name__ == '__main__':
    # session id 配置
    session_config = {
        "configurable": {
            "session_id": "user_001",
        }
    }

    # 此时（增强链）传入的是一个字典
    res = RagService().chain.invoke({"input": "春天穿什么颜色的衣服？"}, session_config)
    print(res)

聊天页面开发

进入到“智能客服”网页：

1.编写测试代码：

import streamlit as st

# 标题
st.title("智能客服")
st.divider()

2.复制文件地址到命令提示符（cmd）中，进入到当前项目目录：

D:\RAG\AI大模型RAG与智能体开发\P4_RAG项目案例\app_qa.py>

3.启动项目

`1`	`streamlit run app_qa.py`

完整代码：

import time
from rag import RagService          # 导入RAG服务类
import streamlit as st               # 导入Streamlit用于构建Web界面
import config_data as config         # 导入配置文件

# ========== 页面标题 ==========
st.title("智能客服")                 # 设置页面标题
st.divider()                         # 添加分隔符

# ========== 初始化会话状态 ==========
# 存储聊天记录，初始时添加一条欢迎消息
if "message" not in st.session_state:
    st.session_state["message"] = [{"role": "assistant", "content": "你好，有什么可以帮助你？"}]

# 初始化RAG服务实例（只创建一次，避免重复初始化）
if "rag" not in st.session_state:
    st.session_state["rag"] = RagService()

# ========== 显示历史聊天记录 ==========
# 遍历所有聊天记录并渲染到页面
for message in st.session_state["message"]:
    st.chat_message(message["role"]).write(message["content"])

# ========== 用户输入 ==========
# 在页面最下方提供用户输入栏
prompt = st.chat_input()

if prompt:
    # 显示用户提问
    st.chat_message("user").write(prompt)
    # 将用户消息添加到聊天记录
    st.session_state["message"].append({"role": "user", "content": prompt})

    # ========== AI响应 ==========
    ai_res_list = []  # 用于缓存AI的流式响应
    with st.spinner("AI思考中..."):
        # 调用RAG链进行流式响应（res_stream：迭代器）
        res_stream = st.session_state["rag"].chain.stream({"input": prompt}, config.session_config)
        #yield

        # 定义捕获生成器：将流式数据同时返回并缓存
        def capture(generator, cache_list):
            for chunk in generator:
                cache_list.append(chunk)  # 缓存每个chunk
                yield chunk               # 返回给Streamlit显示

        # 流式输出AI响应
        st.chat_message("assistant").write_stream(capture(res_stream, ai_res_list))
        # 将AI完整响应添加到聊天记录
        st.session_state["message"].append({"role": "assistant", "content": "".join(ai_res_list)})
# ["a", "b", "c"]   "".join(list)    -> abc
# ["a", "b", "c"]   ",".join(list)    -> a,b,c

配置文件config_data.py：

在原本的文件上添加以下代码：

session_config = {
        "configurable": {
            "session_id": "user_001",
        }
    }

Python基础语法

Sat, 25 Jul 2026 16:12:15 +0800

本篇为学习Langchain过程中用到的一篇资料，刚好可以用于学习python的基础知识【来自黑马课程】

一、Python 环境与程序运行

Python 解释器：常用 CPython（官方默认），可通过命令行输入 python（Windows）/ python3（Linux/Mac）进入交互环境
程序运行方式：
- 交互环境：直接输入代码回车执行，适合简单测试
- 脚本文件：将代码写入 .py 后缀文件，命令行执行 python 文件名.py（Windows）/ python3 文件名.py（Linux/Mac）
注释：代码中不被执行的说明性文字，用于提高可读性
- 单行注释：以 # 开头，示例：# 这是一行单行注释
- 多行注释：用三个单引号 ’’’ 或三个双引号 """ 包裹，示例： ’’' 这是多行注释第一行第二行 ’’' """ 这也是多行注释支持换行书写 """

二、变量与数据类型

变量定义：无需声明类型，直接赋值即可，变量名由字母、数字、下划线组成，不能以数字开头，区分大小写，不能使用Python关键字
- 赋值语法：变量名 = 赋值内容，示例：name = “Python”，age = 25，score = 98.5
- 多变量赋值：a, b, c = 1, 2, 3（一一对应）；a = b = c = 10（所有变量赋同一值）
基本数据类型
- 数字类型（Number）
  - 整数（int）：正整数、负整数、0，示例：10，-5，0
  - 浮点数（float）：带小数点的数字，示例：3.14，-0.99，10.0
  - 布尔值（bool）：只有两个值 True（真，等价于1）和 False（假，等价于0），示例：is_ok = True，is_pass = False
  - 复数（complex）：形如 a+bj，示例：num = 3+4j
- 字符串类型（str）：用单引号、双引号或三引号包裹的字符序列
  - 示例：s1 = ‘hello’，s2 = “world”，s3 = ‘‘‘hello python’’’
  - 字符串不可变：一旦创建，无法修改单个字符
- 容器类型（基础）
  - 列表（list）：有序、可变、可重复存储不同类型数据，用 [] 包裹，示例：lst = [1, “python”, 3.14, True]
  - 元组（tuple）：有序、不可变、可重复存储不同类型数据，用 () 包裹，示例：tup = (2, “java”, 9.9)
  - 字典（dict）：无序（Python3.7+默认有序）、可变，以键值对（key: value）存储，key唯一且不可变，用 {} 包裹，示例：dic = {“name”: “张三”, “age”: 20}
  - 集合（set）：无序、可变、不可重复存储数据，用 {} 包裹（空集合需用 set()，不能用 {}），示例：s = {1, 2, 3, 3}（最终为 {1,2,3}）
数据类型转换
- 转为整数：int(x)，示例：int(“123”) → 123，int(3.99) → 3
- 转为浮点数：float(x)，示例：float(“3.14”) → 3.14，float(10) → 10.0
- 转为字符串：str(x)，示例：str(123) → “123”，str(True) → “True”
- 转为列表：list(x)，示例：list((1,2,3)) → [1,2,3]
- 转为元组：tuple(x)，示例：tuple([1,2,3]) → (1,2,3)
- 转为集合：set(x)，示例：set([1,1,2]) → {1,2}

三、运算符

算术运算符：用于数值计算
- +：加法，示例：10 + 20 → 30；字符串/列表拼接，示例：“hello” + “world” → “helloworld”
- -：减法，示例：20 - 10 → 10
- *：乘法，示例：10 * 3 → 30；字符串/列表重复，示例：“ab” * 3 → “ababab”
- /：除法，结果为浮点数，示例：10 / 3 → 3.3333333333333335
- //：整除（向下取整），示例：10 // 3 → 3；-10 // 3 → -4
- %：取模（求余数），示例：10 % 3 → 1
- **：幂运算，示例：2 ** 3 → 8；10 ** 2 → 100
赋值运算符：用于给变量赋值
- =：基本赋值，示例：a = 10
- +=：加后赋值，示例：a += 5 等价于 a = a + 5
- -=：减后赋值，示例：a -= 5 等价于 a = a - 5
- *=：乘后赋值，示例：a *= 5 等价于 a = a * 5
- /=：除后赋值，示例：a /= 5 等价于 a = a / 5
- //=：整除后赋值，示例：a //= 5 等价于 a = a // 5
- %=：取模后赋值，示例：a %= 5 等价于 a = a % 5
- **=：幂后赋值，示例：a **= 5 等价于 a = a ** 5
比较运算符：用于比较两个值，结果为布尔值 True/False
- ==：等于，示例：10 == 10 → True；“abc” == “abd” → False
- !=：不等于，示例：10 != 20 → True
- ：大于，示例：20 > 10 → True
- <：小于，示例：10 < 20 → True
- =：大于等于，示例：10 >= 10 → True；20 >= 15 → True
- <=：小于等于，示例：10 <= 20 → True；15 <= 15 → True
逻辑运算符：用于逻辑判断（与、或、非）
- and：逻辑与，所有条件为真才为真，有一个为假则为假，示例：(10 > 5) and (20 > 15) → True
- or：逻辑或，有一个条件为真就为真，所有条件为假才为假，示例：(10 > 5) or (20 < 15) → True
- not：逻辑非，取反，示例：not (10 > 5) → False
成员运算符：用于判断元素是否在容器中（列表、元组、字符串、集合、字典）
- in：判断元素是否存在，示例：“a” in “abc” → True；1 in [1,2,3] → True
- not in：判断元素是否不存在，示例：“d” not in “abc” → True；4 not in [1,2,3] → True
身份运算符：用于判断两个变量是否指向同一个内存对象
- is：判断是否为同一对象，示例：a = 10; b = 10; a is b → True
- is not：判断是否不是同一对象，示例：a = [1,2]; b = [1,2]; a is not b → True

四、流程控制语句

条件判断语句（if-elif-else）：根据条件执行不同代码块
- 基本语法1（单条件）： if 条件表达式: 缩进的执行代码块（条件为True时执行）（注意：Python用缩进区分代码块，通常4个空格，不要混用空格和Tab）
- 示例： if score >= 60: print(“及格”)
- 基本语法2（双条件）： if 条件表达式1: 缩进的执行代码块1 else: 缩进的执行代码块2（条件表达式1为False时执行）
- 示例： if score >= 60: print(“及格”) else: print(“不及格”)
- 基本语法3（多条件）： if 条件表达式1: 缩进的执行代码块1 elif 条件表达式2: 缩进的执行代码块2 elif 条件表达式3: 缩进的执行代码块3 … else: 缩进的执行代码块n（所有前面条件都为False时执行）
- 示例： if score >= 90: print(“优秀”) elif score >= 80: print(“良好”) elif score >= 60: print(“及格”) else: print(“不及格”)
- 嵌套条件：if语句内部可以嵌套if-elif-else，注意缩进层级 if a > 10: if a < 20: print(“a在10和20之间”) else: print(“a大于等于20”) else: print(“a小于等于10”)
循环语句：重复执行某段代码块
- for 循环：用于遍历可迭代对象（列表、元组、字符串、字典等）
  - 基本语法： for 变量名 in 可迭代对象: 缩进的循环执行代码块
  - 示例1（遍历列表）： lst = [1,2,3,4] for num in lst: print(num)
  - 示例2（遍历字符串）： s = “python” for char in s: print(char)
  - 示例3（range() 函数辅助：生成整数序列，range(start, end, step)，start默认0，step默认1，不包含end） for i in range(5): # 0,1,2,3,4 print(i) for i in range(2, 8): # 2,3,4,5,6,7 print(i) for i in range(0, 10, 2): # 0,2,4,6,8 print(i)
  - 示例4（遍历字典）： dic = {“name”: “张三”, “age”: 20} for key in dic: # 遍历键 print(key) for value in dic.values(): # 遍历值 print(value) for key, value in dic.items(): # 遍历键值对 print(key, value)
- while 循环：根据条件判断是否继续循环，先判断条件，再执行代码块
  - 基本语法： while 条件表达式: 缩进的循环执行代码块（注意：需设置循环终止条件，避免无限循环）
  - 示例1（基本循环）： count = 0 while count < 5: print(count) count += 1 # 终止条件：count递增到5，条件不成立
  - 示例2（无限循环，需用break终止）： while True: s = input(“输入内容（输入quit退出）：”) if s == “quit”: break print(“你输入了：”, s)
- 循环控制语句：
  - break：立即终止当前循环，跳出循环体，不再执行后续循环代码示例： for i in range(10): if i == 5: break print(i) # 输出0,1,2,3,4
  - continue：跳过当前循环的剩余代码，直接进入下一次循环示例： for i in range(10): if i == 5: continue print(i) # 输出0,1,2,3,4,6,7,8,9
  - else：循环正常结束（未被break终止）时，执行else代码块示例： for i in range(5): print(i) else: print(“循环正常结束”)

五、字符串操作

字符串索引与切片：索引用于获取单个字符，切片用于获取子字符串
- 索引：分为正向索引（从0开始，从左到右）和反向索引（从-1开始，从右到左）示例：s = “python” s[0] → “p”（正向索引第1个字符） s[-1] → “n”（反向索引第1个字符） s[3] → “h”；s[-3] → “h”
- 切片语法：字符串[start:end:step]，start默认0，end默认字符串长度，step默认1，不包含end对应的字符示例：s = “python” s[0:3] → “pyt”（从索引0到2） s[2:] → “thon”（从索引2到末尾） s[:4] → “pyth”（从开头到索引3） s[1:5:2] → “yh”（从索引1到4，步长2） s[::-1] → “nohtyp”（反转字符串）
常用字符串方法
- len(s)：获取字符串长度，示例：len(“python”) → 6
- s.lower()：转为全小写，示例：“Python”.lower() → “python”
- s.upper()：转为全大写，示例：“Python”.upper() → “PYTHON”
- s.strip()：去除字符串首尾空格（可指定去除的字符），示例：" hello “.strip() → “hello”；”###python###".strip("#") → “python”
- s.split(sep)：按指定分隔符分割字符串，返回列表，示例：“a,b,c”.split(",") → [“a”,“b”,“c”]；“hello world”.split() → [“hello”,“world”]
- s.join(iter)：用字符串连接可迭代对象中的元素，示例：",".join([“a”,“b”,“c”]) → “a,b,c”
- s.replace(old, new)：替换字符串中的旧字符/子串为新字符/子串，示例：“hello world”.replace(“world”, “python”) → “hello python”
- s.find(sub)：查找子串首次出现的索引，未找到返回-1，示例：“python”.find(“th”) → 2
- s.count(sub)：统计子串出现的次数，示例：“ababab”.count(“ab”) → 3
- s.startswith(prefix)：判断字符串是否以指定前缀开头，返回布尔值，示例：“python”.startswith(“py”) → True
- s.endswith(suffix)：判断字符串是否以指定后缀结尾，返回布尔值，示例：“python”.endswith(“on”) → True

六、列表操作

列表索引与切片：与字符串用法一致，列表切片返回新列表，支持修改
- 索引：lst = [1,2,3,4,5] lst[0] → 1；lst[-1] → 5
- 切片：lst[1:4] → [2,3,4]；lst[::-1] → [5,4,3,2,1]
- 切片修改：lst[1:3] = [6,7] → lst变为 [1,6,7,4,5]
常用列表方法
- len(lst)：获取列表长度，示例：len([1,2,3]) → 3
- lst.append(x)：在列表末尾添加一个元素，示例：lst = [1,2]；lst.append(3) → [1,2,3]
- lst.extend(iter)：在列表末尾扩展可迭代对象的元素，示例：lst = [1,2]；lst.extend([3,4]) → [1,2,3,4]
- lst.insert(index, x)：在指定索引位置插入元素，示例：lst = [1,3]；lst.insert(1, 2) → [1,2,3]
- lst.remove(x)：删除列表中首次出现的指定元素，示例：lst = [1,2,3,2]；lst.remove(2) → [1,3,2]
- lst.pop(index)：删除指定索引位置的元素，默认删除最后一个元素，返回被删除的元素，示例：lst = [1,2,3]；lst.pop() → 3，lst变为 [1,2]
- lst.clear()：清空列表所有元素，示例：lst = [1,2,3]；lst.clear() → []
- lst.index(x)：查找元素首次出现的索引，未找到报错，示例：[1,2,3].index(2) → 1
- lst.count(x)：统计元素出现的次数，示例：[1,2,2,3].count(2) → 2
- lst.sort()：对列表元素进行升序排序（原地修改），示例：lst = [3,1,2]；lst.sort() → [1,2,3]
- lst.reverse()：反转列表元素（原地修改），示例：lst = [1,2,3]；lst.reverse() → [3,2,1]

七、字典操作

字典的键值对访问与修改
- 访问值：通过键访问，语法：dic[key]，示例：dic = {“name”: “张三”}；dic[“name”] → “张三”
- 修改值：通过键修改，语法：dic[key] = new_value，示例：dic[“name”] = “李四” → dic变为 {“name”: “李四”}
- 添加键值对：语法：dic[new_key] = value，示例：dic[“age”] = 20 → dic变为 {“name”: “李四”, “age”: 20}
常用字典方法
- len(dic)：获取字典键值对的个数，示例：len({“name”: “张三”, “age”: 20}) → 2
- dic.keys()：返回所有键的可迭代对象，示例：dic.keys() → dict_keys([’name’, ‘age’])
- dic.values()：返回所有值的可迭代对象，示例：dic.values() → dict_values([‘张三’, 20])
- dic.items()：返回所有键值对的可迭代对象，示例：dic.items() → dict_items([(’name’, ‘张三’), (‘age’, 20)])
- dic.get(key, default)：获取键对应的值，键不存在返回默认值（默认None），示例：dic.get(“name”) → “张三”；dic.get(“gender”, “未知”) → “未知”
- dic.pop(key, default)：删除指定键的键值对，返回对应的值，键不存在返回默认值（不指定则报错），示例：dic.pop(“age”) → 20
- dic.clear()：清空字典所有键值对，示例：dic.clear() → {}
- dic.update(new_dic)：用新字典更新原字典，存在的键覆盖值，不存在的键添加，示例：dic.update({“age”: 21, “gender”: “男”})

八、函数

函数定义与调用
- 定义语法： def 函数名(参数列表): 缩进的函数体代码块 [return 返回值] （说明：def是关键字，函数名遵循变量命名规则，参数列表可选，return可选，无return默认返回None）
- 示例1（无参数无返回值）： def say_hello(): print(“Hello Python!”)
- 示例2（有参数有返回值）： def add(a, b): result = a + b return result
- 函数调用：语法：函数名(参数列表)，示例： say_hello() # 调用无参函数 sum_result = add(10, 20) # 调用有参函数，接收返回值 print(sum_result)
函数参数
- 位置参数：按参数定义顺序传递参数，必须一一对应，个数一致，示例：add(10, 20)（10对应a，20对应b）
- 关键字参数：按参数名传递参数，顺序可打乱，示例：add(b=20, a=10)
- 默认参数：定义函数时给参数指定默认值，调用时可省略该参数（使用默认值），示例： def power(x, n=2): return x ** n power(3) → 9（使用默认n=2） power(3, 3) → 27（覆盖默认值）
- 可变参数：
  - *args：接收任意个数的位置参数，打包为元组，示例： def sum_all(*args): total = 0 for num in args: total += num return total sum_all(1,2,3) → 6；sum_all(1,2,3,4,5) → 15
  - **kwargs：接收任意个数的关键字参数，打包为字典，示例： def print_info(**kwargs): for key, value in kwargs.items(): print(key, “:”, value) print_info(name=“张三”, age=20)
return 语句：用于返回函数执行结果，执行到return后函数立即结束，可返回单个值或多个值（多个值打包为元组）示例： def func(): return 1, 2, 3 # 等价于 return (1,2,3) a, b, c = func() # 解包，a=1, b=2, c=3

九、模块与包

模块：一个 .py 文件就是一个模块，用于封装相关的变量、函数、类等，提高代码复用性
- 导入模块：
  - import 模块名，示例：import math（导入数学模块）
  - 导入模块并指定别名，示例：import math as m（别名m，简化使用）
  - 从模块中导入指定内容，示例：from math import pi, sqrt（导入pi和sqrt函数）
  - 从模块中导入所有内容，示例：from math import *（不推荐，容易出现命名冲突）
- 使用模块中的内容：
  - 导入整个模块：模块名.变量/函数，示例：math.pi → 3.141592653589793；math.sqrt(16) → 4.0
  - 导入指定内容：直接使用变量/函数，示例：pi → 3.141592653589793；sqrt(16) → 4.0
包：包含 init.py 文件的文件夹，用于组织多个相关模块，避免模块名冲突
- 导入包中的模块：
  - import 包名.模块名
  - from 包名 import 模块名
  - from 包名.模块名 import 函数/变量

十、异常处理

异常：程序运行过程中出现的错误（如语法错误、索引越界、键不存在等），未处理会导致程序终止
异常处理语法（try-except-else-finally）： try: 缩进的可能出现异常的代码块 except 异常类型1: 缩进的异常1处理代码块 except 异常类型2: 缩进的异常2处理代码块 except: 缩进的所有未捕获异常的处理代码块（万能异常捕获） else: 缩进的try代码块无异常时执行的代码块 finally: 缩进的无论是否出现异常都必须执行的代码块（如资源释放）
示例： try: a = 10 / int(input(“请输入一个数字：”)) except ZeroDivisionError: print(“错误：不能除以0”) except ValueError: print(“错误：请输入有效的整数”) else: print(“计算结果：”, a) finally: print(“程序执行完毕”)

十一、文件操作

文件打开与关闭
- 打开文件：open() 函数，语法：file_obj = open(file_path, mode, encoding=None)
  - file_path：文件路径（绝对路径或相对路径）
  - mode：打开模式，常用： r：只读模式（默认），文件不存在报错 w：写入模式，文件不存在创建，文件存在清空原有内容 a：追加模式，文件不存在创建，文件存在在末尾追加内容 r+：读写模式，文件不存在报错 w+：读写模式，文件不存在创建，文件存在清空原有内容 a+：读写模式，文件不存在创建，文件存在在末尾追加内容带 b 的模式（如 rb、wb）：二进制模式，用于读写图片、视频等二进制文件，无需指定 encoding
  - encoding：文件编码，常用 utf-8，示例：encoding=“utf-8”
- 关闭文件：file_obj.close()，必须关闭文件以释放系统资源
文件读写操作
- 读取文件：
  - file_obj.read(size)：读取指定字节数（size可选，默认读取全部内容）
  - file_obj.readline()：读取一行内容
  - file_obj.readlines()：读取所有行，返回列表，每行作为一个元素
- 写入文件：
  - file_obj.write(content)：写入指定内容（字符串或二进制数据）
  - file_obj.writelines(list)：写入列表中的所有元素（元素需为字符串）
上下文管理器（with 语句）：自动关闭文件，无需手动调用 close()，推荐使用示例1（读取文件）： with open(“test.txt”, “r”, encoding=“utf-8”) as f: content = f.read() print(content) 示例2（写入文件）： with open(“test.txt”, “w”, encoding=“utf-8”) as f: f.write(“Hello Python!\n”) f.writelines([“第一行\n”, “第二行\n”]) 示例3（追加文件）： with open(“test.txt”, “a”, encoding=“utf-8”) as f: f.write(“这是追加的内容”)

Python 高级语法（纯文本格式，可直接复制保存为TXT）

十二、面向对象编程（OOP）

类与对象的基本概念
- 类（class）：是对象的抽象模板，定义了对象的属性和方法
- 对象：是类的实例，通过类创建具体的对象
- 语法： class 类名:
类属性：属于类本身，所有实例共享
类属性名 = 属性值

初始化方法：创建对象时自动调用，用于初始化对象属性
def init(self, 参数列表): # 实例属性：属于单个对象，每个实例独立拥有 self.实例属性名 = 参数值

实例方法：第一个参数必须是self，代表当前对象
def 方法名(self, 参数列表): 方法体代码

类方法：第一个参数必须是cls，代表类本身，用@classmethod装饰
@classmethod def 类方法名(cls, 参数列表): 方法体代码

静态方法：无默认参数，和类、对象无关，用@staticmethod装饰
@staticmethod def 静态方法名(参数列表): 方法体代码
- 示例： class Person:
类属性
species = “人类”

初始化方法
def init(self, name, age): self.name = name # 实例属性 self.age = age

实例方法
def introduce(self): print(f"我叫{self.name}，今年{self.age}岁")

类方法
@classmethod def get_species(cls): return cls.species

静态方法
@staticmethod def is_adult(age): return age >= 18

创建对象（实例化）

p1 = Person(“张三”, 20) p2 = Person(“李四”, 17)

访问实例属性和方法

print(p1.name) # 输出张三 p1.introduce() # 输出我叫张三，今年20岁

访问类属性和类方法

print(Person.species) # 输出人类 print(Person.get_species()) # 输出人类

调用静态方法

print(Person.is_adult(20)) # 输出 True print(Person.is_adult(17)) # 输出 False

三大特性：封装、继承、多态
- 封装：隐藏对象的属性和方法，仅通过公开接口访问，提高安全性
  - 私有属性/方法：在名称前加两个下划线__，只能在类内部访问
  - 示例： class Student: def init(self, name, score): self.name = name self.__score = score # 私有属性
def get_score(self): # 公开接口获取私有属性 return self.__score

def set_score(self, new_score): # 公开接口修改私有属性，可添加校验 if 0 <= new_score <= 100: self.__score = new_score else: print(“分数必须在0-100之间”)

s = Student(“王五”, 90) print(s.get_score()) # 输出 90 s.set_score(95) print(s.get_score()) # 输出 95 s.set_score(101) # 输出分数必须在0-100之间

- 继承：子类继承父类的属性和方法，实现代码复用，子类可扩展或重写父类方法
  - 语法：class 子类名(父类名):
  - 重写：子类定义和父类同名的方法，覆盖父类方法
  - super()：调用父类的方法，常用于子类初始化
  - 示例：

父类

class Animal: def init(self, name): self.name = name

def run(self):
    print(f"{self.name}在奔跑")

子类继承父类

class Dog(Animal): # 重写父类方法 def run(self): print(f"{self.name}在飞快地奔跑")

# 子类扩展方法
def bark(self):
    print(f"{self.name}在叫")

class Cat(Animal): def init(self, name, color): super().init(name) # 调用父类初始化方法 self.color = color # 子类新增属性

def run(self):
    print(f"{self.color}的{self.name}在轻盈地奔跑")

dog = Dog(“旺财”) dog.run() # 输出旺财在飞快地奔跑 dog.bark() # 输出旺财在叫

cat = Cat(“咪咪”, “白色”) cat.run() # 输出白色的咪咪在轻盈地奔跑

- 多态：不同子类对象调用同名方法，表现出不同行为，依赖于继承和方法重写
  - 示例：

def animal_run(animal): animal.run()

animal_run(Dog(“旺财”)) # 输出旺财在飞快地奔跑 animal_run(Cat(“咪咪”, “白色”)) # 输出白色的咪咪在轻盈地奔跑

特殊方法（魔术方法）
- 以双下划线__开头和结尾，在特定场景自动调用
- 常用特殊方法：
  - init：初始化对象
  - str：打印对象时调用，返回字符串，示例： class Book: def init(self, title): self.title = title
def str(self): return f"书名：{self.title}"

b = Book(“Python编程”) print(b) # 输出书名：Python编程 - repr：控制台输出对象时调用，用于调试 - len：调用len()函数时触发，示例： class MyList: def init(self, data): self.data = data

def __len__(self):
    return len(self.data)

ml = MyList([1,2,3]) print(len(ml)) # 输出 3 - add：调用+运算符时触发，实现对象相加，示例： class Point: def init(self, x, y): self.x = x self.y = y

def __add__(self, other):
    return Point(self.x + other.x, self.y + other.y)

p1 = Point(1,2) p2 = Point(3,4) p3 = p1 + p2 print(p3.x, p3.y) # 输出 4 6

十三、装饰器

概念：装饰器是一个函数，用于增强另一个函数的功能，不修改原函数代码，遵循开放封闭原则
基础语法：
- 定义装饰器函数：接收被装饰函数作为参数，返回一个包装函数
- 使用@装饰器名语法，放在被装饰函数定义上方
- 示例1（无参数装饰器）：

定义装饰器：计算函数执行时间

import time def timer_decorator(func): def wrapper(*args, **kwargs): start_time = time.time() result = func(*args, **kwargs) # 执行原函数 end_time = time.time() print(f"{func.name}执行时间：{end_time - start_time}秒") return result return wrapper

使用装饰器

@timer_decorator def my_func(): time.sleep(1) print(“函数执行完成”)

my_func() # 输出函数执行完成 + 执行时间

- 示例2（带参数装饰器）：需要嵌套三层函数，最外层函数接收装饰器参数

def repeat_decorator(num): def decorator(func): def wrapper(*args, **kwargs): for _ in range(num): result = func(*args, **kwargs) return result return wrapper return decorator

使用带参数装饰器

@repeat_decorator(3) def say_hi(): print(“Hi!”)

say_hi() # 连续输出3次 Hi!

常用内置装饰器：
- @classmethod：定义类方法
- @staticmethod：定义静态方法
- @property：将方法转换为属性，调用时无需加括号，示例： class Person: def init(self, name, age): self.name = name self.__age = age
@property def age(self): return self.__age

@age.setter def age(self, new_age): if 0 <= new_age <= 120: self.__age = new_age else: print(“年龄不合法”)

p = Person(“张三”, 20) print(p.age) # 调用@property装饰的方法，无需括号，输出20 p.age = 25 # 调用@age.setter装饰的方法，修改属性 print(p.age) # 输出25

十四、迭代器与生成器

迭代器
- 可迭代对象（Iterable）：能被for循环遍历的对象，如列表、字符串、字典等，实现了__iter__方法
- 迭代器（Iterator）：实现了__iter__和__next__方法的对象，调用next()函数获取下一个元素，无元素时抛出StopIteration异常
- 转换方法：使用iter()函数将可迭代对象转为迭代器
- 示例： lst = [1,2,3] it = iter(lst) # 转为迭代器 print(next(it)) # 输出1 print(next(it)) # 输出2 print(next(it)) # 输出3

print(next(it)) # 抛出StopIteration异常

- 自定义迭代器：

class MyIterator: def init(self, max_num): self.max_num = max_num self.current = 0

def __iter__(self):
    return self

def __next__(self):
    if self.current < self.max_num:
        self.current += 1
        return self.current
    else:
        raise StopIteration

mi = MyIterator(3) for num in mi: print(num) # 输出1 2 3

生成器
- 概念：是一种特殊的迭代器，通过yield关键字定义，无需手动实现__iter__和__next__方法，更简洁
- 工作原理：调用生成器函数时，函数不会立即执行，返回生成器对象；每次调用next()或for循环时，执行到yield暂停，返回yield后的值，下次从暂停处继续执行
- 示例1（生成器函数）： def my_generator(max_num): current = 1 while current <= max_num: yield current # 暂停并返回值 current += 1

gen = my_generator(3) print(next(gen)) # 输出1 print(next(gen)) # 输出2 print(next(gen)) # 输出3

- 示例2（生成器表达式）：语法类似列表推导式，用()代替[]，节省内存（无需一次性生成所有元素）

gen_expr = (x*2 for x in range(3)) for num in gen_expr: print(num) # 输出0 2 4

十五、上下文管理器

概念：用于管理资源（如文件、网络连接、数据库连接），确保资源使用后自动释放，避免资源泄漏
实现方式
- 方式1：类实现__enter__和__exit__方法
  - enter：进入上下文时调用，返回资源对象
  - exit：退出上下文时调用，处理异常和资源释放
  - 示例： class MyFile: def init(self, file_path, mode): self.file_path = file_path self.mode = mode self.file = None
def enter(self): self.file = open(self.file_path, self.mode, encoding=“utf-8”) return self.file

def exit(self, exc_type, exc_val, exc_tb): if self.file: self.file.close() # 返回True可抑制异常，返回False则抛出异常 return False

使用自定义上下文管理器

with MyFile(“test.txt”, “w”) as f: f.write(“Hello 上下文管理器”)

- 方式2：使用contextlib模块的@contextmanager装饰器，通过生成器函数实现，更简洁

from contextlib import contextmanager

@contextmanager def my_open(file_path, mode): f = open(file_path, mode, encoding=“utf-8”) try: yield f # yield之前是__enter__逻辑，之后是__exit__逻辑 finally: f.close()

with my_open(“test.txt”, “r”) as f: print(f.read())

十六、多线程与多进程

多线程：适用于IO密集型任务（如文件读写、网络请求），Python中受GIL（全局解释器锁）限制，同一时间只有一个线程执行Python字节码
- 使用threading模块
- 示例： import threading import time

def task(name): print(f"任务{name}开始") time.sleep(2) # 模拟IO操作 print(f"任务{name}结束")

创建线程

t1 = threading.Thread(target=task, args=(“A”,)) t2 = threading.Thread(target=task, args=(“B”,))

启动线程

t1.start() t2.start()

等待线程结束

t1.join() t2.join() print(“所有任务完成”)

多进程：适用于CPU密集型任务（如数值计算），不受GIL限制，通过multiprocessing模块实现
- 示例： from multiprocessing import Process import time

def task(name): print(f"任务{name}开始") time.sleep(2) print(f"任务{name}结束")

if name == “main”: # Windows系统必须加此判断 p1 = Process(target=task, args=(“A”,)) p2 = Process(target=task, args=(“B”,))

p1.start()
p2.start()

p1.join()
p2.join()
print("所有任务完成")

十七、正则表达式

概念：用于匹配、查找、替换字符串的模式，通过re模块实现
常用函数
- re.match(pattern, string)：从字符串开头匹配，匹配成功返回匹配对象，否则返回None
- re.search(pattern, string)：扫描整个字符串，找到第一个匹配项
- re.findall(pattern, string)：找到所有匹配项，返回列表
- re.sub(pattern, repl, string)：替换所有匹配的子串
常用元字符
- .：匹配任意单个字符（除换行符\n）
- ^：匹配字符串开头
- $：匹配字符串结尾
- *：匹配前一个字符0次或多次
- +：匹配前一个字符1次或多次
- ?：匹配前一个字符0次或1次
- []：匹配括号内任意一个字符
- \d：匹配数字，等价于[0-9]
- \w：匹配字母、数字、下划线，等价于[a-zA-Z0-9_]
- \s：匹配空白字符（空格、制表符、换行符等）
示例： import re

匹配手机号（11位数字，以1开头）

pattern = r"^1\d{10}$" print(re.match(pattern, “13812345678”)) # 匹配成功 print(re.match(pattern, “1234567890”)) # 匹配失败

提取所有数字

string = “年龄：20，身高：180cm” print(re.findall(r"\d+", string)) # 输出 [‘20’, ‘180’]

替换敏感词

string = “这个产品真垃圾” print(re.sub(r"垃圾", “”, string)) # 输出这个产品真

十八、高级数据结构

集合（Set）的高级操作
- 交集：s1 & s2 或 s1.intersection(s2)
- 并集：s1 | s2 或 s1.union(s2)
- 差集：s1 - s2 或 s1.difference(s2)
- 对称差集：s1 ^ s2 或 s1.symmetric_difference(s2)
- 示例： s1 = {1,2,3} s2 = {3,4,5} print(s1 & s2) # 交集 {3} print(s1 | s2) # 并集 {1,2,3,4,5} print(s1 - s2) # 差集 {1,2}
有序字典（OrderedDict）：Python3.7前字典无序，需用collections.OrderedDict保证插入顺序
- 示例： from collections import OrderedDict od = OrderedDict() od[“a”] = 1 od[“b”] = 2 od[“c”] = 3 for k, v in od.items(): print(k, v) # 按插入顺序输出 a 1, b 2, c 3
计数器（Counter）：用于统计可迭代对象中元素的出现次数，返回字典格式
- 示例： from collections import Counter lst = [1,2,2,3,3,3] cnt = Counter(lst) print(cnt) # 输出 Counter({3: 3, 2: 2, 1: 1}) print(cnt.most_common(2)) # 输出出现次数最多的2个元素 [(3, 3), (2, 2)]
命名元组（namedtuple）：创建有名称字段的元组，可读性更高
- 示例： from collections import namedtuple Point = namedtuple(“Point”, [“x”, “y”]) p = Point(1, 2) print(p.x) # 输出1 print(p.y) # 输出2
双端队列（deque）：高效实现两端添加和删除元素，比列表更高效，适用于队列和栈场景
- 示例： from collections import deque dq = deque([1,2,3]) dq.append(4) # 右端添加 dq.appendleft(0) # 左端添加 print(dq) # 输出 deque([0, 1, 2, 3, 4]) dq.pop() # 右端删除 dq.popleft() # 左端删除 print(dq) # 输出 deque([1, 2, 3])

Langchain组件（续）

Wed, 22 Jul 2026 16:04:41 +0800

本文基于黑马2026的课程AI大模型RAG与智能体开发编写，课程内容地址：黑马程序员大模型RAG与Agent智能体项目实战教程，基于主流的LangChain技术从大模型提示词到实战项目_哔哩哔哩_bilibili

Langchain组件

【扩展】运算符的重载

前文代码中： chain = chat_prompt_template | model

在语法上使用了 | 运算符的重载

在 Python 中，运算符（如 +、|）的行为由类的魔法方法决定。例如：

a + b 本质调用的是 a.__add__(b) 双下划线
a | b 本质调用的是 a.__or__(b)

只需要自行实现类的方法，即可对|符号的功能进行重写。

示例：

让 a|b|c 的代码得到一个自定义的类对象(类似列表即[a, b, c])
调用run方法依次输出a、b、c
我们需要重写 | 即__or__方法



class Test(object):
    """测试类，代表一个带名字的对象"""

    def __init__(self, name):
        """初始化方法，设置对象的名称属性"""
        self.name = name

    def __or__(self, other):
        """
        重载或运算符(|)

        当执行 a | b 时，Python会调用这个方法
        参数：
            self: 左边的操作数 (a)
            other: 右边的操作数 (b)
        返回：
            一个新的 MySequence 对象，包含 self 和 other
        """
        return MySequence(self, other)

    def __str__(self):
        """
        重载字符串表示方法
        当使用 print() 或 str() 时会调用此方法
        """
        return self.name


class MySequence(object):
    """序列类，用于存储多个对象的链式结构"""

    def __init__(self, *args):
        """
        初始化方法

        参数：
            *args: 可变参数，可以接收任意数量的参数
                   例如 MySequence(a, b, c) 中 args = (a, b, c)
        """
        self.sequence = []  # 创建一个空列表用于存储序列元素
        for arg in args:    # 遍历所有传入的参数
            self.sequence.append(arg)  # 将每个参数添加到序列中

    def __or__(self, other):
        """
        重载或运算符(|)

        当 MySequence 对象与其他对象进行 | 运算时调用
        参数：
            self: 已有的 MySequence 对象
            other: 要添加到序列的新对象
        返回：
            self 自身，支持链式调用
        """
        self.sequence.append(other)  # 将新元素添加到序列末尾
        return self  # 返回自身，实现链式调用

    def run(self):
        """运行方法，打印序列中的所有元素"""
        for i in self.sequence:  # 遍历序列中的每个元素
            print(i)             # 打印元素（会调用元素的 __str__ 方法）


# 主程序入口
if __name__ == '__main__':
    # 创建多个 Test 对象
    a = Test('a')
    b = Test('b')
    c = Test('c')
    e = Test('e')
    f = Test('f')
    g = Test('g')

    # 使用 | 运算符进行链式调用
    # 执行过程：
    # 1. a | b  →  a.__or__(b)  →  MySequence(a, b)
    # 2. MySequence(a, b) | c  →  MySequence.__or__(c)  →  MySequence(a, b, c)
    # 3. 继续添加 e, f, g，最终得到 MySequence(a, b, c, e, f, g)
    d = a | b | c | e | f | g

    # 运行序列，打印所有元素
    d.run()

    # 打印 d 的类型，可以看到它是 MySequence 类
    print(type(d))

Runnable接口

 # 通过多次按住ctrl+鼠标左键点击PromptTemplate可以进入到源码中进行查看
from langchain_core.prompts import PromptTemplate
from langchain_community.llms.tongyi import Tongyi


prompt = PromptTemplate.from_template("你是一个AI助手")
model = Tongyi(model="qwen3-max")

chain = prompt | model | prompt | model
# chain.invoke()
# chain.stream()
print(type(chain))

通过结果我们可以看到不论 | 后面怎么追加，得到的类型都是RunnableSequence，而RunnableSequence又是Runnable接口的一个子类，所以chain不管怎么追加，invoke方法和stream方法都是有的，通过这个形式，在Langchain里面只要想添加链，在 | 后面添加就可以了

StrOutputParser解析器

字符串输出解析器

有如下代码，想要以第一次模型的输出结果，第二次去询问模型：

链的构建完全符合要求（参与的组件）
但是运行报错（ValueError: Invalid input type <class ’langchain_core.messages.ai.AIMessage’>. Must be a PromptValue, str, or list of BaseMessages.）

`1`	`chain = prompt \| model \| model`

错误的主要原因是：

prompt的结果是PromptValue类型，输入给了model
model的输出结果是：

然后将AIMessage输入给下一个model，但是这个输入类型是不符合要求的，所以导致报错

模型（ChatTongyi）源码中关于invoke方法明确指定了input的类型：

StrOutputParser是LangChain内置的简单字符串解析器

可以将AIMessage解析为简单的字符串，符合了模型invoke方法要求（可传入字符串，不接收AIMessage类型）
是Runnable接口的子类（可以加入链）

1
2

parser = StrOutputParser()
chain = prompt | model | parser | model

代码示例

from langchain_core.messages import AIMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_community.chat_models.tongyi import ChatTongyi

parser = StrOutputParser()
model = ChatTongyi(model="qwen3-max")
prompt = PromptTemplate.from_template(
    "我邻居姓：{lastname}，刚生了{gender}，请起名，仅告知我名字无需其它内容。"
)

chain = prompt | model | parser | model | parser

# res: AIMessage = chain.invoke({"lastname": "张", "gender": "女儿"})
# print(res:content) # 因为输出结果是AIMessage，所以拿到模型的回复内容需要用到:content

# 如果不想用上述形式，解决方法：在第二个model后面再加一个parse![OP](assets/SOP2.png)
res: str = chain.invoke({"lastname": "张", "gender": "女儿"})
print(res)
print(type(res))

此处返回的类型本应显示为<class ‘str’>，但是返回了TextAccesser类型，显示TextAccesser是 LangChain v1.0+ 的正常行为：

它本质上就是字符串 - 继承自 str，所有字符串操作都支持

向后兼容设计 - 为了让旧代码（使用 .text() 方法）和新代码（使用 .text 属性）都能工作

可以把它当作普通字符串使用

JsonOutputParser&多模型执行链

`1`	`chain = prompt \| model \| parser \| model \| parser`

在前面我们完成了这样的需求去构建多模型链，不过这种做法并不标准，因为：

上一个模型的输出，没有被处理就输入下一个模型。

正常情况下我们应该有如下处理逻辑：

invoke｜stream 初始输入 → 提示词模板 → 模型 → 数据处理 → 提示词模板 → 模型 → 解析器 → 结果

即：

上一个模型的输出结果，应该作为提示词模版的输入，构建下一个提示词，用来二次调用模型。

根据输出和输入的要求：

invoke｜stream 初始输入 → 提示词模板 → 模型 → 数据处理 → 提示词模板 → 模型 → 解析器 → 结果

代码示例

from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.prompts import PromptTemplate

# 创建所需的解析器
str_parser = StrOutputParser()
json_parser = JsonOutputParser()

# 模型创建
model = ChatTongyi(model="qwen3-max")

# 第一个提示词模板
first_prompt = PromptTemplate.from_template(
    "我邻居姓：{lastname}，刚生了{gender}，请帮忙起名字，"
    # 如果没有下面这行模板，输出结果会报错
    "并封装为JSON格式返回给我。要求key是name，value就是你起的名字，请严格遵守格式要求。"
)

# 第二个提示词模板
second_prompt = PromptTemplate.from_template(
    "姓名：{name}，请帮我解析含义。"
)

# 构建链   （AIMessage("{name: 张若曦}")
chain = first_prompt | model | json_parser | second_prompt | model | str_parser

for chunk in chain.stream({"lastname": "张", "gender": "女儿"}):
    print(chunk, end="", flush=True)

RunnableLambda&函数加入链

chain = first_prompt | model | json_parser | second_prompt | model | str_parser

前文我们根据JsonOutputParser完成了多模型执行链条的构建。

除了JsonOutputParser这类固定功能的解析器之外
我们也可以自己编写Lambda匿名函数来完成自定义逻辑的数据转换，想怎么转换就怎么转换，更自由。

想要完成这个功能，可以基于RunnableLambda类实现。

RunnableLambda类是LangChain内置的，将普通函数等转换为Runnable接口实例，方便自定义函数加入chain。

语法：

RunnableLambda(函数对象或lambda匿名函数**)**

函数直接如链

chain = first_prompt | model | (lambda ai_msg: {“name”: ai_msg.content}) | second_prompt | model | str_parser

跳过RunnableLambda类，直接让函数加入链也是可以的。

因为Runnable接口类在实现__or__的时候，支持Callable接口的实例。

函数就是Callable接口的实例

如上代码示例，|符号（底层是调用__or__）组链，是支持函数加入的。其本质是将函数自动转换为RunnableLambda

代码示例

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_community.chat_models.tongyi import ChatTongyi

model = ChatTongyi(model="qwen3-max")
str_parser = StrOutputParser()

first_prompt = PromptTemplate.from_template(
    "我邻居姓：{lastname}，刚生了{gender}，请帮忙起名字，仅生成一个名字，并告知我名字，不要额外信息。"
)

second_prompt = PromptTemplate.from_template(
    "姓名{name}，请帮我解析含义。"
)

# 函数的入参：AIMessage -> dict  ({"name": "xxx"})
# my_func = RunnableLambda(lambda ai_msg: {"name": ai_msg.content})

chain = first_prompt | model | (lambda ai_msg: {"name": ai_msg.content}) | second_prompt | model | str_parser

for chunk in chain.stream({"lastname": "曹", "gender": "女孩"}):
    print(chunk, end="", flush=True)

Memory临时会话记忆

如果想要封装历史记录，除了自行维护历史消息外，也可以借助LangChain内置的历史记录附加功能。

LangChain提供了History功能，帮助模型在有历史记忆的情况下回答。

基于RunnableWithMessageHistory在原有链的基础上创建带有历史记录功能的新链（新Runnable实例）
基于InMemoryChatMessageHistory为历史记录提供内存存储（临时用）

完整代码

代码示例

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.prompts import PromptTemplate, ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.chat_history import InMemoryChatMessageHistory

model = ChatTongyi(model="qwen3-max")
# prompt = PromptTemplate.from_template(
#     "你需要根据会话历史回应用户问题。对话历史：{chat_history}，用户提问：{input}，请回答"
# )
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "你需要根据会话历史回应用户问题。对话历史："),
        MessagesPlaceholder("chat_history"),
        ("human", "请回答如下问题：{input}")
    ]
)

str_parser = StrOutputParser()

# 创建一个打印prompt的函数
def print_prompt(full_prompt):
    print("【", full_prompt.to_string(), "】")
    return full_prompt


base_chain = prompt | print_prompt | model | str_parser


store = {}      # 创建一个空字典：key就是session，value就是InMemoryChatMessageHistory类对象
# 实现通过会话id获取InMemoryChatMessageHistory类对象
def get_history(session_id):
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()

    return store[session_id]

# 创建一个新的链，对原有链增强功能：自动附加历史消息
conversation_chain = RunnableWithMessageHistory(
    base_chain,     # 被增强的原有chain
    get_history,    # 通过会话id获取InMemoryChatMessageHistory类对象
    input_messages_key="input",             # 表示用户输入在模板中的占位符
    history_messages_key="chat_history"     # 表示历史模板中的占位符
)

# 业务
if __name__ == '__main__':
    # 固定格式，添加LangChain的配置，为当前程序配置所属的session_id
    session_config = {
        "configurable": {
            "session_id": "user_001"
        }
    }

   
    res = conversation_chain.invoke({"input": "小明有2个猫"}, session_config)
    print("第1次执行：", res)
    
    res = conversation_chain.invoke({"input": "小刚有1只狗"}, session_config)
    print("第2次执行：", res)

    res = conversation_chain.invoke({"input": "总共有几个宠物"}, session_config)
    print("第3次执行：", res)

当前会话是临时的，如果将第1次和第2次执行注释掉，直接执行第3次则会提示如下信息：

Memory长期会话记忆

使用InMemoryChatMessageHistory仅可以在内存中临时存储会话记忆，一旦程序退出，则记忆丢失。

InMemoryChatMessageHistory 类继承自 BaseChatMessageHistory

在官方注释中给出了相关实现的指南，并给出了基于文件的历史消息存储示例代码。

我们可以自行实现一个基于Json格式和本地文件的会话数据保存。

FileChatMessageHistory类实现，核心思路：

基于文件存储会话记录，以session_id为文件名，不同session_id有不同文件存储消息

继承BaseChatMessageHistory实现如下3个方法：

add_messages:同步模式，添加消息
messages:同步模式，获取消息
clear：同步模式，清除消息

如下方代码，官方在BaseChatMessageHistory类的注释中提供了一个基于文件存储的示例代码。

其余核心代码

代码示例

import os, json
from typing import Sequence

from langchain_community.chat_models import ChatTongyi
from langchain_core.messages import message_to_dict, messages_from_dict, BaseMessage
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables import RunnableWithMessageHistory


# message_to_dict：单个消息对象（BaseMessage类实例） -> 字典
# messages_from_dict：[字典、字典...]  -> [消息、消息...]
# AIMessage、HumanMessage、SystemMessage 都是BaseMessage的子类


class FileChatMessageHistory(BaseChatMessageHistory):
    def __init__(self, session_id, storage_path):
        self.session_id = session_id        # 会话id
        self.storage_path = storage_path    # 不同会话id的存储文件，所在的文件夹路径
        # 完整的文件路径
        self.file_path = os.path.join(self.storage_path, self.session_id)

        # 确保文件夹是存在的
        os.makedirs(os.path.dirname(self.file_path), exist_ok=True)

    def add_messages(self, messages: Sequence[BaseMessage]) -> None:
        # Sequence序列 类似list、tuple
        all_messages = list(self.messages)      # 已有的消息列表
        all_messages.extend(messages)           # 新的和已有的融合成一个list

        # 将数据同步写入到本地文件中
        # 类对象写入文件 -> 一堆二进制
        # 为了方便，可以将BaseMessage消息转为字典（借助json模块以json字符串写入文件）
        # 官方message_to_dict：单个消息对象（BaseMessage类实例） -> 字典
        # new_messages = []
        # for message in all_messages:
        #     d = message_to_dict(message)
        #     new_messages.append(d)

        new_messages = [message_to_dict(message) for message in all_messages]
        # 将数据写入文件
        with open(self.file_path, "w", encoding="utf-8") as f:
            json.dump(new_messages, f)

    @property       # @property装饰器将messages方法变成成员属性用
    def messages(self) -> list[BaseMessage]:
        # 当前文件内： list[字典]
        try:
            with open(self.file_path, "r", encoding="utf-8") as f:
                messages_data = json.load(f)    # 返回值就是：list[字典]
                return messages_from_dict(messages_data)
        except FileNotFoundError:
            return []

    def clear(self) -> None:
        with open(self.file_path, "w", encoding="utf-8") as f:
            json.dump([], f)





model = ChatTongyi(model="qwen3-max")
# prompt = PromptTemplate.from_template(
#     "你需要根据会话历史回应用户问题。对话历史：{chat_history}，用户提问：{input}，请回答"
# )
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "你需要根据会话历史回应用户问题。对话历史："),
        MessagesPlaceholder("chat_history"),
        ("human", "请回答如下问题：{input}")
    ]
)

str_parser = StrOutputParser()


def print_prompt(full_prompt):
    print("="*20, full_prompt.to_string(), "="*20)
    return full_prompt


base_chain = prompt | print_prompt | model | str_parser

def get_history(session_id):
    return FileChatMessageHistory(session_id, "./chat_history")

# 创建一个新的链，对原有链增强功能：自动附加历史消息
conversation_chain = RunnableWithMessageHistory(
    base_chain,     # 被增强的原有chain
    get_history,    # 通过会话id获取InMemoryChatMessageHistory类对象
    input_messages_key="input",             # 表示用户输入在模板中的占位符
    history_messages_key="chat_history"     # 表示用户输入在模板中的占位符
)


if __name__ == '__main__':
    # 固定格式，添加LangChain的配置，为当前程序配置所属的session_id
    session_config = {
        "configurable": {
            "session_id": "user_001"
        }
    }

    res = conversation_chain.invoke({"input": "小明有2个猫"}, session_config)
    print("第1次执行：", res)
    
    res = conversation_chain.invoke({"input": "小刚有1只狗"}, session_config)
    print("第2次执行：", res)

    # res = conversation_chain.invoke({"input": "总共有几个宠物"}, session_config)
    # print("第3次执行：", res)

先执行第一次和第二次，然后将第一次和第二次注销掉，再执行第三次，可以发现还是能够正常执行

Document loaders：文档加载器

文档加载器提供了一套标准接口，用于将不同来源（如 CSV、PDF 或 JSON等）的数据读取为 LangChain 的文档格式。这确保了无论数据来源如何，都能对其进行一致性处理。

文档加载器（内置或自行实现）需实现BaseLoader接口。

Class Document，是LangChain内文档的统一载体，所有文档加载器最终返回此类的实例。一个基础的Document类实例，基于如下代码创建：

可以看到，Document类其核心记录了：

page_content：文档内容
metadata：文档元数据（字典）

不同的文档加载器可能定义了不同的参数，但是其都实现了统一的接口（方法）。

load()：一次性加载全部文档
lazy_load()：延迟流式传输文档，对大型数据集很有用，避免内存溢出。

一个简单的CSVLoader的使用示例如下：

LangChain内置了许多文档加载器，详细参见官方文档：https://docs.langchain.com/oss/python/integrations/document_loaders

我们简单的学习如下几个常用的文档加载器：

CSVLoader
JSONLoader
PDFLoader

CSVLoader

自定义CSV文件的解析和加载

代码示例

data.csv

name,age,gender,hobby
王梓涵,25,男,"吃饭,rap"
刘若曦,22,女,"睡觉,rap"
陈俊宇,20,男,"吃饭,rap"
赵思瑶,28,女,"睡觉,rap"
黄浩然,15,男,"吃饭,rap"
林雨桐,20,女,"唱跳,rap"
周博文,20,男,"吃饭,rap"
吴诗琪,24,女,"吃饭,rap"
马子轩,22,男,"睡觉,rap"
孙悦然,27,女,"吃饭,rap"

from langchain_community.document_loaders import CSVLoader


loader = CSVLoader(
    file_path="./data/stu.csv",
    csv_args={
        "delimiter": ",",       # 指定分隔符（需要与csv文件中的分隔符一致，否则会导致整个文件解析失败，或者所有数据都被错误地读成一行（或一列））
        "quotechar": '"',       # 指定带有分隔符文本的引号包围是单引号还是双引号
        # 如果数据原本有表头，就不要下面的代码，如果没有可以使用
        # "fieldnames": ['name', 'age', 'gender', '爱好']
    },
    encoding="utf-8"            # 指定编码为UTF-8
)

# 批量加载 .load()   ->  [Document, Document, ...]
# documents = loader.load()
#
# for document in documents:
#     print(type(document), document)

# 懒加载  .lazy_load()  迭代器[Document]
for document in loader.lazy_load():
    print(document)

以下为懒加载的结果，如果内存较大可以选择批量加载，否则选择懒加载即可

JSONLoader

JSONLoader用于将JSON数据加载为Document类型对象。

使用JSONLoader需要额外安装： pip install jq

jq是一个跨平台的json解析工具，LangChain底层对JSON的解析就是基于jq工具实现的。

将JSON数据的信息抽取出来，封装为Document对象，抽取的时候依赖jq_schema语法。

了解jq的基本抽取规则后，即可使用JSONLoader加载JSON文件了。

代码示例

stu.json

{
    "name": "周杰轮",
    "age": 11,
    "hobby": ["唱", "跳", "RAP"],
    "other": {
        "addr": "深圳",
        "tel": "12332112321"
    }
}

stu_json_lines.json

1
2
3

{"name": "周杰轮", "age": 11, "gender": "男"}
{"name": "蔡依临", "age": 12, "gender": "女"}
{"name": "王力鸿", "age": 11, "gender": "男"}

stus.json

name,age,gender,hobby
王梓涵,25,男,"吃饭,rap"
刘若曦,22,女,"睡觉,rap"
陈俊宇,20,男,"吃饭,rap"
赵思瑶,28,女,"睡觉,rap"
黄浩然,15,男,"吃饭,rap"
林雨桐,20,女,"唱跳,rap"
周博文,20,男,"吃饭,rap"
吴诗琪,24,女,"吃饭,rap"
马子轩,22,男,"睡觉,rap"
孙悦然,27,女,"吃饭,rap"

from langchain_community.document_loaders import JSONLoader

loader = JSONLoader(
    file_path="./data/stu.json",
    # 单独抽取
    # jq_schema=".name",
    # jq_schema=".other.addr",	#抽取深圳
    
    # 整体抽取
    jq_schema=".",
    # text_content=False,     # 告知JSONLoader 我抽取的内容不是字符串
)

# 由于文件比较小，此处使用全加载
document = loader.load()
print(document)

from langchain_community.document_loaders import JSONLoader

loader = JSONLoader(
    file_path="./data/stus.json",
    # 告诉JSONLoader，我需要抽取的JSON对象是全部的name字段
    jq_schema=".[].name",
    text_content=False,     # 告知JSONLoader 我抽取的内容不是字符串
)

# 由于文件比较小，此处使用全加载
document = loader.load()
print(document)

from langchain_community.document_loaders import JSONLoader

loader = JSONLoader(
    file_path="./data/stu_json_lines.json",
    jq_schema=".name",
    text_content=False,     # 告知JSONLoader 我抽取的内容不是字符串
    json_lines=True         # 告知JSONLoader 这是一个JSONLines文件（每一行都是一个独立的标准JSON）
)

document = loader.load()
print(document)

运行结果同上

总结

TextLoader

除了前文学习的三个Loader以外，还有一个基本的加载器：TextLoader

作用：读取文本文件（如.txt），将全部内容放入一个Document对象中。

RecursiveCharacterTextSplitter，递归字符文本分割器，主要用于按自然段落分割大文档。是LangChain官方推荐的默认字符分割器。

它在保持上下文完整性和控制片段大小之间实现了良好平衡，开箱即用效果佳。

代码示例

from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# pip install langchain_text_splitters

loader = TextLoader("./data/Python基础语法.txt", encoding="utf-8")

docs = loader.load()        # [Document]

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,         # 分段的最大字符数
    chunk_overlap=50,       # 分段之间允许重叠字符数
    # 文本自然段落分隔的依据符号
    separators=["\n\n", "\n", "。", "！", "？", ".", "!", "?", " ", ""],
    length_function=len,    # 统计字符的依据函数
)

split_docs = splitter.split_documents(docs)
print(len(split_docs))
for doc in split_docs:
    print("="*20)
    print(doc)
    print("="*20)

PyPDFLoader

LangChain内支持许多PDF的加载器，我们选择其中的PyPDFLoader使用。

PyPDFLoader加载器，依赖PyPDF库，所以，需要安装它：

pip install pypdf

PyPDFLoader使用还是比较简单的，如下代码即可快速加载PDF中的文字内容了：

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader(
    file_path="./data/pdf2.pdf",
    mode="single",        # 默认是page模式，每个页面形成一个Document文档对象，
                          # single模式，不管有多少页，只返回1个Document对象
    password="itheima"	  # 用于读取含有密码的pdf文件
)

i = 0
for doc in loader.lazy_load():
    i += 1
    print(doc)
    print("="*20, i)

Vector stories向量存储

基于LangChain的向量存储，存储嵌入数据，并执行相似性搜索。

代码示例

Info.csv

source,info
黑马程序员,Python是世界上最好的编程语言
传智教育,股票代码003032
黑马程序员,LangChain极大地方便了大模型开发
黑马程序员,AI和Python是下一个十年的风口
传智教育,Python学起来很简单的
黑马程序员,学习Python键盘敲烂月薪过万
黑马程序员,努力带来成就，Python助力辉煌
黑马程序员,学习Python的时候也要记得好好休息打打篮球
黑马程序员,明天晚上吃啥子呀
黑马程序员,如何快速减肥呢

from langchain_core.vectorstores import InMemoryVectorStore
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_community.document_loaders import CSVLoader

vector_store = InMemoryVectorStore(
    embedding=DashScopeEmbeddings()
)


loader = CSVLoader(
    file_path="./data/info.csv",
    encoding="utf-8",
    source_column="source",     # 指定本条数据的来源是哪里
)

documents = loader.load()
# id1 id2 id3 id4 ...
# 向量存储的 新增、删除、检索
vector_store.add_documents(
    documents=documents,        # 被添加的文档，类型：list[Document]
    ids=["id"+str(i) for i in range(1, len(documents)+1)] # 给添加的文档提供id（字符串）  list[str]
)

# 删除  传入[id, id...]
vector_store.delete(["id1", "id2"])

# 检索 返回类型list[Document]
result = vector_store.similarity_search(
    "瑞达法",
    3       # 检索的结果要几个
)

print(result)

由于这是内存存储，只要程序停止数据就丢失了，所以下面我们基于外部数据库的存储：

from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_community.document_loaders import CSVLoader

# Chroma 向量数据库（轻量级的）
# 确保 langchain-chroma chromadb 这两个库安装了的，没有的话请pip install

vector_store = Chroma(
    collection_name="test",     # 当前向量存储起个名字，类似数据库的表名称
    embedding_function=DashScopeEmbeddings(),       # 嵌入模型
    persist_directory="./chroma_db"     # 指定数据存放的文件夹
)


loader = CSVLoader(
    file_path="./data/info.csv",
    encoding="utf-8",
    source_column="source",     # 指定本条数据的来源是哪里
)

documents = loader.load()
# id1 id2 id3 id4 ...
# 向量存储的 新增、删除、检索
vector_store.add_documents(
    documents=documents,        # 被添加的文档，类型：list[Document]
    ids=["id"+str(i) for i in range(1, len(documents)+1)] # 给添加的文档提供id（字符串）  list[str]
)

# 删除  传入[id, id...]
vector_store.delete(["id1", "id2"])

# 检索 返回类型list[Document]
result = vector_store.similarity_search(
    "Python是不是简单易学呀",
    3,        # 检索的结果要几个
    filter={"source": "黑马程序员"}  # 过滤的值和values
)

print(result)

检索向量并构建提示词

向量存储的实例，通过**add_texts(list[str])**方法可以快速添加到向量存储中。

流程：

1.先通过向量存储检索匹配信息

2.将用户提问和匹配信息一同封装到提示词模板中提问模型

代码示例

"""
提示词：用户的提问 + 向量库中检索到的参考资料
"""
from langchain_community.chat_models import ChatTongyi
from langchain_core.vectorstores import InMemoryVectorStore
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser


def print_prompt(prompt):
    print(prompt.to_string())
    print("=" * 20)
    return prompt


model = ChatTongyi(model="qwen3-max")
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "以我提供的已知参考资料为主，简洁和专业的回答用户问题。参考资料:{context}。"),
        ("user", "用户提问：{input}")
    ]
)

vector_store = InMemoryVectorStore(embedding=DashScopeEmbeddings(model="text-embedding-v4"))

# 准备一下资料（向量库的数据）
# add_texts 传入一个 list[str]
vector_store.add_texts(
    ["减肥就是要少吃多练", "在减脂期间吃东西很重要,清淡少油控制卡路里摄入并运动起来", "跑步是很好的运动哦"])

input_text = "怎么减肥？"

# 检索向量库
result = vector_store.similarity_search(input_text, 2)
reference_text = "["
for doc in result:
    reference_text += doc.page_content
reference_text += "]"

chain = prompt | print_prompt | model | StrOutputParser()

res = chain.invoke({"input": input_text, "context": reference_text})
print(res)

RunnablePassthrough的使用

代码示例

"""
核心思路：构建一个 RAG（检索增强生成）链
流程：用户提问 → 向量库检索相关资料 → 将提问+资料拼成提示词 → 发送给大模型 → 输出回答

RunnablePassthrough 的作用：
  当链的输入是一个简单的字符串（而非 dict）时，
  RunnablePassthrough 负责将原始输入原封不动地传递到下游。
  这样用户调用 chain.invoke("怎么减肥？") 时，
  "怎么减肥？" 既会送给 retriever 做检索，也会作为 "input" 填入提示词模板。
"""
from langchain_community.chat_models import ChatTongyi
from langchain_core.documents import Document
from langchain_core.runnables import RunnablePassthrough
from langchain_core.vectorstores import InMemoryVectorStore
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser


def print_prompt(prompt):
    """调试用：打印最终拼装好的提示词，方便观察模板变量是否被正确替换"""
    print(prompt.to_string())
    print("=" * 20)
    return prompt  # 注意：必须把 prompt 返回回去，否则链就断了


# ======================== 1. 初始化大模型 ========================
model = ChatTongyi(model="qwen3-max")

# ======================== 2. 定义提示词模板 ========================
# 模板中有两个变量：
#   {context} —— 来自向量检索的结果（参考资料）
#   {input}   —— 来自用户的原始提问
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "以我提供的已知参考资料为主，简洁和专业的回答用户问题。参考资料:{context}。"),
        ("user", "用户提问：{input}")
    ]
)

# ======================== 3. 创建内存向量库 ========================
# InMemoryVectorStore：数据只存在内存中，程序结束就没了（适合学习演示）
# DashScopeEmbeddings：调用通义千问的 embedding 模型，把文本转成向量
vector_store = InMemoryVectorStore(embedding=DashScopeEmbeddings(model="text-embedding-v4"))

# 准备一下资料（向量库的数据）
# add_texts 传入一个 list[str]，内部会自动调用 embedding 模型将文本转为向量并存储
vector_store.add_texts(
    ["减肥就是要少吃多练", "在减脂期间吃东西很重要,清淡少油控制卡路里摄入并运动起来", "跑步是很好的运动哦"])

input_text = "怎么减肥？"

# ======================== 4. 创建检索器（Retriever） ========================
# as_retriever() 将向量库包装成一个 Retriever 对象
# search_kwargs={"k": 2} 表示每次检索返回最相似的 2 条文档
# 重要：retriever 实现了 Runnable 接口，所以可以用 | 管道符与其他组件串联
#   - 输入：str（用户的提问）
#   - 输出：list[Document]（检索到的文档列表）
retriever = vector_store.as_retriever(search_kwargs={"k": 2})


def format_func(docs: list[Document]):
    """
    将检索到的 Document 列表转成一个拼接好的字符串，
    方便嵌入到提示词的 {context} 中。
    例如输出："[减肥就是要少吃多练跑步是很好的运动哦]"
    """
    if not docs:
        return "无相关参考资料"

    formatted_str = "["
    for doc in docs:
        formatted_str += doc.page_content
    formatted_str += "]"

    return formatted_str

# ======================== 5. 构建链（Chain） ========================
# 这是最核心的部分，拆解来看：
#
# 第一层（dict 构造）：{"input": ..., "context": ...}
#   这一层负责生成一个 dict，作为 prompt 模板的输入参数：
#
#   "input": RunnablePassthrough()
#       → RunnablePassthrough() 会把链的原始输入（即 input_text）原样透传
#       → 等价于：lambda x: x  （把 "怎么减肥？" 直接传过去）
#
#   "context": retriever | format_func
#       → 先用 retriever 对输入做向量检索，得到 list[Document]
#       → 再用 format_func 将 list[Document] 格式化为字符串
#       → 等价于：lambda x: format_func(retriever.invoke(x))
#
# 第二层：| prompt
#   → 将 {"input": "...", "context": "..."} 填入提示词模板，得到完整 prompt
#
# 第三层：| print_prompt
#   → 调试用，打印出拼装好的提示词（并透传给下一步）
#
# 第四层：| model
#   → 将提示词发送给大模型，得到 AI 的回复
#
# 第五层：| StrOutputParser()
#   → 将大模型返回的 Message 对象提取为纯字符串
#
chain = (
    {"input": RunnablePassthrough(), "context": retriever | format_func} | prompt | print_prompt | model | StrOutputParser()
)

# ======================== 6. 执行链 ========================
# invoke() 触发整条链的执行：
#   "怎么减肥？" → 向量检索 → 格式化 → 填充模板 → 大模型 → 纯文本回答
res = chain.invoke(input_text)
print(res)

"""
完整数据流总结：

chain.invoke("怎么减肥？")
    │
    ▼
{"input": RunnablePassthrough(), "context": retriever | format_func}
    │                          │
    │                          ▼
    │                    retriever("怎么减肥？")
    │                          │
    │                          ▼
    │                    list[Document] （检索到的 2 条文档）
    │                          │
    │                          ▼
    │                    format_func(docs) → "[减肥就是要少吃多练跑步是很好的运动哦]"
    │
    ▼
{"input": "怎么减肥？", "context": "[减肥就是要少吃多练跑步是很好的运动哦]"}
    │
    ▼
prompt（填充模板） → PromptValue（完整的提示词）
    │
    ▼
model（调用大模型） → AI 回复
    │
    ▼
StrOutputParser() → 纯字符串结果
"""

RAG开发-LangChain

Mon, 13 Jul 2026 16:48:40 +0800

RAG开发

LangChain简介

主要功能

提供：

提示词优化的相关功能API
调用各类模型的功能API
会话记忆的相关功能API
各类文档管理分析的功能API
构建Agent智能体的相关功能API
各类功能链式执行的能力

LangChain是后续学习RAG开发的主力框架

LangChain环境部署

LangChain安装

如果清华镜像源不行，可以使用以下命令：

（社区版）

官方PyPI源：python -m pip install langchain-community langchain-ollama dashscope chromadb -i https://pypi.org/simple/

阿里云镜像：python -m pip install langchain-community langchain-ollama dashscope chromadb -i https://mirrors.aliyun.com/pypi/simple/

基础langchain包：

官方PyPI源：python -m pip install langchain -i https://pypi.org/simple/

阿里云镜像：python -m pip install langchain -i https://mirrors.aliyun.com/pypi/simple/

安装完可以输入python进入python环境进行验证

进入到python环境中输入

import langchain

print(langchain.version)

进行验证

RAG

介绍

通⽤的基础⼤模型存在一些问题：

LLM的知识不是实时的，模型训练好后不具备自动更新知识的能力，会导致部分信息滞后
LLM领域知识是缺乏的，大模型的知识来源于训练数据，这些数据主要来自公开的互联网和开源数据集，无法覆盖特定领域或高度专业化的内部知识
幻觉问题，LLM有时会在回答中⽣成看似合理但实际上是错误的信息
数据安全性

RAG（Retrieval-Augmented Generation）即检索增强生成，为大模型提供了从特定数据源检索到的信息，以此来修正和补充生成的答案。可以总结为一个公式：RAG = 检索技术 + LLM 提示

工作原理

工作流程图解：

RAG标准流程：

简单来说，RAG工作分为两条线：离线准备线 / 在线服务线

标准流程

RAG 标准流程由索引（Indexing）、检索（Retriever）和生成（Generation）三个核心阶段组成。

索引阶段：通过处理多种来源多种格式的文档提取其中文本，将其切分为标准长度的文本块（chunk），并进行嵌入向量化（embedding），向量存储在向量数据库（vector database）中。
- 加载文件
- 内容提取
- 文本分割，形成chunk
- 文本向量化
- 存向量数据库
检索阶段，用户输入的查询（query）被转化为向量表示，通过相似度匹配从向量数据库中检索出最相关的文本块。
- query向量化
- 在文本向量中匹配出与问句向量相似的top_k个
生成阶段，检索到的相关文本与原始查询共同构成提示词（Prompt），输入大语言模型（LLM），生成精确且具备上下文关联的回答。
- 匹配出的文本作为上下文和问题一起添加到prompt中
- 提交给LLM生成答案

主流向量数据库：

RAG的核心价值：

解决知识实效性问题：大模型的训练数据有截止时间，RAG 可以接入最新文档（如公司财报、政策文件），让模型输出 “与时俱进”。

降低模型幻觉：模型的回答基于检索到的事实性资料，而非纯靠自身记忆，大幅减少编造信息的概率。

无需重新训练模型：相比微调（Fine-tuning），RAG 只需更新知识库，成本更低、效率更高。

向量

基础概念

RAG流程中，向量库是一个重要的节点。

离线流程：知识和信息 → 向量嵌入（向量化） → 存入向量库
在线流程：用户的提问 → 向量嵌入（向量化） → 在向量库中匹配

向量（Vector）就是文本的 “数学身份证”：它把一段文字的语义信息，转换成一串固定长度的数字列表，让计算机能 “看懂” 文字的含义并做相似度计算。

简单来说，就是让计算机更方便的理解不同的文本内容，是否表述的是一个意思。

文本嵌入模型（如text-embedding-v1）通过深度学习等技术，从文本提取语义特征并映射为固定长度的数字序列。

向量嵌入的过程，我们一般选用合适的文本嵌入模型来完成。

在向量匹配的过程中，如何识别2段文本是否表述相似的含义，主要可以通过如余弦相似度等算法来完成。比如（下列案例中向量为示例，仅描述概念，非真实向量）：

A： “如何快速学打篮球” → [0.2, 0.5, 0.8]
B： “打篮球怎么学得快” → [0.18, 0.52, 0.79]
C： “运动后吃什么好呢” → [0.9, 0.1, 0.2]

通过余弦相似度算法可以计算得到：A和B相似度0.999789，A和C相似度0.361446

由此可通过精确的数学计算，去匹配2段文本是否描述同一个意思，提高语义匹配的效率和精度。

如何更为精准的完成语义匹配，生成向量的维度是一个很重要的指标。

如text-embedding-v1模型，可以生成1536维的向量（一段文本固定得到1536个数字序列），比较实用。

1536个数字表示，这段文本在1536个主题（抽象的语义特征）方向上的得分（强度）

生成向量的维度越多，就更好的记录文本的语义特征，做语义匹配会更加精准。
更多的向量会在计算、存储和匹配过程中，带来更大的压力。

选择合适的向量维度需要在精确和性能之间做平衡。一般1536维算是比较好的选择。

【扩展】余弦相似度

向量的数字序列，共同决定了向量在高维空间中的方向和长度.而余弦相似度主要就是撇除长度的影响，得到方向的夹角。夹角越小越相似，即方向相同。

如何体现向量的方向和长度呢？以一维向量为例：

向量：[-0.5]、[0.5]、[1]的方向和长度。

向量：[0.5, 0.5]

[0.7, 0.7]

[0.7, 0.5]

[0.5, -0.5]

[-0.5, -0.5]

[-0.6, 0.5]

的方向和长度

PS：3维乃至更高纬度难以描述，但概念一致

余弦相似度主要匹配的就是：同向（无所谓长度）

我们能直接发现

[0.5, 0.5]和[0.7, 0.7]是同向不同长那计算机如何判定就依赖余弦相似度算法了。

代码示例

import numpy as np
"""
计算两个向量的余弦相似度（衡量方向相似性，剔除长度影响）

参数：
    vec_a (np.array): 向量A
    vec_b (np.array): 向量B
返回：
    float: 余弦相似度结果（范围[-1,1]，越接近1方向越一致）
公式：
    cos_sim = (vec_a · vec_b) / (||vec_a|| × ||vec_b||)
    拆解：
    1. 点积：vec_a · vec_b = vec_a[0]×vec_b[0] + vec_a[1]×vec_b[1] + ... + vec_a[n]×vec_b[n]
    2. 模长：||vec_a|| = √(vec_a[0]² + vec_a[1]² + ... + vec_a[n]²)
    3. 模长：||vec_b|| = √(vec_b[0]² + vec_b[1]² + ... + vec_b[n]²)

A: [0.5, 0.5]
B: [0.7, 0.7]
C: [0.7, 0.5]
D: [-0.6, -0.5]
"""


def get_dot(vec_a, vec_b):
    """计算2个向量的点积，2个向量同维度数字乘积之和"""
    if len(vec_a) != len(vec_b):
        raise ValueError("2个向量必须维度数量相同")

    dot_sum = 0
    for a, b in zip(vec_a, vec_b):
        dot_sum += a * b

    return dot_sum


def get_norm(vec):
    """计算单个向量的模长：对向量的每个数字求平方再求和再开根号"""
    sum_square = 0
    for v in vec:
        sum_square += v * v

    # numpy sqrt函数完成开根号
    return np.sqrt(sum_square)


def cosine_similarity(vec_a, vec_b):
    """余弦相似度：2个向量的点积 除以 2个向量模长的乘积"""

    result = get_dot(vec_a, vec_b) / (get_norm(vec_a) * get_norm(vec_b))
    return result


if __name__ == '__main__':
    vec_a = [0.5, 0.5]
    vec_b = [0.7, 0.7]
    vec_c = [0.7, 0.5]
    vec_d = [-0.6, -0.5]

    print("ab:", cosine_similarity(vec_a, vec_b))
    print("ac:", cosine_similarity(vec_a, vec_c))
    print("ad:", cosine_similarity(vec_a, vec_d))

Langchain组件

Models：大语言模型的使用

现在市面上的模型多如牛毛，各种各样的模型不断出现，LangChain模型组件提供了与各种模型的集成，并为所有模型提供一个精简的统一接口。

LangChain目前支持三种类型的模型：LLMs（大语言模型）、Chat Models(聊天模型)、Embeddings Models(嵌入模型）.

LLMs:是技术范畴的统称，指基于大参数量、海量文本训练的 Transformer 架构模型，核心能力是理解和生成自然语言，主要服务于文本生成场景
聊天模型:是应用范畴的细分，是专为对话场景优化的 LLMs，核心能力是模拟人类对话的轮次交互，主要服务于聊天场景
文本嵌入模型: 文本嵌入模型接收文本作为输入, 得到文本的向量.LangChain支持的三类模型，它们的使用场景不同，输入和输出不同，开发者需要根据项目需要选择相应。

我们所用的阿里云通义千问系列主要来自于：langchain_community包

LLMs（阿里云大语言模型的访问）

LLMs使用场景最多，常用大模型的下载库：

同时LangChain支持对许多模型的调用，以通义千问为例：

from langchain_community.llms.tongyi import Tongyi
### 实例化模型
llm = Tongyi(model='qwen-max')
### 模型推理
res = llm.invoke("帮我讲个笑话吧")
print(res)

如果用的python太新了(比如我的是python3.14) - langchain-tongyi 尚未发布 3.14 的 wheel 包，所以无法安装。

会出现以下错误:

DeprecationWarning: langchain-community is being sunset and is no longer actively maintained. See https://github.com/langchain-ai/langchain-community/issues/674 for details and migration guidance toward standalone integration packages.

有两个解决方案：

方案一（推荐）：用 Python 3.10~3.12 运行项目

通义千问相关的 LangChain 包对 3.14 支持不完善，建议用 conda 或 pyenv 创建一个 3.11 环境：

conda create -n rag python=3.11 -y

conda activate rag

pip install langchain langchain-tongyi

方案二：忽略警告继续用旧包

当前代码功能上是正常的，DeprecationWarning 只是提醒 langchain-community 未来不再维护，现在还能用。如果只是学习用途，可以先忽略：

import warnings

warnings.filterwarnings("ignore", category=DeprecationWarning)

from langchain_community.llms.tongyi import Tongyi

如果要访问本地Ollama的模型，简单更改一下代码。

通过langchain_ollama包导入OllamaLLM类即可（请确保Ollama已经启动并提前下载好要使用的模型）。

from langchain_ollama import OllamaLLM
model = OllamaLLM(model="qwen3")

# 通过invoke方法去调用模型
res = model.invoke(input="你是谁呀能做什么？")

print(res)

Models的流失输出

如果需要流式输出结果，需要将模型的invoke方法改为stream方法即可。

invoke方法：一次型返回完整结果
stream方法：逐段返回结果流式输出

阿里云：

# langchain_community
from langchain_community.llms.tongyi import Tongyi

# 不用qwen3-max，因为qwen3-max是聊天模型，qwen-max是大语言模型
model = Tongyi(model="qwen-max")

# 调用invoke向模型提问
res = model.stream(input="你是谁呀能做什么？")

for chunk in res:
	print(chunk, end="", flush=True)

ollama：

from langchain_ollama import OllamaLLM

model = OllamaLLM(model="qwen3")

res = model.stream(input="你是谁呀能做什么？")

for chunk in res:
    print(chunk, end="", flush=True)

Models：聊天模型的使用

Chat Models

聊天消息包含下面几种类型，使用时需要按照约定传入合适的值：

AIMessage: 就是 AI 输出的消息，可以是针对问题的回答. (OpenAI库中的assistant角色）
HumanMessage: 人类消息就是用户信息，由人给出的信息发送给LLMs的提示信息，比如“实现一个快速排序方法”. (OpenAI库中的user角色）
SystemMessage: 可以用于指定模型具体所处的环境和背景，如角色扮演等。你可以在这里给出具体的指示，比如“作为一个代码专家”，或者“返回json格式”. (OpenAI库中的system角色）

单独使用HumanMessage

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage

# 得到模型对象, qwen3-max就是聊天模型
model = ChatTongyi(model="qwen3-max")

# 准备消息列表
messages = [
    HumanMessage(content="写一首唐诗"),
]

# 调用stream流式执行
res = model.stream(input=messages)

# for循环迭代打印输出，通过.content来获取到内容
for chunk in res:
    print(chunk.content, end="", flush=True)

SystemMessage + HumanMessage

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage

# 得到模型对象, qwen3-max就是聊天模型
model = ChatTongyi(model="qwen3-max")

# 准备消息列表
messages = [
    SystemMessage(content="你是一个边塞诗人。"),
    HumanMessage(content="写一首唐诗"),
]

# 调用stream流式执行
res = model.stream(input=messages)

# for循环迭代打印输出，通过.content来获取到内容
for chunk in res:
    print(chunk.content, end="", flush=True)

SystemMessage + HumanMessage + AIMessage

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage

# 得到模型对象, qwen3-max就是聊天模型
model = ChatTongyi(model="qwen3-max")

# 准备消息列表
messages = [
    SystemMessage(content="你是一个边塞诗人。"),
    HumanMessage(content="写一首唐诗"),
    AIMessage(content="锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦。"),
    HumanMessage(content="按照你上一个回复的格式，在写一首唐诗。")
]

# 调用stream流式执行
res = model.stream(input=messages)

# for循环迭代打印输出，通过.content来获取到内容
for chunk in res:
    print(chunk.content, end="", flush=True)

Models：消息的简写形式

SystemMessage、HumanMessage、AIMessage可以有如下的简写形式

原：

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage

# 得到模型对象, qwen3-max就是聊天模型
model = ChatTongyi(model="qwen3-max")

# 准备消息列表
messages = [
    SystemMessage(content="你是一个边塞诗人。"),
    HumanMessage(content="写一首唐诗"),
    AIMessage(content="锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦。"),
    HumanMessage(content="按照你上一个回复的格式，在写一首唐诗。")
]

# 调用stream流式执行
res = model.stream(input=messages)

# for循环迭代打印输出，通过.content来获取到内容
for chunk in res:
    print(chunk.content, end="", flush=True)

简：

# 得到模型对象, qwen3-max就是聊天模型
model = ChatTongyi(model="qwen3-max")
# 准备消息列表
messages = [
    #(角色，内容) 角色：system/human/ai
	("system", "你是一个边塞诗人。"),
    ("human", "写一首唐诗"),
    ("ai", "锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦。"),
    ("human", "按照你上一个回复的格式，再写一首唐诗。")
 ]
# for循环迭代打印输出，通过.content来获取到内容
for chunk in model.stream(input=messages):
	print(chunk.content, end="", flush=True)

通过2元元组封装信息；第一个元素为角色字符串：system/human/ai第二个元素为内容

区别和优势在于，使用类对象的方式，如下：

是静态的，一步到位

直接就得到了Message类的类对象

简写形式如下：

是动态的，需要在运行时

由LangChain内部机制转换为Message类对象

好处就在于，简写形式避免导包、写起来更简单，更重要的是支持：

由于是动态，需要转换步骤

所以简写形式支持内部填充{变量}占位

可在运行时填充具体值(后续学习提示词模板时用到）

Models：嵌入模型的使用

Embeddings Models(文本嵌入模型）

Embeddings Models嵌入模型的特点：将字符串作为输入，返回一个浮点数的列表（向量）。

在NLP中，Embedding的作用就是将数据进行文本向量化。

阿里云千问模型访问方式：

from langchain_community.embeddings import DashScopeEmbeddings

# 初始化嵌入模型对象，其默认使用模型是：text-embedding-v1
embed = DashScopeEmbeddings()

# 测试
# 单次转换
print(embed.embed_query("我喜欢你"))
# 批量转换
print(embed.embed_documents(['我喜欢你', '我稀饭你', '晚上吃啥']))

本地Ollama模型访问方式：

通过langchain_ollama导入OllamaEmbeddings使用，其余不变。

from langchain_ollama import OllamaEmbeddings


model = OllamaEmbeddings(model="qwen3-embedding")

# 不用invoke stream
# embed_query、embed_documents
print(model.embed_query("我喜欢你"))
print(model.embed_documents(["我喜欢你", "我稀饭你", "晚上吃啥"]))

在本地下载模型：

打开命令行，输入ollama pull 模型

目前所掌握的LangChain API如下：

方式	LLMs大语言模型	聊天模型	文本嵌入模型
阿里云千问	from langchain_community.llms.tongyi import Tongyi	from langchain_community.chat_models.tongyi import ChatTongyi	from langchain_community.embeddings import DashScopeEmbeddings
ollama本地模型	from langchain_ollama import OllamaLLM	from langchain_ollama import ChatOllama	from langchain_ollama import OllamaEmbeddings
反复噶	`invoke`批量 / `stream`流式	`invoke`批量 / `stream`流式	`embed_query`单次转换 / `embed_documents`批量转换

通用prompts【zero-shot】

提示词优化在模型应用中非常重要，LangChain提供了PromptTemplate类，用来协助优化提示词。

PromptTemplate表示提示词模板，可以构建一个自定义的基础提示词模板，支持变量的注入，最终生成所需的提示词。

标准写法：

from langchain_core.prompts import PromptTemplate
from langchain_community.llms.tongyi import Tongyi

prompt_template = PromptTemplate.from_template(
	“我的邻居姓{lastname}, 刚生了{gender}, 帮忙起名字，请简略回答。”
)

# 变量注入，生成提示词文本
prompt_text = prompt_template.format(lastname="张", gender="女儿")

model = Tongyi(model="qwen-max")        # 创建模型对象
res = model.invoke(input=prompt_text)   # 调用模型获取结果
print(res)

基于chain链的写法

from langchain_core.prompts import PromptTemplate
from langchain_community.llms.tongyi import Tongyi

#zero-shot
prompt_template = PromptTemplate.from_template(
	“我的邻居姓{lastname}, 刚生了{gender}, 帮忙起名字，请简略回答。”
)
model = Tongyi(model=“qwen-max”)        # 创建模型对象
# 生成链
chain = prompt_template | model
# 基于链，调用模型获取结果
res = chain.invoke(input={"lastname": "张", "gender": "女儿"})
print(res)

zero-sho思想下，可以基于PromptTemplate直接完成
few-shot思想下，需要更换为FewShotPromptTemplate

PS：使用PromptTemplate还不如自己手动拼接字符串？

使用Template模板构建提示词，在大型工程中更容易做标准化模板

Template模板类，支持LangChian框架的链式调用（Runnable接口）

PromptTemplate

FewShotPromptTemplate

ChatPromptTemplate

FewShotPromptTemplate的使用

from langchain_core.prompts import FewShotPromptTemplate

FewShotPromptTemplate(
	examples=None,
    example_prompt=None,
    prefix=None,
    suffix=None,
    input_variables=None
)

参数：

examples：示例数据，list，内套字典

example_prompt：示例数据的提示词模板

prefix：组装提示词，示例数据前内容

suffix：组装提示词，示例数据后内容

input_variables：列表，注入的变量列表

from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate
from langchain_community.llms.tongyi import Tongyi

# 示例的模板
example_template = PromptTemplate.from_template("单词：{word}, 反义词：{antonym}")

# 示例的动态数据注入 要求是list内部套字典
examples_data = [
    {"word": "大", "antonym": "小"},
    {"word": "上", "antonym": "下"},
]

few_shot_template = FewShotPromptTemplate(
    example_prompt=example_template,    # 示例数据的模板
    examples=examples_data,             # 示例的数据（用来注入动态数据的），list内套字典
    prefix="告知我单词的反义词，我提供如下的示例：",                   # 示例之前的提示词
    suffix="基于前面的示例告知我，{input_word}的反义词是？",          # 示例之后的提示词
    input_variables=['input_word']      # 声明在前缀或后缀中所需要注入的变量名（可以多个）
)

prompt_text = few_shot_template.invoke(input={"input_word": "左"}).to_string() # to_string()转为字符串输出
print(prompt_text)

# 创建模型对象
model = Tongyi(model="qwen-max")

print(model.invoke(input=prompt_text))

模板类的format和invoke方法

在PromptTemplate（通用提示词模板）和FewShotPromptTemplate（FewShot提示词模板）的使用中，我们使用了如下：

PromptTemplate、FewShotPromptTemplate、ChatPromptTemplate都拥有format和invoke这2类方法。

format和invoke的区别在于：

区别	format	invoke
功能	纯字符串替换	Runnable接口标准方法，解析占位符生辰提示词
返回值	字符串	PromptValue类对象
传参	.format(k=v，k=v，…)	.invoke({“k”:v，“k”:v，…})
解析	支持解析{}占位符	支持解析{}占位符和MessagePlaceholder结构化占位符

from langchain_core.prompts import PromptTemplate
from langchain_core.prompts import FewShotPromptTemplate
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.llms.tongyi import Tongyi
from langchain_community.chat_models.tongyi import ChatTongyi

# 模板继承关系
"""
PromptTemplate -> StringPromptTemplate -> BasePromptTemplate -> RunnableSerializable -> Runnable
FewShotPromptTemplate -> StringPromptTemplate -> BasePromptTemplate  -> RunnableSerializable -> Runnable
ChatPromptTemplate -> BaseChatPromptTemplate -> BasePromptTemplate  -> RunnableSerializable -> Runnable
Tongyi -> BaseLLM -> BaseLanguageModel -> RunnableSerializable -> Runnable
ChatTongyi -> BaseChatModel -> BaseLanguageModel -> RunnableSerializable -> Runnable
"""


template = PromptTemplate.from_template("我的邻居是：{lastname}，最喜欢：{hobby}")

res = template.format(lastname="张大明", hobby="钓鱼")
print(res, type(res))


res2 = template.invoke({"lastname": "周杰伦", "hobby": "唱歌"})
print(res2, type(res2))

ChatPromptTemplate的使用

**PromptTemplate：**通用提示词模板，支持动态注入信息。

**FewShotPromptTemplate：**支持基于模板注入任意数量的示例信息。

ChatPromptTemplate：支持注入任意数量的历史会话信息。

通过from_messages方法，从列表中获取多轮次会话作为聊天的基础模板
- PS: 前面PromptTemplate类用的from_template仅能接入一条消息，而from_messages可以接入一个list的消息

历史会话信息并不是静态的（固定的），而是随着对话的进行不停地积攒，即动态的。所以，历史会话信息需要支持动态注入。

MessagePlaceholder作为占位
- 提供history作为占位的key
基于invoke动态注入历史会话记录

必须是invoke，format无法注入

代码示例

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_models.tongyi import ChatTongyi

chat_prompt_template = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个边塞诗人，可以作诗。"),
        MessagesPlaceholder("history"),
        ("human", "请再来一首唐诗"),
    ]
)

history_data = [
    ("human", "你来写一首唐诗"),
    ("ai", "床前明月光，疑是地上霜，举头望明月，低头思故乡"),
    ("human", "好诗再来一首"),
    ("ai", "锄禾日当午，汗滴禾下锄，谁知盘中餐，粒粒皆辛苦"),
]

# invoke的返回类型是StringPromptValue → to_string() 变为字符串
prompt_text = chat_prompt_template.invoke({"history": history_data}).to_string()

#聊天模型
model = ChatTongyi(model="qwen3-max")

res = model.invoke(prompt_text)

print(res.content, type(res))# .content的作用是只取模型返回的内容

也可以基于聊天模型，并组装聊天历史的模式，做提示词工程。

few-shot提示方式：求反义词 examples = [ {“word”: “开心”, “antonym”: “难过”}, {“word”: “高”, “antonym”: “矮”}, ]

chain链的基础使用

「将组件串联，上一个组件的输出作为下一个组件的输入」是 LangChain 链（尤其是 | 管道链）的核心工作原理，这也是链式调用的核心价值：实现数据的自动化流转与组件的协同工作，如下。

chain = prompt_template | model

核心前提：即Runnable子类对象才能入链（以及Callable、Mapping接口子类对象也可加入（后续了解用的不多））。

我们目前所学习到的组件，均是Runnable接口的子类，如下类的继承关系：

通过|链接提示词模板对象和模型对象
返回值chain对象是RunnableSerializable对象
- 是Runnable接口的直接子类
- 也是绝大多数组件的父类
通过invoke或stream进行阻塞执行或流式执行

组成的链在执行上有：上一个组件的输出作为下一个组件的输入的特性。

所以有如下执行流程：

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_models.tongyi import ChatTongyi

chat_prompt_template = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个边塞诗人，可以作诗。"),
        MessagesPlaceholder("history"),
        ("human", "请再来一首唐诗"),
    ]
)

history_data = [
    ("human", "你来写一个唐诗"),
    ("ai", "床前明月光，疑是地上霜，举头望明月，低头思故乡"),
    ("human", "好诗再来一个"),
    ("ai", "锄禾日当午，汗滴禾下锄，谁知盘中餐，粒粒皆辛苦"),
]

model = ChatTongyi(model="qwen3-max")

# 组成链，要求每一个组件都是Runnable接口的子类
chain = chat_prompt_template | model #| xxx | xxx | model2 | model3 | ...

# 通过链去调用invoke或stream
# 通过invoke去触发链条，原始输入是"history": history_data（提供给chat_prompt_template）
# 然后再给到model
# res = chain.invoke({"history": history_data})
# print(res.content)

# 通过stream流式输出
for chunk in chain.stream({"history": history_data}):
    print(chunk.content, end="", flush=True)

RAG（前置准备）

Wed, 01 Jul 2026 13:41:02 +0800

本篇博客为学习RAG的前置准备

RAG前置准备

大模型接入

大模型接入有两种方法：

此处学习所用，就使用第二种方法了

1.输入百炼网址

大模型服务平台百炼控制台

2.注册/登录

3.创建自己的API Key

代码调用云端大模型

创建API Key
通过pip为Python程序提供OpenAI库：pip install openai（如果pip用不了，就用python -m pip install openai）
编写代码测试（可从百炼平台官网复制代码，直接执行）

注意：要将代码中的APIKEY替换为自己的

点击运行：

如果想要更换模型，只需要将代码中的model替换为自己需要的模型即可

那么如何进行配置呢？（win）

打开电脑的高级系统设置，在环境变量中的用户变量中新建两个变量：OPENAI_API_KEY和DASHSCOPE_API_KEY，将自己的api_key输入进去并保存。
保存完以后就可以将项目中的APIKEY那行代码删除了，然后重启电脑进行测试

以后写代码就不用明文的将APIKEY写出来了，这样既安全又方便

Ollama简介

官网：Ollama

如何查看ollama支持的模型？

通过ollama官方模型库：https://ollama.com/library

Ollama的部署

Ollama的部署还是很简单的，只需要进入官方网站点击Download按钮下载安装。

安装完成后，通过命令：

ollama run 模型名称

即可运行对应的模型，并在命令行内做交互

也可以在安装完成后直接打开ollama，然后在控制台直接进行交互。不过需要注意的是最好将下载地址更改一下，一般原始的下载地址在C盘，对于C盘空间不太友好的人不太方便。（因为里面的模型需要下载才能使用）

使用代码调用ollama

注意：需要将本地的ollama启动起来才可以在编译器中调用

使用ollama仅为备用方案，是为了如果阿里云免费额度用完了，又或者阿里云不再提供免费的活动了时进行使用

OpenAI库基础使用

OpenAI的基础使用

获取客户端对象

调用模型

处理结果

代码示例

注意：一般把AI的性格（system）设定为话不多，否则消耗的Token会很多

from urllib import response

from httpx import Client
from openai import OpenAI
# 1.获取Client对象
Client  = OpenAI(
    base_url="https://ws-bt194c2c9a0aiu59.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
)

# 2.调用模型
response = Client.chat.completions.create(
    model="qwen3-max",
    messages=[
        {"role": "system", "content": "你是一个Python编程专家，并且不说废话简单回答"},# 设置AI性格
        {"role": "assistant", "content": "好的，我是编程专家，并且话不多，你要问什么？"},
        {"role": "user", "content": "输出1-10的数字，使用pyhton代码"}
    ]
)

# 3.处理结果
print(response.choices[0].message.content)

OpenAI库的流式输出

代码示例

from urllib import response

from httpx import Client
from openai import OpenAI
# 1.获取Client对象
Client  = OpenAI(
    base_url="https://ws-bt194c2c9a0aiu59.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
)

# 2.调用模型
response = Client.chat.completions.create(
    model="qwen3-max",
    messages=[
        {"role": "system", "content": "你是一个Python编程专家，并且话非常多"},
        {"role": "assistant", "content": "好的，我是编程专家，并且话不多，你要问什么？"},
        {"role": "user", "content": "输出1-10的数字，使用pyhton代码"}
    ],
    stream=True
)

# 3.处理结果
# print(response.choices[0].message.content)
for chunk in response:
    print(chunk.choices[0].delta.content,
          end=" ", # 每一段之间以空格分隔
          flush=True # 立刻刷新缓冲区
    )

OpenAI库附带历史消息调用模型

代码示例

from urllib import response

from httpx import Client
from openai import OpenAI

# 1.获取Client对象
Client = OpenAI(
    base_url="https://ws-bt194c2c9a0aiu59.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
)

# 2.调用模型
response = Client.chat.completions.create(
    model="qwen3-max",
    messages=[
        {"role": "system", "content": "你是一个AI助理，回答很简洁，不要使用Markdown格式"},
        {"role": "user", "content": "小明有两条宠物狗"},
        {"role": "assistant", "content": "好的"},
        {"role": "user", "content": "小红有三只宠物猫"},
        {"role": "assistant", "content": "好的"},
        {"role": "user", "content": "总共有多少只宠物"},
    ],
    stream=True
)

# 3.处理结果
for chunk in response:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    # 打印思考过程（如果有）
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
        print(delta.reasoning_content, end="", flush=True)
    # 打印正式回答（过滤掉 None）
    if delta.content:
        print(delta.content, end="", flush=True)

提示词工程

大模型prompt工程指南

提示词工程概念

提示词技巧

任何Prompt技巧，都不如清晰的表达你的需求。这就类似人与人沟通，如果话都说不明白，不可能让别人理解你的思想。因此，写出清晰的指令，是核心。

技巧1：详细的描述

技巧2：让模型充当某个角色

技巧3：使用分隔符标明输入的不同部分

中括号、XML标签、三引号等分隔符可以帮助划分要区别对待的文本，也可以帮助模型更好的理解文本内容。常用’‘‘‘‘‘把内容框起来

技巧4：对任务指定步骤

对于可以拆分的任务可以尽量拆开，最好能为其指定一系列步骤，明确步骤可以让模型更容易实现它们。

技巧5：提供例子

本质类似于few-shot learning。先扔给大模型举例，然后让模型按照例子来输出

基于文本文档，辅助大模型回答，降低模型“幻觉”（一本正经的胡说八道）问题。

即使用参考文本作答 经典的知识库用法，让大模型使用我们提供的信息来组成答案。

实战案例

背景

Zero-shot思想

Few-shot思想

LLM文本分类

任务介绍

Prompt设计

代码示例

from openai import OpenAI

# 1. 获取client对象，OpenAI类对象
client = OpenAI(
     base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
     # 基于本地ollama运行
     # base_url="http://localhost:11434/v1"
)

examples_data = {  # 示例数据
    '新闻报道': '今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。',
    '财务报告': '本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。',
    '公司公告': '本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力',
    '分析师报告': '最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势'
}
# 分类列表
examples_types = ['新闻报道', '财务报道', '公司公告', '分析师报告']

# 提问数据
questions = [
    "今日，央行发布公告宣布降低利率，以刺激经济增长。这一降息举措将影响贷款利率，并在未来几个季度内对金融市场产生影响。",
    "ABC公司今日发布公告称，已成功完成对XYZ公司股权的收购交易。本次交易是ABC公司在扩大业务范围、加强市场竞争力方面的重要举措。据悉，此次收购将进一步巩固ABC公司在行业中的地位，并为未来业务发展提供更广阔的发展空间。详情请见公司官方网站公告栏",
    "公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。",
    "最新的分析报告指出，可再生能源行业预计将在未来几年经历持续增长，投资者应该关注这一领域的投资机会",
    "小明喜欢小新哟"
]

"""
[
    {"role": "system",      "content": "你是金融专家，将文本分类为['新闻报道', '财务报道', '公司公告', '分析师报告']，不清楚的分类为'不清楚类别' 下面有示例："},

    {"role": "user",        "content": "今日，央行发布公告宣布降............."},
    {"role": "assistant",   "content": "新闻报道"},
    {"role": "user",        "content": "ABC公司今日发布公告称，已成功完成对XYZ公司股................."},
    {"role": "assistant",   "content": "财务报告},
    {"role": "user",        "content": "公司资产负债表显示，公司偿债能力强劲，现金流充足..................."},
    {"role": "assistant",   "content": "公司公告"},
    {"role": "user",        "content": "最新的分析报告指出，可再生能源............."},
    {"role": "assistant",   "content": "分析师报告"},

    {"role": "user",        "content": "要提问的问题"}
]
"""

messages = [
    {"role": "system",
     "content": "你是金融专家，将文本分类为['新闻报道', '财务报道', '公司公告', '分析师报告']，不清楚的分类为'不清楚类别' 下面有示例："},
]

for key, value in examples_data.items():
    messages.append({"role": "user", "content": value})
    messages.append({"role": "assistant", "content": key})

# 向模型提问
for q in questions:
    response = client.chat.completions.create(
         model="qwen3-max",
         # model="qwen3",
        messages=messages + [{"role": "user", "content": f"按照示例，回答这段文本的分类类别：{q}"}]
    )

    print(response.choices[0].message.content)

Json数据格式

Python中使用Json

import json

d = {
    "name": "周杰轮",
    "age": 11,
    "gender": "男"
}
# print(str(d)) 输出格式为单引号，json标准格式为双引号
s = json.dumps(d, ensure_ascii=False) #防止中文乱码
print(s)

l = [
    {
        "name": "周杰轮",
        "age": 11,
        "gender": "男"
    },
    {
        "name": "蔡依临",
        "age": 12,
        "gender": "女"
    },
    {
        "name": "小明",
        "age": 16,
        "gender": "男"
    }
]

print(json.dumps(l, ensure_ascii=False))

json_str = '{"name": "周杰轮", "age": 11, "gender": "男"}'
json_array_str = '[{"name": "周杰轮", "age": 11, "gender": "男"}, {"name": "蔡依临", "age": 12, "gender": "女"}, {"name": "小明", "age": 16, "gender": "男"}]'


res_dict = json.loads(json_str)
print(res_dict, type(res_dict))

res_list = json.loads(json_array_str)
print(res_list, type(res_list))

LLM信息抽取

任务介绍

Prompt设计

代码示例

from openai import OpenAI
import json

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
    # base_url="http://localhost:11434/v1"
)

schema = ['日期', '股票名称', '开盘价', '收盘价', '成交量']
examples_data = [  # 示例数据
    {
        "content": "2023-01-10，股市震荡。股票强大科技A股今日开盘价100人民币，一度飙升至105人民币，随后回落至98人民币，最终以102人民币收盘，成交量达到520000。",
        "answers": {
            "日期": "2023-01-10",
            "股票名称": "强大科技A股",
            "开盘价": "100人民币",
            "收盘价": "102人民币",
            "成交量": "520000"
        }
    },
    {
        "content": "2024-05-16，股市利好。股票英伟达美股今日开盘价105美元，一度飙升至109美元，随后回落至100美元，最终以116美元收盘，成交量达到3560000。",
        "answers": {
            "日期": "2024-05-16",
            "股票名称": "英伟达美股",
            "开盘价": "105美元",
            "收盘价": "116美元",
            "成交量": "3560000"
        }
    }
]
questions = [  # 提问问题
    "2025-06-16，股市利好。股票传智教育A股今日开盘价66人民币，一度飙升至70人民币，随后回落至65人民币，最终以68人民币收盘，成交量达到123000。",
    "2025-06-06，股市利好。股票黑马程序员A股今日开盘价200人民币，一度飙升至211人民币，随后回落至201人民币，最终以206人民币收盘。"
]

"""
[
    {"role": "system",      "content": f"你帮我完成信息抽取，我给你句子，你抽取{schema}信息，按JSON字符串输出，如果某些信息不存在，用'原文未提及'表示，请参考如下示例："},

    {"role": "user",        "content": "2023-01-10，股市震荡。股票强大科技A股今日开盘价100人民币，一度飙升至105人民币，随后回落至98人民币，最终以102人民币收盘，成交量达到520000。"},
    {"role": "assistant",   "content": '{"日期":"2023-01-10","股票名称":"强大科技A股","开盘价":"100人民币","收盘价":"102人民币","成交量":"520000"}'},
    {"role": "user",        "content": "2024-05-16，股市利好。股票英伟达美股今日开盘价105美元，一度飙升至109美元，随后回落至100美元，最终以116美元收盘，成交量达到3560000。"},
    {"role": "assistant",   "content": '{"日期":"2024-05-16","股票名称":"英伟达美股","开盘价":"105美元","收盘价":"116美元","成交量":"3560000"}'},

    {"role": "user",        "content": f"按照上述示例，现在抽取这个句子的信息：{要抽取的句子文本}"}]}
]
"""

messages = [
    {"role": "system",
     "content": f"你帮我完成信息抽取，我给你句子，你抽取{schema}信息，按JSON字符串输出，如果某些信息不存在，用'原文未提及'表示，请参考如下示例："}
]

for example in examples_data:
    messages.append(
        {"role": "user", "content": example["content"]}
    )

    messages.append(
        {"role": "assistant", "content": json.dumps(example["answers"], ensure_ascii=False)}
    )

for q in questions:
    response = client.chat.completions.create(
        model="qwen3-max",
        messages=messages + [{"role": "user", "content": f"按照上述的示例，现在抽取这个句子的信息：{q}"}]
    )

    print(response.choices[0].message.content)

LLM信息文本匹配

任务介绍

Prompt设计

代码示例

from openai import OpenAI

client = OpenAI(
     base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
    # base_url="http://localhost:11434/v1"
)

examples_data = {
    "是": [
        ("公司ABC发布了季度财报，显示盈利增长。", "财报披露，公司ABC利润上升。"),
        ("公司ITCAST发布了年度财报，显示盈利大幅度增长。", "财报披露，公司ITCAST更赚钱了。")
    ],
    "不是": [
        ("黄金价格下跌，投资者抛售。", "外汇市场交易额创下新高。"),
        ("央行降息，刺激经济增长。", "新能源技术的创新。")
    ]
}

questions = [
    ("利率上升，影响房地产市场。", "高利率对房地产有一定的冲击。"),
    ("油价大幅度下跌，能源公司面临挑战。", "未来智能城市的建设趋势越加明显。"),
    ("股票市场今日大涨，投资者乐观。", "持续上涨的市场让投资者感到满意。")
]

"""
    {"role": "system",      "content": f"你帮我完成文本匹配，我给你2个句子，被[]包围，你判断它们是否匹配，回答是或不是，请参考如下示例："},
     
    {"role": "user",        "content": "句子1：[公司ABC发布了季度财报，显示盈利增长。]句子2：[财报披露，公司ABC利润上升。]"},
    {"role": "assistant",   "content": "是"},
    {"role": "user",        "content": "句子1：[公司ITCAST发布了年度财报，显示盈利大幅度增长。]句子2：[财报披露，公司ITCAST更赚钱了。]"},
    {"role": "assistant",   "content": "是"},
    {"role": "user",        "content": "句子1：[黄金价格下跌，投资者抛售。]句子2：[外汇市场交易额创下新高。]"},
    {"role": "assistant",   "content": "不是"},
    {"role": "user",        "content": "句子1：[央行降息，刺激经济增长。]句子2：[新能源技术的创新。]"},
    {"role": "assistant",   "content": "不是"}, 
    
    {"role": "user",        "content": f"按照上述示例，回答这2个句子的情况。句子1: [...]，句子2: [...]"}
"""

messages = [
    {"role": "system", "content": f"你帮我完成文本匹配，我给你2个句子，被[]包围，你判断它们是否匹配，回答是或不是，请参考如下示例："},
]

for key, value in examples_data.items():
    for t in value:
        messages.append(
            {"role": "user", "content": f"句子1：[{t[0]}]，句子2：[{t[1]}]"}
        )
        messages.append(
            {"role": "assistant", "content": key}
        )

for q in questions:
    response = client.chat.completions.create(
        model="qwen3-max",
        messages=messages + [{"role": "user", "content": f"句子1：[{q[0]}]，句子2：[{q[1]}]"}]
    )

    print(response.choices[0].message.content)

Docker

Sat, 30 May 2026 08:38:52 +0800

Docker

在学习完Linux的常见命令，安装软件，以及如何部署一个单体项目后，对于Linux的最大感受就是麻烦，核心体现在三点：

命令太多了，记不住
软件安装包名字复杂，不知道去哪里找
安装和部署步骤复杂，容易出错

上述问题在运维时进行安装、部署的时候一样会觉得麻烦、容易出错

今天要学习的Docker技术能够避免部署对服务器环境的依赖，减少复杂的部署流程

通过今天的学习，要能够达成下面的学习目标：

能利用Docker部署常见软件

能利用Docker打包并部署Java应用

理解Docker数据卷的基本作用

能看懂DockerCompose文件

快速入门

要想让Docker帮我们安装和部署软件，肯定要保证你的机器上有Docker。由于大家的操作系统各不相同，安装方式也不同。在Linux的学习中，根据资料提供的CentOS的虚拟机中已经安装了Docker，统一学习环境

如果大家需要自己在别的机器上安装Docker环境，可以参照最后的 附录中的：Docker安装文档

在学习Docker的时候，先将前面Linux中的进程关闭，可以通过ps -ef|grep nginx和ps -ef|grep java来查看对应的进程并杀死，还有关闭mysql

部署MySQL

首先，我们利用Docker来安装一个MySQL软件，大家可以对比一下之前传统的安装方式，看看哪个效率更高一些。

如果是利用传统方式部署MySQL，大概的步骤有：

搜索并下载MySQL安装包
上传至Linux环境
解压和配置环境
安装
初始化和配置

而使用Docker安装，仅仅需要一步即可，在命令行输入下面的命令（建议采用CV大法）：

注意：使用时应该先启动docker：systemctl start docker

docker run -d \
  --name mysql \
  -p 3307:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=123 \
  mysql:8

运行效果如图：

MySQL安装完毕！通过任意客户端工具即可连接到MySQL。

以下为通过CMD连接到MySQL

说明：

其实，当我们执行命令后，Docker做的第一件事情，是去自动搜索并下载了MySQL，然后会自动运行MySQL，我们完全不用插手，是非常方便的。

而且，这种安装方式你完全不用考虑运行的操作系统环境，它不仅仅在CentOS系统是这样，在Ubuntu系统、macOS系统、甚至是装了WSL的Windows下，都可以使用这条命令来安装MySQL 。

要知道，不同操作系统下其安装包、运行环境是都不相同的！如果是手动安装，必须手动解决安装包不同、环境不同的、配置不同的问题！

而使用Docker，这些完全不用考虑。就是因为Docker会自动搜索并下载MySQL。

注意：

这里下载的不是安装包，而是镜像。镜像中不仅包含了MySQL本身，还包含了其运行所需要的环境、配置、系统级函数库。因此它在运行时就有自己独立的环境，就可以跨系统运行，也不需要手动再次配置环境了。这套独立运行的隔离环境我们称为容器。

说明：

镜像：英文是image
容器：英文是container

因此，Docker安装软件的过程，就是自动搜索下载镜像，然后创建并运行容器的过程。

Docker会根据命令中的镜像名称自动搜索并下载镜像，那么问题来了，它是去哪里搜索和下载镜像的呢？这些镜像又是谁制作的呢？

Docker官方提供了一个专门管理、存储镜像的网站，并对外开放了镜像上传、下载的权利。Docker官方提供了一些基础镜像，然后各大软件公司又在基础镜像基础上，制作了自家软件的镜像，全部都存放在这个网站。这个网站就成了Docker镜像交流的社区：https://hub.docker.com

基本上我们常用的各种软件都能在这个网站上找到，我们甚至可以自己制作镜像上传上去。【但是该网站，目前国内上不去了】（但是有魔法的话，还是可以上去的）

像这种提供存储、管理Docker镜像的服务器，被称为DockerRegistry，可以翻译为镜像仓库。DockerHub网站是官方仓库，阿里云、华为云会提供一些第三方仓库，我们也可以自己搭建私有的镜像仓库。

官方仓库在国外，下载速度较慢，一般我们都会使用第三方仓库提供的镜像加速功能，提高下载速度。而企业内部的机密项目，往往会采用私有镜像仓库。

总之，镜像的来源有两种：

基于官方基础镜像自己制作
直接去DockerRegistry下载

总结一下：

Docker本身包含一个后台服务，我们可以利用Docker命令告诉Docker服务，帮助我们快速部署指定的应用。Docker服务部署应用时，首先要去搜索并下载应用对应的镜像，然后根据镜像创建并允许容器，应用就部署完成了。

用一幅图表示如下：

命令解读

利用Docker快速的安装了MySQL，非常的方便，不过我们执行的命令到底是什么意思呢？

docker run -d \
  --name mysql \
  -p 3307:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=123 \
  mysql:8

解读：

docker run -d ：创建并运行一个容器，-d则是让容器以后台进程运行

--name mysql : 给容器起个名字叫mysql，你可以叫别的

-p 3307:3306 : 设置端口映射。

容器是隔离环境，外界不可访问。但是可以将宿主机端口映射容器内到端口，当访问宿主机指定端口时，就是在访问容器内的端口了。

容器内端口往往是由容器内的进程决定，例如MySQL进程默认端口是3306，因此容器内端口一定是3306；而宿主机端口则可以任意指定，一般与容器内保持一致。

格式： -p 宿主机端口:容器内端口，示例中就是将宿主机的3307映射到容器内的3306端口

-e TZ=Asia/Shanghai : 配置容器内进程运行时的一些参数

格式：-e KEY=VALUE，KEY和VALUE都由容器内进程决定

案例中，TZ=Asia/Shanghai是设置时区；MYSQL_ROOT_PASSWORD=123是设置MySQL默认密码

可以到官网去查看有哪些参数配置

mysql:8 : 设置镜像名称，Docker会根据这个名字搜索并下载镜像

格式：REPOSITORY:TAG，例如mysql:8.0，其中REPOSITORY可以理解为镜像名，TAG是版本号

在未指定TAG的情况下，默认是最新版本，也就是mysql:latest

镜像的名称不是随意的，而是要到DockerRegistry中寻找，镜像运行时的配置也不是随意的，要参考镜像的帮助文档，这些在DockerHub网站或者软件的官方网站中都能找到。

如果我们要安装其它软件，也可以到DockerRegistry中寻找对应的镜像名称和版本，阅读相关配置即可。

Docker基础

接下来，我们一起来学习Docker使用的一些基础知识，为将来部署项目打下基础。

常见命令

命令介绍

其中，比较常见的命令有：

命令	说明	文档地址
docker pull	拉取镜像	docker pull
docker push	推送镜像到DockerRegistry	docker push
docker images	查看本地镜像	docker images
docker rmi	删除本地镜像	docker rmi
docker run	创建并运行容器（不能重复创建）	docker run
docker stop	停止指定容器	docker stop
docker start	启动指定容器	docker start
docker restart	重新启动容器	docker restart
docker rm	删除指定容器	docs.docker.com
docker ps	查看容器	docker ps
docker logs	查看容器运行日志	docker logs
docker exec	进入容器	docker exec
docker save	保存镜像到本地压缩文件	docker save
docker load	加载本地压缩文件到镜像	docker load
docker inspect	查看容器详细信息	docker inspect

用一副图来表示这些命令的关系：

补充：

默认情况下，每次重启虚拟机我们都需要手动启动Docker和Docker中的容器。通过命令可以实现开机自启：

# Docker开机自启
systemctl enable docker

# Docker容器开机自启
docker update --restart=always [容器名/容器id]

演示

我们以Nginx为例给大家演示上述命令。

需求：

# 第1步，去DockerHub查看nginx镜像仓库及相关信息

# 第2步，拉取Nginx镜像 (比较耗时)
docker pull nginx:1.20.2

# 第3步，查看镜像
docker images

# 第4步，创建并允许Nginx容器
docker run -d --name nginx -p 80:80 nginx

# 第5步，查看运行中容器
docker ps

# 也可以加格式化方式访问，格式会更加清爽
docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"

# 第6步，访问网页，地址：http://虚拟机地址（192.168.240.128）

# 第7步，停止容器
docker stop nginx

# 第8步，查看所有容器
docker ps -a 

# 第9步，再次启动nginx容器
docker start nginx

# 第10步，再次查看容器
docker ps 

# 第11步，查看容器详细信息
docker inspect nginx

# 第12步，进入容器,查看容器内目录
docker exec -it nginx bash

# 或者，可以进入MySQL
docker exec -it mysql mysql -uroot -p

# 第13步，删除容器
docker rm nginx

# 发现无法删除，因为容器运行中，强制删除容器（容器名/容器ID）
docker rm -f nginx

拉取完Nginx可以通过docker save -o nginx-版本号.tar nginx:版本号来进行保存，然后打开文件所在就可以将其下载到本地，然后就可以将这个.tar文件发给其他人，其他人通过上传到自己的Linux上，使用docker load -i nginx-版本号.tar恢复成镜像

每个容器可以被当成是一个小的系统，它是具备自己的文件系统以及网络环境的

数据卷

容器是隔离环境，容器内程序的文件、配置、运行时产生的容器都在容器内部，我们要读写容器内的文件非常不方便。大家思考几个问题：

如果要升级MySQL版本，需要销毁旧容器，那么数据岂不是跟着被销毁了？
MySQL、Nginx容器运行后，如果我要修改其中的某些配置该怎么办？
我想要让Nginx代理我的静态资源怎么办？

因此，容器提供程序的运行环境，但是 程序运行产生的数据、程序运行依赖的配置都应该与容器解耦。

介绍

数据卷（volume）是一个虚拟目录，是容器内目录与宿主机目录之间映射的桥梁。

以Nginx为例，我们知道Nginx中有两个关键的目录：

html：放置一些静态资源
conf：放置配置文件

如果我们要让Nginx代理我们的静态资源，最好是放到html目录；如果我们要修改Nginx的配置，最好是找到conf下的nginx.conf文件。

但遗憾的是，容器运行的Nginx所有的文件都在容器内部。所以我们必须利用数据卷将两个目录与宿主机目录关联，方便我们操作。

如图：

在上图中：

我们创建了两个数据卷：conf、html
Nginx容器内部的conf目录和html目录分别与两个数据卷关联。
而数据卷conf和html分别指向了宿主机的/var/lib/docker/volumes/conf/_data目录和/var/lib/docker/volumes/html/_data目录

这样一来，容器内的conf和html目录就与宿主机的conf和html目录关联起来，我们称为挂载。

此时，我们操作宿主机的/var/lib/docker/volumes/html/_data就是在操作容器内的/usr/share/nginx/html/_data目录。只要我们将静态资源放入宿主机对应目录，就可以被Nginx代理了。

小提示：

/var/lib/docker/volumes这个目录就是默认的存放所有容器数据卷的目录，其下再根据数据卷名称创建新目录，格式为/数据卷名/_data。

为什么不让容器目录直接指向宿主机目录呢？

因为直接指向宿主机目录就与宿主机强耦合了，如果切换了环境，宿主机目录就可能发生改变了。由于容器一旦创建，目录挂载就无法修改，这样容器就无法正常工作了。

但是容器指向数据卷，一个逻辑名称，而数据卷再指向宿主机目录，就不存在强耦合。如果宿主机目录发生改变，只要改变数据卷与宿主机目录之间的映射关系即可。

不过，我们通过由于数据卷目录比较深，不好寻找，通常我们也允许让容器直接与宿主机目录挂载而不使用数据卷，具体参考2.2.3小节。

命令

数据卷的相关命令有：【可以直接使用命令 docker volume –help进行查看】

命令	说明	文档地址
docker volume create	创建数据卷	docker volume create
docker volume ls	查看所有数据卷	docs.docker.com
docker volume rm	删除指定数据卷	docs.docker.com
docker volume inspect	查看某个数据卷的详情	docs.docker.com
docker volume prune	清除数据卷	docker volume prune

注意：容器与数据卷的挂载要在创建容器时配置，对于创建好的容器，是不能设置数据卷的。而且创建容器的过程中，数据卷会自动创建。

在执行docker run命令时，使用-v 数据卷:容器内目录形式可以完成数据卷挂载

演示环节：演示一下nginx的html目录挂载

# 1.首先创建容器并指定数据卷，注意通过 -v 参数来指定数据卷（静态资源存放目录：/usr/share/nginx/html）
docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx:1.20.2

# 2.然后查看容器
docker  ps

# 3.然后查看数据卷（可以新开一个标签进行查看数据卷中的内容）
docker volume ls

# 4.查看数据卷详情
docker volume inspect html


# 4.查看/var/lib/docker/volumes/html/_data目录
ll /var/lib/docker/volumes/html/_data
#或cd /var/lib/docker/volumes/
#然后ll进行查看

# 5.进入该目录，并随意修改index.html内容
cd /var/lib/docker/volumes/html/_data
vi index.html

# 6.打开页面，查看效果

# 7.进入新开标签中容器内部，查看/usr/share/nginx/html目录内的文件是否变化
docker exec -it nginx bash
cd /usr/share/nginx/html/
ls -l
cat index.html

教学演示环节：演示一下MySQL的匿名数据卷

# 1.查看MySQL容器详细信息
docker inspect mysql

# 关注其中.Config.Volumes部分和.Mounts部分

我们关注两部分内容，第一是.Config.Volumes部分：

{
  "Config": {
    // ... 略
    "Volumes": {
      "/var/lib/mysql": {}
    }
    // ... 略
  }
}

可以发现这个容器声明了一个本地目录，需要挂载数据卷，但是数据卷未定义。这就是匿名卷。

然后，我们再看结果中的.Mounts部分：

{
  "Mounts": [
    {
      "Type": "volume",
      "Name": "29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f",
      "Source": "/var/lib/docker/volumes/29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f/_data",
      "Destination": "/var/lib/mysql",
      "Driver": "local",
    }
  ]
}

可以发现，其中有几个关键属性：

Name：数据卷名称。由于定义容器未设置容器名，这里的就是匿名卷自动生成的名字，一串hash值。
Source：宿主机目录
Destination : 容器内的目录

上述配置是将容器内的/var/lib/mysql这个目录，与数据卷29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f挂载。于是在宿主机中就有了/var/lib/docker/volumes/29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f/_data这个目录。这就是匿名数据卷对应的目录，其使用方式与普通数据卷没有差别。

接下来，可以查看该目录下的MySQL的data文件：

`1`	`ls -l /var/lib/docker/volumes/29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f/_data`

匿名数据卷作用：数据备份

注意：每一个不同的镜像，将来创建容器后内部有哪些目录可以挂载，可以参考DockerHub对应的页面。

挂载本地目录或文件

可以发现，数据卷的目录结构较深，如果我们去操作数据卷目录会不太方便。在很多情况下，我们会直接将容器目录与宿主机指定目录挂载。挂载语法与数据卷类似：

# 挂载本地目录
docker run -d --name 容器名 -p 宿主机端口:容器端口 -v 本地目录:容器内目录

# 挂载本地文件
-v 本地文件:容器内文件

注意：本地目录或文件必须以 / 或 ./开头，如果直接以名字开头，会被识别为数据卷名而非本地目录名。

例如：

1
2
3

-v mysql:/var/lib/mysql # 会被识别为一个数据卷叫mysql，运行时会自动创建这个数据卷

-v ./mysql:/var/lib/mysql # 会被识别为当前目录下的mysql目录，运行时如果不存在会创建目录

演示，删除并重新创建mysql容器，并完成本地目录挂载：

挂载/root/mysql/data到容器内的/var/lib/mysql目录
挂载/root/mysql/init到容器内的/docker-entrypoint-initdb.d目录（初始化的SQL脚本目录）
挂载/root/mysql/conf到容器内的/etc/mysql/conf.d目录（这个是MySQL配置文件目录）

在课前资料中已经准备好了mysql 的init目录、conf目录、data目录，可以直接将其上传到Linux服务器中的 /root/mysql 目录下。

最终执行的指令如下：

#停止容器：查看正在运行的容器，找到 MySQL 的容器 ID 或名称：
docker ps -a
#删除容器：
docker rm <容器名或ID>
#查看残留的数据卷：
docker volume ls
#删除数据卷
docker volume rm <数据卷ID>

docker run -d \
--name mysql \
-p 3307:3306 \
-e MYSQL_ROOT_PASSWORD=123 \
-e TZ=Asia/Shanghai \
-v /root/mysql/data:/var/lib/mysql \
-v /root/mysql/init:/docker-entrypoint-initdb.d \
-v /root/mysql/conf:/etc/mysql/conf.d \
mysql:8

#检验
docker ps
cd data/
ll
#cmd查看
mysql -h 192.168.240.128 -P3307 -uroot -p123

自定义镜像

前面我们一直在使用别人准备好的镜像，那如果我要部署一个Java项目，把它打包为一个镜像该怎么做呢？那接下来，我们就来介绍一下如何自定义镜像。

镜像结构

要想自己构建镜像，必须先了解镜像的结构。

之前我们说过，镜像之所以能让我们快速跨操作系统部署应用而忽略其运行环境、配置，就是因为镜像中包含了程序运行需要的系统函数库、环境、配置、依赖。

因此，自定义镜像本质就是依次准备好程序运行的基础环境、依赖、应用本身、运行配置等文件，并且打包而成。或者说镜像就是包含了应用程序、程序运行的系统函数库、运行配置等文件的文件包，构建镜像的过程其实就是把上述文件打包的过程。

举个例子，我们要从0部署一个Java应用，大概流程是这样：

准备一个linux服务（CentOS或者Ubuntu均可）
安装并配置JDK
上传Jar包
运行jar包

那因此，我们打包镜像也是分成这么几步：

准备Linux运行环境（java项目并不需要完整的操作系统，仅仅是基础运行环境即可）
安装并配置JDK
拷贝jar包
配置启动脚本

上述步骤中的每一次操作其实都是在生产一些文件（系统运行环境、函数库、配置最终都是磁盘文件），所以镜像就是一堆文件的集合。

但需要注意的是，镜像文件不是随意堆放的，而是按照操作的步骤分层叠加而成，每一层形成的文件都会单独打包并标记一个唯一id，称为Layer（层）。这样，如果我们构建时用到的某些层其他人已经制作过，就可以直接拷贝使用这些层，而不用重复制作。

例如，第一步中需要的Linux运行环境，通用性就很强，所以Docker官方就制作了这样的只包含Linux运行环境的镜像。我们在制作java镜像时，就无需重复制作，直接使用Docker官方提供的CentOS或Ubuntu镜像作为基础镜像。然后再搭建其它层即可，这样逐层搭建，最终整个Java项目的镜像结构如图所示：

Dockerfile

由于制作镜像的过程中，需要逐层处理和打包，比较复杂，所以Docker就提供了自动打包镜像的功能。我们只需要将打包的过程，每一层要做的事情用固定的语法写下来，交给Docker去执行即可。而这种记录镜像结构的文件就称为Dockerfile。

其中的语法比较多，比较常用的有：

指令	说明	示例
FROM	指定基础镜像	`FROM centos:7`
ENV	设置环境变量，可在后面指令使用	`ENV key value`
COPY	拷贝本地文件到镜像的指定目录	`COPY ./xx.jar /tmp/app.jar`
RUN	执行Linux的shell命令，一般是安装过程的命令	`RUN yum install gcc`
EXPOSE	执行Linux的shell命令，一般是安装过程的命令	EXPOSE 8080
ENTRYPOINT	镜像中应用的启动命令，容器运行时调用	ENTRYPOINT java -jar xx.jar

例如，要基于 centos:7 镜像来构建一个Java应用，其Dockerfile内容如下：

# 使用 CentOS 7 作为基础镜像
FROM centos:7

# 添加 JDK 到镜像中
COPY jdk17.tar.gz /usr/local/
RUN tar -xzf /usr/local/jdk17.tar.gz -C /usr/local/ &&  rm /usr/local/jdk17.tar.gz

# 设置环境变量
ENV JAVA_HOME=/usr/local/jdk-17.0.10 # 此处名字为17.0.10是因为这是压缩包解压完后目录的名字
ENV PATH=$JAVA_HOME/bin:$PATH

# 创建应用目录
RUN mkdir -p /app
WORKDIR /app

# 复制应用 JAR 文件到容器
COPY app.jar app.jar

# 暴露端口
EXPOSE 8080

# 运行命令
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app/app.jar"]

Dockerfile文件编写好了之后，就可以使用如下命令来构建镜像了。

1
2
3

docker build -t 镜像名 .
#例如：
docker build -t myImage:1.0 .

-t ：是给镜像起名，格式依然是repository:tag的格式，不指定tag时，默认为latest
. ：是指定Dockerfile所在目录，如果就在当前目录，则指定为"."

演示:

前端访问端口：192.168.240.128:8080/emps，如果出现json格式数据就说明镜像构建成功了

网络

上一小节我们创建了一个Java项目的容器，而Java项目往往需要访问其它各种中间件，例如MySQL、Redis等。现在，我们的容器之间能否互相访问呢？我们来测试一下

首先，我们查看下MySQL容器的详细信息，重点关注其中的网络IP地址：

# 1.用基本命令，寻找Networks.bridge.IPAddress属性
docker inspect mysql

# 也可以使用format过滤结果
docker inspect --format='{{range .NetworkSettings.Networks}}{{println .IPAddress}}{{end}}' mysql

# 得到IP地址如下：
172.17.0.2

# 2.然后通过命令进入myapp容器
docker exec -it myapp bash

# 3.在容器内，通过ping命令测试网络
ping 172.17.0.2

# 结果
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.053 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.059 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.058 ms
...

#Ctrl + C退出

发现可以互联，没有问题。

但是，容器的网络IP其实是一个虚拟的IP，其值并不固定与某一个容器绑定，如果我们在开发时写死某个IP，而在部署时很可能MySQL容器的IP会发生变化，连接会失败。

这时候我们可以通过docker当中的自定义指令来创建自己的网卡，然后在创建容器的时候，让容器连接到我们的自己创建的虚拟网卡当中，如果说我们自己的创建的多个容器都连接到我们自己创建的虚拟网卡当中，那么接下来我们容器之间在进行相互通信的时候就可以通过容器的名字进行通信了，就不用再去写对应的IP地址了，因为容器的名字是固定的、不会变化的

常见命令有：

命令	说明
docker network create	创建一个网络
docker network ls	查看所有网络
docker network rm	删除指定网络
docker network prune	清除未使用的网络
docker network connect	使指定容器连接加入某网络
docker network disconnect	使指定容器连接离开某网络
docker network inspect	查看网络详细信息

演示：自定义网络

# 1.首先通过命令创建一个网络
docker network create itheima

# 2.然后查看网络
docker network ls

# 结果：
NETWORK ID     NAME      DRIVER    SCOPE
c5e8fe6f8384   bridge    bridge    local
0b8260f77da2   host      host      local
9ad62123bb7e   itheima   bridge    local
7dc2000c90f6   none      null      local
# 其中，除了itheima以外，其它都是默认的网络
# 查看网络接口ip
ip addr
# 查看容器信息
docker ps

# 3.让 myapp 和 mysql 都加入该网络
# 3.1.mysql容器，加入 itheima 网络
docker network connect itheima mysql

# 查看容器是否加入，查看NetworkSettings中是否有myapp和mysql
docker inspect mysql #myapp同理


# 3.2.myapp容器，也就是我们的java项目, 加入 itheima 网络
docker network connect itheima myapp
# 也可以在创建时加入itheima网络，可以先删除myapp，然后再重新创建，并在创建过程中加入itheima
docker run -d --name myapp -p 8080:8080 --network itheima app:1.0
#此次创建的容器中就没有默认的网络，只有itheima这个网络

# 4.进入myapp容器，尝试利用别名访问db
# 4.1.进入容器
docker exec -it myapp bash

# 4.2.用容器名访问
ping mysql

# 结果：
PING mysql (172.18.0.2) 56(84) bytes of data.
64 bytes from mysql.itheima (172.18.0.2): icmp_seq=1 ttl=64 time=0.044 ms
64 bytes from mysql.itheima (172.18.0.2): icmp_seq=2 ttl=64 time=0.054 ms
...

OK，现在无需记住IP地址也可以实现容器互联了。

项目部署

部署服务端

需求：将我们开发的 tlias-web-management 项目打包为镜像，并部署。
步骤：

1.准备MySQL容器，并创建tlias数据库及表结构。（已完成）

2.准备java应用（tlias项目）镜像，部署Docker容器，运行测试
- 修改tlias项目的配置文件，修改数据库服务地址及Logback日志文件存放地址（打包package）。
- 编写Dockerfile文件。
- 构建Docker镜像。
- 部署Docker容器，运行测试。

1). 修改tlias项目的配置文件，修改数据库服务地址及Logback日志文件存放地址（打包package）。

然后，执行maven中的package生命周期，进行打包(跳过测试)，并将打包后的jar包命名为 tlias.jar 。

2). 编写Dockerfile文件。

文件名 Dockerfile:

# 使用 CentOS 7 作为基础镜像
FROM centos:7

# 添加 JDK 到镜像中
COPY jdk17.tar.gz /usr/local/
RUN tar -xzf /usr/local/jdk17.tar.gz -C /usr/local/ &&  rm /usr/local/jdk17.tar.gz

# 设置环境变量
ENV JAVA_HOME=/usr/local/jdk-17.0.10
ENV PATH=$JAVA_HOME/bin:$PATH

# 阿里云OSS环境变量
ENV OSS_ACCESS_KEY_ID=...
ENV OSS_ACCESS_KEY_SECRET=...

#统一编码
ENV LANG=en_US.UTF-8
ENV LANGUAGE=en_US:en
ENV LC_ALL=en_US.UTF-8

# 创建应用目录
RUN mkdir -p /tlias
WORKDIR /tlias

# 复制应用 JAR 文件到容器
COPY  tilas.jar  tilas.jar

# 暴露端口
EXPOSE 8080

# 运行命令
ENTRYPOINT ["java","-jar","/tlias/tlias.jar"]

由于项目要运行，需要依赖jdk的环境，所以这里我们需要将tlias.jar，jdk17.tar.gz，Dockerfile三个文件，上传到Linux服务器的 /root/tlias 目录下（如果没有这个目录，提前创建好）。

3). 构建Docker镜像，部署Docker容器，运行测试。

构建Docker镜像

`1`	`docker build -t tlias:1.0 .`

部署Docker容器

`1`	`docker run -d --name tlias-server --network itheima -p 8080:8080 tlias:1.0`

–network itheima ：将创建的容器，加入到itheima网络，就可以和itheima网络中的容器通信了。

通过 docker logs -f 容器名，就可以查看容器的运行日志。

这样后端服务，就已经启动起来了。

我们可以打开aipfox进行查看

部署前端

需求：创建一个新的nginx容器，将资料中提供的前端项目的静态资源部署到nginx中。
步骤：
- 在宿主机上准备静态文件及配置文件存放目录(在 /usr/local 目录下创建 tlias-web 目录)。
  - -v /usr/local/tlias-web/html:/usr/share/nginx/html
  - -v /usr/local/tlias-web/conf/nginx.conf:/etc/nginx/nginx.conf
- 部署nginx容器

1). 部署nginx容器（设置目录映射）。

将资料中的目录html和配置文件存放目录 conf，上传至服务器端的 root/tlias-nginx目录下。

执行如下命令，部署nginx容器

docker run -d \
 --name nginx-tlias \
 -v /root/tlias-nginx/html:/usr/share/nginx/html \
 -v /root/tlias-nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
 --network itheima \
 -p 80:80 \
nginx:1.20.2

前后端都部署完毕后，就可以打开浏览器，来测试一下。访问前端的nginx服务器。

并且头像上传功能也可以正常使用

DockerCompose

大家可以看到，我们部署一个简单的java项目，其中包含3个容器：

MySQL
Nginx
Java项目

而稍微复杂的项目，其中还会有各种各样的其它中间件，需要部署的东西远不止3个。如果还像之前那样手动的逐一部署，就太麻烦了。

而Docker Compose就可以帮助我们实现多个相互关联的Docker容器的快速部署。它允许用户通过一个单独的 docker-compose.yml 模板文件（YAML 格式）来定义一组相关联的应用容器。

基本语法

docker-compose文件中可以定义多个相互关联的应用容器，每一个应用容器被称为一个服务（service）。由于service就是在定义某个应用的运行时参数，因此与docker run参数非常相似。

举例来说，用docker run部署MySQL的命令如下：

docker run -d \
--name nginx-tlias \
-p 80:80 \
-v /usr/local/app/html:/usr/share/nginx/html \
-v /usr/local/app/conf/nginx.conf:/etc/nginx/nginx.conf \  
--network itheima \
nginx:1.20.2

如果用docker-compose.yml文件来定义，就是这样：

services:
  mysql:
    image: "nginx:1.20.2"
    container_name: nginx-tlias
    ports:
      - "80:80"
    volumes:
      - "/usr/local/app/html:/usr/share/nginx/html"
      - "/usr/local/app/conf/nginx.conf:/etc/nginx/nginx.conf"
    networks:
      - itheima
networks:
  itheima:
    name: itheima

对比如下：

docker run 参数	docker compose 指令	说明
–name	container_name	容器名称
-p	ports	端口映射
-e	environment	环境变量
-v	volumes	数据卷配置
–network	networks	网络

明白了其中的对应关系，接下来编写docker-compose。

注意：将之前配置的三个容器需要删除，将docker环境恢复到最初的状态

只保留这几个镜像和网络即可

services:
  mysql:
    image: mysql:8
    container_name: mysql
    ports:
      - "3307:3306"
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 123
    volumes:
      - "/usr/local/app/mysql/conf:/etc/mysql/conf.d"
      - "/usr/local/app/mysql/data:/var/lib/mysql"
      - "/usr/local/app/mysql/init:/docker-entrypoint-initdb.d"
    networks:
      - tlias-net
  tlias:
    build: 
      context: .
      dockerfile: Dockerfile
    container_name: tlias-server
    ports:
      - "8080:8080"
    networks:
      - tlias-net
    depends_on:
      - mysql
  nginx:
    image: nginx:1.20.2
    container_name: nginx
    ports:
      - "80:80"
    volumes:
      - "/usr/local/app/nginx/conf/nginx.conf:/etc/nginx/nginx.conf"
      - "/usr/local/app/nginx/html:/usr/share/nginx/html"
    depends_on:
      - tlias
    networks:
      - tlias-net
networks:
  tlias-net:
    name: itheima

基础命令

编写好docker-compose.yml文件，就可以部署项目了。语法如下：

`1`	`docker compose [OPTIONS] [COMMAND]`

其中，OPTIONS和COMMAND都是可选参数，比较常见的有：

操作演示

1). 在 Linux 服务器的 /usr/local 目录下创建目录 app，并切换到 /usr/local/app 目录。

2). 上传资料中提供的 “Docker Compose” 中的文件及文件夹到 /usr/local/app 目录中，如下所示：

注意，资料中提供的Dockerfile文件中的阿里云OSS的 AccessKeyId，AccessKeySecret需要替换成自己的。

3). 执行如下指令，基于DockerCompose部署项目。

`1`	`docker compose up -d`

项目启动完毕之后，就可以启动服务器测试了。

当运行完后就可以使用docker compose down删除，等下次需要的时候再使用 docker compose up -d一键构建启动即可

附录：Docker安装

卸载旧版

首先如果系统中已经存在旧的Docker，则先卸载：

yum remove docker \
    docker-client \
    docker-client-latest \
    docker-common \
    docker-latest \
    docker-latest-logrotate \
    docker-logrotate \
    docker-engine \
    docker-selinux

配置Docker的yum库

首先要安装一个yum工具

`1`	`sudo yum install -y yum-utils device-mapper-persistent-data lvm2`

安装成功后，执行命令，配置Docker的yum源（已更新为阿里云源）：

1
2
3

sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo

更新yum，建立缓存

`1`	`sudo yum makecache fast`

安装Docker

最后，执行命令，安装Docker

`1`	`yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin`

启动和校验

# 启动Docker
systemctl start docker

# 停止Docker
systemctl stop docker

# 重启
systemctl restart docker

# 设置开机自启
systemctl enable docker

# 执行docker ps命令，如果不报错，说明安装启动成功
docker ps

配置镜像加速

镜像地址可能会变更，如果失效可以百度找最新的docker镜像。

配置镜像步骤如下：

# 创建目录
rm -f /etc/docker/daemon.json

# 复制内容
tee /etc/docker/daemon.json <<-'EOF'
{
    "registry-mirrors": [
        "http://hub-mirror.c.163.com",
        "https://mirrors.tuna.tsinghua.edu.cn",
        "http://mirrors.sohu.com",
        "https://ustc-edu-cn.mirror.aliyuncs.com",
        "https://ccr.ccs.tencentyun.com",
        "https://docker.m.daocloud.io",
        "https://docker.awsl9527.cn"
    ]
}
EOF

# 重新加载配置
systemctl daemon-reload

# 重启Docker
systemctl restart docker

Linux

Tue, 26 May 2026 21:31:09 +0800

Linux

Linux概述

主流操作系统

不同领域的主流操作系统，主要分为以下这么几类：桌面操作系统、服务器操作系统、移动设备操作系统、嵌入式操作系统。接下来，这几个领域中，代表性的操作系统是那些?

1). 桌面操作系统

操作系统	特点
Windows	用户数量多
MacOS	操作体验好，办公人士首选
Linux	用户数量少（桌面操作系统，Linux使用较少）

2). 服务器操作系统

操作系统	特点
Unix	安全、稳定、付费
Linux	安全、稳定、免费、占有率高
Windows Server	付费、占有率低

3). 移动设备操作系统

操作系统	特点
Android	基于 Linux 、开源，主要用于智能手机、平板电脑和智能电视
IOS	苹果公司开发、不开源，用于苹果公司的产品，例如：iPhone、 iPad
HarmonyOS	华为公司开发、开源，目前用于华为公司的产品

Linux系统版本

Linux系统的版本分为两种，分别是：内核版和发行版。

1). 内核版

由Linus Torvalds及其团队开发、维护
免费、开源
负责控制硬件

2). 发行版

基于Linux内核版进行扩展
由各个Linux厂商开发、维护
有收费版本和免费版本

我们使用Linux操作系统，实际上选择的是Linux的发行版本。在linux系统中，有各种各样的发行版本，具体如下：

除了上述罗列出来的发行版，还有很多Linux发行版，这里，我们就不再一一列举了。

系统安装

安装方式

Linux系统的安装方式，主要包含以下两种：

虚拟机（Virtual Machine）指通过软件模拟的具有完整硬件系统功能、运行在完全隔离环境中的完整计算机系统。常用虚拟机软件：

VMWare
VirtualBox
VMLite WorkStation
Qemu
HopeddotVOS

那么我们就可以在课程中将Linux操作系统安装在虚拟机中，我们学习选择的虚拟机软件是VMware。

安装VMware

可以自行去网上查找安装程序

安装步骤:

以上就是VMware在安装时的每一步操作，基本上就是点击 “下一步” 一直进行安装。

挂载Linux系统

1). 打开Vmware虚拟机，打开 编辑 -> 虚拟网络编辑器(N)...

选择 NAT模式，然后选择右下角的 更改设置。

设置子网IP为 192.168.100.0，然后选择 应用 -> 确定。

由于学习上课需要使用到虚拟机所以我的ip是上课使用的ip就不是教程中所展示的ip了

2). 解压CentOS7-1.zip到一个比较大的磁盘中 (没有中文的目录)。

3). 打开解压目录，双击.vmx文件，选择以Vmware Workstation打开这个文件。

4). 挂载完毕之后，启动Linux服务器。

启动过程中，如果出现如下界面，选择 我已移动该虚拟机。

5). 启动完毕之后，登录服务器。输入用户名：root，密码：1234 （注意：linux系统输入密码是不显示的，输入完毕，回车即可登录）

安装SSH连接工具

SSH连接工具介绍

Linux已经安装并且配置好了，接下来我们要来学习Linux的基本操作指令。而在学习之前，我们还需要做一件事情，由于我们企业开发时，Linux服务器一般都是在远程的机房部署的，我们要操作服务器，不会每次都跑到远程的机房里面操作，而是会直接通过SSH连接工具进行连接操作。

SSH（Secure Shell），建立在应用层基础上的安全协议。常用的SSH连接工具:

FinalShell安装

双击.exe文件，然后进行正常的安装即可。

连接Linux

打开FinalShell，选择SSH连接。

连接服务器，输入服务器的信息，IP固定的：192.168.100.128，用户名：root，密码：1234
我的ip为192.168.240.128

配置完毕后,双击即可连接服务器。

如果一直连接失败，可以参考我下面的截图进行操作

目录结构

登录到Linux系统之后，我们需要先来熟悉一下Linux的目录结构。在Linux系统中，也是存在目录的概念的，但是Linux的目录结构和Windows的目录结构是存在比较多的差异的在Windows目录下，是一个一个的盘符(C盘、D盘、E盘)，目录是归属于某一个盘符的。Linux系统中的目录有以下特点：

Linux 和 Windows的目录结构对比:

Linux的目录结构，如下：

编号	目录	含义
1	/bin	存放二进制可执行文件
2	/boot	存放系统引导时使用的各种文件
3	/dev	存放设备文件
4	/etc	存放系统配置文件
5	/home	存放系统用户的文件
6	/lib	存放程序运行所需的共享库和内核模块
7	/opt	额外安装的可选应用程序包所放置的位置
8	/root	超级用户目录
9	/sbin	存放二进制可执行文件，只有root用户才能访问
10	/tmp	存放临时文件
11	/usr	存放系统应用程序
12	/var	存放运行时需要改变数据的文件，例如日志文件

Linux常用命令

Linux命令初体验

Linux 命令格式：command [-options] [parameter]
说明：
- command：命令名
- [-options]：选项，可用来对命令进行控制，也可以省略（可选）
- [parameter]：参数，可以是零个、一个或多个（可选）
例如：

使用技巧：

Tab键自动补全

连续两次Tab键，给出操作提示

使用上下箭头快速调出曾经使用过的命令

使用clear命令或Ctrl+l快捷键实现清屏

目录操作命令

ls

用: 显示指定目录下的内容

语法: ls [-al] [dir]

说明:

-a 显示所有文件及目录 (. 开头的隐藏文件也会列出)

-l 除文件名称外，同时将文件型态(d表示目录，-表示文件)、权限、拥有者、文件大小等信息详细列出

注意:

由于我们使用ls命令时经常需要加入-l选项，所以Linux为 ls -l 命令提供了一种简写方式，即 ll

常见用法:

ls -al 查看当前目录的所有文件及目录详细信息

ls -al /etc 查看/etc目录下所有文件及目录详细信息

ll 查看当前目录文件及目录的详细信息

操作示例：

cd

作用: 用于切换当前工作目录，即进入指定目录

语法: cd [dirName]

特殊说明:

~ 表示用户的home目录

. 表示目前所在的目录

.. 表示目前目录位置的上级目录

举例:

cd .. 切换到当前目录的上级目录

cd ~ 切换到用户的home目录

cd /usr/local 切换到/usr/local目录

备注:

用户的home目录

root用户 /root

其他用户 /home/xxx

操作示例:

cd .. 切换到当前目录位置的上级目录; 可以通过 cd ../.. 来切换到上级目录的上级目录

mkdir

作用: 创建目录

语法: mkdir [-p] dirName

说明:

-p: 确保目录名称存在，不存在的就创建一个。通过此选项，可以实现多层目录同时创建

举例:

mkdir itcast 在当前目录下，建立一个名为itcast的子目录

mkdir -p itcast/test 在工作目录下的itcast目录中建立一个名为test的子目录，若itcast目录不存在，则建立一个

操作演示:

rm

作用: 删除文件或者目录

语法: rm [-rf] name

说明:

-r: 将目录及目录中所有文件（目录）逐一删除，即递归删除

-f: 无需确认，直接删除

举例:

rm -r itcast/ 删除名为itcast的目录和目录中所有文件，删除前需确认

rm -rf itcast/ 无需确认，直接删除名为itcast的目录和目录中所有文件

rm -f hello.txt 无需确认，直接删除hello.txt文件

操作演示：

注意: 对于 rm -rf xxx 这样的指令，在执行的时候，一定要慎重，确认无误后再进行删除，避免误删。

文件操作命令

cat

作用: 用于显示文件内容

语法: cat [-n] fileName

说明:

-n: 由1开始对所有输出的行数编号

举例:

cat /etc/profile 查看/etc目录下的profile文件内容

操作演示:

cat 指令会一次性查看文件的所有内容，如果文件内容比较多，这个时候查看起来就不是很方便了，这个时候我们可以通过一个新的指令more。

作用: 以分页的形式显示文件内容

语法: more fileName

操作说明:

回车键向下滚动一行

空格键向下滚动一屏

b 返回上一屏

q或者Ctrl+C 退出more

举例：

more /etc/profile 以分页方式显示/etc目录下的profile文件内容

操作示例：

当我们在查看一些比较大的文件时，我们可能需要经常查询文件尾部的数据信息，那这个时候如果文件很大，我们要一直向下翻页，直到最后一页，去看最新添加的数据，这种方式就比较繁琐了，此时，我们可以借助于tail指令。

head

作用：查看文件开头的内容

语法：head [-n] fileName

说明:

-n ：输出文件开头的n行内容

举例：

head 1.log 默认显示1.log文件开头的10行内容

head -20 1.log 显示1.log文件开头的20行内容

tail

作用: 查看文件末尾的内容

语法: tail [-f] fileName

说明:

-f : 动态读取文件末尾内容并显示，通常用于日志文件的内容输出

举例:

tail /etc/profile 显示/etc目录下的profile文件末尾10行的内容

tail -20 /etc/profile 显示/etc目录下的profile文件末尾20行的内容

tail -f /itcast/my.log 动态读取/itcast目录下的my.log文件末尾内容并显示

操作示例：

A. 默认查询文件尾部10行记录

B. 可以通过指定参数设置查询尾部指定行数的数据

C. 动态读取文件尾部的数据

在窗口1中执行指令 tail -f 1.txt 动态查看文件尾部的数据。然后在顶部的标签中右键选择 “复制标签”，打开新的窗口2 , 此时再新打开的窗口2中执行指令 echo 1 >> 1.txt , 往1.txt文件尾部追加内容，然后我们就可以在窗口1中看到最新的文件尾部的数据。

echo：将指定的文本、字符串或变量的值输出到终端屏幕（标准输出）。

如果我们不想查看文件尾部的数据了，可以直接使用快捷键 Ctrl+C ，结束当前进程。

拷贝移动命令

cp

作用: 用于复制文件或目录

语法: cp [-r] source dest

说明:

-r: 如果复制的是目录需要使用此选项，此时将复制该目录下所有的子目录和文件

举例:

cp hello.txt itcast/ 将hello.txt复制到itcast目录中

cp hello.txt ./hi.txt 将hello.txt复制到当前目录，并改名为hi.txt

cp -r itcast/ ./itheima/ 将itcast目录和目录下所有文件复制到itheima目录下

cp -r itcast/* ./itheima/ 将itcast目录下所有文件复制到itheima目录下

操作示例:

如果拷贝的内容是目录，需要加上参数 -r

mv

作用: 为文件或目录改名、或将文件或目录移动到其它位置

语法: mv source dest

举例:

mv hello.txt hi.txt 将hello.txt改名为hi.txt

mv hi.txt itheima/ 将文件hi.txt移动到itheima目录中

mv hi.txt itheima/hello.txt 将hi.txt移动到itheima目录中，并改名为hello.txt

mv itcast/ itheima/ 如果itheima目录不存在，将itcast目录改名为itheima

mv itcast/ itheima/ 如果itheima目录存在，将itcast目录移动到itheima目录中

操作示例:

mv 命令既能够改名，又可以移动，具体是改名还是移动,系统会根据我们输入的参数进行判定(如果第二个参数dest是一个已存在的目录,将执行移动操作,其他情况都是改名)

打包压缩命令

作用: 对文件进行打包、解包、压缩、解压

语法: tar [-zcxvf] ``fileName ``[files]

包文件后缀为.tar表示只是完成了打包，并没有压缩

包文件后缀为.tar.gz表示打包的同时还进行了压缩

说明:

-z: z代表的是gzip，通过gzip命令处理文件，gzip可以对文件压缩或者解压

-c: c代表的是create，即创建新的包文件

-x: x代表的是extract，实现从包文件中还原文件

-v: v代表的是verbose，显示命令的执行过程

-f: f代表的是file，用于指定包文件的名称

举例：

打包

tar -cvf hello.tar ./* 将当前目录下所有文件打包，打包后的文件名为hello.tar

tar -zcvf hello.tar.gz ./* 将当前目录下所有文件打包并压缩，打包后的文件名为 hello.tar.gz

解包

tar -xvf hello.tar 将hello.tar文件进行解包，并将解包后的文件放在当前目录

tar -zxvf hello.tar.gz 将hello.tar.gz文件进行解压，并将解压后的文件放在当前目录

tar -zxvf hello.tar.gz -C /usr/local 将hello.tar.gz文件进行解压，并将解压后的文件放在/usr/local目录

操作示例:

A. 打包

B. 打包并压缩

C. 解包

D. 解压

解压到指定目录,需要加上参数 -C

区别：

文本编辑命令

文本编辑的命令，主要包含两个: vi 和 vim，两个命令的用法类似，我们课程中主要讲解vim的使用。

vi & vim介绍

作用: vi命令是Linux系统提供的一个文本编辑工具，可以对文件内容进行编辑，类似于Windows中的记事本
语法: vi fileName
说明:
- 1). vim是从vi发展来的一个功能更加强大的文本编辑工具，编辑文件时可以对文本内容进行着色，方便我们对文件进行编辑处理，所以实际工作中vim更加常用。
- 2). 要使用vim命令，需要我们自己完成安装。可以使用下面的命令来完成安装：yum install vim

vim安装

命令： yum install vim

安装过程中，会有确认提示，此时输入 y，然后回车，继续安装：

想要知道自己是否已经安装过vim可以使用命令：which vim

vim使用

作用: 对文件内容进行编辑，vim其实就是一个文本编辑器
语法: vim fileName
说明:
- 1). 在使用vim命令编辑文件时，如果指定的文件存在则直接打开此文件。如果指定的文件不存在则新建文件。
- 2). vim在进行文本编辑时共分为三种模式，分别是命令模式（Command mode），插入模式（Insert mode）和底行模式（Last line mode）。这三种模式之间可以相互切换。我们在使用vim时一定要注意我们当前所处的是哪种模式。
三种模式:
- 命令模式
  - A. 命令模式下可以查看文件内容、移动光标（上下左右箭头、gg、G)
  - B. 通过vim命令打开文件后，默认进入命令模式
  - C. 另外两种模式需要首先进入命令模式，才能进入彼此

命令模式指令	含义
gg	定位到文本内容的第一行
G	定位到文本内容的最后一行
dd	删除光标所在行的数据
ndd	删除当前光标所在行及之后的n行数据
u	撤销操作
i或a或o	进入插入模式(进入后光标所处的位置不同而已)

插入模式
- A. 插入模式下可以对文件内容进行编辑
- B. 在命令模式下按下[i,a,o]任意一个，可以进入插入模式。进入插入模式后，下方会出现【insert】字样
- C. 在插入模式下按下ESC键，回到命令模式
底行模式
- A. 底行模式下可以通过命令对文件内容进行查找、显示行号、退出等操作
- B. 在命令模式下按下[:,/]任意一个，可以进入底行模式
- C. 通过/方式进入底行模式后，可以对文件内容进行查找
- D. 通过:方式进入底行模式后，可以输入wq（保存并退出）、q!（不保存退出）、set nu（显示行号）

底行模式指令	含义
:wq	保存并退出
:q!	不保存退出
:set nu	显示行号
:set nonu	取消行号显示
:n	定位到第n行，如 :10 就是定位到第10行

查找命令

find

作用: 在指定目录下查找文件

语法: find dirName -option fileName

举例:

find . –name "*.java" 在当前目录及其子目录下查找.java结尾文件

find /itcast -name "*.java" 在/itcast目录及其子目录下查找.java结尾的文件

操作示例:

grep

作用: 从指定文件中查找指定的文本内容

语法: grep word fileName

选项：

-i: 检索的关键字忽略(ignore)大小写

-n: 显示关键字所在的这一行的行号

-A: 输出关键字所在行及之后(After)的几行记录 (如:-A5 表示输出关键字所在行之后的5行记录)

-B: 输出关键字所在行及之前(Before)的几行记录 (如:-B5 表示输出关键字所在行之前的5行记录)

举例:

grep Hello HelloWorld.java 查找HelloWorld.java文件中出现的Hello字符串的位置

grep hello *.java 查找当前目录中所有.java结尾的文件中包含hello字符串的位置

操作示例:

软件安装

软件安装方式

在Linux系统中，安装软件的方式主要有四种，这四种安装方式的特点如下：

安装JDK

上述我们介绍了Linux系统软件安装的四种形式，接下来我们就通过第一种(二进制发布包)形式来安装JDK。

JDK具体安装步骤如下：

1). 上传安装包

使用FinalShell自带的上传工具将jdk的二进制发布包上传到Linux

2). 解压安装包

执行如下指令，将上传上来的压缩包进行解压，并通过-C参数指定解压文件存放目录为 /usr/local。

`1`	`tar -zxvf jdk-21_linux-x64_bin.tar.gz -C /usr/local/`

3). 配置环境变量

使用vim命令修改/etc/profile文件，在文件末尾加入如下配置

1
2

export JAVA_HOME=/usr/local/jdk-17.0.10
export PATH=$JAVA_HOME/bin:$PATH

具体操作指令如下:

1). 编辑/etc/profile文件，进入命令模式
    vim /etc/profile

2). 在命令模式中，输入指令 G ， 切换到文件最后
    G

3). 在命令模式中输入 i/a/o 进入插入模式，然后切换到文件最后一行
    i

4). 将上述的配置拷贝到文件中
    export JAVA_HOME=/usr/local/jdk-17.0.10
    export PATH=$JAVA_HOME/bin:$PATH
        
5). 从插入模式，切换到指令模式
    ESC
        
6). 按:进入底行模式，然后输入wq，回车保存
    :wq

4). 重新加载profile文件

为了使更改的配置立即生效，需要重新加载profile文件，执行命令:

`1`	`source /etc/profile`

5). 检查安装是否成功

`1`	`java -version`

安装MySQL

MySQL安装

对于MySQL数据库的安装，我们将要使用前面讲解的第一种安装方式进行安装。

1). 准备工作

在安装MySQL数据库之前，我们需要先检查一下当前Linux系统中，是否安装的有MySQL的相关服务（很多linux安装完毕之后，自带了低版本的mysql的依赖包），如果有，先需要卸载掉，然后再进行安装。

A. 通过rpm相关指令，来查询当前系统中是否存在已安装的mysql软件包，执行指令如下：

rpm -qa 查询当前系统中安装的所有软件
rpm -qa | grep mysql 查询当前系统中安装的名称带mysql的软件
rpm -qa | grep mariadb 查询当前系统中安装的名称带mariadb的软件

通过rpm -qa 查询到系统通过rpm安装的所有软件，太多了，不方便查看，所以我们可以通过管道符 | 配合着grep进行过滤查询。

通过查询，我们发现在当前系统不存在mysqlh和mariadb数据库。

**RPM：**全称为 Red-Hat Package Manager，RPM软件包管理器，是红帽Linux用于管理和安装软件的工具。

如果发现在当前系统中有这两个任意一个或都有，可以换通过以下方法卸载

B. 通过 rpm 相关指令，来卸载对应的组件，执行指令如下：

在rpm中，卸载软件的语法为：rpm -e --nodeps 软件名称

那么，我们就可以通过指令，卸载 mariadb，具体指令为： rpm -e --nodeps mariadb-libs-5.5.60-1.el7_5.x86_64

2). 将资料中提供的MySQL安装包上传到Linux并解压

A. 上传MySQL安装包

我们需要将该MySQL安装包上传到Linux系统的根目录 /root 下面。

B. 解压到当前目录

执行如下指令:

`1`	`tar -xvf mysql-8.0.30-linux-glibc2.12-x86_64.tar.xz`

C. 将解压后的文件夹移动到 /usr/local 目录下，并改名为 mysql

1
2
3

mv mysql-8.0.30-linux-glibc2.12-x86_64 /usr/local/mysql

cd /usr/local/mysql

并执行如下指令, 注册MySQL为系统服务:

1
2

cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysql
chkconfig --add mysql

5). 初始化数据库(因为我的用户组和用户都不为空，所以我就新建了一个叫mysql1)

#创建一个用户组, 组名就叫mysql
groupadd mysql1

#创建一个系统用户 mysql, 并归属于用户组 mysql 
useradd -r -g mysql1 -s /bin/false mysql

1
2

#初始化mysql
mysqld --initialize --user=mysql1 --basedir=/usr/local/mysql --datadir=/usr/local/mysql/data

如果mysql中数据目录不为空，可能就会报出下面的错误

我去问ai，ai给出的解释是：

你正在尝试初始化一个新的数据库实例，但是指定的 --datadir=/usr/local/mysql/data 目录里已经存在文件了。MySQL 的初始化机制要求数据目录必须是空的或者不存在，以防止意外覆盖已有的重要数据。

给出的解决方案如下：

删除前最好将原文件备份一份

创建备份目录

`1`	`mkdir -p /backup`

使用 tar 命令打包（推荐）

`1`	`tar -czvf /backup/mysql_data_backup.tar.gz -C /usr/local/mysql data`

如果你不想压缩，只想单纯复制一份副本，可以使用 cp 命令。但必须加上 -a 参数以保留权限。

`1`	`cp -a /usr/local/mysql/data /backup/data_backup_copy`

验证备份是否成功

`1`	`ls -lh /backup`

如果你看到了 mysql_data_backup.tar.gz（或 data_backup_copy 目录），且文件大小不是 0，说明备份成功。

恢复方法（万一出错了怎么办？）

如果你清空了原目录后发现出错了，可以用以下命令恢复：

如果是用 tar 备份的：

# 进入 mysql 目录
cd /usr/local/mysql
# 解压覆盖
tar -xzvf /backup/mysql_data_backup.tar.gz

如果是用 cp 备份的：

1
2

rm -rf /usr/local/mysql/data
cp -a /backup/data_backup_copy /usr/local/mysql/data

启动MySQL

A. 启动MySQL服务

`1`	`systemctl start mysql`

B. 通过命令, 登录MySQL

1
2

#xxxxx 代表上述生成的root的临时密码
mysql -uroot -pxxxxx

配置MySQL

A. 修改root用户的密码

`1`	`ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '1234';`

注意: 这个root账号仅仅能够在本机localhost上访问，我们在windows上是无法访问的。如果需要在window上或其他服务器上也能远程访问，需要创建一个账号，用于远程访问的。

B. 创建账号, 并授权远程访问

CREATE USER 'root'@'%' IDENTIFIED BY '1234';

GRANT ALL PRIVILEGES ON *.* TO 'root'@'%';

FLUSH PRIVILEGES;

我们已经开启了MySQL的远程访问的权限，为什么还是连接不上MySQL服务器呢？？这是因为Linux系统的防火墙，将我们的访问拦截了。

防火墙操作

Linux系统安装完毕后，系统启动时，防火墙自动启动，防火墙拦截了所有端口的访问。接下来我们就需要学习一下，如何操作防火墙，具体指令如下：

操作	指令	备注
查看防火墙状态	systemctl status firewalld / firewall-cmd –state
暂时关闭防火墙	systemctl stop firewalld
永久关闭防火墙(禁用开机自启)	systemctl disable firewalld	下次启动,才生效
暂时开启防火墙	systemctl start firewalld
永久开启防火墙(启用开机自启)	systemctl enable firewalld	下次启动,才生效
开放指定端口	firewall-cmd –zone=public –add-port=8080/tcp –permanent	需要重新加载生效
关闭指定端口	firewall-cmd –zone=public –remove-port=8080/tcp –permanent	需要重新加载生效
立即生效(重新加载)	firewall-cmd –reload
查看开放端口	firewall-cmd –zone=public –list-ports

注意：要想在windows上能够访问MySQL，需要开放防火墙的3306端口或者直接关闭防火墙，执行如下指令:

#开放防火墙的3306端口号
firewall-cmd --zone=public --add-port=3306/tcp --permanent

#重新加载
firewall-cmd --reload

#查看开放的端口号
firewall-cmd --zone=public --list-ports

或者直接关闭防火墙:

`1`	`systemctl stop firewalld`

连接测试

关闭掉linux系统的防火墙之后，我们就可以打开windows上的命令行，通过mysql的客户端(命令行/图形化界面)来连接远程linux上安装的MySQL数据库了。

1). 客户端连接

2). 打开DataGrip图形化工具连接

执行资料中提供的SQL脚本 tlias.sql 。

安装Nginx

安装

Nginx的安装包，从官方下载下来的是c语言的源码包，我们需要自己编译安装。具体操作步骤如下：

1). 安装Nginx运行时需要的依赖

`1`	`yum install -y pcre pcre-devel zlib zlib-devel openssl openssl-devel`

安装C语言的编译环境.

`1`	`yum install gcc-c++`

安装完后可以检查是否安装成功，安装前也可以使用以下命令查看是否已经安装过了

1
2
3

yum list installed | grep pcre
yum list installed | grep zlib
yum list installed | grep openssl

gcc -v

2). 上传Nginx的源码包

3). 解压源码包到当前目录

`1`	`tar -zxvf nginx-1.20.2.tar.gz`

4). 进入到解压目录后，执行指令

#进入解压目录
cd nginx-1.20.2

#执行命令配置, 生成Makefile文件
./configure --prefix=/usr/local/nginx

5). 执行命令进行编译和安装

#编译
make

#编译安装
make install

安装完成效果如下：

启动Nginx

进入到nginx安装目录/usr/local/nginx，启动nginx服务

1
2

cd /usr/local/nginx/
sbin/nginx

启动完毕之后，我们可以通过 ps 指令查询当前系统中的nginx进程，从而确认nginx是否启动。

然后，我们就可以打开浏览器，访问服务器上的nginx 。

项目部署

前端项目部署

1). 将nginx的安装目录的html中的静态资源文件先删除掉。

2). 将资料中提供的 “资料/06. 项目部署/前端/页面资源” 目录下的静态资源文件，全部上传到nginx安装目录下的 html 目录中.

3). 修改资料中提供的nginx.conf配置文件，将其上传到nginx安装目录下的 conf 目录中.

4). 重新加载nginx服务的配置文件

1
2

#重新加载配置文件（nginx安装目录下操作）
sbin/nginx -s reload

5). 再次访问nginx (可能会存在浏览器缓存, 可以按Ctrl+F5, 强制刷新清理缓存)

如果前端无响应，可能有以下几个原因：

关闭nginx的命令

`1`	`sbin/nginx -s quit`

后端项目部署

之前我们讲解Linux操作系统时，就提到，我们服务端开发工程师学习Linux系统的目的就是将来我们开发的项目绝大部分情况下都需要部署在Linux系统中。

操作步骤：

环境准备

那现在，项目要上线了，要部署到linux服务器上了，我们也需要使用linux服务器上所安装的mysql数据库。

那此时，我们就可以再准备一份文件 application.yml 将里面的配置的mysql的ip地址及相关配置信息修改一下（配置Linux上安装的MySQL的信息）：

#配置数据库连接信息
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://192.168.100.128:3306/tlias
    username: root
    password: 1234
  servlet:
    multipart:
      max-file-size: 10MB #单个文件最大大小限制10MB
      max-request-size: 100MB #单个请求最大大小限制100MB

#配置mybatis的日志输出到控制台
mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    #配置mybatis的驼峰命名的映射开关
    map-underscore-to-camel-case: true
#查看事务管理的日志
logging:
  level:
    org.springframework.jdbc.support.JdbcTransactionManager: debug

#阿里云oss配置
aliyun:
  oss:
    endpoint: https://oss-cn-beijing.aliyuncs.com
    bucketName: java422-web-ai

由于我们的Linux并没有在D盘上，所以我们的日志文件地址也需要进行修改：

改造完毕之后，可以在本地的idea中先启动当前项目，然后访问一下，看看工程是否正常访问。

打包部署

1). 执行 package 指令，进行打包操作，将当前的springboot项目，打成一个jar包。 (跳过测试)

jar包地址：

2). 在Linux服务器上创建一个目录，将jar包上传到服务器。

`1`	`mkdir -p /usr/local/tlias-app`

3). 通过java命令，启动项目

#进入目录/usr/local/app 
cd /usr/local/tlias-app

#运行jar包
java -jar tilas-web-management-0.0.1-SNAPSHOT.jar

项目启动起来之后，就可以打开浏览器测试啦。

阿里云OSS秘钥配置

由于在开发的时候，我们将访问阿里云OSS的AccessKeyId，AccessKeySecret都配置在了系统的环境变量中了。那现在项目部署到了Linux服务器中，调用阿里云OSS进行文件上传时，程序就会获取Linux系统中的环境变量。所以此时，我们需要将AccessKeyId，AccessKeySecret配置为Linux系统的环境变量。

1). 查看Windows系统之前配置的环境变量

1
2
3

echo %OSS_ACCESS_KEY_ID%

echo %OSS_ACCESS_KEY_SECRET%

我们将上述自己的 AccessKeyId 与 AccessKeySecret 复制出来，然后在linux系统中配置环境变量。

2). 执行如下指令：

echo "export OSS_ACCESS_KEY_ID=***" >> /etc/profile

echo "export OSS_ACCESS_KEY_SECRET=***" >> /etc/profile

source /etc/profile

当前程序中存在的问题:

线上程序不会采用控制台霸屏的形式运行程序，而是将程序在后台运行
线上程序不会将日志输出到控制台，而是输出到日志文件，方便运维查阅信息

要解决上述这两个问题，我们就可以通过 nohup 指令让程序在后台运行。

后台运行

1). 后台运行程序

`1`	`nohup java -jar tilas-web-management-0.0.1-SNAPSHOT.jar &> tlias.log &`

通过上述指令就可以后台运行服务，服务运行之后，所有的日志信息都会输出到 tlias.log 文件中。

2). 停止服务

#查看服务的进程信息
ps -ef|grep tlias

#杀掉进程
kill -9 xxxxx

nohup命令说明:

nohup命令：英文全称 no hang up（不挂起），用于不挂断地运行指定命令，退出终端不会影响程序的运行

语法格式： nohup command [ args … ] [&]

参数说明：

command：要执行的命令

args：一些参数，可以指定输出文件

&：让命令在后台运行

举例：

nohup java -jar boot工程.jar &> hello.log &

上述指令的含义为：后台运行 java -jar 命令，并将日志输出到hello.log文件

元注解

Fri, 22 May 2026 21:39:37 +0800

元注解

Java中的元注解（Meta-Annotation），简单来说就是**“用来修饰注解的注解”**。

在Java中，我们可以自己定义注解，但光定义一个空壳注解是没用的。我们需要通过元注解来告诉编译器或JVM：这个自定义的注解能写在哪里？它的生命周期有多长？会不会被继承？

JDK原生提供了几个核心的元注解，其中最常用、最核心的有以下4个：

1. @Target（指定作用范围）

它用来限制你的注解可以写在哪些位置。比如，你希望某个注解只能写在方法上，或者只能写在类上，就需要用到它。它的取值是 ElementType 枚举，常见的有：

ElementType.TYPE：可以作用在类、接口、枚举上。
ElementType.FIELD：可以作用在成员变量（字段）上。
ElementType.METHOD：可以作用在成员方法上。
ElementType.PARAMETER：可以作用在方法参数上。

2. @Retention（指定生命周期）

它用来决定你的注解能保留到什么时候，这是元注解里最核心的一个。它的取值是 RetentionPolicy 枚举，分为三个阶段：

RetentionPolicy.SOURCE：注解只保留在源码中，编译成 .class 文件时就会被丢弃（比如我们常用的 @Override）。
RetentionPolicy.CLASS：注解保留在 .class 字节码文件中，但在JVM运行时不会被加载到内存（这是默认值）。
RetentionPolicy.RUNTIME：注解不仅保留在 .class 中，还会被JVM加载到内存。只有设置为 RUNTIME，你的程序才能在运行时通过反射（Reflection）获取到注解信息。我们平时用的 Spring 框架中的 @Autowired、@Controller 等，底层都是 RUNTIME。

3. @Documented（生成文档）

这是一个标记注解。默认情况下，使用 javadoc 工具生成API文档时，是不会把注解信息包含进去的。如果你的自定义注解上加了 @Documented，那么在生成文档时，这个注解也会作为说明的一部分出现在生成的 HTML 文档里。

4. @Inherited（允许继承）

它用来规定注解是否具有继承性。如果一个父类上加了被 @Inherited 修饰的注解，那么它的子类在没有加任何注解的情况下，会自动继承父类的这个注解。 注意：这个元注解只对类级别的注解（即 @Target 为 TYPE）有效，对方法和字段无效。

结合黑马课程实战举例

为了更好理解，我们正在学的 Spring 来举个例子。在 Spring Boot 中，我们经常用到 @RestController 或 @Service，这些其实就是 Spring 框架帮咱们定义好的自定义注解。

如果我们自己来模拟定义一个类似 @Service 的注解，代码大概长这样：

import java.lang.annotation.*;

// 1. @Target：规定这个 @MyService 注解只能写在类、接口或枚举上
@Target(ElementType.TYPE)
// 2. @Retention：规定这个注解要保留到程序运行时，这样Spring框架才能在启动时通过反射扫描到它
@Retention(RetentionPolicy.RUNTIME)
// 3. @Documented：生成文档时带上这个注解信息
@Documented
public @interface MyService {
    // 可以定义属性，比如给Bean起个名字
    String value() default "";
}

因为 @Retention 设置成了 RUNTIME，Spring 容器在启动的时候，才能通过反射机制去扫描你项目里的所有类，看看哪些类头上顶着 @MyService（或 @Service），然后把这些类自动创建成对象（Bean）并管理起来。

简单总结一下：元注解就是给自定义注解立规矩的“幕后大佬”，尤其是 @Target 和 @Retention，在后续学习 Spring 等框架的底层原理时会非常关键！

后端web进阶（SpringBoot原理）

Thu, 21 May 2026 20:52:49 +0800

后端web进阶(SpringBoot原理)

在前面的课程当中，我们学习的都是web开发的技术使用，都是面向应用层面的，我们学会了怎么样去用。而我们今天所要学习的是web后端开发的最后一个篇章springboot原理篇，主要偏向于底层原理。

这一篇的内容包括这么三个部分：

配置优先级
Bean的管理
剖析Springboot的底层原理

配置优先级

在我们前面的课程当中，我们已经讲解了SpringBoot项目当中支持的三类配置文件：

application.properties
application.yml
application.yaml

在SpringBoot项目当中，我们要想配置一个属性，可以通过这三种方式当中的任意一种来配置都可以，那么如果项目中同时存在这三种配置文件，且都配置了同一个属性，如：Tomcat端口号，到底哪一份配置文件生效呢？

application.properties

`1`	`server.port=8081`

application.yml

1
2

server:
   port: 8082

application.yaml

1
2

server:
   port: 8082

我们启动SpringBoot程序，测试下三个配置文件中哪个Tomcat端口号生效：

properties、yaml、yml三种配置文件同时存在。配置好了，启动服务，测试一下：

properties、yaml、yml三种配置文件，优先级最高的是properties

yaml、yml两种配置文件同时存在

aml、yml 两种配置文件，优先级最高的是yml。

配置文件优先级排名（从高到低）：

properties配置文件

yml配置文件

yaml配置文件

注意事项：虽然springboot支持多种格式配置文件，但是在项目开发时，推荐统一使用一种格式的配置。（yml是主流）

在SpringBoot项目当中除了以上3种配置文件外，SpringBoot为了增强程序的扩展性，除了支持配置文件的配置方式以外，还支持另外两种常见的配置方式：

Java系统属性配置（格式： -Dkey=value）

`1`	`-Dserver.port=9000`

命令行参数（格式：–key=value）

`1`	`--server.port=10010`

那在idea当中运行程序时，如何来指定Java系统属性和命令行参数呢？

编辑启动程序的配置信息

打开之后，选择 Modify options , 选择 Add VM options, Program arguments

重启服务，同时配置Tomcat端口(系统属性、命令行参数)，测试哪个Tomcat端口号生效：

说明，命令行参数的优先级是大于系统属性的，同时配置的情况下，命令行参数的配置项生效

重启服务，同时配置Tomcat端口(application.properties、系统属性)，测试哪个Tomcat端口号生效：

说明，系统属性的优先级是大于application.properties的，同时配置的情况下，系统属性的配置项生效

五种配置方式的优先级： 命令行参数 > 系统属性参数 > properties参数 > yml参数 > yaml参数

思考：如果项目已经打包上线了，这个时候我们又如何来设置Java系统属性和命令行参数呢？

`1`	`java -Dserver.port=9000 -jar XXXXX.jar --server.port=10010`

下面我们来演示下打包程序运行时指定Java系统属性和命令行参数：

执行maven打包指令package，把项目打成jar文件

此处打好的jar包并没有我们刚刚配置的命令行参数和系统属性

在当前目录下打开cmd命令行，使用命令：java -jar 方式运行jar文件程序。

如果不知道该如何操作可以先执行一个指令：java，执行之后就会给我们输出一个对应的帮助文档

系统属性和命令行参数两个都不设置

此时端口号就是我们刚刚设置的properties的端口号

仅设置Java系统属性

但此时会发现下面报错了，说端口号9000已经被占用了，这是因为我们的idea此时还开着，且端口号就是9000

同时设置Java系统属性和命令行参数

注意事项：

Springboot项目进行打包时，需要引入插件 spring-boot-maven-plugin (基于官网骨架创建项目，会自动添加该插件)

在SpringBoot项目当中，常见的属性配置方式有5种， 3种配置文件，加上2种外部属性的配置(Java系统属性、命令行参数)。通过以上的测试，我们也得出了优先级(从低到高)：

application.yaml（忽略）
application.yml
application.properties
java系统属性（-Dxxx=xxx）
命令行参数（–xxx=xxx）

Bean的管理

在前面的课程当中，我们已经讲过了我们可以通过Spring当中提供的注解@Component以及它的三个衍生注解（@Controller、@Service、@Repository）来声明IOC容器中的bean对象，同时我们也学习了如何为应用程序注入运行时所需要依赖的bean对象，也就是依赖注入DI。

我们今天主要学习IOC容器中Bean的其他使用细节，主要学习以下三方面：

bean的作用域配置
管理第三方的bean对象

接下来我们先来学习第一方面，Bean的作用域。

作用域	说明
singleton	容器内同名称的bean只有一个实例（单例）（默认）
prototype	每次使用bean时会创建新的实例（非单例）
request	每个请求范围内会创建新的实例（web环境中，了解）
session	每个会话范围内会创建新的实例（web环境中，了解）
application	每个应用范围内会创建新的实例（web环境中，了解）

知道了bean的5种作用域了，我们要怎么去设置一个bean的作用域呢？

可以借助Spring中的@Scope注解来进行配置作用域

1). 测试一:如果循环结果拿到的是同一个对象，那么就是单例的，否则是非单例的

控制器

//默认bean的作用域为：singleton (单例)：默认单例的bean是在项目启动时创建的，创建完毕后，会将bean存入IOC容器中
@Lazy	//延迟初始化 --> 延迟到第一次使用的时候，再来创建这个bean
@RestController
@RequestMapping("/depts")
public class DeptController {

    @Autowired
    private DeptService deptService;

    public DeptController(){
        System.out.println("DeptController constructor ....");
    }

    //省略其他代码...
}

测试类

package com.itheima;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

@SpringBootTest
class SpringbootWebConfig2ApplicationTests {

    @Autowired
    private ApplicationContext applicationContext; //IOC容器对象

    //bean的作用域
    @Test
    public void testScope(){
        for (int i = 0; i < 10; i++) {
            Object deptController = applicationContext.getBean("deptController");
            System.out.println(deptController);
        }
    }
}

重启SpringBoot服务，运行测试方法，查看控制台打印的日志：

默认单例是在项目启动时构建的（图中报红仅为一个JVM警告，不影响实际运行）

注意事项：

IOC容器中的bean默认使用的作用域：singleton (单例)
默认singleton的bean，在容器启动时被创建，可以使用@Lazy注解来延迟初始化(延迟到第一次使用时)

2). 测试二

修改控制器DeptController代码：

@Scope("![rototype日](assets/prototype日志.png)") //bean作用域为非单例
@RestController
@RequestMapping("/depts")
public class DeptController {

    @Autowired
    private DeptService deptService;

    public DeptController(){
        System.out.println("DeptController constructor ....");
    }

    //省略其他代码...
}

重启SpringBoot服务，再次执行测试方法，查看控制台打印的日志：

注意事项：

prototype的bean，每一次使用该bean的时候都会创建一个新的实例

实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性

小结：

第三方bean

学习完bean的获取、bean的作用域之后，接下来我们再来学习第三方bean的配置。

之前我们所配置的bean，像controller、service，dao三层体系下编写的类，这些类都是我们在项目当中自己定义的类(自定义类)。当我们要声明这些bean，也非常简单，我们只需要在类上加上@Component以及它的这三个衍生注解（@Controller、@Service、@Repository），就可以来声明这个bean对象了。

但是在我们项目开发当中，还有一种情况就是这个类它不是我们自己编写的，而是我们引入的第三方依赖当中提供的，那么此时我们是无法使用 @Component 及其衍生注解来声明bean的，此时就需要使用**@Bean**注解来声明bean 了。

演示1：

在启动类中直接声明这个Bean。比如：我们可以将我们之前使用的阿里云OSS操作的工具类，基于@Bean注解的方式来声明Bean。

package com.itheima;

import com.itheima.utils.AliyunOSSOperator;
import com.itheima.utils.AliyunOSSProperties;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;


@SpringBootApplication
public class SpringbootWebConfigApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfigApplication.class, args);
    }

    @Bean
    public AliyunOSSOperator aliyunOSSOperator(AliyunOSSProperties ossProperties) {
        return new AliyunOSSOperator(ossProperties);
    }
}

测试：

package com.itheima;


import cn.hutool.core.io.FileUtil;

import com.itheima.utils.AliyunOSSOperator;
import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

import java.io.File;

@SpringBootTest
class SpringbootWebConfig2ApplicationTests {

    @Autowired
    private ApplicationContext applicationContext; //IOC容器对象

    @Autowired
    private AliyunOSSOperator aliyunOSSOperator;

    //bean的作用域
    @Test
    public void testScope(){
        for (int i = 0; i < 10; i++) {
            Object deptController = applicationContext.getBean("deptController");
            System.out.println(deptController);
        }
    }

    @Test
    public void testupload() throws Exception {
        File file = new File("D:\\picture\\111.jpg");
        String url = aliyunOSSOperator.upload(FileUtil.readBytes(file), "111.jpg");
        System.out.println(url);
    }
}

演示2：

若要管理的第三方 bean 对象，建议对这些bean进行集中分类配置，可以通过 @Configuration 注解声明一个配置类。【推荐】

package com.itheima.config;

import com.itheima.utils.AliyunOSSOperator;
import com.itheima.utils.AliyunOSSProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class OSSConfig {
    @Bean
    public AliyunOSSOperator aliyunOSSOperator(AliyunOSSProperties ossProperties) {
        return new AliyunOSSOperator(ossProperties);
    }
}

SpringBoot原理

SpringBoot使我们能够集中精力地去关注业务功能的开发，而不用过多地关注框架本身的配置使用。而我们前面所讲解的都是面向应用层面的技术，接下来我们开始学习SpringBoot的原理，这部分内容偏向于底层的原理分析。

在剖析SpringBoot的原理之前，我们先来快速回顾一下我们前面所讲解的Spring家族的框架。

Spring是目前世界上最流行的Java框架，它可以帮助我们更加快速、更加容易的来构建Java项目。而在Spring家族当中提供了很多优秀的框架，而所有的框架都是基于一个基础框架的SpringFramework(也就是Spring框架)。而前面我们也提到，如果我们直接基于Spring框架进行项目的开发，会比较繁琐。

这个繁琐主要体现在两个地方：

在pom.xml中依赖配置比较繁琐，在项目开发时，需要自己去找到对应的依赖，还需要找到依赖它所配套的依赖以及对应版本，否则就会出现版本冲突问题。
在使用Spring框架进行项目开发时，需要在Spring的配置文件中做大量的配置，这就造成Spring框架入门难度较大，学习成本较高。
- 基于Spring存在的问题，官方在Spring框架4.0版本之后，又推出了一个全新的框架：SpringBoot。
- 通过 SpringBoot来简化Spring框架的开发(是简化不是替代)。我们直接基于SpringBoot来构建Java项目，会让我们的项目开发更加简单，更加快捷。

SpringBoot框架之所以使用起来更简单更快捷，是因为SpringBoot框架底层提供了两个非常重要的功能：一个是起步依赖，一个是自动配置。

通过SpringBoot所提供的起步依赖，就可以大大的简化pom文件当中依赖的配置，从而解决了Spring框架当中依赖配置繁琐的问题。

通过自动配置的功能就可以大大的简化框架在使用时bean的声明以及bean的配置。我们只需要引入程序开发时所需要的起步依赖，项目开发时所用到常见的配置都已经有了，我们直接使用就可以了。

简单回顾之后，接下来我们来学习下SpringBoot的原理。其实学习SpringBoot的原理就是来解析SpringBoot当中的起步依赖与自动配置的原理。我们首先来学习SpringBoot当中起步依赖的原理。

起步依赖

假如我们没有使用SpringBoot，用的是Spring框架进行web程序的开发，此时我们就需要引入web程序开发所需要的一些依赖。

当我们引入了 spring-boot-starter-web 之后，maven会通过依赖传递特性，将web开发所需的常见依赖都传递下来。

所以，起步依赖的原理就是Maven的依赖传递。

在SpringBoot给我们提供的这些起步依赖当中，已提供了当前程序开发所需要的所有的常见依赖(官网地址：https://docs.spring.io/spring-boot/docs/2.7.7/reference/htmlsingle/#using.build-systems.starters)。

比如：springboot-starter-web，这是web开发的起步依赖，在web开发的起步依赖当中，就集成了web开发中常见的依赖：json、web、webmvc、tomcat等。我们只需要引入这一个起步依赖，其他的依赖都会自动的通过Maven的依赖传递进来。

自动配置

SpringBoot的自动配置就是当spring容器启动后，一些配置类、bean对象就自动存入到了IOC容器中，不需要我们手动去声明，从而简化了开发，省去了繁琐的配置操作。

比如，在我们前面讲解AOP记录日志的那个案例中，我们要将一个对象转为json，直接注入一个Gson，然后就可以直接使用了。而我们在我们整个项目中，也并未配置Gson这个类型的bean，为什么可以直接注入使用呢？原因就是因为这个bean，springboot中已经帮我们自动配置完毕了，我们是可以直接使用的。

我们可以在SpringBootWebTests中进行一个测试：在文件中添加这几行代码

@Autowired
private Gson gson;

@Test
public void testJson() {
    System.out.println(gson.toJson(Result.success("Hello Gson")));
}

可以发现当前项目中我们没有去声明gson这个bean，但是我们却可以直接将这个bean注入进来使用它，这是Springboot给我们提供的功能

那接下来，我们就要来解析，SpringBoot中到底是如何完成自动配置的。

实现方案

我们知道了什么是自动配置之后，接下来我们就要来剖析自动配置的原理。解析自动配置的原理就是分析在 SpringBoot项目当中，我们引入对应的依赖之后，是如何将依赖jar包当中所提供的bean以及配置类直接加载到当前项目的SpringIOC容器当中的。

接下来，我们就直接通过代码来分析自动配置原理。

准备工作：在Idea中导入"资料\03. 自动配置原理" 下的 itheima-utils 工程
在SpringBoot项目 spring-boot-web-config 工程中，通过坐标引入itheima-utils依赖

1、引入的 itheima-utils 中配置如下:

@Component
public class TokenParser {
    public void parse(){
        System.out.println("TokenParser ... parse ...");
    }
}

2、在测试类中，添加测试方法

@SpringBootTest
public class AutoConfigurationTests {
    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void testTokenParse(){
        tokenParser.parse();
    }

    //省略其他代码...
}

3、执行测试方法

（框架报的错一定要从下往上看）

异常信息描述：没有com.example.TokenParse类型的bean

说明：在Spring容器中没有找到com.example.TokenParse类型的bean对象

思考：引入进来的第三方依赖当中的bean以及配置类为什么没有生效？

原因在我们之前讲解IOC的时候有提到过，在类上添加@Component注解来声明bean对象时，还需要保证@Component注解能被Spring的组件扫描到。
SpringBoot项目中的@SpringBootApplication注解，具有包扫描的作用，但是它只会扫描启动类所在的当前包以及子包。
当前包：com.itheima，第三方依赖中提供的包：com.example（扫描不到）

那么如何解决以上问题的呢？

方案1：@ComponentScan 组件扫描
方案2：@Import 导入（使用@Import导入的类会被Spring加载到IOC容器

方案一

@ComponentScan组件扫描【在启动类上添加@ComponentScan要扫描的包】

@SpringBootApplication
@ComponentScan({"com.itheima","com.example"}) //指定要扫描的包
public class SpringbootWebConfigApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfigApplication.class, args);
    }
}

重新执行测试方法，控制台日志输出：

如果采用以上这种方式来完成自动配置，那我们进行项目开发时，就需要引入大量的第三方的依赖，就需要在启动类上配置N多要扫描的包，这种方式会很繁琐。而且这种大面积的扫描性能也比较低。

缺点：

使用繁琐

性能低

结论：SpringBoot中并没有采用以上这种方案。

方案二

@Import导入

导入形式主要有以下几种：
- 导入普通类
- 导入配置类
- 导入ImportSelector接口实现类

1). 使用@Import导入普通类：

@Import(TokenParser.class) //导入的类会被Spring加载到IOC容器中
@SpringBootApplication
public class SpringbootWebConfigApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfigApplication.class, args);
    }
}

重新执行测试方法，控制台日志输出：

2). 使用@Import导入配置类：

配置类

@Configuration
public class HeaderConfig {
    @Bean
    public HeaderParser headerParser(){
        return new HeaderParser();
    }

    @Bean
    public HeaderGenerator headerGenerator(){
        return new HeaderGenerator();
    }
}

启动类

@Import(HeaderConfig.class) //导入配置类
@SpringBootApplication
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}

测试类

@SpringBootTest
public class AutoConfigurationTests {
    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void testHeaderParser(){
        System.out.println(applicationContext.getBean(HeaderParser.class));
    }

    @Test
    public void testHeaderGenerator(){
        System.out.println(applicationContext.getBean(HeaderGenerator.class));
    }
    
    //省略其他代码...
}

执行测试方法：

这里就测试testHeaderParser，第二个方法结果一样就不展示了

3). 使用@Import导入ImportSelector接口实现类：

ImportSelector接口实现类

public class MyImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //返回值字符串数组（数组中封装了全限定名称的类，可以一次性导入多个类）
        return new String[]{"com.example.HeaderConfig","com.example.TokenParser"};
    }
}

启动类

@Import(MyImportSelector.class) //导入ImportSelector接口实现类
@SpringBootApplication
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}

执行测试方法：

我们就拿上面的配置类的测试方案来测试，虽然注释掉了配置类的@import会导致报错，但是由于我们导入了接口实现类，而接口实现类中又有配置类的方法，所以此时报错是误报，直接运行即可

我们使用@Import注解通过这三种方式都可以导入第三方依赖中所提供的bean或者是配置类。

思考：如果基于以上方式完成自动配置，当要引入一个第三方依赖时，是不是还要知道第三方依赖中有哪些配置类和哪些Bean对象？

答案：是的。（对程序员来讲，很不友好，而且比较繁琐）

思考：当我们要使用第三方依赖，依赖中到底有哪些bean和配置类，谁最清楚？

答案：第三方依赖自身最清楚。

结论：我们不用自己指定要导入哪些bean对象和配置类了，让第三方依赖它自己来指定。

怎么让第三方依赖自己指定bean对象和配置类？

比较常见的方案就是第三方依赖给我们提供一个注解，这个注解一般都以@EnableXxxx开头的注解，注解中封装的就是@Import注解

4). 使用第三方依赖提供的 @EnableXxxxx注解

第三方依赖中提供的注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyImportSelector.class)//指定要导入哪些bean对象或配置类
public @interface EnableHeaderConfig { 
}

在使用时只需在启动类上加上@EnableXxxxx注解即可

![HC注](assets/EHC注解.png) //使用第三方依赖提供的Enable开头的注解
@SpringBootApplication
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}

执行测试方法：

以上四种方式都可以完成导入操作，但是第4种方式会更方便更优雅，而这种方式也是SpringBoot当中所采用的方式。

原理分析

源码跟踪

前面我们讲解了在项目当中引入第三方依赖之后，如何加载第三方依赖中定义好的bean对象以及配置类，从而完成自动配置操作。那下面我们通过源码跟踪的形式来剖析下SpringBoot底层到底是如何完成自动配置的。

源码跟踪技巧：

在跟踪框架源码的时候，一定要抓住关键点，找到核心流程。一定不要从头到尾一行代码去看，一个方法的去研究，一定要找到关键流程，抓住关键点，先在宏观上对整个流程或者整个原理有一个认识，有精力再去研究其中的细节。

要搞清楚SpringBoot的自动配置原理，要从SpringBoot启动类上使用的核心注解@SpringBootApplication开始分析：【按住Ctrl点击@SpringBootApplication】

在@SpringBootApplication注解中包含了：

元注解（详见博客<元注解>）
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
我们先来看第一个注解：@SpringBootConfiguration

@SpringBootConfiguration注解上使用了@Configuration，表明SpringBoot启动类就是一个配置类。

@Indexed注解，是用来加速应用启动的（不用关心）。

接下来再先看@ComponentScan注解：

@ComponentScan注解是用来进行组件扫描的，扫描启动类所在的包及其子包下所有被@Component及其衍生注解声明的类。

SpringBoot启动类，之所以具备扫描包功能，就是因为包含了@ComponentScan注解。

最后我们来看看@EnableAutoConfiguration注解（自动配置核心注解）：

使用@Import注解，导入了实现ImportSelector接口的实现类。

AutoConfigurationImportSelector类是ImportSelector接口的实现类。

AutoConfigurationImportSelector类中重写了ImportSelector接口的selectImports()方法：

selectImports()方法底层调用getAutoConfigurationEntry()方法，获取可自动配置的配置类信息集合

getAutoConfigurationEntry()方法通过调用getCandidateConfigurations(annotationMetadata, attributes)方法获取在配置文件中配置的所有自动配置类的集合

getCandidateConfigurations方法的功能：

获取所有基于 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中配置类的集合

META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件这两个文件在哪里呢？

通常在引入的起步依赖中，都有包含以上文件

在前面在给大家演示自动配置的时候，我们直接在测试类当中注入了一个叫gson的bean对象，进行JSON格式转换。虽然我们没有配置bean对象，但是我们是可以直接注入使用的。原因就是因为在自动配置类当中做了自动配置。到底是在哪个自动配置类当中做的自动配置呢？我们通过搜索来查询一下。

在META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 配置文件中指定了第三方依赖Gson的配置类：GsonAutoConfiguration

打开上面的第三方依赖中提供的 GsonAutoConfiguration 类：【按两下shift搜索完双击进入】

在GsonAutoConfiguration类上，添加了注解@AutoConfiguration，通过查看源码，可以明确：GsonAutoConfiguration 类是一个配置。

完成自动配置的原理就是在配置类中定义一个@Bean标识的方法，而Spring会自动调用配置类中使用@Bean标识的方法，并把方法的返回值注册到IOC容器中。

注意：在低版本(2.7.0以前)的springboot中，自动配置类(XxxAutoConfiguration)是定义在spring.factories文件中

自动配置源码小结

自动配置原理源码入口就是 @SpringBootApplication 注解，在这个注解中封装了3个注解，分别是：

@SpringBootConfiguration
- 声明当前类是一个配置类
@ComponentScan
- 进行组件扫描（SpringBoot中默认扫描的是启动类所在的当前包及其子包）
@EnableAutoConfiguration
- 封装了@Import注解（Import注解中指定了一个ImportSelector接口的实现类）
- 在实现类重写的selectImports()方法，读取当前项目下所有依赖jar包中META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports两个文件里面定义的配置类（配置类中定义了@Bean注解标识的方法）。

当SpringBoot程序启动时，就会加载配置文件当中所定义的配置类，并将这些配置类信息(类的全限定名)封装到String类型的数组中，最终通过@Import注解将这些配置类全部加载到Spring的IOC容器中，交给IOC容器管理。

在 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件中定义的配置类非常多，而且每个配置类中又可以定义很多的bean，那这些bean都会注册到Spring的IOC容器中吗？

答案：并不是。在声明bean对象时，上面有加一个 @ConditionalOnMissingBean 注解，这种注解的作用就是按照条件进行装配，只有满足条件之后，才会将bean注册到Spring的IOC容器中（下面会详细来讲解）

@Conditional

我们在跟踪SpringBoot自动配置的源码的时候，在自动配置类声明bean的时候，除了在方法上加了一个@Bean注解以外，还会经常用到一个注解，就是以Conditional开头的这一类的注解。以Conditional开头的这些注解都是条件装配的注解。下面我们就来介绍下条件装配注解。

@Conditional注解：

作用：按照一定的条件进行判断，在满足给定条件后才会注册对应的bean对象到Spring的IOC容器中。
位置：方法、类
@Conditional本身是一个父注解，派生出大量的子注解，最常见的有以下三种：
- @ConditionalOnClass：判断环境中有对应字节码文件，才注册bean到IOC容器。
- @ConditionalOnMissingBean：判断环境中没有对应的bean(类型或名称)，才注册bean到IOC容器。
- @ConditionalOnProperty：判断配置文件中有对应属性和值，才注册bean到IOC容器。

下面我们通过代码来演示下Conditional注解的使用：

@ConditionalOnClass注解

@Configuration
public class HeaderConfig {

    @Bean
    @ConditionalOnClass(name="io.jsonwebtoken.Jwts")//环境中存在指定的这个类，才会将该bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    
    //省略其他代码...
}

pom.xml（如果没有就会报错）

<!--JWT令牌-->
<dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.1</version>
</dependency>

测试类

@SpringBootTest
public class SpringbootWebConfig2ApplicationTests {
    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void testHeaderParser(){
        System.out.println(applicationContext.getBean(HeaderParser.class));
    }
    
    //省略其他代码...
}

执行testHeaderParser()测试方法：

因为 io.jsonwebtoken.Jwts 字节码文件在启动SpringBoot程序时已存在，所以创建HeaderParser对象并注册到IOC容器中。

@ConditionalOnMissingBean注解

@Configuration
public class HeaderConfig {
        
    @Bean
    @ConditionalOnMissingBean //不存在该类型的bean，才会将该bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    
    //省略其他代码...
}

执行testHeaderParser()测试方法：

SpringBoot在调用@Bean标识的headerParser()前，IOC容器中是没有HeaderParser类型的bean，所以HeaderParser对象正常创建，并注册到IOC容器中。

再次修改@ConditionalOnMissingBean注解：如果已经存在，条件不满足，Spring就会跳过当前被该注解标注的Bean的创建（此时已经存在指定类型的bean了）

@Configuration
public class HeaderConfig {

    @Bean
    @ConditionalOnMissingBean//不存在指定类型的bean，才会将该bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    
    //省略其他代码...
}

执行testHeaderParser()测试方法：

@ConditionalOnProperty注解（这个注解和配置文件当中配置的属性有关系）

先在application.yml配置文件中添加如下的键值对：

`1`	`name: itheima`

在声明bean的时候就可以指定一个条件@ConditionalOnProperty

@Configuration
public class HeaderConfig {

    @Bean
    @ConditionalOnProperty(name ="name",havingValue = "itheima")//配置文件中存在指定属性名与值，才会将bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }

    @Bean
    public HeaderGenerator headerGenerator(){
        return new HeaderGenerator();
    }
}

执行testHeaderParser()测试方法：

修改@ConditionalOnProperty注解： havingValue的值修改为"itheima2"

再次执行testHeaderParser()测试方法：

因为 application.yml 配置文件中，不存在： name: itheima2，所以HeaderParser对象在IOC容器中不存在

我们再回头看看之前讲解SpringBoot源码时提到的一个配置类：GsonAutoConfiguration

最后再来梳理一下自动配置原理：

自动配置的核心就在@SpringBootApplication注解上，SpringBootApplication这个注解底层包含了3个注解，分别是：

@SpringBootConfiguration

@ComponentScan

@EnableAutoConfiguration

@EnableAutoConfiguration这个注解才是自动配置的核心。

它封装了一个@Import注解，Import注解里面指定了一个ImportSelector接口的实现类。

在这个实现类中，重写了ImportSelector接口中的selectImports()方法。

而selectImports()方法中会去读取两份配置文件，并将配置文件中定义的配置类作为selectImports()方法的返回值返回，返回值代表的就是需要将哪些类交给Spring的IOC容器进行管理。

那么所有自动配置类的中声明的bean都会加载到Spring的IOC容器中吗? 其实并不会，因为这些配置类中在声明bean时，通常都会添加@Conditional开头的注解，这个注解就是进行条件装配。而Spring会根据Conditional注解有选择性的进行bean的创建。

@Enable 开头的注解底层，它就封装了一个注解： import 注解，它里面指定了一个类，是 ImportSelector 接口的实现类。在实现类当中，我们需要去实现 ImportSelector 接口当中的一个方法 selectImports 这个方法。这个方法的返回值代表的就是我需要将哪些类交给 spring 的 IOC容器进行管理。

此时它会去读取两份配置文件，一份是 spring.factories，另外一份是autoConfiguration.imports。而在 autoConfiguration.imports 这份文件当中，它就会去配置大量的自动配置的类。

而前面我们也提到过这些所有的自动配置类当中，所有的 bean都会加载到 spring 的 IOC 容器当中吗？其实并不会，因为这些配置类当中，在声明 bean 的时候，通常会加上这么一类@Conditional 开头的注解。这个注解就是进行条件装配。所以SpringBoot非常的智能，它会根据 @Conditional 注解来进行条件装配。只有条件成立，它才会声明这个bean，才会将这个 bean 交给 IOC 容器管理。

自定义starter

分析

前面我们解析了SpringBoot中自动配置的原理，下面我们就通过一个自定义starter案例来加深对于自动配置原理的理解。首先介绍一下自定义starter的业务场景，再来分析一下具体的操作步骤。

所谓starter指的就是SpringBoot当中的起步依赖。在SpringBoot当中已经给我们提供了很多的起步依赖了，我们为什么还需要自定义 starter 起步依赖？

这是因为在实际的项目开发当中，我们可能会用到很多第三方的技术，并不是所有的第三方的技术官方都给我们提供了与SpringBoot整合的starter起步依赖，但是这些技术又非常的通用，在很多项目组当中都在使用。

业务场景：

我们前面案例当中所使用的阿里云OSS对象存储服务，现在阿里云的官方是没有给我们提供对应的起步依赖的，这个时候使用起来就会比较繁琐，我们需要引入对应的依赖。我们还需要在配置文件当中进行配置，还需要基于官方SDK示例来改造对应的工具类，我们在项目当中才可以进行使用。
大家想在我们当前项目当中使用了阿里云OSS，我们需要进行这么多步的操作。在别的项目组当中要想使用阿里云OSS，是不是也需要进行这么多步的操作，所以这个时候我们就可以自定义一些公共组件，在这些公共组件当中，我就可以提前把需要配置的bean都提前配置好。将来在项目当中，我要想使用这个技术，我直接将组件对应的坐标直接引入进来，就已经自动配置好了，就可以直接使用了。我们也可以把公共组件提供给别的项目组进行使用，这样就可以大大的简化我们的开发。

在SpringBoot项目中，一般都会将这些公共组件封装为SpringBoot当中的starter，也就是我们所说的起步依赖。

而在springboot中，官方提供的起步依赖或第三方提供的起步依赖，基本都会包含两个模块，如下所示：

其中，spring-boot-starter 或 xxx-spring-boot-starter 这个模块主要是依赖管理的功能。而 spring-boot-autoconfigure 或 xxxx-spring-boot-autoconfigure 主要是起到自动配置的作用，自动配置的核心代码就在这个模块中编写。

例如我们当前项目中的起步依赖：

：

SpringBoot官方starter命名： spring-boot-starter-xxxx

第三组织提供的starter命名： xxxx-spring-boot-starter

SpringBoot官方的自动配置依赖 spring-boot-autoconfigure 中就提供了配置类，并且也提供了springboot会自动读取的配置文件。当SpringBoot项目启动时，会读取到META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports配置文件中的配置类并加载配置类，生成相关bean对象注册到IOC容器中。

结果：我们可以直接在SpringBoot程序中使用自动配置的bean对象。

在自定义一个起步依赖starter的时候，按照规范需要定义两个模块：

starter模块（进行依赖管理[把程序开发所需要的依赖都定义在starter起步依赖中]）
autoconfigure模块（自动配置）

将来在项目当中进行相关功能开发时，只需要引入一个起步依赖就可以了，因为它会将autoconfigure自动配置的依赖给传递下来。

需求

上面我们简单介绍了自定义starter的场景，以及自定义starter时涉及到的模块之后，接下来我们就来完成一个自定义starter的案例。

需求：自定义aliyun-oss-spring-boot-starter，完成阿里云OSS操作工具类 AliyunOSSOperator 的自动配置。
目标：引入起步依赖引入之后，要想使用阿里云OSS，注入AliyunOSSOperator 直接使用即可。

之前我们的用法：

1). 在pom.xml中引入阿里云oss的所有依赖

<!--阿里云OSS-->
<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-sdk-oss</artifactId>
    <version>3.17.4</version>
</dependency>
<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.1</version>
</dependency>
<dependency>
    <groupId>javax.activation</groupId>
    <artifactId>activation</artifactId>
    <version>1.1.1</version>
</dependency>
<!-- no more than 2.3.3-->
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>2.3.3</version>
</dependency>

2). application.yml 中配置阿里云OSS的配置信息

#阿里云oss配置
aliyun:
  oss:
    endpoint: https://oss-cn-beijing.aliyuncs.com
    bucketName: java-ai-26-5-07
    region: cn-beijing

3). 定义实体类封装配置信息

package com.itheima.utils;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliyunOSSProperties {
    private String endpoint;
    private String bucketName;
}

4). 定义工具类AliyunOSSOperator

package com.itheima.utils;

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import com.aliyun.oss.model.OSSObjectSummary;
import com.aliyun.oss.model.ObjectListing;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

@Component
public class AliyunOSSOperator {

    @Autowired
    private AliyunOSSProperties aliyunOSSProperties;

    /**
     * 文件上传
     */
    public String upload(byte[] content, String originalFilename) throws Exception {
        String endpoint = aliyunOSSProperties.getEndpoint();
        String bucketName = aliyunOSSProperties.getBucketName();

        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();

        // 填写Object完整路径，例如202406/1.png。Object完整路径中不能包含Bucket名称。
        //获取当前系统日期的字符串,格式为 yyyy/MM
        String dir = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy/MM"));
        //根据原始文件名originalFilename, 生成一个新的不重复的文件名
        String newFileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));
        String objectName = dir + "/" + newFileName;

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        //文件上传
        try {
            ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(content));
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }

        return endpoint.split("//")[0] + "//" + bucketName + "." + endpoint.split("//")[1] + "/" + objectName;
    }


    /**
     * 查询文件列表
     */
    public List<String> listFiles() throws Exception {
        String endpoint = aliyunOSSProperties.getEndpoint();
        String bucketName = aliyunOSSProperties.getBucketName();
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 指定前缀，例如exampledir/object。
        String keyPrefix = null;

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        try {
            // 列举文件。如果不设置keyPrefix，则列举存储空间下的所有文件。如果设置keyPrefix，则列举包含指定前缀的文件。
            ObjectListing objectListing = ossClient.listObjects(bucketName, keyPrefix);
            List<OSSObjectSummary> sums = objectListing.getObjectSummaries();
            if(sums != null && !sums.isEmpty()){
                return sums.stream().map(OSSObjectSummary::getKey).collect(Collectors.toList());
            }
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
        return null;
    }

    /**
     * 删除指定对象
     */
    public void deleteFile(String objectName) throws Exception {
        String endpoint = aliyunOSSProperties.getEndpoint();
        String bucketName = aliyunOSSProperties.getBucketName();

        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        try {
            // 删除文件或目录。如果要删除目录，目录必须为空。
            ossClient.deleteObject(bucketName, objectName);
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }

}

5). 其他地方要使用阿里云OSS，注入工具类，再使用

@Slf4j
@RestController
public class UploadController {
    @Autowired
    private AliyunOSSOperator aliyunOSSOperator;

    /**
     * 文件上传
     */
    @PostMapping("/upload")
    public Result upload(MultipartFile file) throws Exception {
        log.info("上传文件：{}",file.getOriginalFilename());
        //调用aliyun OSS进行文件上传
        String url = aliyunOSSOperator.upload(file.getBytes(), file.getOriginalFilename());
        //返回结果
        return Result.success(url);
    }
}

我们可以看到，在项目中使用阿里云OSS，需要这么五步操作，而阿里云OSS这个云服务还是非常常见的，很多项目中都要使用。

现在我们使用阿里云OSS，需要做这么几步，将来在开发其他的项目的时候，使用阿里云OSS，这几步要不要做？当团队中其他小伙伴也在使用阿里云OSS的时候，步骤不也是一样的。

所以这个时候我们就可以制作一个公共组件(自定义starter)。starter定义好之后，将来要使用阿里云OSS进行文件上传，只需要将起步依赖引入进来之后，就可以直接注入 AliyunOSSOperator 使用了。

实现

需求明确了，接下来我们再来分析一下具体的实现步骤：

第1步：创建自定义starter模块 aliyun-oss-spring-boot-starter（进行依赖管理）
- 把阿里云OSS所有的依赖统一管理起来
第2步：创建autoconfigure模块 aliyun-oss-spring-boot-autoconfigure
- 在starter中引入autoconfigure （我们使用时只需要引入starter起步依赖即可）
第3步：在autoconfigure模块aliyun-oss-spring-boot-autoconfigure中完成自动配置
- 定义一个自动配置类，在自动配置类中将所要配置的bean都提前配置好
- 定义配置文件，把自动配置类的全类名定义在配置文件(META-INF/spring/xxxx.imports)中

下面我们就按照分析的步骤来实现自定义starter。

首先我们先来创建两个Maven模块：

1). 创建aliyun-oss-spring-boot-starter

选择springboot的版本，不需要勾选任何的依赖。直接点击 create 创建项目。

创建完starter模块后，删除多余的文件，只保留一个pom.xml文件。最终保留内容如下：

pom.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.5.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-springboot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>aliyun-oss-springboot-starter</name>
    <description>aliyun-oss-springboot-starter</description>

    <properties>
        <java.version>17</java.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

</project>

2). 创建aliyun-oss-spring-boot-autoconfigure模块

选择Springboot的版本，不用勾选任何依赖。

截图见第一步

创建完starter模块后，删除多余的文件，只保留 src 和 pom.xml 。最终保留内容如下：

该模块的pom.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.5.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>aliyun-oss-spring-boot-autoconfigure</name>
    <description>aliyun-oss-spring-boot-autoconfigure</description>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

</project>

按照我们之前的分析，是需要在starter模块中来引入autoconfigure这个模块的。打开starter模块中的pom文件：

<?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.5.13<version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

前两步已经完成了，接下来是最关键的就是第三步：在aliyun-oss-spring-boot-autoconfigure模块当中来完成自动配置操作。

我们将之前案例中所使用的阿里云OSS部分的代码直接拷贝到autoconfigure模块下，然后进行改造就行了。

拷贝过来后，还缺失一些相关的依赖，需要把相关依赖也拷贝过来：

<?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.5.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--阿里云OSS依赖-->
        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-sdk-oss</artifactId>
            <version>3.18.4</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.1</version>
        </dependency>

        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- no more than 2.3.3-->
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.3</version>
        </dependency>

    </dependencies>

</project>

此时需要将之前常见的AliyunOSSOperator文件和AliyunOSSProperties文件拷贝到com.aliyun.oss目录下

此时会发现这两个文件报错了，原因是没有引入如下依赖：

		<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

但是此时没有别的地方需要到这个依赖，能少引入依赖是最好的，所以我们此时直接在AliyunOSSProperties文件中添加构造方法和toString()方法即可

public String getEndpoint() {
    return endpoint;
}

public void setEndpoint(String endpoint) {
    this.endpoint = endpoint;
}

public String getBucketName() {
    return bucketName;
}

public void setBucketName(String bucketName) {
    this.bucketName = bucketName;
}

public String getRegion() {
    return region;
}

public void setRegion(String region) {
    this.region = region;
}

@Override
public String toString() {
    return "AliyunOSSProperties{" +
            "endpoint='" + endpoint + '\'' +
            ", bucketName='" + bucketName + '\'' +
            ", region='" + region + '\'' +
            '}';
}

那此时在类上添加的 @Component 注解还有用吗？

答案：没用了。在SpringBoot项目中，并不会去扫描com.aliyun.oss这个包，不扫描这个包那类上的注解也就失去了作用。

@Component注解不需要使用了，可以从类上删除了。

1). 删除 AliyunOSSOperator 工具类上的 @Component 注解和 @Autowired 注解。

2). 删除 AliyunOSSProperties 实体类上的 @Component 注解。

删除后如果报红色错误，暂时不理会，后面再来处理。

3). 既然不能用 @Component 注解声明bean，那就需要按照 starter 的定义规范，定义一个自动配置类，在自动配置类中声明bean。

下面我们就要定义一个自动配置类 AliOSSAutoConfiguration 了，在自动配置类当中来声明 AliOSSOperator 的bean对象。

具体代码如下：

package com.aliyun.oss;

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(AliyunOSSProperties.class)
public class AliyunOSSAutoConfiguration {
    
    @Bean
    public AliyunOSSOperator aliyunOSSOperator(AliyunOSSProperties aliyunOSSProperties) {
        return new AliyunOSSOperator(aliyunOSSProperties);
    }
    
}

AliyunOSSOperator 的代码中需要增加一个有参构造，将 AliyunOSSProperties 对象传递给工具类。代码改造如下：

4). 在 aliyun-oss-spring-boot-autoconfigure 模块中的resources下，新建自动配置文件 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

将自动配置类的全类名，配置在文件中，这样在springboot启动的时候，就会加载到这份文件，并加载到其中的配置类了。

配置内容如下：

`1`	`com.aliyun.oss.AliyunOSSAutoConfiguration`

到此呢，这个 aliyun-oss-spring-boot-stater 就定义好了，哪里要想使用，就可以直接导入依赖，直接注入使用了。

测试

阿里云OSS的starter我们刚才已经定义好了，接下来我们就来做一个测试。

导入课程资料中的测试工程springboot-autoconfiguration-test

测试前准备：

1). 在导入的test工程中引入阿里云starter依赖

<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-springboot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

2). 在导入的test工程中的 application.yml 中配置阿里云OSS的配置信息

#阿里云OSS
aliyun:
  oss:
    endpoint: https://oss-cn-beijing.aliyuncs.com
    bucketName: java-ai-26-5-07
    region: cn-beijing

3). 在test工程中的 UploadController 类编写代码

package com.itheima.controller;

import com.aliyun.oss.AliyunOSSOperator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class UploadController {
    
    @Autowired
    private AliyunOSSOperator aliyunOSSOperator;
    
    @PostMapping("/upload")
    public String upload(MultipartFile image) throws Exception {
        //上传文件到阿里云 OSS
        String url = aliyunOSSOperator.upload(image.getBytes(), image.getOriginalFilename());
        return url;
    }
    
}

编写完代码后，我们启动当前的SpringBoot测试工程，使用Apifox工具进行文件上传：

这样，我们就完成了starter的定义。在其他项目中要想使用，引入依赖，配置一下阿里云OSS的信息，就可以直接注入是用了。

后端web进阶（Maven高级）

Thu, 21 May 2026 20:50:02 +0800

后端web进阶(Maven高级)

Web开发讲解完毕之后，我们再来学习Maven高级。其实在前面的课程当中，我们已经学习了Maven。

我们讲到 Maven 是一款构建和管理 Java 项目的工具。经过前面十几天 web 开发的学习，相信大家对于 Maven 这款工具的基本使用应该没什么问题了。我们掌握了 Maven 工具的基本使用之后，其实对于一些简单的项目的构建及管理基本上就没什么问题了。

但是如果我们需要开发一些中大型的项目，此时仅凭我们前面所学习的 Maven 的基础知识就比较难以应对了。所以我们接下来还需要学习 Maven 提供的一些高级的功能，这些功能在构建和管理 Java 项目的时候用的也是非常多的。

Maven高级内容包括:

分模块设计与开发

继承与聚合

私服

分模块设计与开发

介绍

所谓分模块设计，顾名思义指的就是我们在设计一个 Java 项目的时候，将一个 Java 项目拆分成多个模块进行开发。

1). 未分模块设计的问题

如果项目不分模块，也就意味着所有的业务代码是不是都写在这一个 Java 项目当中。随着这个项目的业务扩张，项目当中的业务功能可能会越来越多。

假如我们开发的是一个大型的电商项目，里面可能就包括了商品模块的功能、搜索模块的功能、购物车模块、订单模块、用户中心等等。这些所有的业务代码我们都在一个 Java 项目当中编写。

此时大家可以试想一下，假如我们开发的是一个大型的电商网站，这个项目组至少几十号甚至几百号开发人员，这些开发人员全部操作这一个 Java 项目。此时大家就会发现我们项目管理和维护起来将会非常的困难。而且大家再来看，假如在我们的项目当中，我们自己定义了一些通用的工具类以及通用的组件，而公司还有其他的项目组，其他项目组也想使用我们所封装的这些组件和工具类，其实是非常不方便的。因为 Java 项目当中包含了当前项目的所有业务代码，所以就造成了这里面所封装的一些组件会难以复用。

总结起来，主要两点问题：不方便项目的维护和管理、项目中的通用组件难以复用。

2). 分模块设计

分模块设计我们在进行项目设计阶段，就可以将一个大的项目拆分成若干个模块，每一个模块都是独立的。

比如我们可以将商品的相关功能放在商品模块当中，搜索的相关业务功能我都封装在搜索模块当中，还有像购物车模块、订单模块。而为了组件的复用，我们也可以将项目当中的实体类、工具类以及我们定义的通用的组件都单独的抽取到一个模块当中。

如果当前这个模块，比如订单模块需要用到这些实体类以及工具类或者这些通用组件，此时直接在订单模块当中引入工具类的坐标就可以了。这样我们就将一个项目拆分成了若干个模块儿，这就是分模块设计。

分模块设计之后，大家再来看。我们在进行项目管理的时候，我就可以几个人一组，几个人来负责订单模块，另外几个人来负责购物车模块，这样更加便于项目的管理以及项目的后期维护。

而且分模块设计之后，如果我们需要用到另外一个模块的功能，我们直接依赖模块就可以了。比如商品模块、搜索模块、购物车订单模块都需要依赖于通用组件当中封装的一些工具类，我只需要引入通用组件的坐标就可以了。

分模块设计就是将项目按照功能/结构拆分成若干个子模块，方便项目的管理维护、拓展，也方便模块键的相互调用、资源共享。

策略

策略一：按照功能模块拆分，比如：公共组件、商品模块、搜索模块、购物车模块、订单模块等。
策略二：按层拆分，比如：公共组件、实体类、控制层、业务层、数据访问层。
策略三：按照功能模块 + 层拆分。

实践

分析

好，我们明白了什么是分模块设计以及分模块设计的优势之后，接下来我们就来看一下我们之前所开发的案例工程。

我们可以看到在这个项目当中，除了我们所开发的部门管理以及员工管理、登录认证等相关业务功能以外，我们是不是也定义了一些实体类，也就是pojo包下存放的一些类，像分页结果的封装类PageBean、统一响应结果Result，我们还定义了一些通用的工具类，像Jwts、阿里云OSS操作的工具类等等。

如果在当前公司的其他项目组当中，也想使用我们所封装的这些公共的组件，该怎么办？大家可以思考一下。

方案一：直接依赖我们当前项目 tlias-web-management ，但是存在两大缺点：
- 这个项目当中包含所有的业务功能代码，而想共享的资源，仅仅是pojo下的实体类，以及 utils 下的工具类。如果全部都依赖进来，项目在启动时将会把所有的类都加载进来，会影响性能。
- 如果直接把这个项目都依赖进来了，那也就意味着我们所有的业务代码都对外公开了，这个是非常不安全的。
方案二：分模块设计
- 将pojo包下的实体类，抽取到一个maven模块中 tlias-pojo
- 将utils包下的工具类，抽取到一个maven模块中 tlias-utils
- 其他的业务代码，放在tlias-web-management这个模块中，在该模块中需要用到实体类pojo、工具类utils，直接引入对应的依赖即可。

注意：分模块开发需要先针对模块功能进行设计，再进行编码。不会先将工程开发完毕，然后进行拆分。

PS：当前我们是为了演示分模块开发，所以是基于我们前面开发的案例项目进行拆分的，实际中都是分模块设计，然后再开发的。

实现

思路我们分析完毕，接下来，我们就根据我们分析的思路，按照如下模块进行拆分：

【此处建议将源文件复制一份到新的项目目录下进行操作，创建一个空项目，然后配置对应的jdk】

1. 创建maven模块tlias-pojo，存放实体类

A. 创建一个正常的Maven模块，模块名 tlias-pojo

B. 然后在tlias-pojo中创建一个包 com.itheima.pojo (和原来案例项目中的pojo包名一致)

C. 将原来案例项目 tlias-web-management 中的pojo包下的实体类，复制到 tlias-pojo 模块中

D. 在 tlias-pojo 模块的pom.xml文件中引入依赖

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.34</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>3.5.13</version>
    </dependency>
</dependencies>

因为在实体类中，还用到了Spring框架中的 @DateTimeFormat 这样的注解，所以这里再引入一个springboot的基础起步依赖。

【注意：如果在引入了依赖后项目依然报红，那么可以将原代码剪切以后再复制进来即可，但是这种方法可能有些麻烦，需要一个一个点开查看是否报错，也可以将这个工程关闭重新打开一下就行了】

E. 删除原有案例项目 tlias-web-management 的pojo包【直接删除不要犹豫，我们已经将该模块拆分出去了】，然后在pom.xml中引入 tlias-pojo的依赖

<dependency>
    <groupId>com.itheima</groupId>
    <artifactId>tlias-pojo</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

2. 创建Maven模块 tlias-utils，存放相关工具类

A. 创建一个正常的Maven模块，模块名 tlias-utils

B. 然后在 tlias-utils 中创建一个包 com.itheima.utils (和原来案例项目中的utils包名一致)

C. 将原来案例项目 tlias-web-management 中的util包下的实体类，复制到 tlias-utils 模块中

D. 在 tlias-utils 模块的 pom.xml 文件中引入依赖。

<dependencies>
    <!-- JWT依赖-->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>

    <dependency>
        <groupId>com.aliyun.oss</groupId>
        <artifactId>aliyun-sdk-oss</artifactId>
        <version>3.17.4</version>
    </dependency>
    <dependency>
        <groupId>javax.xml.bind</groupId>
        <artifactId>jaxb-api</artifactId>
        <version>2.3.1</version>
    </dependency>
    <dependency>
        <groupId>javax.activation</groupId>
        <artifactId>activation</artifactId>
        <version>1.1.1</version>
    </dependency>
    <!-- no more than 2.3.3-->
    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
        <version>2.3.3</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>3.5.13</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.34</version>
    </dependency>
</dependencies>

E. 删除原有案例项目 tlias-web-management 的util包【直接删除不要犹豫，我们已经将该模块拆分出去了】，然后在management的 pom.xml中引入 tlias-utils 的依赖。

<dependency>
    <groupId>com.itheima</groupId>
    <artifactId>tlias-utils</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

到此呢，就已经完成了模块的拆分，拆分出了tlias-pojo、tlias-utils、tlias-web-management，如果其他项目中需要用到 pojo，或者 utils工具类，就可以直接引入依赖。

**什么是分模块设计：**将项目按照功能拆分成若干个子模块

**为什么要分模块设计：**方便项目的管理维护、扩展，也方便模块间的相互调用，资源共享

**注意事项：**分模块设计需要先针对模块功能进行设计，再进行编码。不会先将工程开发完毕，然后进行拆分

继承与聚合

在案例项目分模块开发之后啊，我们会看到 tlias-pojo、tlias-utils、tlias-web-management 中都引入了一个依赖 lombok 的依赖。我们在三个模块中分别配置了一次。

如果是做一个大型的项目，这三个模块当中重复的依赖可能会很多很多。如果每一个 Maven 模块里面，我们都来单独的配置一次，功能虽然能实现，但是配置是比较繁琐的。

而接下来我们要讲解的 Maven 的继承用来解决这问题的。

继承

我们可以再创建一个父工程 tlias-parent ，然后让上述的三个模块 tlias-pojo、tlias-utils、tlias-web-management 都来继承这个父工程。然后再将各个模块中都共有的依赖，都提取到父工程 tlias-parent中进行配置，只要子工程继承了父工程，依赖它也会继承下来，这样就无需在各个子工程中进行配置了。

概念：继承描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承。
作用：简化依赖配置、统一管理依赖
实现：

<parent>
    <groupId>...</groupId>
    <artifactId>...</artifactId>
    <version>...</version>
    <relativePath>....</relativePath>
</parent>

这是我们在这里先介绍一下什么是继承以及继承的作用，以及在 maven 当中如何来实现这层继承关系。接下来我们就来创建这样一个 parent 父工程，我们就可以将各个子工程当中共有的这部分依赖统一的定义在父工程 parent 当中，从而来简化子工程的依赖配置。接下来我们来看一下具体的操作步骤。

我们在这里先介绍一下什么是继承以及继承的作用，以及在 maven 当中如何来实现这层继承关系。接下来我们就来创建这样一个 parent 父工程，我们就可以将各个子工程当中共有的这部分依赖，统一的定义在父工程 parent 当中，从而来简化子工程的依赖配置。

继承关系

思路分析

我们当前的项目 tlias-web-management，还稍微有一点特殊，因为是一个springboot项目，而所有的springboot项目都有一个统一的父工程，就是 spring-boot-starter-parent。与java语言类似，Maven不支持多继承，一个maven项目只能继承一个父工程，如果继承了spring-boot-starter-parent，就没法继承我们自己定义的父工程 tlias-parent了。

那我们怎么来解决这个问题呢？

那此时，大家可以想一下，Java虽然不支持多继承，但是可以支持多重继承，比如：A 继承 B， B 继承C。那在Maven中也是支持多重继承的，所以呢，我们就可以让我们自己创建的三个模块，都继承 tlias-parent，而 tlias-parent 再继承 spring-boot-starter-parent，就可以了。具体结构如下：

实现

1). 创建maven模块tlias-parent，该工程为父工程，设置打包方式pom(默认jar)。

工程结构如下（src目录不需要，直接删除）：

父工程tlias-parent的 pom.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 http://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.5.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.itheima</groupId>
    <artifactId>tlias-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

Maven打包方式：

jar：普通模块打包，springboot项目基本都是jar包（内嵌tomcat运行）

war：普通web程序打包，需要部署在外部的tomcat服务器中运行

pom：父工程或聚合工程，该模块不写代码，仅进行依赖管理

2). 在子工程（tlias-pojo、tlias-utils、tlias-web-management）的pom.xml文件中，配置继承关系。

<parent>
    <groupId>com.itheima</groupId>
    <artifactId>tlias-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../tlias-parent/pom.xml</relativePath>
</parent>

<artifactId>tlias-utils</artifactId>
<version>1.0-SNAPSHOT</version>

这里是以 tlias-utils 为例，指定了其父工程。其他的模块，都是相同的配置方式。

注意：

在子工程中，配置了继承关系之后，坐标中的groupId是可以省略的，因为会自动继承父工程的。

relativePath指定父工程的pom文件的相对位置（如果不指定，将从本地仓库/远程仓库查找该工程）。

../ 代表的上一级目录

3). 在父工程中配置各个工程共有的依赖（子工程会自动继承父工程的依赖）。

<?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 http://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.5.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.itheima</groupId>
    <artifactId>tlias-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>3.2.8</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.34</version>
        </dependency>
    </dependencies>

</project>

此时，我们已经将各个子工程中共有的依赖（lombok 和 spring-boot-starter），都定义在了父工程中，子工程中的这一项依赖，就可以直接删除了。删除之后，我们会看到父工程中配置的依赖 lombok，子工程直接继承下来了。

工程结构说明:

我们当前的项目结构为：

tlias-parent

tlias-pojo

tlias-utils

tlias-web-management

因为我们是项目开发完毕之后，给大家基于现有项目拆分的各个模块，tlias-web-management 已经存在了，然后再创建各个模块与父工程，所以父工程与模块之间是平级的。

工程结构说明:

而实际项目中，可能还会见到下面的工程结构：

tlias-parent

tlias-pojo

tlias-utils

tlias-web-management

而在真实的企业开发中，都是先设计好模块之后，再开始创建模块，开发项目。那此时呢，一般都会先创建父工程 tlias-parent，然后将创建的各个子模块，都放在父工程parent下面。这样层级结构会更加清晰一些。

版本锁定

场景

如果项目中各个模块中都公共的这部分依赖，我们可以直接定义在父工程中，从而简化子工程的配置。然而在项目开发中，还有一部分依赖，并不是各个模块都共有的，可能只是其中的一小部分模块中使用到了这个依赖。

比如：在tlias-web-management、tlias-web-system、tlias-web-report这三个子工程中，都使用到了jwt的依赖。但是 tlias-pojo、tlias-utils中并不需要这个依赖，那此时，这个依赖，我们不会直接配置在父工程 tlias-parent中，而是哪个模块需要，就在哪个模块中配置。

而由于是一个项目中的多个模块，那多个模块中，我们要使用的同一个依赖的版本要一致，这样便于项目依赖的统一管理。比如：这个jwt依赖，我们都使用的是 0.9.1 这个版本。

那假如说，我们项目要升级，要使用到jwt最新版本 0.9.2 中的一个新功能，那此时需要将依赖的版本升级到0.9.2，那此时该怎么做呢？

第一步：去找当前项目中所有的模块的pom.xml配置文件，看哪些模块用到了jwt的依赖。

第二步：找到这个依赖之后，将其版本version，更换为 0.9.2。

问题：如果项目拆分的模块比较多，每一次更换版本，我们都得找到这个项目中的每一个模块，一个一个的更改。很容易就会出现，遗漏掉一个模块，忘记更换版本的情况。

那我们又该如何来解决这个问题，如何来统一管理各个依赖的版本呢？

答案：Maven的版本锁定功能。

介绍

在maven中，可以在父工程的pom文件中通过 <dependencyManagement> 来统一管理依赖版本。

父工程：

<!--统一管理依赖版本-->
<dependencyManagement>
    <dependencies>
        <!--JWT令牌-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
    </dependencies>
</dependencyManagement>

子工程：

<dependencies>
    <!--JWT令牌-->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
    </dependency>
</dependencies>

在父工程中所配置的 <dependencyManagement> 只能统一管理依赖版本，并不会将这个依赖直接引入进来。这点和 <dependencies> 是不同的。
子工程要使用这个依赖，还是需要引入的，只是此时就无需指定 <version> 版本号了，父工程统一管理。变更依赖版本，只需在父工程中统一变更。

实现

接下来，我们就可以将 tlias-utils 模块中单独配置的依赖，将其版本统一交给 tlias-parent 进行统一管理。

具体步骤如下：

1). tlias-parent中的配置

<dependencyManagement>
    <dependencies>
        <!-- JWT依赖-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-sdk-oss</artifactId>
            <version>3.17.4</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.1</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- no more than 2.3.3-->
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.3</version>
        </dependency>
    </dependencies>
</dependencyManagement>

2). tlias-utils 中的pom.xml配置

如果依赖的版本已经在父工程进行了统一管理，所以在子工程中就无需再配置依赖的版本了。

<dependencies>
    <!-- JWT依赖-->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
    </dependency>

    <dependency>
        <groupId>com.aliyun.oss</groupId>
        <artifactId>aliyun-sdk-oss</artifactId>
    </dependency>
    <dependency>
        <groupId>javax.xml.bind</groupId>
        <artifactId>jaxb-api</artifactId>
    </dependency>
    <dependency>
        <groupId>javax.activation</groupId>
        <artifactId>activation</artifactId>
    </dependency>
    <!-- no more than 2.3.3-->
    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
    </dependency>
</dependencies>

我们之所以，在springboot项目中很多时候，引入依赖坐标，都不需要指定依赖的版本 <version> ，是因为在父工程 spring-boot-starter-parent中已经通过 <dependencyManagement>对依赖的版本进行了统一的管理维护。

属性配置

我们也可以通过自定义属性及属性引用的形式，在父工程中将依赖的版本号进行集中管理维护。

具体语法为：

1). 自定义属性

1
2
3

<properties>
    <lombok.version>1.18.34</lombok.version>
</properties>

2). 引用属性

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>${lombok.version}</version>
</dependency>

接下来，我们就可以在父工程中，将所有的版本号，都集中管理维护起来。

<?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 http://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.5.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.itheima</groupId>
    <artifactId>tlias-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <spring-boot.version>3.5.13</spring-boot.version>
        <lombok.version>1.18.34</lombok.version>
        <jwt.version>0.9.1</jwt.version>
        <aliyun.oss.version>3.17.4</aliyun.oss.version>
        <jaxb.version>2.3.1</jaxb.version>
        <javax.activation.version>1.1.1</javax.activation.version>
        <jaxb.runtime.version>2.3.3</jaxb.runtime.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>${spring-boot.version}</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <!-- JWT依赖-->
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>${jwt.version}</version>
            </dependency>

            <dependency>
                <groupId>com.aliyun.oss</groupId>
                <artifactId>aliyun-sdk-oss</artifactId>
                <version>${aliyun.oss.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.xml.bind</groupId>
                <artifactId>jaxb-api</artifactId>
                <version>${jaxb.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.activation</groupId>
                <artifactId>activation</artifactId>
                <version>${javax.activation.version}</version>
            </dependency>
            <!-- no more than 2.3.3-->
            <dependency>
                <groupId>org.glassfish.jaxb</groupId>
                <artifactId>jaxb-runtime</artifactId>
                <version>${jaxb.runtime.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

版本集中管理之后，我们要想修改依赖的版本，就只需要在父工程中自定义属性的位置，修改对应的属性值即可。

面试题：与的区别是什么?

<dependencies> 是直接依赖，在父工程配置了依赖，子工程会直接继承下来。

<dependencyManagement> 是统一管理依赖版本，不会直接依赖，还需要在子工程中引入所需依赖(无需指定版本)

聚合

分模块设计与开发之后啊，我们的项目被拆分为多个模块，而模块之间的关系，可能错综复杂。那就比如我们当前的案例项目，结构如下（相对还是比较简单的）：

此时，tlias-web-management 模块的父工程是 tlias-parent，该模块又依赖了 tlias-pojo、tlias-utils 模块。那此时，我们要想将 tlias-web-management 模块打包，是比较繁琐的。因为在进行项目打包时，maven会从本地仓库中来查找 tlias-parent 父工程，以及它所依赖的模块 tlias-pojo、tlias-utils，而本地仓库目前是没有这几个依赖的。

所以，我们再打包tlias-web-management 模块前，需要将 tlias-parent、tlias-pojo、tlias-utils 分别执行install生命周期安装到maven的本地仓库，然后再针对于 tlias-web-management 模块执行package进行打包操作。

那此时，大家试想一下，如果开发一个大型项目，拆分的模块很多，模块之间的依赖关系错综复杂，那此时要进行项目的打包、安装操作，是非常繁琐的。而我们接下来，要讲解的maven的聚合就是来解决这个问题的，通过maven的聚合就可以轻松实现项目的一键构建（清理、编译、测试、打包、安装等）。

介绍

**聚合：**将多个模块组织成一个整体，同时进行项目的构建。
**聚合工程：**一个不具有业务功能的“空”工程（有且仅有一个pom文件）【PS：一般来说，继承关系中的父工程与聚合关系中的聚合工程是同一个】
**作用：**快速构建项目（无需根据依赖关系手动构建，直接在聚合工程上构建即可）

实现

在maven中，我们可以在聚合工程中通过 <moudules> 设置当前聚合工程所包含的子模块的名称。我们可以在 tlias-parent中，添加如下配置，来指定当前聚合工程，需要聚合的模块：

<!-- 聚合其他模块 -->
<modules>
    <module>../tlias-pojo</module>
    <module>../tlias-utils</module>
    <module>../tlias-web-management</module>
</modules>

那此时，我们要进行编译、打包、安装操作，就无需在每一个模块上操作了。只需要在聚合工程上，统一进行操作就可以了。添加了聚合的module后Maven面板就会变成这样

**测试：**执行在聚合工程 tlias-parent 中执行 package 打包指令

那 tlias-parent 中所聚合的其他模块全部都会执行 package 指令，这就是通过聚合实现项目的一键构建（一键清理clean、一键编译compile、一键测试test、一键打包package、一键安装install等）。

继承与聚合对比

作用
- 聚合用于快速构建项目
- 继承用于简化依赖配置、统一管理依赖
相同点：
- 聚合与继承的pom.xml文件打包方式均为pom，通常将两种关系制作到同一个pom文件中
- 聚合与继承均属于设计型模块，并无实际的模块内容
不同点：
- 聚合是在聚合工程中配置关系，聚合可以感知到参与聚合的模块有哪些
- 继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己

私服

前面我们在讲解多模块开发的时候，我们讲到我们所拆分的模块是可以在同一个公司各个项目组之间进行资源共享的。这个模块的资源共享，就需要通过我们接下来所讲解的 Maven 的私服来实现。

首先我们先介绍一下什么是私服，以及它的作用是什么。再来介绍一下我们如何将每位模块打包上传到私服，以及从私服当中来下载。

场景

在介绍什么是私服之前，我们先来分析一下同一个公司，两个项目组之间如何基于私服进行资源的共享。

假设现在有两个团队，A 和 B。 A 开发了一个模块 tlias-utils，模块开发完毕之后，将模块打成jar包，并安装到了A的本地仓库。

那此时，该公司的B团队开发项目时，要想使用 tlias-utils 中提供的工具类，该怎么办呢？对于maven项目来说，是不是在pom.xml文件中引入 tlias-utils的坐标就可以了呢？

大家可以思考一下，当B团队在maven项目的pom.xml配置文件中引入了依赖的坐标之后，maven是如何查找这个依赖的？查找顺序为：

1). 本地仓库：本地仓库中是没有这个依赖jar包的。

2). 远程中央仓库：由于该模块时自己公司开发的，远程仓库中也没有这个依赖。

因为目前tlias-utils这个依赖，还在A的本地仓库中的。 B电脑上的maven项目，是不可能找得到A电脑上maven本地仓库的jar包的。那此时，大家可能会有一个想法：因为A和B都会连接中央仓库，我们可以将A本地仓库的jar包，直接上传到中央仓库，然后B从中央仓库中下载tlias-utils这个依赖。

这个想法很美好，但是现实很残酷。这个方案是行不通的，因为中央仓库全球只有一个，不是什么人都可以往中央仓库中来上传jar包的，我们是没有权限操作的。

那此时，maven的私服就出场了，私服其实就是架设在公司局域网内部的一台服务器，就是一种特殊的远程仓库。

有了私服之后，各个团队就可以直接来连接私服了。 A 连接上私服之后，他就可以把jar包直接上传到私服当中。我公司自己内部搭建的服务器，我是不是有权限操作呀，把jar包上传到私服之后，我让 B 团队的所有开发人员也连接同一台私服。连接上这一台私服之后，他就会根据坐标的信息，直接从私服当中将对应的jar包下载到自己的本地仓库，这样就可以使用到依赖当中所提供的一些工具类了。这样我们就可以通过私服来完成资源的共享。

而如果我们在项目中需要使用其他第三方提供的依赖，如果本地仓库没有，也会自动连接私服下载，如果私服没有，私服此时会自动连接中央仓库，去中央仓库中下载依赖，然后将下载的依赖存储在私服仓库及本地仓库中。

介绍

**私服：**是一种特殊的远程仓库，它是架设在局域网内的仓库服务，用来代理位于外部的中央仓库，用于解决团队内部的资源共享与资源同步问题。
依赖查找顺序：
- 本地仓库
- 私服仓库
- 中央仓库
**注意事项：**私服在企业项目开发中，一个项目/公司，只需要一台即可（无需我们自己搭建，会使用即可）。

资源上传与下载

步骤分析

资源上传与下载，我们需要做三步配置，执行一条指令。

第一步配置：在maven的配置文件中配置访问私服的用户名、密码。
第二步配置：在maven的配置文件中配置连接私服的地址(url地址)。
第三步配置：在项目的pom.xml文件中配置上传资源的位置(url地址)。
配置好了上述三步之后，要上传资源到私服仓库，就执行执行maven生命周期：deploy。

私服仓库说明：

RELEASE：存储自己开发的RELEASE发布版本的资源。

SNAPSHOT：存储自己开发的SNAPSHOT发布版本的资源。

Central：存储的是从中央仓库下载下来的依赖。

项目版本说明：

RELEASE(发布版本)：功能趋于稳定、当前更新停止，可以用于发行的版本，存储在私服中的RELEASE仓库中。

SNAPSHOT(快照版本)：功能不稳定、尚处于开发中的版本，即快照版本，存储在私服的SNAPSHOT仓库中。

具体操作

私服已经搭建好了，已经启动起来了，我们可以访问私服测试：http://localhost:8081。

我的启动地址：D:\develop\nexus\nexus\nexus-3.75.1-01\bin下的start.bat文件

私服准备好了之后，我们要做如下几步配置：

1. 设置私服的访问用户名/密码（在自己maven安装目录下的conf/settings.xml中的servers中配置）

我的Maven配置地址：D:\develop\.m2\apache-maven-3.9.11\conf

<server>
    <id>maven-releases</id>
    <username>admin</username>
    <password>admin</password>
</server>
    
<server>
    <id>maven-snapshots</id>
    <username>admin</username>
    <password>admin</password>
</server>

2. 设置私服依赖下载的仓库组地址（在自己maven安装目录下的conf/settings.xml中的mirrors中配置）

<mirror>
    <id>maven-public</id>
    <mirrorOf>*</mirrorOf>
    <url>http://localhost:8081/repository/maven-public/</url>
</mirror>

3. 设置私服依赖下载的仓库组地址（在自己maven安装目录下的conf/settings.xml中的profiles中配置）

<profile>
    <id>allow-snapshots</id>
    <activation>
        <activeByDefault>true</activeByDefault>
    </activation>
    <repositories>
        <repository>
            <id>maven-public</id>
            <url>http://localhost:8081/repository/maven-public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>
</profile>

4. IDEA的maven工程的pom文件中配置上传（发布）地址(直接在tlias-parent中配置发布地址)

<distributionManagement>
    <!-- release版本的发布地址 -->
    <repository>
        <id>maven-releases</id>
        <url>http://localhost:8081/repository/maven-releases/</url>
    </repository>
    <!-- snapshot版本的发布地址 -->
    <snapshotRepository>
        <id>maven-snapshots</id>
        <url>http://localhost:8081/repository/maven-snapshots/</url>
    </snapshotRepository>
</distributionManagement>

配置完成之后，我们就可以在tlias-parent中执行deploy生命周期，将项目发布到私服仓库中。

通过日志，我们可以看到，这几个模块打的jar包确实已经上传到了私服仓库中（由于当前我们的项目是SNAPSHOT版本，所以jar包是上传到了snapshot仓库中）。

那接下来，我们再来打开私服来看一下：

我们看到，我们项目中的这几个模块，在私服中都有了。那接下来，当其他项目组的开发人员在项目中，就可以直接通过依赖的坐标，就可以完成引入对应的依赖，此时本地仓库没有，就会自动从私服仓库中下载。

此时我们就可以在其他的项目中引入这个tlias-utils的依赖，但是这个依赖不一定就是从私服中引入的，有可能是本地仓库中引入进来的

备注说明：在真实的企业开发中，私服都是在远程服务器中的，并不是在本地的。这里我们只是为了方便演示。

注意：此次学习完记得将私服关闭，可以将过程中关闭的阿里云开起来

web后端总结

到此，全部的web后端开发内容就全部完成了，以下为web后端整体内容的框架与总结

其中SpringMVC就是Spring framework的一部分，是Spring framework对web、apps的支持，它并不是一个独立的模块

其中SpringMVC、Spring framework、Mybatis统称为SSM

SpringAOP

Tue, 19 May 2026 22:15:16 +0800

后端Web进阶（AOP）

接下来我们进入到AOP的学习。 AOP也是spring框架的第二大核心，我们先来学习AOP的基础。

什么是AOP？

AOP：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。

那什么又是面向方法编程呢，为什么又需要面向方法编程呢？

来，我们举个例子做一个说明：

比如，我们这里有一个项目，项目中开发了很多的业务功能。然而有一些业务功能执行效率比较低，执行耗时较长，我们需要针对于这些业务方法进行优化。那首先第一步就需要定位出执行耗时比较长的业务方法，再针对于业务方法再来进行优化。

此时我们就需要统计当前这个项目当中每一个业务方法的执行耗时。那么统计每一个业务方法的执行耗时该怎么实现？

可能多数人首先想到的就是在每一个业务方法运行之前，记录这个方法运行的开始时间。在这个方法运行完毕之后，再来记录这个方法运行的结束时间。拿结束时间减去开始时间，不就是这个方法的执行耗时吗。

而这个功能如果通过AOP来实现，我们只需要单独定义下面这一小段代码即可，不需要修改原始的任何业务方法即可记录每一个业务方法的执行耗时。

所以，AOP的优势主要体现在以下四个方面：

减少重复代码：不需要在业务方法中定义大量的重复性的代码，只需要将重复性的代码抽取到AOP程序中即可。
代码无侵入：在基于AOP实现这些业务功能时，对原有的业务代码是没有任何侵入的，不需要修改任何的业务代码。
提高开发效率
维护方便

AOP是一种思想，而在Spring框架中，对这种思想进行了实现，那我们要学习的就是Spring AOP。

AOP基础

AOP入门

在了解了什么是AOP后，我们下面通过一个快速入门程序，体验下AOP的开发，并掌握Spring中AOP的开发步骤。

需求：统计部门管理各个业务层方法执行耗时。
原始方式：

在原始的实现方式中，我们需要在业务层的也一个方法执行执行，获取方法运行的开始时间；然后运行原始的方法逻辑；最后在每一个方法运行结束时，获取方法运行结束时间，计算执行耗时。

SpringAOP实现步骤：

此处直接导入黑马学习资料中提供的springboot-aop-quickstart项目工程

1). 导入依赖：在 pom.xml 文件中导入 AOP 的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2). 编写AOP程序：针对于特定方法根据业务需要进行编程

@Component
@Aspect //当前类为切面类
@Slf4j
public class RecordTimeAspect {

    //针对部门管理层所有的方法
    @Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录方法执行开始时间
        long begin = System.currentTimeMillis();

        //执行原始方法
        Object result = pjp.proceed();

        //记录方法执行结束时间
        long end = System.currentTimeMillis();

        //计算方法执行耗时
        log.info("方法执行耗时: {}毫秒",end-begin);
        return result;
    }
}

重新启动SpringBoot服务，打开浏览器访问部门管理的功能进行测试：

我们可以看到，在控制台中输出了方法的执行耗时：

但是当我们测试了其他功能时也仅显示方法执行时间，不知道是哪个方法，此时就可以在第三步中添加pjp.getSignature()方法获取当前运行的原始方法的签名

//3. 记录方法运行的结束时间, 记录耗时
long end = System.currentTimeMillis();
log.info("方法 {} 执行耗时: {}ms", pjp.getSignature() ,end-begin);
return  result;

我们通过AOP入门程序完成了业务方法执行耗时的统计，那其实AOP的功能远不止于此，常见的应用场景如下：

记录系统的操作日志
权限控制
事务管理：我们前面所讲解的Spring事务管理，底层其实也是通过AOP来实现的，只要添加@Transactional注解之后，AOP程序自动会在原始方法运行前先来开启事务，在原始方法运行完毕之后提交或回滚事务

这些都是AOP应用的典型场景。

通过入门程序，我们也应该感受到了AOP面向切面编程的一些优势：

代码无侵入：没有修改原始的业务方法，就已经对原始的业务方法进行了功能的增强或者是功能的改变
减少了重复代码
提高开发效率
维护方便

AOP核心概念

通过SpringAOP的快速入门，感受了一下AOP面向切面编程的开发方式。下面我们再来学习AOP当中涉及到的一些核心概念。

连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）
- 连接点指的是可以被aop控制的方法。例如：入门程序当中所有的业务方法都是可以被aop控制的方法。
- 在SpringAOP提供的JoinPoint当中，封装了连接点方法在执行时的相关信息。（后面会有具体的讲解）

通知：Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）
- 在入门程序中是需要统计各个业务方法的执行耗时的，此时我们就需要在这些业务方法运行开始之前，先记录这个方法运行的开始时间，在每一个业务方法运行结束的时候，再来记录这个方法运行的结束时间。
- 在AOP面向切面编程当中，我们只需要将这部分重复的代码逻辑抽取出来单独定义。抽取出来的这一部分重复的逻辑，也就是共性的功能。

切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用。
- 在通知当中，我们所定义的共性功能到底要应用在哪些方法上？此时就涉及到了切入点pointcut概念。切入点指的是匹配连接点的条件。通知仅会在切入点方法运行时才会被应用。
- 在aop的开发当中，我们通常会通过一个切入点表达式来描述切入点(后面会有详解)。

假如：切入点表达式改为DeptServiceImpl.list()，此时就代表仅仅只有list这一个方法是切入点。只有list()方法在运行的时候才会应用通知。
切面：Aspect，描述通知与切入点的对应关系（通知+切入点）

当通知和切入点结合在一起，就形成了一个切面。通过切面就能够描述当前aop程序需要针对于哪个原始方法，在什么时候执行什么样的操作。

而切面所在的类，称之为切面类（被@Aspect注解标识的类）。

目标对象：Target，通知所应用的对象

目标对象指的就是通知所应用的对象，我们就称之为目标对象。

AOP的核心概念我们介绍完毕之后，接下来我们再来分析一下我们所定义的通知是如何与目标对象结合在一起，对目标对象当中的方法进行功能增强的。

Spring的AOP底层是基于动态代理技术来实现的，也就是说在程序运行的时候，会自动的基于动态代理技术为目标对象生成一个对应的代理对象。在代理对象当中就会对目标对象当中的原始方法进行功能的增强。

为什么叫“动态”代理？

静态代理： 如果我们要手动去写那个 DeptServiceProxy 类，那叫静态代理。如果有 100 个 Service 类都要加日志，你就得手写 100 个代理类，工作量巨大且代码冗余。
动态代理：

在这张图的技术（Spring AOP）中，右下角的 DeptServiceProxy 实际上是不存在的源码文件。它是 Spring 框架在程序运行时，利用 JDK 动态代理或 CGLIB 技术，在内存中动态生成出来的。
- 程序员只需要写好“目标对象”和“切面”。
- 框架会自动把它们组装成一个代理对象。

AOP进阶

AOP的基础知识学习完之后，下面我们对AOP当中的各个细节进行详细的学习。主要分为4个部分：

通知类型
通知顺序
切入点表达式
连接点

我们先来学习第一部分通知类型。

在入门程序当中，我们已经使用了一种功能最为强大的通知类型：Around环绕通知。

@Component
@Aspect //当前类为切面类
@Slf4j
public class TimeAspect {

    @Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录方法执行开始时间
        long begin = System.currentTimeMillis();
        //执行原始方法
        Object result = pjp.proceed();
        //记录方法执行结束时间
        long end = System.currentTimeMillis();
        //计算方法执行耗时
        log.info("方法执行耗时: {}毫秒",end-begin);
        return result;
    }
}

只要我们在通知方法上加上了@Around注解，就代表当前通知是一个环绕通知。

Spring AOP 通知类型	说明
@Around	环绕通知，此注解标注的通知方法在目标方法前、后都被执行
@Before	前置通知，此注解标注的通知方法在目标方法前被执行
@After	后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
@AfterReturning	返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行
@AfterThrowing	异常后通知，此注解标注的通知方法发生异常后执行

五种类型标志：前置、环绕、后置、返回后、异常后

下面我们通过代码演示，来加深对于不同通知类型的理解：

@Slf4j
@Component
@Aspect
public class MyAspect1 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(JoinPoint joinPoint){
        log.info("before ...");

    }

    //环绕通知
    @Around("execution(* com.itheima.service.*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before ...");

        //调用目标对象的原始方法执行
        Object result = proceedingJoinPoint.proceed();
        
        //原始方法如果执行时有异常，环绕通知中的后置代码不会在执行了
        
        log.info("around after ...");
        return result;
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(JoinPoint joinPoint){
        log.info("after ...");
    }

    //返回后通知（程序在正常执行的情况下，会执行的后置通知）
    @AfterReturning("execution(* com.itheima.service.*.*(..))")
    public void afterReturning(JoinPoint joinPoint){
        log.info("afterReturning ...");
    }

    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("execution(* com.itheima.service.*.*(..))")
    public void afterThrowing(JoinPoint joinPoint){
        log.info("afterThrowing ...");
    }
}

重新启动SpringBoot服务，进行测试：

1). 没有异常情况下：

使用 Apifox 测试查询所有部门数据

查看idea中控制台日志输出：

程序没有发生异常的情况下，@AfterThrowing标识的通知方法不会执行。

2). 出现异常情况下：

修改DeptServiceImpl业务实现类中的代码：添加异常

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    @Override
    public List<Dept> list() {

        List<Dept> deptList = deptMapper.list();
        //模拟异常
        int num = 10/0;
        return deptList;
    }
    
    //省略其他代码...
}

重新启动SpringBoot服务，测试发生异常情况下通知的执行：

查看idea中控制台日志输出

程序发生异常的情况下：

@AfterReturning标识的通知方法不会执行，@AfterThrowing标识的通知方法执行了

@Around环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑也不会在执行了（因为原始方法调用已经出异常了）

在使用通知时的注意事项：

@Around环绕通知需要自己调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行

@Around环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值，否则原始方法执行完毕，是获取不到返回值的。

五种常见的通知类型，我们已经测试完毕了，此时我们再来看一下刚才所编写的代码，有什么问题吗？

//前置通知
@Before("execution(* com.itheima.service.*.*(..))")

//环绕通知
@Around("execution(* com.itheima.service.*.*(..))")
  
//后置通知
@After("execution(* com.itheima.service.*.*(..))")

//返回后通知（程序在正常执行的情况下，会执行的后置通知）
@AfterReturning("execution(* com.itheima.service.*.*(..))")

//异常通知（程序在出现异常的情况下，执行的后置通知）
@AfterThrowing("execution(* com.itheima.service.*.*(..))")

我们发现啊，每一个注解里面都指定了切入点表达式，而且这些切入点表达式都一模一样。此时我们的代码当中就存在了大量的重复性的切入点表达式，假如此时切入点表达式需要变动，就需要将所有的切入点表达式一个一个的来改动，就变得非常繁琐了。

怎么来解决这个切入点表达式重复的问题？答案就是：抽取

Spring提供了@PointCut注解，该注解的作用是将公共的切入点表达式抽取出来，需要用到时引用该切入点表达式即可。

@Slf4j
@Component
@Aspect
public class MyAspect1 {

    //切入点方法（公共的切入点表达式）
    @Pointcut("execution(* com.itheima.service.*.*(..))")
    private void pt(){}

    //前置通知（引用切入点）
    @Before("pt()")
    public void before(JoinPoint joinPoint){
        log.info("before ...");

    }

    //环绕通知
    @Around("pt()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before ...");

        //调用目标对象的原始方法执行
        Object result = proceedingJoinPoint.proceed();
        //原始方法在执行时：发生异常
        //后续代码不在执行

        log.info("around after ...");
        return result;
    }

    //后置通知
    @After("pt()")
    public void after(JoinPoint joinPoint){
        log.info("after ...");
    }

    //返回后通知（程序在正常执行的情况下，会执行的后置通知）
    @AfterReturning("pt()")
    public void afterReturning(JoinPoint joinPoint){
        log.info("afterReturning ...");
    }

    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("pt()")
    public void afterThrowing(JoinPoint joinPoint){
        log.info("afterThrowing ...");
    }
}

需要注意的是：当切入点方法使用private修饰时，仅能在当前切面类中引用该表达式，当外部其他切面类中也要引用当前类中的切入点表达式，就需要把private改为public，而在引用的时候，具体的语法为：

@Slf4j
@Component
@Aspect
public class MyAspect2 {
    //引用MyAspect1切面类中的切入点表达式
    @Before("com.itheima.aspect.MyAspect1.pt()")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }
}

通知顺序

讲解完了Spring中AOP所支持的5种通知类型之后，接下来我们再来研究通知的执行顺序。

当在项目开发当中，我们定义了多个切面类，而多个切面类中多个切入点都匹配到了同一个目标方法。此时当目标方法在运行的时候，这多个切面类当中的这些通知方法都会运行。

此时我们就有一个疑问，这多个通知方法到底哪个先运行，哪个后运行？下面我们通过程序来验证（这里呢，我们就定义两种类型的通知进行测试，一种是前置通知@Before，一种是后置通知@After）

定义多个切面类：

@Slf4j
@Component
@Aspect
public class MyAspect2 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}

@Slf4j
@Component
@Aspect
public class MyAspect3 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect3 -> before ...");
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect3 ->  after ...");
    }
}

@Slf4j
@Component
@Aspect
public class MyAspect4 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect4 -> before ...");
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect4 -> after ...");
    }
}

重新启动SpringBoot服务，测试通知的执行顺序：

备注：

把DeptServiceImpl实现类中模拟异常的代码删除或注释掉。

注释掉其他切面类(把@Aspect注释即可)，仅保留MyAspect2、MyAspect3、MyAspect4 ，这样就可以清晰看到执行的结果，而不被其他切面类干扰。

使用 Apifox 测试查询所有部门数据。

查看idea中控制台日志输出

通过以上程序运行可以看出在不同切面类中，默认按照切面类的类名字母排序：
- 目标方法前的通知方法：字母排名靠前的先执行
- 目标方法后的通知方法：字母排名靠前的后执行

如果我们想控制通知的执行顺序有两种方式：

修改切面类的类名（这种方式非常繁琐、而且不便管理）
使用Spring提供的@Order注解

使用@Order注解，控制通知的执行顺序：

@Slf4j
@Component
@Aspect
@Order(2)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect2 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }

    //后置通知 
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}

@Slf4j
@Component
@Aspect
@Order(3)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect3 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect3 -> before ...");
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect3 ->  after ...");
    }
}

@Slf4j
@Component
@Aspect
@Order(1) //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect4 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect4 -> before ...");
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect4 -> after ...");
    }
}

重新启动SpringBoot服务，测试通知执行顺序：

通知的执行顺序大家主要知道两点即可：

不同的切面类当中，默认情况下通知的执行顺序是与切面类的类名字母排序是有关系的
可以在切面类上面加上@Order注解，来控制不同的切面类通知的执行顺序

切入点表达式

从AOP的入门程序到现在，我们一直都在使用切入点表达式来描述切入点。下面我们就来详细的介绍一下切入点表达式的具体写法。

切入点表达式：描述切入点方法的一种表达式

作用：主要用来决定项目中的哪些方法需要加入通知
常见形式：
- execution(……)：根据方法的签名来匹配
@annotation(……) ：根据注解匹配

首先我们先学习第一种最为常见的execution切入点表达式。

execution

execution主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：

`1`	`execution(访问修饰符? 返回值包名.类名.?方法名(方法参数) throws 异常?)`

其中带?的表示可以省略的部分

访问修饰符：可省略（比如: public、protected）
包名.类名：可省略（强烈不建议省略）
throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

示例：

`1`	`@Before("execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")`

可以使用通配符描述切入点

* ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分
.. ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数

切入点表达式的语法规则：

方法的访问修饰符可以省略
返回值可以使用*号代替（任意返回值类型）
包名可以使用*号代替，代表任意包（一层包使用一个*）
使用..配置包名，标识此包以及此包下的所有子包
类名可以使用*号代替，标识任意类
方法名可以使用*号代替，表示任意方法
可以使用 * 配置参数，一个任意类型的参数
可以使用.. 配置参数，任意个任意类型的参数

切入点表达式示例

省略方法的修饰符号

`1`	`execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))`

使用*代替返回值类型

`1`	`execution(* com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))`

使用*代替包名（一层包使用一个*）

`1`	`execution(* com.itheima...DeptServiceImpl.delete(java.lang.Integer))`

使用..省略包名

`1`	`execution(* com..DeptServiceImpl.delete(java.lang.Integer))`

使用*代替类名

`1`	`execution(* com..*.delete(java.lang.Integer))`

使用*代替方法名

`1`	`execution(* com...(java.lang.Integer))`

使用 * 代替参数

`1`	`execution(* com.itheima.service.impl.DeptServiceImpl.delete(*))`

使用..省略参数

`1`	`execution(* com...(..))`

将上述切入点表达式挨个放入示例中的代码里进行测试，测试时将其他@Before注释掉，然后点击左侧的红色m按钮看是可以跳转到对应的逻辑代码中，可以即为成功

注意事项：

根据业务需要，可以使用且（&&）、或（||）、非（!）来组合比较复杂的切入点表达式。

`1`	`execution(* com.itheima.service.DeptService.list(..)) \|\| execution(* com.itheima.service.DeptService.delete(..))`

切入点表达式的书写建议：

所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是 find 开头，更新类方法都是update开头

//业务类
@Service
public class DeptServiceImpl implements DeptService {
    
    public List<Dept> findAllDept() {
       //省略代码...
    }
    
    public Dept findDeptById(Integer id) {
       //省略代码...
    }
    
    public void updateDeptById(Integer id) {
       //省略代码...
    }
    
    public void updateDeptByMoreCondition(Dept dept) {
       //省略代码...
    }
    //其他代码...
}

//匹配DeptServiceImpl类中以find开头的方法

`1`	`execution(* com.itheima.service.impl.DeptServiceImpl.find*(..))`

描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性

`1`	`execution(* com.itheima.service.DeptService.*(..))`

在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名匹配尽量不使用 ..，使用 * 匹配单个包

`1`	`execution(* com.itheima...DeptServiceImpl.find*(..))`

切入点表达式书写建议：

所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：findXxx，updateXxx。

描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性。

在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名尽量不使用..，使用 * 匹配单个包。

@annotation

已经学习了execution切入点表达式的语法。那么如果我们要匹配多个无规则的方法，比如：list()和 delete()这两个方法。这个时候我们基于execution这种切入点表达式来描述就不是很方便了。而在之前我们是将两个切入点表达式组合在了一起完成的需求，这个是比较繁琐的。

我们可以借助于另一种切入点表达式 @annotation 来描述这一类的切入点，从而来简化切入点表达式的书写。

实现步骤：

编写自定义注解
在业务类要做为连接点的方法上添加自定义注解

新建一个类：com.itheima.anno.LogOperation

自定义注解：LogOperation

//定义注解
@Target(ElementType.METHOD)
//保留注解
@Retention(RetentionPolicy.RUNTIME)
public @interface LogOperation {
}

业务类：DeptServiceImpl

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    @Override
    @LogOperation //自定义注解（表示：当前方法属于目标方法）
    public List<Dept> list() {
        List<Dept> deptList = deptMapper.list();
        //模拟异常
        //int num = 10/0;
        return deptList;
    }

    @Override
    @LogOperation //自定义注解（表示：当前方法属于目标方法）
    public void delete(Integer id) {
        //1. 删除部门
        deptMapper.delete(id);
    }


    @Override
    public void save(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.save(dept);
    }

    @Override
    public Dept getById(Integer id) {
        return deptMapper.getById(id);
    }

    @Override
    public void update(Dept dept) {
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.update(dept);
    }
}

切面类

@Slf4j
@Component
@Aspect
public class MyAspect5 {
    //针对list方法、delete方法进行前置通知和后置通知

    //前置通知
    @Before("@annotation(com.itheima.anno.LogOperation)")
    public void before(){
        log.info("MyAspect5 -> before ...");
    }
    
    //后置通知
    @After("@annotation(com.itheima.anno.LogOperation)")
    public void after(){
        log.info("MyAspect5 -> after ...");
    }
}

重启SpringBoot服务，测试查询所有部门数据，查看控制台日志：

到此我们两种常见的切入点表达式我已经介绍完了。

execution切入点表达式
- 根据我们所指定的方法的描述信息来匹配切入点方法，这种方式也是最为常用的一种方式
- 如果我们要匹配的切入点方法的方法名不规则，或者有一些比较特殊的需求，通过execution切入点表达式描述比较繁琐
annotation 切入点表达式
- 基于注解的方式来匹配切入点方法。这种方式虽然多一步操作，我们需要自定义一个注解，但是相对来比较灵活。我们需要匹配哪个方法，就在方法上加上对应的注解就可以了

根据业务需要，可以使用 && ，||，！来组合比较复杂的切入点表达式。

连接点

我们前面在讲解AOP核心概念的时候，我们提到过什么是连接点，连接点可以简单理解为可以被AOP控制的方法。

我们目标对象当中所有的方法是不是都是可以被AOP控制的方法。而在SpringAOP当中，连接点又特指方法的执行。

在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型

对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

@Slf4j
@Aspect
@Component
public class MyAspect6 {

    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(JoinPoint joinPoint){
        log.info("before ....");
        //1. 获取目标对象
        Object target = joinPoint.getTarget();
        log.info("获取目标对象: {}", target);

        //2. 获取目标类
        String className = joinPoint.getTarget().getClass().getName();
        log.info("获取目标类: {}", className);

        //3. 获取目标方法
        String methodName = joinPoint.getSignature().getName();
        log.info("获取目标方法: {}", methodName);

        //4. 获取目标方法参数
        Object[] args = joinPoint.getArgs();
        log.info("获取目标方法参数: {}", Arrays.toString(args));
    }

    @Around("execution(* com.itheima.service.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        log.info("around ... before ....");

        Object result = pjp.proceed();

        log.info("around ... after ....");
        return result;
    }

}

AOP案例

SpringAOP的相关知识我们就已经全部学习完毕了。最后我们要通过一个案例来对AOP进行一个综合的应用。

需求

需求：将案例（Tlias智能学习辅助系统）中增、删、改相关接口的操作日志记录到数据库表中

就是当访问部门管理和员工管理当中的增、删、改相关功能接口时，需要详细的操作日志，并保存在数据表中，便于后期数据追踪。

操作日志信息包含：

操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长

所记录的日志信息包括当前接口的操作人是谁操作的，什么时间点操作的，以及访问的是哪个类当中的哪个方法，在访问这个方法的时候传入进来的参数是什么，访问这个方法最终拿到的返回值是什么，以及整个接口方法的运行时长是多长时间。

分析

问题1：项目当中增删改相关的方法是不是有很多？
- 很多
问题2：我们需要针对每一个功能接口方法进行修改，在每一个功能接口当中都来记录这些操作日志吗？
- 这种做法比较繁琐

以上两个问题的解决方案：可以使用AOP解决(每一个增删改功能接口中要实现的记录操作日志的逻辑代码是相同)。

可以把这部分记录操作日志的通用的、重复性的逻辑代码抽取出来定义在一个通知方法当中，我们通过AOP面向切面编程的方式，在不改动原始功能的基础上来对原始的功能进行增强。目前我们所增强的功能就是来记录操作日志，所以也可以使用AOP的技术来实现。使用AOP的技术来实现也是最为简单，最为方便的。

问题3：既然要基于AOP面向切面编程的方式来完成的功能，那么我们要使用 AOP五种通知类型当中的哪种通知类型？
- 答案：环绕通知 @Around。因为所记录的操作日志当中包括：操作人、操作时间，访问的是哪个类、哪个方法、方法运行时参数、方法的返回值、方法的运行时长。方法返回值，是在原始方法执行后才能获取到的。方法的运行时长，需要原始方法运行之前记录开始时间，原始方法运行之后记录结束时间。通过计算获得方法的执行耗时。基于以上的分析我们确定要使用Around环绕通知。
问题4：最后一个问题，切入点表达式我们该怎么写？
- 答案：使用 @annotation 来描述切入点表达式。要匹配业务接口当中所有的增删改的方法，而增删改方法在命名上没有共同的前缀或后缀。此时如果使用execution切入点表达式也可以，但是会比较繁琐。当遇到增删改的方法名没有规律时，就可以使用 @annotation切入点表达式，其中切入点表达式匹配的是controller的方法（如下图）

步骤

简单分析了一下大概的实现思路后，接下来我们就要来完成案例了。案例的实现步骤其实就两步：

准备工作
- 引入AOP的起步依赖
- 导入资料中准备好的数据库表结构，并引入对应的实体类
编码实现(基于AI实现)
- 自定义注解@LogOperation
- 定义切面类，完成记录操作日志的逻辑

代码实现

请帮我基于Spring AOP中的环绕通知 @Around 实现记录系统所有增、删、改功能接口的操作日志。具体信息如下：

日志信息包含：操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长

功能接口所在包为 com.itheima.controller

日志表为 operate_log 表，对应的实体类为 OperateLog。具体表结构如下：

create table operate_log(

id int unsigned primary key auto_increment comment ‘ID’,

operate_emp_id int unsigned comment ‘操作人ID’,

operate_time datetime comment ‘操作时间’,

class_name varchar(100) comment ‘操作的类名’,

method_name varchar(100) comment ‘操作的方法名’,

method_params varchar(1000) comment ‘方法参数’,

return_value varchar(2000) comment ‘返回值’,

cost_time int comment ‘方法执行耗时, 单位:ms’

) comment ‘操作日志表’;

并且已经提供了OperateLogMapper接口来操作 operate_log, 并在其中已经定义好了 insert 方法用来保存日志数据.

1). 准备工作

在 pom.xml 中引入AOP的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

创建数据库表结构

-- 操作日志表
create table operate_log(
    id int unsigned primary key auto_increment comment 'ID',
    operate_emp_id int unsigned comment '操作人ID',
    operate_time datetime comment '操作时间',
    class_name varchar(100) comment '操作的类名',
    method_name varchar(100) comment '操作的方法名',
    method_params varchar(1000) comment '方法参数',
    return_value varchar(2000) comment '返回值, 存储json格式',
    cost_time int comment '方法执行耗时, 单位:ms'
) comment '操作日志表';

引入资料中准备的实体类引入资料中准备的实体类

package com.itheima.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class OperateLog {
    private Integer id; //ID
    private Integer operateEmpId; //操作人ID
    private LocalDateTime operateTime; //操作时间
    private String className; //操作类名
    private String methodName; //操作方法名
    private String methodParams; //操作方法参数
    private String returnValue; //操作方法返回值
    private Long costTime; //操作耗时
}

引入资料中准备的日志操作Mapper接口 OperateLogMapper

package com.itheima.mapper;

import com.itheima.pojo.OperateLog;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface OperateLogMapper {
    
    //插入日志数据
    @Insert("insert into operate_log (operate_emp_id, operate_time, class_name, method_name, method_params, return_value, cost_time) " +
            "values (#{operateEmpId}, #{operateTime}, #{className}, #{methodName}, #{methodParams}, #{returnValue}, #{costTime});")
    public void insert(OperateLog log);
    
}

1). 自定义注解 @Log

/**
 *  自定义注解，用于标识哪些方法需要记录日志
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}

2). 定义AOP记录日志的切面类

package com.itheima.aop;

import com.itheima.anno.Log;
import com.itheima.mapper.OperateLogMapper;
import com.itheima.pojo.OperateLog;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.Arrays;

@Slf4j
@Aspect
@Component
public class OperationLogAspect {

    @Autowired
    private OperateLogMapper operateLogMapper;

    // 环绕通知
    @Around("@annotation(com.itheima.anno.Log)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 记录开始时间
        long startTime = System.currentTimeMillis();
        // 执行方法
        Object result = joinPoint.proceed();
        // 当前时间
        long endTime = System.currentTimeMillis();
        // 耗时
        long costTime = endTime - startTime;

        // 构建日志对象
        OperateLog olog = new OperateLog();
        olog.setOperateEmpId(getCurrentUserId()); // 需要实现 getCurrentUserId 方法
        olog.setOperateTime(LocalDateTime.now());
        olog.setClassName(joinPoint.getTarget().getClass().getName());
        olog.setMethodName(joinPoint.getSignature().getName());
        olog.setMethodParams(Arrays.toString(joinPoint.getArgs()));
        olog.setReturnValue(result.toString());
        olog.setCostTime(costTime);

        //保存日志
        log.info("记录操作日志:{}",log);

        // 插入日志
        operateLogMapper.insert(olog);
        return result;
    }

    // 示例方法，获取当前用户ID
    private int getCurrentUserId() {
        // 这里应该根据实际情况从认证信息中获取当前登录用户的ID
        return 1; // 示例返回值
    }
}

3). 在需要记录的日志的Controller层的方法上，加上注解@Log

@RestController
@RequestMapping("/clazzs")
public class ClazzController {

    @Autowired
    private ClazzService clazzService;

    
    /*
    * 删除部门
    * */
    @Log
    @DeleteMapping
    public Result delete(Integer id){
        //System.out.println("根据ID删除部门: " + id);
        log.info("根据ID删除部门: {}" ,id);
        deptService.deleteById(id);
        return Result.success();
    }

    /*
    * 新增部门
    * */
    @Log
    @PostMapping
    public Result add(@RequestBody Dept dept){
        //System.out.println("添加部门：" + dept);
        log.info("添加部门：{}" , dept);
        deptService.addDept(dept);
        return Result.success();
    }
    
    /**
     * 修改部门
     */
    @Log
    @PutMapping
    public Result update(@RequestBody Dept dept){
        //System.out.println("修改部门, dept=" + dept);
        log.info("修改部门, dept={}" , dept);
        deptService.update(dept);
        return Result.success();
    }
}

重启SpringBoot服务，测试操作日志记录功能：

打开浏览器，针对于员工的数据、部门的数据进行增删改之后。我们打开数据库表结构可以来看一下：

我们会看到，在数据库表中，就清晰的记录了谁、什么时间点、调用了哪个类的哪个方法、传入了什么参数、返回了什么数据，都清晰的记录在数据库中了。（此时id还没有进行优化）

获取当前登录员工

员工登录成功后，哪里存储的有当前登录员工的信息？ 给客户端浏览器下发的jwt令牌中
如何从JWT令牌中获取当前登录用户的信息呢？ 获取请求头中传递的jwt令牌，并解析
TokenFilter 中已经解析了令牌的信息，如何传递给AOP程序、Controller、Service呢？ThreadLocal

ThreadLocal

ThreadLocal 并不是一个Thread，而是Thread的局部变量。
ThreadLocal为每个线程提供一份单独的存储空间，具有线程隔离的效果，不同的线程之间不会相互干扰。

常见方法：
- public void set(T value) 设置当前线程的线程局部变量的值
- public T get() 返回当前线程所对应的线程局部变量的值
- public void remove() 移除当前线程的线程局部变量

示例：

package com.itheima;

public class ThreadLocalTest {
    private static ThreadLocal<String> local = new ThreadLocal<>();
    public static void main(String[] args) {
        //主线程
        local.set("Main Message");
        //创建线程
        //子线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                local.set("Child Message");
                System.out.println(Thread.currentThread().getName() + ": " + local.get());
            }
        }).start();

        System.out.println(Thread.currentThread().getName() + ": " + local.get());

        local.remove();
        System.out.println(Thread.currentThread().getName() + ": " + local.get());
    }
}

记录当前登录员工

增删改的执行流程：

前端发起请求，请求到达我们的web服务器（Tomcat服务器），服务器接收到这次请求，它就会从线程池当中获取一个线程来处理这次请求，直到这次请求处理完成，也就意味着一次请求对应一个线程，每一次请求都会有一个独立的线程来处理这次请求

我们可以来进行一个测试：在前端刷新一下部门管理页面（相当于查询部门）：

这便是线程池当中的线程

具体操作步骤：

定义ThreadLocal操作的工具类，用于操作当前登录员工ID。

在 com.itheima.utils 引入工具类 CurrentHolder

package com.itheima.utils;

public class CurrentHolder {

    private static final ThreadLocal<Integer> CURRENT_LOCAL = new ThreadLocal<>();

    public static void setCurrentId(Integer employeeId) {
        CURRENT_LOCAL.set(employeeId);
    }

    public static Integer getCurrentId() {
        return CURRENT_LOCAL.get();
    }

    public static void remove() {
        CURRENT_LOCAL.remove();
    }
}

在TokenFilter中，解析完当前登录员工ID，将其存入ThreadLocal（用完之后需将其删除）。

package com.itheima.filter;

import com.itheima.utils.CurrentHolder;
import com.itheima.utils.JwtUtils;
import io.jsonwebtoken.Claims;
import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import java.io.IOException;

@Slf4j
@WebFilter(urlPatterns = "/*")
public class TokenFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        //1. 获取请求的url地址
        String uri = request.getRequestURI(); // /employee/login
        //String url = request.getRequestURL().toString(); // http://localhost:8080/employee/login

        //2. 判断是否是登录请求, 如果url地址中包含 login, 则说明是登录请求, 放行
        if (uri.contains("login")) {
            log.info("登录请求, 放行");
            filterChain.doFilter(request, response);
            return;
        }

        //3. 获取请求中的token
        String token = request.getHeader("token");

        //4. 判断token是否为空, 如果为空, 响应401状态码
        if (token == null || token.isEmpty()) {
            log.info("token为空, 响应401状态码");
            response.setStatus(401); // 响应401状态码
            return;
        }

        //5. 如果token不为空, 调用JWtUtils工具类的方法解析token, 如果解析失败, 响应401状态码
        try {
            Claims claims = JwtUtils.parseJWT(token);
            Integer empId = Integer.valueOf(claims.get("id").toString());
            CurrentHolder.setCurrentId(empId);
            log.info("token解析成功, 放行");
        } catch (Exception e) {
            log.info("token解析失败, 响应401状态码");
            response.setStatus(401);
            return;
        }

        //6. 放行
        filterChain.doFilter(request, response);

        //7. 清空当前线程绑定的id
        CurrentHolder.remove();
    }
}

在AOP程序中，从ThreadLocal中获取当前登录员工的ID。

package com.itheima.aop;

import com.itheima.anno.LogOperation;
import com.itheima.mapper.OperateLogMapper;
import com.itheima.pojo.OperateLog;
import com.itheima.utils.CurrentHolder;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.Arrays;

@Aspect
@Component
public class OperationLogAspect {

    @Autowired
    private OperateLogMapper operateLogMapper;

    // 环绕通知
    @Around("@annotation(log)")
    public Object around(ProceedingJoinPoint joinPoint, LogOperation log) throws Throwable {
        // 记录开始时间
        long startTime = System.currentTimeMillis();
        // 执行方法
        Object result = joinPoint.proceed();
        // 当前时间
        long endTime = System.currentTimeMillis();
        // 耗时
        long costTime = endTime - startTime;

        // 构建日志对象
        OperateLog operateLog = new OperateLog();
        operateLog.setOperateEmpId(getCurrentUserId()); // 需要实现 getCurrentUserId 方法
        operateLog.setOperateTime(LocalDateTime.now());
        operateLog.setClassName(joinPoint.getTarget().getClass().getName());
        operateLog.setMethodName(joinPoint.getSignature().getName());
        operateLog.setMethodParams(Arrays.toString(joinPoint.getArgs()));
        operateLog.setReturnValue(result.toString());
        operateLog.setCostTime(costTime);

        // 插入日志
        operateLogMapper.insert(operateLog);
        return result;
    }

    // 示例方法，获取当前用户ID
    private int getCurrentUserId() {
        return CurrentHolder.getCurrentId();
    }
}

代码优化完毕之后，我们重新启动服务测试。就可以看到，可以获取到不同的登录用户信息了。

在同一个线程/同一个请求中，进行数据共享就可以使用 ThreadLocal。

新增日志管理

此节为完善日志管理功能模块

接口描述

代码实现

OperateLogController：

package com.itheima.controller;

import com.itheima.pojo.OperateLog;
import com.itheima.pojo.PageResult;
import com.itheima.pojo.Result;
import com.itheima.service.OperateLogService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 操作日志
 */
@Slf4j
@RequestMapping("/log")
@RestController
public class OperateLogController {

    @Autowired
    private OperateLogService operateLogService;

    /*
    * 分页查询日志
    * */
    @GetMapping("/page")
    public Result page(@RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "10") Integer pageSize) {
        log.info("日志分页查询：page={}, pageSize={}", page, pageSize);
        PageResult<OperateLog> pageResult = operateLogService.page(page, pageSize);
        return Result.success(pageResult);
    }
}

OperateLogService：

package com.itheima.service;

import com.itheima.pojo.OperateLog;
import com.itheima.pojo.PageResult;

public interface OperateLogService {

    /*
    * 分页查询日志
    * */
    PageResult<OperateLog> page(Integer page, Integer pageSize);
}

OperateLogServiceImpl：

package com.itheima.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.itheima.mapper.OperateLogMapper;
import com.itheima.pojo.OperateLog;
import com.itheima.pojo.PageResult;
import com.itheima.service.OperateLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class OperateLogServiceImpl implements OperateLogService {

    @Autowired
    private OperateLogMapper operateLogMapper;

    @Override
    public PageResult<OperateLog> page(Integer page, Integer pageSize) {
        //1. 设置分页参数
        PageHelper.startPage(page, pageSize);
        //2. 执行查询
        List<OperateLog> logList = operateLogMapper.list();
        //3. 封装分页结果
        Page<OperateLog> p = (Page<OperateLog>) logList;
        return new PageResult<>(p.getTotal(), p.getResult());
    }
}

OperateLogMapper接口：

1
2
3

//分页查询日志数据
@Select("select * from operate_log order by operate_time desc")
public List<OperateLog> list();

前后端联调测试

功能测试

Web后端实战（6）

Sun, 17 May 2026 14:02:36 +0800

Tlias智能学习辅助系统

通过前面的学习，我们已经实现了部门管理、员工管理的基本功能，但是会发现，我们并没有登录，就直接访问到了Tlias智能学习辅助系统的后台。这是不安全的，所以我们今天的主题就是登录认证。最终要实现的效果是：

如果用户名密码错误，不允许登录系统。

如果用户名和密码都正确，则登录成功，可以访问系统。

登录功能

需求

在登录界面中，我们可以输入用户的用户名以及密码，然后点击 “登录” 按钮就要请求服务器，服务端判断用户输入的用户名或者密码是否正确。如果正确，则返回成功结果，前端跳转至系统首页面。

接口描述

地址：接口文档 - 飞书云文档

我们参照接口文档中的 其他接口 -> 登录接口

思路分析

怎么样才算登录成功了呢？
- 用户名和密码都输入正确，登录成功
- 否则，登录失败
登录功能的本质是什么？
- 查询
- 根据用户名和密码查询员工信息
三层架构

功能开发

AI提示词：

你是一名java开发工程师，现需要基于 SpringBoot+Mybatis 实现员工登录的基本功能，开发一个基本的登录接口，基本信息如下：

接口请求路径 /login ，请求方式post

接口请求参数有：用户名 username，密码 password，为json格式的数据 {“username”:“admin”, “password”:“123456”}

接口响应数据：json格式，具体的数据格式如下：

{

“code”: 1,

“msg”: “success”,

“data”: {

“id”: 1,

“username”: “songjiang”,

“name”: “宋江”,

“token”: “…”

}

}

数据库表为 emp, 对应的实体类为Emp，已存在，对应的表结构为：

create table emp (

id int unsigned primary key auto_increment comment ‘ID,主键’,

username varchar(20) not null comment ‘用户名’,

password varchar(32) default ‘123456’ not null comment ‘密码’,

name varchar(10) not null comment ‘姓名’,

gender tinyint unsigned not null comment ‘性别, 1:男, 2:女’,

phone char(11) not null comment ‘手机号’,

job tinyint unsigned null comment ‘职位, 1:班主任,2:讲师,3:学工主管,4:教研主管,5:咨询师’,

salary int unsigned null comment ‘薪资’,

image varchar(300) null comment ‘头像’,

entry_date date null comment ‘入职日期’,

dept_id int unsigned null comment ‘关联的部门ID’,

create_time datetime null comment ‘创建时间’,

update_time datetime null comment ‘修改时间’,

constraint emp_pk unique (phone),

constraint username unique (username)

) comment ‘员工表’;

1). 准备实体类LoginInfo，封装登录成功后，返回给前端的数据。

/**
 * 登录成功结果封装类
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginInfo {
    private Integer id; //员工ID
    private String username; //用户名
    private String name; //姓名
    private String token; //令牌
}

2). 定义LoginController

@Slf4j
@RestController
public class LoginController {

    @Autowired
    private EmpService empService;

    @PostMapping("/login")
    public Result login(@RequestBody Emp emp){
        log.info("登录 :{}", emp);
        LoginInfo loginInfo = empService.login(emp);
        if(loginInfo != null){
            return Result.success(loginInfo);
        }
        return Result.error("用户名或密码错误~");
    }

}

3). EmpService接口中增加 login 登录方法

/**
 * 登录
 */
LoginInfo login(Emp emp);

4). EmpServiceImpl实现login方法

@Override
public LoginInfo login(Emp emp) {
    Emp empLogin = empMapper.getUsernameAndPassword(emp);
    if(empLogin != null){
        LoginInfo loginInfo = new LoginInfo(empLogin.getId(), empLogin.getUsername(), empLogin.getName(), null);
        return loginInfo;
    }
    return null;
}

5). EmpMapper增加接口方法

/**
 * 根据用户名和密码查询员工信息
 */
@Select("select * from emp where username = #{username} and password = #{password}")
Emp getUsernameAndPassword(Emp emp);

功能测试

功能开发完毕后，我们就可以启动服务，打开 Apifox 进行测试了。

发起POST请求，访问：http://localhost:8080/login

前后端联调测试

错误密码登录：

成功登录后进入到后台管理系统页面：

我们已经完成了基础登录功能的开发与测试，在我们登录成功后就可以进入到后台管理系统中进行数据的操作。

但是当我们在浏览器中新的页面上输入地址：http://localhost:90，发现没有登录仍然可以进入到后端管理系统页面。

而真正的登录功能应该是：登陆后才能访问后端系统页面，不登陆则跳转登陆页面进行登陆。

为什么会出现这个问题？其实原因很简单，就是因为针对于我们当前所开发的部门管理、员工管理以及文件上传等相关接口来说，我们在服务器端并没有做任何的判断，没有去判断用户是否登录了。所以无论用户是否登录，都可以访问部门管理以及员工管理的相关数据。所以我们目前所开发的登录功能，它只是徒有其表。而我们要想解决这个问题，我们就需要完成一步非常重要的操作：登录校验。

登录校验

什么是登录校验？

所谓登录校验，指的是我们在服务器端接收到浏览器发送过来的请求之后，首先我们要对请求进行校验。先要校验一下用户登录了没有，如果用户已经登录了，就直接执行对应的业务操作就可以了；如果用户没有登录，此时就不允许他执行相关的业务操作，直接给前端响应一个错误的结果，最终跳转到登录页面，要求他登录成功之后，再来访问对应的数据。

思路

了解完什么是登录校验之后，接下来我们分析一下登录校验大概的实现思路。

首先我们在宏观上先有一个认知：

前面在讲解HTTP协议的时候，我们提到HTTP协议是无状态协议。什么又是无状态的协议？

所谓无状态，指的是每一次请求都是独立的，下一次请求并不会携带上一次请求的数据。而浏览器与服务器之间进行交互，基于HTTP协议也就意味着现在我们通过浏览器来访问了登陆这个接口，实现了登陆的操作，接下来我们在执行其他业务操作时，服务器也并不知道这个员工到底登陆了没有。因为HTTP协议是无状态的，两次请求之间是独立的，所以是无法判断这个员工到底登陆了没有。

那应该怎么来实现登录校验的操作呢？具体的实现思路可以分为两部分：

在员工登录成功后，需要将用户登录成功的信息存起来，记录用户已经登录成功的标记。
在浏览器发起请求时，需要在服务端进行统一拦截，拦截后进行登录校验。

想要判断员工是否已经登录，我们需要在员工登录成功之后，存储一个登录成功的标记，接下来在每一个接口方法执行之前，先做一个条件判断，判断一下这个员工到底登录了没有。如果是登录了，就可以执行正常的业务操作，如果没有登录，会直接给前端返回一个错误的信息，前端拿到这个错误信息之后会自动的跳转到登录页面。

我们程序中所开发的查询功能、删除功能、添加功能、修改功能，都需要使用以上套路进行登录校验。此时就会出现：相同代码逻辑，每个功能都需要编写，就会造成代码非常繁琐。

为了简化这块操作，我们可以使用一种技术：统一拦截技术。

通过统一拦截的技术，我们可以来拦截浏览器发送过来的所有的请求，拦截到这个请求之后，就可以通过请求来获取之前所存入的登录标记，在获取到登录标记且标记为登录成功，就说明员工已经登录了。如果已经登录，我们就直接放行(意思就是可以访问正常的业务接口了)。

我们要完成以上操作，会涉及到web开发中的两个技术：

会话技术

介绍

什么是会话？

在我们日常生活当中，会话指的就是谈话、交谈。
在web开发当中，会话指的就是浏览器与服务器之间的一次连接，我们就称为一次会话。

在用户打开浏览器第一次访问服务器的时候，这个会话就建立了，直到有任何一方断开连接，此时会话就结束了。在一次会话当中，是可以包含多次请求和响应的。

比如：打开了浏览器来访问web服务器上的资源（浏览器不能关闭、服务器不能断开）

第1次：访问的是登录的接口，完成登录操作

第2次：访问的是部门管理接口，查询所有部门数据

第3次：访问的是员工管理接口，查询员工数据

只要浏览器和服务器都没有关闭，以上3次请求都属于一次会话当中完成的。

需要注意的是：会话是和浏览器关联的，当有三个浏览器客户端和服务器建立了连接时，就会有三个会话。同一个浏览器在未关闭之前请求了多次服务器，这多次请求是属于同一个会话。比如：1、2、3这三个请求都是属于同一个会话。当我们关闭浏览器之后，这次会话就结束了。而如果我们是直接把web服务器关了，那么所有的会话就都结束了。

知道了会话的概念了，接下来我们再来了解下会话跟踪。

**会话跟踪：**一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。

比如在使用浏览器进行登录时的验证码校验就包含了两次请求，第一次是请求验证码，第二次是请求登录

服务器会接收很多的请求，但是服务器是需要识别出这些请求是不是同一个浏览器发出来的。比如：1和2这两个请求是不是同一个浏览器发出来的，3和5这两个请求不是同一个浏览器发出来的。如果是同一个浏览器发出来的，就说明是同一个会话。如果是不同的浏览器发出来的，就说明是不同的会话。而识别多次请求是否来自于同一浏览器的过程，我们就称为会话跟踪。

我们使用会话跟踪技术就是要完成在同一个会话中，多个请求之间进行共享数据。

为什么要共享数据呢？

由于HTTP是无状态协议，在后面请求中怎么拿到前一次请求生成的数据呢？此时就需要在一次会话的多次请求之间进行数据共享

会话跟踪技术有三种：

Cookie（客户端会话跟踪技术）：数据存储在客户端浏览器当中
Session（服务端会话跟踪技术）：数据存储在储在服务端
令牌技术

会话跟踪方案

方案一：Cookie

cookie 是客户端会话跟踪技术，它是存储在客户端浏览器的，我们使用 cookie 来跟踪会话，我们就可以在浏览器第一次发起请求来请求服务器的时候，我们在服务器端来设置一个cookie。

比如第一次请求了登录接口，登录接口执行完成之后，我们就可以设置一个cookie，在 cookie 当中我们就可以来存储用户相关的一些数据信息。比如我可以在 cookie 当中来存储当前登录用户的用户名，用户的ID。

服务器端在给客户端在响应数据的时候，会自动的将 cookie 响应给浏览器，浏览器接收到响应回来的 cookie 之后，会自动的将 cookie 的值存储在浏览器本地。接下来在后续的每一次请求当中，都会将浏览器本地所存储的 cookie 自动地携带到服务端。

接下来在服务端我们就可以获取到 cookie 的值。我们可以去判断一下这个 cookie 的值是否存在，如果不存在这个cookie，就说明客户端之前是没有访问登录接口的；如果存在 cookie 的值，就说明客户端之前已经登录完成了。这样我们就可以基于 cookie 在同一次会话的不同请求之间来共享数据。

我刚才在介绍流程的时候，用了 3 个自动：

服务器会自动的将 cookie 响应给浏览器。
浏览器接收到响应回来的数据之后，会自动的将 cookie 存储在浏览器本地。
在后续的请求当中，浏览器会自动的将 cookie 携带到服务器端。

为什么这一切都是自动化进行的？

是因为 cookie 它是 HTP 协议当中所支持的技术，而各大浏览器厂商都支持了这一标准。在 HTTP 协议官方给我们提供了一个响应头和请求头：

响应头 Set-Cookie ：设置Cookie数据的
请求头 Cookie：携带Cookie数据的

代码测试：

@Slf4j
@RestController
public class SessionController {

    //设置Cookie
    @GetMapping("/c1")
    public Result cookie1(HttpServletResponse response){
        response.addCookie(new Cookie("login_username","itheima")); //设置Cookie/响应Cookie
        return Result.success();
    }
        
    //获取Cookie
    @GetMapping("/c2")
    public Result cookie2(HttpServletRequest request){
        Cookie[] cookies = request.getCookies();
        for (Cookie cookie : cookies) {
            if(cookie.getName().equals("login_username")){
                System.out.println("login_username: "+cookie.getValue()); //输出name为login_username的cookie
            }
        }
        return Result.success();
    }
}

A. 访问c1接口，设置Cookie，

我们可以看到，设置的cookie，通过响应头Set-Cookie响应给浏览器，并且浏览器会将Cookie，存储在浏览器端。

B. 访问c2接口 http://localhost:8080/c2，此时浏览器会自动的将Cookie携带到服务端，是通过请求头Cookie，携带的。

可以看到响应的Cookie，注意：此时控制台的报错信息为没有favicon.ico这个静态资源，这是浏览器的图标，由于我现在并没有这个资源所以就会报错，这个问题可以不用管它

优缺点：

优点：HTTP协议中支持的技术（像Set-Cookie 响应头的解析以及 Cookie 请求头数据的携带，都是浏览器自动进行的，是无需我们手动操作的）
缺点：
- 移动端APP(Android、IOS)中无法使用Cookie
- 不安全，用户可以自己禁用Cookie
- Cookie不能跨域

跨域介绍：

现在的项目，大部分都是前后端分离的，前后端最终也会分开部署，前端部署在服务器 192.168.150.200 上，端口 80，后端部署在 192.168.150.100上，端口 8080

我们打开浏览器直接访问前端工程，访问url：http://192.168.150.200/login.html

然后在该页面发起请求到服务端，而服务端所在地址不再是localhost，而是服务器的IP地址192.168.150.100，假设访问接口地址为：http://192.168.150.100:8080/login

那此时就存在跨域操作了，因为我们是在 http://192.168.150.200/login.html 这个页面上访问了http://192.168.150.100:8080/login 接口

此时如果服务器设置了一个Cookie，这个Cookie是不能使用的，因为Cookie无法跨域

区分跨域的维度（三个维度有任何一个维度不同，那就是跨域操作）：

协议

IP/协议

端口

举例：

http://192.168.150.200/login.html ———-> https://192.168.150.200/login [协议不同，跨域]

http://192.168.150.200/login.html ———-> http://192.168.150.100/login [IP不同，跨域]

http://192.168.150.200/login.html ———-> http://192.168.150.200:8080/login [端口不同，跨域]

http://192.168.150.200/login.html ———-> http://192.168.150.200/login

方案二：Session

前面介绍的时候，我们提到Session，它是服务器端会话跟踪技术，所以它是存储在服务器端的。而 Session 的底层其实就是基于我们刚才所介绍的 Cookie 来实现的。

获取Session

如果我们现在要基于 Session 来进行会话跟踪，浏览器在第一次请求服务器的时候，我们就可以直接在服务器当中来获取到会话对象Session。如果是第一次请求Session ，会话对象是不存在的，这个时候服务器会自动的创建一个会话对象Session 。而每一个会话对象Session ，它都有一个ID（示意图中Session后面括号中的1，就表示ID），我们称之为 Session 的ID。

响应Cookie (JSESSIONID)

接下来，服务器端在给浏览器响应数据的时候，它会将 Session 的 ID 通过 Cookie 响应给浏览器。其实在响应头当中增加了一个 Set-Cookie 响应头。这个 Set-Cookie 响应头对应的值是不是cookie？ cookie 的名字是固定的 JSESSIONID 代表的服务器端会话对象 Session 的 ID。浏览器会自动识别这个响应头，然后自动将Cookie存储在浏览器本地。

查找Session

接下来，在后续的每一次请求当中，都会将 Cookie 的数据获取出来，并且携带到服务端。接下来服务器拿到JSESSIONID这个 Cookie 的值，也就是 Session 的ID。拿到 ID 之后，就会从众多的 Session 当中来找到当前请求对应的会话对象Session。

这样我们是不是就可以通过 Session 会话对象在同一次会话的多次请求之间来共享数据了？好，这就是基于 Session 进行会话跟踪的流程。

代码测试

@Slf4j
@RestController
public class SessionController {

    //存值
    @GetMapping("/s1")
    public Result session1(HttpSession session){
        log.info("HttpSession-s1: {}", session.hashCode());

        session.setAttribute("loginUser", "tom"); //往session中存储数据
        return Result.success();
    }
    
	//取值
    @GetMapping("/s2")
    public Result session2(HttpServletRequest request){
        HttpSession session = request.getSession();
        log.info("HttpSession-s2: {}", session.hashCode());

        Object loginUser = session.getAttribute("loginUser"); //从session中获取数据
        log.info("loginUser: {}", loginUser);
        return Result.success(loginUser);
    }
}

A. 访问 s1 接口，http://localhost:8080/s1

请求完成之后，在响应头中，就会看到有一个Set-Cookie的响应头，里面响应回来了一个Cookie，就是JSESSIONID，这个就是服务端会话对象 Session 的ID。

B. 访问 s2 接口，http://localhost:8080/s2

接下来，在后续的每次请求时，都会将Cookie的值，携带到服务端，那服务端呢，接收到Cookie之后，会自动的根据JSESSIONID的值，找到对应的会话对象Session。

那经过这两步测试，大家也会看到，在控制台中输出如下日志：

两次请求，获取到的Session会话对象的hashcode是一样的，就说明是同一个会话对象。而且，第一次请求时，往Session会话对象中存储的值，第二次请求时，也获取到了。那这样，我们就可以通过Session会话对象，在同一个会话的多次请求之间来进行数据共享了。

优缺点

优点：Session是存储在服务端的，安全
缺点：
- 服务器集群环境下无法直接使用Session
- 移动端APP(Android、IOS)中无法使用Cookie
- 用户可以自己禁用Cookie
- Cookie不能跨域

PS：Session 底层是基于Cookie实现的会话跟踪，如果Cookie不可用，则该方案，也就失效了。

服务器集群环境为何无法使用Session？

首先第一点，我们现在所开发的项目，一般都不会只部署在一台服务器上，因为一台服务器会存在一个很大的问题，就是单点故障。所谓单点故障，指的就是一旦这台服务器挂了，整个应用都没法访问了。

所以在现在的企业项目开发当中，最终部署的时候都是以集群的形式来进行部署，也就是同一个项目它会部署多份。比如这个项目我们现在就部署了 3 份。

而用户在访问的时候，到底访问这三台其中的哪一台？其实用户在访问的时候，他会访问一台前置的服务器，我们叫负载均衡服务器,它的作用就是将前端发起的请求均匀的分发给后面的这三台服务器。

此时假如我们通过 session 来进行会话跟踪，可能就会存在这样一个问题。用户打开浏览器要进行登录操作，此时会发起登录请求。登录请求到达负载均衡服务器，将这个请求转给了第一台 Tomcat 服务器。

Tomcat 服务器接收到请求之后，要获取到会话对象session。获取到会话对象 session 之后，要给浏览器响应数据，最终在给浏览器响应数据的时候，就会携带这么一个 cookie 的名字，就是 JSESSIONID ，下一次再请求的时候，是不是又会将 Cookie 携带到服务端？

好。此时假如又执行了一次查询操作，要查询部门的数据。这次请求到达负载均衡服务器之后，负载均衡服务器将这次请求转给了第二台 Tomcat 服务器，此时他就要到第二台 Tomcat 服务器当中。根据JSESSIONID 也就是对应的 session 的 ID 值，要找对应的 session 会话对象。

我想请问在第二台服务器当中有没有这个ID的会话对象 Session，是没有的。此时是不是就出现问题了？我同一个浏览器发起了 2 次请求，结果获取到的不是同一个会话对象，这就是Session这种会话跟踪方案它的缺点，在服务器集群环境下无法直接使用Session。

可以看到上面这两种传统的会话技术，在现在的企业开发当中会存在很多的问题。为了解决这些问题，在现在的企业开发当中，基本上都会采用第三种方案，通过令牌技术来进行会话跟踪。

方案三：令牌技术

这里我们所提到的令牌，其实它就是一个用户身份的标识，看似很高大上，很神秘，其实本质就是一个字符串。

如果通过令牌技术来跟踪会话，我们就可以在浏览器发起请求。在请求登录接口的时候，如果登录成功，我就可以生成一个令牌，令牌就是用户的合法身份凭证。接下来我在响应数据的时候，我就可以直接将令牌响应给前端。

接下来我们在前端程序当中接收到令牌之后，就需要将这个令牌存储起来。这个存储可以存储在 cookie 当中，也可以存储在其他的存储空间(比如：localStorage)当中。

接下来，在后续的每一次请求当中，都需要将令牌携带到服务端。携带到服务端之后，接下来我们就需要来校验令牌的有效性。如果令牌是有效的，就说明用户已经执行了登录操作，如果令牌是无效的，就说明用户之前并未执行登录操作。

此时，如果是在同一次会话的多次请求之间，我们想共享数据，我们就可以将共享的数据存储在令牌当中就可以了。

优缺点

优点：
- 支持PC端、移动端
- 解决集群环境下的认证问题
- 减轻服务器的存储压力（无需在服务器端存储）
缺点：需要自己实现（包括令牌的生成、令牌的传递、令牌的校验）

针对于这三种方案，现在企业开发当中使用的最多的就是第三种令牌技术进行会话跟踪。而前面的这两种传统的方案，现在企业项目开发当中已经很少使用了。所以在后续的学习当中，我也将会采用令牌技术来解决案例项目当中的会话跟踪问题。

三种方案总结对比：

JWT令牌最典型的应用场景就是登录认证：

在浏览器发起请求来执行登录操作，此时会访问登录的接口，如果登录成功之后，我们需要生成一个jwt令牌，将生成的 jwt令牌返回给前端。
前端拿到jwt令牌之后，会将jwt令牌存储起来。在后续的每一次请求中都会将jwt令牌携带到服务端。
服务端统一拦截请求之后，先来判断一下这次请求有没有把令牌带过来，如果没有带过来，直接拒绝访问，如果带过来了，还要校验一下令牌是否是有效。如果有效，就直接放行进行请求的处理。

在JWT登录认证的场景中我们发现，整个流程当中涉及到两步操作：

在登录成功之后，要生成令牌。
每一次请求当中，要接收令牌并对令牌进行校验。

JWT令牌

前面我们介绍了基于令牌技术来实现会话追踪。这里所提到的令牌就是用户身份的标识，其本质就是一个字符串。令牌的形式有很多，我们使用的是功能强大的 JWT令牌。

介绍

JWT全称 JSON Web Token （官网：https://jwt.io/），定义了一种简洁的、自包含的格式，用于在通信双方以json数据格式安全的传输信息。由于数字签名的存在，这些信息是可靠的。
- 简洁：是指jwt就是一个简单的字符串。可以在请求参数或者是请求头当中直接传递。
- 自包含：指的是jwt令牌，看似是一个随机的字符串，但是我们是可以根据自身的需求在jwt令牌中存储自定义的数据内容。如：可以直接在jwt令牌中存储用户的相关信息。
- 简单来讲，jwt就是将原始的json数据格式进行了安全的封装，这样就可以直接基于jwt在通信双方安全的进行信息传输了。

JWT的组成：（JWT令牌由三个部分组成，三个部分之间使用英文的点来分割）

第一部分：Header(头），记录令牌类型、签名算法等。例如：{“alg”:“HS256”,“type”:“JWT”}
第二部分：Payload(有效载荷），携带一些自定义信息、默认信息等。例如：{“id”:“1”,“username”:“Tom”}
第三部分：Signature(签名），防止Token被篡改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来。

签名的目的就是为了防jwt令牌被篡改，而正是因为jwt令牌最后一个部分数字签名的存在，所以整个jwt 令牌是非常安全可靠的。一旦jwt令牌当中任何一个部分、任何一个字符被篡改了，整个令牌在校验的时候都会失败，所以它是非常安全可靠的。

JWT是如何将原始的JSON格式数据，转变为字符串的呢？

其实在生成JWT令牌时，会对JSON格式的数据进行一次编码：进行base64编码
Base64：是一种基于64个可打印的字符来表示二进制数据的编码方式。既然能编码，那也就意味着也能解码。所使用的64个字符分别是A到Z、a到z、 0- 9，一个加号，一个斜杠，加起来就是64个字符。任何数据经过base64编码之后，最终就会通过这64个字符来表示。当然还有一个符号，那就是等号。等号它是一个补位的符号
需要注意的是Base64是编码方式，而不是加密方式。

生成和校验

简单介绍了JWT令牌以及JWT令牌的组成之后，接下来我们就来学习基于Java代码如何生成和校验JWT令牌。

1). 首先我们先来实现JWT令牌的生成。要想使用JWT令牌，需要先引入JWT的依赖：

<!-- JWT依赖-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

在引入完JWT依赖后，就可以调用工具包中提供的API来完成JWT令牌的生成和校验。工具类：Jwts

2). 生成JWT代码实现：

  @Test
    public void testGenJwt() {
        Map<String, Object> claims = new HashMap<>();
        claims.put("id", 10);
        claims.put("username", "admin");

        //生成JWT令牌
        String jwt = Jwts.builder()
                //注意：此处" "里的内容是要去将你想要输入的内容转化为base64编码，此处是将字符串"itheima"进行base64编码
                .signWith(SignatureAlgorithm.HS256, "aXRoZWltYQ==")
                .addClaims(claims)//添加自定义信息
                .setExpiration(new Date(System.currentTimeMillis() + 3600 * 1000))//设置令牌有效期:1h
                .compact();
        System.out.println(jwt);
    }

运行测试方法：

`1`	`eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MTAsInVzZXJuYW1lIjoiYWRtaW4iLCJleHAiOjE3NzkwMjYxNzh9.kFW_awg_7DpJ-ld0Yk9N6WkItahYCPY6SxRpdZm_I6A`

输出的结果就是生成的JWT令牌,，通过英文的点分割对三个部分进行分割，我们可以将生成的令牌复制一下，然后打开JWT的官网，将生成的令牌直接放在Encoded位置，此时就会自动的将令牌解析出来。

第一部分解析出来，看到JSON格式的原始数据，所使用的签名算法为HS256。

第二个部分是我们自定义的数据，之前我们自定义的数据就是id，还有一个exp代表的是我们所设置的过期时间。

由于前两个部分是base64编码，所以是可以直接解码出来。但最后一个部分并不是base64编码，是经过签名算法计算出来的，所以最后一个部分是不会解析的。

3). 实现了JWT令牌的生成，下面我们接着使用Java代码来校验JWT令牌(解析生成的令牌)：

@Test
public void testParseJwt() {
    Claims claims = Jwts.parser().setSigningKey("aXRoZWltYQ==")
        .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MTAsInVzZXJuYW1lIjoiYWRtaW4iLCJleHAiOjE3NzkwMjY3NzV9.dpsge5KAa9d0MTFZmJaCjh78TW5H9BF1WWCpzBW1VpE")
        .getBody();
    System.out.println(claims);
}

注意将这里的令牌替换为自己的令牌，如果一直报错可以尝试重新生成一个令牌再将生成的令牌放进来，必须一个字符都不能错

运行测试方法：

`1`	`{id=10, username=admin, exp=1779026775}`

令牌解析后，我们可以看到id和过期时间，如果在解析的过程当中没有报错，就说明解析成功了。

下面我们做一个测试：把令牌header中的数字9变为8，还是随便将一个字母进行大小写互换，运行测试方法后都会发现报错：

结论：篡改令牌中的任何一个字符，在对令牌进行解析时都会报错，所以JWT令牌是非常安全可靠的。

我们继续测试：修改生成令牌的时指定的过期时间，修改为1分钟。

@Test
public void genJwt(){
    Map<String, Object> claims = new HashMap<>();
    claims.put("id", 10);
    claims.put("username", "itheima");

    String jwt = Jwts.builder().signWith(SignatureAlgorithm.HS256, "aXRjYXN0")
        .addClaims(claims)
        .setExpiration(new Date(System.currentTimeMillis() + 60 * 1000)) //有效期60s
        .compact();
    System.out.println(jwt);
    //输出结果：eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MTAsInVzZXJuYW1lIjoiYWRtaW4iLCJleHAiOjE3NzkwMjM2OTB9.qLyt0ewcR06W58giSPRC_XXS71-Omt4ZSQ_1gVE0vYE
}

@Test
public void parseJwt(){
    Claims claims = Jwts.parser()
        .setSigningKey("aXRjYXN0")//指定签名密钥
        .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MTAsInVzZXJuYW1lIjoiYWRtaW4iLCJleHAiOjE3NzkwMjM2OTB9.qLyt0ewcR06W58giSPRC_XXS71-Omt4ZSQ_1gVE0vYE)
        .getBody();

    System.out.println(claims);
}

等待1分钟之后运行测试方法发现也报错了，说明：JWT令牌过期后，令牌就失效了，解析的为非法令牌。

通过以上测试，我们在使用JWT令牌时需要注意：

JWT校验时使用的签名秘钥，必须和生成JWT令牌时使用的秘钥是配套的。

如果JWT令牌解析校验时报错，则说明 JWT令牌被篡改或失效了（过期了），令牌非法。

登录时下发令牌

JWT令牌的生成和校验的基本操作我们已经学习完了，接下来我们就需要在案例当中通过JWT令牌技术来跟踪会话。具体的思路我们前面已经分析过了，主要就是两步操作：

生成令牌
1. 在登录成功之后来生成一个JWT令牌，并且把这个令牌直接返回给前端
校验令牌
1. 拦截前端请求，从请求中获取到令牌，对令牌进行解析校验

那我们首先来完成：登录成功之后生成JWT令牌，并且把令牌返回给前端。

实现步骤：

引入JWT工具类：在项目工程下创建 com.itheima.util 包，并把提供JWT工具类复制到该包下

package com.itheima.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
import java.util.Map;

public class JwtUtils {

    private static final String SECRET_KEY = "aXRoZWltYQ=="; // 秘钥
    private static final long EXPIRATION_TIME = 12 * 60 * 60 * 1000; // 12小时

    /**
     * 生成JWT令牌
     * @param claims 令牌中包含的信息
     * @return 生成的JWT令牌字符串
     */
    public static String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .addClaims(claims)
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                .compact();
    }

    /**
     * 解析JWT令牌
     * @param token 要解析的JWT令牌字符串
     * @return 包含令牌信息的Claims对象
     * @throws Exception 如果令牌无效或已过期，则抛出异常
     */
    public static Claims parseToken(String token) throws Exception {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody();
    }
}

完善 EmpServiceImpl中的 login 方法逻辑，登录成功，生成JWT令牌并返回

@Override
public LoginInfo login(Emp emp) {
    Emp empLogin = empMapper.getUsernameAndPassword(emp);
    if(empLogin != null){
        //1. 生成JWT令牌
        Map<String,Object> dataMap = new HashMap<>();
        dataMap.put("id", empLogin.getId());
        dataMap.put("username", empLogin.getUsername());
        
        String jwt = JwtUtils.generateJwt(dataMap);
        LoginInfo loginInfo = new LoginInfo(empLogin.getId(), empLogin.getUsername(), empLogin.getName(), jwt);
        return loginInfo;
    }
    return null;
}

重启服务，打开 Apifox 测试登录接口：

在接口文档中有这么一个备注说明

备注说明：

用户登录成功后，系统会自动下发JWT令牌，然后在后续的每次请求中，都需要在请求头header中携带到服务端，请求头的名称为 token ，值为登录时下发的JWT令牌。如果检测到用户未登录，则直接响应 401 状态码。

打开浏览器完成前后端联调操作：利用开发者工具，抓取一下网络请求

登录请求完成后，可以看到JWT令牌已经响应给了前端，此时前端就会将JWT令牌存储在浏览器本地。

服务器响应的JWT令牌存储在本地浏览器哪里了呢？

在当前案例中，JWT令牌存储在浏览器的本地存储空间 localstorage中了。 localstorage 是浏览器的本地存储，在移动端也是支持的。

我们在发起一个查询部门数据的请求，此时我们可以看到在请求头中包含一个token(JWT令牌)，后续的每一次请求当中，都会将这个令牌携带到服务端。

过滤器Filter

Filter快速入门

什么是Filter？

Filter表示过滤器，是 JavaWeb三大组件(Servlet、Filter、Listener)之一。
过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能
- 使用了过滤器之后，要想访问web服务器上的资源，必须先经过滤器，过滤器处理完毕之后，才可以访问对应的资源。
过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等。

过滤器当中我们拦截到了请求之后，如果希望继续访问后面的web资源，就要执行放行操作，放行就是调用 FilterChain对象当中的doFilter()方法，在调用doFilter()这个方法之前所编写的代码属于放行之前的逻辑。

在放行后访问完 web 资源之后还会回到过滤器当中，回到过滤器之后如有需求还可以执行放行之后的逻辑，放行之后的逻辑我们写在doFilter()这行代码之后。

定义Filter：定义一个类，实现Filter接口，并实现其所有方法
配置Filter：Filter类上加@WebFilter注解，配置拦截路径。引导类上加@ServletComponentScan 开启Servlet组件支持

1). 定义过滤器

@WebFilter(urlPatterns = "/*")  // 拦截所有请求
@Slf4j
public class DemoFilter implements Filter {
	//初始化方法, web服务器启动, 创建Filter实例时调用, 只调用一次
    @Override 
    public void init(FilterConfig filterConfig) throws ServletException {
        log. info("init 初始化方法执行了");
    }

	//核心方法,拦截到请求之后调用, 每一次请求都会调用
    @Override   
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        log.info("拦截到了请求...");
        //放行请求
        filterChain.doFilter(servletRequest,servletResponse);

    }
	 //销毁方法, web容器销毁时调用,只调用一次
    @Override
    public void destroy() {
        log.info("销毁方法执行了");
    }
}

当我们在Filter类上面加了@WebFilter注解之后，接下来我们还需要在启动类上面加上一个注解@ServletComponentScan，通过这个@ServletComponentScan注解来开启SpringBoot项目对于Servlet组件的支持。

@ServletComponentScan
@SpringBootApplication
class TilasWebManagementApplicationTests {

    public static void main(String[] args) {
        SpringApplication.run(TilasWebManagementApplication.class, args);
    }
}

重新启动服务，打开浏览器，执行部门管理的请求，可以看到控制台输出了过滤器中的内容：

这是未加放行请求时的输出结果，加入了放行请求后就可以在控制台看到信息了

**注意事项：**在过滤器Filter中，如果不执行放行操作，将无法访问后面的资源。放行操作：chain.doFilter(request, response);

登录校验过滤器

分析

过滤器Filter的快速入门以及使用细节我们已经介绍完了，接下来最后一步，我们需要使用过滤器Filter来完成案例当中的登录校验功能。

我们先来回顾下前面分析过的登录校验的基本流程：

要进入到后台管理系统，我们必须先完成登录操作，此时就需要访问登录接口login。
登录成功之后，我们会在服务端生成一个JWT令牌，并且把JWT令牌返回给前端，前端会将JWT令牌存储下来。
在后续的每一次请求当中，都会将JWT令牌携带到服务端，请求到达服务端之后，要想去访问对应的业务功能，此时我们必须先要校验令牌的有效性。
对于校验令牌的这一块操作，我们使用登录校验的过滤器，在过滤器当中来校验令牌的有效性。如果令牌是无效的，就响应一个错误的信息，也不会再去放行访问对应的资源了。如果令牌存在，并且它是有效的，此时就会放行去访问对应的web资源，执行相应的业务操作。

大概清楚了在Filter过滤器的实现步骤了，那在正式开发登录校验过滤器之前，我们思考两个问题：

所有的请求，拦截到了之后，都需要校验令牌吗？
1. 答案：注册、登录请求例外（当前系统不支持注册功能）
拦截到请求后，什么情况下才可以放行，执行业务操作？
1. 答案：有令牌，且令牌校验通过(合法)；否则都返回未登录错误结果(401)

具体流程

我们要完成登录校验，主要是利用Filter过滤器实现，而Filter过滤器的流程步骤：

基于上面的业务流程，我们分析出具体的操作步骤：

获取请求url
判断请求url中是否包含login，如果包含，说明是登录操作，放行
获取请求头中的令牌（token）
判断令牌是否存在，如果不存在，响应 401
解析token，如果解析失败，响应 401
放行

代码实现

在 com.itheima.filter 包下创建TokenFilter，具体代码如下：

package com.itheima.filter;

import com.itheima.utils.JwtUtils;
import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpStatus;

import java.io.IOException;

/*
令牌校验过滤器
*/

@Slf4j
@WebFilter(urlPatterns = "/*")
public class TokenFilter implements Filter {

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain filterChain) throws IOException, ServletException {
        //获取请求和响应对象
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //1.获取到请求路径
        String url = request.getRequestURL().toString();
        //2.判断请求路径是否为登录路径，如果路径中包含了/login，说明是登录操作，放行
        if(url.contains("login")){ //登录请求
            log.info("登录请求 , 直接放行");
            filterChain.doFilter(request, response);
            return;
        }
        //3.获取请求头中的令牌（token）
        String token = request.getHeader("token");
        //4.判断令牌是否存在，如果存在，则通过，如果不存在，说明用户未登录，返回错误信息（响应401状态码）
        if(token == null || token.isEmpty()){ //jwt为空
            log.info("获取到token令牌为空, 返回401");
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return;
        }
        //5.如果令牌存在，则解析令牌，获取其中的用户名，如果校验失败 -> 返回错误信息（响应401状态码）
        try {
            JwtUtils.parseToken(token);
        } catch (Exception e) {
            e.printStackTrace();
            log.info("解析令牌失败, 返回401");
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
            return;
        }
        //6.校验通过，放行
        log.info("令牌合法, 放行");
        filterChain.doFilter(request , response);
    }
}

ps：此时可以将之前的DemoFilter中的@WebFilter(urlPatterns = "/*") 注释了，原因在本节结尾

登录校验的过滤器我们编写完成了，接下来我们就可以重新启动服务来做一个测试：

我们可以在步骤1处打个断点进行测试

测试1：进行登录操作

可以发现是登陆操作，此时再点击下一步即可返回对应的信息

测试2：未登录是否可以访问部门管理页面

首先关闭浏览器，重新打开浏览器，在地址栏中输入：http://localhost:90/dept

由于用户没有登录，登录校验过滤器返回错误信息，前端页面根据返回的错误信息结果，自动跳转到登录页面了

测试3：先进行登录操作，再访问部门管理页面

登录校验成功之后，可以正常访问相关业务操作页面

还可以进行其他的测试，比如随便找一个要登录以后才能使用的操作（如：员工性别统计），然后按照测试1步骤打断点进行测试，分别测试无token、token错误以及token正确的情况（该接口的token需要写到Headers中）。可以发现前两种情况都会返回401错误信息，只有当输入token且token正确的情况下才可以进入到相关页面

Filter详解

Filter过滤器的快速入门程序我们已经完成了，接下来我们就要详细的介绍一下过滤器Filter在使用中的一些细节。主要介绍以下3个方面的细节：

过滤器的执行流程
过滤器的拦截路径配置
过滤器链

执行流程

首先我们先来看下过滤器的执行流程：

@WebFilter(urlPatterns = "/*") 
public class DemoFilter implements Filter {
    
    @Override //初始化方法, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法执行了");
    }
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        
        System.out.println("DemoFilter   放行前逻辑.....");

        //放行请求
        filterChain.doFilter(servletRequest,servletResponse);

        System.out.println("DemoFilter   放行后逻辑.....");
        
    }

    @Override //销毁方法, 只调用一次
    public void destroy() {
        System.out.println("destroy 销毁方法执行了");
    }
}

启动之后运行测试：

也可以分别在放行前、放行请求、放行后以及LoginController中的log处打断点进行测试

了解了Filter的执行流程之后，我们来总结两个问题

问题1：放行后访问对应资源，资源访问完成后，还会回到Filter中吗？会
问题2：如果回到Filter中，是重新执行还是执行放行后的逻辑？执行放行后逻辑

拦截路径

执行流程我们搞清楚之后，接下来再来介绍一下过滤器的拦截路径，Filter可以根据需求，配置不同的拦截资源路径：

拦截路径	urlPatterns值	含义
拦截具体路径	/login	只有访问 /login 路径时，才会被拦截
目录拦截	/emps/*	访问/emps下的所有资源，都会被拦截
拦截所有	/*	访问所有资源，都会被拦截

下面我们来测试"拦截具体路径"：

@WebFilter(urlPatterns = "/login")  //拦截/login具体路径
public class DemoFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("DemoFilter   放行前逻辑.....");

        //放行请求
        filterChain.doFilter(servletRequest,servletResponse);

        System.out.println("DemoFilter   放行后逻辑.....");
    }


    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

执行完后在apifox中发送登录请求可以发现正常输出了放行前、放行请求和放行后的日志

此时再换成其他的接口（如：员工性别统计）进行测试，可以发现控制台并没有输出上述的三个日志

说明没有拦截此次请求，因为我们此次拦截的是登录请求

还可以测试/emps/*拦截，这里就不一一展示了，有兴趣的可以自行测试

过滤器链

最后我们在来介绍下过滤器链，什么是过滤器链呢？所谓过滤器链指的是在一个web应用程序当中，可以配置多个过滤器，多个过滤器就形成了一个过滤器链。

比如：在我们web服务器当中，定义了两个过滤器，这两个过滤器就形成了一个过滤器链。

而这个链上的过滤器在执行的时候会一个一个的执行，会先执行第一个Filter，放行之后再来执行第二个Filter，如果执行到了最后一个过滤器放行之后，才会访问对应的web资源。

访问完web资源之后，按照我们刚才所介绍的过滤器的执行流程，还会回到过滤器当中来执行过滤器放行后的逻辑，而在执行放行后的逻辑的时候，顺序是反着的。

先要执行过滤器2放行之后的逻辑，再来执行过滤器1放行之后的逻辑，最后在给浏览器响应数据。

过滤器链上过滤器的执行顺序：注解配置的Filter，优先级是按照过滤器类名（字符串）的自然排序。比如：

AbcFilter

DemoFilter

这两个过滤器来说，AbcFilter 会先执行，DemoFilter会后执行。

可以复制一份DemoFilter到AbcFilter中进行测试，可以发现AbcFilter是先于DemoFilter执行的

在测试完成后可以将这两个测试类的过滤器注释掉，然后将项目中的过滤器打开，因为过滤器链中的过滤器越多，执行性能越低

拦截器Interceptor

快速入门

什么是拦截器？

是一种动态拦截方法调用的机制，类似于过滤器。
拦截器是Spring框架中提供的，用来动态拦截控制器方法的执行。
拦截器的作用：拦截请求，在指定方法调用前后，根据业务需要执行预先设定的代码。

在拦截器当中，我们通常也是做一些通用性的操作，比如：我们可以通过拦截器来拦截前端发起的请求，将登录校验的逻辑全部编写在拦截器当中。在校验的过程当中，如发现用户登录了(携带JWT令牌且是合法令牌)，就可以直接放行，去访问spring当中的资源。如果校验时发现并没有登录或是非法令牌，就可以直接给前端响应未登录的错误信息。

下面我们通过快速入门程序，来学习下拦截器的基本使用。拦截器的使用步骤和过滤器类似，也分为两步：

定义拦截器，实现HandleInterceptor接口，并实现其所有方法
注册配置拦截器

1). 自定义拦截器

实现HandlerInterceptor接口，并重写其所有方法

@Slf4j
@Component  //自定义拦截器
public class DemoInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //目标资源方法执行前执行。 返回true：放行    返回false：不放行
        log.info("preHandle...");
        return true;
    }

    //目标资源方法执行后执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        log.info("postHandle...");
    }

    //视图渲染完毕后执行，最后执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        log.info("afterCompletion...");
    }
}

注意：

preHandle方法：目标资源方法执行前执行。返回true：放行返回false：不放行
postHandle方法：目标资源方法执行后执行
afterCompletion方法：视图渲染完毕后执行，最后执行

2). 注册配置拦截器

在 com.itheima下创建一个包，然后创建一个配置类 WebConfig，实现 WebMvcConfigurer 接口，并重写 addInterceptors 方法

@Configuration  
public class WebConfig implements WebMvcConfigurer {

    //自定义的拦截器对象
    @Autowired
    private DemoInterceptor demoInterceptor;

    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
       //注册自定义拦截器对象
        registry.addInterceptor(demoInterceptor).addPathPatterns("/**");//设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
    }
}

注意：使用拦截器时需要将过滤器全部注释掉~

重新启动SpringBoot服务，打开Apifox测试：

可以看到控制台输出的日志：

接下来我们再来做一个测试：将拦截器中返回值改为false

使用Apifox，再次点击send发送请求后，没有响应数据，说明请求被拦截了没有放行

令牌校验Interceptor

讲解完了拦截器的基本操作之后，接下来我们需要完成最后一步操作：通过拦截器来完成案例当中的登录校验功能。

登录校验的业务逻辑以及操作步骤我们前面已经分析过了，和登录校验Filter过滤器当中的逻辑是完全一致的。现在我们只需要把这个技术方案由原来的过滤器换成拦截器interceptor就可以了。

1). TokenInterceptor

在 com.itheima.interceptor 包下创建 TokenInterceptor

@Slf4j
@Component
public class TokenInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1. 获取请求url。
        String url = request.getRequestURL().toString();

        //2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行。
        if(url.contains("login")){ //登录请求
            log.info("登录请求 , 直接放行");
            return true;
        }

        //3. 获取请求头中的令牌（token）。
        String token = request.getHeader("token");

        //4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）。
        if(!StringUtils.hasLength(token)){ //token为空
            log.info("获取到token令牌为空, 返回错误结果");
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
            return false;
        }

        //5. 解析token，如果解析失败，返回错误结果（未登录）。
        try {
            JwtUtils.parseToken(token);
        } catch (Exception e) {
            e.printStackTrace();
            log.info("解析令牌失败, 返回错误结果");
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
            return false;
        }

        //6. 放行。
        log.info("令牌合法, 放行");
        return true;
    }

}

2). 配置拦截器

@Configuration  
public class WebConfig implements WebMvcConfigurer {
    //拦截器对象
    @Autowired
    private TokenInterceptor tokenInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
       //注册自定义拦截器对象
        registry.addInterceptor(tokenInterceptor).addPathPatterns("/**");
    }
}

登录校验的拦截器编写完成后，接下来我们就可以重新启动服务来做一个测试：（关闭登录校验Filter过滤器）

测试1：未登录是否可以访问部门管理页面

首先关闭浏览器，重新打开浏览器，在地址栏中输入：http://localhost:90/dept

由于用户没有登录，校验机制返回错误信息，前端页面根据返回的错误信息结果，自动跳转到登录页面了

测试2：先进行登录操作，再访问部门管理页面

登录校验成功之后，可以正常访问相关业务操作页面

到此我们也就验证了所开发的登录校验的拦截器也是没问题的。登录校验的过滤器和拦截器，我们只需要使用其中的一种就可以了

如果想要在apifox中直接测试其他接口未登录访问，可以先使用登录接口进行测试获取到token令牌，再将token令牌复制到其他接口中进行测试（先将Headers中的token置为空，然后输入错误，最后输入正确token），测试过程中可以分别在TokenInterceptor的步骤中打断点进行观察。

Interceptor详解

拦截器的入门程序完成之后，接下来我们来介绍拦截器的使用细节。拦截器的使用细节我们主要介绍两个部分：

拦截器的拦截路径配置
拦截器的执行流程

拦截路径

首先我们先来看拦截器的拦截路径的配置，在注册配置拦截器的时候，我们要指定拦截器的拦截路径，通过addPathPatterns("要拦截路径")方法，就可以指定要拦截哪些资源。

在入门程序中我们配置的是/**，表示拦截所有资源，而在配置拦截器时，不仅可以指定要拦截哪些资源，还可以指定不拦截哪些资源，只需要调用excludePathPatterns("不拦截路径")方法，指定哪些资源不需要拦截。

/*
* 拦截器配置类
* */
@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private TokenInterceptor tokenInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //注册自定义拦截器对象
        registry.addInterceptor(tokenInterceptor)
                .addPathPatterns("/**")//设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
                .excludePathPatterns("/login");//设置不拦截的请求路径
    }
}

在拦截器中除了可以设置/**拦截所有资源外，还有一些常见拦截路径设置：

拦截路径	含义	举例
/*	一级路径	能匹配/depts，/emps，/login，不能匹配 /depts/1
/**	任意级路径	能匹配/depts，/depts/1，/depts/1/2
/depts/*	/depts下的一级路径	能匹配/depts/1，不能匹配/depts/1/2，/depts
/depts/**	/depts下的任意级路径	能匹配/depts，/depts/1，/depts/1/2，不能匹配/emps/1

执行流程

介绍完拦截路径的配置之后，接下来我们再来介绍拦截器的执行流程。通过执行流程，大家就能够清晰的知道过滤器与拦截器的执行时机。

当我们打开浏览器来访问部署在web服务器当中的web应用时，此时我们所定义的过滤器会拦截到这次请求。拦截到这次请求之后，它会先执行放行前的逻辑，然后再执行放行操作。而由于我们当前是基于springboot开发的，所以放行之后是进入到了spring的环境当中，也就是要来访问我们所定义的controller当中的接口方法。
Tomcat并不识别所编写的Controller程序，但是它识别Servlet程序，所以在Spring的Web环境中提供了一个非常核心的Servlet：DispatcherServlet（前端控制器），所有请求都会先进行到DispatcherServlet，再将请求转给Controller。
当我们定义了拦截器后，会在执行Controller的方法之前，请求被拦截器拦截住。执行preHandle()方法，这个方法执行完成后需要返回一个布尔类型的值，如果返回true，就表示放行本次操作，才会继续访问controller中的方法；如果返回false，则不会放行（controller中的方法也不会执行）。
在controller当中的方法执行完毕之后，再回过来执行postHandle()这个方法以及afterCompletion() 方法，然后再返回给DispatcherServlet，最终再来执行过滤器当中放行后的这一部分逻辑的逻辑。执行完毕之后，最终给浏览器响应数据。

以上就是拦截器的执行流程。通过执行流程分析，大家应该已经清楚了过滤器和拦截器之间的区别，其实它们之间的区别主要是两点：

接口规范不同：过滤器需要实现Filter接口，而拦截器需要实现HandlerInterceptor接口。
拦截范围不同：过滤器Filter会拦截所有的资源，而Interceptor只会拦截Spring环境中的资源。

将DemoInterceptor中的preHandle设置为false，

通过同时打开DemoFilter和DemoInterceptor来进行测试：

可以发现DemoFilter已经放行了，但是由于DemoInterceptor中的preHandle设置为false，所以并没有放行拦截到了请求

现在将preHandles设置为true，可以在apifox中查询到了，而此时的拦截顺序就是DemoFilter先执行，但是放行顺序是反过来的

注意：在学完这部分内容后记得关掉多余的拦截器或过滤器，只需要其中生效一个就可以了，我这里开的是TokenFilter过滤器

【小tips】在本次学习过程中，我发现我没有登录直接访问http://localhost:90是能够直接进入到前端页面中的，但是进入到的是http://localhost:90/index页面，而这个页面似乎并没有接口来实现它（由于我没有学习前端课程，不知道前端页面的代码是怎样的），我在前面课程一键导入的apifox接口中没有发现index页面，我不确定是不是因为index页面不属于这个系统中的页面所以才能直接访问，而当我在这个页面中直接点击其他接口的页面就会直接跳转到登录页面并提示错误信息，这时候就会被/**给拦截了。

Web后端实战（5）

Fri, 15 May 2026 14:34:35 +0800

Tlias智能学习辅助系统

数据准备

在数据库中，创建学生表 clazz , student，SQL如下：

create table clazz(
    id   int unsigned primary key auto_increment comment 'ID,主键',
    name  varchar(30) not null unique  comment '班级名称',
    room  varchar(20) comment '班级教室',
    begin_date date not null comment '开课时间',
    end_date date not null comment '结课时间',
    master_id int unsigned null comment '班主任ID, 关联员工表ID',
    subject tinyint unsigned not null comment '学科, 1:java, 2:前端, 3:大数据, 4:Python, 5:Go, 6: 嵌入式',
    create_time datetime  comment '创建时间',
    update_time datetime  comment '修改时间'
)comment '班级表';

INSERT INTO clazz VALUES (1,'JavaEE就业163期','212','2024-04-30','2024-06-29',10,1,'2024-06-01 17:08:23','2024-06-01 17:39:58'),
    (2,'前端就业90期','210','2024-07-10','2024-01-20',3,2,'2024-06-01 17:45:12','2024-06-01 17:45:12'),
    (3,'JavaEE就业165期','108','2024-06-15','2024-12-25',6,1,'2024-06-01 17:45:40','2024-06-01 17:45:40'),
    (4,'JavaEE就业166期','105','2024-07-20','2024-02-20',20,1,'2024-06-01 17:46:10','2024-06-01 17:46:10'),
    (5,'大数据就业58期','209','2024-08-01','2024-02-15',7,3,'2024-06-01 17:51:21','2024-06-01 17:51:21'),
    (6,'JavaEE就业167期','325','2024-11-20','2024-05-10',36,1,'2024-11-15 11:35:46','2024-12-13 14:31:24');


create table student(
  id int unsigned primary key auto_increment comment 'ID,主键',
  name varchar(10)  not null comment '姓名',
  no char(10)  not null unique comment '学号',
  gender tinyint unsigned  not null comment '性别, 1: 男, 2: 女',
  phone  varchar(11)  not null unique comment '手机号',
  id_card  char(18)  not null unique comment '身份证号',
  is_college tinyint unsigned  not null comment '是否来自于院校, 1:是, 0:否',
  address  varchar(100)  comment '联系地址',
  degree  tinyint unsigned  comment '最高学历, 1:初中, 2:高中, 3:大专, 4:本科, 5:硕士, 6:博士',
  graduation_date date comment '毕业时间',
  clazz_id  int unsigned not null comment '班级ID, 关联班级表ID',
  violation_count tinyint unsigned default '0' not null comment '违纪次数',
  violation_score tinyint unsigned default '0' not null comment '违纪扣分',
  create_time  datetime  comment '创建时间',
  update_time  datetime  comment '修改时间'
) comment '学员表';


INSERT INTO student VALUES (1,'段誉','2022000001',1,'18800000001','110120000300200001',1,'北京市昌平区建材城西路1号',1,'2021-07-01',2,0,0,'2024-11-14 21:22:19','2024-11-15 16:20:59'),
    (2,'萧峰','2022000002',1,'18800210003','110120000300200002',1,'北京市昌平区建材城西路2号',2,'2022-07-01',1,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (3,'虚竹','2022000003',1,'18800013001','110120000300200003',1,'北京市昌平区建材城西路3号',2,'2024-07-01',1,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (4,'萧远山','2022000004',1,'18800003211','110120000300200004',1,'北京市昌平区建材城西路4号',3,'2024-07-01',1,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (5,'阿朱','2022000005',2,'18800160002','110120000300200005',1,'北京市昌平区建材城西路5号',4,'2020-07-01',1,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (6,'阿紫','2022000006',2,'18800000034','110120000300200006',1,'北京市昌平区建材城西路6号',4,'2021-07-01',2,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (7,'游坦之','2022000007',1,'18800000067','110120000300200007',1,'北京市昌平区建材城西路7号',4,'2022-07-01',2,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (8,'康敏','2022000008',2,'18800000077','110120000300200008',1,'北京市昌平区建材城西路8号',5,'2024-07-01',2,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (9,'徐长老','2022000009',1,'18800000341','110120000300200009',1,'北京市昌平区建材城西路9号',3,'2024-07-01',2,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (10,'云中鹤','2022000010',1,'18800006571','110120000300200010',1,'北京市昌平区建材城西路10号',2,'2020-07-01',2,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (11,'钟万仇','2022000011',1,'18800000391','110120000300200011',1,'北京市昌平区建材城西路11号',4,'2021-07-01',1,0,0,'2024-11-14 21:22:19','2024-11-15 16:21:24'),
    (12,'崔百泉','2022000012',1,'18800000781','110120000300200018',1,'北京市昌平区建材城西路12号',4,'2022-07-05',3,6,17,'2024-11-14 21:22:19','2024-12-13 14:33:58'),
    (13,'耶律洪基','2022000013',1,'18800008901','110120000300200013',1,'北京市昌平区建材城西路13号',4,'2024-07-01',2,0,0,'2024-11-14 21:22:19','2024-11-15 16:21:21'),
    (14,'天山童姥','2022000014',2,'18800009201','110120000300200014',1,'北京市昌平区建材城西路14号',4,'2024-07-01',1,0,0,'2024-11-14 21:22:19','2024-11-15 16:21:17'),
    (15,'刘竹庄','2022000015',1,'18800009401','110120000300200015',1,'北京市昌平区建材城西路15号',3,'2020-07-01',4,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (16,'李春来','2022000016',1,'18800008501','110120000300200016',1,'北京市昌平区建材城西路16号',4,'2021-07-01',4,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (17,'王语嫣','2022000017',2,'18800007601','110120000300200017',1,'北京市昌平区建材城西路17号',2,'2022-07-01',4,0,0,'2024-11-14 21:22:19','2024-11-14 21:22:19'),
    (18,'郑成功','2024001101',1,'13309092345','110110110110110110',0,'北京市昌平区回龙观街道88号',5,'2021-07-01',3,2,7,'2024-11-15 16:26:18','2024-11-15 16:40:10');

表结构关系说明：

实体类Clazz：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Clazz {
    private Integer id; //ID
    private String name; //班级名称
    private String room; //班级教室
    private LocalDate beginDate; //开课时间
    private LocalDate endDate; //结课时间
    private Integer masterId; //班主任
    private Integer subject; //学科
    private LocalDateTime createTime; //创建时间
    private LocalDateTime updateTime; //修改时间

    private String masterName; //班主任姓名
    private String status; //班级状态 - 未开班 , 在读 , 已结课
}

实体类Student：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private Integer id; //ID
    private String name; //姓名
    private String no; //序号
    private Integer gender; //性别 , 1: 男 , 2 : 女
    private String phone; //手机号
    private String idCard; //身份证号
    private Integer isCollege; //是否来自于院校, 1: 是, 0: 否
    private String address; //联系地址
    private Integer degree; //最高学历, 1: 初中, 2: 高中 , 3: 大专 , 4: 本科 , 5: 硕士 , 6: 博士
    private LocalDate graduationDate; //毕业时间
    private Integer clazzId; //班级ID
    private Short violationCount; //违纪次数
    private Short violationScore; //违纪扣分
    private LocalDateTime createTime; //创建时间
    private LocalDateTime updateTime; //修改时间

    private String clazzName;//班级名称
}

需求：班级管理

需要开发如下几个接口，且开发的时候建议按照如下顺序开发：

条件分页查询接口

地址：接口文档 - 飞书云文档

参照接口文档 班级管理 -> 班级列表查询

注意：班级状态，显示为：未开班、已结课、在读中 这三种。

如果：

当前时间 > 结课时间：状态未 已结课。
当前时间 < 开课时间：状态未 未开班。
否则，就是 在读中。

1).准备Clazz表对应的基础结构，包括Controller、Server、Mapper：

ClazzController：

@Slf4j
@RestController
@RequestMapping("/clazzs")
public class ClazzController {

    @Autowired
    private ClazzService clazzService;

    /**
     * 查询所有班级数据
     */
        @GetMapping
        public Result page(@RequestParam(defaultValue = "1") Integer page ,
                           @RequestParam(defaultValue = "10") Integer pageSize,
                           String name,
                           @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,
                           @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end) {

            log.info("分页查询：{}，{}，{}，{}，{}",name,begin,end,page,pageSize);
            return Result.success(clazzService.page(page,pageSize,name,begin,end));


    }

}

ClazzService：

@Service
public interface ClazzService {
    /*
     * 查询所有班级
     * */
     PageResult<Clazz> page(Integer page, Integer pageSize, String name, LocalDate begin,LocalDate end);


}

ClazzServiceImpl：

@Service
public class ClazzServiceImpl implements ClazzService {

    @Autowired
    private ClazzMapper ClazzMapper;


    public PageResult<Clazz> page(Integer page, Integer pageSize, String name, LocalDate begin, LocalDate end) {
        PageHelper.startPage(page,pageSize);
        List<Clazz> clazzList = ClazzMapper.list(name,begin,end);
        Page<Clazz> p = (Page<Clazz>) clazzList;
        return new PageResult<>(p.getTotal(),p.getResult());
    }
}

ClazzMapper：

@Mapper
public interface ClazzMapper {

    /*
    * 查询所有班级
    * */
    @Select("select * from clazz;")
    List<Clazz> findall();

    List<Clazz> list(String name, LocalDate begin, LocalDate end);
}

将对应的查询语句写在映射文件中

ClazzMapper.xml：

<select id="page" resultType="com.itheima.pojo.Clazz">
        SELECT
        c.id,
        c.name,
        c.room,
        c.begin_date,
        c.end_date,
        c.create_time,
        c.update_time,
        -- 重点：从 emp 表中获取 name，并起别名为 masterName
        e.name AS masterName,
        -- 之前的状态计算逻辑也可以保留在这里
        CASE
            WHEN CURDATE() &gt; c.end_date THEN '已结课'
            WHEN CURDATE() &lt; c.begin_date THEN '未开班'
            ELSE '在读中'
        END AS status
        FROM
        clazz c
        LEFT JOIN
        emp e ON c.master_id = e.id
    </select>

XML 常用的转义字符：

<：<

>：：>

&：：&

&quote;："

'：'

功能测试

前后端联调测试

（此处页面展示不同是因为前面代码写错了，没有将班主任和状态展示出来，这是修改以后的图，下面几张是修改前的图）

查询所有员工接口

那其实，对于培训机构来说，班主任就是这个企业的员工。所以，班主任下拉列表中展示的就是所有的员工数据。

地址：接口文档 - 飞书云文档

参照接口文档 员工管理 -> 查询全部员工

EmpController：

/**
 * 查询所有员工
 */
@GetMapping("/list")
public Result list() {
    // 调用业务逻辑层（Service）的 findall 方法，获取部门列表数据
    List<Emp> empList = empService.findAll();
    // 将查询到的 deptList 封装在 Result 对象中返回，通常包含状态码、消息和数据。
    return Result.success(empList);
}

EmpService：

`1`	`List<Emp> findAll();`

EmpServiceImpl：

@Override
public List<Emp> findAll() {
    return empMapper.findAll();
}

EmpMapper：

1
2

//查询所有员工
List<Emp> findAll();

EmpMapper.xml：

1
2
3

<select id="findAll" resultType="com.itheima.pojo.Emp">
    select * from emp;
</select>

功能测试

前后端联调测试

新增班级信息接口

参照接口文档 班级管理 -> 添加班级

功能测试

前后端联调测试

根据ID查询班级接口

参照接口文档 班级管理 -> 根据ID查询

ClazzController：

/**
 * 查询回显
 */
@GetMapping("/{id}")
public Result getInfo(@PathVariable Integer id){
    log.info("根据id查询员工的详细信息");
    Clazz clazz  = clazzService.getInfo(id);
    return Result.success(clazz);
}

ClazzService：

/*
 * 根据ID查询班级信息
 * */
Clazz getInfo(Integer id);

ClazzServiceImpl：

@Override
public Clazz getInfo(Integer id) {
    return clazzMapper.getById(id);
}

ClazzMapper：

/*
* 根据ID查询班级信息
* */
Clazz getById(Integer id);

ClazzMapper.xml：

1
2
3

<select id="getById" resultType="com.itheima.pojo.Clazz">
    select * from clazz where id = #{id}
</select>

功能测试

前后端联调测试

选择与我们刚刚查询id相同的班级信息，点击编辑，发现班级的信息都展示出来了

修改班级信息接口

参照接口文档 班级管理 -> 修改班级

ClazzController：

/**
 * 更新班级信息
 */
@PutMapping
public Result update(@RequestBody Clazz clazz){
    log.info("修改部门信息, {}", clazz);
    clazzService.update(clazz);
    return Result.success();
}

ClazzService：

/*
* 修改班级信息
* */
void update(Clazz clazz);

ClazzServiceImpl：

@Override
public void update(Clazz clazz) {
    //补全基础属性 - updateTime
    clazz.setUpdateTime(LocalDateTime.now());
    //调用Mapper接口方法更新班级
    clazzMapper.update(clazz);
}

ClazzMapper：

/*
* 修改班级信息
* */
@Update("update clazz set name=#{name},room=#{room},begin_date=#{beginDate},end_date=#{endDate},master_id=#{masterId},subject=#{subject}" +
        " where id = #{id}")
void update(Clazz clazz);

功能测试

前后端联调测试

修改前：

修改后：

删除班级信息接口

参照接口文档 班级管理 -> 删除班级

ClazzController：

/**
 * 删除班级 - List
 */
@DeleteMapping("/{id}")
public Result delete(@PathVariable Integer id){
    log.info("删除班级: id={} ", id);
    clazzService.delete(id);
    return Result.success("删除成功");
}

ClazzService：

/*
* 删除班级
* */
void delete(Integer id);

ClazzServiceImpl：

@Transactional(rollbackFor = {Exception.class})
@Override
public void delete(Integer id) {
    //1. 检查班级下是否有学生
    int count = clazzMapper.countStudentsByClazzId(id);
    if (count > 0) {
        throw new ClassHasStudentsException();
    }

    //2. 根据ID批量删除班级基本信息
    clazzMapper.deleteById(id);
}

ClazzMapper：

/*
* 删除班级
* */
void deleteById(@Param("id") Integer id);

/*
* 根据班级ID统计学生数量
* */
int countStudentsByClazzId(@Param("clazzId") Integer clazzId);

ClazzMapper.xml：

1
2
3

<delete id="deleteById">
    DELETE FROM clazz WHERE id = #{id}
</delete>

自定义异常处理器：ClassHasStudentsException

package com.itheima.exception;

/**
 * 班级下有学生时抛出的异常
 */
public class ClassHasStudentsException extends RuntimeException {

    public ClassHasStudentsException() {
        super("对不起，该班级下有学生，不能直接删除");
    }

    public ClassHasStudentsException(String message) {
        super(message);
    }
}

全局异常处理器：GlobalExceptionHandler

/*
* 全局异常处理器
* */
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    //处理异常
    @ExceptionHandler
    public Result ex(Exception e){//方法形参中指定能够处理的异常类型
        log.error("程序出错啦~",e);
        //e.printStackTrace();//打印堆栈中的异常信息
        //捕获到异常之后，响应一个标准的Result
        return Result.error("对不起,操作失败,请联系管理员");
    }

    @ExceptionHandler
    //如果是DuplicateKeyException，那么这个处理器就会生效，如果是别的上面的就会生效
    public Result handleDuplicateKeyException(DuplicateKeyException e){
        log.error("程序出错啦~",e);
        // 获取异常的具体描述信息，通常包含 "Duplicate entry 'xxx' for key 'xxx'"
        String message = e.getMessage();
        // 定位 "Duplicate entry" 关键字的位置，作为截取错误信息的起点
        int i = message.indexOf("Duplicate entry");
        // 从关键字位置开始截取字符串，获取包含具体重复值的片段
        String errMsg = message.substring(i);
        // 按照空格将截取的字符串分割成数组
        String[] arr = errMsg.split(" ");
        // 数组下标为2的元素通常是具体的重复值（如 'admin'），拼接提示语后返回
        // 注意：这里假设了异常信息的格式是固定的，且重复值在数组的第三个位置
        return Result.error(arr[2] + "已存在");
    }

    @ExceptionHandler
    public Result handleClassHasStudentsException(ClassHasStudentsException e){
        return Result.error(e.getMessage());
    }
}

功能测试

前后端联调测试

删除无学生班级：

删除有学生班级：

需求：学员管理

由于该部分为学习了后面知识后回来补充的，而后面有些功能会影响到这个部分的测试（如测试时无Token令牌会导致报错，测试起来比较麻烦），所以该部分就不进行前后端联调测试了，仅为完成功能实现

需要开发如下几个接口，建议按照如下顺序开发接口：

查询所有班级接口

地址：接口文档 - 飞书云文档

参照接口文档 班级管理 -> 查询所有班级

在新增学员的时候，要展示出所有的班级信息。

ClazzController：新增 @GetMapping("/list") 端点，返回所有班级

/**
 * 查询所有班级数据
 */
@GetMapping("/list")
public Result list() {
    log.info("查询所有班级数据");
    List<Clazz> clazzList = clazzService.findAll();
    return Result.success(clazzList);
}

ClazzService：新增 List findAll() 接口方法

/*
 * 查询所有班级
 * */
List<Clazz> findAll();

ClazzServiceImpl：

@Override
public List<Clazz> findAll() {
    return clazzMapper.findall();
}

由于ClazzMapper.findall() 已经存在（@Select(“select * from clazz;")），所以 Mapper 层无需改动。

条件分页查询接口

接口描述：

在pojo层创建StudentQueryParam.java ：

package com.itheima.pojo;

import lombok.Data;

@Data
public class StudentQueryParam {
    private Integer page = 1; //页码
    private Integer pageSize = 10; //每页展示记录数
    private String name; //姓名
    private Integer degree; //最高学历
    private Integer clazzId; //班级ID
}

在mapper层创建StudentMapper.java

package com.itheima.mapper;

import com.itheima.pojo.Student;
import com.itheima.pojo.StudentQueryParam;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface StudentMapper {

    /*
    * 条件分页查询学员列表
    * */
    List<Student> list(StudentQueryParam studentQueryParam);
}

在resource目录下的mapper层创建StudentMapper.xml ，基于动态SQL，通过left join clazz 表获取班级名称

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.mapper.StudentMapper">

    <select id="list" resultType="com.itheima.pojo.Student">
        select s.*, c.name clazzName
        from student s left join clazz c on s.clazz_id = c.id
        <where>
            <if test="name != null and name != ''">
                s.name like concat('%',#{name},'%')
            </if>
            <if test="degree != null">
                and s.degree = #{degree}
            </if>
            <if test="clazzId != null">
                and s.clazz_id = #{clazzId}
            </if>
        </where>
    </select>

</mapper>

在service层创建StudentService.java ：

package com.itheima.service;

import com.itheima.pojo.PageResult;
import com.itheima.pojo.Student;
import com.itheima.pojo.StudentQueryParam;

public interface StudentService {

    /*
    * 学员分页查询
    * */
    PageResult<Student> page(StudentQueryParam studentQueryParam);
}

在service层创建StudentServiceImpl.java ：

package com.itheima.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.itheima.mapper.StudentMapper;
import com.itheima.pojo.PageResult;
import com.itheima.pojo.Student;
import com.itheima.pojo.StudentQueryParam;
import com.itheima.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Override
    public PageResult<Student> page(StudentQueryParam studentQueryParam) {
        //1. 设置分页参数
        PageHelper.startPage(studentQueryParam.getPage(), studentQueryParam.getPageSize());
        //2. 执行查询
        List<Student> studentList = studentMapper.list(studentQueryParam);
        //3. 封装分页结果
        Page<Student> p = (Page<Student>) studentList;
        return new PageResult<>(p.getTotal(), p.getResult());
    }
}

在controller层创建StudentController.java

package com.itheima.controller;

import com.itheima.pojo.PageResult;
import com.itheima.pojo.Result;
import com.itheima.pojo.Student;
import com.itheima.pojo.StudentQueryParam;
import com.itheima.service.StudentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 学员管理
 */
@Slf4j
@RequestMapping("/students")
@RestController
public class StudentController {

    @Autowired
    private StudentService studentService;

    /*
    * 条件分页查询学员列表
    * */
    @GetMapping
    public Result page(StudentQueryParam studentQueryParam) {
        log.info("学员查询请求参数：{}", studentQueryParam);
        PageResult<Student> pageResult = studentService.page(studentQueryParam);
        return Result.success(pageResult);
    }
}

新增学生信息接口

接口文档：

StudentController：

/*
* 新增学员
* */
@PostMapping
public Result save(@RequestBody Student student) {
    log.info("新增学员: {}", student);
    studentService.save(student);
    return Result.success();
}

StudentService：

/*
* 新增学员
* */
void save(Student student);

StudentServiceImpl：

@Override
public void save(Student student) {
    //补全基础属性
    student.setCreateTime(LocalDateTime.now());
    student.setUpdateTime(LocalDateTime.now());
    //调用Mapper接口方法插入数据
    studentMapper.insert(student);
}

StudentMapper：

*
* 新增学员
* */
@Options(useGeneratedKeys = true, keyProperty = "id")
@Insert("insert into student(name, no, gender, phone, id_card, is_college, address, degree, graduation_date, clazz_id, create_time, update_time) " +
        "values(#{name}, #{no}, #{gender}, #{phone}, #{idCard}, #{isCollege}, #{address}, #{degree}, #{graduationDate}, #{clazzId}, #{createTime}, #{updateTime})")
void insert(Student student);

根据ID查询学生接口

接口文档：

StudentController：

/*
* 根据ID查询学员
* */
@GetMapping("/{id}")
public Result getInfo(@PathVariable Integer id) {
    log.info("根据id查询学员信息: {}", id);
    Student student = studentService.getInfo(id);
    return Result.success(student);
}

StudentService：

/*
* 根据ID查询学员
* */
Student getInfo(Integer id);

StudentServiceImpl：

@Override
public Student getInfo(Integer id) {
    return studentMapper.getById(id);
}

StudentMapper.java：

/*
* 根据ID查询学员
* */
Student getById(Integer id);

StudentMapper.xml：

<select id="getById" resultType="com.itheima.pojo.Student">
    select s.*, c.name clazzName
    from student s left join clazz c on s.clazz_id = c.id
    where s.id = #{id}
</select>

修改学生信息接口

接口文档：

StudentController：

/*
* 修改学员
* */
@PutMapping
public Result update(@RequestBody Student student) {
    log.info("修改学员信息: {}", student);
    studentService.update(student);
    return Result.success();
}

StudentService：

/*
* 修改学员
* */
void update(Student student);

StudentServiceImpl：

@Override
public void update(Student student) {
    //补全基础属性
    student.setUpdateTime(LocalDateTime.now());
    //调用Mapper接口方法更新数据
    studentMapper.update(student);
}

StudentMapper：

/*
* 修改学员
* */
@Update("update student set name=#{name}, no=#{no}, gender=#{gender}, phone=#{phone}, id_card=#{idCard}, is_college=#{isCollege}, " +
        "address=#{address}, degree=#{degree}, graduation_date=#{graduationDate}, clazz_id=#{clazzId}, update_time=#{updateTime} where id = #{id}")
void update(Student student);

修改前：

修改后：

删除学生信息接口

接口文档：

StudentController：

/*
* 删除学员
* */
@DeleteMapping("/{ids}")
public Result delete(@PathVariable Integer ids) {
    log.info("删除学员: id={}", ids);
    studentService.delete(ids);
    return Result.success();
}

StudentService：

*
* 删除学员
* */
void delete(Integer id);

StudentServiceImpl：

@Override
public void delete(Integer id) {
    studentMapper.deleteById(id);
}

StudentMapper：

*
* 删除学员
* */
@Delete("delete from student where id = #{id}")
void deleteById(Integer id);

删除前：

删除后：

违纪处理接口

接口文档：

违纪处理一次，需要将违纪次数+1，违纪扣分+前端输入的分数。

StudentController：

/*
* 违纪处理
* */
@PutMapping("/violation/{id}/{score}")
public Result violation(@PathVariable Integer id, @PathVariable Integer score) {
    log.info("违纪处理: id={}, score={}", id, score);
    studentService.violation(id, score);
    return Result.success();
}

StudentService：

*
* 违纪处理
* */
void violation(Integer id, Integer score);

StudentServiceImpl：

@Override
public void violation(Integer id, Integer score) {
    studentMapper.updateViolation(id, score, LocalDateTime.now());
}

StudentMapper：

/*
* 违纪处理
* */
@Update("update student set violation_count = violation_count + 1, violation_score = violation_score + #{score}, update_time = #{updateTime} where id = #{id}")
void updateViolation(@Param("id") Integer id, @Param("score") Integer score, @Param("updateTime") LocalDateTime updateTime);

再添加一次违纪记录，分值为1分

到此，关于学生管理的增删改查功能，我们就已经全部实现了。

需求：学员信息统计

需要开发如下几个接口：

班级人数统计接口开发：参照接口文档 数据统计 -> 班级人数统计
学员学历信息统计接口开发：参照接口文档 数据统计 -> 学员学历统计

班级人数统计接口：

ClazzOption：

package com.itheima.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ClazzOption {
    private List clazzList; // 班级列表
    private List dataList;  // 数据列表
}

ReportController：

 /**
     * 统计班级人数
     */
    @GetMapping("/studentCountData")
    public Result getStudentCountData(){
        log.info("统计班级人数");
        ClazzOption clazzOption = reportService.getStudentCountData();
        return Result.success(clazzOption);
    }

ReportService：

/*
* 统计班级人数
* */
List<Map> getStudentCountData();

ReportServiceImpl：

@Override
    public ClazzOption getStudentCountData() {
        //1.调用mapper接口，获取统计数据
        List<Map> list = studentMapper.countStudentByClazz(); // map：name 班级名称，value = 班级人数
        //2.组装结果并返回
        List<Object> clazzList = list.stream().map(dataMap -> dataMap.get("name")).toList();
        List<Object> dataList = list.stream().map(dataMap -> dataMap.get("value")).toList();
        return new ClazzOption(clazzList, dataList);
    }

StudentMapper.java：

/*
* 统计班级人数
* */
List<Map> countStudentByClazz();

StudentMapper.xml：

   <select id="countStudentByClazz" resultType="java.util.Map">
        select c.name as name, count(s.id) as value
        from clazz c left join student s on c.id = s.clazz_id
        group by c.id, c.name
    </select>

结果与学历统计一起放在下面了

学员学历信息统计接口：

ReportController：

/**
 * 统计学历分布
 */
@GetMapping("/studentDegreeData")
public Result getStudentDegreeData(){
    log.info("统计学历分布");
    List<Map> degreeList = reportService.getStudentDegreeData();
    return Result.success(degreeList);
}

ReportService：

/*
* 统计学历分布
* */
List<Map> getStudentDegreeData();

ReportServiceImpl：

@Override
public List<Map> getStudentDegreeData() {
    return studentMapper.countStudentByDegree();
}

StudentMapper.java：

/*
* 统计学历分布
* */
List<Map> countStudentByDegree();

StudentMapper.xml：

<select id="countStudentByDegree" resultType="java.util.Map">
    select
        case when degree = 1 then '初中'
             when degree = 2 then '高中'
             when degree = 3 then '大专'
             when degree = 4 then '本科'
             when degree = 5 then '硕士'
             when degree = 6 then '博士'
        end as name,
        count(*) as value
    from student group by degree order by degree
</select>

需求：功能完善

删除部门时：如果部门下有员工，则不允许删除该部门，并给前端提示错误信息：对不起，当前部门下有员工，不能直接删除！

DeptHasEmployeesException.java：新建，RuntimeException，提示消息：“对不起，当前部门下有员工，不能直接删除！”

package com.itheima.exception;

/**
 * 部门下有员工时抛出的异常
 */
public class DeptHasEmployeesException extends RuntimeException {

    public DeptHasEmployeesException() {
        super("对不起，当前部门下有员工，不能直接删除！");
    }

    public DeptHasEmployeesException(String message) {
        super(message);
    }
}

GlobalExceptionHandler.java：新增 handleDeptHasEmployeesException() 处理器

package com.itheima.exception;

/**
 * 班级下有学生时抛出的异常
 */
public class ClassHasStudentsException extends RuntimeException {

    public ClassHasStudentsException() {
        super("对不起，该班级下有学生，不能直接删除");
    }

    public ClassHasStudentsException(String message) {
        super(message);
    }
}

DeptMapper.java：新增 countEmployeesByDeptId(Integer deptId)

/*
* 根据部门ID统计员工数量
* */
@Select("select count(*) from emp where dept_id = #{deptId}")
int countEmployeesByDeptId(Integer deptId);

/*
*删除部门
* */
@Delete("delete from dept where id = #{id}")
void deleteById(Integer id);

DeptServiceImpl.java：deleteById() 中新增检查逻辑

@Override
public void deleteById(Integer id) {
    //1. 检查部门下是否有员工
    int count = deptMapper.countEmployeesByDeptId(id);
    if (count > 0) {
        throw new DeptHasEmployeesException();
    }
    //2. 根据ID删除部门
    deptMapper.deleteById(id);
}

凉介的笔记

RAG项目案例

RAG项目案例

RAG回顾

项目需求和思路

离线流程

知识库服务

在线流程

历史会话记录功能

聊天页面开发

Python基础语法

一、Python 环境与程序运行

二、变量与数据类型

三、运算符

四、流程控制语句

五、字符串操作

六、列表操作

七、字典操作

八、函数

九、模块与包

十、异常处理

十一、文件操作

Python 高级语法（纯文本格式，可直接复制保存为TXT）

十二、面向对象编程（OOP）

类属性：属于类本身，所有实例共享

初始化方法：创建对象时自动调用，用于初始化对象属性

实例方法：第一个参数必须是self，代表当前对象

类方法：第一个参数必须是cls，代表类本身，用@classmethod装饰

静态方法：无默认参数，和类、对象无关，用@staticmethod装饰

类属性

初始化方法

实例方法

类方法

静态方法

创建对象（实例化）

访问实例属性和方法

访问类属性和类方法

调用静态方法

父类

子类继承父类

十三、装饰器

定义装饰器：计算函数执行时间

使用装饰器

使用带参数装饰器

十四、迭代器与生成器

print(next(it)) # 抛出StopIteration异常

十五、上下文管理器

使用自定义上下文管理器

十六、多线程与多进程

创建线程

启动线程

等待线程结束

十七、正则表达式

匹配手机号（11位数字，以1开头）

提取所有数字

替换敏感词

十八、高级数据结构

Langchain组件（续）

Langchain组件

【扩展】运算符的重载

Runnable接口

StrOutputParser解析器

JsonOutputParser&多模型执行链

RunnableLambda&函数加入链

Memory临时会话记忆

Memory长期会话记忆

Document loaders：文档加载器

CSVLoader

JSONLoader

TextLoader

PyPDFLoader

Vector stories向量存储

检索向量并构建提示词

RunnablePassthrough的使用

RAG开发-LangChain

RAG开发

LangChain简介

主要功能

LangChain环境部署

LangChain安装