修改登出功能可用

lib/core/constants/api_constants.dart

   static const String login = '/api/v1/auth/login';
   static const String register = '/api/v1/auth/register';
   static const String logout = '/api/v1/auth/logout';
+  static const String refresh = '/api/v1/auth/refresh';
   static const String getCurrentUser = '/api/v1/auth/me';
   
   // 用户管理接口
   static String getLoginUrl() => '$baseUrl$login';
   static String getRegisterUrl() => '$baseUrl$register';
   static String getLogoutUrl() => '$baseUrl$logout';
+  static String getRefreshUrl() => '$baseUrl$refresh';
   static String getCurrentUserUrl() => '$baseUrl$getCurrentUser';
   static String getUserProfileUrl() => '$baseUrl$getUserProfile';
   static String getUpdateProfileUrl() => '$baseUrl$updateUserProfile';

lib/data/datasources/local/shared_prefs.dart

   SharedPrefs(this._prefs);
 
   // Token管理
-  Future<bool> setAuthToken(String token) async {
-    return await _prefs.setString(AppConstants.authTokenKey, token);
+  Future<bool> setAccessToken(String token) async {
+    return await _prefs.setString('access_token', token);
   }
 
-  String? getAuthToken() {
-    return _prefs.getString(AppConstants.authTokenKey);
+  Future<bool> setRefreshToken(String token) async {
+    return await _prefs.setString('refresh_token', token);
   }
 
-  Future<bool> removeAuthToken() async {
-    return await _prefs.remove(AppConstants.authTokenKey);
+  String? getAccessToken() {
+    return _prefs.getString('access_token');
+  }
+
+  String? getRefreshToken() {
+    return _prefs.getString('refresh_token');
+  }
+
+  Future<bool> removeTokens() async {
+    await _prefs.remove('access_token');
+    await _prefs.remove('refresh_token');
+    return true;
   }
 
   // 用户数据管理

lib/data/datasources/remote/api_client.dart

     }
   }
   
-  // 保存token
-  Future<void> saveToken(String token) async {
-    await _prefs.setString('access_token', token);
+  // 保存tokens
+  Future<void> saveTokens(String accessToken, String? refreshToken) async {
+    await _prefs.setString('access_token', accessToken);
+    if (refreshToken != null && refreshToken.isNotEmpty) {
+      await _prefs.setString('refresh_token', refreshToken);
+    }
   }
   
-  // 清除token
-  Future<void> clearToken() async {
+  // 清除所有token
+  Future<void> clearTokens() async {
     await _prefs.remove('access_token');
+    await _prefs.remove('refresh_token');
+  }
+
+  // 获取refresh_token
+  String? getRefreshToken() {
+    return _prefs.getString('refresh_token');
   }
   
   // 检查是否已登录

lib/data/repositories/auth_repository.dart

     required SharedPreferences prefs,
   }) : _apiClient = apiClient, _prefs = prefs;
   
-  // 登录（需要使用安全登录替代）
+  // 登录（需要使用安全登录替代）保存双token
   Future<ApiResponse<User>> login(LoginRequest request) async {
     try {
       final response = await _apiClient.post(
         ApiConstants.getLoginUrl(),
         request.toJson(),
-        withAuth: false,
+        withAuth: false,  // 登录不需要认证头
       );
       
       if (response.statusCode == 200) {
           json.decode(response.body)
         );
         
-        // 保存token
-        await _apiClient.saveToken(tokenResponse.accessToken);
+        // 保存access_token和refresh_token
+        await _apiClient.saveTokens(
+          tokenResponse.accessToken,
+          tokenResponse.refreshToken,
+        );
+        
+        // 保存用户数据
+        await _prefs.setString(
+          'user_data',
+          json.encode(tokenResponse.user.toJson()),
+        );
         
         return ApiResponse<User>(
           success: true,
     }
   }
   
-  // 注册（需要使用安全注册替代）
+  // 注册（需要使用安全注册替代）保存双token
   Future<ApiResponse<User>> register(RegisterRequest request) async {
     try {
       final response = await _apiClient.post(
           json.decode(response.body)
         );
         
-        // 保存token
-        await _apiClient.saveToken(tokenResponse.accessToken);
+        // 保存双token
+        await _apiClient.saveTokens(
+          tokenResponse.accessToken,
+          tokenResponse.refreshToken,
+        );
+        
+        // 保存用户数据
+        await _prefs.setString(
+          'user_data',
+          json.encode(tokenResponse.user.toJson()),
+        );
         
         return ApiResponse<User>(
           success: true,
         username: request.username,
         password: request.password,
       );
-
-      print(ApiConstants.getLoginUrl());
-      print(secureRequest.toJson());
       
       final response = await _apiClient.post(
         ApiConstants.getLoginUrl(),
         secureRequest.toJson(),
         withAuth: false,
       );
-      print(response.statusCode);
       
       // ... 处理响应
       if (response.statusCode == 200) {
           json.decode(response.body)
         );
         
-        // 保存token
-        await _apiClient.saveToken(tokenResponse.accessToken);
+        // 保存access_token和refresh_token
+        await _apiClient.saveTokens(
+          tokenResponse.accessToken,
+          tokenResponse.refreshToken,
+        );
+        
+        // 保存用户数据
+        await _prefs.setString(
+          'user_data',
+          json.encode(tokenResponse.user.toJson()),
+        );
         
         return ApiResponse<User>(
           success: true,
           json.decode(response.body)
         );
         
-        // 保存token
-        await _apiClient.saveToken(tokenResponse.accessToken);
+        // 保存双token
+        await _apiClient.saveTokens(
+          tokenResponse.accessToken,
+          tokenResponse.refreshToken,
+        );
+        
+        // 保存用户数据
+        await _prefs.setString(
+          'user_data',
+          json.encode(tokenResponse.user.toJson()),
+        );
         
         return ApiResponse<User>(
           success: true,
       
       if (response.statusCode == 200) {
         final userData = json.decode(response.body);
+        final user = User.fromJson(userData);
+        
+        // 更新本地用户数据
+        await _prefs.setString('user_data', json.encode(user.toJson()));
+        
         return ApiResponse<User>(
           success: true,
           message: '获取成功',
-          data: User.fromJson(userData),
+          data: user,
         );
+      } else if (response.statusCode == 401) {
+        // Token过期，尝试刷新
+        final refreshResult = await _refreshToken();
+        if (refreshResult) {
+          // 刷新成功，重新获取用户信息
+          return await getCurrentUser();
+        } else {
+          return ApiResponse<User>(
+            success: false,
+            message: '登录已过期，请重新登录',
+          );
+        }
       } else {
         return ApiResponse<User>(
           success: false,
       );
     }
   }
-  
-  // 登出
-  Future<bool> logout() async {
+
+  // 刷新Token
+  Future<bool> _refreshToken() async {
     try {
+      final refreshToken = _apiClient.getRefreshToken();
+      
+      if (refreshToken == null || refreshToken.isEmpty) {
+        return false;
+      }
+      
       final response = await _apiClient.post(
-        ApiConstants.getLogoutUrl(),
-        {},
-        withAuth: true,
+        ApiConstants.getRefreshUrl(),  // 需要添加这个常量
+        {'refresh_token': refreshToken},
+        withAuth: false,
       );
       
       if (response.statusCode == 200) {
-        await _apiClient.clearToken();
+        final data = json.decode(response.body);
+        final newAccessToken = data['access_token'];
+        final newRefreshToken = data['refresh_token'];
+        
+        // 保存新的tokens
+        await _apiClient.saveTokens(newAccessToken, newRefreshToken);
         return true;
       }
+      
       return false;
     } catch (e) {
       return false;
     }
   }
   
+  // 登出
+  Future<ApiResponse<bool>> logout() async {
+    try {
+      // 获取refresh_token
+      final refreshToken = _apiClient.getRefreshToken();
+      
+      if (refreshToken == null || refreshToken.isEmpty) {
+        // 没有refresh_token，只清除本地数据
+        await _clearLocalData();
+        return ApiResponse<bool>(
+          success: true,
+          message: '已退出登录',
+          data: true,
+        );
+      }
+      
+      // 发送登出请求到服务器
+      final response = await _apiClient.post(
+        ApiConstants.getLogoutUrl(),
+        {'refresh_token': refreshToken},
+        withAuth: true,  // 需要access_token认证头
+      );
+      
+      // 无论服务器响应如何，都清除本地数据
+      await _clearLocalData();
+      
+      if (response.statusCode == 200) {
+        return ApiResponse<bool>(
+          success: true,
+          message: '已成功退出登录',
+          data: true,
+        );
+      } else {
+        // 服务器登出失败，但本地已清除
+        return ApiResponse<bool>(
+          success: true,
+          message: '已退出登录（服务器通信失败）',
+          data: true,
+        );
+      }
+    } catch (e) {
+      // 网络异常，仍然清除本地数据
+      await _clearLocalData();
+      return ApiResponse<bool>(
+        success: true,
+        message: '已退出登录（网络异常）',
+        data: true,
+      );
+    }
+  }
+
+  // 清除本地数据
+  Future<void> _clearLocalData() async {
+    await _apiClient.clearTokens();
+    await _prefs.remove('user_data');
+  }
+  
   // 检查登录状态
   Future<bool> isLoggedIn() async {
-    return _apiClient.isLoggedIn();
+    // 检查是否有access_token
+    if (!_apiClient.isLoggedIn()) {
+      return false;
+    }
+    
+    // 可以进一步验证token是否有效
+    try {
+      final response = await _apiClient.get(
+        ApiConstants.getCurrentUserUrl(),
+        withAuth: true,
+      );
+      return response.statusCode == 200;
+    } catch (e) {
+      return false;
+    }
   }
 }

lib/main.dart

 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
+import 'core/constants/route_constants.dart';
 import 'presentation/providers/auth_provider.dart';
 import 'presentation/providers/user_provider.dart';
 import 'presentation/navigation/app_router.dart';
 
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
-  await di.init();
+  await di.init();  // 初始化DI容器
   runApp(const MyApp());
 }
 
           ),
         ),
         debugShowCheckedModeBanner: false,
-        initialRoute: '/',
+        initialRoute: RouteConstants.splash,
         onGenerateRoute: AppRouter.onGenerateRoute,
       ),
     );

lib/presentation/navigation/app_router.dart

 import '../screens/profile/profile_detail_screen.dart';
 import '../screens/splash_screen.dart';
 import '../../core/constants/route_constants.dart';
+import 'route_guards.dart';
 
 class AppRouter {
   static Route<dynamic> onGenerateRoute(RouteSettings settings) {
     switch (settings.name) {
       case RouteConstants.splash:
         return MaterialPageRoute(builder: (_) => const SplashScreen());
+      
       case RouteConstants.home:
         return MaterialPageRoute(builder: (_) => const HomeScreen());
+      
       case RouteConstants.login:
         return MaterialPageRoute(builder: (_) => const LoginScreen());
+      
       case RouteConstants.register:
         return MaterialPageRoute(builder: (_) => const RegisterScreen());
+      
       case RouteConstants.news:
         return MaterialPageRoute(builder: (_) => const NewsScreen());
+      
       case RouteConstants.services:
         return MaterialPageRoute(builder: (_) => const ServicesScreen());
+      
       case RouteConstants.profile:
-        return MaterialPageRoute(builder: (_) => const ProfileScreen());
+        return MaterialPageRoute(
+          builder: (_) => ProtectedRoute(
+            routeName: RouteConstants.profile,
+            child: const ProfileScreen(),
+          ),
+        );
+      
       case RouteConstants.profileDetail:
-        return MaterialPageRoute(builder: (_) => const ProfileDetailScreen());
+        return MaterialPageRoute(
+          builder: (_) => ProtectedRoute(
+            routeName: RouteConstants.profileDetail,
+            child: const ProfileDetailScreen(),
+          ),
+        );
+      
       default:
         return MaterialPageRoute(
           builder: (_) => Scaffold(

lib/presentation/navigation/route_guards.dart

 
 class ProtectedRoute extends StatelessWidget {
   final Widget child;
+  final String? routeName;
   
-  const ProtectedRoute({Key? key, required this.child}) : super(key: key);
+  const ProtectedRoute({
+    super.key,
+    required this.child,
+    this.routeName,
+  });
   
   @override
   Widget build(BuildContext context) {
     } else {
       return LoginScreen(
         onSuccess: () {
-          Navigator.of(context).pushReplacement(
-            MaterialPageRoute(builder: (_) => child),
-          );
+          // 如果有routeName，可以使用pushReplacementNamed
+          if (routeName != null) {
+            Navigator.of(context).pushReplacementNamed(routeName!);
+          } else {
+            // 否则使用原来的方式
+            Navigator.of(context).pushReplacement(
+              MaterialPageRoute(builder: (_) => child),
+            );
+          }
         },
       );
     }

lib/presentation/providers/auth_provider.dart

   String? get error => _error;
   
   Future<void> _loadCurrentUser() async {
-    final user = await authRepository.getCurrentUser();
-    if (user != null) {
-      _user = user.data;
+    final response = await authRepository.getCurrentUser();
+    if (response.success && response.data != null) {
+      _user = response.data;
       notifyListeners();
     }
   }
   }
   
   Future<void> logout() async {
-    await authRepository.logout();
-    _user = null;
+    _isLoading = true;
+    _error = null;
     notifyListeners();
+    
+    try {
+      final response = await authRepository.logout();
+      
+      if (response.success) {
+        _user = null;
+        _error = null;
+      } else {
+        _error = response.message;
+      }
+    } catch (e) {
+      _error = '登出失败: $e';
+    } finally {
+      _isLoading = false;
+      notifyListeners();
+    }
   }
   
   Future<void> checkAuthStatus() async {

lib/presentation/screens/auth/login_screen.dart

 class LoginScreen extends StatefulWidget {
   final VoidCallback? onSuccess;
   
-  const LoginScreen({super.key, this.onSuccess});
+  const LoginScreen({
+    super.key,
+    this.onSuccess,
+  });
   
   @override
   State<LoginScreen> createState() => _LoginScreenState();
 
 class _LoginScreenState extends State<LoginScreen> {
   final _formKey = GlobalKey<FormState>();
-  final _emailController = TextEditingController(text: 'test@example.com');
-  final _passwordController = TextEditingController(text: '123456');
+  final _emailController = TextEditingController(text: 'aaa');
+  final _passwordController = TextEditingController(text: 'Heweidabangzi77!');
   
   @override
   void dispose() {
                           _passwordController.text,
                         );
                         if (authProvider.isAuthenticated) {
-                          widget.onSuccess?.call();
+                          // widget.onSuccess?.call();
                           Navigator.of(context).pushReplacementNamed(RouteConstants.home);
+                          // Navigator.of(context).pushNamedAndRemoveUntil(RouteConstants.home);
                         }
                       }
                     },

lib/presentation/screens/profile/profile_screen.dart

 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
+import '../../../core/constants/route_constants.dart';
 import '../../providers/auth_provider.dart';
 import '../../providers/user_provider.dart';
 import '../../navigation/bottom_nav_bar.dart';
 
   @override
   Widget build(BuildContext context) {
-    return ProtectedWidget(
-      child: _ProfileContent(),
-      loadingWidget: const Center(
-        child: CircularProgressIndicator(),
-      ),
-    );
+    // 直接显示内容，认证由路由层处理
+    return _ProfileContent();
   }
 }
 
                         title: '退出登录',
                         subtitle: '安全退出当前账号',
                         onTap: () async {
-                          await authProvider.logout();
-                          if (mounted) {
-                            Navigator.of(context).pushReplacementNamed('/');
+                          // 防止重复点击
+                          if (authProvider.isLoading) return;
+
+                          final shouldLogout = await showDialog<bool>(
+                            context: context,
+                            builder: (context) {
+                              final isIOS = Theme.of(context).platform == TargetPlatform.iOS;
+                              
+                              if (isIOS) {
+                                // iOS风格：确定在右边，取消在左边
+                                return AlertDialog(
+                                  title: const Text('确认退出'),
+                                  content: const Text('确定要退出登录吗？'),
+                                  actionsAlignment: MainAxisAlignment.spaceBetween,
+                                  actions: [
+                                    TextButton(
+                                      onPressed: () => Navigator.of(context).pop(true),
+                                      child: const Text('确定'),
+                                    ),
+                                    TextButton(
+                                      onPressed: () => Navigator.of(context).pop(false),
+                                      child: const Text('取消'),
+                                    ),
+                                  ],
+                                );
+                              } else {
+                                // Android/Material风格：取消在左边，确定在右边
+                                return AlertDialog(
+                                  title: const Text('确认退出'),
+                                  content: const Text('确定要退出登录吗？'),
+                                  actionsAlignment: MainAxisAlignment.spaceBetween,
+                                  actions: [
+                                    TextButton(
+                                      onPressed: () => Navigator.of(context).pop(false),
+                                      child: const Text('取消'),
+                                    ),
+                                    TextButton(
+                                      onPressed: () => Navigator.of(context).pop(true),
+                                      child: const Text('确定'),
+                                    ),
+                                  ],
+                                );
+                              }
+                            },
+                          );
+                          
+                          if (shouldLogout == true) {
+                            await authProvider.logout();
+
+                            // 登出后，确保在组件仍然存在时进行导航
+                            if (mounted) {
+                              // 使用pushReplacementNamed清空导航栈
+                              Navigator.of(context).pushReplacementNamed(RouteConstants.home);
+                            }
                           }
                         },
                       ),

lib/presentation/widgets/custom/protected_widget.dart

   Widget build(BuildContext context) {
     final authProvider = Provider.of<AuthProvider>(context);
     
+    // 如果正在加载，显示loading
     if (authProvider.isLoading) {
       return loadingWidget ?? const LoadingIndicator();
     }
     
+    // 如果未认证，显示登录页
     if (!authProvider.isAuthenticated) {
       return LoginScreen(
         onSuccess: () {
       );
     }
     
+    // 已认证，显示子组件
     return child;
   }
 }