Se connecter à Flutter avec Spring Boot

• Project : Maven (recommandé)
• Language : Java
• Spring Boot : laisse la dernière version stable

• Group : com.example
• Artifact : myapi
• Packaging : Jar
• Java : 17 (ou 21 si tu as installé la version récente)

• Spring Web
• Spring Data JPA
• MySQL Driver
• (optionnel) Spring Security si tu veux gérer l’authentification

spring.datasource.url=jdbc:mysql://localhost:3306/flutter_app
spring.datasource.username=root
spring.datasource.password=

spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.show-sql=true

# CORS configuration
spring.web.cors.allowed-origins=http://localhost:3000,http://10.0.2.2
spring.web.cors.allowed-methods=GET,POST,PUT,DELETE,OPTIONS
spring.web.cors.allowed-headers=*
spring.web.cors.allow-credentials=true

@Entity
@Table(name = "utilisateurs")
public class Utilisateur {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true, nullable = false)
    private String email;
    
    @Column(nullable = false)
    private String password;
    
    @ElementCollection(fetch = FetchType.EAGER)
    private List roles = new ArrayList<>();
    
    // Constructeurs, getters et setters
    public Utilisateur() {}
    
    public Utilisateur(String email, String password, List roles) {
        this.email = email;
        this.password = password;
        this.roles = roles;
    }
    
    // Getters et setters pour tous les champs
}

@Repository
public interface UtilisateurRepository extends JpaRepository {
    Optional findByEmail(String email);
    Boolean existsByEmail(String email);
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .cors().and()
            .csrf().disable()
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated()
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            );
        
        return http.build();
    }
}

@RestController
@RequestMapping("/api/auth")
@CrossOrigin(origins = "*")
public class AuthController {
    
    @Autowired
    private UtilisateurRepository utilisateurRepository;
    
    @Autowired
    private PasswordEncoder passwordEncoder;
    
    @PostMapping("/login")
    public ResponseEntity login(@RequestBody LoginRequest loginRequest) {
        try {
            Optional utilisateurOpt = utilisateurRepository.findByEmail(loginRequest.getEmail());
            
            if (utilisateurOpt.isEmpty()) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
                    .body(new AuthResponse(false, "Identifiants invalides", null));
            }
            
            Utilisateur utilisateur = utilisateurOpt.get();
            
            if (!passwordEncoder.matches(loginRequest.getPassword(), utilisateur.getPassword())) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
                    .body(new AuthResponse(false, "Mot de passe incorrect", null));
            }
            
            // Créer une réponse avec les informations utilisateur
            UserResponse userResponse = new UserResponse(
                utilisateur.getId(),
                utilisateur.getEmail(),
                utilisateur.getRoles()
            );
            
            return ResponseEntity.ok(new AuthResponse(true, "Connexion réussie", userResponse));
            
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new AuthResponse(false, "Erreur serveur: " + e.getMessage(), null));
        }
    }
    
    // Classes internes pour les requêtes et réponses
    public static class LoginRequest {
        private String email;
        private String password;
        
        // Getters et setters
        public String getEmail() { return email; }
        public void setEmail(String email) { this.email = email; }
        public String getPassword() { return password; }
        public void setPassword(String password) { this.password = password; }
    }
    
    public static class AuthResponse {
        private boolean success;
        private String message;
        private UserResponse user;
        
        // Constructeurs, getters et setters
        public AuthResponse(boolean success, String message, UserResponse user) {
            this.success = success;
            this.message = message;
            this.user = user;
        }
        
        // Getters et setters
    }
    
    public static class UserResponse {
        private Long id;
        private String email;
        private List roles;
        
        // Constructeurs, getters et setters
        public UserResponse(Long id, String email, List roles) {
            this.id = id;
            this.email = email;
            this.roles = roles;
        }
        
        // Getters et setters
    }
}

@Component
public class DataLoader implements CommandLineRunner {
    
    @Autowired
    private UtilisateurRepository utilisateurRepository;
    
    @Autowired
    private PasswordEncoder passwordEncoder;
    
    @Override
    public void run(String... args) throws Exception {
        // Vérifier si l'utilisateur test existe déjà
        if (utilisateurRepository.findByEmail("nodejs@example.com").isEmpty()) {
            Utilisateur utilisateur = new Utilisateur();
            utilisateur.setEmail("nodejs@example.com");
            utilisateur.setPassword(passwordEncoder.encode("123456"));
            utilisateur.setRoles(Arrays.asList("ROLE_USER"));
            
            utilisateurRepository.save(utilisateur);
            System.out.println("Utilisateur test créé avec succès");
        }
    }
}

flutter create flutter_login_app

dependencies:
  flutter:
    sdk: flutter
  http: ^0.13.5

import 'dart:convert';
import 'package:http/http.dart' as http;

class AuthService {
  static const String baseUrl = "http://10.0.2.2:8080/api/auth";

  static Future> login(String email, String password) async {
    try {
      final response = await http.post(
        Uri.parse('$baseUrl/login'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode({
          'email': email,
          'password': password,
        }),
      );

      final responseData = jsonDecode(response.body);
      return responseData;
    } catch (e) {
      throw Exception('Erreur de connexion: $e');
    }
  }
}

import 'package:flutter/material.dart';
import 'login_page.dart';

void main() {
  runApp(const MainApp());
}

class MainApp extends StatelessWidget {
  const MainApp({super.key});

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      debugShowCheckedModeBanner: false,
      home: LoginPage(),
    );
  }
}