Aide-mémoire¶

Les équivalences entre ce que tu connais et Java / Spring Boot, à garder ouvert pendant que tu codes. Chaque ligne renvoie à une notion détaillée dans les chapitres.

Syntaxe¶

Concept	Rust	Python	Java
Variable	`let x = 5;`	`x = 5`	`var x = 5;` ou `int x = 5;`
Mutabilité	`let mut x`	toujours mutable	mutable par défaut, `final` pour figer la variable
Constante	`const MAX: u32 = 10;`	`MAX = 10` (convention)	`static final int MAX = 10;`
Afficher	`println!("{x}")`	`print(x)`	`System.out.println(x)`
Formater	`format!("{a}-{b}")`	`f"{a}-{b}"`	`"%s-%s".formatted(a, b)`
Fonction	`fn add(a: i32, b: i32) -> i32`	`def add(a, b):`	`static int add(int a, int b)`
Closure	`\|x\| x + 1`	`lambda x: x + 1`	`x -> x + 1`
Boucle sur un intervalle	`for i in 0..n`	`for i in range(n)`	`for (int i = 0; i < n; i++)`
Boucle sur une collection	`for x in &v`	`for x in v`	`for (var x : v)`
`match`	`match v { ... }`	`match v:`	`switch (v) { case ... -> ... }`
Test de type + liaison	`if let Some(x) = o`	`isinstance(o, Foo)`	`if (o instanceof Foo f)`
Chaîne multiligne	`r#"..."#`	`"""..."""`	`"""` + retour à la ligne (text block)

Détails : Syntaxe et types.

Types¶

Concept	Rust	Python	Java
Entiers, flottants	`i32`, `i64`, `f64`	`int`, `float`	`int`, `long`, `double` (primitifs)
Non signés	`u8`, `u32`, `u64`	—	n'existent pas (`byte` est signé)
Booléen, caractère	`bool`, `char` (32 bits)	`bool`, `str`	`boolean`, `char` (16 bits, UTF-16)
Chaîne	`String` / `&str`	`str`	`String` (immuable)
Absence de valeur	`Option<T>`	`None`	`Optional<T>`, ou `null`
Erreur récupérable	`Result<T, E>`	exception	exception
Struct de données	`struct` + `#[derive(...)]`	`@dataclass(frozen=True)`	`record`
Enum avec données	`enum`	—	`sealed interface` + `record`
Trait	`trait`	`Protocol` / ABC	`interface`
Implémenter	`impl Trait for X`	`class X(Base)`	`class X implements I`
Générique borné	`fn f<T: Ord>(t: T)`	`TypeVar(bound=...)`	`<T extends Comparable<T>> void f(T t)`
Objet dynamique	`Box<dyn Trait>`	tout objet	le type interface lui-même
Tuple	`(a, b)`	`(a, b)`	pas de tuple : un petit `record`

Détails : Classes et objets, Records, enums, sealed.

Collections¶

Rust	Python	Java (interface → implémentation)
`Vec<T>`	`list`	`List<T>` → `ArrayList<T>`
`HashMap<K, V>`	`dict`	`Map<K, V>` → `HashMap<K, V>`
`BTreeMap<K, V>`	—	`Map<K, V>` → `TreeMap<K, V>` (triée)
`HashSet<T>`	`set`	`Set<T>` → `HashSet<T>`
`VecDeque<T>`	`collections.deque`	`Deque<T>` → `ArrayDeque<T>`
`vec![1, 2]` (immuable si non `mut`)	`(1, 2)`	`List.of(1, 2)` (immuable)
`v.iter().filter(..).map(..).collect()`	compréhension	`v.stream().filter(..).map(..).toList()`

Détails : Génériques et collections, Lambdas et streams.

Mémoire, égalité, erreurs¶

Concept	Rust	Python	Java
Libérer une ressource	`Drop`	`with`	`try (var r = ...) { }` + `AutoCloseable`
Égalité de valeur	`PartialEq` (`==`)	`__eq__` (`==`)	`equals()` (pas `==`)
Identité	`std::ptr::eq`	`is`	`==` sur des objets
Hachage	`Hash`	`__hash__`	`hashCode()` (à redéfinir avec `equals`)
Affichage	`Debug` / `Display`	`__repr__` / `__str__`	`toString()`
Ordre	`Ord`	`__lt__`	`Comparable<T>` ou `Comparator<T>`
Copie	`.clone()`	`copy.copy()`	constructeur de copie, ou objets immuables
Lever une erreur	`return Err(e)` / `panic!`	`raise`	`throw new ...Exception(...)`
Propager	`?`	automatique	automatique (`throws` pour les checked)
Déballer ou planter	`.unwrap()`	—	`optional.orElseThrow()`
Partage entre threads	`Arc<Mutex<T>>`	`threading.Lock`	`synchronized`, `AtomicInteger`, `ConcurrentHashMap`

Détails : Mémoire et références, Exceptions et Optional, Threads et concurrence.

Outillage¶

Action	Rust	Python	Java (Maven)
Manifeste	`Cargo.toml`	`pyproject.toml`	`pom.xml`
Registre	crates.io	PyPI	Maven Central
Compiler	`cargo build`	—	`./mvnw compile`
Tester	`cargo test`	`pytest`	`./mvnw test`
Lancer	`cargo run`	`python main.py`	`./mvnw spring-boot:run` (Spring) ou `java Main.java`
Livrable	`cargo build --release`	wheel	`./mvnw package` → `target/*.jar`
Console interactive	—	`python`	`jshell`
Arbre des dépendances	`cargo tree`	`pipdeptree`	`./mvnw dependency:tree`

Détails : Installer et lancer, Maven.

Spring Boot vs Axum et FastAPI¶

Besoin	Axum (Rust)	FastAPI (Python)	Spring Boot
Déclarer une route	`.route("/x", get(h))`	`@app.get("/x")`	`@GetMapping("/x")` dans un `@RestController`
Paramètre de chemin	`Path(id): Path<i64>`	`def f(id: int)`	`@PathVariable Long id`
Paramètre de requête	`Query(p): Query<P>`	`q: str \| None = None`	`@RequestParam(required = false) String q`
Corps JSON	`Json(body): Json<T>`	modèle Pydantic	`@Valid @RequestBody T body`
État partagé, dépendances	`State<AppState>`	`Depends(...)`	injection par constructeur
Réponse personnalisée	`impl IntoResponse`	`Response`	`ResponseEntity<T>`
Accès base de données	sqlx	SQLAlchemy	Spring Data JPA
Migrations	`sqlx migrate`	Alembic	Flyway

Détails : Spring Boot, API REST.

Annotations Spring les plus courantes¶

Application et beans¶

Annotation	Sur	Rôle
`@SpringBootApplication`	classe principale	Configuration + auto-configuration + scan des composants
`@Component`, `@Service`, `@Repository`	classe	Bean détecté par le scan (le nom indique la couche)
`@Configuration` + `@Bean`	classe + méthode	Déclarer des beans à la main
`@Value("${cle}")`	paramètre, champ	Injecter une propriété
`@ConfigurationProperties("prefixe")`	classe, record	Lier un groupe de propriétés à un objet typé
`@Profile("prod")`	classe, méthode `@Bean`	Bean actif seulement avec ce profil
`@Transactional`	classe, méthode	Exécuter la méthode dans une transaction

Web¶

Annotation	Sur	Rôle
`@RestController`	classe	Contrôleur dont les retours sont sérialisés en JSON
`@RequestMapping("/api/x")`	classe	Préfixe d'URL commun
`@GetMapping`, `@PostMapping`, `@PatchMapping`, `@DeleteMapping`	méthode	Associer une méthode HTTP + un chemin
`@PathVariable`, `@RequestParam`, `@RequestBody`	paramètre	Lire le chemin, la query string, le corps
`@Valid`	paramètre	Déclencher la validation (`@NotBlank`, `@Size`...)
`@ResponseStatus`	méthode, exception	Code HTTP par défaut
`@RestControllerAdvice` + `@ExceptionHandler`	classe + méthode	Traduire les exceptions en réponses HTTP

Données et tests¶

Annotation	Sur	Rôle
`@Entity`, `@Table`	classe	Classe persistée dans une table
`@Id`, `@GeneratedValue`, `@Column`	champ	Clé primaire, génération, colonne
`@NotBlank`, `@Size`, `@Min`, `@Email`	champ, composant de record	Contraintes de validation
`@SpringBootTest`	classe de test	Démarre toute l'application
`@WebMvcTest`, `@DataJpaTest`	classe de test	Ne démarre qu'une tranche (web ou JPA)
`@MockitoBean`	champ de test	Remplace un bean par un mock Mockito

Commandes utiles¶

java Main.java                      # lancer un fichier source sans compiler à part
jshell                              # console interactive
./mvnw spring-boot:run              # lancer l'appli Spring en dev
./mvnw test                         # lancer les tests
./mvnw package                      # produire target/*.jar
java -jar target/app.jar            # lancer le jar
java -jar target/app.jar --server.port=9090 --spring.profiles.active=prod
./mvnw dependency:tree              # voir les dépendances transitives