Spring :
Spring :framework open source pour développer des applications d’entreprise , on peut le
combiner avec un conteneur web (tomcat) pour avoir un serveur d’application.
Spring boot : c' est un module spring , une super couche de spring pour créer des
applications spring avec zéro configuration.
Avantages spring boot :
- Auto configuration
- Serveur web intégré (Tomcat)
- Gestion de dépendances ( starters )
-
contient ensemble de modules :
l’ensemble des modules(Spring Data , spring MVC , spring security)
DAO: Spring DATA
Spring DATA: pour la communication avec les DBR et NonR. ( l'ensemble des
génériques )
- Interface générique JpaRepository<Entité,Type de Id>:contient les méthodes de
CRUD pour agir sur une BDR(ORM) .
- interface générique MongoRepository<Entité,Type de Id>: pour les BDNR (pour
ODM)
WEB: Spring MVC
HandlerMapping is an interface that defines a mapping between requests and handler
objects.
⇒ @Configuration : marque la classe comme source de définitions de bean pour le contexte
de l'application .
⇒ @Bean annotation which is applied on a method to specify that it returns a bean to be
managed by Spring context(spring IOC).
Spring IOC container est le core de Spring Framework , il permet de :
-Creer et gerer les beans (IOC)
-injecter les dépendances (injection des dependance)
This is the XML equivalent of the above Java based config:
DispatcherServlet : Une Servlet qui joue le rôle de front contrôleur (le point
d'entrée), pour traiter les requêtes de clients.
deux types de contrôler:
- classe noté par @Controller ( le type de retour est une vue HTML ou jsp )
- classe noté par @RestController=@controller+@responsebody (return
JSON/XML …)
les rôles d’un controller:
- 1- Récupérer les informations à partir de la requête
- 2-Appeler le service concerné
- 3- envoi le Model (data) + le vue
IOC = l’inversion de contrôle : Permettre au développeur de s'occuper uniquement
du code métier (exigences fonctionnelles )et c’est le framework qui s’occupe du
code technique (Gestion des transactions , sécurité ,communication avec BD) ⇒
Spring IOC.
Injection de dépendance est un mécanisme simple dans la programmation objet
(OOD)permettant de diminuer le couplage entre les objets(s'appuyer sur des abstractions, pas
sur des concrétions) ⇒ afin d’assurer le principe de ouvert à l'extension et fermer à
la modification.
les types de l’injection:
- sous forme d’attribut via @Autowired
- via le constructeur
- Via setters
@Qualifaier : le choix de l'implémentation (Si on a plus d’une implémentation on utilise cette
annotation pour préciser l’annotation désirée).
@SpringBootApplication : C'est une annotation de spring boot qui combine trois autres
annotations:
- @Configuration : pour marquer une classe comme une classe de configuration,
- @EnableAutoConfiguration: pour activer la configuration automatique de spring
boot.
- @ComponentScan: pour scanner les différentes classes constituant les Beans de
notre application.
The interface [Link] represents the
Spring IoC container and is responsible for instantiating, configuring, and assembling the
aforementioned beans.
Spring IOC container gets its instructions on what objects to instantiate, configure, and
assemble by reading configuration metadata.
The configuration metadata is represented :
-in XML,
-Java annotations
-Java code.
It allows you to express the objects that compose your application and the rich
interdependencies between such objects.
on récupère les infos de request via:
@PathVariable annotation is used to extract the value from the URI(url/variable)
@RequestParams extract values from the query string(url?variable=valeur)
@RequestBody annotated parameters get linked to the HTTP request body.
JDBC:java database connection est une application fournie par Java pour assurer
la communication avec les BDR.
JPA (java persistence application ) est une spécification de ORM (object
relational mapping)==>pour dépasser les limites de JDBC (exception non
gérée ,gestion explicit de la connexion ,le passage entre un objet java et
les données de DB se fait manuellement ⇒ le couplage fort avec la BD).
Java Bean : est une classe java sérialisable(sérialisation: mécanisme de
conversion d’un objet a un byte stream ⇒ que on peut envoyer dans le
réseau , enregistrer dans fichier et stocker dans DB) , constructeur sans
paramètre , attributs privées accessible via les getters et setters.
Les contraintes sur une entité JPA :
POJO: JPA entity est un POJO (plain old java object):
1-annotation @entite
2- constructeur sans paramètre
3-identifiant @ id
4-La classe ne doit pas être déclarée comme static.
Les avantage de Object Relational Mapping :
1-génération automatique de code
2-indépendances à la BD via l’utilisation de HQL
HQL (jpql):(Hibernate query language) est une extension de sql , est une
représentation orientée objet du langage de requête ie : au lieu d’utiliser le nom de la
table en utilise le nom de la classe ce que rend ce langage indépendant de la base
de données relationnelle utilisée.
Fetch type :
Lazy:indique que la relation doit être chargée à la demande.(getStuent)((id , name,
address)
Eager:indique que la relation doit être chargée immédiatement en même temps que
l'entité qui la porte. (id , name, address, students list).
Transaction :est l’ensemble des opérations(requêtes) qu’on doit traiter comme une
seule opération pour assurer la cohérence des données pour se faire on utilise Java
Transaction API (JTA) .
JPA vs JDO :
JPA : décrit ORM juste pour BDR
JDO(java data object): décrit ORM pour toutes les bases de données possibles.
Actuator :est une dépendance spring permettant de faire le monitoring de l’application en
production.
Singleton : permet d’assurer qu’il n’y aura toujours qu’une instance d’une
classe donnée qui sera instanciée. ⇒ pour éviter la consommation de mémoire
inutile.
Une API (application programming interface)est une ensemble de règles
(interface,annotation et classe)permettant à un service de communiquer avec un
autre service sans savoir comment il est implementer.
Web service :Composants web basés sur HTTP pour la communication et
l'échange de données entre applications ⇒ on deux spécification pour le mettre
en place :
JAX-WS ET JAX-RS
JAX-WS:est une spécification JEE pour créer des web services basée sur le protocole
SOAP et interagir avec XML .(son implémentation est Jersey).
WSDL est une description de web service écrite en XML , facilitant l’exploitation de
l’interface de web service (contient les méthodes , les paramètres d'entrée et de
sortie) .
UDDI(universal Description discovery and integration):est un annuaire
permettant à la fois la publication (registre contenant les wsdl des webs services) et
l’exploration (discover, ie:exploitation) de web service.
JAX-RS:est une spécification JEE permettant de créer des web service basé sur la norme
restful(base sur le protocole http) et interagir avec XML,JSON.
Rest et Restful :styles d’architecture permettant de créer des web services.
SoapUI:pour test les api rest et soap
XML vs Json :les deux sont des formats pour présenter les données mais le json
est plus recommandé car il est plus léger et facile.
AOP : La séparation des aspects métiers et des aspects techniques d'une
application est rendue possible grâce à la programmation Orienté Aspect.
Stateful et stateless : deux approches pour sécuriser une app web
❖ stateful: la session de l’utilisateur est géré par le serveur
❖ stateless: la session de l’utilisateur est géré par le client
—---------------------------------------------------------------------------------------------------
[Link]
Design patterns:
-Solutions typiques aux problèmes courants dans la conception de logiciels.
-Plan prédéfinis pour résoudre un problème donné.
Trois catégories:
1-Creational Design Patterns: Mécanisme de création des objets⇒ afin
d’augmenter la flexibilité et réutilisation du code
Singleton:assurer qu'une classe n'a qu'une seule instance.
2-Structural Design Patterns
3-Behavioral Design Patterns
SOLID: The First 5 Principles of Object Oriented Design(OOD):
La problématique:le couplage fort , des logiciels rigides ⇒ difficiles à corriger et à
maintenir.
Solution:La mise en place des 5 principes de OOD permet de répondre à cette
problématique ⇒ couplage faible ,facile à maintenir, tester, étendre ⇒ des
logiciels agiles , flexibles.
1-Single Responsibility Principle : une classe s’occupe d’une seule responsabilité . La
classe doit résoudre une seule problématique. ⇒ facilite le test et la maintenance.
2- Open-Closed Principle: Open for extension et ferme a la modification. ⇒ code
maintenable.
3-Inversion de dépendance:s'appuyer sur des abstractions, pas sur des concrétions. ⇒
couplage faible.
—-------------------------------------------------------------
MOre information:
Spring Boot DevTools pick up the changes and restart the application.
Spring par pratique :
Spring est un Framework base sur Ioc permettre au dev de se concentrer sur l’aspect métier et
le Framework qui va se concentrer sur la technique par exemple la gestion des transactions.
Ioc est rendu possible grâce a AOP est un paradigme. ==> en utilisant les tisseurs
d’aspect :AspectJ,Spring AOP ,JBOSS AOP …
AOP :Paradigme Oriente Aspect.
ð Application ouverte à l’extension et ferme à la modification.
Couplage fort vs couplage faible :
Pour instaurer le couplage faible en utilise les interfaces pour assurer le principe ouvert à
l’extension et ferme à la modification.
Dans il est conseille d’utiliser les interfaces au lien des classes directement.
Notre classe métier donc sera liée interface repository cela signifier que notre classe métier
peut travailler avec n’import classe qui implémenté cette interface due l’importance d’utiliser
les interfaces au lien des classes directement.
Injection des dépendances par instanciation statique :
Est le fait de créer des objets avec le mot clé newè couplage fort .
IDao dao = new ImpDao() ; cette action est injection dans la variable dao objet de la class
impldao.
Nullpointerexception : exception throwed si on applique une methode sur un object null è non
satisfaction des dépendances .
Pour avoir le couplage faible on doit appliquer instanciation dynamique sans utiliser
framework on peut créer un fichier de configuration
classNotFoundException : si la classe que on cherche a charger n existe pas
instanciorn dynamique
—-----------------------------------------------------------------------------------------------------------
startegie pattern