Démystification de Spring une histoire de pattern

Démystification de Spring
Une Histoire de Pattern

Donnez-moi une définition simple ?
C’est un Framework C’est magique
C’est pour faire des application web
C’est pour faciliter le développement

Hervé
Letourneur
Développeur Java depuis 16 ans
Practice Leader

Un peu d’histoire !
Les premières lignes de code de Spring : fin 2002
Winter Spring
https://spring.io/blog/2006/11/09/spring-framework-the-origins-of-a-project-and-a-name
Rod Johnson publie un livre sur J2EE

Une définition simple :
Un conteneur IOC
Inversion de Contrôle

Code Applicatif
Librairie Librairie Librairie
Framework
Code
Applicatif
Code
Applicatif
Code
Applicatif

Principe d’Hollywood
« Ne nous appelez pas, c'est nous qui vous appellerons »

https://martinfowler.com/bliki/InversionOfControl.html

Comment Spring fait ?
Injection de dépendance
Inversion de Dépendance

Inversion des dépendances (Dependency inversion principle)
il faut dépendre des abstractions, pas des implémentations. Cela
favorise la modularité, la flexibilité et la réutilisabilité en réduisant
les dépendances directes entre les modules.
public class Controller {
private final Service service;
public Controller(DataSource
dataSource) {
this.service = new
Service(dataSource);
}
}
private final IService service;
public Controller(IService service) {
this.service = service;
}
}

Service
(code métier)
Controller
(Web)
Port
(Dao)
public Controller(IService service)
{
}
}
public class Service implements IService
{
private final IPort port;
public Service(IPort port) {
this.port = port;
}
}
public class Dao implements IPort {
private final DataSource dataSource;
public Dao(DataSource dataSource) {
this.dataSource = dataSource;
}
}

public class Application {
public static void main(String[] args) {
DataSource dataSource = new DataSource();
IPort port = new Dao(dataSource);
IService service = new Service(port);
Controller controller = new Controller(service);
}
}
public class Application {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
Controller controller = applicationContext.getBean(Controller.class);
}
}
On inverse le contrôle
L’injection de dépendance

Premier Design Pattern
ApplicationContext
FACTORY

Comment le contexte crée nos composants ?
Scan des
définitions
- Annotation
- Classe de configuration
- XMLConfiguration
Création des
Composants
Via la Réflexivité
Selon le mode d’injection
- Constructeur
- Setter
Référencement
des
dépendances
Dictionnaire (Map)
associant le composant
à son nom et type
ServiceLocator
- Fields

Démystification de Spring une histoire de pattern

Factory
Réflexivité ServiceLocator
Injection de dépendance

Et si on déléguait plus ?
Cycle de vie de nos composants
Scope
Singleton Prototype
ObjectFactory<T
>
Web

Factory
Injection de dépendance Cycle de vie
Singleton
Prototype
Scope

Framework
Code
Applicatif
Code
Applicatif
Code
Applicatif
AOP
Programmation Orienté Aspect

Exemple : Aspect Transactionnel
@Transactional
public String sayHello() {
return port.findHowToSayHello();
}
Proxy Decorator

Comment Spring crée ses proxys ?
CGLIB
(Class based)
JDK Dynamic Proxy
(Interface based)
Spring-AOP

Importance de l’inversion de dépendance
private final Service service;
public Controller(DataSource
dataSource) {
this.service = new
Service(dataSource);
}
}
public Controller(IService service) {
}
}

@Transactional
@Loggable
@Cacheable
public String sayHello() {
return port.findHowToSayHello();
}
Service
Proxy
Loggable
Cacheable
Transactionnal
Chaine de
Responsabilité

Service
(code métier)
Service
(code métier)
Controller
(Web)
Port
(Dao)
Framework
Code
Applicatif
Code
Applicatif
Code
Applicatif

Factory
Singleton
Prototype
Scope
AOP
Proxy
Décorator
Chaine de
Responsabilité

DispatcherServlet
DispatcherServlet
Web.xml
ContextLoaderListener
Service
(code
métier)
Controller
(Web)
Port
(Dao)
Service
(code
métier)
Controller
(Web)
Port
(Dao)
Service
(code
métier)
Controller
(Web)
Port
(Dao)

JDBC
try (Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bdd", "USER", "1234");
PreparedStatement pstmt = conn.prepareStatement("SELECT id, email from user where name = ?"))
{
pstmt.setString(1, name);
try (ResultSet rs = pstmt.executeQuery()) {
List<User> users = new ArrayList<>();
while (rs.next()) {
int id = rs.getInt("id");
String email = rs.getString("email");
users.add(new User(id, name, email));
}
return users;
}
}
}
Requête
Paramètre
Connection
Mapper
ResultSet
PrepareStatement
Exécution requête
Itération sur le RS
Mapping entité
Fermeture ressource

JdbcTemplate
Template de Méthode
@Override
public <T> List<T> query(String sql, RowMapper<T> rowMapper, @Nullable Object... args) throws
DataAccessException {
return result(query(sql, args, new RowMapperResultSetExtractor<>(rowMapper)));
}

Factory
Singleton
Prototype
Scope
AOP
Proxy
Décorator
Chaine de
Responsabilité
Web
DispatcherServlet
BDD
Template de Méthode

L’été de Spring
Conteneur perçu comme léger et simple
Standard dans les projets Java

Spring-Security
CorsFilter ExceptionFilter JwtFilter
Authentication
Filter
Security Chain

Spring-data-Jpa
public interface UserRepository extends JpaRepository<User, String> {
List<User> findByName(String name);
}
Convention over Configuration
public List<User> findUserByName(String name) {
return entityManager.createQuery("SELECT u FROM User u WHERE u.name = :name",
User.class)
.setParameter("name", name)
.getResultList();
}

Winter is coming
Web.xml
Dispatcher
ContextLoader
Configurer
La
datasource
Configurer la
plateforme
de
transaction
Activer
l’AOP
Définir les
templatesConfigurer le
routing dans la
DispatcherServlet
Et plein d’autres
définitions dépendantes
des modules utilisés
Spring security Spring web
Spring core
Y.Y.Y-2 Y.X.Z-3

2014 : Spring-Boot
Auto-Configuration
DispatcherServlet
Web.xml
ContextLoaderListener
Service
(code
métier)
Controller
(Web)
Port
(Dao)
Service
(code
métier)
Controller
(Web)
Port
(Dao)
Service
(code
métier)
Controller
(Web)
Port
(Dao)
Activation des proxys pour
les transactions
Création des datasources
Et des Templates
Configuration de
la dispatcher
Déclaration de la
DispatcherServlet
Démarrage d’un conteneur Web
et du contexte Spring associé
Auto-Configuration

Creation du concept de Starter
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.3</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
</dependencies>
Gestion des dépendances
Auto-Configuration
Basé sur les @Conditional

L’été de Spring-Boot
Perçu comme plus simple à utiliser
Standard dans les projets Java
Rapidité de démarrage d’un projet
Architectures MicroServices

Winter is coming back again ?
Démarrage de l’ordre de la seconde
Empreinte mémoire importante

Quel sera le prochain renouveau ?
Spring Boot avec GraalVM
Quarkus
Frameworkless

Démystification de Spring une histoire de pattern

Contenu connexe

Similaire à Démystification de Spring une histoire de pattern (20)

Démystification de Spring une histoire de pattern

Notes de l'éditeur