首页
关于
Search
1
同步本地Markdown至Typecho站点
54 阅读
2
微服务
38 阅读
3
苍穹外卖
27 阅读
4
JavaWeb——后端
24 阅读
5
消息队列MQ
18 阅读
后端学习
项目
杂项
科研
论文
默认分类
登录
找到
7
篇与
项目
相关的结果
- 第 2 页
2025-03-21
招标文件解析
产品官网：智标领航 - 招投标AI解决方案 产品后台：xxx 项目地址：xxx git clone地址：xxx 选择develop分支，develop-xx 后面的xx越近越新。 正式环境：xxx 测试环境：xxx 大解析：指从招标文件解析入口进去，upload.py 小解析：从投标文件生成入口进去，little_zbparse 和get_deviation，两个接口后端一起调 项目启动与维护： .env存放一些密钥（大模型、textin等），它是gitignore忽略了，因此在服务器上git pull项目的时候，这个文件不会更新（因为密钥比较重要），需要手动维护服务器相应位置的.env。 如何更新服务器上的版本： 步骤 进入项目文件夹 **注意：**需要确认.env是否存在在服务器，默认是隐藏的 输入cat .env 如果不存在，在项目文件夹下sudo vim .env 将密钥粘贴进去！！！ git pull sudo docker-compose up --build -d 更新并重启 或者 sudo docker-compose build 先构建镜像 sudo docker-compose up -d 等空间时再重启 sudo docker-compose logs flask_app --since 1h 查看最近1h的日志（如果重启后报错也能查看，推荐重启后都运行一下这个） requirements.txt一般无需变动，除非代码中使用了新的库，也要手动在该文件中添加包名及对应的版本 docker基础知识 docker-compose: 本项目为单服务项目，只有flask_app(服务名) build context（context: .）： 这是在构建镜像时提供给 Docker 的文件集，指明哪些文件可以被 Dockerfile 中的 COPY 或 ADD 指令使用。它是构建过程中的“资源包”。 对于多服务，build下就要针对不同的服务，指定所需的“资源包”和对应的Dockerfile dockerfile: COPY . .（在 Dockerfile 中）： 这条指令会将构建上下文中的所有内容复制到镜像中的当前工作目录（这里是 /flask_project）。 docker exec -it zbparse-flask_app-1 sh 这个命令会直接进入到flask_project目录内部ls之后可以看到： Dockerfile README.md docker-compose.yml flask_app md_files requirements.txt 如果这个基础上再cd /会切换到这个容器的根目录，可以看到flask_project文件夹以及其他基础系统环境。如： bin boot dev etc flask_project home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var 数据卷挂载： volumes: -/home/Z/zbparse_output_dev:/flask_project/flask_app/static/output # 额外的数据卷挂载 本地路径：容器内路径 都从根目录找起。 完整的容器名 <项目名>-<服务名>-<序号> 项目名：默认是当前目录的名称（这里是 zbparse），或者你在启动 Docker Compose 时通过 -p 参数指定的项目名称。 服务名：在 docker-compose.yml 文件中定义的服务名称（这里是 flask_app）。 序号：如果同一个服务启动了多个容器，会有数字序号来区分（这里是 1）。 docker-compose exec flask_app sh docker exec -it zbparse-flask_app-1 sh 这两个是等价的，因为docker-compose 会自动找到对应的完整容器名并执行命令。 删除所有悬空镜像（无容器引用的 <none> 镜像） docker image prune 如何本地启动本项目： Pycharm启动 requirements.txt里的环境要配好 conda create -n zbparse python=3.8 conda activate zbparse pip install -r requirements.txt .env环境配好 （一般不需要在电脑环境变量中额外配置了，但是要在Pycharm中安装插件，使得项目在启动时能将env中的环境变量自动配置到系统环境变量中！！！） 点击下拉框，Edit configurations 设置run_serve.py为启动脚本 注意这里的working directory要设置到最外层文件夹，而不是flask_app！！！ 命令行启动 1.编写ps1脚本 # 切换到指定目录 cd D:\PycharmProjects\zbparse # 激活 Conda 环境 conda activate zbparse # 检查是否存在 .env 文件 if (Test-Path .env) { # 读取 .env 文件并设置环境变量 Get-Content .env | ForEach-Object { if ($_ -match '^\s*([^=]+)=(.*)') { $name = $matches[1].Trim() $value = $matches[2].Trim() [System.Environment]::SetEnvironmentVariable($name, $value) } } } else { Write-Host ".env not find" } # 设置 PYTHONPATH 环境变量 $env:PYTHONPATH = "D:\flask_project" # 运行 Python 脚本 python flask_app\run_serve.py $env:PYTHONPATH = "D:\flask_project"，告诉 Python 去 D:\flask_project 查找模块，这样就能让 Python 找到你的 flask_app 包。 2.确保conda已添加到系统环境变量 打开 Anaconda Prompt，然后输入 where conda 来查看 conda 的路径。 打开系统环境变量Path，添加一条：C:\ProgramData\anaconda3\condabin 或者 CMD 中 set PATH=%PATH%;新添加的路径 重启终端可以刷新环境变量 3.如果你尚未在 PowerShell 中初始化 conda，可以在 Anaconda Prompt 中运行： conda init powershell 4.进入到存放run.ps1文件的目录，在搜索栏中输入powershell 5.默认情况下，PowerShell 可能会阻止运行脚本。你可以调整执行策略： Set-ExecutionPolicy RemoteSigned -Scope CurrentUser 6.运行脚本 .\run.ps1 注意！！！ Windows 控制台存在QuickEdit 模式，在 QuickEdit 模式下，当你在终端窗口中点击（尤其是拖动或选中内容）时，控制台会进入文本选择状态，从而暂停正在运行的程序！！ 禁用 QuickEdit 模式 在 PowerShell 窗口标题栏上点击右键，选择“属性”。 在“选项”选项卡中，取消勾选“快速编辑模式”。 点击“确定”，重启 PowerShell 窗口后再试。 模拟用户请求 postman打post请求测试： http://127.0.0.1:5000/upload body: { "file_url":"xxxx", "zb_type":2 } file_url如何获取：OSS管理控制台 bid-assistance/test 里面找个文件的url，推荐'094定稿-湖北工业大学xxx' 注意这里的url地址有时效性，要经常重新获取新的url 清理服务器上的文件夹 1.编写shell文件，sudo vim clean_dir.sh 清理/home/Z/zbparse_output_dev下的output1这些二级目录下的c8d2140d-9e9a-4a49-9a30-b53ba565db56这种uuid的三级目录（只保留最近7天）。 #!/bin/bash # 需要清理的 output 目录路径 ROOT_DIR="/home/Z/zbparse_output_dev" # 检查目标目录是否存在 if [ ! -d "$ROOT_DIR" ]; then echo "目录 $ROOT_DIR 不存在！" exit 1 fi echo "开始清理 $ROOT_DIR 下超过 7 天的目录..." echo "以下目录将被删除：" # -mindepth 2 表示从第二层目录开始查找，防止删除 output 下的直接子目录（如 output1、output2） # -depth 采用深度优先遍历，确保先处理子目录再处理父目录 find "$ROOT_DIR" -mindepth 2 -depth -type d -mtime +7 -print -exec rm -rf {} \; echo "清理完成。" 2.添加权限。 sudo chmod +x ./clean_dir.sh 3.执行 sudo ./clean_dir.sh 以 root 用户的身份编辑 crontab 文件，从而设置或修改系统定时任务（cron jobs）。每天零点10分清理 sudo crontab -e 在里面添加： 10 0 * * * /home/Z/clean_dir.sh 目前测试服务器和正式服务器都写上了！无需变动 内存泄漏问题 问题定位 查看容器运行时占用的文件FD套接字FD等（排查内存泄漏,长期运行这三个值不会很大） [Z@iZbp13rxxvm0y7yz7l02hbZ zbparse]$ docker exec -it zbparse-flask_app-1 sh ls -l /proc/1/fd | awk ' BEGIN { file=0; socket=0; pipe=0; other=0 } { if(/socket:/) socket++ else if(/pipe:/) pipe++ else if(/\/|tmp/) file++ # 识别文件路径特征 else other++ } END { print "文件FD:", file print "套接字FD:", socket print "管道FD:", pipe print "其他FD:", other }' 可以发现文件FD很大，基本上发送一个请求文件FD就加一，且不会衰减： 经排查，@validate_and_setup_logger注解会为每次请求都创建一个logger，需要在@app.teardown_request中获取与本次请求有关的logger并释放。 def create_logger(app, subfolder): """ 创建一个唯一的 logger 和对应的输出文件夹。 参数: subfolder (str): 子文件夹名称，如 'output1', 'output2', 'output3' """ unique_id = str(uuid.uuid4()) g.unique_id = unique_id output_folder = os.path.join("flask_app", "static", "output", subfolder, unique_id) os.makedirs(output_folder, exist_ok=True) log_filename = "log.txt" log_path = os.path.join(output_folder, log_filename) logger = logging.getLogger(unique_id) if not logger.handlers: file_handler = logging.FileHandler(log_path) file_formatter = CSTFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler.setFormatter(file_formatter) logger.addHandler(file_handler) stream_handler = logging.StreamHandler() stream_handler.setFormatter(logging.Formatter('%(message)s')) logger.addHandler(stream_handler) logger.setLevel(logging.INFO) logger.propagate = False g.logger = logger g.output_folder = output_folder #输出文件夹路径 handler：每当 logger 生成一条日志信息时，这条信息会被传递给所有关联的 handler，由 handler 决定如何输出这条日志。例如，FileHandler 会把日志写入文件，而 StreamHandler 会将日志输出到控制台。 logger.setLevel(logging.INFO) ：它设置了 logger 的日志级别阈值。Logger 只会处理大于或等于 INFO 级别的日志消息（例如 INFO、WARNING、ERROR、CRITICAL），而 DEBUG 级别的消息会被忽略。 解决这个文件句柄问题后内存泄漏仍未解决，考虑分模块排查。 本项目结构大致是**1.**预处理（文件读取切分） **2.**并发调用5个函数分别调用大模型获取结果。 因此排查思路： 先将预处理模块单独拎出来作为接口，上传文件测试。 文件一般几MB，首先会读到内存，再处理，必然会占用很多内存，且它是调用每个接口都会经历的环节(little_zbparse/upload等) 内存泄漏排查工具 pip install memory_profiler from memory_profiler import memory_usage import time @profile def my_function(): a = [i for i in range(100000)] time.sleep(1) # 模拟耗时操作 b = {i: i*i for i in range(100000)} time.sleep(1) return a, b # 监控函数“运行前”和“运行后”的内存快照 mem_before = memory_usage()[0] result=my_function() mem_after = memory_usage()[0] print(f"Memory before: {mem_before} MiB, Memory after: {mem_after} MiB") @profile注解加在函数上，可以逐行分析内存增减情况。 memory_usage()[0] 可以获取当前程序所占内存的快照 产生的数据都存到result变量-》内存中，这是正常的，因此my_function没有内存泄漏问题。 但是 @profile def extract_text_by_page(file_path): result = "" with open(file_path, 'rb') as file: reader =PdfReader(file) num_pages = len(reader.pages) # print(f"Total pages: {num_pages}") for page_num in range(num_pages): page = reader.pages[page_num] text = page.extract_text() return "" 可以发现尽管我返回""，内存仍然没有释放！因为就是读取pdf这块发生了内存泄漏！ tracemalloc def extract_text_by_page(file_path): result = "" with open(file_path, 'rb') as file: reader =PdfReader(file) num_pages = len(reader.pages) # print(f"Total pages: {num_pages}") for page_num in range(num_pages): page = reader.pages[page_num] text = page.extract_text() return result # 开始跟踪内存分配 tracemalloc.start() # 捕捉函数调用前的内存快照 snapshot_before = tracemalloc.take_snapshot() # 调用函数 file_path=r'C:\Users\Administrator\Desktop\fsdownload\00550cfc-fd33-469e-8272-9215291b175c\ztbfile.pdf' result = extract_text_by_page(file_path) # 捕捉函数调用后的内存快照 snapshot_after = tracemalloc.take_snapshot() # 比较两个快照，获取内存分配差异信息 stats = snapshot_after.compare_to(snapshot_before, 'lineno') print("[ Top 10 内存变化 ]") for stat in stats[:10]: print(stat) # 停止内存分配跟踪 tracemalloc.stop() tracemalloc能更深入的分析，不仅是自己写的代码，调用的库函数产生的内存也能分析出来。在这个例子中就是PyPDF2中的各个函数占用了大部分内存。 综上，定位到问题，就是读取PDF，使用PyPDF2库的地方 如何解决： 首先尝试用with open打开文件，代替直接使用 reader =PdfReader(file_path) 能够确保文件正常关闭。但是没有效果。 考虑为每次请求开子进程处理，有效隔离内存泄漏导致的资源占用，这样子进程运行结束后会释放资源。 但是解析流程是流式/分段返回的，因此还需处理： _child_target 是一个“桥梁”： 它在子进程内调用 goods_bid_main(...) (你的生成器) 并把每一次 yield 得到的数据放进队列。 结束时放一个 None 表示没有更多数据。 run_in_subprocess 是主进程使用的接口，开启子进程： 它启动子进程并实时 get() 队列数据，然后 yield 给外界调用者。 当队列里读到 None，说明子进程运行完毕，就 break 循环并 p.join()。 main_func是真正执行的函数！！！ def _child_target(main_func, queue, output_folder, file_path, file_type, unique_id): """ 子进程中调用 `main_func`（它是一个生成器函数）， 将其 yield 出的数据逐条放进队列，最后放一个 None 表示结束。 """ try: for data in main_func(output_folder, file_path, file_type, unique_id): queue.put(data) except Exception as e: # 如果要把异常也传给父进程，以便父进程可感知 queue.put(json.dumps({'error': str(e)}, ensure_ascii=False)) finally: queue.put(None) def run_in_subprocess(main_func, output_folder, file_path, file_type, unique_id): """ 启动子进程调用 `main_func(...)`，并在父进程流式获取其输出（通过 Queue）。 子进程结束时，操作系统回收其内存；父进程则保持实时输出。 """ queue = multiprocessing.Queue() p = multiprocessing.Process( target=_child_target, args=(main_func, queue, output_folder, file_path, file_type, unique_id) ) p.start() while True: item = queue.get() # 阻塞等待子进程产出的数据 if item is None: break yield item p.join() 如果开子线程，线程共享同一进程的内存空间，所以如果发生内存泄漏，泄漏的内存会累积在整个进程中，影响所有线程。 开子进程的缺点：多进程通常消耗的系统资源（如内存、启动开销）比多线程要大，因为每个进程都需要独立的资源和上下文切换开销。 进程池 在判断上传的文件是否为招标文件时，需要快速准确地响应。因此既保证内存不泄漏，又保证速度的方案就是在项目启动时创建进程池。（因为创建进程需要耗时2到3秒！） 如果是Waitress服务器启动，这里的进程池是全局共享的；但如果Gunicorn启动，每个请求分配一个worker进程，进程池是在worker里面共享的！！！ #创建app，启动时 def create_app(): # 创建全局日志记录器 app = Flask(__name__) app.process_pool = Pool(processes=10, maxtasksperchild=3) app.global_logger = create_logger_main('model_log') # 全局日志记录器 #调用时 pool = current_app.process_pool # 使用全局的进程池 def judge_zbfile_exec_sub(file_path): result = pool.apply( judge_zbfile_exec, # 你的实际执行函数 args=(file_path,) ) return result 但是存在一个问题：第一次发送请求执行时间较慢！ 可以发现实际执行只需7.7s，但是接口实际耗时10.23秒，主要是因懒加载或按需初始化：有些模块或资源在子进程启动时并不会马上加载，而是在子进程首次真正执行任务时才进行初始化。 解决思路：提前热身（warm up）进程池 在应用启动后、还没正式接受请求之前，可以提交一个简单的“空任务”或非常小的任务给进程池，让子进程先完成相关的初始化。这种“预热”方式能在正式请求到来之前就完成大部分初始化，减少首次请求的延迟。 还可以快速验证服务是否正常启动 def warmup_request(): # 等待服务器完全启动，例如等待 1-2 秒 time.sleep(5) try: url = "http://127.0.0.1:5000/judge_zbfile" #url必须为永久地址，完成热启动，创建进程池 payload = {"file_url": "xxx"} # 根据实际情况设置 file_url headers = {"Content-Type": "application/json"} response = requests.post(url, json=payload, headers=headers) print(f"Warm-up 请求发送成功，状态码：{response.status_code}") except Exception as e: print(f"Warm-up 请求出错：{e}") threading.Thread(target=warmup_request, daemon=True).start() flask_app结构介绍 项目中做限制的地方 账号、服务器分流 服务器分流：目前linux服务器和windows服务器主要是硬件上的分流（文件切分需要消耗CPU资源），大模型基底还是调用阿里，共用的tpm qpm。 账号分流：qianwen_plus下的 api_keys = cycle([ os.getenv("DASHSCOPE_API_KEY"), # os.getenv("DASHSCOPE_API_KEY_BACKUP1"), # os.getenv("DASHSCOPE_API_KEY_BACKUP2") ]) api_keys_lock = threading.Lock() def get_next_api_key(): with api_keys_lock: return next(api_keys) api_key = get_next_api_key() 只需轮流使用不同的api_key即可。目前没有启用。 大模型的限制 general/llm下的doubao.py 和通义千问long_plus.py 目前是linux和windows各部署一套，因此项目中的qps是对半的，即calls=? 这是qianwen-long的限制（针对阿里qpm为1200，每秒就是20，又linux和windows服务器对半，就是10；TPM无上限） @sleep_and_retry @limits(calls=10, period=1) # 每秒最多调用10次 def rate_limiter(): pass # 这个函数本身不执行任何操作，只用于限流 这是qianwen-plus的限制（针对tpm为1000万，每个请求2万tokens，那么linux和windows总的qps为8时，8x60x2=960<1000。单个为4） 经过2.11号测试，calls=4时最高TPM为800，因此把目前稳定版把calls设为5 2.12,用turbo作为超限后的承载，目前把calls设为7 @sleep_and_retry @limits(calls=7, period=1) # 每秒最多调用7次 def qianwen_plus(user_query, need_extra=False): logger = logging.getLogger('model_log') # 通过日志名字获取记录器 qianwen_turbo的限制（TPM为500万，由于它是plus后的手段，稳妥一点，qps设为6，两个服务器分流即calls=3） @sleep_and_retry @limits(calls=3, period=1) # 500万tpm，每秒最多调用6次，两个服务器分流就是3次 （plus超限后的保底手段，稳妥一点） 重点！！后续阿里扩容之后成倍修改这块calls=? 如果不用linux和windows负载均衡，这里的calls也要乘2！！ 接口的限制 start_up.py的def create_app()函数，限制了对每个接口同时100次请求。这里事实上不再限制了（因为100已经足够大了），默认限制做到大模型限制这块。 app.connection_limiters['upload'] = ConnectionLimiter(max_connections=100) app.connection_limiters['get_deviation'] = ConnectionLimiter(max_connections=100) app.connection_limiters['default'] = ConnectionLimiter(max_connections=100) app.connection_limiters['judge_zbfile'] = ConnectionLimiter(max_connections=100) ConnectionLimiter.py以及每个接口上的装饰器，如 @require_connection_limit(timeout=1800) def zbparse(): 这里限制了每个接口内部执行的时间，暂时设置到了30分钟！（不包括排队时间）超时就是解析失败 后端的限制： 目前后端发起招标请求，如果发送超过100（max_connections=100）个请求，我这边会排队后面的请求，这时后端的计时器会将这些请求也视作正在解析中，事实上它们还在排队等待中，这样会导致在极端情况下，新进的解析文件速度大于解析的速度，排队越来越长，后面的文件会因为等待时间过长而直接失败，而不是'解析失败'。 general 是公共函数存放的文件夹，llm下是各类大模型，读取文件下是docx pdf文件的读取以及文档清理clean_pdf，去页眉页脚页码 general下的llm下的清除file_id.py 需要每周运行至少一次，防止file_id数量超出（我这边对每次请求结束都有file_id记录并清理，向应该还没加） llm下的model_continue_query是'模型继续回答'脚本，应对超长文本模型一次无法输出完的情况，继续提问，拼接成完整的内容。 general下的file2markdown是textin 文件--》markdown general下的format_change是pdf-》docx 或doc/docx->pdf general下的merge_pdfs.py是拼接文件的：1.拼接招标公告+投标人须知 2.拼接评标细则章节+资格审查章节 general中比较重要的！！！ 后处理： general下的post_processing,解析后的后处理部分，包括extract_info、 资格审查、技术偏离 商务偏离 所需提交的证明材料，都在这块生成。 post_processing中的inner_post_processing专门提取extracted_info post_processing中的process_functions_in_parallel提取 资格审查、技术偏离、 商务偏离、 所需提交的证明材料 大解析upload用了post_processing完整版， little_zbparse.py、小解析main.py用了inner_post_processing get_deviation.py、偏离表数据解析main.py用了process_functions_in_parallel 截取pdf： 截取pdf_main.py是顶级函数， 二级是截取pdf货物标版.py和截取pdf工程标版.py （非general下） 三级是截取pdf通用函数.py 如何判断截取位置是否正确？根据output文件夹中的切分情况（打开各个文件查看是否切分准确，目前的逻辑主要是按大章切分，即'招标公告'章节） 如果切分不准确，如何定位正则表达式？ 首先判断当前是工程标解析还是货物标解析，即zb_type=1还是2 如果是2，那么是货物标解析，那么就是截取pdf_main.py调用截取pdf货物标版.py，如下图，selection=1代表截取'招标公告'，那么如果招标公告没有切准，就在这块修改。这里可以发现get_notice是通用函数，即截取pdf通用函数.py中的get_notice函数，那么继续往内部跳转。 若开头没截准，就改begin_pattern，末尾没截准，就改end_pattern 另外：在截取pdf货物标版.py中，还有extract_pages_twice函数，即第一次没有切分到之后，会运行该函数，这边又有一套begin_pattern和end_pattern，即二次提取 如何测试？ 输入pdf_path，和你要切分的序号，selection=1代表切公告，依次类推，可以看切出来的效果如何。 无效标和废标公共代码 获取无效标与废标项的主要执行代码。对docx文件进行预处理=》正则=》temp.txt=》大模型筛选 如果提的不全，可能是正则没涵盖到位，也可能是大模型提示词漏选了。 这里：如果段落中既被正则匹配，又被follow_up_keywords中的任意一个匹配，那么不会添加到temp中（即不会被大模型筛选），它会直接添加到最后的返回中! 投标人须知正文条款提取成json文件 将截取到的ztbfile_tobidders_notice_part2.pdf ，即须知正文，转为clause1.json 文件，便于后续提取开评定标流程、投标文件要求、重新招标、不再招标和终止招标 这块的主要逻辑就是匹配形如'一、总则'这样的大章节 然后匹配形如'1.1' '1.1.1'这样的序号，由于是按行读取pdf，一个序号后面的内容可能有好几行，因此遇到下一个序号（如'2.1')开头，之前的内容都视为上一个序号的。 old_version 都是废弃文件代码，未在正式、测试环境中使用的，不用管 routes 是接口以及主要实现部分，一一对应 get_deviation对应偏离表数据解析main，获得偏离表数据 judge_zbfile对应判断是否是招标文件 little_zbparse对应小解析main，负责解析extract_info test_zbparse是测试接口，无对应 upload对应工程标解析和货物标解析，即大解析 混淆澄清：小解析可以指代一个过程，即从'投标文件生成'这个入口进去的解析，后端会同时调用little_zbparse和get_deviation。这个过程称为'小解析'。 但是little_zbparse也叫小解析，命名如此因为最初只需返回这些数据(extract_info)，后续才陆续返回商务、技术偏离... utils是接口这块的公共功能函数。其中validate_and_setup_logger函数对不同的接口请求对应到不同的output文件夹，如upload->output1。后续增加接口也可直接在这里写映射关系。 重点关注大解析：upload.py和货物标解析main.py static 存放解析的输出和提示词 其中output用gitignore了，git push不会推送这块内容。 各个文件夹(output1 output2..)对应不同的接口请求 test_case&testdir test_case是测试用例，是对一些函数的测试。好久没更新了 testdir是平时写代码的测试的地方 它们都不影响正式和测试环境的解析 工程标&货物标 是两个解析流程中不一样的地方（一样的都写在general中了） 主要是货物标额外解析了采购要求（提取采购需求main+技术参数要求提取+商务服务其他要求提取） 最后： ConnectionLimiter.py定义了接口超时时间->超时后断开与后端的连接 logger_setup.py 为每个请求创建单独的log，每个log对应一个log.txt start_up.py是启动脚本，run_serve也是启动脚本，是对start_up.py的简单封装，目前dockerfile定义的直接使用run_serve启动 持续关注 yield sse_format(tech_deviation_response) yield sse_format(tech_deviation_star_response) yield sse_format(zigefuhe_deviation_response) yield sse_format(shangwu_deviation_response) yield sse_format(shangwu_star_deviation_response) yield sse_format(proof_materials_response) 工程标解析目前仍没有解析采购要求这一块，因此后处理返回的只有'资格审查'和''证明材料"和"extracted_info"，没有''商务偏离''及'商务带星偏离'，也没有'技术偏离'和'技术带星偏离'，而货物标解析是完全版。 其中''证明材料"和"extracted_info"是直接返给后端保存的 大解析中返回了技术评分，后端接收后不仅显示给前端，还会返给向，用于生成技术偏离表 小解析时，get_deviation.py其实也可以返回技术评分，但是没有返回，因为没人和我对接，暂时注释了。 4.商务评议和技术评议偏离表，即评分细则的偏离表，暂时没做，但是商务评分、技术评分无论大解析还是小解析都解析了，稍微对该数据处理一下返回给后端就行。 这个是解析得来的结果，适合给前端展示，但是要生成商务技术评议偏离表的话，需要再调一次大模型，对该数据进行重新归纳，以字符串列表为佳。再传给后端。（未做） 如何定位问题 查看static下的output文件夹 （upload大解析对应output1） docker-compose文件中规定了数据卷挂载的路径：- /home/Z/zbparse_output_dev:/flask_project/flask_app/static/output 也就是说static/output映射到了服务器的Z/zbparse_output_dev文件夹 根据时间查找哪个子文件夹（uuid作为子文件名） 查看是否有final_result.json文件，如果有，说明解析流程正常结束了，问题可能出在后端（a.后端接口请求超限30分钟 b.后处理存在解析数据的时候出错） 也可能出现在自身解析，可以查看子文件内的log.txt，查看日志。 若解析正常（有final_result）但解析不准，可以根据以下定位： a.查看子文件夹下的文件切分是否准确，例如：如果评标办法不准确，那么查看ztbfile_evaluation_methon，是否正确切到了评分细则。如果切到了，那就改general/商务技术评分提取里的提示词；否则修改截取pdf那块关于'评标办法'的正则表达式。 b.总之是先看切的准不准，再看提示词能否优化，都要定位到对应的代码中！ 学习总结 Flask + Waitress ： Flask 和 Waitress 是两个不同层级的工具，在 Python Web 开发中扮演互补角色。它们的协作关系可以概括为：Flask 负责构建 Web 应用逻辑，而 Waitress 作为生产级服务器承载 Flask 应用。 # Flask 开发服务器（仅用于开发） if __name__ == '__main__': app.run(host='0.0.0.0', port=5000) # 使用 Waitress 启动（生产环境） from waitress import serve serve(app, host='0.0.0.0', port=8080) Waitress 的工作方式 作为 WSGI 服务器：Waitress 作为一个 WSGI 服务器，负责监听指定端口上的网络请求，并将请求传递给 WSGI 应用（如 Flask 应用）。 多线程处理：默认情况下，waitress 在单个进程内启用线程池。当请求到达时，waitress 会从线程池中分配一个线程来处理这个请求。由于 GIL 限制，同一时间只有一个线程在执行 Python 代码（只能使用一个核心，CPU利用率只能到100%）。 Flask 与 waitress 的协同工作 WSGI 接口：Flask 应用实现了 WSGI 接口。waitress 接收到请求后，会调用 Flask 应用对应的视图函数来处理请求，生成响应。 请求处理流程 请求进入 waitress waitress 分配一个线程并调用 Flask 应用 Flask 根据路由匹配并执行对应的处理函数 处理函数返回响应，waitress 将响应发送给客户端 Waitress 的典型使用场景 跨平台部署：尤其适合 Windows 环境（Gunicorn 等服务器不支持）。 简单配置：无需复杂设置即可获得比开发服务器(Flask自带)更强的性能。 中小型应用：对并发要求不极高的场景，Waitress 的轻量级特性优势明显。 Waitress的不足与处理 由于 waitress 是在单进程下工作，所有线程共享进程内存，如果业务逻辑简单且无复杂资源共享问题，这种方式是足够的。 引入子进程：如果需要每个请求实现内存隔离或者绕过 GIL 来利用多核 CPU，有时会在 Flask 视图函数内部启动子进程来处理实际任务。 直接采用多进程部署方案：使用 Gunicorn 的多 worker 模式 Gunicorn Gunicorn 的工作方式 预启动 Worker 进程。Gunicorn 启动时，会按照配置数量（例如 4 个 worker）创建多个 worker 进程。这些 worker 进程会一直运行，并监听同一个端口上的请求。不会针对每个请求单独创建新进程。 共享 socket：所有 worker 进程共享同一个监听 socket，当有请求到来时，操作系统会将请求分发给某个空闲的 worker。 推荐worker 数量 = (2 * CPU 核心数) + 1 如何启动： 要使用异步 worker，你需要： pip install gevent 启动 Gunicorn 时指定 worker 类型和数量，例如： gunicorn -k gevent -w 4 --max-requests 100 flask_app.start_up:create_app --bind 0.0.0.0:5000 使用 -k gevent（或者 -k eventlet）就可以使用异步 worker，单个 worker 能够处理多个 I/O 密集型请求。 使用--max-requests 100 。每个 worker 在处理完 100 个请求后会自动重启，从而释放可能累积的内存。 本项目的执行流程： 调用CPU进行PDF文件的读取与切分，CPU密集型，耗时半分钟 针对切分之后的不同部分，分别调用大模型，得到回答，IO密集型，耗时2分钟。 解决方案： 1.使用flask+waitress，waitress会为每个用户请求开新的线程处理，然后我的代码逻辑会在这个线程内开子进程来执行具体的代码，以绕过GIL限制，且正确释放内存资源。 **后续可以开一个共享的进程池代替为每个请求开子进程。以避免高并发下竞争多核导致的频繁CPU切换问题。 2.使用Gunicorn的异步worker，gunicorn为固定创建worker（进程），处理用户请求，一个异步 worker 可以同时处理多个用户请求，因为当一个请求在等待外部响应（例如调用大模型接口）时，worker 可以切换去处理其他请求。 全局解释器锁（GIL）： Python（特别是 CPython 实现）中有一个叫做全局解释器锁（Global Interpreter Lock，简称 GIL）的机制，这个锁确保在任何时刻只有一个线程在执行 Python 字节码。 这意味着，即使你启动了多个线程，它们在执行 Python 代码时实际上是串行执行的，而不是并行利用多核 CPU。 在 Java 中，多线程通常能充分利用多核，因为 Java 的线程是真正的系统级线程，不存在类似 CPython 中的 GIL 限制。 影响： CPU密集型任务：由于 GIL 的存在，在 CPU 密集型任务中，多线程往往不能提高性能，因为同时只有一个线程在执行 Python 代码。 I/O密集型任务：如果任务主要等待 I/O（例如网络、磁盘读写），线程在等待时会释放 GIL，此时多线程可以提高程序的响应性和吞吐量。 NumPy能够在一定程度上绕过 Python 的 GIL 限制。许多 NumPy 的数值计算操作（如矩阵乘法、向量化运算等）是由高度优化的 C 或 Fortran 库（如 BLAS、LAPACK）实现的。这些库通常在执行计算密集型任务时会释放 GIL。C 扩展模块的方式将 C 代码嵌入到 Python 中，从而利用底层 C 库的高性能优势 进程与线程 1、进程是操作系统分配任务的基本单位，进程是python中正在运行的程序；当我们打开了1个浏览器时就是开始了一个浏览器进程； 线程是进程中执行任务的基本单元（执行指令集），一个进程中至少有一个线程、当只有一个线程时，称为主线程 2、线程的创建和销毁耗费资源少，进程的创建和销毁耗费资源多；线程很容易创建，进程不容易创建 3、线程的切换速度快，进程慢 4、一个进程中有多个线程时：线程之间可以进行通信；一个进程中有多个子进程时，进程与进程之间不可以相互通信，如果需要通信时，就必须通过一个中间代理实现，Queue、Pipe。 5、多进程可以利用多核cpu，多线程不可以利用多核cpu 6、一个新的线程很容易被创建，一个新的进程创建需要对父进程进行一次克隆 7、多进程的主要目的是充分使用CPU的多核机制，多线程的主要目的是充分利用某一个单核 ——————————————— 每个进程有自己的独立 GIL 多线程适用于 I/O 密集型任务 多进程适用于CPU密集型任务 因此，多进程用于充分利用多核，进程内开多线程以充分利用单核。 进程池 multiprocessing.Pool库：，通过 maxtasksperchild 指定每个子进程在退出前最多执行的任务数，这有助于防止某些任务中可能存在的内存泄漏问题 pool =Pool(processes=10, maxtasksperchild=3) concurrent.futures.ProcessPoolExecutor更高级、更统一，没有类似 maxtasksperchild 的参数，意味着进程在整个执行期内会一直存活，适合任务本身比较稳定的场景。 pool =ProcessPoolExecutor(max_workers=10) 最好创建的进程数等同于CPU核心数，如果大于，且每个进程都是CPU密集型（高负债一直用到CPU），那么进程之间会竞争CPU，导致上下文切换增加，反而会降低性质。 设置的工作进程数接近 CPU 核心数，以便每个进程能独占一个核运行。 进程、线程间通信 线程间通信： 线程之间可以直接共享全局变量、对象或数据结构，不需要额外的序列化过程，但这也带来了同步的复杂性（如竞态条件）。 import threading num=0 def work(): global num for i in range(1000000): num+=1 print('work',num) def work1(): global num for i in range(1000000): num+=1 print('work1',num) if __name__ == '__main__': t1=threading.Thread(target=work) t2=threading.Thread(target=work1) t1.start() t2.start() t1.join() t2.join() print('主线程执行结果',num) 运行结果： work 1551626 work1 1615783 主线程执行结果 1615783 这些数值都小于预期的 2000000，因为： 即使存在 GIL，num += 1 这样的操作实际上并不是原子的。GIL 确保同一时刻只有一个线程执行 Python 字节码，但在执行 num += 1 时，实际上会发生下面几步操作： 从内存中读取 num 的当前值 对读取到的值进行加 1 操作 将新的值写回到内存 由多个字节码组成！！！ 因此会导致： 线程 A 读取到 num 的值 切换到线程 B，线程 B 也读取同样的 num 值并进行加 1，然后写回 当线程 A 恢复时，它依然基于之前读取的旧值进行加 1，最后写回，从而覆盖了线程 B 的更新 解决： from threading import Lock import threading num=0 def work(): global num for i in range(1000000): with lock: num+=1 print('work',num) def work1(): global num for i in range(1000000): with lock: num+=1 print('work1',num) if __name__ == '__main__': lock=Lock() t1=threading.Thread(target=work) t2=threading.Thread(target=work1) t1.start() t2.start() t1.join() t2.join() print('主线程执行结果',num) 进程间通信（IPC）： 进程之间默认不共享内存，因此如果需要传递数据，就必须使用专门的通信机制。 在 Python 中，可以使用 multiprocessing.Queue、multiprocessing.Pipe、共享内存（如 multiprocessing.Value 和 multiprocessing.Array）等方式实现进程间通信。 from multiprocessing import Process, Queue def worker(process_id, q): # 每个进程将数据放入队列 q.put(f"data_from_process_{process_id}") print(f"Process {process_id} finished.") if __name__ == '__main__': q = Queue() processes = [] for i in range(5): p = Process(target=worker, args=(i, q)) processes.append(p) p.start() for p in processes: p.join() # 从队列中收集数据 results = [] while not q.empty(): results.append(q.get()) print("Collected data:", results) 当你在主进程中创建了一个 Queue 对象，然后将它作为参数传递给子进程时，子进程会获得一个能够与主进程通信的“句柄”。 子进程中的 q.put(...) 操作会将数据通过这个管道传送到主进程，而主进程可以通过 q.get() 来获取这些数据。 这种机制虽然看起来像是“共享”，但实际上是通过 IPC（进程间通信）实现的，而不是直接共享内存中的变量。 项目贡献 效果图
项目
zy123
3月21日
0
5
0
2025-03-21
苍穹外卖
苍穹外卖 项目简介 整体介绍 本项目（苍穹外卖）是专门为餐饮企业（餐厅、饭店）定制的一款软件产品，包括 系统管理后台 和 小程序端应用 两部分。其中系统管理后台主要提供给餐饮企业内部员工使用，可以对餐厅的分类、菜品、套餐、订单、员工等进行管理维护，对餐厅的各类数据进行统计，同时也可进行来单语音播报功能。小程序端主要提供给消费者使用，可以在线浏览菜品、添加购物车、下单、支付、催单等。 1). 管理端功能 员工登录/退出 , 员工信息管理 , 分类管理 , 菜品管理 , 套餐管理 , 菜品口味管理 , 订单管理 ，数据统计，来单提醒。 2). 用户端功能 微信登录 , 收件人地址管理 , 用户历史订单查询 , 菜品规格查询 , 购物车功能 , 下单 , 支付、分类及菜品浏览。 技术选型 1). 用户层 本项目中在构建系统管理后台的前端页面，我们会用到H5、Vue.js、ElementUI、apache echarts(展示图表)等技术。而在构建移动端应用时，我们会使用到微信小程序。 2). 网关层 Nginx是一个服务器，主要用来作为Http服务器，部署静态资源，访问性能高。在Nginx中还有两个比较重要的作用： 反向代理和负载均衡， 在进行项目部署时，要实现Tomcat的负载均衡，就可以通过Nginx来实现。 3). 应用层 SpringBoot： 快速构建Spring项目, 采用 "约定优于配置" 的思想, 简化Spring项目的配置开发。 SpringMVC：SpringMVC是spring框架的一个模块，springmvc和spring无需通过中间整合层进行整合，可以无缝集成。 Spring Task: 由Spring提供的定时任务框架。 httpclient: 主要实现了对http请求的发送。 Spring Cache: 由Spring提供的数据缓存框架 JWT: 用于对应用程序上的用户进行身份验证的标记。 阿里云OSS: 对象存储服务，在项目中主要存储文件，如图片等。 Swagger： 可以自动的帮助开发人员生成接口文档，并对接口进行测试。 POI: 封装了对Excel表格的常用操作。 WebSocket: 一种通信网络协议，使客户端和服务器之间的数据交换更加简单，用于项目的来单、催单功能实现。 4). 数据层 MySQL： 关系型数据库, 本项目的核心业务数据都会采用MySQL进行存储。 Redis： 基于key-value格式存储的内存数据库, 访问速度快, 经常使用它做缓存。 Mybatis： 本项目持久层将会使用Mybatis开发。 pagehelper: 分页插件。 spring data redis: 简化java代码操作Redis的API。 5). 工具 git: 版本控制工具, 在团队协作中, 使用该工具对项目中的代码进行管理。 maven: 项目构建工具。 junit：单元测试工具，开发人员功能实现完毕后，需要通过junit对功能进行单元测试。 postman: 接口测工具，模拟用户发起的各类HTTP请求，获取对应的响应结果。 准备工作 //待完善，最后写一套本地java开发、nginx部署前端；服务器docker部署的方案！！！ 前端环境搭建 Windows下 1.构建和打包前端项目 npm install #安装依赖 npm run build #打包，但我TypeScript 检查报错 npm run pure-build #不检查类型打包 2.将构建文件复制到指定目录 Nginx 默认的静态文件根目录通常是 /usr/share/nginx/html,你可以选择将打包好的静态文件拷贝到该目录 或者使用自定义目录/var/www/my-frontend,并修改 Nginx 配置文件来指向这个目录。 3.配置 Nginx 打开 Nginx 的配置文件，通常位于 /etc/nginx/nginx.conf 以下是一个使用自定义目录 /var/www/my-frontend 作为站点根目录的示例配置： server { listen 80; server_name your-domain.com; # 如果没有域名可以使用 _ 或 localhost root /var/www/my-frontend; index index.html; location / { try_files $uri $uri/ /index.html; } } 4.启动或重启 Nginx 启动：双击nginx.exe 重启：nginx -s reload 5.查看是否正在运行 tasklist /FI "IMAGENAME eq nginx.exe" 6.访问前端项目 在浏览器中输入你配置的域名或服务器 IP 地址 终止运行nginx： nginx.exe -s stop 后端环境搭建 工程的每个模块作用说明： 序号 名称 说明 1 sky-take-out maven父工程，统一管理依赖版本，聚合其他子模块 2 sky-common 子模块，存放公共类，例如：工具类、常量类、异常类等 3 sky-pojo 子模块，存放实体类、VO、DTO等 4 sky-server 子模块，后端服务，存放配置文件、Controller、Service、Mapper等 分析sky-common模块的每个包的作用： 名称 说明 constant 存放相关常量类 context 存放上下文类 enumeration 项目的枚举类存储 exception 存放自定义异常类 json 处理json转换的类 properties 存放SpringBoot相关的配置属性类 result 返回结果类的封装 utils 常用工具类 分析sky-pojo模块的每个包的作用： 名称 说明 Entity 实体，通常和数据库中的表对应 DTO 数据传输对象，通常用于程序中各层之间传递数据（接收从web来的数据） VO 视图对象，为前端展示数据提供的对象（响应给web） POJO 普通Java对象，只有属性和对应的getter和setter 分析sky-server模块的每个包的作用： 名称 说明 config 存放配置类 controller 存放controller类 interceptor 存放拦截器类 mapper 存放mapper接口 service 存放service类 SkyApplication 启动类 数据库初始化 执行sky.sql文件 序号 数据表名 中文名称 1 employee 员工表 2 category 分类表 3 dish 菜品表 4 dish_flavor 菜品口味表 5 setmeal 套餐表 6 setmeal_dish 套餐菜品关系表 7 user 用户表 8 address_book 地址表 9 shopping_cart 购物车表 10 orders 订单表 11 order_detail 订单明细表 跨域问题产生方式： 你在地址栏输 http://localhost:8100/api/health，这是浏览器直接导航到该 URL——浏览器会绕过 CORS 机制，直接向服务器发请求并渲染响应结果，这种场景不受 CORS 限制。 但如果你在一个在 http://localhost:3000（或任何不同端口）下运行的前端网页里，用 JavaScript 这样写： fetch('http://localhost:8100/api/health') .then(res => res.json()) .then(data => console.log(data)) .catch(err => console.error(err)); 会触发跨域 Nginx 1.静态资源托管 直接高效地托管前端静态文件（HTML/CSS/JS/图片等）。 server { root /var/www/html; index index.html; location / { try_files $uri $uri/ /index.html; # 支持前端路由（如 React/Vue） } } try_files：按顺序尝试多个文件或路径，直到找到第一个可用的为止。 $uri：尝试直接访问请求的路径对应的文件（例如 /css/style.css）。 $uri/：尝试将路径视为目录（例如 /blog/ 会查找 /blog/index.html）。 /index.html：如果前两者均未找到，最终返回前端入口文件 index.html。 2.nginx 反向代理： 反向代理的好处： 提高访问速度 因为nginx本身可以进行缓存，如果访问的同一接口，并且做了数据缓存，nginx就直接可把数据返回，不需要真正地访问服务端，从而提高访问速度。 保证后端服务安全 因为一般后台服务地址不会暴露，所以使用浏览器不能直接访问，可以把nginx作为请求访问的入口，请求到达nginx后转发到具体的服务中，从而保证后端服务的安全。 统一入口解决跨域问题（无需后端配置 CORS）。 @Configuration public class CorsConfig implements WebMvcConfigurer { @Override public void addCorsMappings(CorsRegistry registry) { // 覆盖所有请求 registry.addMapping("/**") // 允许发送 Cookie .allowCredentials(true) // 放行哪些域名（必须用 patterns，否则 * 会和 allowCredentials 冲突） .allowedOriginPatterns("*") .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") .allowedHeaders("*") .exposedHeaders("*"); } } nginx 反向代理的配置方式： server{ listen 80; server_name localhost; location /api/{ proxy_pass http://localhost:8080/admin/; #反向代理 } } 监听80端口号， 然后当我们访问 http://localhost:80/api/../..这样的接口的时候，它会通过 location /api/ {} 这样的反向代理到 http://localhost:8080/admin/上来。 3.负载均衡配置（默认是轮询） 将流量分发到多个后端服务器，提升系统吞吐量和容错能力。 upstream webservers{ server 192.168.100.128:8080; server 192.168.100.129:8080; } server{ listen 80; server_name localhost; location /api/{ proxy_pass http://webservers/admin;#负载均衡 } } 完整流程示例 用户访问：浏览器打开 http://yourdomain.com。 Nginx 返回静态文件：返回 index.html 和前端资源。 前端发起 API 请求：前端代码调用 /api/data。 Nginx 代理请求：将 /api/data 转发到 http://backend_server:3000/api/data。 后端响应：处理请求并返回数据，Nginx 将结果传回前端。 APIFox 使用APIFox管理、测试接口、导出接口文档... 优势： 1.多格式支持 APIFox 能够导入包括 YApi 格式在内的多种接口文档，同时支持导出为 OpenAPI、Postman Collection、Markdown 和 HTML 等格式，使得接口文档在不同工具间无缝迁移和使用。 2.接口调试与 Mock 内置接口调试工具可以直接发送请求、查看返回结果，同时内置 Mock 服务功能，方便前后端联调和接口数据模拟，提升开发效率。 3.易用性与团队协作 界面直观、操作便捷，支持多人协作，通过分支管理和版本控制，团队成员可以并行开发并进行变更管理，确保接口维护有序。 迭代分支功能： 新建迭代分支，新增的待测试的接口在这里充分测试，没问题之后合并回主分支。 导出接口文档： 推荐导出数据格式为OpenAPI Spec，它是一种通用的 API 描述标准，Postman和APIFox都支持。 与Idea集成 安装plugin Apifox-helper，配置token，即可直接在controller层接口右键 "upload to Apifox" Swagger 使得前后端分离开发更加方便，有利于团队协作 接口的文档在线自动生成，降低后端开发人员编写接口文档的负担 功能测试 使用： 1.导入 knife4j 的maven坐标 在pom.xml中添加依赖 <dependency> <groupId>com.github.xiaoymin</groupId> <artifactId>knife4j-spring-boot-starter</artifactId> </dependency> 2.在配置类中加入 knife4j 相关配置 WebMvcConfiguration.java /** * 通过knife4j生成接口文档 * @return */ @Bean public Docket docket() { ApiInfo apiInfo = new ApiInfoBuilder() .title("苍穹外卖项目接口文档") .version("2.0") .description("苍穹外卖项目接口文档") .build(); Docket docket = new Docket(DocumentationType.SWAGGER_2) .apiInfo(apiInfo) .select() .apis(RequestHandlerSelectors.basePackage("com.sky.controller")) .paths(PathSelectors.any()) .build(); return docket; } 3.设置静态资源映射，否则接口文档页面无法访问 WebMvcConfiguration.java /** * 设置静态资源映射 * @param registry */ protected void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/"); registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/"); } 4.访问测试 接口文档访问路径为 http://ip:port/doc.html ---> http://localhost:8080/doc.html 这是根据后端 Java 代码（通常是注解）自动生成接口文档，访问是通过后端服务的端口，这些文档最终会以静态文件的形式存在于 jar 包内，通常存放在 META-INF/resources/ 常用注解 通过注解可以控制生成的接口文档，使接口文档拥有更好的可读性，常用注解如下： 注解 说明 @Api 用在类上，例如Controller，表示对类的说明 @ApiModel 用在类上，例如entity、DTO、VO @ApiModelProperty 用在属性上，描述属性信息 @ApiOperation 用在方法上，例如Controller的方法，说明方法的用途、作用 EmployeeLoginDTO.java @Data @ApiModel(description = "员工登录时传递的数据模型") public class EmployeeLoginDTO implements Serializable { @ApiModelProperty("用户名") private String username; @ApiModelProperty("密码") private String password; } EmployeeController.java @Api(tags = "员工相关接口") public class EmployeeController { @Autowired private EmployeeService employeeService; @Autowired private JwtProperties jwtProperties; /** * 登录 * * @param employeeLoginDTO * @return */ @PostMapping("/login") @ApiOperation(value = "员工登录") public Result<EmployeeLoginVO> login(@RequestBody EmployeeLoginDTO employeeLoginDTO) { //.............. } } 后端部署 项目开发完毕 这种情况下JAVA代码无需改动，直接本地打包maven->package成Jar包复制到服务器上部署： 本项目为multi-module (聚合) Maven 工程，父工程为sky-take-out，子模块有common,pojo,server，其中server依赖common和pojo： <dependency> <groupId>com.sky</groupId> <artifactId>sky-common</artifactId> <version>1.0-SNAPSHOT</version> </dependency> <dependency> <groupId>com.sky</groupId> <artifactId>sky-pojo</artifactId> <version>1.0-SNAPSHOT</version> </dependency> 打包方式（本地）： 法一.直接对父工程执行mvn clean install 法二.分别先对子模块common和pojo执行install，再对server执行package 注意：直接对server打包会报错！！！ 因为Maven 在构建 sky-server 时，去你本地仓库或远程仓库寻找它依赖的两个 SNAPSHOT 包。 在父工程的pom中添加这段，能将你的应用和所有依赖都打到一个可执行的 “fat jar” 里 <build> <finalName>${project.artifactId}</finalName> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> JAVA项目dockerfile： # 使用 JDK 17 运行时镜像 FROM openjdk:17-jdk-slim # 设置时区为上海 ENV TZ=Asia/Shanghai RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone # 创建工作目录 WORKDIR /app # 复制 Fat Jar，重命名为 app.jar COPY sky-server-1.0-SNAPSHOT.jar ./app.jar # 暴露端口（与 application.properties 中的 server.port 保持一致） EXPOSE 8085 # 以 exec 形式启动 ENTRYPOINT ["java", "-jar", "app.jar"] ENTRYPOINT ["java", "-jar", "app.jar"] 能够启动是因为Spring Boot 的 Maven 插件在打包时已经将你的启动类标记进去了： Spring Boot 的启动器会： 读取 MANIFEST.MF 里的 Start-Class: com.sky.SkyApplication 将 com.sky.SkyApplication 作为入口调用其 main 方法 由于该项目还需依赖Mysql和Redis运行，因此需在docker-compose.yml中统一创建容器环境。（:ro代表只读） version: "3.8" services: mysql: image: mysql:8.0 container_name: sky-mysql restart: always environment: MYSQL_ROOT_PASSWORD: 123456 MYSQL_DATABASE: sky_take_out TZ: Asia/Shanghai volumes: - ./data/mysql:/var/lib/mysql - ./init/sky.sql:/docker-entrypoint-initdb.d/sky.sql:ro - ./mysql-conf/my.cnf:/etc/mysql/conf.d/my.cnf:ro ports: - "3306:3306" networks: - sky-net redis: image: redis:7.0-alpine container_name: sky-redis restart: always command: redis-server --requirepass 123456 volumes: - ./data/redis:/data ports: - "6379:6379" networks: - sky-net app: build: context: . dockerfile: Dockerfile image: sky-server:latest container_name: sky-server depends_on: - mysql - redis volumes: - ./config:/app/config:ro environment: TZ: Asia/Shanghai SPRING_PROFILES_ACTIVE: dev ports: - "8085:8085" restart: always networks: - sky-net volumes: mysql: redis: networks: sky-net: external: true 其中启动数据库要准备两份文件： 初始化脚本sky.sql，用来创建数据库和表 my.cnf：让初始化脚本创建的表中的中文数据正常显示 [client] default-character-set = utf8mb4 [mysql] default-character-set = utf8mb4 [mysqld] character-set-server = utf8mb4 collation-server = utf8mb4_unicode_ci init_connect='SET NAMES utf8mb4' 另外： application-dev.yml 是给 Spring Boot 读取的，Spring Boot 会在启动时自动加载它，填充到JAVA项目中。 Docker Compose 里的 environment: 无法读取application-dev.yml，要不就写死、要不就写在.env文件中。 最后项目结构： 滚动开发阶段 1.仅需改动Dokcerfile，docker-compose无需更改: # —— 第一阶段：Maven 构建 —— FROM maven:3.8.7-eclipse-temurin-17-alpine AS builder WORKDIR /workspace # 把项目级 settings.xml 复制到容器里 COPY .mvn/settings.xml /root/.m2/settings.xml # 1) 先把父 POM 和所有子模块的目录结构都复制过来 COPY whut-take-out-backend/pom.xml ./pom.xml COPY whut-take-out-backend/sky-common ./sky-common COPY whut-take-out-backend/sky-pojo ./sky-pojo COPY whut-take-out-backend/sky-server ./sky-server # （可选：如果父 pom 有 <modules>，也可把 settings.xml、父级的其它 POM 拷过来） RUN mvn dependency:go-offline -B # 2) 拷贝所有子模块源码 COPY whut-take-out-backend ./whut-take-out-backend # 3) 只构建 sky-server 模块（并且把依赖模块一并编译） RUN mvn -f whut-take-out-backend/pom.xml clean package \ -pl sky-server -am \ -DskipTests -B # —— 第二阶段：运行时镜像 —— FROM openjdk:17-jdk-slim ENV TZ=Asia/Shanghai RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone WORKDIR /app # 4) 把第一阶段产物（sky-server 模块的 Jar）拷过来 COPY --from=builder \ /workspace/whut-take-out-backend/sky-server/target/sky-server-*.jar \ ./app.jar EXPOSE 8085 ENTRYPOINT ["java", "-jar", "app.jar"] 命令解析： mvn dependency:go-offline -B 这一步只做依赖预取，也就是把所有在父 POM、子模块 POM、以及插件里声明的第三方库都下载到本地仓库（~/.m2/repository） 真正的编译+构建打包步骤： RUN mvn -f whut-take-out-backend/pom.xml clean package \ -pl sky-server -am \ -DskipTests -B -f whut-take-out-backend/pom.xml 指定使用哪个 POM 作为构建入口（父工程）。 clean: 把上一次构建残留的 target/ 目录删掉，保证从零开始构建 package：执行到 package 阶段 生成 JAR/WAR -pl sky-server (--projects) 只针对 sky-server 模块执行后续构建。 -am (--also-make) 如果 sky-server 依赖了多模块工程里的其他子模块（如 common、pojo），就会先把它们编译好，确保 sky-server 拿到最新的本地模块依赖。 -DskipTests 跳过单元测试，加快构建速度。 -B 批处理模式（无交互），适合 Docker 构建。 2.maven构建依赖可能比较慢，需创建.mvn/settings.xml （这个提速非常多！务必添加） <settings xmlns="http://maven.apache.org/SETTINGS/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.1.0 https://maven.apache.org/xsd/settings-1.1.0.xsd"> <mirrors> <mirror> <id>aliyun</id> <name>aliyun maven</name> <url>https://maven.aliyun.com/repository/public</url> <mirrorOf>central,apache.snapshots</mirrorOf> </mirror> </mirrors> </settings> 使用阿里云镜像加速 3.验证：http://124.71.159.195:8085/doc.html 踩坑总结 Maven 默认会用 artifactId-version来命名,eg： <artifactId>group-buying-sys</artifactId> <version>1.0-SNAPSHOT</version> group-buying-sys-app-1.0-SNAPSHOT.jar 如果server模块中的pom中指定了finalName，那么打包出来的文件将命名为finalName中指定的名称，如 example-app.jar <build> <finalName>example-app</finalName> </build> 这个问题导致docker-compose构建镜像时一直报错：Error: Unable to access jarfile app.jar 部署时占用问题端口： Error response from daemon: Ports are not available: exposing port TCP 0.0.0.0:13306 -> 0.0.0.0:0: listen tcp 0.0.0.0:13306: bind: An attempt was made to access a socket in a way forbidden by its access permissions. 先查看是否端口被占用： netstat -aon | findstr 5672 如果没有被占用，那么就是windows的bug，在CMD使用管理员权限重启NAT网络服务即可 net stop winnat net start winnat 前端部署 直接部署开发完毕的前端代码，准备： 0）创建docker网络：docker network create sky-net 1）静态资源html文件夹(npm run build 打包源码获得) 2）nginx.conf 注意把nginx.conf中的server改为Docker 容器（或服务）在同一网络中的服务名，如 upstream webservers { server sky-server:8085 weight=90; } 因为同一个网络下的服务名会自动注册DNS，进行地址解析！ 3）docker-compose文件 version: "3.8" services: frontend: image: nginx:alpine container_name: sky-frontend ports: - "85:80" volumes: # 把本地 html 目录挂到容器的默认站点目录 - ./html:/usr/share/nginx/html:ro # 把本地的 nginx.conf 覆盖容器里的配置 - ./nginx.conf:/etc/nginx/nginx.conf:ro networks: - sky-net networks: sky-net: external: true 实战开发 分页查询 传统员工分页查询分析： 采用分页插件PageHelper： 在执行empMapper.list()方法时，就是执行：select * from emp 语句，怎么能够实现分页操作呢？ 分页插件帮我们完成了以下操作： 先获取到要执行的SQL语句： select * from emp 为了实现分页，第一步是获取符合条件的总记录数。分页插件将原始 SQL 查询中的 SELECT * 改成 SELECT count(*) select count(*) from emp; 一旦知道了总记录数，分页插件会将 SELECT * 的查询语句进行修改，加入 LIMIT 关键字，限制返回的记录数。 select * from emp limit ?, ? 第一个参数（?）是 起始位置，通常是 (当前页 - 1) * 每页显示的记录数，即从哪一行开始查询。 第二个参数（?）是 每页显示的记录数，即返回多少条数据。 执行分页查询,例如，假设每页显示 10 条记录，你请求第 2 页数据，那么 SQL 语句会变成： select * from emp limit 10, 10; #跳过前10条数据，请求接下来的10条，即第2页数据 使用方法： 当使用 PageHelper 分页插件时，无需在 Mapper 中手动处理分页。只需在 Mapper 中编写常规的列表查询。 在 Service 层，调用 Mapper 方法之前，设置分页参数。 调用 Mapper 查询后，自动进行分页，并将结果封装到 PageBean 对象中返回。 1、在pom.xml引入依赖 <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper-spring-boot-starter</artifactId> <version>1.4.2</version> </dependency> 2、EmpMapper @Mapper public interface EmpMapper { //获取当前页的结果列表 @Select("select * from emp") public List<Emp> list(); } 3、EmpServiceImpl 当调用 PageHelper.startPage(page, pageSize) 时，PageHelper 插件会拦截随后的 SQL 查询，自动修改查询，加入 LIMIT 子句来实现分页功能。 @Override public PageBean page(Integer page, Integer pageSize) { // 设置分页参数 PageHelper.startPage(page, pageSize); //page是页号，不是起始索引 // 执行分页查询 List<Emp> empList = empMapper.list(); // 获取分页结果 Page<Emp> p = (Page<Emp>) empList; //封装PageBean PageBean pageBean = new PageBean(p.getTotal(), p.getResult()); return pageBean; } 4、Controller @Slf4j @RestController @RequestMapping("/emps") public class EmpController { @Autowired private EmpService empService; //条件分页查询 @GetMapping public Result page(@RequestParam(defaultValue = "1") Integer page, @RequestParam(defaultValue = "10") Integer pageSize) { //记录日志 log.info("分页查询，参数：{},{}", page, pageSize); //调用业务层分页查询功能 PageBean pageBean = empService.page(page, pageSize); //响应 return Result.success(pageBean); } } 条件分页查询 思路分析： <select id="pageQuery" resultType="com.sky.entity.Employee"> select * from employee <where> <if test="name != null and name != ''"> and name like concat('%',#{name},'%') </if> </where> order by create_time desc /select> 文件上传 阿里云OSS存储 pom文件中添加如下依赖： <dependency> <groupId>com.aliyun.oss</groupId> <artifactId>aliyun-sdk-oss</artifactId> <version>3.15.1</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> 上传文件的工具类 /** * 阿里云 OSS 工具类 */ public class AliOssUtil { private String endpoint; private String accessKeyId; private String accessKeySecret; private String bucketName; /** * 文件上传 * * @param bytes * @param objectName * @return */ public String upload(byte[] bytes, String objectName) { // 创建OSSClient实例。 OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret); try { // 创建PutObject请求。 ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(bytes)); } catch (OSSException oe) { System.out.println("Caught an OSSException, which means your request made it to OSS, " + "but was rejected with an error response for some reason."); System.out.println("Error Message:" + oe.getErrorMessage()); System.out.println("Error Code:" + oe.getErrorCode()); System.out.println("Request ID:" + oe.getRequestId()); System.out.println("Host ID:" + oe.getHostId()); } catch (ClientException ce) { System.out.println("Caught an ClientException, which means the client encountered " + "a serious internal problem while trying to communicate with OSS, " + "such as not being able to access the network."); System.out.println("Error Message:" + ce.getMessage()); } finally { if (ossClient != null) { ossClient.shutdown(); } } //文件访问路径规则 https://BucketName.Endpoint/ObjectName StringBuilder stringBuilder = new StringBuilder("https://"); stringBuilder .append(bucketName) .append(".") .append(endpoint) .append("/") .append(objectName); log.info("文件上传到:{}", stringBuilder.toString()); return stringBuilder.toString(); } } 自己搭建FileBrowser存储 public class FileBrowserUtil { private String domain; private String username; private String password; /** * —— 第一步：登录拿 token —— * 调用 /api/login 接口，返回纯 JWT 字符串，或 {"token":"..."} 结构 */ public String login() throws IOException { String url = domain + "/api/login"; try (CloseableHttpClient client = HttpClients.createDefault()) { HttpPost post = new HttpPost(url); post.setHeader("Content-Type", "application/json"); // 构造登录参数 JSONObject cred = new JSONObject(); cred.put("username", username); cred.put("password", password); post.setEntity(new StringEntity(cred.toString(), StandardCharsets.UTF_8)); try (CloseableHttpResponse resp = client.execute(post)) { int status = resp.getStatusLine().getStatusCode(); String body = EntityUtils.toString(resp.getEntity(), StandardCharsets.UTF_8).trim(); if (status >= 200 && status < 300) { // 如果返回 JSON 对象，则解析出 token 字段 if (body.startsWith("{") && body.endsWith("}")) { JSONObject obj = JSONObject.parseObject(body); String token = obj.getString("token"); log.info("登录成功，token={}", token); return token; } // 否则直接当成原始 JWT 返回 log.info("登录成功，token={}", body); return body; } else { log.error("Login failed: HTTP {} - {}", status, body); throw new IOException("Login failed: HTTP " + status); } } } } /** * —— 第二步：上传文件 —— * POST {domain}/api/resources/{encodedPath}?override=true * Header: X-Auth: token */ public String uploadFile(byte[] fileBytes, String fileName) throws IOException { String token = login(); String remotePath = "store/" + fileName; String encodedPath = URLEncoder .encode(remotePath, StandardCharsets.UTF_8) .replace("%2F", "/"); // 根据后缀猜 MIME 类型 String mimeType = URLConnection.guessContentTypeFromName(fileName); if (mimeType == null) { mimeType = "application/octet-stream"; } String uploadUrl = domain + "/api/resources/" + encodedPath + "?override=true"; try (CloseableHttpClient client = HttpClients.createDefault()) { HttpPost post = new HttpPost(uploadUrl); post.setHeader("X-Auth", token); post.setEntity(new ByteArrayEntity(fileBytes, ContentType.create(mimeType))); try (CloseableHttpResponse resp = client.execute(post)) { int status = resp.getStatusLine().getStatusCode(); String respBody = EntityUtils.toString(resp.getEntity(), StandardCharsets.UTF_8); if (status < 200 || status >= 300) { log.error("文件上传失败: HTTP {} - {}", status, respBody); throw new IOException("Upload failed: HTTP " + status); } log.info("文件上传成功，remotePath={}", remotePath); return remotePath; } } } /** * 第三步：生成公开分享链接 * 模拟浏览器的 POST /api/share/{encodedPath} 请求，body 为 "{}" */ public String createShareLink(String remotePath) throws IOException { String token = login(); // URL encode 并保留斜杠 String encodedPath = URLEncoder .encode(remotePath, StandardCharsets.UTF_8) .replace("%2F", "/"); String shareUrl = domain + "/api/share/" + encodedPath; log.info("准备创建分享链接，POST {}", shareUrl); try (CloseableHttpClient client = HttpClients.createDefault()) { HttpPost post = new HttpPost(shareUrl); post.setHeader("Cookie", "auth=" + token); post.setHeader("X-Auth", token); post.setHeader("Content-Type", "text/plain;charset=UTF-8"); post.setEntity(new StringEntity("{}", StandardCharsets.UTF_8)); try (CloseableHttpResponse resp = client.execute(post)) { int status = resp.getStatusLine().getStatusCode(); String body = EntityUtils.toString(resp.getEntity(), StandardCharsets.UTF_8).trim(); if (status < 200 || status >= 300) { log.error("创建分享失败 HTTP {} - {}", status, body); throw new IOException("Share failed: HTTP " + status); } // ========= 这里改为先检测是对象还是数组 ========= JSONObject json; if (body.startsWith("[")) { // 如果真返回数组（老版本可能是 [{...}]） json = JSONArray.parseArray(body).getJSONObject(0); } else if (body.startsWith("{")) { // 当前版本直接返回对象 json = JSONObject.parseObject(body); } else { throw new IOException("Unexpected share response: " + body); } String hash = json.getString("hash"); String publicUrl = domain + "/api/public/dl/" + hash + "/" + remotePath; log.info("创建分享链接成功：{}", publicUrl); return publicUrl; } } } /** * —— 整合示例：上传并立即返回分享链接 —— */ public String uploadAndGetUrl(byte[] fileBytes, String fileName) throws IOException { String remotePath = uploadFile(fileBytes, fileName); return createShareLink(remotePath); } } 数据库密码加密 加密存储确保即使数据库泄露，攻击者也不能轻易获取用户原始密码。 spring security中提供了一个加密类BCryptPasswordEncoder。 它采用哈希算法 SHA-256 +随机盐+密钥对密码进行加密。加密算法是一种可逆的算法，而哈希算法是一种不可逆的算法。 因为有随机盐的存在，所以相同的明文密码经过加密后的密码是不一样的，盐在加密的密码中是有记录的，所以需要对比的时候，springSecurity是可以从中获取到盐的 添加 spring-security-crypto 依赖,无需引入Spring Security 的认证、授权、过滤器链等其它安全组件！ <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-crypto</artifactId> </dependency> 添加配置 @Configuration public class SecurityConfig { @Bean public PasswordEncoder passwordEncoder() { // 参数 strength 为工作因子，默认为 10，这里可以根据需要进行调整 return new BCryptPasswordEncoder(10); } } 用户注册、加密 encode @Autowired private PasswordEncoder passwordEncoder; // 对密码进行加密 String encodedPassword = passwordEncoder.encode(rawPassword); 验证密码 matches // 使用 matches 方法来对比明文密码和存储的哈希密码 boolean judge= passwordEncoder.matches(rawPassword, user.getPassword()); BaseContext 如何获得当前登录的用户id？ 方法：ThreadLocal ThreadLocal为每个线程提供单独一份存储空间，具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问。 每次请求代表一个线程！！！注：请求可以先经过拦截器，再经过controller=>service=>mapper,都是在一个线程里。而即使同一个用户，先用两次请求/login、 /upload，它们也不处于同一线程中！ public class BaseContext { public static ThreadLocal<Long> threadLocal = new ThreadLocal<>(); public static void setCurrentId(Long id) { threadLocal.set(id); } public static Long getCurrentId() { return threadLocal.get(); } public static void removeCurrentId() { threadLocal.remove(); } } 实现方式：登录成功 -> 生成jwt令牌 (claims中存userId)->前端浏览器保存 后续每次请求携带jwt -> 拦截器检查jwt令牌 -> BaseContext.setCurrentId(jwt中取出的userId); -> BaseContext.getCurrentId(); //service层中获取当前userId 全局异常处理 新增员工时的问题 录入的用户名已存，抛出的异常后没有处理。 法一：每次新增员工前查询一遍数据库，保证无重复username再插入。 法二：插入后系统报“Duplicate entry”再处理。 「乐观策略」减少不必要的查询，只有在冲突时才抛错。 解决方法：定义全局异常处理器 @RestControllerAdvice @Slf4j public class GlobalExceptionHandler { /** * 捕获业务异常 * @param ex * @return */ @ExceptionHandler public Result exceptionHandler(BaseException ex){ log.error("异常信息：{}", ex.getMessage()); return Result.error(ex.getMessage()); } @ExceptionHandler public Result exceptionHandler(SQLIntegrityConstraintViolationException ex){ //Duplicate entry 'zhangsan' for key 'employee.idx_username' String message = ex.getMessage(); log.info(message); if(message.contains("Duplicate entry")){ String[] split = message.split(" "); String username = split[2]; String msg = username + MessageConstant.ALREADY_EXISTS; return Result.error(msg); }else{ return Result.error(MessageConstant.UNKNOWN_ERROR); } } } SQLIntegrityConstraintViolationException用来捕获各种 完整性约束冲突，如唯一／主键约束冲突（向一个设置了 UNIQUE 或者 PRIMARY KEY 的字段重复插入相同的值。）。可以捕捉username重复异常。并以Result.error(msg)返回通用响应。 另外，自定义一个异常BaseException与若干个业务层异常， public class BaseException extends RuntimeException { public BaseException() { } public BaseException(String msg) { super(msg); } } 业务层抛异常： throw new AccountLockedException(MessageConstant.ACCOUNT_LOCKED); 这样抛出异常之后可以被全局异常处理器 exceptionHandler(BaseException ex) 捕获。 SpringMVC的消息转换器(处理日期) Jackson 是一个用于处理 JSON 数据 的流行 Java 库，主要用于： 序列化：将 Java 对象转换为 JSON 字符串（例如：Java对象 → {"name":"Alice"}）。Controller 返回值上带有 @ResponseBody 或者使用 @RestController 反序列化：将 JSON 字符串解析为 Java 对象（例如：{"name":"Alice"} → Java对象）。方法参数上标注了 @RequestBody Spring Boot默认集成了Jackson 1). 方式一 在属性上加上注解，对日期进行格式化 但这种方式，需要在每个时间属性上都要加上该注解，使用较麻烦，不能全局处理。 2). 方式二（推荐 ) 在WebMvcConfiguration中扩展SpringMVC的消息转换器，统一对LocalDateTime、LocalDate、LocalTime进行格式处理 /** * 扩展Spring MVC框架的消息转化器 * @param converters */ protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) { log.info("扩展消息转换器..."); //创建一个消息转换器对象 MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter(); //需要为消息转换器设置一个对象转换器，对象转换器可以将Java对象序列化为json数据 converter.setObjectMapper(new JacksonObjectMapper()); //将自己的消息转化器加入容器中,确保覆盖默认的 Jackson 行为 converters.add(0,converter); } JacksonObjectMapper()文件： //直接复用 Jackson 的核心功能，仅覆盖或扩展特定行为。 public class JacksonObjectMapper extends ObjectMapper { public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd"; //LocalDate public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss"; //LocalDateTime // public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm"; public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss"; //LocalTime public JacksonObjectMapper() { super(); //收到未知属性时不报异常 this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false); //反序列化时，属性不存在的兼容处理 this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); SimpleModule simpleModule = new SimpleModule() .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT))) .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT))) .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT))) .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT))) .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT))) .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT))); //注册功能模块 例如，可以添加自定义序列化器和反序列化器 this.registerModule(simpleModule); } } 数据库操作代码复用 为提高代码复用率，在 Mapper 层统一定义一个通用的 update 方法，利用 MyBatis 的动态 SQL，根据传入的 Employee 对象中非空字段生成对应的 SET 子句。这样： 启用/禁用员工：只需在业务层调用（如 startOrStop），传入带有 id 和 status 的 Employee 实例，底层自动只更新 status 字段。 更新员工信息：调用（如 updateEmployee）时，可传入包含多个属性的 Employee 实例，自动更新那些非空字段。 Controller 层和 Service 层的方法命名可根据不同业务场景进行区分，底层均复用同一个 update方法 在 EmployeeMapper 接口中声明 update 方法： /** * 根据主键动态修改属性 * @param employee */ void update(Employee employee); 在 EmployeeMapper.xml 中编写SQL： <update id="update" parameterType="Employee"> update employee <set> <if test="name != null">name = #{name},</if> <if test="username != null">username = #{username},</if> <if test="password != null">password = #{password},</if> <if test="phone != null">phone = #{phone},</if> <if test="sex != null">sex = #{sex},</if> <if test="idNumber != null">id_Number = #{idNumber},</if> <if test="updateTime != null">update_Time = #{updateTime},</if> <if test="updateUser != null">update_User = #{updateUser},</if> <if test="status != null">status = #{status},</if> </set> where id = #{id} </update> 操作多表时的规范操作 功能：实现批量删除套餐操作，只能删除'非起售中'的套餐，关联表有套餐表和套餐菜品表。 代码1： @Transactional public void deleteBatch(Long[] ids) { for(Long id:ids){ Setmeal setmeal = setmealMapper.getById(id); if(StatusConstant.ENABLE == setmeal.getStatus()){ //起售中的套餐不能删除 throw new DeletionNotAllowedException(MessageConstant.SETMEAL_ON_SALE); } else{ Long setmealId=id; setmealMapper.deleteById(id); setmeal_dishMapper.deleteByDishId(id); } } } 代码2： @Transactional public void deleteBatch(List<Long> ids) { ids.forEach(id -> { Setmeal setmeal = setmealMapper.getById(id); if (StatusConstant.ENABLE == setmeal.getStatus()) { //起售中的套餐不能删除 throw new DeletionNotAllowedException(MessageConstant.SETMEAL_ON_SALE); } }); ids.forEach(setmealId -> { //删除套餐表中的数据 setmealMapper.deleteById(setmealId); //删除套餐菜品关系表中的数据 setmealDishMapper.deleteBySetmealId(setmealId); }); } 代码2更好，因为： 1.把「验证」逻辑和「删除」逻辑分成了两段，职责更单一，读代码的时候一目了然 2.避免不必要的删除操作，第一轮只做 getById 校验，碰到 起售中 马上抛异常，从不执行任何删除 SQL，效率更高。 @Transactional 最典型的场景就是：在同一个业务方法里要执行多条数据库操作（增删改），而且这些操作必须保证“要么都成功、要么都失败” 时，用它来把这些 SQL 语句包裹在同一个事务里，遇到运行时异常就回滚，避免出现“删到一半、中途抛错”导致的数据不一致。也就是说，同时操作多表时，都在方法上加下这个注解！ 公共字段自动填充——AOP编程 在数据库操作中，通常需要为某些公共字段（如创建时间、更新时间等）自动赋值。采用AOP： 统一管理这些字段的赋值逻辑 避免在业务代码中重复设置 确保数据一致性 序号 字段名 含义 数据类型 操作类型 1 create_time 创建时间 datetime insert 2 create_user 创建人id bigint insert 3 update_time 修改时间 datetime insert、update 4 update_user 修改人id bigint insert、update 实现步骤： 1). 自定义注解 AutoFill，用于标识需要进行公共字段自动填充的方法 2). 自定义切面类 AutoFillAspect，统一拦截加入了 AutoFill 注解的方法，通过反射为公共字段赋值 客户端 → Service → Mapper接口方法（带@AutoFill） ↓ 切面触发 Before 通知（AutoFillAspect.autoFill） [1] 读取注解，确定 INSERT/UPDATE [2] 从 BaseContext 拿到 currentId [3] 反射调用 entity.setXxx() ↓ 切面执行完毕，回到原方法 Mapper 执行动态 SQL，将已填充的字段写入数据库 3). 在 需要统一填充的Mapper 的方法上加入 AutoFill 注解 **技术点：**枚举、注解、AOP、反射 HttpClient HttpClient作用： 在Java程序中发送HTTP请求 接收响应数据 HttpClient的maven坐标： <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.13</version> </dependency> HttpClient的核心API： HttpClient：Http客户端对象类型，使用该类型对象可发起Http请求。 HttpClients：可认为是构建器，可创建HttpClient对象。 CloseableHttpClient：实现类，实现了HttpClient接口。 HttpGet：Get方式请求类型。 HttpPost：Post方式请求类型。 HttpClient发送请求步骤： 创建HttpClient对象 创建Http请求对象 调用HttpClient的execute方法发送请求 快速入门 @SpringBootTest public class HttpClientTest { /** * 测试通过httpclient发送GET方式的请求 */ @Test public void testGET() throws Exception{ //创建httpclient对象 CloseableHttpClient httpClient = HttpClients.createDefault(); //创建请求对象 HttpGet httpGet = new HttpGet("http://localhost:8080/user/shop/status"); //发送请求，接受响应结果 CloseableHttpResponse response = httpClient.execute(httpGet); //获取服务端返回的状态码 int statusCode = response.getStatusLine().getStatusCode(); System.out.println("服务端返回的状态码为：" + statusCode); HttpEntity entity = response.getEntity(); String body = EntityUtils.toString(entity); System.out.println("服务端返回的数据为：" + body); //关闭资源 response.close(); httpClient.close(); } @Test public void testPOST() throws Exception{ // 创建httpclient对象 CloseableHttpClient httpClient = HttpClients.createDefault(); //创建请求对象 HttpPost httpPost = new HttpPost("http://localhost:8080/admin/employee/login"); JSONObject jsonObject = new JSONObject(); jsonObject.put("username","admin"); jsonObject.put("password","123456"); StringEntity entity = new StringEntity(jsonObject.toString()); //指定请求编码方式 entity.setContentEncoding("utf-8"); //数据格式 entity.setContentType("application/json"); httpPost.setEntity(entity); //发送请求 CloseableHttpResponse response = httpClient.execute(httpPost); //解析返回结果 int statusCode = response.getStatusLine().getStatusCode(); System.out.println("响应码为：" + statusCode); HttpEntity entity1 = response.getEntity(); String body = EntityUtils.toString(entity1); System.out.println("响应数据为：" + body); //关闭资源 response.close(); httpClient.close(); } } 使用时将GET POST方法单独封装到HttpClient工具类中，Service层中直接使用工具类，传入需要的请求体即可。 微信小程序 步骤分析： 小程序端，调用wx.login()获取code，就是授权码。 小程序端，调用wx.request()发送请求并携带code，请求开发者服务器(自己编写的后端服务)。 开发者服务端，通过HttpClient向微信接口服务发送请求，并携带appId+appsecret+code三个参数。 开发者服务端，接收微信接口服务返回的数据，session_key+opendId等。opendId是微信用户的唯一标识。 开发者服务端，自定义登录态，生成令牌token和openid等数据返回给小程序端，方便后绪请求身份校验。 小程序端，收到自定义登录态，存储storage。 小程序端，后绪通过wx.request()发起业务请求时，携带token。 开发者服务端，收到请求后，通过携带的token，解析当前登录用户的id（无需获取openid，因为token中存了userid可以确认用户身份）。 开发者服务端，身份校验通过后，继续相关的业务逻辑处理，最终返回业务数据。 缓存功能 用户端小程序展示的菜品数据都是通过查询数据库获得，如果用户端访问量比较大，数据库访问压力随之增大。 实现思路 通过Redis来缓存菜品数据，减少数据库查询操作。 经典缓存实现代码 缓存逻辑分析： 每个分类下的菜品保存一份缓存数据 数据库中菜品数据有变更时清理缓存数据 @Autowired private RedisTemplate redisTemplate; /** * 根据分类id查询菜品 * * @param categoryId * @return */ @GetMapping("/list") @ApiOperation("根据分类id查询菜品") public Result<List<DishVO>> list(Long categoryId) { //构造redis中的key，规则：dish_分类id String key = "dish_" + categoryId; //查询redis中是否存在菜品数据 List<DishVO> list = (List<DishVO>) redisTemplate.opsForValue().get(key); if(list != null && list.size() > 0){ //如果存在，直接返回，无须查询数据库 return Result.success(list); } //////////////////////////////////////////////////////// Dish dish = new Dish(); dish.setCategoryId(categoryId); dish.setStatus(StatusConstant.ENABLE);//查询起售中的菜品 //如果不存在，查询数据库，将查询到的数据放入redis中 list = dishService.listWithFlavor(dish); //////////////////////////////////////////////////////// redisTemplate.opsForValue().set(key, list); return Result.success(list); } 为了保证数据库和Redis中的数据保持一致，修改管理端接口 DishController 的相关方法，加入清理缓存逻辑。 需要改造的方法： 新增菜品 修改菜品 批量删除菜品 起售、停售菜品 清理缓冲方法： private void cleanCache(String pattern){ Set keys = redisTemplate.keys(pattern); redisTemplate.delete(keys); } Spring Cache框架实现缓存 Spring Cache 是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> <version>2.7.3</version> </dependency> 在SpringCache中提供了很多缓存操作的注解，常见的是以下的几个： 注解 说明 @EnableCaching 开启缓存注解功能，通常加在启动类上 @Cacheable 在方法执行前先查询缓存中是否有数据，如果有数据，则直接返回缓存数据(取）；如果没有缓存数据，调用方法并将方法返回值放到缓存中 @CachePut 将方法的返回值放到缓存中 @CacheEvict 将一条或多条数据从缓存中删除 1）@CachePut 说明： 作用: 将方法返回值，放入缓存 value: 缓存的名称, 每个缓存名称下面可以有很多key key: 缓存的key ----------> 支持Spring的表达式语言SPEL语法 value 和 cacheNames 属性在用法上是等效的。它们都用来指定缓存区的名称 在Redis中并没有直接的“缓存名”概念，而是通过键（key）来访问数据。Spring Cache通过cacheNames属性来模拟不同的“缓存区”，实际上这是通过将这些名称作为键的一部分来实现的。例如，如果你有一个缓存名为 userCache，那么所有相关的缓存条目的键可能以 "userCache::" 开头。 在save方法上加注解@CachePut @PostMapping @CachePut(value = "userCache", key = "#user.id")//key的生成：userCache::1 public User save(@RequestBody User user){ userMapper.insert(user); return user; } **说明：**key的写法如下 #user.id : #user指的是方法形参的名称, id指的是user的id属性 , 也就是使用user的id属性作为key ; #result.id : #result代表方法返回值，该表达式 代表以返回对象的id属性作为key ； 2）@Cacheable 说明: 作用: 在方法执行前，spring先查看缓存中是否有指定的key的数据，如果有数据，则直接返回缓存数据，不执行后续sql操作；若没有数据，调用方法并将方法返回值放到缓存中。 在getById上加注解@Cacheable @GetMapping @Cacheable(cacheNames = "userCache",key="#id") public User getById(Long id){ User user = userMapper.getById(id); return user; } 3）@CacheEvict 说明： 作用: 清理指定缓存 在 delete 方法上加注解@CacheEvict @DeleteMapping @CacheEvict(cacheNames = "userCache",key = "#id")//删除某个key对应的缓存数据 public void deleteById(Long id){ userMapper.deleteById(id); } @DeleteMapping("/delAll") @CacheEvict(cacheNames = "userCache",allEntries = true)//删除userCache下所有的缓存数据 public void deleteAll(){ userMapper.deleteAll(); } **总结：**新增数据的时候->添加缓存@CachePut ; 查询的时候->判断有无缓存@Cacheable; 删除的时候->删除缓存@CacheEvict。 Spring Cache是经典缓存的上位替代！！！ 注意，如果缓存的是套餐分类，即一个套餐分类中含有多个套餐，那么在新增套餐的时候，需要清除相应的套餐分类缓存，因为当你新增一个属于分类 5 的套餐时，原来缓存里那份「分类 5 的列表」已经不再完整──它少了新加的那个套餐。 但是如果缓存的就是套餐本身，新增套餐的时候就可以直接缓存套餐。不要混淆两者！ 下单支付 下单 表名 含义 说明 orders 订单表 主要存储订单的基本信息(如: 订单号、状态、金额、支付方式、下单用户、收件地址等) order_detail 订单明细表 主要存储订单详情信息(如: 该订单关联的套餐及菜品的信息) 微信支付 官方文档：https://pay.weixin.qq.com/static/product/product_index.shtml 商户系统调用微信后台： **JSAPI下单：**商户系统调用该接口在微信支付服务后台生成预支付交易单(对应时序图的第5步) 微信小程序调起支付： 通过JSAPI下单接口获取到发起支付的必要参数prepay_id，然后使用微信支付提供的小程序方法调起小程序支付(对应时序图的第10步) 内网穿透 微信后台会调用到商户系统给推送支付的结果，在这里我们就会遇到一个问题，就是微信后台怎么就能调用到我们这个商户系统呢？因为这个调用过程，其实本质上也是一个HTTP请求。 目前，商户系统它的ip地址就是当前自己电脑的ip地址，只是一个局域网内的ip地址，微信后台无法调用到。 解决：内网穿透。通过cpolar软件可以获得一个临时域名，而这个临时域名是一个公网ip，这样，微信后台就可以请求到商户系统了。 1)下载地址：https://dashboard.cpolar.com/get-started 2). cpolar指定authtoken 复制authtoken： 执行命令： 注意，cd到cpolar.exe所在的目录打开cmd 输入代码： cpolar.exe authtoken ZmIwMmQzZDYtZDE2ZS00ZGVjLWE2MTUtOGQ0YTdhOWI2M2Q1 3）获取临时域名 cpolar.exe http 8080 这里的 https://52ac2ecb.r18.cpolar.top 就是与http://localhost:8080对应的临时域名。 原理： 客户端向 cpolar 的中转节点发起 出站（outbound）连接，完成身份认证（authtoken），并在连接上报出要映射的本地端口，比如 HTTP 的 8080 中转节点分配一个公网端点，如abcd1234.cpolar.com 外部用户 访问 http://abcd1234.cpolar.com，落到 cpolar 的中转节点，中转节点 通过先前建立好的持久隧道，把流量转发到你本地运行的客户端。 百度地址解析 优化用户下单功能，加入校验逻辑，如果用户的收货地址距离商家门店超出配送范围（配送范围为5公里内），则下单失败。 思路： 1. 基于百度地图开放平台实现（https://lbsyun.baidu.com/） 2. 注册账号--->创建应用获取AK(服务端应用)--->调用接口 相关接口 https://lbsyun.baidu.com/index.php?title=webapi/guide/webservice-geocoding https://lbsyun.baidu.com/index.php?title=webapi/directionlite-v1 商家门店地址可以配置在配置文件中，例如： sky: shop: address: 湖北省武汉市洪山区武汉理工大学 baidu: ak: ${sky.baidu.ak} Spring Task Spring Task 是Spring框架提供的任务调度工具，可以按照约定的时间自动执行某个代码逻辑。 **定位：**定时任务框架 **作用：**定时自动执行某段Java代码 cron表达式 cron表达式其实就是一个字符串，通过cron表达式可以定义任务触发的时间 **构成规则：**分为6或7个域，由空格分隔开，每个域代表一个含义 每个域的含义分别为：秒、分钟、小时、日、月、周、年(可选) 通配符： * 表示所有值； ? 表示未说明的值，即不关心它为何值； - 表示一个指定的范围； , 表示附加一个可能值； / 符号前表示开始时间，符号后表示每次递增的值； cron表达式案例： */5 * * * * ? 每隔5秒执行一次 0 0 5-15 * * ? 每天5-15点整点触发 0 0/3 * * * ? 每三分钟触发一次 0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟触发 0 10/5 14 * * ? 在每天下午2点10分到下午2:55期间的每5分钟触发 0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时 0 0 10,14,16 * * ? 每天上午10点，下午2点，4点 cron表达式在线生成器：https://cron.qqe2.com/ 现在可以直接GPT生成！ 入门案例 Spring Task使用步骤 1). 导入maven坐标 spring-context（Spring Boot Starter已包含，无需导入！） 2). 启动类添加注解 @EnableScheduling 开启任务调度 3). 自定义定时任务类,然后只要在方法上标注 @Scheduled(cron = xxx) @Slf4j @Component public class MyTask { //定时任务 每隔5秒触发一次 @Scheduled(cron = "0/5 * * * * ?") public void executed(){ log.info("定時任務開始執行:{}",new Date()); } } 订单状态定时处理 用户下单后可能存在的情况： 下单后未支付，订单一直处于**“待支付”**状态 用户收货后管理端未点击完成按钮，订单一直处于**“派送中”**状态 对于上面两种情况需要通过定时任务来修改订单状态，具体逻辑为： 通过定时任务每分钟检查一次是否存在支付超时订单（下单后超过15分钟仍未支付则判定为支付超时订单），如果存在则修改订单状态为“已取消” 通过定时任务每天凌晨1点（打烊后）检查一次是否存在“派送中”的订单，如果存在则修改订单状态为“已完成” Websocket WebSocket 是基于 TCP 的一种新的网络协议。它实现了浏览器与服务器全双工通信——浏览器和服务器只需要完成一次握手，两者之间就可以创建持久性的连接， 并进行双向数据传输。 HTTP协议和WebSocket协议对比： HTTP是短连接 WebSocket是长连接 HTTP通信是单向的，基于请求响应模式 WebSocket支持双向通信 HTTP和WebSocket底层都是TCP连接 工作流程： 1.握手（Handshake） 客户端发起一个特殊的 HTTP 请求（带有 Upgrade: websocket 和 Connection: Upgrade 头） 服务端如果支持 WebSocket，则返回 HTTP 101 Switching Protocols，双方在同一个 TCP 连接上切换到 WebSocket 协议 2.数据帧交换 握手成功后，客户端和服务端可以互相推送（push）“数据帧”（Frame），不再有 HTTP 的请求／响应模型 3.关闭连接 任一端发送关闭控制帧（Close Frame），对方确认后关闭 TCP 连接 WebSocket应用场景： 视频弹幕、实时聊天、体育实况更新、股票基金实时更新报价 入门案例 实现步骤： 1). 直接使用websocket.html页面作为WebSocket客户端 http://localhost:8080/ws/12345 最主要的是建立websocket连接！ 2). 导入WebSocket的maven坐标 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 3). 导入WebSocket服务端组件WebSocketServer，用于和客户端通信（比较固定，建立连接、接收消息、关闭连接、发送消息） 基于 JSR-356（Java WebSocket API） 的“注解型”实现 @ServerEndpoint("/ws/{sid}") 来声明一个 WebSocket 端点，容器（如 Tomcat/Jetty）或 Spring 的 ServerEndpointExporter 会扫描并注册它。 @OnOpen、@OnMessage、@OnClose、@OnError 等标注的方法，分别对应连接建立、收到消息、连接关闭和出错时的回调。 /** * WebSocket服务 */ @Component @ServerEndpoint("/ws/{sid}") public class WebSocketServer { //存放会话对象 private static Map<String, Session> sessionMap = new HashMap(); /** * 连接建立成功调用的方法 */ @OnOpen public void onOpen(Session session, @PathParam("sid") String sid) { System.out.println("客户端：" + sid + "建立连接"); sessionMap.put(sid, session); } /** * 收到客户端消息后调用的方法 * * @param message 客户端发送过来的消息 */ @OnMessage public void onMessage(String message, @PathParam("sid") String sid) { System.out.println("收到来自客户端：" + sid + "的信息:" + message); } /** * 连接关闭调用的方法 * * @param sid */ @OnClose public void onClose(@PathParam("sid") String sid) { System.out.println("连接断开:" + sid); sessionMap.remove(sid); } /** * 群发 * * @param message */ public void sendToAllClient(String message) { Collection<Session> sessions = sessionMap.values(); for (Session session : sessions) { try { //服务器向客户端发送消息 session.getBasicRemote().sendText(message); } catch (Exception e) { e.printStackTrace(); } } } } 4). 导入配置类WebSocketConfiguration，注册WebSocket的服务端组件 /** * WebSocket配置类，用于注册WebSocket的Bean */ @Configuration public class WebSocketConfiguration { @Bean public ServerEndpointExporter serverEndpointExporter() { return new ServerEndpointExporter(); } } 作用：找到@ServerEndpoint 的类并注册到容器中。 5). 导入定时任务类WebSocketTask，定时向客户端推送数据 @Component public class WebSocketTask { @Autowired private WebSocketServer webSocketServer; /** * 通过WebSocket每隔5秒向客户端发送消息 */ @Scheduled(cron = "0/5 * * * * ?") public void sendMessageToClient() { webSocketServer.sendToAllClient("这是来自服务端的消息：" + DateTimeFormatter.ofPattern("HH:mm:ss").format(LocalDateTime.now())); } } 这里可以改为来单提醒、催单提醒。 来单提醒 设计思路： 通过WebSocket实现管理端页面和服务端保持长连接状态 当客户支付后，调用WebSocket的相关API实现服务端向客户端推送消息 客户端浏览器解析服务端推送的消息，判断是来单提醒还是客户催单，进行相应的消息提示和语音播报 约定服务端发送给客户端浏览器的数据格式为JSON，字段包括：type，orderId，content type 为消息类型，1为来单提醒 2为客户催单 orderId 为订单id content 为消息内容 数据展示与处理 数据展示 Apache ECharts 是一款基于 Javascript 的数据可视化图表库，提供直观，生动，可交互，可个性化定制的数据可视化图表。 官网地址：https://echarts.apache.org/zh/index.html 例：营业额统计 具体返回数据一般由前端来决定，前端展示图表，折线图对应数据是什么格式，是有固定的要求的。所以说，后端需要去适应前端，它需要什么格式的数据，后端就返回什么格式的数据。 导出数据到Excel Apache POI 我们可以使用 POI 在 Java 程序中对Miscrosoft Office各种文件进行读写操作。一般情况下，POI 都是用于操作 Excel 文件。 Apache POI的maven坐标 <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>3.16</version> </dependency> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi-ooxml</artifactId> <version>3.16</version> </dependency> 实现步骤： 1). 设计Excel模板文件！ 2). 查询近30天的运营数据 3). 将查询到的运营数据写入模板文件 row = sheet.getRow(7 + i); //获取行 row.getCell(1).setCellValue(date.toString()); //获取该行的某列，并设值。 4). 通过输出流将Excel文件下载到客户端浏览器
项目
zy123
3月21日
0
27
0
上一页
1
2
