zy123 发布的文章 - 第 8 页 - 咕咕鸽爱学习

登录

找到 46 篇与 zy123 相关的结果 - 第 8 页

2025-03-21
test int main(){ return 0; } 一级标题：# xx 二级标题：## xx 无序列表：- xx 1 2 有序列表：1. xx first second 任务列表：- [ ] xx xx xxx 斜体：星号xx星号斜体加粗：星号星号xx星号星号加粗删除：波浪线波浪线xx波浪线波浪线删除分割线：--- $$ \frac{\partial f}{\partial x}=2\sqrt{a}x $$ 注释：百度 [谷歌][id] [id]: google.com ""谷歌"" [请参考标题一](#一级标题：# xx )

自学

zy123 3月21日
0 0 0
2025-03-21
招标文件解析产品官网：智标领航 - 招投标AI解决方案产品后台：https://intellibid.cn:9091/login?redirect=%2Findex 项目地址：zy123/zbparse - zbparse - 智标领航代码仓库 git clone地址：http://47.98.59.178:3000/zy123/zbparse.git 选择develop分支，develop-xx 后面的xx越近越新。正式环境：121.41.119.164:5000 测试环境：47.98.58.178:5000 大解析：指从招标文件解析入口进去，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 2 0
2025-03-21
微服务微服务 Mybatis-Plus 快速开始 1.引入依赖 <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.3.1</version> </dependency> 由于这个starter包含对mybatis的自动装配，因此完全可以替换掉Mybatis的starter。 2.定义mapper 修改mp-demo中的com.itheima.mp.mapper包下的UserMapper接口，让其继承BaseMapper： public interface UserMapper extends BaseMapper<User> { } MybatisPlus如何知道我们要查询的是哪张表？表中有哪些字段呢？约定大于配置泛型中的User就是与数据库对应的PO. MybatisPlus就是根据PO实体的信息来推断出表的信息，从而生成SQL的。默认情况下： MybatisPlus会把PO实体的类名驼峰转下划线作为表名 MybatisPlus会把PO实体的所有变量名驼峰转下划线作为表的字段名，并根据变量类型推断字段类型 MybatisPlus会把名为id的字段作为主键但很多情况下，默认的实现与实际场景不符，因此MybatisPlus提供了一些注解便于我们声明表信息。 3.常见注解 @TableName 描述：表名注解，标识实体类对应的表使用位置：实体类 @TableName("user") public class User { private Long id; private String name; } @TableId 描述：主键注解，标识实体类中的主键字段使用位置：实体类的主键字段 TableId注解支持两个属性：属性类型必须指定默认值描述 value String 否 "" 主键字段名 type Enum 否 IdType.NONE 指定主键类型 @TableName("user") public class User { @TableId(value="id",type=IdType.AUTO) private Long id; private String name; } 必须指定type=IdType.AUTO，默认是雪花算法算出一个随机的id（插入操作时） @TableField 一般情况下我们并不需要给字段添加@TableField注解，一些特殊情况除外：成员变量名与数据库字段名不一致成员变量是以isXXX命名，按照JavaBean的规范，MybatisPlus识别字段时会把is去除，这就导致与数据库不符。成员变量名与数据库一致，但是与数据库的**关键字(如order)**冲突。使用@TableField注解给字段名添加转义字符：```` 支持的其它属性如下： exist:默认为true，表示是数据库字段，若 @TableField(exist=false) private String address; 将自动跳过address的增删查改，因为它不被视为字段。 @TableName("user") public class User { @TableId private Long id; private String name; private Integer age; @TableField("isMarried") private Boolean isMarried; @TableField("`order`") private String order; } 常见配置大多数的配置都有默认值，因此我们都无需配置。但还有一些是没有默认值的，例如: 实体类的别名扫描包全局id类型要改也就改这两个即可 mybatis-plus: type-aliases-package: com.itheima.mp.domain.po global-config: db-config: id-type: auto # 全局id类型为自增长核心功能条件构造器除了新增以外，修改、删除、查询的SQL语句都需要指定where条件。因此BaseMapper中提供的相关方法除了以id作为where条件以外，还支持更加复杂的where条件。 Wrapper就是条件构造的抽象类，其下有很多默认实现，继承关系如图： QueryWrapper /**查询出名字中带o的，存款大于等于1000元的人的id，username,info,balance * SELECT id,username,info,balance * FROM user * WHERE username LIKE ? AND balance >=? */ @Test void testQueryWrapper(){ QueryWrapper<User> wrapper =new QueryWrapper<User>() .select("id","username","info","balance") .like("username","o") .ge("balance",1000); //查询 List<User> users=userMapper.selectList(wrapper); users.forEach(System.out::println); } //更新用户名为jack的用户的余额为2000 @Test void testUpdateByQueryWrapper() { // 1.构建查询条件 where name = "Jack" QueryWrapper<User> wrapper = new QueryWrapper<User>().eq("username", "Jack"); // 2.更新数据，user中非null字段都会作为set语句 User user = new User(); user.setBalance(2000); userMapper.update(user, wrapper); } UpdateWrapper 基于BaseMapper中的update方法更新时只能直接赋值，对于一些复杂的需求就难以实现。例如：更新id为1,2,4的用户的余额，扣200，对应的SQL应该是： UPDATE user SET balance = balance - 200 WHERE id in (1, 2, 4) @Test void testUpdateWrapper() { List<Long> ids = List.of(1L, 2L, 4L); // 1.生成SQL UpdateWrapper<User> wrapper = new UpdateWrapper<User>() .setSql("balance = balance - 200") // SET balance = balance - 200 .in("id", ids); // WHERE id in (1, 2, 4) // 2.更新，注意第一个参数可以给null，也就是不填更新字段和数据， // 而是基于UpdateWrapper中的setSQL来更新 userMapper.update(null, wrapper); } LambdaQueryWrapper 无论是QueryWrapper还是UpdateWrapper在构造条件的时候都需要写死字段名称，会出现字符串魔法值。这在编程规范中显然是不推荐的。那怎么样才能不写字段名，又能知道字段名呢？其中一种办法是基于变量的gettter方法结合反射技术。因此我们只要将条件对应的字段的getter方法传递给MybatisPlus，它就能计算出对应的变量名了。而传递方法可以使用JDK8中的方法引用和Lambda表达式。因此MybatisPlus又提供了一套基于Lambda的Wrapper，包含两个： LambdaQueryWrapper LambdaUpdateWrapper @Test void testLambdaQueryWrapper() { // 1.构建条件 WHERE username LIKE "%o%" AND balance >= 1000 QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.lambda() .select(User::getId, User::getUsername, User::getInfo, User::getBalance) .like(User::getUsername, "o") .ge(User::getBalance, 1000); // 2.查询 List<User> users = userMapper.selectList(wrapper); users.forEach(System.out::println); } 总之，推荐使用LambdaQueryWrapper，若要使用set，才用LambdaUpdateWrapper。普通的QueryWrapper用得少自定义sql 可以让我们利用Wrapper生成查询条件，再结合Mapper.xml编写SQL 1.先在业务层利用wrapper创建条件，传递参数 @Test void testCustomWrapper() { // 1.准备自定义查询条件 List<Long> ids = List.of(1L, 2L, 4L); QueryWrapper<User> wrapper = new QueryWrapper<User>().in("id", ids); // 2.调用mapper的自定义方法，直接传递Wrapper userMapper.deductBalanceByIds(200, wrapper); } 自定义mapper层把wrapper和其他业务参数传进去，自定义sql语句书写sql的前半部分，后面拼接。 package com.itheima.mp.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.itheima.mp.domain.po.User; import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Update; import org.apache.ibatis.annotations.Param; public interface UserMapper extends BaseMapper<User> { @Select("UPDATE user SET balance = balance - #{money} ${ew.customSqlSegment}") void deductBalanceByIds(@Param("money") int money, @Param("ew") QueryWrapper<User> wrapper); } 这里wrapper前面必须写@Param("ew") ${ew.customSqlSegment}可以自动拼接前面写的条件语句 Mapper层常用方法查询： selectById：根据主键 ID 查询单条记录。 selectBatchIds：根据主键 ID 批量查询记录。 selectOne：根据指定条件查询单条记录。 QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.eq("username", "alice"); User user = userMapper.selectOne(queryWrapper); selectList：根据指定条件查询多条记录。 QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.ge("age", 18); List<User> users = userMapper.selectList(queryWrapper); 插入： insert：插入一条记录。 User user = new User(); user.setUsername("alice"); user.setAge(20); int rows = userMapper.insert(user); 更新 updateById：根据主键 ID 更新记录。 User user = new User(); user.setId(1L); user.setAge(25); int rows = userMapper.updateById(user); update：根据指定条件更新记录。 UpdateWrapper<User> updateWrapper = new UpdateWrapper<>(); updateWrapper.eq("username", "alice"); User user = new User(); user.setAge(30); int rows = userMapper.update(user, updateWrapper); 删除操作 deleteById：根据主键 ID 删除记录。 deleteBatchIds：根据主键 ID 批量删除记录。 delete：根据指定条件删除记录。 QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.eq("username", "alice"); int rows = userMapper.delete(queryWrapper); IService 由于Service中经常需要定义与业务有关的自定义方法，因此我们不能直接使用IService，而是自定义Service接口，然后继承IService以拓展方法。同时，让自定义的Service实现类继承ServiceImpl，这样就不用自己实现IService中的接口了。首先，定义IUserService，继承IService： package com.itheima.mp.service; import com.baomidou.mybatisplus.extension.service.IService; import com.itheima.mp.domain.po.User; public interface IUserService extends IService<User> { // 拓展自定义方法 } 然后，编写UserServiceImpl类，继承ServiceImpl，实现UserService： package com.itheima.mp.service.impl; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.itheima.mp.domain.po.User; import com.itheima.mp.domain.po.service.IUserService; import com.itheima.mp.mapper.UserMapper; import org.springframework.stereotype.Service; @Service public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService { }

自学

zy123 3月21日
0 0 0
2025-03-21
Untitled Untitled

自学

zy123 3月21日
0 0 0
2025-03-21
Java笔记本 Java笔记本 IDEA基础操作 Intellij Ideav创建Java项目：创建空项目创建Java module 创建包 package edu.whut.xx 创建类，类名首字母必须大写！ IDEA快捷键： Ctrl + Alt + L 格式化代码 Ctrl + / 注释/取消注释当前行 Ctrl + D 复制当前行或选中的代码块 Ctrl + Y 删除当前行 Ctrl + N 查找类 Ctrl+shift+F 在文件中查找代码调试快捷键：快捷键功能 Shift + F9 调试当前程序 F8 单步执行（不进入方法） F7 单步执行（进入方法） Shift + F8 跳出当前方法 Alt + F9 运行到光标处 Ctrl + F2 停止调试缩写生成的代码说明 psvm public static void main(String[] args) {} 生成 main 方法 sout System.out.println(); 打印到控制台 fori for (int i = 0; i < ; i++) {} 生成 for 循环 iter for (Type item : iterable) {} 生成增强 for 循环 new Test().var Test test = new Test(); 自动补全变量声明从exsiting file中导入模块：方法一：复制整个模块到项目文件夹，并导入模块的 *.iml 文件，这种方式保留了模块原有的配置信息。方法二：新建一个模块，然后将原模块的 src 文件夹下的包复制过去，这种方式更灵活，可以手动调整模块设置。删除模块：模块右键，remove module，这只是把它从项目中移除，然后！！打开模块所在文件夹，物理删除，才是真正完全删除。转义符的作用防止字符被误解：在字符串中，一些字符（如 " 和 \）有特殊的含义。例如，双引号用于标识字符串的开始和结束，反斜杠通常用于转义。所以当你希望在字符串中包含这些特殊字符时，你需要使用转义符来告诉解析器这些字符是字符串的一部分，而不是特殊符号。例如，\" 表示在字符串中包含一个双引号字符，而不是字符串的结束标志。 "Hello \"World\"" => 结果是：Hello "World" （双引号被转义） "C:\\Program Files\\App" => 结果是：C:\Program Files\App（反斜杠被转义）如果只是"C:\Program Files\App" 那么路径就会报错表示非打印字符：转义符可以用于表示一些不可见的或非打印的控制字符，如换行符（\n）、制表符（\t）等。这些字符无法直接通过键盘输入，所以使用转义符来表示它们。 Java基础语法二进制：0b 八进制：0 十六进制：0x 在 System.out.println() 方法中，"ln" 代表 "line"，表示换行。因此，println 实际上是 "print line" 的缩写。这个方法会在输出文本后自动换行. System.out.println("nihao "+1.3331)； #Java 会自动将数值转换为字符串一维数组创建： // 方式1：先声明，再指定长度（默认值为0、null等） int[] arr1 = new int[10]; // 创建一个长度为10的int数组 // 方式2：使用初始化列表直接创建数组 int[] arr2 = {1, 2, 3, 4, 5}; // 创建并初始化一个包含5个元素的int数组 String[] strs = {"eat", "tea", "tan", "ate", "nat", "bat"}; // 方式3：结合new关键字和初始化列表创建数组（常用于明确指定类型时） int[] arr3 = new int[]{1, 2, 3, 4, 5}; // 与方式2效果相同字符串创建 String str = "Hello, World!"; //（1）直接赋值 String str = new String("Hello, World!"); //使用 new 关键字 char[] charArray = {'H', 'e', 'l', 'l', 'o'}; String str = new String(charArray); //通过字符数组创建 switch-case public class SwitchCaseExample { public static void main(String[] args) { // 定义一个 int 类型变量，作为 switch 的表达式 int day = 3; String dayName; // 根据 day 的值执行相应的分支 switch(day) { case 1: dayName = "Monday"; // 当 day 为 1 时 break; // 结束当前 case case 2: dayName = "Tuesday"; // 当 day 为 2 时 break; case 3: dayName = "Wednesday"; // 当 day 为 3 时 break; case 4: dayName = "Thursday"; // 当 day 为 4 时 break; case 5: dayName = "Friday"; // 当 day 为 5 时 break; case 6: dayName = "Saturday"; // 当 day 为 6 时 break; case 7: dayName = "Sunday"; // 当 day 为 7 时 break; default: // 如果 day 不在 1 到 7 之间 dayName = "Invalid day"; } // 输出最终结果 System.out.println("The day is: " + dayName); } } 强制类型转换 double sqrted=Math.sqrt(n); int soft_max=(int) sqrted; Math库常用方法 Math.pow(3, 2)); Math.sqrt(9)); Math.abs(a)); Math.max(a, b)); Math.min(a, b)); 枚举 public enum OperationType { /** * 更新操作 */ UPDATE, /** * 插入操作 */ INSERT } OperationType opType = OperationType.INSERT; // 声明并初始化 public void execute(OperationType type, Object entity) { switch (type) { case INSERT: insertEntity(entity); break; case UPDATE: updateEntity(entity); break; default: throw new IllegalArgumentException("Unsupported operation: " + type); } } // 定义枚举类型 public enum DayOfWeek { MONDAY("星期一", 1), TUESDAY("星期二", 2), WEDNESDAY("星期三", 3), THURSDAY("星期四", 4), FRIDAY("星期五", 5), SATURDAY("星期六", 6), SUNDAY("星期日", 7); // 枚举属性 private final String chineseName; private final int dayNumber; // 构造方法 DayOfWeek(String chineseName, int dayNumber) { this.chineseName = chineseName; this.dayNumber = dayNumber; } // 方法 public String getChineseName() { return chineseName; } public int getDayNumber() { return dayNumber; } } // 使用示例 public class Main { public static void main(String[] args) { DayOfWeek today = DayOfWeek.MONDAY; System.out.println(today.getChineseName()); // 输出: 星期一 System.out.println(today.getDayNumber()); // 输出: 1 } } Java传参方式基本数据类型（Primitives）传递方式：按值传递每次传递的是变量的值的副本**，对该值的修改不会影响原变量**。例如：int、double、boolean 等类型。引用类型（对象）传递方式：对象引用的副本传递传递的是对象引用的一个副本，指向同一块内存区域。因此，方法内部通过该引用修改对象的状态，会影响到原对象。如数组、集合、String、以及其他所有对象类型。注意 StringBuilder s = new StringBuilder(); s.append("hello"); String res = s.toString(); // res = "hello" s.append(" world"); // s = "hello world" System.out.println(res); // 输出还是 "hello" 浅拷贝拷贝对象本身，但内部成员（例如集合中的元素）只是复制引用，新旧对象的内部成员指向同一份内存。如果内部元素是不可变的（如 Integer、String 等），这种拷贝通常足够。如果元素是可变对象，修改其中一个对象可能会影响另一个。 List<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); // 浅拷贝：新列表中的元素引用和原列表中的是同一份 List<Integer> shallowCopy = new ArrayList<>(list); 可变对象，浅拷贝修改对象会出错！ List<Box> list = new ArrayList<>(); list.add(new Box(1)); list.add(new Box(2)); list.add(new Box(3)); List<Box> shallowCopy = new ArrayList<>(list); shallowCopy.get(0).value = 10; // 修改 shallowCopy 中第一个 Box 的 value System.out.println(list); // 输出: [10, 2, 3]，因为同一 Box 对象被修改 System.out.println(shallowCopy); // 输出: [10, 2, 3] 深拷贝不仅复制对象本身，还递归地复制其所有内部成员，从而生成一个完全独立的副本。即使内部元素是可变的，修改新对象也不会影响原始对象。 // 深拷贝 List<MyObject> 的例子 List<MyObject> originalList = new ArrayList<>(); originalList.add(new MyObject(10)); originalList.add(new MyObject(20)); List<MyObject> deepCopy = new ArrayList<>(); for (MyObject obj : originalList) { deepCopy.add(new MyObject(obj)); // 每个元素都创建一个新的对象 } 日期在Java中：代表年月日的类型是 LocalDate。LocalDate 类位于 java.time 包下，用于表示没有时区的日期，如年、月、日。代表年月日时分秒的类型是 LocalDateTime。LocalDateTime 类也位于 java.time 包下，用于表示没有时区的日期和时间，包括年、月、日、时、分、秒。 LocalDateTime.now()，获取当前时间访问修饰符 public（公共的）：使用public修饰的成员可以被任何其他类访问，无论这些类是否属于同一个包。例如，如果一个类的成员被声明为public，那么其他类可以通过该类的对象直接访问该成员。 protected（受保护的）：使用protected修饰的成员可以被同一个包中的其他类访问，也可以被不同包中的子类访问。与包访问级别相比，protected修饰符提供了更广泛的访问权限。 default (no modifier)（默认的，即包访问级别）：如果没有指定任何访问修饰符，则默认情况下成员具有包访问权限。在同一个包中的其他类可以访问默认访问级别的成员，但是在不同包中的类不能访问。 private（私有的）：使用private修饰的成员只能在声明它们的类内部访问，其他任何类都不能访问这些成员。这种访问级别提供了最高的封装性和安全性。如果您在另一个类中实例化了包含私有成员的类，那么您无法直接访问该类的私有成员。但是，您可以通过公共方法来间接地访问和操作私有成员。则每个实例都有自己的一份拷贝，只有当变量被声明为 static 时，变量才是类级别的，会被所有实例共享。 // 文件：com/example/PrivateExample.java package com.example; public class PrivateExample { private int privateVar = 30; // 公共方法，用于访问私有成员 public int getPrivateVar() { return privateVar; } } 修饰符不仅可以用来修饰成员变量和方法，也可以用来修饰类。顶级类只能使用 public 或默认（即不写任何修饰符，称为包访问权限）。内部类可以使用所有访问修饰符（public、protected、private 和默认），这使得你可以更灵活地控制嵌套类的访问范围。 public class OuterClass { // 内部类使用private，只能在OuterClass内部访问 private class InnerPrivateClass { // ... } // 内部类使用protected，同包以及其他包中的子类可以访问 protected class InnerProtectedClass { // ... } // 内部类使用默认访问权限，只在同包中可见 class InnerDefaultClass { // ... } // 内部类使用public，任何地方都可访问（但访问时需要通过OuterClass对象） public class InnerPublicClass { // ... } } 四种内部类下面是四种内部类（成员内部类、局部内部类、静态内部类和匿名内部类）的示例代码，展示了如何用每一种方式来实现Runnable的run()方法并创建线程。成员内部类定义位置：成员内部类定义在外部类的成员位置。访问权限：可以无限制地访问外部类的所有成员，包括私有成员。实例化方式：需要先创建外部类的实例，然后才能创建内部类的实例。修改限制：不能有静态字段和静态方法（除非声明为常量final static）。成员内部类属于外部类的一个实例，不能独立存在于类级别上。用途：适用于内部类与外部类关系密切，需要频繁访问外部类成员的情况。 public class OuterClass { class InnerClass implements Runnable { // static int count = 0; // 编译错误 public static final int CONSTANT = 100; // 正确：可以定义常量 public void run() { System.out.println("成员内部类中的线程正在运行..."); } } public void startThread() { InnerClass inner = new InnerClass(); Thread thread = new Thread(inner); thread.start(); } public static void main(String[] args) { OuterClass outer = new OuterClass(); outer.startThread(); } } 局部内部类定义位置：局部内部类定义在一个方法或任何块内（如：if语句、循环语句内）。访问权限：只能访问所在方法的final或事实上的final（即不被后续修改的）局部变量和外部类的成员变量（同成员内部类）。实例化方式：只能在定义它们的块中创建实例。修改限制：同样不能有静态字段和方法。用途：适用于只在方法或代码块中使用的类，有助于将实现细节隐藏在方法内部。 public class OuterClass { public void startThread() { class LocalInnerClass implements Runnable { public void run() { System.out.println("局部内部类中的线程正在运行..."); } } LocalInnerClass localInner = new LocalInnerClass(); Thread thread = new Thread(localInner); thread.start(); } public static void main(String[] args) { OuterClass outer = new OuterClass(); outer.startThread(); } } 静态内部类定义位置：定义在外部类内部，但使用static修饰。访问权限：只能直接访问外部类的静态成员，访问非静态成员需要通过外部类实例。实例化方式：可以直接创建，不需要外部类的实例。修改限制：可以有自己的静态成员。用途：适合当内部类工作不依赖外部类实例时使用，常用于实现与外部类关系不那么密切的帮助类。 public class OuterClass { // 外部类的静态成员 private static int staticVar = 10; // 外部类的实例成员 private int instanceVar = 20; // 静态内部类 public static class StaticInnerClass { public void display() { // 可以直接访问外部类的静态成员 System.out.println("staticVar: " + staticVar); // 下面这行代码会报错，因为不能直接访问外部类的实例成员 // System.out.println("instanceVar: " + instanceVar); // 如果确实需要访问实例成员，可以通过创建外部类的对象来访问 OuterClass outer = new OuterClass(); System.out.println("通过外部类实例访问 instanceVar: " + outer.instanceVar); } } public static void main(String[] args) { // 直接创建静态内部类的实例，不需要外部类实例 OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass(); inner.display(); } } 匿名内部类使用匿名内部类实现抽象类相当于临时创建了一个未命名的子类，并且立即实例化了这个子类的对象。定义位置：在需要使用它的地方立即定义和实例化。访问权限：类似局部内部类，只能访问final或事实上的final局部变量。实例化方式：在定义时就实例化，不能显式地命名构造器。修改限制：不能有任何静态成员。用途：适用于创建一次性使用的实例，通常用于接口或抽象类的实现。 //eg1 public class OuterClass { public static void main(String[] args) { Runnable runnable = new Runnable() { @Override public void run() { System.out.println("匿名内部类中的线程正在运行..."); } }; Thread thread = new Thread(runnable); thread.start(); } } //eg2 安卓开发中用过很多次！ import javax.swing.*; import java.awt.event.*; public class GUIApp { public static void main(String[] args) { JFrame frame = new JFrame("Demo"); JButton button = new JButton("Click Me!"); // 匿名内部类用于事件监听 button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { System.out.println("Button was clicked!"); } }); frame.add(button); frame.setSize(300, 200); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } } 创建ActionListener实例 new ActionListener() { public void actionPerformed(ActionEvent e) { System.out.println("Button was clicked!"); } } 这部分代码是匿名内部类的核心。这里发生的事情包括： new ActionListener()：这表示创建了ActionListener接口的一个实现。由于ActionListener是一个接口，我们不能直接实例化它，而是需要提供该接口的一个具体实现。在这种情况下，我们通过创建一个匿名内部类来提供实现。大括号 { ... }：在这对大括号内，我们定义了接口中需要实现的方法。对于ActionListener接口，必须实现actionPerformed(ActionEvent e)方法。方法实现： public void actionPerformed(ActionEvent e)：这是ActionListener接口要求实现的方法，用于响应事件。这里的方法定义了当事件发生时（例如，用户点击按钮）执行的操作。 System.out.println("Button was clicked!");：这是actionPerformed方法的具体实现，即当按钮被点击时，控制台将输出一条消息。将匿名内部类添加为事件监听器 button.addActionListener(...); button.addActionListener(EventListener)：这是JButton类的一个方法，用于添加事件监听器。这个方法的参数是ActionListener类型的对象，这里传入的正是我们刚刚创建的匿名内部类的实例。 Lambda表达式 Lambda表达式特别适用于只有单一抽象方法的接口（也即函数式接口）。lambda 表达式主要用于实现函数式接口。 @FunctionalInterface 注解：这是一个可选的注解，用于表示接口是一个函数式接口。虽然不是强制的，但它可以帮助编译器识别意图，并检查接口是否确实只有一个抽象方法。 public class LambdaExample { // 定义函数式接口，doSomething 有两个参数 @FunctionalInterface interface MyInterface { void doSomething(int a, int b); } public static void main(String[] args) { // 使用 Lambda 表达式实现接口方法 MyInterface obj = (a, b) -> { System.out.println("参数a: " + a + ", 参数b: " + b); }; obj.doSomething(5, 10); } } lambda表达式格式：(参数列表) -> { 代码块 } 或 (参数列表) ->表达式; 在上述Lambda表达式中，因为MyInterface接口的doSomething()方法不接受任何参数并且没有返回值，所以Lambda表达式的参数列表为空（()），后面跟的是执行的代码块。以下是lambda表达式的重要特征: 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。可选的参数圆括号：一个参数无需定义圆括号，但无参数或多个参数需要定义圆括号。可选的大括号：如果主体只有一个语句，可以不使用大括号。可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，使用大括号需显示retrun；如果函数是void则不需要返回值。 // 定义一个函数式接口 interface Calculator { int add(int a, int b); } public class LambdaReturnExample { public static void main(String[] args) { // 例子1：单个表达式，不使用大括号和 return 关键字 Calculator calc1 = (a, b) -> a + b; System.out.println("calc1: " + calc1.add(5, 3)); // 输出：8 // 例子2：使用大括号，需要显式使用 return 关键字 Calculator calc2 = (a, b) -> { return a + b; }; System.out.println("calc2: " + calc2.add(5, 3)); // 输出：8 } } 示例1： list.forEach这个方法接受一个函数式接口作为参数。它只有一个抽象方法 accept(T t)因此，可以使用 lambda 表达式来实现。 import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { List<String> list = Arrays.asList("Apple", "Banana", "Cherry", "Date"); // 使用 Lambda 表达式迭代列表 list.forEach(item -> System.out.println(item)); } } 示例2： Collections.sort 方法用于对列表进行排序，它接受两个参数第一个参数：要排序的列表（这里是一个 List<String>）。第二个参数：一个实现了 Comparator 接口的比较器，用于指定排序规则。如果返回负数，表示 a 应该排在 b 的前面；如果返回正数，则 a 应该排在 b 的后面。 import java.util.Arrays; import java.util.Collections; import java.util.List; public class Main { public static void main(String[] args) { List<String> names = Arrays.asList("John", "Jane", "Adam", "Dana"); // 使用Lambda表达式排序 Collections.sort(names, (String a, String b) -> a.compareTo(b)); // 输出排序结果 names.forEach(name -> System.out.println(name)); } } 静态成员变量的初始化静态成员变量属于类级别，在类加载时完成初始化。初始化方式主要有两种： 1.静态初始化块（Static Initialization Block） public class MyClass { static int num1, num2; // 第一个静态代码块 static { num1 = 1; System.out.println("静态代码块1执行"); } // 主方法 public static void main(String[] args) { System.out.println("main方法执行"); } // 第二个静态代码块 static { num2 = 3; System.out.println("静态代码块2执行"); } } 输出：静态代码块1执行静态代码块2执行 main方法执行说明：类加载时依次执行所有静态代码块，然后执行 main 方法。 2.在声明时直接初始化 public class MyClass { // 直接在声明时初始化静态成员变量 public static int staticVariable = 42; } 静态成员变量的访问不需要创建 MyClass 的实例，可以直接通过类名访问： int value = MyClass.staticVariable; MyClass obj = new MyClass(); System.out.println("obj.num1 = " + obj.staticVariable); #通过示例访问也可以静态方法静态方法属于类级别，不依赖于任何具体实例静态方法访问规则：可以直接访问：类中的其他静态成员变量。类中的静态方法。不能直接访问：非静态成员变量。非静态方法（必须通过对象实例访问）。 public class MyClass { private static int staticVar = 10; private int instanceVar = 20; // 静态方法：可以直接访问静态成员 public static void staticMethod() { System.out.println(staticVar); // 正确：访问静态成员变量 // System.out.println(instanceVar); // 错误：不能直接访问非静态成员变量 // 如需要访问非静态成员，必须先创建对象实例 MyClass obj = new MyClass(); System.out.println(obj.instanceVar); // 正确：通过对象实例访问非静态成员变量 } // 非静态方法：可以访问所有成员 public void instanceMethod() { System.out.println(staticVar); // 正确：访问静态成员变量 System.out.println(instanceVar); // 正确：访问非静态成员变量 } } 调用静态方法： MyClass.staticMethod(); // 通过类名直接调用静态方法 super关键字 super 关键字有两种主要的使用方法：访问父类的成员和调用父类的构造方法。访问父类的成员可以使用 super 关键字来引用父类的字段或方法。这在子类中存在同名的字段或方法时特别有用。因为父类的成员变量和方法都是默认的访问修饰符，可以继承给子类，而子类也定义了同名的xxx，发生了变量隐藏（shadowing）。 class Parent { int num = 10; void display() { System.out.println("Parent class method"); } } class Child extends Parent { int num = 20; void display() { System.out.println("Child class method"); } void print() { System.out.println("Child class num: " + num); // 访问子类中的num System.out.println("Parent class num: " + super.num); // 使用super关键字访问父类中的num super.display(); // 调用父类中的display方法 } } public class Main { public static void main(String[] args) { Child obj = new Child(); obj.print(); } } 输出： Child class num: 20 Parent class num: 10 Parent class method 调用父类的构造方法可以使用 super 关键字调用父类的构造方法。这通常在子类的构造方法中使用，用于显式地调用父类的构造方法。 class Parent { Parent() { System.out.println("Parent class constructor"); } } class Child extends Parent { Child() { super(); // 调用父类的构造方法 System.out.println("Child class constructor"); } } public class Main { public static void main(String[] args) { Child obj = new Child(); } } 输出： Parent class constructor Child class constructor final关键字 final 关键字，意思是最终的、不可修改的，最见不得变化，用来修饰类、方法和变量，具有以下特点：修饰类：类不能继承，final 类中的所有成员方法都会被隐式的指定为 final 方法；修饰变量：该变量为常量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能让其指向另一个对象。修饰符方法：方法不能重写变量修饰符的顺序在Java中，变量的修饰符应该按照规定的顺序出现，通常是这样的：访问修饰符：public、protected、private，或者不写（默认为包级访问）。非访问修饰符：final、static、abstract、synchronized、volatile等。数据类型：变量的数据类型，如int、String、class等。变量名：变量的名称。 public static final int MAX_COUNT = 100; #定义常量 protected static volatile int counter; #定义成员变量全限定名全限定名（Fully Qualified Name，简称 FQN）指的是一个类或接口在 Java 中的完整名称，包括它所在的包名。例如：对于类 Integer，其全限定名是 java.lang.Integer。对于自定义的类 DeptServiceImpl，如果它位于包 edu.zju.zy123.service.impl 中，那么它的全限定名就是 edu.zju.zy123.service.impl.DeptServiceImpl。使用全限定名可以消除歧义，确保指定的类型在整个项目中唯一无误。使用场景： Spring AOP 的 Pointcut 表达式 MyBatis的XML映射文件的namespace属性 JAVA面向对象 public class Dog { // 成员变量 private String name; // 构造函数 public Dog(String name) { this.name = name; } // 一个函数：让狗狗“叫” public void bark() { System.out.println(name + " says: Woof! Woof!"); } // （可选）获取狗狗的名字 public String getName() { return name; } // 测试主方法 public static void main(String[] args) { Dog myDog = new Dog("Buddy"); myDog.bark(); // 输出：Buddy says: Woof! Woof! System.out.println("Name: " + myDog.getName()); } } JAVA三大特性封装封装指隐藏对象的状态信息（属性），不允许外部对象直接访问对象的内部信息（private实现）。但是可以提供一些可以被外界访问的方法(public)来操作属性。继承 [修饰符] class 子类名 extends 父类名{ 类体部分 } //class C extends A, B // 错误：C 不能同时继承 A 和 B Java只支持单继承，不支持多继承。一个类只能有一个父类，不可以有多个父类。 Java支持多层继承(A → B → C )。 Java继承了父类非私有的成员变量和成员方法，但是请注意：子类是无法继承父类的构造方法的。多态指在面向对象编程中，同样的消息（方法调用）可以在不同的对象上触发不同的行为。方法重写（Override）：动态多态；子类从父类继承的某个实例方法无法满足子类的功能需要时，需要在子类中对该实例方法进行重新实现，这样的过程称为重写，也叫做覆写、覆盖。要求：必须存在继承关系（子类继承父类）。子类重写的方法的访问修饰符不能比父类更严格（可以相同或更宽松）。方法名、参数列表和返回值类型必须与父类中的方法完全相同（Java 5 以后支持协变返回类型，即允许返回子类型）。向上转型（Upcasting）：动态多态；子类对象可以赋值给父类引用，这样做可以隐藏对象的真实类型，只能调用父类中声明的方法。 class Animal { public void makeSound() { System.out.println("Animal makes sound"); } } class Dog extends Animal { @Override public void makeSound() { System.out.println("Dog barks"); } public void fetch() { System.out.println("Dog fetches the ball"); } } public class Test { public static void main(String[] args) { Animal animal = new Dog(); // 向上转型 animal.makeSound(); // 调用的是 Dog 重写的 makeSound() 方法 // animal.fetch(); // 编译错误：Animal 类型没有 fetch() 方法 } } 多态实现总结：继承 + 重写 + 父类引用指向子类对象＝多态方法重载（Overload）:静态多态；在一个类中，可以定义多个同名方法，但参数列表不同。当调用这些方法时，会根据传递的参数类型或数量选择相应的方法。与重写的区别：重载发生在同一个类中，与继承无关；重写发生在子类中，依赖继承关系，实现运行时多态。 class Calculator { int add(int a, int b) { return a + b; } double add(double a, double b) { return a + b; } } 抽象类定义抽象类是包含至少一个抽象方法的类。抽象方法没有实现，只定义了方法的签名。注意：抽象类不能被实例化。必须实现抽象方法如果一个子类继承了抽象类，通常必须实现抽象类中的所有抽象方法，否则该子类也必须声明为抽象类。例如： abstract class Animal { // 抽象方法，没有方法体 public abstract void makeSound(); // 普通方法 public void sleep() { System.out.println("Sleeping..."); } } // 正确：子类实现了所有抽象方法 class Dog extends Animal { @Override public void makeSound() { System.out.println("Dog barks"); } } // 错误：如果不实现 makeSound() 方法，则 Dog 必须也声明为抽象类如何使用抽象类由于抽象类不能直接实例化，我们通常有两种方法来使用抽象类：定义一个新的子类创建一个子类继承抽象类并实现所有抽象方法，然后使用子类实例化对象： Animal animal = new Dog(); animal.makeSound(); // 输出：Dog barks 使用匿名内部类使用匿名内部类实现抽象类相当于临时创建了一个未命名的子类，并且立即实例化了这个子类的对象。 Animal animal = new Animal() { @Override public void makeSound() { System.out.println("Anonymous animal sound"); } }; animal.makeSound(); // 输出：Anonymous animal sound 接口接口（Interface）：定义了一组方法的规范，侧重于行为的约定。接口中的所有方法默认是抽象的（Java 8 之后可包含默认方法和静态方法），不包含成员变量（除了常量）。抽象类（Abstract Class）：可以包含抽象方法和具体实现的方法，还可以拥有成员变量和构造方法，适用于需要部分通用实现的情况。方法实现：接口： Java 8 前：所有方法都是抽象方法，只包含方法声明。 Java 8 及以后：可包含默认方法（default methods）和静态方法。抽象类：可以同时包含抽象方法（不提供实现）和具体方法（提供实现）。继承：类实现接口时，使用关键字 implements。类继承抽象类时，使用关键字 extends。多继承：类可以实现多个接口（多继承）。类只能继承一个抽象类（单继承）。 // 定义接口 interface Flyable { void fly(); } interface Swimmable { void swim(); } // 实现多个接口的类 class Bird implements Flyable, Swimmable { // 实现接口中的方法 public void fly() { System.out.println("Bird is flying"); } public void swim() { System.out.println("Bird is swimming"); } } // 主类 public class Main { public static void main(String[] args) { // 创建实现多个接口的对象 Bird bird = new Bird(); // 调用实现的方法 bird.fly(); // 输出: Bird is flying bird.swim(); // 输出: Bird is swimming } } 容器 Collection 在 Java 中，Collection 是一个接口，它表示一组对象的集合。Collection 接口是 Java 集合框架中最基本的接口之一，定义了一些操作集合的通用方法，例如添加、删除、遍历等。所有集合类（例如 List、Set、Queue 等）都直接或间接地继承自 Collection 接口。 boolean add(E e)：将指定的元素添加到集合中（可选操作）。 boolean remove(Object o)：从集合中移除指定的元素（可选操作）。 boolean contains(Object o)：如果集合中包含指定的元素，则返回 true。 int size()：返回集合中的元素个数。 void clear()：移除集合中的所有元素。 boolean isEmpty()：如果集合为空，则返回 true。 import java.util.ArrayList; import java.util.Collection; public class CollectionExample { public static void main(String[] args) { // 创建一个 Collection 对象，使用 ArrayList 作为实现类 Collection<String> fruits = new ArrayList<>(); // 添加元素到集合中 fruits.add("Apple"); fruits.add("Banana"); fruits.add("Cherry"); System.out.println("添加元素后集合大小: " + fruits.size()); // 输出集合大小 // 检查集合是否包含某个元素 System.out.println("集合中是否包含 'Banana': " + fruits.contains("Banana")); // 从集合中移除元素 fruits.remove("Banana"); System.out.println("移除 'Banana' 后集合大小: " + fruits.size()); // 清空集合 fruits.clear(); System.out.println("清空集合后，集合是否为空: " + fruits.isEmpty()); } } Iterator 在 Java 中，Iterator 是一个接口，遍历集合元素。Collection 接口中定义了 iterator() 方法，返回一个 Iterator 对象。 Iterator 接口中包含以下主要方法： hasNext()：如果迭代器还有下一个元素，则返回 true，否则返回 false。 next()：返回迭代器的下一个元素，并将迭代器移动到下一个位置。 remove()：从迭代器当前位置删除元素。该方法是可选的，不是所有的迭代器都支持。 import java.util.ArrayList; import java.util.Iterator; public class Main { public static void main(String[] args) { // 创建一个 ArrayList 集合 ArrayList<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); int size = list.size(); // 获取列表大小 System.out.println("Size of list: " + size); // 输出 3 // 获取集合的迭代器 Iterator<Integer> iterator = list.iterator(); // 使用迭代器遍历集合并输出元素 while (iterator.hasNext()) { Integer element = iterator.next(); System.out.println(element); } } } ArrayList ArrayList 是 List 接口的一种实现，而 List 接口又继承自 Collection 接口。包括 add()、remove()、contains() 等。 HashSet HashMap // 使用 entrySet() 方法获取 Map 中所有键值对的集合，并使用增强型 for 循环遍历键值对 System.out.println("Entries in the map:"); for (Map.Entry<String, Integer> entry : map.entrySet()) { String key = entry.getKey(); Integer value = entry.getValue(); System.out.println("Key: " + key + ", Value: " + value); } PriorityQueue 默认是小根堆，输出1，2，5，8 import java.util.PriorityQueue; public class Main { public static void main(String[] args) { // 创建一个 PriorityQueue 对象 PriorityQueue<Integer> pq = new PriorityQueue<>(); // 添加元素到队列 pq.offer(5); pq.offer(2); pq.offer(8); pq.offer(1); // 打印队列中的元素 System.out.println("Elements in the priority queue:"); while (!pq.isEmpty()) { System.out.println(pq.poll()); } } } offer() 方法用于将元素插入到队列中 poll() 方法用于移除并返回队列中的头部元素 peek() 方法用于返回队列中的头部元素但不移除它。 JAVA异常处理 public class ExceptionExample { // 方法声明中添加 throws 关键字，指定可能抛出的异常类型 public static void main(String[] args) throws SomeException, AnotherException { try { // 可能会抛出异常的代码块 if (someCondition) { throw new SomeException("Something went wrong"); } } catch (SomeException e) { // 处理 SomeException 异常 System.out.println("Caught SomeException: " + e.getMessage()); } catch (AnotherException e) { // 处理 AnotherException 异常 System.out.println("Caught AnotherException: " + e.getMessage()); } finally { // 不管是否发生异常，都会执行的代码块 System.out.println("End of try-catch block"); } } } // 自定义异常类，继承自 Exception 类 public class SomeException extends Exception { // 构造方法，用于设置异常信息 public SomeException(String message) { // 调用父类的构造方法，设置异常信息 super(message); } } 好用的方法 toString() **Arrays.toString()**转一维数组 **Arrays.deepToString()**转二维数组这个方法是是用来将数组转换成String类型输出的，入参可以是long，float，double，int，boolean，byte，object 型的数组。 import java.util.Arrays; public class Main { public static void main(String[] args) { // 一维数组示例 int[] oneD = {1, 2, 3, 4, 5}; System.out.println("一维数组输出: " + Arrays.toString(oneD)); // 二维数组示例 int[][] twoD = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; // 使用 Arrays.deepToString() 输出二维数组 System.out.println("二维数组输出: " + Arrays.deepToString(twoD)); } } 自定义对象的toString() 方法每个 Java 对象默认都有 toString() 方法（可以根据需要覆盖）当直接打印一个没有重写 toString() 方法的对象时，其输出格式通常为： java.lang.Object@15db9742 当打印重写toString() 方法的对象时： class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "Person{name='" + name + "', age=" + age + "}"; } } public class Main { public static void main(String[] args) { Person person = new Person("Alice", 30); System.out.println(person); //会自动调用对象的 toString() 方法 //Person{name='Alice', age=30} } } 类加载器和获取资源文件路径在Java中，类加载器的主要作用是根据**类路径（Classpath）**加载类文件以及其他资源文件。类路径是JVM在运行时用来查找类文件和资源文件的一组目录或JAR包。在许多项目（例如Maven或Gradle项目）中，src/main/resources目录下的内容在编译时会被复制到输出目录（如target/classes），src/main/java 下编译后的 class 文件也会放到这里。 src/ ├── main/ │ ├── java/ │ │ └── com/ │ │ └── example/ │ │ └── App.java │ └── resources/ │ ├── application.yml │ └── static/ │ └── logo.png └── test/ ├── java/ │ └── com/ │ └── example/ │ └── AppTest.java └── resources/ └── test-data.json 映射到 target/ 后： target/ ├── classes/ ← 主代码和资源的输出根目录 │ ├── com/ │ │ └── example/ │ │ └── App.class ← 编译自 src/main/java/com/example/App.java │ ├── application.yml ← 复制自 src/main/resources/application.yml │ └── static/ │ └── logo.png ← 复制自 src/main/resources/static/logo.png └── test-classes/ ← 测试代码和测试资源的输出根目录 ├── com/ │ └── example/ │ └── AppTest.class ← 编译自 src/test/java/com/example/AppTest.java └── test-data.json ← 复制自 src/test/resources/test-data.json // 获取 resources 根目录下的 emp.xml 文件路径 String empFileUrl = this.getClass().getClassLoader().getResource("emp.xml").getFile(); // 获取 resources/static 目录下的 tt.img 文件路径 URL resourceUrl = getClass().getClassLoader().getResource("static/tt.img"); String ttImgPath = resourceUrl != null ? resourceUrl.getFile() : null; this.getClass()：获取当前对象（即调用该代码的对象）的 Class 对象。 .getClassLoader()：获取该 Class 对象的类加载器（ClassLoader）。 .getResource("emp.xml")：从类路径中获取名为 "emp.xml" 的资源，并返回一个 URL 对象，该 URL 对象指向 "emp.xml" 文件的位置。 .getFile()：从 URL 对象中获取文件路径部分，即获取 "emp.xml" 文件的绝对路径字符串。 **类路径（Classpath）**是 Java 虚拟机（JVM）用于查找类文件和其他资源文件的一组路径。类加载器的主要作用之一就是从类路径中加载类文件和其他资源文件。反射反射技术，指的是加载类的字节码到内存，并以编程的方法解刨出类中的各个成分（成员变量、方法、构造器等）。反射技术例子：IDEA通过反射技术就可以获取到类中有哪些方法，并且把方法的名称以提示框的形式显示出来，所以你能看到这些提示了。 1.获取类的字节码（Class对象）：有三种方法 public class Test1Class{ public static void main(String[] args){ Class c1 = Student.class; System.out.println(c1.getName()); //获取全类名：edu.whut.pojo.Student System.out.println(c1.getSimpleName()); //获取简单类名: Student Class c2 = Class.forName("com.itheima.d2_reflect.Student"); //全类名 System.out.println(c1 == c2); //true Student s = new Student(); Class c3 = s.getClass(); System.out.println(c2 == c3); //true } } 2.获取类的构造器定义类 public class Cat{ private String name; private int age; public Cat(){ } private Cat(String name, int age){ } } 获取构造器列表 public class TestConstructor { @Test public void testGetAllConstructors() { // 1. 获取类的 Class 对象 Class<?> c = Cat.class; // 2. 获取类的全部构造器（包括public、private等） Constructor<?>[] constructors = c.getDeclaredConstructors(); // 3. 遍历并打印构造器信息 for (Constructor<?> constructor : constructors) { System.out.println( constructor.getName() + " --> 参数个数：" + constructor.getParameterCount() ); } } } c.getDeclaredConstructors() 会返回所有声明的构造器（包含私有构造器），而 c.getConstructors() 只会返回公共构造器。 constructor.getParameterCount() 用于获取该构造器的参数个数。获取某个构造器：指定参数类型！ public class Test2Constructor(){ @Test public void testGetConstructor(){ //1、反射第一步：必须先得到这个类的Class对象 Class c = Cat.class; /2、获取private修饰的有两个参数的构造器，第一个参数String类型，第二个参数int类型 Constructor constructor = c.getDeclaredConstructor(String.class,int.class); constructor.setAccessible(true); //禁止检查访问权限，可以使用private构造函数 Cat cat=(Cat)constructor.newInstance("叮当猫",3); //初始化Cat对象 } } c.getDeclaredConstructor(String.class, int.class)：根据参数列表获取特定的构造器。如果构造器是private修饰的，先需要调用setAccessible(true) 表示禁止检查访问控制，然后再调用newInstance(实参列表) 就可以执行构造器，完成对象的初始化了。 3.获取类的成员变量不管是设置值还是获取值，都需要：拿到 Field 对象。指定操作哪个对象的该字段。对于私有字段，还需要调用 setAccessible(true) 来关闭访问检查。 4.获取类的成员方法获取单个指定的成员方法：第一个参数填方法名、第二个参数填方法中的参数类型执行：第一个参数传入一个对象，然后是若干方法参数（无参可不写）... 示例：Cat 类与测试类 public class Cat { private String name; public int age; public Cat() { this.name = "Tom"; this.age = 1; } public void meow() { System.out.println("Meow! My name is " + this.name); } private void purr() { System.out.println("Purr... I'm a happy cat!"); } } import org.junit.Test; import java.lang.reflect.Field; import java.lang.reflect.Method; public class FieldReflectionTest { @Test public void testFieldAccess() throws Exception { // 1. 获取 Cat 类的 Class 对象 Class<?> catClass = Cat.class; // 2. 创建 Cat 对象实例 Cat cat = new Cat(); // ---------------------- // A. 获取 public 字段 // ---------------------- Field ageField = catClass.getField("age"); // 只能获取public字段 System.out.println("初始 age = " + ageField.get(cat)); // 读取 age 的值 // 设置 age 的值 ageField.set(cat, 5); System.out.println("修改后 age = " + ageField.get(cat)); // ---------------------- // B. 获取 private 字段 // ---------------------- Field nameField = catClass.getDeclaredField("name"); // 获取私有字段 nameField.setAccessible(true); // 关闭权限检查 System.out.println("初始 name = " + nameField.get(cat)); // 设置 name 的值 nameField.set(cat, "Jerry"); System.out.println("修改后 name = " + nameField.get(cat)); } @Test public void testMethodAccess() throws Exception { // 1. 获取 Cat 类的 Class 对象 Class<?> catClass = Cat.class; // 2. 创建 Cat 对象实例 Cat cat = new Cat(); // ---------------------- // A. 获取并调用 public 方法 // ---------------------- // 获取名为 "meow"、无参数的方法 Method meowMethod = catClass.getMethod("meow"); // 调用该方法 meowMethod.invoke(cat); // ---------------------- // B. 获取并调用 private 方法 // ---------------------- // 获取名为 "purr"、无参数的私有方法 Method purrMethod = catClass.getDeclaredMethod("purr"); purrMethod.setAccessible(true); // 关闭权限检查 purrMethod.invoke(cat); } } 注解在 Java 中，注解用于给程序元素（类、方法、字段等）添加元数据，这些元数据可被编译器、工具或运行时反射读取，以实现配置、检查、代码生成以及框架支持（如依赖注入、AOP 等）功能，而不直接影响代码的业务逻辑。比如：Junit框架的@Test注解可以用在方法上，用来标记这个方法是测试方法，被@Test标记的方法能够被Junit框架执行。再比如：@Override注解可以用在方法上，用来标记这个方法是重写方法，被@Override注解标记的方法能够被IDEA识别进行语法检查。使用注解定义注解使用 @interface 定义注解 // 定义注解 @Retention(RetentionPolicy.RUNTIME) // 定义注解的生命周期 @Target(ElementType.METHOD) // 定义注解可以应用的Java元素类型 public @interface MyAnnotation { // 定义注解的元素（属性） String description() default "This is a default description"; int value() default 0; } 元注解是修饰注解的注解。 @Retention(RetentionPolicy.RUNTIME) //指定注解的生命周期，即在运行时有效，可用于反射等用途。 @Target(ElementType.METHOD) //方法上的注解 @Target(ElementType.TYPE) //类上的注解（包含类、接口、枚举等类型）简化使用：如果注解中只有一个属性需要设置，而且该属性名为 value，则在使用时可以省略属性名 @MyAnnotation(5) // 等同于 @MyAnnotation(value = 5) public void someMethod() { // 方法实现 } 当需要为注解的多个属性赋值时，传参必须指明属性名称： @MyAnnotation(value = 5, description = "Specific description") public void anotherMethod() { // 方法实现 } 如果所有属性都使用默认值，可以直接使用注解而不传入任何参数： @MyAnnotation public void anotherMethod() { // 方法实现 } 解析注解 public class MyClass { @MyAnnotation(value = "specific value") public void myMethod() { // 方法实现 } } import java.lang.reflect.Method; public class AnnotationReader { public static void main(String[] args) throws NoSuchMethodException { // 获取MyClass的Class对象 Class<MyClass> obj = MyClass.class; // 获取myMethod方法的Method对象 Method method = obj.getMethod("myMethod"); // 获取方法上的MyAnnotation注解实例 MyAnnotation annotation = method.getAnnotation(MyAnnotation.class); if (annotation != null) { // 输出注解的value值 System.out.println("注解的value: " + annotation.value()); } } } 快速检查某个注解是否存在于method 上 if (method.isAnnotationPresent(MyAnnotation.class)) { // 如果存在MyAnnotation注解，则执行相应逻辑 } 检查方法 method 上是否存在 MyAnnotation 注解。如果存在，就返回该注解的实例，否则返回 null MyAnnotation annotation = method.getAnnotation(MyAnnotation.class); Junit 单元测试步骤 1.导入依赖将 JUnit 框架的 jar 包添加到项目中（注意：IntelliJ IDEA 默认集成了 JUnit，无需手动导入）。 2.编写测试类为待测业务方法创建对应的测试类。测试类中定义测试方法，要求方法必须为 public 且返回类型为 void。 3.添加测试注解在测试方法上添加 @Test 注解，确保 JUnit 能自动识别并执行该方法。 4.运行测试在测试方法上右键选择“JUnit运行”。测试通过显示绿色标志；测试失败显示红色标志。 public class UserMapperTest { @Test public void testListUser() { UserMapper userMapper = new UserMapper(); List<User> list = userMapper.list(); Assert.assertNotNull("User list should not be null", list); list.forEach(System.out::println); } } 注意，如果需要使用依赖注入，需要在测试类上加@SpringBootTest注解它会启动 Spring 应用程序上下文，并在测试期间模拟运行整个 Spring Boot 应用程序。这意味着你可以在集成测试中使用 Spring 的各种功能，例如自动装配、依赖注入、配置加载等 @RunWith(SpringRunner.class) @SpringBootTest public class UserMapperTest { @Autowired private UserMapper userMapper; @Test public void testListUser() { List<User> list = userMapper.list(); Assert.assertNotNull("User list should not be null", list); list.forEach(System.out::println); } } 写了@Test注解，那么该测试函数就可以直接运行！若一个测试类中写了多个测试方法，可以全部执行！原理可能是： //自定义注解 @Retention(RetentionPolicy.RUNTIME) //指定注解在运行时可用，这样才能通过反射获取到该注解。 @Target(ElementType.METHOD) //指定注解可用于方法上。 public @interface MyTest { } public class AnnotationTest4 { @MyTest public void test() { System.out.println("===test4==="); } public static void main(String[] args) throws Exception { AnnotationTest4 a = new AnnotationTest4(); Class<?> c = AnnotationTest4.class; // 获取当前类中声明的所有方法 Method[] methods = c.getDeclaredMethods(); // 遍历方法，检查是否使用了 @MyTest 注解 for (Method method : methods) { if (method.isAnnotationPresent(MyTest.class)) { // 如果标注了 @MyTest，就通过反射调用该方法 method.invoke(a); } } } } 在Springboot中，如何快速生成单元测试？选中类名，右键：对象拷贝属性 public void save(EmployeeDTO employeeDTO) { Employee employee = new Employee(); //对象属性拷贝 BeanUtils.copyProperties(employeeDTO, employee); } employeeDTO的内容拷贝给employee StartOrStopDTO dto = new StartOrStopDTO(1, 100L); // 用 Builder 拷贝 id 和 status Employee employee = Employee.builder() .id(dto.getId()) .status(dto.getStatus()) .build();

自学

zy123 3月21日
0 0 0