Les design patterns, ou « patrons de conception », sont des solutions réutilisables à des problèmes courants rencontrés lors de la conception de logiciels. Ils sont largement utilisés en programmation orientée objet pour améliorer la modularité, la flexibilité et la maintenabilité du code. En Rust, un langage de programmation moderne et performant, vous pouvez également appliquer des design patterns pour structurer votre code de manière efficace.
Voici quelques exemples de design patterns orientés objet et comment ils peuvent être implémentés en Rust :
- Patron de conception Singleton :
Le Singleton garantit qu’une classe n’a qu’une seule instance et fournit un moyen d’y accéder globalement. En Rust, cela peut être réalisé en utilisant un module pour encapsuler l’état partagé et en exposant une fonction pour obtenir une référence à cet état unique.
rust// Module singleton.rs
pub struct Singleton {
// Etat partagé
data: i32,
}
impl Singleton {
pub fn get_instance() -> &'static mut Singleton {
static mut INSTANCE: *mut Singleton = 0 as *mut Singleton;
unsafe {
if INSTANCE.is_null() {
INSTANCE = Box::into_raw(Box::new(Singleton { data: 0 }));
}
&mut *INSTANCE
}
}
pub fn set_data(&mut self, new_data: i32) {
self.data = new_data;
}
pub fn get_data(&self) -> i32 {
self.data
}
}
- Patron de conception Factory :
Le Factory permet de créer des objets sans spécifier explicitement la classe des objets à créer. En Rust, cela peut être réalisé en utilisant une méthode de création dans une structure ou un trait.
rust// Module factory.rs
pub trait Product {
fn operation(&self);
}
pub struct ConcreteProductA;
impl Product for ConcreteProductA {
fn operation(&self) {
println!("Concrete Product A operation");
}
}
pub struct ConcreteProductB;
impl Product for ConcreteProductB {
fn operation(&self) {
println!("Concrete Product B operation");
}
}
pub struct Factory;
impl Factory {
pub fn create_product(&self, product_type: &str) -> Box<dyn Product> {
match product_type {
"A" => Box::new(ConcreteProductA),
"B" => Box::new(ConcreteProductB),
_ => panic!("Unsupported product type"),
}
}
}
- Patron de conception Observer :
L’Observer permet à un objet (appelé le sujet) de notifier plusieurs autres objets (appelés les observateurs) lorsqu’un événement se produit. En Rust, cela peut être réalisé en utilisant des closures ou des traits.
rust// Module observer.rs
pub trait Observer {
fn update(&self, data: i32);
}
pub struct Subject {
observers: Vec<Box<dyn Observer>>,
data: i32,
}
impl Subject {
pub fn new() -> Self {
Subject {
observers: Vec::new(),
data: 0,
}
}
pub fn register(&mut self, observer: Box<dyn Observer>) {
self.observers.push(observer);
}
pub fn set_data(&mut self, new_data: i32) {
self.data = new_data;
self.notify_observers();
}
fn notify_observers(&self) {
for observer in &self.observers {
observer.update(self.data);
}
}
}
pub struct ConcreteObserver;
impl Observer for ConcreteObserver {
fn update(&self, data: i32) {
println!("Observer received update: {}", data);
}
}
Ces exemples montrent comment certains design patterns classiques peuvent être implémentés en Rust. Ils illustrent la flexibilité et la puissance de Rust pour exprimer des concepts de programmation orientée objet de manière efficace et sûre, grâce à son système de types avancé et à son modèle de propriété unique. En comprenant et en appliquant ces design patterns, les développeurs Rust peuvent créer des systèmes logiciels robustes et modulaires.
Plus de connaissances
Bien sûr, explorons davantage de design patterns et leur implémentation en Rust :
- Patron de conception Builder :
Le Builder est utilisé pour construire un objet complexe étape par étape. En Rust, cela peut être réalisé en utilisant une structure de données mutable et des méthodes pour ajouter progressivement des composants à cet objet.
rust// Module builder.rs
pub struct Product {
part_a: String,
part_b: String,
}
pub struct ProductBuilder {
product: Product,
}
impl ProductBuilder {
pub fn new() -> Self {
ProductBuilder {
product: Product {
part_a: String::new(),
part_b: String::new(),
},
}
}
pub fn with_part_a(mut self, part_a: &str) -> Self {
self.product.part_a = part_a.to_string();
self
}
pub fn with_part_b(mut self, part_b: &str) -> Self {
self.product.part_b = part_b.to_string();
self
}
pub fn build(self) -> Product {
self.product
}
}
- Patron de conception Adapter :
L’Adapter permet à des interfaces incompatibles de travailler ensemble. En Rust, cela peut être réalisé en créant un adaptateur qui implémente l’interface cible et utilise l’interface source pour effectuer les opérations nécessaires.
rust// Module adapter.rs
pub trait Target {
fn request(&self);
}
pub struct Adaptee;
impl Adaptee {
pub fn specific_request(&self) {
println!("Adaptee specific request");
}
}
pub struct Adapter {
adaptee: Adaptee,
}
impl Adapter {
pub fn new(adaptee: Adaptee) -> Self {
Adapter { adaptee }
}
}
impl Target for Adapter {
fn request(&self) {
self.adaptee.specific_request();
}
}
- Patron de conception Strategy :
Le Strategy permet de définir une famille d’algorithmes, encapsule chacun d’eux et les rend interchangeables. En Rust, cela peut être réalisé en utilisant des traits pour définir les différentes stratégies et en les implémentant séparément.
rust// Module strategy.rs
pub trait Strategy {
fn execute(&self);
}
pub struct ConcreteStrategyA;
impl Strategy for ConcreteStrategyA {
fn execute(&self) {
println!("Executing strategy A");
}
}
pub struct ConcreteStrategyB;
impl Strategy for ConcreteStrategyB {
fn execute(&self) {
println!("Executing strategy B");
}
}
pub struct Context {
strategy: Box<dyn Strategy>,
}
impl Context {
pub fn new(strategy: Box<dyn Strategy>) -> Self {
Context { strategy }
}
pub fn set_strategy(&mut self, strategy: Box<dyn Strategy>) {
self.strategy = strategy;
}
pub fn execute_strategy(&self) {
self.strategy.execute();
}
}
Ces exemples supplémentaires démontrent encore plus la polyvalence de Rust dans la mise en œuvre de différents design patterns. En utilisant ces patterns, les développeurs peuvent concevoir des systèmes logiciels qui sont à la fois flexibles et extensibles, facilitant ainsi la maintenance et l’évolution du code au fil du temps.