<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
	<channel>
		<title>Java on MyBearIsYellow</title>
		<link>https://www.mybearisyellow.me/tags/java/</link>
		<description>Recent content in Java on MyBearIsYellow</description>
		<generator>Hugo</generator>
		<language>fr-FR</language>
		
			<managingEditor>rajekevin@hotmail.fr (MyBearIsYellow)</managingEditor>
		
		
			<webMaster>rajekevin@hotmail.fr (MyBearIsYellow)</webMaster>
		
		
			<copyright>© 2026 MyBearIsYellow</copyright>
		
		
			<lastBuildDate>Fri, 10 Jul 2026 00:00:00 +0000</lastBuildDate>
		
			<atom:link href="https://www.mybearisyellow.me/tags/java/index.xml" rel="self" type="application/rss+xml" />
			<item>
				<title>Architecture hexagonale</title>
				<link>https://www.mybearisyellow.me/architecture-logicielle/architecture-hexagonale/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/architecture-logicielle/architecture-hexagonale/</guid>
				<description>L&amp;rsquo;architecture hexagonale (Ports &amp;amp; Adapters) place le métier au centre et le connecte au monde extérieur via des ports — des interfaces définies par le métier — implémentés par des adaptateurs interchangeables. La base de données, l&amp;rsquo;API REST ou la CLI ne sont que des détails branchés sur ces ports.</description>
			</item>
			<item>
				<title>Clean Architecture expliquée simplement</title>
				<link>https://www.mybearisyellow.me/architecture-logicielle/clean-architecture-expliquee-simplement/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/architecture-logicielle/clean-architecture-expliquee-simplement/</guid>
				<description>La Clean Architecture organise le code en cercles concentriques : le métier au centre, les détails techniques (base de données, framework, UI) à l&amp;rsquo;extérieur. La règle est simple — les dépendances ne pointent jamais vers l&amp;rsquo;extérieur.</description>
			</item>
			<item>
				<title>Couplage fort vs faible</title>
				<link>https://www.mybearisyellow.me/architecture-logicielle/couplage-fort-vs-faible/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/architecture-logicielle/couplage-fort-vs-faible/</guid>
				<description>Le couplage mesure à quel point un composant dépend d&amp;rsquo;un autre. Un couplage fort rend le système fragile et difficile à faire évoluer ; un couplage faible, obtenu via des interfaces et l&amp;rsquo;injection de dépendance, permet de changer une implémentation sans toucher au code qui l&amp;rsquo;utilise.</description>
			</item>
			<item>
				<title>Domain Driven Design (DDD)</title>
				<link>https://www.mybearisyellow.me/architecture-logicielle/domain-driven-design-ddd/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/architecture-logicielle/domain-driven-design-ddd/</guid>
				<description>Le Domain Driven Design (DDD) est autant une démarche de modélisation métier qu&amp;rsquo;une technique de code. Il propose un vocabulaire partagé avec les experts métier, des frontières explicites entre sous-domaines (bounded context), et des règles précises pour modéliser entités, value objects et agrégats.</description>
			</item>
			<item>
				<title>Le Pattern Abstract Factory expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/abstract-factory/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/abstract-factory/</guid>
				<description>L&amp;rsquo;Abstract Factory va plus loin que la Factory simple : elle garantit qu&amp;rsquo;un ensemble d&amp;rsquo;objets liés entre eux (une famille) reste toujours cohérent, en regroupant plusieurs méthodes de création derrière une seule interface.</description>
			</item>
			<item>
				<title>Le Pattern Adapter expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/adapter/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/adapter/</guid>
				<description>Le Adapter Pattern permet à deux interfaces incompatibles de fonctionner ensemble, sans modifier ni l&amp;rsquo;une ni l&amp;rsquo;autre. Il s&amp;rsquo;intercale entre le code appelant et une librairie tierce pour traduire les appels d&amp;rsquo;un contrat vers un autre.</description>
			</item>
			<item>
				<title>Le Pattern Builder expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/builder/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/builder/</guid>
				<description>Le Builder Pattern sépare la construction d&amp;rsquo;un objet complexe en une série d&amp;rsquo;étapes chaînées, chacune configurant une partie de l&amp;rsquo;objet. Il évite les constructeurs à rallonge et rend le code de construction lisible, même avec de nombreux paramètres optionnels.</description>
			</item>
			<item>
				<title>Le Pattern Decorator expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/decorator/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/decorator/</guid>
				<description>Le Decorator Pattern permet d&amp;rsquo;ajouter dynamiquement des responsabilités à un objet, en l&amp;rsquo;enveloppant dans une ou plusieurs couches qui respectent la même interface. Une alternative à l&amp;rsquo;héritage quand les combinaisons de comportements se multiplient.</description>
			</item>
			<item>
				<title>Le Pattern Dependency Injection expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/dependency-injection/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/dependency-injection/</guid>
				<description>L&amp;rsquo;injection de dépendances (Dependency Injection) consiste à fournir à un objet ce dont il a besoin depuis l&amp;rsquo;extérieur, plutôt que de le laisser construire lui-même ses dépendances. Un principe simple qui rend le code testable et remplaçable.</description>
			</item>
			<item>
				<title>Le Pattern Factory expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/factory/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/factory/</guid>
				<description>Le Factory Pattern encapsule la logique de création d&amp;rsquo;un objet dans une méthode ou une classe dédiée, plutôt que de disperser des &lt;code&gt;new&lt;/code&gt; conditionnels dans tout le code. Le client dépend d&amp;rsquo;une interface, jamais des classes concrètes créées derrière.</description>
			</item>
			<item>
				<title>Le Pattern Observer expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/observer/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/observer/</guid>
				<description>L&amp;rsquo;Observer Pattern définit une relation un-à-plusieurs : quand un objet change d&amp;rsquo;état, tous ses abonnés sont notifiés automatiquement, sans que l&amp;rsquo;émetteur ait besoin de connaître leur nature exacte. C&amp;rsquo;est le pattern derrière les event listeners et les systèmes pub/sub.</description>
			</item>
			<item>
				<title>Le Pattern Repository expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/repository/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/repository/</guid>
				<description>Le Repository Pattern cache les détails de stockage (SQL, ORM, API externe) derrière une interface orientée métier. Le domaine manipule des objets, pas des requêtes — l&amp;rsquo;implémentation concrète du stockage reste un détail interchangeable.</description>
			</item>
			<item>
				<title>Le Pattern Singleton expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/singleton/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/singleton/</guid>
				<description>Le Singleton garantit qu&amp;rsquo;une classe n&amp;rsquo;a qu&amp;rsquo;une seule instance, accessible depuis n&amp;rsquo;importe où dans l&amp;rsquo;application. Pratique en apparence, mais c&amp;rsquo;est aussi l&amp;rsquo;un des patterns les plus critiqués : il introduit un état global qui rend le code difficile à tester et à faire évoluer.</description>
			</item>
			<item>
				<title>Le Pattern Strategy expliqué simplement</title>
				<link>https://www.mybearisyellow.me/design-patterns/strategy/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/design-patterns/strategy/</guid>
				<description>Le Strategy Pattern permet de faire varier un comportement indépendamment du code qui l&amp;rsquo;utilise. Au lieu d&amp;rsquo;empiler des &lt;code&gt;if/else&lt;/code&gt;, on encapsule chaque variante dans sa propre classe, interchangeable à tout moment.</description>
			</item>
			<item>
				<title>Séparation des responsabilités</title>
				<link>https://www.mybearisyellow.me/architecture-logicielle/separation-des-responsabilites/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/architecture-logicielle/separation-des-responsabilites/</guid>
				<description>Séparer les responsabilités, ce n&amp;rsquo;est pas seulement écrire des petites classes : c&amp;rsquo;est isoler chaque raison de changer dans sa propre unité, que ce soit une classe, un module ou une couche entière du système. Bien fait, un changement métier ne touche qu&amp;rsquo;un seul endroit du code.</description>
			</item>
			<item>
				<title>SOLID expliqué simplement</title>
				<link>https://www.mybearisyellow.me/architecture-logicielle/solid-explique-simplement/</link>
				<pubDate>Fri, 10 Jul 2026 00:00:00 +0000</pubDate><author>rajekevin@hotmail.fr (MyBearIsYellow)</author>
				<guid>https://www.mybearisyellow.me/architecture-logicielle/solid-explique-simplement/</guid>
				<description>SOLID est un acronyme regroupant cinq principes de conception orientée objet formulés par Robert C. Martin : Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation et Dependency Inversion. Ensemble, ils visent un seul objectif : pouvoir faire évoluer le code sans le casser.</description>
			</item>
	</channel>
</rss>
