diff --git a/rhj/backend/.env.example b/Merge/back_rhj/.env.example
similarity index 100%
rename from rhj/backend/.env.example
rename to Merge/back_rhj/.env.example
diff --git a/rhj/backend/README.md b/Merge/back_rhj/README.md
similarity index 100%
rename from rhj/backend/README.md
rename to Merge/back_rhj/README.md
diff --git a/rhj/backend/__pycache__/config.cpython-312.pyc b/Merge/back_rhj/__pycache__/config.cpython-312.pyc
similarity index 100%
rename from rhj/backend/__pycache__/config.cpython-312.pyc
rename to Merge/back_rhj/__pycache__/config.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/__pycache__/test_smtp.cpython-312.pyc b/Merge/back_rhj/__pycache__/test_smtp.cpython-312.pyc
similarity index 100%
rename from rhj/backend/__pycache__/test_smtp.cpython-312.pyc
rename to Merge/back_rhj/__pycache__/test_smtp.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app.py b/Merge/back_rhj/app.py
similarity index 100%
rename from rhj/backend/app.py
rename to Merge/back_rhj/app.py
diff --git a/rhj/backend/app/__init__.py b/Merge/back_rhj/app/__init__.py
similarity index 100%
rename from rhj/backend/app/__init__.py
rename to Merge/back_rhj/app/__init__.py
diff --git a/rhj/backend/app/__pycache__/__init__.cpython-312.pyc b/Merge/back_rhj/app/__pycache__/__init__.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/__pycache__/__init__.cpython-312.pyc
rename to Merge/back_rhj/app/__pycache__/__init__.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/__pycache__/routes.cpython-312.pyc b/Merge/back_rhj/app/__pycache__/routes.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/__pycache__/routes.cpython-312.pyc
rename to Merge/back_rhj/app/__pycache__/routes.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/blueprints/__pycache__/__init__.cpython-312.pyc b/Merge/back_rhj/app/blueprints/__pycache__/__init__.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/blueprints/__pycache__/__init__.cpython-312.pyc
rename to Merge/back_rhj/app/blueprints/__pycache__/__init__.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/blueprints/__pycache__/recommend.cpython-312.pyc b/Merge/back_rhj/app/blueprints/__pycache__/recommend.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/blueprints/__pycache__/recommend.cpython-312.pyc
rename to Merge/back_rhj/app/blueprints/__pycache__/recommend.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/blueprints/recommend.py b/Merge/back_rhj/app/blueprints/recommend.py
similarity index 100%
rename from rhj/backend/app/blueprints/recommend.py
rename to Merge/back_rhj/app/blueprints/recommend.py
diff --git a/rhj/backend/app/functions/FAuth.py b/Merge/back_rhj/app/functions/FAuth.py
similarity index 100%
rename from rhj/backend/app/functions/FAuth.py
rename to Merge/back_rhj/app/functions/FAuth.py
diff --git a/rhj/backend/app/functions/__pycache__/FAuth.cpython-312.pyc b/Merge/back_rhj/app/functions/__pycache__/FAuth.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/functions/__pycache__/FAuth.cpython-312.pyc
rename to Merge/back_rhj/app/functions/__pycache__/FAuth.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/__init__.py b/Merge/back_rhj/app/models/__init__.py
similarity index 100%
rename from rhj/backend/app/models/__init__.py
rename to Merge/back_rhj/app/models/__init__.py
diff --git a/rhj/backend/app/models/__pycache__/__init__.cpython-312.pyc b/Merge/back_rhj/app/models/__pycache__/__init__.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/__pycache__/__init__.cpython-312.pyc
rename to Merge/back_rhj/app/models/__pycache__/__init__.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/__pycache__/email_verification.cpython-312.pyc b/Merge/back_rhj/app/models/__pycache__/email_verification.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/__pycache__/email_verification.cpython-312.pyc
rename to Merge/back_rhj/app/models/__pycache__/email_verification.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/__pycache__/users.cpython-312.pyc b/Merge/back_rhj/app/models/__pycache__/users.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/__pycache__/users.cpython-312.pyc
rename to Merge/back_rhj/app/models/__pycache__/users.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/email_verification.py b/Merge/back_rhj/app/models/email_verification.py
similarity index 100%
rename from rhj/backend/app/models/email_verification.py
rename to Merge/back_rhj/app/models/email_verification.py
diff --git a/rhj/backend/app/models/recall/__init__.py b/Merge/back_rhj/app/models/recall/__init__.py
similarity index 100%
rename from rhj/backend/app/models/recall/__init__.py
rename to Merge/back_rhj/app/models/recall/__init__.py
diff --git a/rhj/backend/app/models/recall/__pycache__/__init__.cpython-312.pyc b/Merge/back_rhj/app/models/recall/__pycache__/__init__.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recall/__pycache__/__init__.cpython-312.pyc
rename to Merge/back_rhj/app/models/recall/__pycache__/__init__.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recall/__pycache__/ad_recall.cpython-312.pyc b/Merge/back_rhj/app/models/recall/__pycache__/ad_recall.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recall/__pycache__/ad_recall.cpython-312.pyc
rename to Merge/back_rhj/app/models/recall/__pycache__/ad_recall.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recall/__pycache__/bloom_filter.cpython-312.pyc b/Merge/back_rhj/app/models/recall/__pycache__/bloom_filter.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recall/__pycache__/bloom_filter.cpython-312.pyc
rename to Merge/back_rhj/app/models/recall/__pycache__/bloom_filter.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recall/__pycache__/hot_recall.cpython-312.pyc b/Merge/back_rhj/app/models/recall/__pycache__/hot_recall.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recall/__pycache__/hot_recall.cpython-312.pyc
rename to Merge/back_rhj/app/models/recall/__pycache__/hot_recall.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recall/__pycache__/multi_recall_manager.cpython-312.pyc b/Merge/back_rhj/app/models/recall/__pycache__/multi_recall_manager.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recall/__pycache__/multi_recall_manager.cpython-312.pyc
rename to Merge/back_rhj/app/models/recall/__pycache__/multi_recall_manager.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recall/__pycache__/swing_recall.cpython-312.pyc b/Merge/back_rhj/app/models/recall/__pycache__/swing_recall.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recall/__pycache__/swing_recall.cpython-312.pyc
rename to Merge/back_rhj/app/models/recall/__pycache__/swing_recall.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recall/__pycache__/usercf_recall.cpython-312.pyc b/Merge/back_rhj/app/models/recall/__pycache__/usercf_recall.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recall/__pycache__/usercf_recall.cpython-312.pyc
rename to Merge/back_rhj/app/models/recall/__pycache__/usercf_recall.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recall/ad_recall.py b/Merge/back_rhj/app/models/recall/ad_recall.py
similarity index 100%
rename from rhj/backend/app/models/recall/ad_recall.py
rename to Merge/back_rhj/app/models/recall/ad_recall.py
diff --git a/rhj/backend/app/models/recall/bloom_filter.py b/Merge/back_rhj/app/models/recall/bloom_filter.py
similarity index 100%
rename from rhj/backend/app/models/recall/bloom_filter.py
rename to Merge/back_rhj/app/models/recall/bloom_filter.py
diff --git a/rhj/backend/app/models/recall/hot_recall.py b/Merge/back_rhj/app/models/recall/hot_recall.py
similarity index 100%
rename from rhj/backend/app/models/recall/hot_recall.py
rename to Merge/back_rhj/app/models/recall/hot_recall.py
diff --git a/rhj/backend/app/models/recall/multi_recall_manager.py b/Merge/back_rhj/app/models/recall/multi_recall_manager.py
similarity index 100%
rename from rhj/backend/app/models/recall/multi_recall_manager.py
rename to Merge/back_rhj/app/models/recall/multi_recall_manager.py
diff --git a/rhj/backend/app/models/recall/swing_recall.py b/Merge/back_rhj/app/models/recall/swing_recall.py
similarity index 100%
rename from rhj/backend/app/models/recall/swing_recall.py
rename to Merge/back_rhj/app/models/recall/swing_recall.py
diff --git a/rhj/backend/app/models/recall/usercf_recall.py b/Merge/back_rhj/app/models/recall/usercf_recall.py
similarity index 100%
rename from rhj/backend/app/models/recall/usercf_recall.py
rename to Merge/back_rhj/app/models/recall/usercf_recall.py
diff --git a/rhj/backend/app/models/recommend/LightGCN.py b/Merge/back_rhj/app/models/recommend/LightGCN.py
similarity index 100%
rename from rhj/backend/app/models/recommend/LightGCN.py
rename to Merge/back_rhj/app/models/recommend/LightGCN.py
diff --git a/rhj/backend/app/models/recommend/LightGCN_pretrained.pt b/Merge/back_rhj/app/models/recommend/LightGCN_pretrained.pt
similarity index 100%
rename from rhj/backend/app/models/recommend/LightGCN_pretrained.pt
rename to Merge/back_rhj/app/models/recommend/LightGCN_pretrained.pt
Binary files differ
diff --git a/rhj/backend/app/models/recommend/__pycache__/LightGCN.cpython-312.pyc b/Merge/back_rhj/app/models/recommend/__pycache__/LightGCN.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recommend/__pycache__/LightGCN.cpython-312.pyc
rename to Merge/back_rhj/app/models/recommend/__pycache__/LightGCN.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recommend/__pycache__/base_model.cpython-312.pyc b/Merge/back_rhj/app/models/recommend/__pycache__/base_model.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recommend/__pycache__/base_model.cpython-312.pyc
rename to Merge/back_rhj/app/models/recommend/__pycache__/base_model.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recommend/__pycache__/lightgcn_scorer.cpython-312.pyc b/Merge/back_rhj/app/models/recommend/__pycache__/lightgcn_scorer.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recommend/__pycache__/lightgcn_scorer.cpython-312.pyc
rename to Merge/back_rhj/app/models/recommend/__pycache__/lightgcn_scorer.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recommend/__pycache__/operators.cpython-312.pyc b/Merge/back_rhj/app/models/recommend/__pycache__/operators.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/models/recommend/__pycache__/operators.cpython-312.pyc
rename to Merge/back_rhj/app/models/recommend/__pycache__/operators.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/models/recommend/base_model.py b/Merge/back_rhj/app/models/recommend/base_model.py
similarity index 100%
rename from rhj/backend/app/models/recommend/base_model.py
rename to Merge/back_rhj/app/models/recommend/base_model.py
diff --git a/rhj/backend/app/models/recommend/operators.py b/Merge/back_rhj/app/models/recommend/operators.py
similarity index 100%
rename from rhj/backend/app/models/recommend/operators.py
rename to Merge/back_rhj/app/models/recommend/operators.py
diff --git a/rhj/backend/app/models/users.py b/Merge/back_rhj/app/models/users.py
similarity index 100%
rename from rhj/backend/app/models/users.py
rename to Merge/back_rhj/app/models/users.py
diff --git a/rhj/backend/app/routes.py b/Merge/back_rhj/app/routes.py
similarity index 100%
rename from rhj/backend/app/routes.py
rename to Merge/back_rhj/app/routes.py
diff --git a/rhj/backend/app/services/__pycache__/__init__.cpython-312.pyc b/Merge/back_rhj/app/services/__pycache__/__init__.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/services/__pycache__/__init__.cpython-312.pyc
rename to Merge/back_rhj/app/services/__pycache__/__init__.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/services/__pycache__/lightgcn_scorer.cpython-312.pyc b/Merge/back_rhj/app/services/__pycache__/lightgcn_scorer.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/services/__pycache__/lightgcn_scorer.cpython-312.pyc
rename to Merge/back_rhj/app/services/__pycache__/lightgcn_scorer.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/services/__pycache__/recommendation_service.cpython-312.pyc b/Merge/back_rhj/app/services/__pycache__/recommendation_service.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/services/__pycache__/recommendation_service.cpython-312.pyc
rename to Merge/back_rhj/app/services/__pycache__/recommendation_service.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/services/lightgcn_scorer.py b/Merge/back_rhj/app/services/lightgcn_scorer.py
similarity index 100%
rename from rhj/backend/app/services/lightgcn_scorer.py
rename to Merge/back_rhj/app/services/lightgcn_scorer.py
diff --git a/rhj/backend/app/services/recommendation_service.py b/Merge/back_rhj/app/services/recommendation_service.py
similarity index 100%
rename from rhj/backend/app/services/recommendation_service.py
rename to Merge/back_rhj/app/services/recommendation_service.py
diff --git a/rhj/backend/app/user_post_graph.txt b/Merge/back_rhj/app/user_post_graph.txt
similarity index 100%
rename from rhj/backend/app/user_post_graph.txt
rename to Merge/back_rhj/app/user_post_graph.txt
diff --git a/rhj/backend/app/utils/__pycache__/bloom_filter.cpython-312.pyc b/Merge/back_rhj/app/utils/__pycache__/bloom_filter.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/utils/__pycache__/bloom_filter.cpython-312.pyc
rename to Merge/back_rhj/app/utils/__pycache__/bloom_filter.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/utils/__pycache__/bloom_filter_manager.cpython-312.pyc b/Merge/back_rhj/app/utils/__pycache__/bloom_filter_manager.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/utils/__pycache__/bloom_filter_manager.cpython-312.pyc
rename to Merge/back_rhj/app/utils/__pycache__/bloom_filter_manager.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/utils/__pycache__/data_loader.cpython-312.pyc b/Merge/back_rhj/app/utils/__pycache__/data_loader.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/utils/__pycache__/data_loader.cpython-312.pyc
rename to Merge/back_rhj/app/utils/__pycache__/data_loader.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/utils/__pycache__/graph_build.cpython-312.pyc b/Merge/back_rhj/app/utils/__pycache__/graph_build.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/utils/__pycache__/graph_build.cpython-312.pyc
rename to Merge/back_rhj/app/utils/__pycache__/graph_build.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/utils/__pycache__/parse_args.cpython-312.pyc b/Merge/back_rhj/app/utils/__pycache__/parse_args.cpython-312.pyc
similarity index 100%
rename from rhj/backend/app/utils/__pycache__/parse_args.cpython-312.pyc
rename to Merge/back_rhj/app/utils/__pycache__/parse_args.cpython-312.pyc
Binary files differ
diff --git a/rhj/backend/app/utils/data_loader.py b/Merge/back_rhj/app/utils/data_loader.py
similarity index 100%
rename from rhj/backend/app/utils/data_loader.py
rename to Merge/back_rhj/app/utils/data_loader.py
diff --git a/rhj/backend/app/utils/graph_build.py b/Merge/back_rhj/app/utils/graph_build.py
similarity index 100%
rename from rhj/backend/app/utils/graph_build.py
rename to Merge/back_rhj/app/utils/graph_build.py
diff --git a/rhj/backend/app/utils/parse_args.py b/Merge/back_rhj/app/utils/parse_args.py
similarity index 100%
rename from rhj/backend/app/utils/parse_args.py
rename to Merge/back_rhj/app/utils/parse_args.py
diff --git a/rhj/backend/config.py b/Merge/back_rhj/config.py
similarity index 100%
rename from rhj/backend/config.py
rename to Merge/back_rhj/config.py
diff --git a/rhj/backend/test_bloom_filter.py b/Merge/back_rhj/test_bloom_filter.py
similarity index 100%
rename from rhj/backend/test_bloom_filter.py
rename to Merge/back_rhj/test_bloom_filter.py
diff --git a/rhj/backend/test_redbook_recommendation.py b/Merge/back_rhj/test_redbook_recommendation.py
similarity index 100%
rename from rhj/backend/test_redbook_recommendation.py
rename to Merge/back_rhj/test_redbook_recommendation.py
diff --git "a/rhj/backend/\351\202\256\344\273\266\346\234\215\345\212\241\351\205\215\347\275\256\346\214\207\345\215\227.md" "b/Merge/back_rhj/\351\202\256\344\273\266\346\234\215\345\212\241\351\205\215\347\275\256\346\214\207\345\215\227.md"
similarity index 100%
rename from "rhj/backend/\351\202\256\344\273\266\346\234\215\345\212\241\351\205\215\347\275\256\346\214\207\345\215\227.md"
rename to "Merge/back_rhj/\351\202\256\344\273\266\346\234\215\345\212\241\351\205\215\347\275\256\346\214\207\345\215\227.md"
diff --git a/Merge/back_trm/app.py b/Merge/back_trm/app.py
index 3c7fb86..af7fefc 100644
--- a/Merge/back_trm/app.py
+++ b/Merge/back_trm/app.py
@@ -1,8 +1,47 @@
 from app import create_app
 from flask_cors import CORS
+import os
+import psutil
+from flask import Flask,g,request
+import time
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from config import Config
+from app.functions.Fpost import Fpost;
 
 app = create_app()
 CORS(app, resources={r"/*": {"origins": "*"}})
 
+proc=psutil.Process(os.getpid())
+@app.before_request
+def before_request():
+    g.start_time=time.time()
+    g.start_cpu=proc.cpu_times()
+    g.start_mem=proc.memory_info()
+
+@app.after_request
+def after_request(response):
+    end_time = time.time()
+    end_cpu = proc.cpu_times()
+    end_mem = proc.memory_info()
+
+    elapsed = end_time - g.start_time
+    cpu_user = end_cpu.user - g.start_cpu.user
+    cpu_sys  = end_cpu.system - g.start_cpu.system
+    mem_rss  = end_mem.rss - g.start_mem.rss
+
+    #写入性能消耗
+    engine=create_engine(Config.SQLURL)
+    SessionLocal = sessionmaker(bind=engine)
+    session = SessionLocal()
+    f=Fpost(session)
+    f.recordsyscost(
+        request.path,
+        elapsed,
+        cpu_user,
+        cpu_sys,
+        mem_rss
+    )
+    return response
 if __name__ == "__main__":
     app.run(debug=True,port=5713,host='0.0.0.0')
\ No newline at end of file
diff --git a/Merge/back_trm/app/__pycache__/__init__.cpython-310.pyc b/Merge/back_trm/app/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index f713fad..0000000
--- a/Merge/back_trm/app/__pycache__/__init__.cpython-310.pyc
+++ /dev/null
Binary files differ
diff --git a/Merge/back_trm/app/__pycache__/__init__.cpython-312.pyc b/Merge/back_trm/app/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index ec28c7e..0000000
--- a/Merge/back_trm/app/__pycache__/__init__.cpython-312.pyc
+++ /dev/null
Binary files differ
diff --git a/Merge/back_trm/app/__pycache__/routes.cpython-310.pyc b/Merge/back_trm/app/__pycache__/routes.cpython-310.pyc
deleted file mode 100644
index 5166bf4..0000000
--- a/Merge/back_trm/app/__pycache__/routes.cpython-310.pyc
+++ /dev/null
Binary files differ
diff --git a/Merge/back_trm/app/functions/Fpost.py b/Merge/back_trm/app/functions/Fpost.py
index 7d6ccd2..2237815 100644
--- a/Merge/back_trm/app/functions/Fpost.py
+++ b/Merge/back_trm/app/functions/Fpost.py
@@ -4,6 +4,8 @@
 import hashlib
 from datetime import datetime, timedelta
 from sqlalchemy.orm import Session
+from ..models.logs import Log
+from ..models.syscost import PerformanceData
 class Fpost:
     def __init__(self,session:Session):
         self.session=session
@@ -99,4 +101,56 @@
             
         except Exception as e:
             self.session.rollback()
-            raise Exception(f"创建token失败: {str(e)}")
\ No newline at end of file
+            raise Exception(f"创建token失败: {str(e)}")
+        
+    def recordlog(self,user_id,log_type,content,ip):
+        """
+        记录日志
+        :param user_id: 用户ID
+        :param log_type: 日志类型，'access','error','behavior','system'
+        :param content: 日志内容
+        :param ip: IP地址
+        """
+        try:
+            new_log = Log(
+                user_id=user_id,
+                type=log_type,
+                content=content,
+                ip=ip
+            )
+            self.session.add(new_log)
+            self.session.commit()
+        except Exception as e:
+            self.session.rollback()
+            raise Exception(f"记录日志失败: {str(e)}")
+    
+    def getrecordlog(self):
+       res= self.session.query(Log).all()
+       return res 
+    
+    def recordsyscost(self, endpoint: str, elapsed_time: float, cpu_user: float, cpu_system: float, memory_rss: int):
+        """
+        记录系统性能消耗到 performance_data 表
+        :param endpoint: 请求接口路径
+        :param elapsed_time: 总耗时（秒）
+        :param cpu_user: 用户态 CPU 时间差（秒）
+        :param cpu_system: 系统态 CPU 时间差（秒）
+        :param memory_rss: RSS 内存增量（字节）
+        """
+        try:
+            new_record = PerformanceData(
+                endpoint=endpoint,
+                elapsed_time=elapsed_time,
+                cpu_user=cpu_user,
+                cpu_system=cpu_system,
+                memory_rss=memory_rss
+            )
+            self.session.add(new_record)
+            self.session.commit()
+        except Exception as e:
+            self.session.rollback()
+            raise Exception(f"记录系统性能消耗失败: {e}")
+    
+    def getsyscost(self):
+        res= self.session.query(PerformanceData).all()
+        return res
\ No newline at end of file
diff --git a/rhj/backend/app/models/recall/bloom_filter.py b/Merge/back_trm/app/functions/__init__.py
similarity index 100%
copy from rhj/backend/app/models/recall/bloom_filter.py
copy to Merge/back_trm/app/functions/__init__.py
diff --git a/Merge/back_trm/app/functions/__pycache__/Fpost.cpython-310.pyc b/Merge/back_trm/app/functions/__pycache__/Fpost.cpython-310.pyc
index f9b1bc6..3a49c6c 100644
--- a/Merge/back_trm/app/functions/__pycache__/Fpost.cpython-310.pyc
+++ b/Merge/back_trm/app/functions/__pycache__/Fpost.cpython-310.pyc
Binary files differ
diff --git a/Merge/back_trm/app/functions/__pycache__/__init__.cpython-310.pyc b/Merge/back_trm/app/functions/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..ed5a973
--- /dev/null
+++ b/Merge/back_trm/app/functions/__pycache__/__init__.cpython-310.pyc
Binary files differ
diff --git a/Merge/back_trm/app/models/__pycache__/logs.cpython-310.pyc b/Merge/back_trm/app/models/__pycache__/logs.cpython-310.pyc
new file mode 100644
index 0000000..f1e86e3
--- /dev/null
+++ b/Merge/back_trm/app/models/__pycache__/logs.cpython-310.pyc
Binary files differ
diff --git a/Merge/back_trm/app/models/__pycache__/syscost.cpython-310.pyc b/Merge/back_trm/app/models/__pycache__/syscost.cpython-310.pyc
new file mode 100644
index 0000000..9831ffd
--- /dev/null
+++ b/Merge/back_trm/app/models/__pycache__/syscost.cpython-310.pyc
Binary files differ
diff --git a/Merge/back_trm/app/models/logs.py b/Merge/back_trm/app/models/logs.py
new file mode 100644
index 0000000..ac8cf1c
--- /dev/null
+++ b/Merge/back_trm/app/models/logs.py
@@ -0,0 +1,19 @@
+from sqlalchemy import Column, BigInteger, Integer, Enum, Text, String, TIMESTAMP, ForeignKey, Index
+from sqlalchemy.sql import func
+from . import Base  # adjust if Base lives elsewhere
+
+class Log(Base):
+    __tablename__ = 'logs'
+    __table_args__ = (
+        Index('user_id', 'user_id'),
+        Index('idx_logs_created', 'created_at'),
+    )
+
+    id = Column(BigInteger, primary_key=True, autoincrement=True, comment='日志ID')
+    user_id = Column(Integer, ForeignKey('users.id', ondelete='SET NULL'), comment='用户ID')
+    type = Column(Enum('access', 'error', 'behavior', 'system',
+                       name='logs_type_enum'), nullable=False, comment='日志类型')
+    content = Column(Text, nullable=False, comment='日志内容')
+    ip = Column(String(45), nullable=True, comment='IP地址')
+    created_at = Column(TIMESTAMP, server_default=func.current_timestamp(),
+                        nullable=True, comment='记录时间')
diff --git a/Merge/back_trm/app/models/syscost.py b/Merge/back_trm/app/models/syscost.py
new file mode 100644
index 0000000..bbde029
--- /dev/null
+++ b/Merge/back_trm/app/models/syscost.py
@@ -0,0 +1,15 @@
+from sqlalchemy import Column, BigInteger, DateTime, String, Float, func
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+class PerformanceData(Base):
+    __tablename__ = 'performance_data'
+
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+    record_time = Column(DateTime, nullable=False, server_default=func.now(), comment='记录时间')
+    endpoint = Column(String(255), nullable=True, comment='请求接口路径')
+    elapsed_time = Column(Float, nullable=False, comment='总耗时（秒）')
+    cpu_user = Column(Float, nullable=False, comment='用户态 CPU 时间差（秒）')
+    cpu_system = Column(Float, nullable=False, comment='系统态 CPU 时间差（秒）')
+    memory_rss = Column(BigInteger, nullable=False, comment='RSS 内存增量（字节）')
\ No newline at end of file
diff --git a/Merge/back_trm/app/routes.py b/Merge/back_trm/app/routes.py
index 41b022b..625ea6d 100644
--- a/Merge/back_trm/app/routes.py
+++ b/Merge/back_trm/app/routes.py
@@ -5,8 +5,10 @@
 from config import Config
 from flask import jsonify,request
 
+
 main = Blueprint('main', __name__)
 
+
 @main.route('/sgiveadmin',methods=['POST','GET'])
 def giveadmin():
     data=request.get_json()
@@ -17,12 +19,23 @@
     f=Fpost(session)
     checres=f.checkid(data['userid'],'superadmin')
     if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要超级管理员才能执行修改用户角色的操作，但是当前用户不是超级管理员',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Unauthorized'})
     
     res=f.giveadmin(data['targetid'])
     if not res:
+        f.recordlog(data['userid'],
+                     'error', 
+                     f"尝试修改用户{data['targetid']}角色为admin失败，用户不存在",
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'User not found'})
-    
+    f.recordlog(data['userid'],
+                    'behavior', 
+                    f'用户角色为admin修改成功，用户ID: {data["targetid"]} 被修改为管理员',
+                    request.remote_addr)
     return jsonify({'status': 'success', 'message': 'User role updated to admin'})
 
 @main.route('/sgiveuser',methods=['POST','GET'])
@@ -35,12 +48,23 @@
     f=Fpost(session)
     checres=f.checkid(data['userid'],'superadmin')
     if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要超级管理员才能执行修改用户角色的操作，但是当前用户不是超级管理员',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Unauthorized'})
     
     res=f.giveuser(data['targetid'])
     if not res:
+        f.recordlog(data['userid'],
+                     'error', 
+                     f"尝试修改用户{data['targetid']}为user失败，用户不存在",
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'User not found'})
-    
+    f.recordlog(data['userid'],
+                    'behavior', 
+                    f'用户角色修改成功，用户ID: {data["targetid"]} 被修改为普通用户',
+                    request.remote_addr)
     return jsonify({'status': 'success', 'message': 'User role updated to user'})
 
 
@@ -54,12 +78,23 @@
     f=Fpost(session)
     checres=f.checkid(data['userid'],'superadmin')
     if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要超级管理员才能执行修改用户角色的操作，但是当前用户不是超级管理员',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Unauthorized'})
     
     res=f.givesuperadmin(data['targetid'])
     if not res:
+        f.recordlog(data['userid'],
+                     'error', 
+                     f'尝试修改用户{data["targetid"]}角色为superadmin失败，用户不存在',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'User not found'})
-    
+    f.recordlog(data['userid'],
+                    'behavior', 
+                    f'用户角色修改成功，用户ID: {data["targetid"]} 被修改为超级管理员',
+                    request.remote_addr)
     return jsonify({'status': 'success', 'message': 'User role updated to superadmin'})
 
 @main.route('/sgetuserlist',methods=['POST','GET'])
@@ -72,6 +107,10 @@
     f=Fpost(session)
     checres=f.checkid(data['userid'],'superadmin')
     if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要超级管理员才能执行获取用户列表的操作，但是当前用户不是超级管理员',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Unauthorized'})
     res=f.getuserlist()
     respons=[]
@@ -81,6 +120,11 @@
             'username': datai[1],
             'role': datai[2]
         })
+
+    f.recordlog(data['userid'],
+                    'access', 
+                    '获取用户列表成功',
+                    request.remote_addr)
     return jsonify(respons)
 
 @main.route('/apostlist',methods=['POST','GET'])
@@ -93,6 +137,10 @@
     f=Fpost(session)
     checres=f.checkid(data['userid'],'admin')
     if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要管理员才能执行获取帖子列表的操作，但是当前用户不是管理员',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Unauthorized'})
     res=f.getlist()
     respons=[]
@@ -102,6 +150,10 @@
             'title': datai[1],
             'status': datai[2]
         })
+    f.recordlog(data['userid'],
+                 'access', 
+                 '获取帖子列表成功',
+                 request.remote_addr)
     return jsonify(respons)
 
 @main.route('/agetpost',methods=['POST','GET'])
@@ -113,9 +165,22 @@
     f=Fpost(session)
     checres=f.checkid(data['userid'],'admin')
     if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要管理员才能执行获取帖子详情的操作，但是当前用户不是管理员',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Unauthorized'})
     res=f.getpost(data['postid'])
-
+    if not res:
+        f.recordlog(data['userid'],
+                     'error', 
+                     f'尝试获取帖子{data["postid"]}失败，帖子不存在',
+                     request.remote_addr)
+        return jsonify({'status': 'error', 'message': 'Post not found'})
+    f.recordlog(data['userid'],
+                 'access', 
+                 f'获取帖子详情成功，帖子ID: {data["postid"]}',
+                 request.remote_addr)
     return jsonify(res.to_dict() if res else {})
 
 @main.route('/areview',methods=['POST','GET'])
@@ -127,12 +192,23 @@
     f=Fpost(session)
     checres=f.checkid(data['userid'],'admin')
     if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要管理员才能执行帖子审核的操作，但是当前用户不是管理员',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Unauthorized'})
     
     res=f.review(data['postid'],data['status'])
     if not res:
+        f.recordlog(data['userid'],
+                     'error', 
+                     f'尝试审核帖子{data["postid"]}失败，帖子不存在',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Post not found'})
-    
+    f.recordlog(data['userid'],
+                 'behavior', 
+                 f'帖子审核成功，帖子ID: {data["postid"]} 状态更新为 {data["status"]}',
+                 request.remote_addr)
     return jsonify({'status': 'success', 'message': 'Post reviewed successfully'})
 
 
@@ -146,10 +222,102 @@
     f=Fpost(session)
     checres=f.checkid(data['userid'],'admin')
     if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要管理员才能执行Nginx认证的操作，但是当前用户不是管理员',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Unauthorized'})
     
     res=f.nginxauth(data['postid'],data['status'])
     if not res:
+        f.recordlog(data['userid'],
+                     'error', 
+                     f'尝试更新Nginx认证状态失败，帖子{data["postid"]}不存在',
+                     request.remote_addr)
         return jsonify({'status': 'error', 'message': 'Post not found'})
+    f.recordlog(data['userid'],
+                 'behavior', 
+                 f'Nginx认证状态更新成功，帖子ID: {data["postid"]} 状态更新为 {data["status"]}',
+                 request.remote_addr)
+    return jsonify({'status': 'success', 'message': 'Nginx auth updated successfully'})
+
+@main.route('/getsyscost',methods=['POST','GET'])
+def getsyscost():
+    data=request.get_json()
+    engine=create_engine(Config.SQLURL)
+    SessionLocal = sessionmaker(bind=engine)
+    session = SessionLocal()
+    f=Fpost(session)
+    checres=f.checkid(data['userid'],'superadmin')
+    if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要管理员才能执行获取系统性能消耗的操作，但是当前用户不是管理员',
+                     request.remote_addr)
+        return jsonify({'status': 'error', 'message': 'Unauthorized'})
     
-    return jsonify({'status': 'success', 'message': 'Nginx auth updated successfully'})
\ No newline at end of file
+    res=f.getsyscost()
+    if not res:
+        f.recordlog(data['userid'],
+                     'error', 
+                     '尝试获取系统性能消耗数据失败，数据不存在',
+                     request.remote_addr)
+        return jsonify({'status': 'error', 'message': 'No performance data found'})
+    
+    f.recordlog(data['userid'],
+                 'access', 
+                 '获取系统性能消耗数据成功',
+                 request.remote_addr)
+    resdata = []
+    for datai in res:
+        resdata.append({
+            'id': datai.id,
+            'record_time': datai.record_time.isoformat(),
+            'endpoint': datai.endpoint,
+            'elapsed_time': datai.elapsed_time,
+            'cpu_user': datai.cpu_user,
+            'cpu_system': datai.cpu_system,
+            'memory_rss': datai.memory_rss
+        })
+    return jsonify(resdata)
+@main.route('/getrecordlog',methods=['POST','GET'])
+def getrecordlog():
+    data=request.get_json()
+    engine=create_engine(Config.SQLURL)
+    SessionLocal = sessionmaker(bind=engine)
+    session = SessionLocal()
+    f=Fpost(session)
+    checres=f.checkid(data['userid'],'admin')
+    if(not checres):
+        f.recordlog(data['userid'],
+                     'error', 
+                     '系统需要管理员才能执行获取日志的操作，但是当前用户不是管理员',
+                     request.remote_addr)
+        return jsonify({'status': 'error', 'message': 'Unauthorized'})
+    
+    res=f.getrecordlog()
+    if not res:
+        f.recordlog(data['userid'],
+                     'error', 
+                     '尝试获取日志失败，日志不存在',
+                     request.remote_addr)
+        return jsonify({'status': 'error', 'message': 'No logs found'})
+    
+    f.recordlog(data['userid'],
+                 'access', 
+                 '获取日志成功',
+                 request.remote_addr)
+    
+    resdata = []
+    for datai in res:
+        resdata.append({
+            'id': datai.id,
+            'user_id': datai.user_id,
+            'type': datai.type,
+            'content': datai.content,
+            'ip': datai.ip,
+            'created_at': datai.created_at.isoformat()
+        })
+    
+    return jsonify(resdata)
+    
diff --git a/Merge/back_wzy/models/logs.py b/Merge/back_wzy/models/logs.py
new file mode 100644
index 0000000..3170dbd
--- /dev/null
+++ b/Merge/back_wzy/models/logs.py
@@ -0,0 +1,19 @@
+from sqlalchemy import Column, BigInteger, Integer, Enum, Text, String, TIMESTAMP, ForeignKey, Index
+from sqlalchemy.sql import func
+from extensions import db  # adjust if Base lives elsewhere
+
+class Log(db.Model):
+    __tablename__ = 'logs'
+    __table_args__ = (
+        Index('user_id', 'user_id'),
+        Index('idx_logs_created', 'created_at'),
+    )
+
+    id = Column(BigInteger, primary_key=True, autoincrement=True, comment='日志ID')
+    user_id = Column(Integer, ForeignKey('users.id', ondelete='SET NULL'), comment='用户ID')
+    type = Column(Enum('access', 'error', 'behavior', 'system',
+                       name='logs_type_enum'), nullable=False, comment='日志类型')
+    content = Column(Text, nullable=False, comment='日志内容')
+    ip = Column(String(45), nullable=True, comment='IP地址')
+    created_at = Column(TIMESTAMP, server_default=func.current_timestamp(),
+                        nullable=True, comment='记录时间')
diff --git a/Merge/front/package.json b/Merge/front/package.json
index f394aac..31c1d3e 100644
--- a/Merge/front/package.json
+++ b/Merge/front/package.json
@@ -13,7 +13,8 @@
     "react-scripts": "^5.0.1",
     "web-vitals": "^2.1.4",
     "lucide-react": "^0.468.0",
-    "antd": "^4.24.0"
+    "antd": "^4.24.0",
+    "crypto-js": "^4.2.0"
   },
   "scripts": {
     "start": "react-scripts start",
diff --git a/Merge/front/src/components/LogoutButton.js b/Merge/front/src/components/LogoutButton.js
new file mode 100644
index 0000000..a10e716
--- /dev/null
+++ b/Merge/front/src/components/LogoutButton.js
@@ -0,0 +1,77 @@
+import React from 'react';
+import { Button, Modal } from 'antd';
+import { LogoutOutlined } from '@ant-design/icons';
+import { clearAuthInfo, getUserInfo } from '../utils/auth';
+
+const LogoutButton = ({ style = {}, onLogout = null }) => {
+  const userInfo = getUserInfo();
+
+  const handleLogout = () => {
+    Modal.confirm({
+      title: '确认退出',
+      content: '您确定要退出登录吗？',
+      okText: '确定',
+      cancelText: '取消',
+      onOk: () => {
+        // 清除认证信息，但保留记住的登录信息
+        clearAuthInfo(false);
+        
+        // 执行回调函数
+        if (onLogout) {
+          onLogout();
+        } else {
+          // 默认跳转到登录页
+          window.location.href = '/';
+        }
+      }
+    });
+  };
+
+  const handleCompleteLogout = () => {
+    Modal.confirm({
+      title: '完全退出',
+      content: '这将清除所有保存的登录信息，包括"记住我"的设置。确定要继续吗？',
+      okText: '确定',
+      cancelText: '取消',
+      onOk: () => {
+        // 清除所有认证信息，包括记住的登录信息
+        clearAuthInfo(true);
+        
+        // 执行回调函数
+        if (onLogout) {
+          onLogout();
+        } else {
+          // 默认跳转到登录页
+          window.location.href = '/';
+        }
+      }
+    });
+  };
+
+  if (!userInfo) {
+    return null;
+  }
+
+  return (
+    <div style={style}>
+      <Button 
+        type="default" 
+        icon={<LogoutOutlined />}
+        onClick={handleLogout}
+        style={{ marginRight: 8 }}
+      >
+        退出登录
+      </Button>
+      <Button 
+        type="link" 
+        size="small"
+        onClick={handleCompleteLogout}
+        style={{ color: '#ff4d4f' }}
+      >
+        完全退出
+      </Button>
+    </div>
+  );
+};
+
+export default LogoutButton;
diff --git a/Merge/front/src/pages/ForgotPasswordPage/ForgotPasswordPage.css b/Merge/front/src/pages/ForgotPasswordPage/ForgotPasswordPage.css
new file mode 100644
index 0000000..6af35e6
--- /dev/null
+++ b/Merge/front/src/pages/ForgotPasswordPage/ForgotPasswordPage.css
@@ -0,0 +1,915 @@
+/* 忘记密码页面 - 继承注册页面样式 */
+
+/* 导入注册页面的所有样式 */
+@import url('../RegisterPage/RegisterPage.css');
+
+/* 小红书风格忘记密码卡片 */
+.forgot-password-card {
+  background: #fff;
+  border-radius: 8px;
+  padding: 40px; /* 增加桌面端内边距 */
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.1);
+  border: 1px solid #e1e1e1;
+  width: 100%;
+  max-width: 450px; /* 增加桌面端卡片最大宽度 */
+  transition: none;
+}
+
+/* 忘记密码头部 */
+.forgot-password-header {
+  text-align: center;
+  margin-bottom: 40px;
+}
+
+/* Logo样式 */
+.logo-section {
+  margin-bottom: 24px;
+}
+
+.logo-icon {
+  width: 60px;
+  height: 60px;
+  background: #ff2442;
+  border-radius: 12px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 28px;
+  margin: 0 auto 16px;
+  box-shadow: 0 4px 12px rgba(255, 36, 66, 0.2);
+}
+
+.forgot-password-title {
+  font-size: 24px;
+  font-weight: 600;
+  color: #333;
+  margin: 0 0 12px 0;
+  text-align: center;
+}
+
+.forgot-password-title::after {
+  display: none;
+}
+
+.forgot-password-subtitle {
+  font-size: 14px;
+  color: #999;
+  margin: 0 0 32px 0;
+  font-weight: 400;
+  text-align: center;
+}
+
+/* 表单样式 */
+.forgot-password-form {
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+  width: 100%;
+}
+
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  width: 100%;
+  box-sizing: border-box;
+  margin-bottom: 2px;
+  position: relative; /* 为绝对定位的错误提示提供参考点 */
+}
+
+.form-group .input-wrapper {
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.form-label {
+  font-size: 14px;
+  font-weight: 500;
+  color: #333;
+  margin-bottom: 8px;
+}
+
+.input-wrapper {
+  position: relative;
+  display: flex;
+  align-items: center;
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.form-input {
+  width: 100% !important;
+  height: 44px;
+  padding: 12px 16px 12px 48px;
+  border: 1px solid #e1e1e1;
+  border-radius: 6px;
+  font-size: 14px;
+  transition: border-color 0.2s ease;
+  background: #fff;
+  color: #333;
+  box-sizing: border-box !important;
+  flex: 1;
+  min-width: 0;
+}
+
+/* 针对 Antd Input 组件的特定样式 */
+.form-input.ant-input,
+.form-input.ant-input-affix-wrapper {
+  width: 100% !important;
+  height: 44px !important;
+  border: 1px solid #e1e1e1 !important;
+  border-radius: 6px !important;
+  padding: 12px 48px 12px 48px !important;
+  font-size: 14px !important;
+  background: #fff !important;
+  color: #333 !important;
+  box-sizing: border-box !important;
+  flex: 1 !important;
+  min-width: 0 !important;
+  display: flex !important;
+  align-items: center !important;
+}
+
+.form-input.ant-input-affix-wrapper .ant-input {
+  width: 100% !important;
+  height: 100% !important;
+  padding: 0 !important;
+  border: none !important;
+  background: transparent !important;
+  flex: 1 !important;
+  min-width: 0 !important;
+  box-sizing: border-box !important;
+}
+
+.form-input:focus {
+  outline: none;
+  border-color: #ff2442;
+  box-shadow: none;
+  transform: none;
+}
+
+/* Antd Input focus 样式 */
+.form-input.ant-input:focus,
+.form-input.ant-input-affix-wrapper:focus,
+.form-input.ant-input-affix-wrapper-focused {
+  outline: none !important;
+  border-color: #ff2442 !important;
+  box-shadow: none !important;
+  transform: none !important;
+}
+
+.form-input::placeholder {
+  color: #9ca3af;
+}
+
+.input-icon {
+  position: absolute;
+  left: 16px;
+  top: 50%;
+  transform: translateY(-50%);
+  color: #9ca3af;
+  pointer-events: none;
+  transition: color 0.3s ease;
+  z-index: 2;
+}
+
+.form-input:focus + .input-icon {
+  color: #ff2442;
+}
+
+/* 邮箱验证码输入框容器 */
+.email-code-wrapper {
+  display: flex;
+  gap: 8px;
+  width: 100%;
+  box-sizing: border-box;
+  align-items: flex-start;
+}
+
+.email-code-input {
+  flex: 1;
+  min-width: 0;
+}
+
+.send-code-button {
+  height: 44px !important;
+  padding: 0 16px !important;
+  background: #ff2442 !important;
+  border-color: #ff2442 !important;
+  border-radius: 6px !important;
+  font-size: 14px !important;
+  font-weight: 500 !important;
+  white-space: nowrap !important;
+  flex-shrink: 0 !important;
+  min-width: 100px !important;
+  display: flex !important;
+  align-items: center !important;
+  justify-content: center !important;
+  transition: all 0.2s ease !important;
+  box-sizing: border-box !important;
+}
+
+.send-code-button:hover:not(:disabled) {
+  background: #d91e3a !important;
+  border-color: #d91e3a !important;
+  transform: none !important;
+  box-shadow: none !important;
+}
+
+.send-code-button:disabled {
+  background: #f5f5f5 !important;
+  border-color: #d9d9d9 !important;
+  color: #bfbfbf !important;
+  cursor: not-allowed !important;
+}
+
+.send-code-button.ant-btn-loading {
+  background: #ff2442 !important;
+  border-color: #ff2442 !important;
+  color: white !important;
+}
+
+/* 小红书风格忘记密码按钮 */
+.forgot-password-button {
+  width: 100%;
+  height: 48px; /* 固定高度，防止布局变化 */
+  padding: 12px;
+  background: #ff2442;
+  color: white;
+  border: none;
+  border-radius: 6px;
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  margin-top: 8px;
+  position: relative; /* 为绝对定位的加载状态做准备 */
+  box-sizing: border-box; /* 确保padding包含在总尺寸内 */
+  min-width: 0; /* 防止flex子元素造成宽度变化 */
+}
+
+.forgot-password-button:hover:not(:disabled) {
+  background: #d91e3a;
+  transform: none;
+  box-shadow: none;
+}
+
+.forgot-password-button:active:not(:disabled) {
+  transform: none;
+}
+
+.forgot-password-button:disabled {
+  background: #ccc;
+  cursor: not-allowed;
+  opacity: 0.8;
+}
+
+.forgot-password-button.loading {
+  background: #ff7b8a;
+  cursor: not-allowed;
+}
+
+.loading-spinner {
+  width: 16px;
+  height: 16px;
+  border: 2px solid rgba(255, 255, 255, 0.3);
+  border-radius: 50%;
+  border-top-color: #fff;
+  animation: spin 1s ease-in-out infinite;
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+/* 加载遮罩层 */
+.loading-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+  backdrop-filter: blur(4px);
+}
+
+.loading-content {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 16px;
+  background: white;
+  padding: 32px;
+  border-radius: 12px;
+  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
+}
+
+.loading-spinner-large {
+  width: 40px;
+  height: 40px;
+  border: 4px solid rgba(255, 36, 66, 0.2);
+  border-radius: 50%;
+  border-top-color: #ff2442;
+  animation: spin 1s ease-in-out infinite;
+}
+
+.loading-text {
+  margin: 0;
+  color: #333;
+  font-size: 16px;
+  font-weight: 500;
+}
+
+/* 登录链接 */
+.login-link {
+  text-align: center;
+  margin-top: 20px;
+  padding-top: 20px;
+  border-top: 1px solid #e5e7eb;
+}
+
+.login-link p {
+  margin: 0 0 8px 0;
+  font-size: 14px;
+  color: #64748b;
+}
+
+.login-link p:last-child {
+  margin-bottom: 0;
+}
+
+.login-link a {
+  color: #ff2442;
+  text-decoration: none;
+  font-weight: 500;
+  transition: color 0.2s ease;
+}
+
+.login-link a:hover {
+  color: #d91e3a;
+  text-decoration: underline;
+}
+
+/* 返回邮箱输入样式 */
+.back-to-email {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 12px 16px;
+  background: #f8f8f8;
+  border-radius: 6px;
+  border: 1px solid #e1e1e1;
+}
+
+.back-button {
+  background: none;
+  border: none;
+  color: #ff2442;
+  font-size: 14px;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 0;
+  transition: color 0.2s ease;
+  width: fit-content;
+}
+
+.back-button:hover {
+  color: #d91e3a;
+}
+
+.email-display {
+  font-size: 14px;
+  color: #666;
+  font-weight: 500;
+}
+
+/* 有左侧图标时的内边距调整 */
+.input-wrapper.has-icon .form-input {
+  padding-left: 48px !important;
+}
+
+.input-wrapper.has-icon .form-input.ant-input,
+.input-wrapper.has-icon .form-input.ant-input-affix-wrapper {
+  padding-left: 48px !important;
+}
+
+/* 有右侧切换按钮时的内边距调整 */
+.input-wrapper.has-toggle .form-input {
+  padding-right: 48px !important;
+}
+
+.input-wrapper.has-toggle .form-input.ant-input,
+.input-wrapper.has-toggle .form-input.ant-input-affix-wrapper {
+  padding-right: 48px !important;
+}
+
+/* 没有图标时的内边距调整 */
+.input-wrapper:not(.has-icon) .form-input {
+  padding-left: 16px !important;
+}
+
+.input-wrapper:not(.has-icon) .form-input.ant-input,
+.input-wrapper:not(.has-icon) .form-input.ant-input-affix-wrapper {
+  padding-left: 16px !important;
+}
+
+/* 没有切换按钮时的内边距调整 */
+.input-wrapper:not(.has-toggle) .form-input {
+  padding-right: 16px !important;
+}
+
+.input-wrapper:not(.has-toggle) .form-input.ant-input,
+.input-wrapper:not(.has-toggle) .form-input.ant-input-affix-wrapper {
+  padding-right: 16px !important;
+}
+
+/* 确保输入框内容完全填充 */
+.form-input.ant-input-affix-wrapper .ant-input-suffix {
+  position: absolute !important;
+  right: 12px !important;
+  top: 50% !important;
+  transform: translateY(-50%) !important;
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+.form-input.ant-input-affix-wrapper .ant-input-prefix {
+  position: absolute !important;
+  left: 16px !important;
+  top: 50% !important;
+  transform: translateY(-50%) !important;
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+/* 确保所有输入框完全填充其容器 */
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.form-group .input-wrapper {
+  width: 100%;
+  box-sizing: border-box;
+}
+
+/* 防止输入框溢出容器 */
+.form-input,
+.form-input.ant-input,
+.form-input.ant-input-affix-wrapper {
+  max-width: 100% !important;
+  overflow: hidden !important;
+}
+
+/* 确保内部输入元素不会超出边界 */
+.form-input.ant-input-affix-wrapper .ant-input {
+  max-width: 100% !important;
+  overflow: hidden !important;
+  text-overflow: ellipsis !important;
+}
+
+/* 精细间距控制 */
+.forgot-password-header + .forgot-password-form {
+  margin-top: -4px;
+}
+
+.forgot-password-form .form-group:not(:last-child) {
+  margin-bottom: 2px;
+}
+
+.forgot-password-form .form-group:last-of-type {
+  margin-bottom: 6px;
+}
+
+.forgot-password-button + .login-link {
+  margin-top: 14px;
+}
+
+/* 响应式设计 */
+@media (max-width: 768px) {
+  /* 重置body和html确保一致性 */
+  html, body {
+    height: 100%;
+    height: 100dvh;
+    margin: 0;
+    padding: 0;
+    overflow-x: hidden;
+    box-sizing: border-box;
+  }
+  
+  .forgot-password-container {
+    padding: 16px;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    min-height: 100dvh; /* 动态视口高度 */
+    /* 强制重置可能影响定位的样式 */
+    margin: 0;
+    box-sizing: border-box;
+    /* 防止内容溢出影响布局 */
+    overflow-x: hidden;
+    overflow-y: auto;
+    /* 确保flexbox在所有移动设备上表现一致 */
+    -webkit-box-align: center;
+    -webkit-box-pack: center;
+    display: flex !important;
+    position: relative;
+  }
+  
+  .forgot-password-content {
+    max-width: 100%;
+    padding: 20px;
+    /* 确保内容区域稳定 */
+    margin: 0 auto;
+    box-sizing: border-box;
+    /* 防止宽度计算问题 */
+    width: calc(100% - 40px);
+    max-width: 480px; /* 增加最大宽度 */
+    position: relative;
+    display: flex;
+    justify-content: center;
+  }
+  
+  .forgot-password-card {
+    padding: 32px 28px; /* 增加内边距 */
+    border-radius: 16px;
+    /* 确保卡片稳定定位 */
+    margin: 0;
+    box-sizing: border-box;
+    width: 100%;
+    max-width: 450px; /* 增加卡片最大宽度 */
+    /* 防止backdrop-filter导致的渲染差异 */
+    will-change: auto;
+    position: relative;
+    /* 防止触摸操作影响布局 */
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    -webkit-tap-highlight-color: transparent;
+  }
+  
+  .forgot-password-title {
+    font-size: 24px;
+  }
+  
+  .form-input {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px;
+    font-size: 16px; /* 防止iOS Safari缩放 */
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input,
+  .form-input.ant-input-affix-wrapper {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px !important;
+    font-size: 16px !important;
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input-affix-wrapper .ant-input {
+    width: 100% !important;
+    height: 100% !important;
+    padding: 0 !important;
+    border: none !important;
+    background: transparent !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+    box-sizing: border-box !important;
+  }
+}
+
+@media (max-width: 480px) {
+  .forgot-password-container {
+    padding: 16px;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    min-height: 100dvh; /* 动态视口高度 */
+    /* 强制重置样式 */
+    margin: 0;
+    box-sizing: border-box;
+    position: relative;
+    /* 确保垂直居中 */
+    display: flex !important;
+  }
+  
+  .forgot-password-content {
+    /* 更严格的尺寸控制 */
+    width: calc(100vw - 32px);
+    max-width: 420px; /* 增加最大宽度 */
+    padding: 16px;
+    margin: 0 auto;
+    box-sizing: border-box;
+    display: flex;
+    justify-content: center;
+  }
+  
+  .forgot-password-card {
+    padding: 28px 24px; /* 增加内边距 */
+    border-radius: 12px;
+    /* 确保卡片完全稳定 */
+    margin: 0;
+    box-sizing: border-box;
+    width: 100%;
+    position: relative;
+    /* 防止变换导致的位置偏移 */
+    transform: none !important;
+    /* 防止触摸操作影响布局 */
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    /* 防止点击时的高亮效果影响布局 */
+    -webkit-tap-highlight-color: transparent;
+  }
+  
+  .forgot-password-title {
+    font-size: 22px;
+  }
+  
+  .form-input {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px;
+    font-size: 16px; /* 防止iOS Safari缩放 */
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input,
+  .form-input.ant-input-affix-wrapper {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px !important;
+    font-size: 16px !important;
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input-affix-wrapper .ant-input {
+    width: 100% !important;
+    height: 100% !important;
+    padding: 0 !important;
+    border: none !important;
+    background: transparent !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+    box-sizing: border-box !important;
+  }
+  
+  /* 移动端优化 */
+  .background-pattern {
+    display: none;
+  }
+  
+  /* 禁用可能影响位置的悬停效果 */
+  .forgot-password-card:hover {
+    transform: none !important;
+  }
+}
+
+/* 高对比度模式支持 */
+@media (prefers-contrast: high) {
+  .forgot-password-card {
+    background: white;
+    border: 2px solid #000;
+  }
+  
+  .form-input {
+    border-color: #000;
+  }
+  
+  .form-input:focus {
+    border-color: #0066cc;
+    box-shadow: 0 0 0 2px #0066cc;
+  }
+}
+
+/* 减少动画模式 */
+@media (prefers-reduced-motion: reduce) {
+  .background-pattern {
+    animation: none;
+  }
+  
+  .forgot-password-card,
+  .form-input,
+  .forgot-password-button {
+    transition: none;
+  }
+}
+
+/* 深色模式支持 */
+@media (prefers-color-scheme: dark) {
+  .forgot-password-background {
+    background: linear-gradient(135deg, #1a202c 0%, #2d3748 100%);
+  }
+  
+  .forgot-password-card {
+    background: rgba(26, 32, 44, 0.95);
+    border-color: rgba(255, 255, 255, 0.1);
+  }
+  
+  .forgot-password-title {
+    color: #f7fafc;
+  }
+  
+  .forgot-password-subtitle {
+    color: #a0aec0;
+  }
+  
+  .form-label {
+    color: #e2e8f0;
+  }
+  
+  .form-input {
+    background: #2d3748;
+    border-color: #4a5568;
+    color: #f7fafc;
+  }
+  
+  .form-input:focus {
+    border-color: #ff2442;
+  }
+  
+  .login-link {
+    border-color: #4a5568;
+  }
+  
+  .login-link p {
+    color: #a0aec0;
+  }
+  
+  /* 深色模式下的错误提示样式 */
+  .error-message {
+    background: rgba(26, 32, 44, 0.95);
+    color: #ff6b6b;
+  }
+  
+  .back-to-email {
+    background: #2d3748;
+    border-color: #4a5568;
+  }
+  
+  .email-display {
+    color: #a0aec0;
+  }
+}
+
+/* 错误提示样式 - 使用绝对定位避免影响布局 */
+.error-message {
+  position: absolute;
+  top: 95%;
+  left: 4px;
+  right: 4px;
+  font-size: 12px;
+  color: #ff4d4f;
+  margin-top: 4px;
+  display: flex;
+  align-items: center;
+  min-height: 16px;
+  animation: fadeInDown 0.3s ease-out;
+  font-weight: 400;
+  line-height: 1.2;
+  background: rgba(255, 255, 255, 0.95);
+  backdrop-filter: blur(4px);
+  padding: 2px 4px;
+  border-radius: 4px;
+  z-index: 10;
+  pointer-events: none; /* 避免干扰用户交互 */
+}
+
+@keyframes fadeInDown {
+  from {
+    opacity: 0;
+    transform: translateY(-8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+/* 输入框错误状态样式 */
+.form-input.input-error,
+.form-input.input-error.ant-input,
+.form-input.input-error.ant-input-affix-wrapper {
+  border-color: #ff4d4f !important;
+  box-shadow: 0 0 0 2px rgba(255, 77, 79, 0.1) !important;
+  transition: all 0.3s ease !important;
+}
+
+.form-input.input-error:focus,
+.form-input.input-error.ant-input:focus,
+.form-input.input-error.ant-input-affix-wrapper:focus,
+.form-input.input-error.ant-input-affix-wrapper-focused {
+  border-color: #ff4d4f !important;
+  box-shadow: 0 0 0 2px rgba(255, 77, 79, 0.2) !important;
+}
+
+/* 错误状态下的图标颜色 */
+.form-input.input-error .anticon {
+  color: #ff4d4f !important;
+}
+
+/* 确保表单组间距一致 */
+.form-group {
+  margin-bottom: 0px;
+}
+
+.form-group:last-of-type {
+  margin-bottom: 0px;
+}
+
+/* 错误弹窗样式 */
+.error-modal .ant-modal-header {
+  background: #fff;
+  border-bottom: 1px solid #f0f0f0;
+  padding: 16px 24px;
+}
+
+.error-modal .ant-modal-title {
+  color: #333;
+  font-weight: 600;
+  font-size: 16px;
+}
+
+.error-modal .ant-modal-body {
+  padding: 16px 24px 24px;
+}
+
+.error-modal .ant-modal-footer {
+  padding: 12px 24px 24px;
+  border-top: none;
+  text-align: center;
+}
+
+.error-modal .ant-btn-primary {
+  background: #ff2442;
+  border-color: #ff2442;
+  font-weight: 500;
+  height: 40px;
+  padding: 0 24px;
+  border-radius: 6px;
+  transition: all 0.2s ease;
+}
+
+.error-modal .ant-btn-primary:hover {
+  background: #d91e3a;
+  border-color: #d91e3a;
+  transform: translateY(-1px);
+  box-shadow: 0 4px 12px rgba(255, 36, 66, 0.3);
+}
+
+.error-modal .ant-modal-content {
+  border-radius: 12px;
+  overflow: hidden;
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
+}
+
+/* 错误弹窗遮罩层 */
+.error-modal .ant-modal-mask {
+  background: rgba(0, 0, 0, 0.6);
+  backdrop-filter: blur(4px);
+}
+
+/* 错误弹窗动画 */
+.error-modal .ant-modal {
+  animation: errorModalSlideIn 0.3s ease-out;
+}
+
+@keyframes errorModalSlideIn {
+  from {
+    opacity: 0;
+    transform: translateY(-20px) scale(0.95);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
diff --git a/Merge/front/src/pages/ForgotPasswordPage/ForgotPasswordPage.js b/Merge/front/src/pages/ForgotPasswordPage/ForgotPasswordPage.js
new file mode 100644
index 0000000..d0437d5
--- /dev/null
+++ b/Merge/front/src/pages/ForgotPasswordPage/ForgotPasswordPage.js
@@ -0,0 +1,567 @@
+import React, { useState } from 'react';
+import { Link, useNavigate } from 'react-router-dom';
+import { Input, Button, message, Modal, Alert } from 'antd';
+import { MailOutlined, LockOutlined, SafetyOutlined, ExclamationCircleOutlined, CheckCircleOutlined } from '@ant-design/icons';
+import { hashPassword } from '../../utils/crypto';
+import './ForgotPasswordPage.css';
+
+const baseURL = 'http://10.126.59.25:8082';
+
+const ForgotPasswordPage = () => {
+  const [formData, setFormData] = useState({
+    email: '',
+    emailCode: '',
+    newPassword: '',
+    confirmPassword: ''
+  });
+
+  const [errors, setErrors] = useState({
+    email: '',
+    emailCode: '',
+    newPassword: '',
+    confirmPassword: ''
+  });
+
+  const [emailCodeSent, setEmailCodeSent] = useState(false);
+  const [countdown, setCountdown] = useState(0);
+  const [sendingCode, setSendingCode] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [errorModal, setErrorModal] = useState({
+    visible: false,
+    title: '',
+    content: ''
+  });
+  const [successAlert, setSuccessAlert] = useState({
+    visible: false,
+    message: ''
+  });
+  const [emailCodeSuccessAlert, setEmailCodeSuccessAlert] = useState({
+    visible: false,
+    message: ''
+  });
+
+  const navigate = useNavigate();
+
+  // 显示错误弹窗
+  const showErrorModal = (title, content) => {
+    setErrorModal({
+      visible: true,
+      title: title,
+      content: content
+    });
+  };
+
+  // 关闭错误弹窗
+  const closeErrorModal = () => {
+    setErrorModal({
+      visible: false,
+      title: '',
+      content: ''
+    });
+  };
+
+  // 显示成功提示
+  const showSuccessAlert = (message) => {
+    setSuccessAlert({
+      visible: true,
+      message: message
+    });
+    
+    // 3秒后自动隐藏
+    setTimeout(() => {
+      setSuccessAlert({
+        visible: false,
+        message: ''
+      });
+    }, 3000);
+  };
+
+  // 显示邮件验证码发送成功提示
+  const showEmailCodeSuccessAlert = (message) => {
+    setEmailCodeSuccessAlert({
+      visible: true,
+      message: message
+    });
+    
+    // 5秒后自动隐藏
+    setTimeout(() => {
+      setEmailCodeSuccessAlert({
+        visible: false,
+        message: ''
+      });
+    }, 5000);
+  };
+
+  // 倒计时效果
+  React.useEffect(() => {
+    let timer;
+    if (countdown > 0) {
+      timer = setTimeout(() => {
+        setCountdown(countdown - 1);
+      }, 1000);
+    }
+    return () => clearTimeout(timer);
+  }, [countdown]);
+
+  // 发送邮箱验证码
+  const sendEmailCode = async () => {
+    // 验证邮箱格式
+    if (!formData.email || typeof formData.email !== 'string' || !formData.email.trim()) {
+      setErrors(prev => ({
+        ...prev,
+        email: '请先输入邮箱地址'
+      }));
+      return;
+    }
+    
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) {
+      setErrors(prev => ({
+        ...prev,
+        email: '请输入有效的邮箱地址'
+      }));
+      return;
+    }
+
+    setSendingCode(true);
+    
+    try {
+      // 调用后端API发送验证码
+      const response = await fetch(baseURL + '/send-verification-code', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          email: formData.email,
+          type: 'reset_password'
+        })
+      });
+      
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      
+      const result = await response.json();
+      
+      if (result.success) {
+        showEmailCodeSuccessAlert('验证码已发送到您的邮箱');
+        setEmailCodeSent(true);
+        setCountdown(60); // 60秒倒计时
+        
+        // 清除邮箱错误提示
+        setErrors(prev => ({
+          ...prev,
+          email: ''
+        }));
+      } else {
+        // 根据具体错误信息进行处理
+        const errorMessage = result.message || '发送验证码失败，请稍后再试';
+        
+        if (errorMessage.includes('用户不存在') || errorMessage.includes('邮箱未注册')) {
+          setErrors(prev => ({
+            ...prev,
+            email: '该邮箱尚未注册，请检查邮箱地址或先注册账户'
+          }));
+        } else {
+          showErrorModal('发送验证码失败', errorMessage);
+        }
+      }
+      
+    } catch (error) {
+      console.error('发送验证码失败:', error);
+      
+      // 根据错误类型显示不同的错误信息
+      if (error.name === 'TypeError' && error.message.includes('Failed to fetch')) {
+        showErrorModal('网络连接失败', '无法连接到服务器，请检查您的网络连接后重试。');
+      } else if (error.message.includes('HTTP 500')) {
+        showErrorModal('服务器错误', '服务器出现了内部错误，请稍后重试。');
+      } else if (error.message.includes('HTTP 429')) {
+        showErrorModal('发送频率限制', '验证码发送过于频繁，请稍后再试。');
+      } else if (error.message.includes('HTTP 400')) {
+        showErrorModal('请求错误', '邮箱格式错误，请检查邮箱地址是否正确。');
+      } else {
+        showErrorModal('发送失败', '发送验证码失败，请稍后重试。');
+      }
+    } finally {
+      setSendingCode(false);
+    }
+  };
+
+  const handleInputChange = (field) => (e) => {
+    const value = e.target.value;
+    setFormData(prev => ({
+      ...prev,
+      [field]: value
+    }));
+    
+    // 清除对应字段的错误提示
+    if (errors[field]) {
+      setErrors(prev => ({
+        ...prev,
+        [field]: ''
+      }));
+    }
+  };
+
+  const handlePasswordChange = (e) => {
+    const value = e.target.value;
+    setFormData(prev => ({
+      ...prev,
+      newPassword: value
+    }));
+    
+    // 清除密码错误提示
+    if (errors.newPassword) {
+      setErrors(prev => ({
+        ...prev,
+        newPassword: ''
+      }));
+    }
+  };
+
+  const handleConfirmPasswordChange = (e) => {
+    const value = e.target.value;
+    setFormData(prev => ({
+      ...prev,
+      confirmPassword: value
+    }));
+    
+    // 清除确认密码错误提示
+    if (errors.confirmPassword) {
+      setErrors(prev => ({
+        ...prev,
+        confirmPassword: ''
+      }));
+    }
+  };
+
+  const validateForm = () => {
+    const newErrors = {
+      email: '',
+      emailCode: '',
+      newPassword: '',
+      confirmPassword: ''
+    };
+    
+    let hasError = false;
+    
+    // 验证邮箱
+    if (!formData.email || typeof formData.email !== 'string' || !formData.email.trim()) {
+      newErrors.email = '请输入邮箱地址';
+      hasError = true;
+    } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) {
+      newErrors.email = '请输入有效的邮箱地址';
+      hasError = true;
+    }
+    
+    // 验证邮箱验证码
+    if (!formData.emailCode || typeof formData.emailCode !== 'string' || !formData.emailCode.trim()) {
+      newErrors.emailCode = '请输入邮箱验证码';
+      hasError = true;
+    } else if (formData.emailCode.length !== 6 || !/^\d{6}$/.test(formData.emailCode)) {
+      newErrors.emailCode = '请输入6位数字验证码';
+      hasError = true;
+    }
+    
+    // 验证新密码
+    if (!formData.newPassword || typeof formData.newPassword !== 'string' || !formData.newPassword.trim()) {
+      newErrors.newPassword = '请输入新密码';
+      hasError = true;
+    } else if (formData.newPassword.length < 6) {
+      newErrors.newPassword = '密码长度至少6位';
+      hasError = true;
+    } else if (formData.newPassword.length > 20) {
+      newErrors.newPassword = '密码长度不能超过20位';
+      hasError = true;
+    }
+    
+    // 验证确认密码
+    if (!formData.confirmPassword || typeof formData.confirmPassword !== 'string' || !formData.confirmPassword.trim()) {
+      newErrors.confirmPassword = '请确认新密码';
+      hasError = true;
+    } else if (formData.newPassword !== formData.confirmPassword) {
+      newErrors.confirmPassword = '两次输入的密码不一致';
+      hasError = true;
+    }
+    
+    setErrors(newErrors);
+    return !hasError;
+  };
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    
+    // 验证表单
+    if (!validateForm()) {
+      return;
+    }
+    
+    setIsLoading(true);
+    
+    try {
+      // 验证码验证成功，重置密码
+      const resetResponse = await fetch(baseURL + '/reset-password', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          email: formData.email,
+          new_password: hashPassword(formData.newPassword), // 前端加密密码
+          verification_code: hashPassword(formData.emailCode) // 前端加密验证码
+        })
+      });
+      
+      if (!resetResponse.ok) {
+        throw new Error(`HTTP ${resetResponse.status}: ${resetResponse.statusText}`);
+      }
+      
+      const resetResult = await resetResponse.json();
+      
+      if (resetResult.success) {
+        showSuccessAlert('密码重置成功！请使用新密码登录，正在跳转到登录页面...');
+        // 清空表单数据
+        setFormData({
+          email: '',
+          emailCode: '',
+          newPassword: '',
+          confirmPassword: ''
+        });
+        setErrors({
+          email: '',
+          emailCode: '',
+          newPassword: '',
+          confirmPassword: ''
+        });
+        // 延迟跳转到登录页面，让用户看到成功提示
+        setTimeout(() => {
+          navigate('/login');
+        }, 2000);
+      } else {
+        // 处理重置密码失败的情况
+        const errorMessage = resetResult.message || '密码重置失败，请稍后再试';
+        showErrorModal('密码重置失败', errorMessage);
+      }
+      
+    } catch (error) {
+      console.error('密码重置失败:', error);
+      
+      // 根据错误类型显示不同的错误信息
+      if (error.name === 'TypeError' && error.message.includes('Failed to fetch')) {
+        showErrorModal('网络连接失败', '无法连接到服务器，请检查您的网络连接后重试。');
+      } else if (error.message.includes('HTTP 500')) {
+        showErrorModal('服务器内部错误', '服务器出现了内部错误，请稍后重试。');
+      } else if (error.message.includes('HTTP 400')) {
+        showErrorModal('请求参数错误', '请求参数有误，请检查您输入的信息是否正确。');
+      } else if (error.message.includes('HTTP 409')) {
+        showErrorModal('操作冲突', '重置操作发生冲突，请稍后重试。');
+      } else {
+        showErrorModal('重置失败', '密码重置失败，请稍后重试。');
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return (
+    <div className="register-container">
+      <div className="register-background"></div>
+      
+      {isLoading && (
+        <div className="loading-overlay">
+          <div className="loading-content">
+            <div className="loading-spinner-large"></div>
+            <p className="loading-text">正在重置密码...</p>
+          </div>
+        </div>
+      )}
+      
+      <div className="register-content">
+        <div className="register-card">
+          {/* 成功提示 */}
+          {successAlert.visible && (
+            <div style={{ marginBottom: '16px' }}>
+              <Alert
+                message={successAlert.message}
+                type="success"
+                icon={<CheckCircleOutlined />}
+                showIcon
+                closable
+                onClose={() => setSuccessAlert({ visible: false, message: '' })}
+                style={{
+                  borderRadius: '8px',
+                  border: '1px solid #b7eb8f',
+                  backgroundColor: '#f6ffed'
+                }}
+              />
+            </div>
+          )}
+
+          {/* 邮件验证码发送成功提示 */}
+          {emailCodeSuccessAlert.visible && (
+            <div style={{ marginBottom: '16px' }}>
+              <Alert
+                message={emailCodeSuccessAlert.message}
+                type="success"
+                icon={<CheckCircleOutlined />}
+                showIcon
+                closable
+                onClose={() => setEmailCodeSuccessAlert({ visible: false, message: '' })}
+                style={{
+                  borderRadius: '8px',
+                  border: '1px solid #b7eb8f',
+                  backgroundColor: '#f6ffed'
+                }}
+              />
+            </div>
+          )}
+          
+          <div className="register-header">
+            <h1 className="register-title">重置密码</h1>
+            <p className="register-subtitle">请输入邮箱地址和新密码</p>
+          </div>
+
+          <form className="register-form" onSubmit={handleSubmit}>
+            <div className="form-group">
+              <Input
+                type="email"
+                id="email"
+                name="email"
+                className={`form-input ${errors.email ? 'input-error' : ''}`}
+                placeholder="请输入邮箱地址"
+                value={formData.email}
+                onChange={handleInputChange('email')}
+                prefix={<MailOutlined />}
+                size="large"
+                title=""
+                status={errors.email ? 'error' : ''}
+              />
+              {errors.email && (
+                <div className="error-message">
+                  {errors.email}
+                </div>
+              )}
+            </div>
+
+            <div className="form-group">
+              <div className="email-code-wrapper">
+                <Input
+                  type="text"
+                  id="emailCode"
+                  name="emailCode"
+                  className={`form-input email-code-input ${errors.emailCode ? 'input-error' : ''}`}
+                  placeholder="请输入6位验证码"
+                  value={formData.emailCode}
+                  onChange={handleInputChange('emailCode')}
+                  prefix={<SafetyOutlined />}
+                  maxLength={6}
+                  size="large"
+                  title=""
+                  status={errors.emailCode ? 'error' : ''}
+                />
+                <Button
+                  type="primary"
+                  className="send-code-button"
+                  onClick={sendEmailCode}
+                  loading={sendingCode}
+                  disabled={countdown > 0 || !formData.email || sendingCode}
+                  size="large"
+                >
+                  {countdown > 0 ? `${countdown}s后重发` : (emailCodeSent ? '重新发送' : '发送验证码')}
+                </Button>
+              </div>
+              {errors.emailCode && (
+                <div className="error-message">
+                  {errors.emailCode}
+                </div>
+              )}
+            </div>
+
+            <div className="form-group">
+              <Input.Password
+                id="newPassword"
+                name="newPassword"
+                className={`form-input ${errors.newPassword ? 'input-error' : ''}`}
+                placeholder="请输入新密码"
+                value={formData.newPassword}
+                onChange={handlePasswordChange}
+                prefix={<LockOutlined />}
+                size="large"
+                title=""
+                status={errors.newPassword ? 'error' : ''}
+              />
+              {errors.newPassword && (
+                <div className="error-message">
+                  {errors.newPassword}
+                </div>
+              )}
+            </div>
+
+            <div className="form-group">
+              <Input.Password
+                id="confirmPassword"
+                name="confirmPassword"
+                className={`form-input ${errors.confirmPassword ? 'input-error' : ''}`}
+                placeholder="请确认新密码"
+                value={formData.confirmPassword}
+                onChange={handleConfirmPasswordChange}
+                prefix={<LockOutlined />}
+                size="large"
+                title=""
+                status={errors.confirmPassword ? 'error' : ''}
+              />
+              {errors.confirmPassword && (
+                <div className="error-message">
+                  {errors.confirmPassword}
+                </div>
+              )}
+            </div>
+
+            <button
+              type="submit"
+              className={`register-button ${isLoading ? 'loading' : ''}`}
+              disabled={isLoading}
+            >
+              {isLoading ? (
+                <>
+                  <div className="loading-spinner"></div>
+                  重置中...
+                </>
+              ) : (
+                '重置密码'
+              )}
+            </button>
+          </form>
+
+          <div className="login-link">
+            <p>想起密码了？ <Link to="/login">立即登录</Link></p>
+            <p>还没有账户？ <Link to="/register">立即注册</Link></p>
+          </div>
+        </div>
+      </div>
+
+      {/* 错误弹窗 */}
+      <Modal
+        title={
+          <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
+            <ExclamationCircleOutlined style={{ color: '#ff4d4f', fontSize: '18px' }} />
+            {errorModal.title}
+          </div>
+        }
+        open={errorModal.visible}
+        onOk={closeErrorModal}
+        onCancel={closeErrorModal}
+        okText="我知道了"
+        cancelButtonProps={{ style: { display: 'none' } }}
+        centered
+        className="error-modal"
+      >
+        <div style={{ padding: '16px 0', fontSize: '14px', lineHeight: '1.6' }}>
+          {errorModal.content}
+        </div>
+      </Modal>
+    </div>
+  );
+};
+
+export default ForgotPasswordPage;
diff --git a/Merge/front/src/pages/LoginPage/LoginPage.css b/Merge/front/src/pages/LoginPage/LoginPage.css
new file mode 100644
index 0000000..ab1e24c
--- /dev/null
+++ b/Merge/front/src/pages/LoginPage/LoginPage.css
@@ -0,0 +1,1288 @@
+/* 登录页面容器 */
+.login-container {
+  min-height: 100vh;
+  min-height: 100dvh; /* 动态视口高度，避免移动端地址栏影响 */
+  height: 100vh;
+  height: 100dvh;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  overflow: hidden;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+    sans-serif;
+  /* 确保容器稳定定位 */
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  /* 重置文本对齐 */
+  text-align: initial;
+}
+
+/* 小红书风格背景 */
+.login-background {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: #f8f8f8;
+  z-index: -1;
+}
+
+/* 登录内容区域 */
+.login-content {
+  width: 100%;
+  max-width: 500px; /* 增加桌面端最大宽度 */
+  padding: 0;
+  z-index: 1;
+  /* 确保内容稳定定位 */
+  box-sizing: border-box;
+  position: relative;
+  display: flex;
+  justify-content: center;
+}
+
+/* 小红书风格登录卡片 */
+.login-card {
+  background: #fff;
+  border-radius: 8px;
+  padding: 40px; /* 增加桌面端内边距 */
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.1);
+  border: 1px solid #e1e1e1;
+  width: 100%;
+  max-width: 450px; /* 增加桌面端卡片最大宽度 */
+  transition: none;
+}
+
+/* 登录头部 */
+.login-header {
+  text-align: center;
+  margin-bottom: 40px;
+}
+
+/* Logo样式 */
+.logo-section {
+  margin-bottom: 24px;
+}
+
+.logo-icon {
+  width: 60px;
+  height: 60px;
+  background: #ff2442;
+  border-radius: 12px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 28px;
+  margin: 0 auto 16px;
+  box-shadow: 0 4px 12px rgba(255, 36, 66, 0.2);
+}
+
+.login-title {
+  font-size: 24px;
+  font-weight: 600;
+  color: #333;
+  margin: 0 0 12px 0;
+  text-align: center;
+}
+
+.login-title::after {
+  display: none;
+}
+
+.login-subtitle {
+  font-size: 14px;
+  color: #999;
+  margin: 0 0 32px 0;
+  font-weight: 400;
+  text-align: center;
+}
+
+/* 表单样式 */
+.login-form {
+  display: flex;
+  flex-direction: column;
+  gap: 24px;
+  width: 100%;
+}
+
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  width: 100%;
+  box-sizing: border-box;
+  margin-bottom: 2px;
+  position: relative; /* 为绝对定位的错误提示提供参考点 */
+}
+
+.form-group .input-wrapper {
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.form-label {
+  font-size: 14px;
+  font-weight: 500;
+  color: #333;
+  margin-bottom: 8px;
+}
+
+.input-wrapper {
+  position: relative;
+  display: flex;
+  align-items: center;
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.form-input {
+  width: 100% !important;
+  height: 44px;
+  padding: 12px 16px 12px 48px;
+  border: 1px solid #e1e1e1;
+  border-radius: 6px;
+  font-size: 14px;
+  transition: border-color 0.2s ease;
+  background: #fff;
+  color: #333;
+  box-sizing: border-box !important;
+  flex: 1;
+  min-width: 0;
+}
+
+/* 针对 Antd Input 组件的特定样式 */
+.form-input.ant-input,
+.form-input.ant-input-affix-wrapper {
+  width: 100% !important;
+  height: 44px !important;
+  border: 1px solid #e1e1e1 !important;
+  border-radius: 6px !important;
+  padding: 12px 48px 12px 48px !important;
+  font-size: 14px !important;
+  background: #fff !important;
+  color: #333 !important;
+  box-sizing: border-box !important;
+  flex: 1 !important;
+  min-width: 0 !important;
+  display: flex !important;
+  align-items: center !important;
+}
+
+.form-input.ant-input-affix-wrapper .ant-input {
+  width: 100% !important;
+  height: 100% !important;
+  padding: 0 !important;
+  border: none !important;
+  background: transparent !important;
+  flex: 1 !important;
+  min-width: 0 !important;
+  box-sizing: border-box !important;
+}
+
+.form-input:focus {
+  outline: none;
+  border-color: #ff2442;
+  box-shadow: none;
+  transform: none;
+}
+
+/* Antd Input focus 样式 */
+.form-input.ant-input:focus,
+.form-input.ant-input-affix-wrapper:focus,
+.form-input.ant-input-affix-wrapper-focused {
+  outline: none !important;
+  border-color: #ff2442 !important;
+  box-shadow: none !important;
+  transform: none !important;
+}
+
+.form-input::placeholder {
+  color: #9ca3af;
+}
+
+.input-icon {
+  position: absolute;
+  left: 16px;
+  top: 50%;
+  transform: translateY(-50%);
+  color: #9ca3af;
+  pointer-events: none;
+  transition: color 0.3s ease;
+  z-index: 2;
+}
+
+.form-input:focus + .input-icon {
+  color: #ff2442;
+}
+
+.password-toggle {
+  position: absolute;
+  right: 12px;
+  top: 50%;
+  transform: translateY(-50%);
+  background: none;
+  border: none;
+  color: #9ca3af;
+  cursor: pointer;
+  padding: 4px;
+  border-radius: 4px;
+  transition: all 0.3s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 2;
+  width: 24px;
+  height: 24px;
+}
+
+.password-toggle:hover {
+  color: #ff2442;
+  background-color: rgba(255, 36, 66, 0.1);
+}
+
+/* 表单选项 */
+.form-options {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-top: 8px;
+  margin-bottom: 16px;
+  width: 100%;
+  flex-wrap: nowrap; /* 确保不换行 */
+  min-height: 24px;
+  gap: 8px; /* 添加基础间距 */
+}
+
+/* Ant Design Checkbox 样式兼容 */
+.form-options .ant-checkbox-wrapper {
+  flex: 0 0 auto; /* 不伸缩，保持原始大小 */
+  font-size: 14px;
+  color: #64748b;
+  white-space: nowrap; /* 防止文字换行 */
+  overflow: hidden;
+  text-overflow: ellipsis;
+  max-width: 50%; /* 限制最大宽度 */
+}
+
+.form-options .ant-checkbox-wrapper .ant-checkbox {
+  margin-right: 8px;
+}
+
+.form-options .forgot-password {
+  flex: 0 0 auto; /* 不伸缩，保持原始大小 */
+  margin-left: auto;
+  white-space: nowrap;
+  color: #ff2442;
+  text-decoration: none;
+  font-size: 14px;
+  transition: color 0.3s ease;
+  max-width: 45%; /* 限制最大宽度 */
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.form-options .forgot-password:hover {
+  color: #ff1a3a;
+  text-decoration: underline;
+}
+
+.checkbox-wrapper {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  cursor: pointer;
+  font-size: 14px;
+  color: #64748b;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+  flex-shrink: 0;
+}
+
+.checkbox {
+  position: relative;
+  width: 18px;
+  height: 18px;
+  margin: 0;
+  cursor: pointer;
+  opacity: 0;
+}
+
+.checkmark {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 18px;
+  height: 18px;
+  background-color: #fff;
+  border: 1px solid #e1e1e1;
+  border-radius: 3px;
+  transition: all 0.2s ease;
+}
+
+.checkbox:checked + .checkmark {
+  background-color: #ff2442;
+  border-color: #ff2442;
+}
+
+.checkmark:after {
+  content: "";
+  position: absolute;
+  display: none;
+  left: 5px;
+  top: 2px;
+  width: 4px;
+  height: 8px;
+  border: solid white;
+  border-width: 0 2px 2px 0;
+  transform: rotate(45deg);
+}
+
+.checkbox:checked + .checkmark:after {
+  display: block;
+}
+
+.forgot-password {
+  font-size: 14px;
+  color: #ff2442;
+  text-decoration: none;
+  font-weight: 400;
+  transition: color 0.2s ease;
+  margin-left: auto;
+  flex-shrink: 0;
+  white-space: nowrap;
+}
+
+.forgot-password:hover {
+  color: #d91e3a;
+  text-decoration: underline;
+}
+
+/* 小红书风格登录按钮 */
+.login-button {
+  width: 100%;
+  height: 48px; /* 固定高度，防止布局变化 */
+  padding: 12px;
+  background: #ff2442;
+  color: white;
+  border: none;
+  border-radius: 6px;
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  margin-top: 8px;
+  box-sizing: border-box; /* 确保padding包含在总尺寸内 */
+  min-width: 0; /* 防止flex子元素造成宽度变化 */
+}
+
+.login-button:hover:not(:disabled) {
+  background: #d91e3a;
+  transform: none;
+  box-shadow: none;
+}
+
+.login-button:active:not(:disabled) {
+  transform: none;
+}
+
+.login-button:disabled {
+  background: #ccc;
+  cursor: not-allowed;
+  opacity: 0.8;
+}
+
+.login-button.loading {
+  background: #ff7b8a;
+  cursor: not-allowed;
+}
+
+.loading-spinner {
+  width: 16px;
+  height: 16px;
+  border: 2px solid rgba(255, 255, 255, 0.3);
+  border-radius: 50%;
+  border-top-color: #fff;
+  animation: spin 1s ease-in-out infinite;
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+/* 加载遮罩层 */
+.loading-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+  backdrop-filter: blur(4px);
+}
+
+.loading-content {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 16px;
+  background: white;
+  padding: 32px;
+  border-radius: 12px;
+  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
+}
+
+.loading-spinner-large {
+  width: 40px;
+  height: 40px;
+  border: 4px solid rgba(255, 36, 66, 0.2);
+  border-radius: 50%;
+  border-top-color: #ff2442;
+  animation: spin 1s ease-in-out infinite;
+}
+
+.loading-text {
+  margin: 0;
+  color: #333;
+  font-size: 16px;
+  font-weight: 500;
+}
+
+/* 分隔线 */
+.login-divider {
+  position: relative;
+  text-align: center;
+  margin: 32px 0;
+  color: #9ca3af;
+  font-size: 14px;
+}
+
+.login-divider::before {
+  content: '';
+  position: absolute;
+  top: 50%;
+  left: 0;
+  right: 0;
+  height: 1px;
+  background: linear-gradient(to right, transparent, #e5e7eb, transparent);
+}
+
+.login-divider span {
+  background: rgba(255, 255, 255, 0.95);
+  padding: 0 16px;
+  position: relative;
+  z-index: 1;
+}
+
+/* 社交登录 */
+.social-login {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.social-button {
+  width: 100%;
+  padding: 12px 16px;
+  border: 1px solid #e1e1e1;
+  border-radius: 6px;
+  background: white;
+  color: #333;
+  font-size: 14px;
+  font-weight: 400;
+  cursor: pointer;
+  transition: border-color 0.2s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+}
+
+.social-button:hover {
+  border-color: #ccc;
+}
+
+.social-button.google:hover {
+  border-color: #4285f4;
+  box-shadow: 0 4px 12px rgba(66, 133, 244, 0.2);
+}
+
+.social-button.github:hover {
+  border-color: #333;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+}
+
+.social-button.xiaohongshu:hover {
+  border-color: #ff2442;
+  box-shadow: 0 4px 12px rgba(255, 36, 66, 0.2);
+}
+
+/* 注册链接 */
+.signup-link {
+  text-align: center;
+  margin-top: 20px;
+  padding-top: 20px;
+  border-top: 1px solid #e5e7eb;
+}
+
+.signup-link p {
+  margin: 0;
+  font-size: 14px;
+  color: #64748b;
+}
+
+.signup-link a {
+  color: #ff2442;
+  text-decoration: none;
+  font-weight: 500;
+  transition: color 0.2s ease;
+}
+
+.signup-link a:hover {
+  color: #d91e3a;
+  text-decoration: underline;
+}
+
+/* 有左侧图标时的内边距调整 */
+.input-wrapper.has-icon .form-input {
+  padding-left: 48px !important;
+}
+
+.input-wrapper.has-icon .form-input.ant-input,
+.input-wrapper.has-icon .form-input.ant-input-affix-wrapper {
+  padding-left: 48px !important;
+}
+
+/* 有右侧切换按钮时的内边距调整 */
+.input-wrapper.has-toggle .form-input {
+  padding-right: 48px !important;
+}
+
+.input-wrapper.has-toggle .form-input.ant-input,
+.input-wrapper.has-toggle .form-input.ant-input-affix-wrapper {
+  padding-right: 48px !important;
+}
+
+/* 没有图标时的内边距调整 */
+.input-wrapper:not(.has-icon) .form-input {
+  padding-left: 16px !important;
+}
+
+.input-wrapper:not(.has-icon) .form-input.ant-input,
+.input-wrapper:not(.has-icon) .form-input.ant-input-affix-wrapper {
+  padding-left: 16px !important;
+}
+
+/* 没有切换按钮时的内边距调整 */
+.input-wrapper:not(.has-toggle) .form-input {
+  padding-right: 16px !important;
+}
+
+.input-wrapper:not(.has-toggle) .form-input.ant-input,
+.input-wrapper:not(.has-toggle) .form-input.ant-input-affix-wrapper {
+  padding-right: 16px !important;
+}
+
+/* 确保输入框内容完全填充 */
+.form-input.ant-input-affix-wrapper .ant-input-suffix {
+  position: absolute !important;
+  right: 12px !important;
+  top: 50% !important;
+  transform: translateY(-50%) !important;
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+.form-input.ant-input-affix-wrapper .ant-input-prefix {
+  position: absolute !important;
+  left: 16px !important;
+  top: 50% !important;
+  transform: translateY(-50%) !important;
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+/* 确保所有输入框完全填充其容器 */
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.form-group .input-wrapper {
+  width: 100%;
+  box-sizing: border-box;
+}
+
+/* 防止输入框溢出容器 */
+.form-input,
+.form-input.ant-input,
+.form-input.ant-input-affix-wrapper {
+  max-width: 100% !important;
+  overflow: hidden !important;
+}
+
+/* 确保内部输入元素不会超出边界 */
+.form-input.ant-input-affix-wrapper .ant-input {
+  max-width: 100% !important;
+  overflow: hidden !important;
+  text-overflow: ellipsis !important;
+}
+
+/* 精细间距控制 */
+.login-header + .login-form {
+  margin-top: -4px;
+}
+
+.login-form .form-group:not(:last-child) {
+  margin-bottom: 2px;
+}
+
+.login-form .form-group:last-of-type {
+  margin-bottom: 6px;
+}
+
+.login-button + .signup-link {
+  margin-top: 14px;
+}
+
+/* 响应式设计 */
+@media (max-width: 768px) {
+  /* 重置body和html确保一致性 */
+  html, body {
+    height: 100%;
+    height: 100dvh;
+    margin: 0;
+    padding: 0;
+    overflow-x: hidden;
+    box-sizing: border-box;
+  }
+  
+  .login-container {
+    padding: 16px;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    min-height: 100dvh; /* 动态视口高度 */
+    /* 强制重置可能影响定位的样式 */
+    margin: 0;
+    box-sizing: border-box;
+    /* 防止内容溢出影响布局 */
+    overflow-x: hidden;
+    overflow-y: auto;
+    /* 确保flexbox在所有移动设备上表现一致 */
+    -webkit-box-align: center;
+    -webkit-box-pack: center;
+    display: flex !important;
+    position: relative;
+  }
+  
+  .login-content {
+    max-width: 100%;
+    padding: 20px;
+    /* 确保内容区域稳定 */
+    margin: 0 auto;
+    box-sizing: border-box;
+    /* 防止宽度计算问题 */
+    width: calc(100% - 40px);
+    max-width: 480px; /* 增加最大宽度 */
+    position: relative;
+    display: flex;
+    justify-content: center;
+  }
+  
+  .login-card {
+    padding: 32px 28px; /* 增加内边距 */
+    border-radius: 16px;
+    /* 确保卡片稳定定位 */
+    margin: 0;
+    box-sizing: border-box;
+    width: 100%;
+    max-width: 450px; /* 增加卡片最大宽度 */
+    /* 防止backdrop-filter导致的渲染差异 */
+    will-change: auto;
+    position: relative;
+    /* 防止触摸操作影响布局 */
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    -webkit-tap-highlight-color: transparent;
+  }
+  
+  .login-title {
+    font-size: 24px;
+  }
+  
+  .form-input {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px;
+    font-size: 16px; /* 防止iOS Safari缩放 */
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input,
+  .form-input.ant-input-affix-wrapper {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px !important;
+    font-size: 16px !important;
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input-affix-wrapper .ant-input {
+    width: 100% !important;
+    height: 100% !important;
+    padding: 0 !important;
+    border: none !important;
+    background: transparent !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+    box-sizing: border-box !important;
+  }
+  
+  .social-login {
+    gap: 10px;
+  }
+  
+  .social-button {
+    padding: 12px 16px;
+    font-size: 14px;
+  }
+  
+  .form-options {
+    display: flex !important;
+    flex-direction: row !important;
+    justify-content: space-between !important;
+    align-items: center !important;
+    gap: 8px !important;
+    width: 100% !important;
+    flex-wrap: nowrap !important;
+    min-height: 22px !important;
+    margin-top: 8px !important;
+    margin-bottom: 16px !important;
+  }
+  
+  .checkbox-wrapper {
+    font-size: 13px;
+    flex: 0 0 auto !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 48% !important;
+  }
+  
+  .forgot-password {
+    font-size: 13px;
+    margin-left: auto;
+    flex: 0 0 auto !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 48% !important;
+  }
+  
+  /* Ant Design Checkbox 的特殊处理 */
+  .form-options .ant-checkbox-wrapper {
+    flex: 0 0 auto !important;
+    font-size: 13px !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 48% !important;
+  }
+}
+
+@media (max-width: 480px) {
+  .login-container {
+    padding: 16px;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    min-height: 100dvh; /* 动态视口高度 */
+    /* 强制重置样式 */
+    margin: 0;
+    box-sizing: border-box;
+    position: relative;
+    /* 确保垂直居中 */
+    display: flex !important;
+  }
+  
+  .login-content {
+    /* 更严格的尺寸控制 */
+    width: calc(100vw - 32px);
+    max-width: 420px; /* 增加最大宽度 */
+    padding: 16px;
+    margin: 0 auto;
+    box-sizing: border-box;
+    display: flex;
+    justify-content: center;
+  }
+  
+  .login-card {
+    padding: 28px 24px; /* 增加内边距 */
+    border-radius: 12px;
+    /* 确保卡片完全稳定 */
+    margin: 0;
+    box-sizing: border-box;
+    width: 100%;
+    position: relative;
+    /* 防止变换导致的位置偏移 */
+    transform: none !important;
+    /* 防止触摸操作影响布局 */
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    /* 防止点击时的高亮效果影响布局 */
+    -webkit-tap-highlight-color: transparent;
+  }
+  
+  .login-title {
+    font-size: 22px;
+  }
+  
+  .form-input {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px;
+    font-size: 16px; /* 防止iOS Safari缩放 */
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input,
+  .form-input.ant-input-affix-wrapper {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px !important;
+    font-size: 16px !important;
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input-affix-wrapper .ant-input {
+    width: 100% !important;
+    height: 100% !important;
+    padding: 0 !important;
+    border: none !important;
+    background: transparent !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+    box-sizing: border-box !important;
+  }
+  
+  .social-login {
+    gap: 10px;
+  }
+  
+  .social-button {
+    padding: 12px 16px;
+    font-size: 14px;
+  }
+  
+  .form-options {
+    display: flex !important;
+    flex-direction: row !important;
+    justify-content: space-between !important;
+    align-items: center !important;
+    gap: 6px !important;
+    width: 100% !important;
+    min-height: 20px !important;
+    flex-wrap: nowrap !important;
+    margin-top: 8px !important;
+    margin-bottom: 16px !important;
+  }
+  
+  .checkbox-wrapper {
+    flex: 0 0 auto !important;
+    font-size: 12px !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 45% !important;
+  }
+  
+  .forgot-password {
+    flex: 0 0 auto !important;
+    font-size: 12px !important;
+    margin-left: auto !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 45% !important;
+  }
+  
+/* 移动端优化 */
+  .background-pattern {
+    display: none;
+  }
+  
+  /* 禁用可能影响位置的悬停效果 */
+  .login-card:hover {
+    transform: none !important;
+  }
+}
+
+/* 超小屏幕优化（320px及以下） */
+@media (max-width: 320px) {
+  .login-content {
+    padding: 16px;
+  }
+  
+  .login-card {
+    padding: 24px;
+  }
+  
+  .form-options {
+    display: flex !important;
+    flex-direction: row !important;
+    justify-content: space-between !important;
+    align-items: center !important;
+    gap: 4px !important;
+    width: 100% !important;
+    flex-wrap: nowrap !important;
+    min-height: 18px !important;
+    margin-top: 6px !important;
+    margin-bottom: 14px !important;
+  }
+  
+  .checkbox-wrapper {
+    flex: 0 0 auto !important;
+    font-size: 11px !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 42% !important;
+    line-height: 1.2 !important;
+  }
+  
+  .forgot-password {
+    flex: 0 0 auto !important;
+    font-size: 11px !important;
+    margin-left: auto !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 42% !important;
+    line-height: 1.2 !important;
+  }
+  
+  /* Ant Design Checkbox 的特殊处理 */
+  .form-options .ant-checkbox-wrapper {
+    flex: 0 0 auto !important;
+    font-size: 11px !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 42% !important;
+    line-height: 1.2 !important;
+  }
+}
+
+/* 极小屏幕优化（280px及以下） */
+@media (max-width: 280px) {
+  .form-options {
+    display: flex !important;
+    flex-direction: row !important;
+    justify-content: space-between !important;
+    align-items: center !important;
+    gap: 2px !important;
+    width: 100% !important;
+    flex-wrap: nowrap !important;
+    min-height: 16px !important;
+    margin-top: 6px !important;
+    margin-bottom: 14px !important;
+  }
+  
+  .form-options .ant-checkbox-wrapper {
+    flex: 0 0 auto !important;
+    font-size: 10px !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 40% !important;
+    line-height: 1.1 !important;
+  }
+  
+  .form-options .forgot-password {
+    flex: 0 0 auto !important;
+    font-size: 10px !important;
+    margin-left: auto !important;
+    white-space: nowrap !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    max-width: 40% !important;
+    line-height: 1.1 !important;
+  }
+  
+  .form-options .ant-checkbox-wrapper .ant-checkbox {
+    margin-right: 2px !important;
+    transform: scale(0.8) !important; /* 进一步缩小checkbox */
+  }
+}
+
+/* 高对比度模式支持 */
+@media (prefers-contrast: high) {
+  .login-card {
+    background: white;
+    border: 2px solid #000;
+  }
+  
+  .form-input {
+    border-color: #000;
+  }
+  
+  .form-input:focus {
+    border-color: #0066cc;
+    box-shadow: 0 0 0 2px #0066cc;
+  }
+}
+
+/* 减少动画模式 */
+@media (prefers-reduced-motion: reduce) {
+  .background-pattern {
+    animation: none;
+  }
+  
+  .login-card,
+  .form-input,
+  .login-button,
+  .social-button {
+    transition: none;
+  }
+}
+
+/* 深色模式支持 */
+@media (prefers-color-scheme: dark) {
+  .login-background {
+    background: linear-gradient(135deg, #1a202c 0%, #2d3748 100%);
+  }
+  
+  .login-card {
+    background: rgba(26, 32, 44, 0.95);
+    border-color: rgba(255, 255, 255, 0.1);
+  }
+  
+  .login-title {
+    color: #f7fafc;
+  }
+  
+  .login-subtitle {
+    color: #a0aec0;
+  }
+  
+  .form-label {
+    color: #e2e8f0;
+  }
+  
+  .form-input {
+    background: #2d3748;
+    border-color: #4a5568;
+    color: #f7fafc;
+  }
+  
+  .form-input:focus {
+    border-color: #ff2442;
+  }
+  
+  .social-button {
+    background: #2d3748;
+    border-color: #4a5568;
+    color: #f7fafc;
+  }
+  
+  .signup-link {
+    border-color: #4a5568;
+  }
+  
+  .signup-link p {
+    color: #a0aec0;
+  }
+  
+  /* 深色模式下的错误提示样式 */
+  .error-message {
+    background: rgba(26, 32, 44, 0.95);
+    color: #ff6b6b;
+  }
+  
+  /* 深色模式下的错误弹窗样式 */
+  .error-modal .ant-modal-header {
+    background: #2d3748;
+    border-color: #4a5568;
+  }
+  
+  .error-modal .ant-modal-title {
+    color: #f7fafc;
+  }
+  
+  .error-modal .ant-modal-body {
+    background: #2d3748;
+    color: #f7fafc;
+  }
+  
+  .error-modal .ant-modal-footer {
+    background: #2d3748;
+  }
+  
+  .error-modal .ant-modal-content {
+    background: #2d3748;
+  }
+}
+
+/* 错误提示样式 - 使用绝对定位避免影响布局 */
+.error-message {
+  position: absolute;
+  top: 95%;
+  left: 4px;
+  right: 4px;
+  font-size: 12px;
+  color: #ff4d4f;
+  margin-top: 4px;
+  display: flex;
+  align-items: center;
+  min-height: 16px;
+  animation: fadeInDown 0.3s ease-out;
+  font-weight: 400;
+  line-height: 1.2;
+  background: rgba(255, 255, 255, 0.95);
+  backdrop-filter: blur(4px);
+  padding: 2px 4px;
+  border-radius: 4px;
+  z-index: 10;
+  pointer-events: none; /* 避免干扰用户交互 */
+}
+
+@keyframes fadeInDown {
+  from {
+    opacity: 0;
+    transform: translateY(-8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+/* 输入框错误状态样式 */
+.form-input.input-error,
+.form-input.input-error.ant-input,
+.form-input.input-error.ant-input-affix-wrapper {
+  border-color: #ff4d4f !important;
+  box-shadow: 0 0 0 2px rgba(255, 77, 79, 0.1) !important;
+  transition: all 0.3s ease !important;
+}
+
+.form-input.input-error:focus,
+.form-input.input-error.ant-input:focus,
+.form-input.input-error.ant-input-affix-wrapper:focus,
+.form-input.input-error.ant-input-affix-wrapper-focused {
+  border-color: #ff4d4f !important;
+  box-shadow: 0 0 0 2px rgba(255, 77, 79, 0.2) !important;
+}
+
+/* 错误状态下的图标颜色 */
+.form-input.input-error .anticon {
+  color: #ff4d4f !important;
+}
+
+/* 确保表单组间距一致 */
+.form-group {
+  margin-bottom: 0px;
+}
+
+.form-group:last-of-type {
+  margin-bottom: 0px;
+}
+
+/* 错误弹窗样式 */
+.error-modal .ant-modal-header {
+  background: #fff;
+  border-bottom: 1px solid #f0f0f0;
+  padding: 16px 24px;
+}
+
+.error-modal .ant-modal-title {
+  color: #333;
+  font-weight: 600;
+  font-size: 16px;
+}
+
+.error-modal .ant-modal-body {
+  padding: 16px 24px 24px;
+}
+
+.error-modal .ant-modal-footer {
+  padding: 12px 24px 24px;
+  border-top: none;
+  text-align: center;
+}
+
+.error-modal .ant-btn-primary {
+  background: #ff2442;
+  border-color: #ff2442;
+  font-weight: 500;
+  height: 40px;
+  padding: 0 24px;
+  border-radius: 6px;
+  transition: all 0.2s ease;
+}
+
+.error-modal .ant-btn-primary:hover {
+  background: #d91e3a;
+  border-color: #d91e3a;
+  transform: translateY(-1px);
+  box-shadow: 0 4px 12px rgba(255, 36, 66, 0.3);
+}
+
+.error-modal .ant-modal-content {
+  border-radius: 12px;
+  overflow: hidden;
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
+}
+
+/* 错误弹窗遮罩层 */
+.error-modal .ant-modal-mask {
+  background: rgba(0, 0, 0, 0.6);
+  backdrop-filter: blur(4px);
+}
+
+/* 错误弹窗动画 */
+.error-modal .ant-modal {
+  animation: errorModalSlideIn 0.3s ease-out;
+}
+
+@keyframes errorModalSlideIn {
+  from {
+    opacity: 0;
+    transform: translateY(-20px) scale(0.95);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
diff --git a/Merge/front/src/pages/LoginPage/LoginPage.js b/Merge/front/src/pages/LoginPage/LoginPage.js
new file mode 100644
index 0000000..c315b7d
--- /dev/null
+++ b/Merge/front/src/pages/LoginPage/LoginPage.js
@@ -0,0 +1,380 @@
+import React, { useState, useEffect } from 'react';
+import { Link } from 'react-router-dom';
+import { Input, Checkbox, Modal, Alert } from 'antd';
+import { MailOutlined, LockOutlined, ExclamationCircleOutlined, CheckCircleOutlined } from '@ant-design/icons';
+import { 
+  getRememberedLoginInfo, 
+  saveRememberedLoginInfo, 
+  saveAuthInfo, 
+  isLoggedIn 
+} from '../../utils/auth';
+import { hashPassword } from '../../utils/crypto';
+import './LoginPage.css';
+
+const baseURL = 'http://10.126.59.25:8082';
+
+const LoginPage = () => {
+  const [formData, setFormData] = useState({
+    email: '',
+    password: ''
+  });
+
+  const [rememberMe, setRememberMe] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [errors, setErrors] = useState({
+    email: '',
+    password: ''
+  });
+  const [errorModal, setErrorModal] = useState({
+    visible: false,
+    title: '',
+    content: ''
+  });
+  const [successAlert, setSuccessAlert] = useState({
+    visible: false,
+    message: ''
+  });
+
+  // 显示错误弹窗
+  const showErrorModal = (title, content) => {
+    setErrorModal({
+      visible: true,
+      title: title,
+      content: content
+    });
+  };
+
+  // 关闭错误弹窗
+  const closeErrorModal = () => {
+    setErrorModal({
+      visible: false,
+      title: '',
+      content: ''
+    });
+  };
+
+  // 显示成功提示
+  const showSuccessAlert = (message) => {
+    setSuccessAlert({
+      visible: true,
+      message: message
+    });
+    
+    // 3秒后自动隐藏
+    setTimeout(() => {
+      setSuccessAlert({
+        visible: false,
+        message: ''
+      });
+    }, 3000);
+  };
+
+  // 页面加载时检查是否有记住的登录信息
+  useEffect(() => {
+    // 检查是否已经登录
+    if (isLoggedIn()) {
+      // 如果已经有token，可以选择直接跳转到主页面
+      // window.location.href = '/test-dashboard';
+      console.log('用户已登录');
+    }
+
+    // 获取记住的登录信息
+    const rememberedInfo = getRememberedLoginInfo();
+    if (rememberedInfo.rememberMe && rememberedInfo.email) {
+      setFormData({
+        email: rememberedInfo.email,
+        password: rememberedInfo.password
+      });
+      setRememberMe(true);
+    }
+  }, []);
+
+  const handleEmailChange = (e) => {
+    const value = e.target.value;
+    setFormData(prev => ({
+      ...prev,
+      email: value
+    }));
+    
+    // 清除邮箱错误提示
+    if (errors.email) {
+      setErrors(prev => ({
+        ...prev,
+        email: ''
+      }));
+    }
+  };
+
+  const handlePasswordChange = (e) => {
+    const value = e.target.value;
+    setFormData(prev => ({
+      ...prev,
+      password: value
+    }));
+    
+    // 清除密码错误提示
+    if (errors.password) {
+      setErrors(prev => ({
+        ...prev,
+        password: ''
+      }));
+    }
+  };
+
+  const handleRememberMeChange = (e) => {
+    const checked = e.target.checked;
+    setRememberMe(checked);
+    
+    // 如果取消记住我，清除已保存的登录信息
+    if (!checked) {
+      saveRememberedLoginInfo('', '', false);
+    }
+  };
+
+  const validateForm = () => {
+    const newErrors = {
+      email: '',
+      password: ''
+    };
+    
+    let hasError = false;
+    
+    // 验证邮箱
+    if (!formData.email || typeof formData.email !== 'string' || !formData.email.trim()) {
+      newErrors.email = '请输入邮箱地址';
+      hasError = true;
+    } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) {
+      newErrors.email = '请输入有效的邮箱地址';
+      hasError = true;
+    }
+    
+    // 验证密码
+    if (!formData.password || typeof formData.password !== 'string' || !formData.password.trim()) {
+      newErrors.password = '请输入密码';
+      hasError = true;
+    } else if (formData.password.length < 6) {
+      newErrors.password = '密码长度至少6位';
+      hasError = true;
+    }
+    
+    setErrors(newErrors);
+    return !hasError;
+  };
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    
+    // 验证表单
+    if (!validateForm()) {
+      return;
+    }
+    
+    setIsLoading(true);
+    
+    try {
+      // 发送登录请求到后端
+      const response = await fetch(baseURL + '/login', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          email: formData.email, // 后端支持邮箱登录
+          password: hashPassword(formData.password) // 前端加密密码
+        })
+      });
+      
+      const result = await response.json();
+      
+      if (result.success) {
+        // 显示成功提示
+        showSuccessAlert('登录成功！正在跳转...');
+        
+        // 保存认证信息
+        saveAuthInfo(result.token, result.user, rememberMe);
+        
+        // 保存或清除记住的登录信息
+        saveRememberedLoginInfo(formData.email, formData.password, rememberMe);
+        
+        // 延迟跳转，让用户看到成功提示
+        setTimeout(() => {
+          window.location.href = '/test-dashboard';
+        }, 1500);
+      } else {
+        // 登录失败，显示错误信息
+        let errorTitle = '登录失败';
+        let errorContent = result.message || '登录失败，请检查您的邮箱和密码';
+        
+        // 根据错误类型提供更详细的信息
+        if (result.message) {
+          if (result.message.includes('邮箱') || result.message.includes('email')) {
+            errorTitle = '邮箱验证失败';
+            errorContent = '您输入的邮箱地址不存在或格式不正确，请检查后重试。';
+          } else if (result.message.includes('密码') || result.message.includes('password')) {
+            errorTitle = '密码验证失败';
+            errorContent = '您输入的密码不正确，请检查后重试。如果忘记密码，请点击"忘记密码"进行重置。';
+          } else if (result.message.includes('用户不存在')) {
+            errorTitle = '用户不存在';
+            errorContent = '该邮箱尚未注册，请先注册账户或检查邮箱地址是否正确。';
+          } else if (result.message.includes('账户被锁定') || result.message.includes('locked')) {
+            errorTitle = '账户被锁定';
+            errorContent = '您的账户因安全原因被暂时锁定，请联系客服或稍后重试。';
+          }
+        }
+        
+        showErrorModal(errorTitle, errorContent);
+      }
+    } catch (error) {
+      console.error('登录请求失败:', error);
+      
+      // 根据错误类型显示不同的错误信息
+      if (error.name === 'TypeError' && error.message.includes('fetch')) {
+        showErrorModal('网络连接失败', '无法连接到服务器，请检查您的网络连接后重试。如果问题持续存在，请联系客服。');
+      } else if (error.name === 'AbortError') {
+        showErrorModal('请求超时', '请求超时，请检查网络连接后重试。');
+      } else {
+        showErrorModal('登录失败', '网络连接失败，请检查网络或稍后重试。如果问题持续存在，请联系客服。');
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return (
+    <div className="login-container">
+      <div className="login-background"></div>
+      
+      {isLoading && (
+        <div className="loading-overlay">
+          <div className="loading-content">
+            <div className="loading-spinner-large"></div>
+            <p className="loading-text">正在登录...</p>
+          </div>
+        </div>
+      )}
+      
+      <div className="login-content">
+        <div className="login-card">
+          {/* 成功提示 */}
+          {successAlert.visible && (
+            <div style={{ marginBottom: '16px' }}>
+              <Alert
+                message={successAlert.message}
+                type="success"
+                icon={<CheckCircleOutlined />}
+                showIcon
+                closable
+                onClose={() => setSuccessAlert({ visible: false, message: '' })}
+                style={{
+                  borderRadius: '8px',
+                  border: '1px solid #b7eb8f',
+                  backgroundColor: '#f6ffed'
+                }}
+              />
+            </div>
+          )}
+          
+          <div className="login-header">
+            <h1 className="login-title">欢迎来到小红书</h1>
+            <p className="login-subtitle">标记我的生活</p>
+          </div>
+
+          <form className="login-form" onSubmit={handleSubmit}>
+            <div className="form-group">
+              <Input
+                type="email"
+                id="email"
+                name="email"
+                className={`form-input ${errors.email ? 'input-error' : ''}`}
+                placeholder="请输入您的邮箱"
+                value={formData.email}
+                onChange={handleEmailChange}
+                prefix={<MailOutlined />}
+                size="large"
+                title=""
+                status={errors.email ? 'error' : ''}
+              />
+              {errors.email && (
+                <div className="error-message">
+                  {errors.email}
+                </div>
+              )}
+            </div>
+
+            <div className="form-group">
+              <Input.Password
+                id="password"
+                name="password"
+                className={`form-input ${errors.password ? 'input-error' : ''}`}
+                placeholder="请输入您的密码"
+                value={formData.password}
+                onChange={handlePasswordChange}
+                prefix={<LockOutlined />}
+                size="large"
+                title=""
+                status={errors.password ? 'error' : ''}
+              />
+              {errors.password && (
+                <div className="error-message">
+                  {errors.password}
+                </div>
+              )}
+            </div>
+
+            <div className="form-options">
+              <Checkbox 
+                checked={rememberMe}
+                onChange={handleRememberMeChange}
+              >
+                记住我
+              </Checkbox>
+              <Link to="/forgot-password" className="forgot-password">忘记密码？</Link>
+            </div>
+
+            <button
+              type="submit"
+              className={`login-button ${isLoading ? 'loading' : ''}`}
+              disabled={isLoading}
+            >
+              {isLoading ? (
+                <>
+                  <div className="loading-spinner"></div>
+                  登录中...
+                </>
+              ) : (
+                '登录'
+              )}
+            </button>
+          </form>
+
+          <div className="signup-link">
+            <p>还没有账户？ <Link to="/register">立即注册</Link></p>
+          </div>
+        </div>
+      </div>
+
+      {/* 错误弹窗 */}
+      <Modal
+        title={
+          <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
+            <ExclamationCircleOutlined style={{ color: '#ff4d4f', fontSize: '18px' }} />
+            {errorModal.title}
+          </div>
+        }
+        open={errorModal.visible}
+        onOk={closeErrorModal}
+        onCancel={closeErrorModal}
+        okText="我知道了"
+        cancelButtonProps={{ style: { display: 'none' } }}
+        centered
+        className="error-modal"
+      >
+        <div style={{ padding: '16px 0', fontSize: '14px', lineHeight: '1.6' }}>
+          {errorModal.content}
+        </div>
+      </Modal>
+    </div>
+  );
+};
+
+export default LoginPage;
diff --git a/Merge/front/src/pages/RegisterPage/RegisterPage.css b/Merge/front/src/pages/RegisterPage/RegisterPage.css
new file mode 100644
index 0000000..fc03361
--- /dev/null
+++ b/Merge/front/src/pages/RegisterPage/RegisterPage.css
@@ -0,0 +1,1027 @@
+/* 注册页面容器 */
+.register-container {
+  min-height: 100vh;
+  min-height: 100dvh; /* 动态视口高度，避免移动端地址栏影响 */
+  height: 100vh;
+  height: 100dvh;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  overflow: hidden;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+    sans-serif;
+  /* 确保容器稳定定位 */
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  /* 重置文本对齐 */
+  text-align: initial;
+}
+
+/* 小红书风格背景 */
+.register-background {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: #f8f8f8;
+  z-index: -1;
+}
+
+/* 注册内容区域 */
+.register-content {
+  width: 100%;
+  max-width: 500px; /* 增加桌面端最大宽度 */
+  padding: 0;
+  z-index: 1;
+  /* 确保内容稳定定位 */
+  box-sizing: border-box;
+  position: relative;
+  display: flex;
+  justify-content: center;
+}
+
+/* 小红书风格注册卡片 */
+.register-card {
+  background: #fff;
+  border-radius: 8px;
+  padding: 40px; /* 增加桌面端内边距 */
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.1);
+  border: 1px solid #e1e1e1;
+  width: 100%;
+  max-width: 450px; /* 增加桌面端卡片最大宽度 */
+  transition: none;
+}
+
+/* 注册头部 */
+.register-header {
+  text-align: center;
+  margin-bottom: 40px;
+}
+
+/* Logo样式 */
+.logo-section {
+  margin-bottom: 24px;
+}
+
+.logo-icon {
+  width: 60px;
+  height: 60px;
+  background: #ff2442;
+  border-radius: 12px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 28px;
+  margin: 0 auto 16px;
+  box-shadow: 0 4px 12px rgba(255, 36, 66, 0.2);
+}
+
+.register-title {
+  font-size: 24px;
+  font-weight: 600;
+  color: #333;
+  margin: 0 0 12px 0;
+  text-align: center;
+}
+
+.register-title::after {
+  display: none;
+}
+
+.register-subtitle {
+  font-size: 14px;
+  color: #999;
+  margin: 0 0 32px 0;
+  font-weight: 400;
+  text-align: center;
+}
+
+/* 表单样式 */
+.register-form {
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+  width: 100%;
+}
+
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  width: 100%;
+  box-sizing: border-box;
+  margin-bottom: 2px;
+  position: relative; /* 为绝对定位的错误提示提供参考点 */
+}
+
+.form-group .input-wrapper {
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.form-label {
+  font-size: 14px;
+  font-weight: 500;
+  color: #333;
+  margin-bottom: 8px;
+}
+
+.input-wrapper {
+  position: relative;
+  display: flex;
+  align-items: center;
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.form-input {
+  width: 100% !important;
+  height: 44px;
+  padding: 12px 16px 12px 48px;
+  border: 1px solid #e1e1e1;
+  border-radius: 6px;
+  font-size: 14px;
+  transition: border-color 0.2s ease;
+  background: #fff;
+  color: #333;
+  box-sizing: border-box !important;
+  flex: 1;
+  min-width: 0;
+}
+
+/* 针对 Antd Input 组件的特定样式 */
+.form-input.ant-input,
+.form-input.ant-input-affix-wrapper {
+  width: 100% !important;
+  height: 44px !important;
+  border: 1px solid #e1e1e1 !important;
+  border-radius: 6px !important;
+  padding: 12px 48px 12px 48px !important;
+  font-size: 14px !important;
+  background: #fff !important;
+  color: #333 !important;
+  box-sizing: border-box !important;
+  flex: 1 !important;
+  min-width: 0 !important;
+  display: flex !important;
+  align-items: center !important;
+}
+
+.form-input.ant-input-affix-wrapper .ant-input {
+  width: 100% !important;
+  height: 100% !important;
+  padding: 0 !important;
+  border: none !important;
+  background: transparent !important;
+  flex: 1 !important;
+  min-width: 0 !important;
+  box-sizing: border-box !important;
+}
+
+.form-input:focus {
+  outline: none;
+  border-color: #ff2442;
+  box-shadow: none;
+  transform: none;
+}
+
+/* Antd Input focus 样式 */
+.form-input.ant-input:focus,
+.form-input.ant-input-affix-wrapper:focus,
+.form-input.ant-input-affix-wrapper-focused {
+  outline: none !important;
+  border-color: #ff2442 !important;
+  box-shadow: none !important;
+  transform: none !important;
+}
+
+.form-input::placeholder {
+  color: #9ca3af;
+}
+
+.input-icon {
+  position: absolute;
+  left: 16px;
+  top: 50%;
+  transform: translateY(-50%);
+  color: #9ca3af;
+  pointer-events: none;
+  transition: color 0.3s ease;
+  z-index: 2;
+}
+
+.form-input:focus + .input-icon {
+  color: #ff2442;
+}
+
+.password-toggle {
+  position: absolute;
+  right: 12px;
+  top: 50%;
+  transform: translateY(-50%);
+  background: none;
+  border: none;
+  color: #9ca3af;
+  cursor: pointer;
+  padding: 4px;
+  border-radius: 4px;
+  transition: all 0.3s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 2;
+  width: 24px;
+  height: 24px;
+}
+
+.password-toggle:hover {
+  color: #ff2442;
+  background-color: rgba(255, 36, 66, 0.1);
+}
+
+/* 邮箱验证码输入框容器 */
+.email-code-wrapper {
+  display: flex;
+  gap: 8px;
+  width: 100%;
+  box-sizing: border-box;
+  align-items: flex-start;
+}
+
+.email-code-input {
+  flex: 1;
+  min-width: 0;
+}
+
+.send-code-button {
+  height: 44px !important;
+  padding: 0 16px !important;
+  background: #ff2442 !important;
+  border-color: #ff2442 !important;
+  border-radius: 6px !important;
+  font-size: 14px !important;
+  font-weight: 500 !important;
+  white-space: nowrap !important;
+  flex-shrink: 0 !important;
+  min-width: 100px !important;
+  display: flex !important;
+  align-items: center !important;
+  justify-content: center !important;
+  transition: all 0.2s ease !important;
+  box-sizing: border-box !important;
+}
+
+.send-code-button:hover:not(:disabled) {
+  background: #d91e3a !important;
+  border-color: #d91e3a !important;
+  transform: none !important;
+  box-shadow: none !important;
+}
+
+.send-code-button:disabled {
+  background: #f5f5f5 !important;
+  border-color: #d9d9d9 !important;
+  color: #bfbfbf !important;
+  cursor: not-allowed !important;
+}
+
+.send-code-button.ant-btn-loading {
+  background: #ff2442 !important;
+  border-color: #ff2442 !important;
+  color: white !important;
+}
+
+/* 小红书风格注册按钮 */
+.register-button {
+  width: 100%;
+  height: 48px; /* 固定高度，防止布局变化 */
+  padding: 12px;
+  background: #ff2442;
+  color: white;
+  border: none;
+  border-radius: 6px;
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  margin-top: 8px;
+  position: relative; /* 为绝对定位的加载状态做准备 */
+  box-sizing: border-box; /* 确保padding包含在总尺寸内 */
+  min-width: 0; /* 防止flex子元素造成宽度变化 */
+}
+
+.register-button:hover:not(:disabled) {
+  background: #d91e3a;
+  transform: none;
+  box-shadow: none;
+}
+
+.register-button:active:not(:disabled) {
+  transform: none;
+}
+
+.register-button:disabled {
+  background: #ccc;
+  cursor: not-allowed;
+  opacity: 0.8;
+}
+
+.register-button.loading {
+  background: #ff7b8a;
+  cursor: not-allowed;
+}
+
+.loading-spinner {
+  width: 16px;
+  height: 16px;
+  border: 2px solid rgba(255, 255, 255, 0.3);
+  border-radius: 50%;
+  border-top-color: #fff;
+  animation: spin 1s ease-in-out infinite;
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+/* 加载遮罩层 */
+.loading-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+  backdrop-filter: blur(4px);
+}
+
+.loading-content {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 16px;
+  background: white;
+  padding: 32px;
+  border-radius: 12px;
+  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
+}
+
+.loading-spinner-large {
+  width: 40px;
+  height: 40px;
+  border: 4px solid rgba(255, 36, 66, 0.2);
+  border-radius: 50%;
+  border-top-color: #ff2442;
+  animation: spin 1s ease-in-out infinite;
+}
+
+.loading-text {
+  margin: 0;
+  color: #333;
+  font-size: 16px;
+  font-weight: 500;
+}
+
+/* 分隔线 */
+.register-divider {
+  position: relative;
+  text-align: center;
+  margin: 32px 0;
+  color: #9ca3af;
+  font-size: 14px;
+}
+
+.register-divider::before {
+  content: '';
+  position: absolute;
+  top: 50%;
+  left: 0;
+  right: 0;
+  height: 1px;
+  background: linear-gradient(to right, transparent, #e5e7eb, transparent);
+}
+
+.register-divider span {
+  background: rgba(255, 255, 255, 0.95);
+  padding: 0 16px;
+  position: relative;
+  z-index: 1;
+}
+
+/* 社交登录 */
+.social-login {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.social-button {
+  width: 100%;
+  padding: 12px 16px;
+  border: 1px solid #e1e1e1;
+  border-radius: 6px;
+  background: white;
+  color: #333;
+  font-size: 14px;
+  font-weight: 400;
+  cursor: pointer;
+  transition: border-color 0.2s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+}
+
+.social-button:hover {
+  border-color: #ccc;
+}
+
+.social-button.google:hover {
+  border-color: #4285f4;
+  box-shadow: 0 4px 12px rgba(66, 133, 244, 0.2);
+}
+
+.social-button.github:hover {
+  border-color: #333;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+}
+
+.social-button.xiaohongshu:hover {
+  border-color: #ff2442;
+  box-shadow: 0 4px 12px rgba(255, 36, 66, 0.2);
+}
+
+/* 登录链接 */
+.login-link {
+  text-align: center;
+  margin-top: 20px;
+  padding-top: 20px;
+  border-top: 1px solid #e5e7eb;
+}
+
+.login-link p {
+  margin: 0;
+  font-size: 14px;
+  color: #64748b;
+}
+
+.login-link a {
+  color: #ff2442;
+  text-decoration: none;
+  font-weight: 500;
+  transition: color 0.2s ease;
+}
+
+.login-link a:hover {
+  color: #d91e3a;
+  text-decoration: underline;
+}
+
+/* 有左侧图标时的内边距调整 */
+.input-wrapper.has-icon .form-input {
+  padding-left: 48px !important;
+}
+
+.input-wrapper.has-icon .form-input.ant-input,
+.input-wrapper.has-icon .form-input.ant-input-affix-wrapper {
+  padding-left: 48px !important;
+}
+
+/* 有右侧切换按钮时的内边距调整 */
+.input-wrapper.has-toggle .form-input {
+  padding-right: 48px !important;
+}
+
+.input-wrapper.has-toggle .form-input.ant-input,
+.input-wrapper.has-toggle .form-input.ant-input-affix-wrapper {
+  padding-right: 48px !important;
+}
+
+/* 没有图标时的内边距调整 */
+.input-wrapper:not(.has-icon) .form-input {
+  padding-left: 16px !important;
+}
+
+.input-wrapper:not(.has-icon) .form-input.ant-input,
+.input-wrapper:not(.has-icon) .form-input.ant-input-affix-wrapper {
+  padding-left: 16px !important;
+}
+
+/* 没有切换按钮时的内边距调整 */
+.input-wrapper:not(.has-toggle) .form-input {
+  padding-right: 16px !important;
+}
+
+.input-wrapper:not(.has-toggle) .form-input.ant-input,
+.input-wrapper:not(.has-toggle) .form-input.ant-input-affix-wrapper {
+  padding-right: 16px !important;
+}
+
+/* 确保输入框内容完全填充 */
+.form-input.ant-input-affix-wrapper .ant-input-suffix {
+  position: absolute !important;
+  right: 12px !important;
+  top: 50% !important;
+  transform: translateY(-50%) !important;
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+.form-input.ant-input-affix-wrapper .ant-input-prefix {
+  position: absolute !important;
+  left: 16px !important;
+  top: 50% !important;
+  transform: translateY(-50%) !important;
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+/* 确保所有输入框完全填充其容器 */
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.form-group .input-wrapper {
+  width: 100%;
+  box-sizing: border-box;
+}
+
+/* 防止输入框溢出容器 */
+.form-input,
+.form-input.ant-input,
+.form-input.ant-input-affix-wrapper {
+  max-width: 100% !important;
+  overflow: hidden !important;
+}
+
+/* 确保内部输入元素不会超出边界 */
+.form-input.ant-input-affix-wrapper .ant-input {
+  max-width: 100% !important;
+  overflow: hidden !important;
+  text-overflow: ellipsis !important;
+}
+
+/* 精细间距控制 */
+.register-header + .register-form {
+  margin-top: -4px;
+}
+
+.register-form .form-group:not(:last-child) {
+  margin-bottom: 2px;
+}
+
+.register-form .form-group:last-of-type {
+  margin-bottom: 6px;
+}
+
+.register-button + .login-link {
+  margin-top: 14px;
+}
+
+/* 响应式设计 */
+@media (max-width: 768px) {
+  /* 重置body和html确保一致性 */
+  html, body {
+    height: 100%;
+    height: 100dvh;
+    margin: 0;
+    padding: 0;
+    overflow-x: hidden;
+    box-sizing: border-box;
+  }
+  
+  .register-container {
+    padding: 16px;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    min-height: 100dvh; /* 动态视口高度 */
+    /* 强制重置可能影响定位的样式 */
+    margin: 0;
+    box-sizing: border-box;
+    /* 防止内容溢出影响布局 */
+    overflow-x: hidden;
+    overflow-y: auto;
+    /* 确保flexbox在所有移动设备上表现一致 */
+    -webkit-box-align: center;
+    -webkit-box-pack: center;
+    display: flex !important;
+    position: relative;
+  }
+  
+  .register-content {
+    max-width: 100%;
+    padding: 20px;
+    /* 确保内容区域稳定 */
+    margin: 0 auto;
+    box-sizing: border-box;
+    /* 防止宽度计算问题 */
+    width: calc(100% - 40px);
+    max-width: 480px; /* 增加最大宽度 */
+    position: relative;
+    display: flex;
+    justify-content: center;
+  }
+  
+  .register-card {
+    padding: 32px 28px; /* 增加内边距 */
+    border-radius: 16px;
+    /* 确保卡片稳定定位 */
+    margin: 0;
+    box-sizing: border-box;
+    width: 100%;
+    max-width: 450px; /* 增加卡片最大宽度 */
+    /* 防止backdrop-filter导致的渲染差异 */
+    will-change: auto;
+    position: relative;
+    /* 防止触摸操作影响布局 */
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    -webkit-tap-highlight-color: transparent;
+  }
+  
+  .register-title {
+    font-size: 24px;
+  }
+  
+  .form-input {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px;
+    font-size: 16px; /* 防止iOS Safari缩放 */
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input,
+  .form-input.ant-input-affix-wrapper {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px !important;
+    font-size: 16px !important;
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input-affix-wrapper .ant-input {
+    width: 100% !important;
+    height: 100% !important;
+    padding: 0 !important;
+    border: none !important;
+    background: transparent !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+    box-sizing: border-box !important;
+  }
+  
+  .social-login {
+    gap: 10px;
+  }
+  
+  .social-button {
+    padding: 12px 16px;
+    font-size: 14px;
+  }
+}
+
+@media (max-width: 480px) {
+  .register-container {
+    padding: 16px;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    min-height: 100dvh; /* 动态视口高度 */
+    /* 强制重置样式 */
+    margin: 0;
+    box-sizing: border-box;
+    position: relative;
+    /* 确保垂直居中 */
+    display: flex !important;
+  }
+  
+  .register-content {
+    /* 更严格的尺寸控制 */
+    width: calc(100vw - 32px);
+    max-width: 420px; /* 增加最大宽度 */
+    padding: 16px;
+    margin: 0 auto;
+    box-sizing: border-box;
+    display: flex;
+    justify-content: center;
+  }
+  
+  .register-card {
+    padding: 28px 24px; /* 增加内边距 */
+    border-radius: 12px;
+    /* 确保卡片完全稳定 */
+    margin: 0;
+    box-sizing: border-box;
+    width: 100%;
+    position: relative;
+    /* 防止变换导致的位置偏移 */
+    transform: none !important;
+    /* 防止触摸操作影响布局 */
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    /* 防止点击时的高亮效果影响布局 */
+    -webkit-tap-highlight-color: transparent;
+  }
+  
+  .register-title {
+    font-size: 22px;
+  }
+  
+  .form-input {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px;
+    font-size: 16px; /* 防止iOS Safari缩放 */
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input,
+  .form-input.ant-input-affix-wrapper {
+    width: 100% !important;
+    height: 44px !important;
+    padding: 12px 48px 12px 48px !important;
+    font-size: 16px !important;
+    box-sizing: border-box !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+  }
+  
+  .form-input.ant-input-affix-wrapper .ant-input {
+    width: 100% !important;
+    height: 100% !important;
+    padding: 0 !important;
+    border: none !important;
+    background: transparent !important;
+    flex: 1 !important;
+    min-width: 0 !important;
+    box-sizing: border-box !important;
+  }
+  
+  .social-login {
+    gap: 10px;
+  }
+  
+  .social-button {
+    padding: 12px 16px;
+    font-size: 14px;
+  }
+  
+  /* 移动端优化 */
+  .background-pattern {
+    display: none;
+  }
+  
+  /* 禁用可能影响位置的悬停效果 */
+  .register-card:hover {
+    transform: none !important;
+  }
+}
+
+/* 高对比度模式支持 */
+@media (prefers-contrast: high) {
+  .register-card {
+    background: white;
+    border: 2px solid #000;
+  }
+  
+  .form-input {
+    border-color: #000;
+  }
+  
+  .form-input:focus {
+    border-color: #0066cc;
+    box-shadow: 0 0 0 2px #0066cc;
+  }
+}
+
+/* 减少动画模式 */
+@media (prefers-reduced-motion: reduce) {
+  .background-pattern {
+    animation: none;
+  }
+  
+  .register-card,
+  .form-input,
+  .register-button,
+  .social-button {
+    transition: none;
+  }
+}
+
+/* 深色模式支持 */
+@media (prefers-color-scheme: dark) {
+  .register-background {
+    background: linear-gradient(135deg, #1a202c 0%, #2d3748 100%);
+  }
+  
+  .register-card {
+    background: rgba(26, 32, 44, 0.95);
+    border-color: rgba(255, 255, 255, 0.1);
+  }
+  
+  .register-title {
+    color: #f7fafc;
+  }
+  
+  .register-subtitle {
+    color: #a0aec0;
+  }
+  
+  .form-label {
+    color: #e2e8f0;
+  }
+  
+  .form-input {
+    background: #2d3748;
+    border-color: #4a5568;
+    color: #f7fafc;
+  }
+  
+  .form-input:focus {
+    border-color: #ff2442;
+  }
+  
+  .social-button {
+    background: #2d3748;
+    border-color: #4a5568;
+    color: #f7fafc;
+  }
+  
+  .login-link {
+    border-color: #4a5568;
+  }
+  
+  .login-link p {
+    color: #a0aec0;
+  }
+  
+  /* 深色模式下的错误提示样式 */
+  .error-message {
+    background: rgba(26, 32, 44, 0.95);
+    color: #ff6b6b;
+  }
+}
+
+/* 错误提示样式 - 使用绝对定位避免影响布局 */
+.error-message {
+  position: absolute;
+  top: 95%;
+  left: 4px;
+  right: 4px;
+  font-size: 12px;
+  color: #ff4d4f;
+  margin-top: 4px;
+  display: flex;
+  align-items: center;
+  min-height: 16px;
+  animation: fadeInDown 0.3s ease-out;
+  font-weight: 400;
+  line-height: 1.2;
+  background: rgba(255, 255, 255, 0.95);
+  backdrop-filter: blur(4px);
+  padding: 2px 4px;
+  border-radius: 4px;
+  z-index: 10;
+  pointer-events: none; /* 避免干扰用户交互 */
+}
+
+@keyframes fadeInDown {
+  from {
+    opacity: 0;
+    transform: translateY(-8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+/* 输入框错误状态样式 */
+.form-input.input-error,
+.form-input.input-error.ant-input,
+.form-input.input-error.ant-input-affix-wrapper {
+  border-color: #ff4d4f !important;
+  box-shadow: 0 0 0 2px rgba(255, 77, 79, 0.1) !important;
+  transition: all 0.3s ease !important;
+}
+
+.form-input.input-error:focus,
+.form-input.input-error.ant-input:focus,
+.form-input.input-error.ant-input-affix-wrapper:focus,
+.form-input.input-error.ant-input-affix-wrapper-focused {
+  border-color: #ff4d4f !important;
+  box-shadow: 0 0 0 2px rgba(255, 77, 79, 0.2) !important;
+}
+
+/* 错误状态下的图标颜色 */
+.form-input.input-error .anticon {
+  color: #ff4d4f !important;
+}
+
+/* 确保表单组间距一致 */
+.form-group {
+  margin-bottom: 0px;
+}
+
+.form-group:last-of-type {
+  margin-bottom: 0px;
+}
+
+/* 错误弹窗样式 */
+.error-modal .ant-modal-header {
+  background: #fff;
+  border-bottom: 1px solid #f0f0f0;
+  padding: 16px 24px;
+}
+
+.error-modal .ant-modal-title {
+  color: #333;
+  font-weight: 600;
+  font-size: 16px;
+}
+
+.error-modal .ant-modal-body {
+  padding: 16px 24px 24px;
+}
+
+.error-modal .ant-modal-footer {
+  padding: 12px 24px 24px;
+  border-top: none;
+  text-align: center;
+}
+
+.error-modal .ant-btn-primary {
+  background: #ff2442;
+  border-color: #ff2442;
+  font-weight: 500;
+  height: 40px;
+  padding: 0 24px;
+  border-radius: 6px;
+  transition: all 0.2s ease;
+}
+
+.error-modal .ant-btn-primary:hover {
+  background: #d91e3a;
+  border-color: #d91e3a;
+  transform: translateY(-1px);
+  box-shadow: 0 4px 12px rgba(255, 36, 66, 0.3);
+}
+
+.error-modal .ant-modal-content {
+  border-radius: 12px;
+  overflow: hidden;
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
+}
+
+/* 错误弹窗遮罩层 */
+.error-modal .ant-modal-mask {
+  background: rgba(0, 0, 0, 0.6);
+  backdrop-filter: blur(4px);
+}
+
+/* 错误弹窗动画 */
+.error-modal .ant-modal {
+  animation: errorModalSlideIn 0.3s ease-out;
+}
+
+@keyframes errorModalSlideIn {
+  from {
+    opacity: 0;
+    transform: translateY(-20px) scale(0.95);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
diff --git a/Merge/front/src/pages/RegisterPage/RegisterPage.js b/Merge/front/src/pages/RegisterPage/RegisterPage.js
new file mode 100644
index 0000000..836e1cf
--- /dev/null
+++ b/Merge/front/src/pages/RegisterPage/RegisterPage.js
@@ -0,0 +1,625 @@
+import React, { useState } from 'react';
+import { Link, useNavigate } from 'react-router-dom';
+import { Input, Button, message, Modal, Alert } from 'antd';
+import { MailOutlined, LockOutlined, UserOutlined, SafetyOutlined, ExclamationCircleOutlined, CheckCircleOutlined } from '@ant-design/icons';
+import { hashPassword } from '../../utils/crypto';
+import './RegisterPage.css';
+
+const baseURL = 'http://10.126.59.25:8082';
+
+const RegisterPage = () => {
+  const [formData, setFormData] = useState({
+    username: '',
+    email: '',
+    emailCode: '',
+    password: '',
+    confirmPassword: ''
+  });
+
+  const [errors, setErrors] = useState({
+    username: '',
+    email: '',
+    emailCode: '',
+    password: '',
+    confirmPassword: ''
+  });
+
+  const [emailCodeSent, setEmailCodeSent] = useState(false);
+  const [countdown, setCountdown] = useState(0);
+  const [sendingCode, setSendingCode] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [errorModal, setErrorModal] = useState({
+    visible: false,
+    title: '',
+    content: ''
+  });
+  const [successAlert, setSuccessAlert] = useState({
+    visible: false,
+    message: ''
+  });
+  const [emailCodeSuccessAlert, setEmailCodeSuccessAlert] = useState({
+    visible: false,
+    message: ''
+  });
+
+  const navigate = useNavigate();
+
+  // 显示错误弹窗
+  const showErrorModal = (title, content) => {
+    setErrorModal({
+      visible: true,
+      title: title,
+      content: content
+    });
+  };
+
+  // 关闭错误弹窗
+  const closeErrorModal = () => {
+    setErrorModal({
+      visible: false,
+      title: '',
+      content: ''
+    });
+  };
+
+  // 显示成功提示
+  const showSuccessAlert = (message) => {
+    setSuccessAlert({
+      visible: true,
+      message: message
+    });
+    
+    // 3秒后自动隐藏
+    setTimeout(() => {
+      setSuccessAlert({
+        visible: false,
+        message: ''
+      });
+    }, 3000);
+  };
+
+  // 显示邮件验证码发送成功提示
+  const showEmailCodeSuccessAlert = (message) => {
+    setEmailCodeSuccessAlert({
+      visible: true,
+      message: message
+    });
+    
+    // 5秒后自动隐藏
+    setTimeout(() => {
+      setEmailCodeSuccessAlert({
+        visible: false,
+        message: ''
+      });
+    }, 5000);
+  };
+
+  // 倒计时效果
+  React.useEffect(() => {
+    let timer;
+    if (countdown > 0) {
+      timer = setTimeout(() => {
+        setCountdown(countdown - 1);
+      }, 1000);
+    }
+    return () => clearTimeout(timer);
+  }, [countdown]);
+
+  // 发送邮箱验证码
+  const sendEmailCode = async () => {
+    // 验证邮箱格式
+    if (!formData.email || typeof formData.email !== 'string' || !formData.email.trim()) {
+      setErrors(prev => ({
+        ...prev,
+        email: '请先输入邮箱地址'
+      }));
+      return;
+    }
+    
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) {
+      setErrors(prev => ({
+        ...prev,
+        email: '请输入有效的邮箱地址'
+      }));
+      return;
+    }
+
+    setSendingCode(true);
+    
+    try {
+      // 调用后端API发送验证码
+      const response = await fetch(baseURL + '/send-verification-code', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          email: formData.email,
+          verification_type: 'register'
+        })
+      });
+      
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      
+      const result = await response.json();
+      
+      if (result.success) {
+        showEmailCodeSuccessAlert('验证码已发送到您的邮箱');
+        setEmailCodeSent(true);
+        setCountdown(60); // 60秒倒计时
+        
+        // 清除邮箱错误提示
+        setErrors(prev => ({
+          ...prev,
+          email: ''
+        }));
+      } else {
+        // 根据具体错误信息进行处理
+        const errorMessage = result.message || '发送验证码失败，请稍后再试';
+        
+        if (errorMessage.includes('邮箱') && (errorMessage.includes('已注册') || errorMessage.includes('已存在'))) {
+          setErrors(prev => ({
+            ...prev,
+            email: errorMessage
+          }));
+        } else {
+          showErrorModal('发送验证码失败', errorMessage);
+        }
+      }
+      
+    } catch (error) {
+      console.error('发送验证码失败:', error);
+      
+      // 根据错误类型显示不同的错误信息
+      if (error.name === 'TypeError' && error.message.includes('Failed to fetch')) {
+        showErrorModal('网络连接失败', '无法连接到服务器，请检查您的网络连接后重试。如果问题持续存在，请联系客服。');
+      } else if (error.message.includes('HTTP 500')) {
+        showErrorModal('服务器错误', '服务器出现了内部错误，请稍后重试。如果问题持续存在，请联系客服。');
+      } else if (error.message.includes('HTTP 429')) {
+        showErrorModal('发送频率限制', '验证码发送过于频繁，请稍后再试。为了防止垃圾邮件，系统限制了发送频率。');
+      } else if (error.message.includes('HTTP 400')) {
+        showErrorModal('请求错误', '邮箱格式错误，请检查邮箱地址是否正确。');
+      } else {
+        showErrorModal('发送失败', '发送验证码失败，请稍后重试。如果问题持续存在，请联系客服。');
+      }
+    } finally {
+      setSendingCode(false);
+    }
+  };
+
+  const handleInputChange = (field) => (e) => {
+    const value = e.target.value;
+    setFormData(prev => ({
+      ...prev,
+      [field]: value
+    }));
+    
+    // 清除对应字段的错误提示
+    if (errors[field]) {
+      setErrors(prev => ({
+        ...prev,
+        [field]: ''
+      }));
+    }
+  };
+
+  const handlePasswordChange = (e) => {
+    const value = e.target.value;
+    setFormData(prev => ({
+      ...prev,
+      password: value
+    }));
+    
+    // 清除密码错误提示
+    if (errors.password) {
+      setErrors(prev => ({
+        ...prev,
+        password: ''
+      }));
+    }
+  };
+
+  const handleConfirmPasswordChange = (e) => {
+    const value = e.target.value;
+    setFormData(prev => ({
+      ...prev,
+      confirmPassword: value
+    }));
+    
+    // 清除确认密码错误提示
+    if (errors.confirmPassword) {
+      setErrors(prev => ({
+        ...prev,
+        confirmPassword: ''
+      }));
+    }
+  };
+
+  const validateForm = () => {
+    const newErrors = {
+      username: '',
+      email: '',
+      emailCode: '',
+      password: '',
+      confirmPassword: ''
+    };
+    
+    let hasError = false;
+    
+    // 验证用户名
+    if (!formData.username || typeof formData.username !== 'string' || !formData.username.trim()) {
+      newErrors.username = '请输入用户名';
+      hasError = true;
+    } else if (formData.username.length < 2) {
+      newErrors.username = '用户名至少2个字符';
+      hasError = true;
+    } else if (formData.username.length > 20) {
+      newErrors.username = '用户名不能超过20个字符';
+      hasError = true;
+    }
+    
+    // 验证邮箱
+    if (!formData.email || typeof formData.email !== 'string' || !formData.email.trim()) {
+      newErrors.email = '请输入邮箱地址';
+      hasError = true;
+    } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) {
+      newErrors.email = '请输入有效的邮箱地址';
+      hasError = true;
+    }
+    
+    // 验证邮箱验证码
+    if (!formData.emailCode || typeof formData.emailCode !== 'string' || !formData.emailCode.trim()) {
+      newErrors.emailCode = '请输入邮箱验证码';
+      hasError = true;
+    } else if (formData.emailCode.length !== 6 || !/^\d{6}$/.test(formData.emailCode)) {
+      newErrors.emailCode = '请输入6位数字验证码';
+      hasError = true;
+    }
+    
+    // 验证密码
+    if (!formData.password || typeof formData.password !== 'string' || !formData.password.trim()) {
+      newErrors.password = '请输入密码';
+      hasError = true;
+    } else if (formData.password.length < 6) {
+      newErrors.password = '密码长度至少6位';
+      hasError = true;
+    } else if (formData.password.length > 20) {
+      newErrors.password = '密码长度不能超过20位';
+      hasError = true;
+    }
+    
+    // 验证确认密码
+    if (!formData.confirmPassword || typeof formData.confirmPassword !== 'string' || !formData.confirmPassword.trim()) {
+      newErrors.confirmPassword = '请确认密码';
+      hasError = true;
+    } else if (formData.password !== formData.confirmPassword) {
+      newErrors.confirmPassword = '两次输入的密码不一致';
+      hasError = true;
+    }
+    
+    setErrors(newErrors);
+    return !hasError;
+  };
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    
+    // 验证表单
+    if (!validateForm()) {
+      return;
+    }
+    
+    setIsLoading(true);
+    
+    try {
+      // 调用后端API进行注册
+      const registerResponse = await fetch(baseURL + '/register', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          username: formData.username,
+          email: formData.email,
+          password: hashPassword(formData.password), // 前端加密密码
+          verification_code: hashPassword(formData.emailCode) // 前端加密验证码
+        })
+      });
+      
+      if (!registerResponse.ok) {
+        throw new Error(`HTTP ${registerResponse.status}: ${registerResponse.statusText}`);
+      }
+      
+      const registerResult = await registerResponse.json();
+      
+      if (registerResult.success) {
+        showSuccessAlert('注册成功！欢迎加入小红书，正在跳转到登录页面...');
+        // 清空表单数据
+        setFormData({
+          username: '',
+          email: '',
+          emailCode: '',
+          password: '',
+          confirmPassword: ''
+        });
+        setErrors({
+          username: '',
+          email: '',
+          emailCode: '',
+          password: '',
+          confirmPassword: ''
+        });
+        // 延迟跳转到登录页面，让用户看到成功提示
+        setTimeout(() => {
+          navigate('/login');
+        }, 2000);
+      } else {
+        // 处理不同的注册失败情况
+        const errorMessage = registerResult.message || '注册失败，请稍后再试';
+        
+        // 如果是邮箱已存在的错误，将错误显示在邮箱字段下方
+        if (errorMessage.includes('邮箱') && (errorMessage.includes('已存在') || errorMessage.includes('已注册'))) {
+          setErrors(prev => ({
+            ...prev,
+            email: errorMessage
+          }));
+        } 
+        // 如果是用户名已存在的错误，将错误显示在用户名字段下方
+        else if (errorMessage.includes('用户名') && (errorMessage.includes('已存在') || errorMessage.includes('已被使用'))) {
+          setErrors(prev => ({
+            ...prev,
+            username: errorMessage
+          }));
+        } 
+        else {
+          // 其他错误显示在消息框中
+          message.error(errorMessage);
+        }
+      }
+      
+    } catch (error) {
+      console.error('注册失败:', error);
+      
+      // 根据错误类型显示不同的错误信息
+      if (error.name === 'TypeError' && error.message.includes('Failed to fetch')) {
+        showErrorModal('网络连接失败', '无法连接到服务器，请检查您的网络连接后重试。如果问题持续存在，请联系客服。');
+      } else if (error.message.includes('HTTP 500')) {
+        showErrorModal('服务器内部错误', '服务器出现了内部错误，请稍后重试或联系客服。技术团队已收到通知。');
+      } else if (error.message.includes('HTTP 400')) {
+        showErrorModal('请求参数错误', '请求参数有误，请检查您输入的信息是否正确。');
+      } else if (error.message.includes('HTTP 409')) {
+        showErrorModal('用户信息冲突', '您输入的邮箱或用户名可能已被其他用户使用，请尝试使用其他邮箱或用户名。');
+      } else if (error.message.includes('HTTP')) {
+        showErrorModal('请求失败', `请求失败 (${error.message})，请稍后重试。如果问题持续存在，请联系客服。`);
+      } else {
+        showErrorModal('注册失败', '注册过程中发生未知错误，请稍后重试。如果问题持续存在，请联系客服。');
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return (
+    <div className="register-container">
+      <div className="register-background"></div>
+      
+      {isLoading && (
+        <div className="loading-overlay">
+          <div className="loading-content">
+            <div className="loading-spinner-large"></div>
+            <p className="loading-text">正在注册...</p>
+          </div>
+        </div>
+      )}
+      
+      <div className="register-content">
+        <div className="register-card">
+          {/* 成功提示 */}
+          {successAlert.visible && (
+            <div style={{ marginBottom: '16px' }}>
+              <Alert
+                message={successAlert.message}
+                type="success"
+                icon={<CheckCircleOutlined />}
+                showIcon
+                closable
+                onClose={() => setSuccessAlert({ visible: false, message: '' })}
+                style={{
+                  borderRadius: '8px',
+                  border: '1px solid #b7eb8f',
+                  backgroundColor: '#f6ffed'
+                }}
+              />
+            </div>
+          )}
+
+          {/* 邮件验证码发送成功提示 */}
+          {emailCodeSuccessAlert.visible && (
+            <div style={{ marginBottom: '16px' }}>
+              <Alert
+                message={emailCodeSuccessAlert.message}
+                type="success"
+                icon={<CheckCircleOutlined />}
+                showIcon
+                closable
+                onClose={() => setEmailCodeSuccessAlert({ visible: false, message: '' })}
+                style={{
+                  borderRadius: '8px',
+                  border: '1px solid #b7eb8f',
+                  backgroundColor: '#f6ffed'
+                }}
+              />
+            </div>
+          )}
+          
+          <div className="register-header">
+            <h1 className="register-title">加入小红书</h1>
+            <p className="register-subtitle">发现美好生活，分享精彩瞬间</p>
+          </div>
+
+          <form className="register-form" onSubmit={handleSubmit}>
+            <div className="form-group">
+              <Input
+                type="text"
+                id="username"
+                name="username"
+                className={`form-input ${errors.username ? 'input-error' : ''}`}
+                placeholder="请输入用户名"
+                value={formData.username}
+                onChange={handleInputChange('username')}
+                prefix={<UserOutlined />}
+                size="large"
+                title=""
+                status={errors.username ? 'error' : ''}
+              />
+              {errors.username && (
+                <div className="error-message">
+                  {errors.username}
+                </div>
+              )}
+            </div>
+
+            <div className="form-group">
+              <Input
+                type="email"
+                id="email"
+                name="email"
+                className={`form-input ${errors.email ? 'input-error' : ''}`}
+                placeholder="请输入邮箱地址"
+                value={formData.email}
+                onChange={handleInputChange('email')}
+                prefix={<MailOutlined />}
+                size="large"
+                title=""
+                status={errors.email ? 'error' : ''}
+              />
+              {errors.email && (
+                <div className="error-message">
+                  {errors.email}
+                </div>
+              )}
+            </div>
+
+            <div className="form-group">
+              <div className="email-code-wrapper">
+                <Input
+                  type="text"
+                  id="emailCode"
+                  name="emailCode"
+                  className={`form-input email-code-input ${errors.emailCode ? 'input-error' : ''}`}
+                  placeholder="请输入6位验证码"
+                  value={formData.emailCode}
+                  onChange={handleInputChange('emailCode')}
+                  prefix={<SafetyOutlined />}
+                  maxLength={6}
+                  size="large"
+                  title=""
+                  status={errors.emailCode ? 'error' : ''}
+                />
+                <Button
+                  type="primary"
+                  className="send-code-button"
+                  onClick={sendEmailCode}
+                  loading={sendingCode}
+                  disabled={countdown > 0 || !formData.email || sendingCode}
+                  size="large"
+                >
+                  {countdown > 0 ? `${countdown}s后重发` : (emailCodeSent ? '重新发送' : '发送验证码')}
+                </Button>
+              </div>
+              {errors.emailCode && (
+                <div className="error-message">
+                  {errors.emailCode}
+                </div>
+              )}
+            </div>
+
+            <div className="form-group">
+              <Input.Password
+                id="password"
+                name="password"
+                className={`form-input ${errors.password ? 'input-error' : ''}`}
+                placeholder="请输入密码"
+                value={formData.password}
+                onChange={handlePasswordChange}
+                prefix={<LockOutlined />}
+                size="large"
+                title=""
+                status={errors.password ? 'error' : ''}
+              />
+              {errors.password && (
+                <div className="error-message">
+                  {errors.password}
+                </div>
+              )}
+            </div>
+
+            <div className="form-group">
+              <Input.Password
+                id="confirmPassword"
+                name="confirmPassword"
+                className={`form-input ${errors.confirmPassword ? 'input-error' : ''}`}
+                placeholder="请确认密码"
+                value={formData.confirmPassword}
+                onChange={handleConfirmPasswordChange}
+                prefix={<LockOutlined />}
+                size="large"
+                title=""
+                status={errors.confirmPassword ? 'error' : ''}
+              />
+              {errors.confirmPassword && (
+                <div className="error-message">
+                  {errors.confirmPassword}
+                </div>
+              )}
+            </div>
+
+            <button
+              type="submit"
+              className={`register-button ${isLoading ? 'loading' : ''}`}
+              disabled={isLoading}
+            >
+              {isLoading ? (
+                <>
+                  <div className="loading-spinner"></div>
+                  注册中...
+                </>
+              ) : (
+                '立即注册'
+              )}
+            </button>
+          </form>
+
+          <div className="login-link">
+            <p>已有账户？ <Link to="/login">立即登录</Link></p>
+          </div>
+        </div>
+      </div>
+
+      {/* 错误弹窗 */}
+      <Modal
+        title={
+          <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
+            <ExclamationCircleOutlined style={{ color: '#ff4d4f', fontSize: '18px' }} />
+            {errorModal.title}
+          </div>
+        }
+        open={errorModal.visible}
+        onOk={closeErrorModal}
+        onCancel={closeErrorModal}
+        okText="我知道了"
+        cancelButtonProps={{ style: { display: 'none' } }}
+        centered
+        className="error-modal"
+      >
+        <div style={{ padding: '16px 0', fontSize: '14px', lineHeight: '1.6' }}>
+          {errorModal.content}
+        </div>
+      </Modal>
+    </div>
+  );
+};
+
+export default RegisterPage;
diff --git a/Merge/front/src/pages/TestDashboard/TestDashboard.css b/Merge/front/src/pages/TestDashboard/TestDashboard.css
new file mode 100644
index 0000000..a9e1c80
--- /dev/null
+++ b/Merge/front/src/pages/TestDashboard/TestDashboard.css
@@ -0,0 +1,189 @@
+.test-dashboard {
+  min-height: 100vh;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  padding: 20px;
+}
+
+.dashboard-header {
+  text-align: center;
+  margin-bottom: 30px;
+  color: white;
+}
+
+.dashboard-header h1 {
+  font-size: 2.5rem;
+  margin-bottom: 10px;
+  text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+}
+
+.dashboard-header p {
+  font-size: 1.1rem;
+  opacity: 0.9;
+}
+
+.dashboard-content {
+  max-width: 1200px;
+  margin: 0 auto;
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.user-info-card,
+.token-info-card,
+.api-test-card {
+  background: white;
+  border-radius: 12px;
+  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+  border: none;
+}
+
+.user-info-card .ant-card-head {
+  background: linear-gradient(90deg, #4f46e5 0%, #7c3aed 100%);
+  border-radius: 12px 12px 0 0;
+  border-bottom: none;
+}
+
+.user-info-card .ant-card-head-title {
+  color: white;
+  font-weight: 600;
+}
+
+.user-info-card .ant-card-extra .ant-btn {
+  color: white;
+  border-color: rgba(255, 255, 255, 0.3);
+}
+
+.user-info-card .ant-card-extra .ant-btn:hover {
+  background: rgba(255, 255, 255, 0.1);
+  border-color: rgba(255, 255, 255, 0.5);
+}
+
+.user-info-card .ant-card-extra .ant-btn-danger {
+  background: #ef4444;
+  border-color: #ef4444;
+}
+
+.user-info-card .ant-card-extra .ant-btn-danger:hover {
+  background: #dc2626;
+  border-color: #dc2626;
+}
+
+.token-info-card .ant-card-head {
+  background: linear-gradient(90deg, #059669 0%, #0d9488 100%);
+  border-radius: 12px 12px 0 0;
+  border-bottom: none;
+}
+
+.token-info-card .ant-card-head-title {
+  color: white;
+  font-weight: 600;
+}
+
+.api-test-card .ant-card-head {
+  background: linear-gradient(90deg, #ea580c 0%, #dc2626 100%);
+  border-radius: 12px 12px 0 0;
+  border-bottom: none;
+}
+
+.api-test-card .ant-card-head-title {
+  color: white;
+  font-weight: 600;
+}
+
+.token-display {
+  background: #f8fafc;
+  padding: 20px;
+  border-radius: 8px;
+  border: 1px solid #e2e8f0;
+}
+
+.token-text {
+  background: #1e293b;
+  color: #10b981;
+  padding: 12px;
+  border-radius: 6px;
+  font-family: 'Courier New', monospace;
+  font-size: 14px;
+  word-break: break-all;
+  margin: 10px 0;
+  border: 1px solid #334155;
+}
+
+.token-note {
+  color: #64748b;
+  font-size: 12px;
+  font-style: italic;
+  margin: 10px 0 0 0;
+}
+
+.loading-container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  height: 100vh;
+  color: white;
+}
+
+.spinner {
+  width: 40px;
+  height: 40px;
+  border: 4px solid rgba(255, 255, 255, 0.3);
+  border-left-color: white;
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+  margin-bottom: 20px;
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.loading-container p {
+  font-size: 1.1rem;
+  opacity: 0.9;
+}
+
+/* 响应式设计 */
+@media (max-width: 768px) {
+  .test-dashboard {
+    padding: 10px;
+  }
+  
+  .dashboard-header h1 {
+    font-size: 2rem;
+  }
+  
+  .dashboard-content {
+    gap: 15px;
+  }
+  
+  .user-info-card .ant-card-extra {
+    flex-direction: column;
+    gap: 8px;
+  }
+  
+  .token-text {
+    font-size: 12px;
+  }
+}
+
+/* Ant Design 组件样式覆写 */
+.ant-descriptions-item-label {
+  font-weight: 600;
+  color: #374151;
+  background: #f9fafb;
+}
+
+.ant-descriptions-item-content {
+  color: #111827;
+}
+
+.ant-tag {
+  font-weight: 500;
+  border-radius: 6px;
+  padding: 2px 8px;
+}
diff --git a/Merge/front/src/pages/TestDashboard/TestDashboard.js b/Merge/front/src/pages/TestDashboard/TestDashboard.js
new file mode 100644
index 0000000..0cc9914
--- /dev/null
+++ b/Merge/front/src/pages/TestDashboard/TestDashboard.js
@@ -0,0 +1,295 @@
+import React, { useState, useEffect } from 'react';
+import { Card, Button, Descriptions, Avatar, Tag, Space, message } from 'antd';
+import { UserOutlined, LogoutOutlined, ReloadOutlined } from '@ant-design/icons';
+import { getUserInfo, getAuthToken, isLoggedIn, saveAuthInfo, createAuthenticatedRequest } from '../../utils/auth';
+import LogoutButton from '../../components/LogoutButton';
+import './TestDashboard.css';
+
+const TestDashboard = () => {
+  const [userInfo, setUserInfo] = useState(null);
+  const [token, setToken] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [jwtTestLoading, setJwtTestLoading] = useState(false);
+
+  useEffect(() => {
+    // 检查用户是否已登录
+    if (!isLoggedIn()) {
+      window.location.href = '/';
+      return;
+    }
+
+    // 获取用户信息和token
+    const authToken = getAuthToken();
+    const authUserInfo = getUserInfo();
+    
+    setToken(authToken);
+    setUserInfo(authUserInfo);
+  }, []);
+
+  const handleRefreshProfile = async () => {
+    if (!token) {
+      message.error('未找到认证token');
+      return;
+    }
+
+    setLoading(true);
+    try {
+      const response = await fetch('http://10.126.59.25:8082/profile', createAuthenticatedRequest());
+
+      const result = await response.json();
+      
+      if (result.success) {
+        setUserInfo(result.user);
+        // 更新存储的用户信息，保持原有的存储方式（localStorage或sessionStorage）
+        const isRemembered = localStorage.getItem('authToken');
+        saveAuthInfo(token, result.user, !!isRemembered);
+        message.success('用户信息刷新成功');
+      } else {
+        message.error(`获取用户信息失败: ${result.message}`);
+      }
+    } catch (error) {
+      console.error('刷新用户信息失败:', error);
+      message.error('网络连接失败');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleLogout = async () => {
+    if (!token) {
+      // 清除存储并跳转
+      localStorage.removeItem('authToken');
+      localStorage.removeItem('userInfo');
+      sessionStorage.removeItem('authToken');
+      sessionStorage.removeItem('userInfo');
+      window.location.href = '/';
+      return;
+    }
+
+    try {
+      const response = await fetch('http://10.126.59.25:8082/logout', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        }
+      });
+
+      const result = await response.json();
+      
+      if (result.success) {
+        message.success('退出登录成功');
+      } else {
+        message.warning(`退出登录: ${result.message}`);
+      }
+    } catch (error) {
+      console.error('退出登录请求失败:', error);
+      message.warning('网络请求失败，但将清除本地数据');
+    } finally {
+      // 无论请求成功与否，都清除本地存储并跳转
+      localStorage.removeItem('authToken');
+      localStorage.removeItem('userInfo');
+      sessionStorage.removeItem('authToken');
+      sessionStorage.removeItem('userInfo');
+      window.location.href = '/';
+    }
+  };
+
+  const handleTestJWT = async () => {
+    if (!token) {
+      message.error('未找到认证token');
+      return;
+    }
+
+    setJwtTestLoading(true);
+    try {
+      const response = await fetch('http://10.126.59.25:8082/test-jwt', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          token: token, // 可选：在请求体中也发送token进行额外验证
+          test_purpose: 'frontend_jwt_test'
+        })
+      });
+
+      const result = await response.json();
+      
+      if (result.success) {
+        message.success(`JWT令牌验证成功！用户: ${result.user.username}`);
+        console.log('JWT验证详细结果:', result);
+        
+        // 如果有额外的token验证结果，也显示出来
+        if (result.additional_token_verification) {
+          console.log('额外token验证:', result.additional_token_verification);
+        }
+      } else {
+        message.error(`JWT令牌验证失败: ${result.message}`);
+      }
+    } catch (error) {
+      console.error('JWT令牌验证失败:', error);
+      message.error('网络连接失败');
+    } finally {
+      setJwtTestLoading(false);
+    }
+  };
+
+  const getRoleColor = (role) => {
+    switch (role) {
+      case 'superadmin':
+        return 'red';
+      case 'admin':
+        return 'orange';
+      case 'user':
+      default:
+        return 'blue';
+    }
+  };
+
+  const getStatusColor = (status) => {
+    switch (status) {
+      case 'active':
+        return 'green';
+      case 'banned':
+        return 'red';
+      case 'muted':
+        return 'orange';
+      default:
+        return 'default';
+    }
+  };
+
+  if (!userInfo) {
+    return (
+      <div className="test-dashboard">
+        <div className="loading-container">
+          <div className="spinner"></div>
+          <p>加载用户信息中...</p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="test-dashboard">
+      <div className="dashboard-header">
+        <h1>测试仪表板</h1>
+        <p>登录成功！以下是从后端返回的用户信息：</p>
+      </div>
+
+      <div className="dashboard-content">
+        <Card
+          title={
+            <Space>
+              <Avatar size={40} icon={<UserOutlined />} src={userInfo.avatar} />
+              <span>用户信息</span>
+            </Space>
+          }
+          extra={
+            <Space>
+              <Button 
+                type="primary" 
+                icon={<ReloadOutlined />}
+                loading={loading}
+                onClick={handleRefreshProfile}
+              >
+                刷新信息
+              </Button>
+              <LogoutButton onLogout={() => window.location.href = '/'} />
+            </Space>
+          }
+          className="user-info-card"
+        >
+          <Descriptions column={2} bordered>
+            <Descriptions.Item label="用户ID">{userInfo.id}</Descriptions.Item>
+            <Descriptions.Item label="用户名">{userInfo.username}</Descriptions.Item>
+            <Descriptions.Item label="邮箱">{userInfo.email}</Descriptions.Item>
+            <Descriptions.Item label="角色">
+              <Tag color={getRoleColor(userInfo.role)}>
+                {userInfo.role}
+              </Tag>
+            </Descriptions.Item>
+            <Descriptions.Item label="账号状态">
+              <Tag color={getStatusColor(userInfo.status)}>
+                {userInfo.status}
+              </Tag>
+            </Descriptions.Item>
+            <Descriptions.Item label="个人简介" span={2}>
+              {userInfo.bio || '暂无个人简介'}
+            </Descriptions.Item>
+            <Descriptions.Item label="创建时间">
+              {userInfo.created_at ? new Date(userInfo.created_at).toLocaleString() : '未知'}
+            </Descriptions.Item>
+            <Descriptions.Item label="更新时间">
+              {userInfo.updated_at ? new Date(userInfo.updated_at).toLocaleString() : '未知'}
+            </Descriptions.Item>
+          </Descriptions>
+        </Card>
+
+        <Card title="登录状态信息" className="login-status-card">
+          <div className="login-status-display">
+            <Descriptions column={1} bordered>
+              <Descriptions.Item label="登录方式">
+                <Tag color={localStorage.getItem('authToken') ? 'green' : 'blue'}>
+                  {localStorage.getItem('authToken') ? '记住我登录 (持久化)' : '普通登录 (会话)'}
+                </Tag>
+              </Descriptions.Item>
+              <Descriptions.Item label="Token存储位置">
+                {localStorage.getItem('authToken') ? 'localStorage (浏览器关闭后仍保持登录)' : 'sessionStorage (浏览器关闭后需重新登录)'}
+              </Descriptions.Item>
+              <Descriptions.Item label="记住的登录信息">
+                {localStorage.getItem('rememberMe') === 'true' ? 
+                  `已保存邮箱: ${localStorage.getItem('rememberedEmail') || '无'}` : 
+                  '未保存登录信息'
+                }
+              </Descriptions.Item>
+            </Descriptions>
+          </div>
+        </Card>
+
+        <Card title="Token信息" className="token-info-card">
+          <div className="token-display">
+            <p><strong>认证Token:</strong></p>
+            <div className="token-text">
+              {token ? `${token.substring(0, 50)}...` : '未找到token'}
+            </div>
+            <p className="token-note">
+              * Token已被安全截断显示，完整token存储在浏览器存储中
+            </p>
+          </div>
+        </Card>
+
+        <Card title="API测试" className="api-test-card">
+          <Space direction="vertical" style={{ width: '100%' }}>
+            <p>您可以使用以下按钮测试不同的API接口：</p>
+            <Space wrap>
+              <Button onClick={handleRefreshProfile} loading={loading}>
+                测试 GET /profile
+              </Button>
+              <Button onClick={handleLogout}>
+                测试 POST /logout
+              </Button>
+              <Button 
+                onClick={handleTestJWT} 
+                loading={jwtTestLoading}
+                type="primary"
+              >
+                测试 POST /test-jwt
+              </Button>
+              <Button 
+                type="dashed"
+                onClick={() => window.open('http://10.126.59.25:8082/health', '_blank')}
+              >
+                测试 GET /health
+              </Button>
+            </Space>
+          </Space>
+        </Card>
+      </div>
+    </div>
+  );
+};
+
+export default TestDashboard;
diff --git a/rhj/frontend/src/reportWebVitals.js b/Merge/front/src/reportWebVitals.js
similarity index 100%
rename from rhj/frontend/src/reportWebVitals.js
rename to Merge/front/src/reportWebVitals.js
diff --git a/Merge/front/src/router/App.js b/Merge/front/src/router/App.js
index 1a7fe0e..e1b9454 100644
--- a/Merge/front/src/router/App.js
+++ b/Merge/front/src/router/App.js
@@ -15,6 +15,11 @@
 import UploadPage     from '../components/UploadPage'      // src/components/UploadPage.jsx
 
 
+import LoginPage from '../pages/LoginPage/LoginPage';
+import RegisterPage from '../pages/RegisterPage/RegisterPage';
+import ForgotPasswordPage from '../pages/ForgotPasswordPage/ForgotPasswordPage';
+import TestDashboard from '../pages/TestDashboard/TestDashboard';
+
 export default function AppRoutes() {
   return (
     <Routes>
@@ -31,7 +36,13 @@
       <Route path="/dashboard/*" element={<UploadPage />} />
 
       {/* 根路径重定向到 dashboard */}
-      <Route path="/" element={<Navigate to="/dashboard/overview" replace />} />
+      {/* <Route path="/" element={<Navigate to="/dashboard/overview" replace />} /> */}
+
+      <Route path="/" element={<LoginPage />} />
+      <Route path="/login" element={<LoginPage />} />
+      <Route path="/register" element={<RegisterPage />} />
+      <Route path="/forgot-password" element={<ForgotPasswordPage />} />
+      <Route path="/test-dashboard" element={<TestDashboard />} />
 
       {/* 最后一个兜底 */}
       <Route path="*" element={<PlaceholderPage pageId="home" />} />
diff --git a/Merge/front/src/utils/auth.js b/Merge/front/src/utils/auth.js
new file mode 100644
index 0000000..d04e102
--- /dev/null
+++ b/Merge/front/src/utils/auth.js
@@ -0,0 +1,155 @@
+// 认证相关的工具函数
+
+/**
+ * 获取当前用户的认证token
+ * @returns {string|null} 认证token，如果未登录则返回null
+ */
+export const getAuthToken = () => {
+  // 优先从localStorage获取（记住我的情况）
+  const localToken = localStorage.getItem('authToken');
+  if (localToken) {
+    return localToken;
+  }
+  
+  // 然后从sessionStorage获取（不记住我的情况）
+  const sessionToken = sessionStorage.getItem('authToken');
+  return sessionToken;
+};
+
+/**
+ * 获取当前用户信息
+ * @returns {object|null} 用户信息，如果未登录则返回null
+ */
+export const getUserInfo = () => {
+  // 优先从localStorage获取
+  const localUserInfo = localStorage.getItem('userInfo');
+  if (localUserInfo) {
+    try {
+      return JSON.parse(localUserInfo);
+    } catch (error) {
+      console.error('解析localStorage中的用户信息失败:', error);
+    }
+  }
+  
+  // 然后从sessionStorage获取
+  const sessionUserInfo = sessionStorage.getItem('userInfo');
+  if (sessionUserInfo) {
+    try {
+      return JSON.parse(sessionUserInfo);
+    } catch (error) {
+      console.error('解析sessionStorage中的用户信息失败:', error);
+    }
+  }
+  
+  return null;
+};
+
+/**
+ * 检查用户是否已登录
+ * @returns {boolean} 是否已登录
+ */
+export const isLoggedIn = () => {
+  const token = getAuthToken();
+  return !!token;
+};
+
+/**
+ * 获取记住的登录信息
+ * @returns {object} 包含email, password, rememberMe的对象
+ */
+export const getRememberedLoginInfo = () => {
+  const email = localStorage.getItem('rememberedEmail') || '';
+  const password = localStorage.getItem('rememberedPassword') || '';
+  const rememberMe = localStorage.getItem('rememberMe') === 'true';
+  
+  return {
+    email,
+    password,
+    rememberMe
+  };
+};
+
+/**
+ * 保存记住的登录信息
+ * @param {string} email 邮箱
+ * @param {string} password 密码
+ * @param {boolean} remember 是否记住
+ */
+export const saveRememberedLoginInfo = (email, password, remember) => {
+  if (remember) {
+    localStorage.setItem('rememberedEmail', email);
+    localStorage.setItem('rememberedPassword', password);
+    localStorage.setItem('rememberMe', 'true');
+  } else {
+    localStorage.removeItem('rememberedEmail');
+    localStorage.removeItem('rememberedPassword');
+    localStorage.removeItem('rememberMe');
+  }
+};
+
+/**
+ * 保存用户认证信息
+ * @param {string} token 认证token
+ * @param {object} userInfo 用户信息
+ * @param {boolean} remember 是否记住登录状态
+ */
+export const saveAuthInfo = (token, userInfo, remember = false) => {
+  if (remember) {
+    // 记住我：保存到localStorage
+    localStorage.setItem('authToken', token);
+    localStorage.setItem('userInfo', JSON.stringify(userInfo));
+    
+    // 清除sessionStorage
+    sessionStorage.removeItem('authToken');
+    sessionStorage.removeItem('userInfo');
+  } else {
+    // 不记住我：保存到sessionStorage
+    sessionStorage.setItem('authToken', token);
+    sessionStorage.setItem('userInfo', JSON.stringify(userInfo));
+    
+    // 清除localStorage中的认证信息（但保留记住的登录表单信息）
+    localStorage.removeItem('authToken');
+    localStorage.removeItem('userInfo');
+  }
+};
+
+/**
+ * 清除所有认证信息（退出登录）
+ * @param {boolean} clearRemembered 是否同时清除记住的登录信息
+ */
+export const clearAuthInfo = (clearRemembered = false) => {
+  // 清除认证token和用户信息
+  localStorage.removeItem('authToken');
+  localStorage.removeItem('userInfo');
+  sessionStorage.removeItem('authToken');
+  sessionStorage.removeItem('userInfo');
+  
+  // 如果需要，清除记住的登录信息
+  if (clearRemembered) {
+    localStorage.removeItem('rememberedEmail');
+    localStorage.removeItem('rememberedPassword');
+    localStorage.removeItem('rememberMe');
+  }
+};
+
+/**
+ * 创建带认证头的fetch请求配置
+ * @param {object} options 原始fetch配置
+ * @returns {object} 带认证头的fetch配置
+ */
+export const createAuthenticatedRequest = (options = {}) => {
+  const token = getAuthToken();
+  
+  if (!token) {
+    throw new Error('用户未登录');
+  }
+  
+  return {
+    ...options,
+    headers: {
+      ...options.headers,
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    }
+  };
+};
diff --git a/Merge/front/src/utils/crypto.js b/Merge/front/src/utils/crypto.js
new file mode 100644
index 0000000..eac10f0
--- /dev/null
+++ b/Merge/front/src/utils/crypto.js
@@ -0,0 +1,48 @@
+// 密码加密工具函数
+import CryptoJS from 'crypto-js';
+
+/**
+ * 使用 SHA256 加密密码
+ * @param {string} password 原始密码
+ * @returns {string} 加密后的密码
+ */
+export const hashPassword = (password) => {
+  if (!password || typeof password !== 'string') {
+    throw new Error('密码必须是非空字符串');
+  }
+  
+  return CryptoJS.SHA256(password).toString();
+};
+
+/**
+ * 验证密码是否已经被加密
+ * @param {string} password 密码字符串
+ * @returns {boolean} 是否为已加密的密码（64位十六进制字符串）
+ */
+export const isEncryptedPassword = (password) => {
+  if (!password || typeof password !== 'string') {
+    return false;
+  }
+  
+  // SHA256 加密后是64位十六进制字符串
+  return /^[a-f0-9]{64}$/i.test(password);
+};
+
+/**
+ * 安全的密码加密函数，避免重复加密
+ * @param {string} password 密码
+ * @returns {string} 加密后的密码
+ */
+export const safeHashPassword = (password) => {
+  if (!password) {
+    throw new Error('密码不能为空');
+  }
+  
+  // 如果已经是加密的密码，直接返回
+  if (isEncryptedPassword(password)) {
+    return password;
+  }
+  
+  // 否则进行加密
+  return hashPassword(password);
+};
