Maven Spring Hibernate Prime Faces

Développement WEB en JEE avec les Frameworks:
MAVEN
Spring
Hibernate et Reverse Engineering
PrimeFaces implémentation des JSF (Java Server Faces )
sous
le serveur d’applications Apache Tomcat
Janvier 2020
Dr. J NDONG 1
Architecture Logicielle
Présentation:
Métier DAO
framework MVC 2 Contrôleur (aiguillage)
Gestion aux données
- modèles
(POJOs)
- PrimeFaces Servlet - JavaBeans
(JSF ) fournie (sessions)
par le framework: Hibernate
FacesServlet Spring IOC
Données
2
Création sous Eclipse un projet MAVEN
On utilise MAVEN pour gérer toutes les dépendances de notre application. Nous allons créer un
DWP (Dynamic Web Project) sous Eclipse JEE et Maven télécharge toutes les APIs dont on aura
besoin, notamment tous les frameworks mis en jeu.
Lancer donc Eclipse JEE et faites menu File  New Maven Projet:
3
4
Vous obtenez la fenêtre suivante. Cliquez sur le bouton Next
5
Vous obtenez la fenêtre suivante. Laisser Internet charger les catégories de projets
(Archetype) et localisez et sélectionnez maven-archetype-webapp, Cliquez sur Next.
6
Vous obtenez la fenêtre suivante. Donner le Group Id, Artifact Id et le Package.
Cliquez sur Finish.
com.essai
projetmaven
com.essai.projetmaven
7
Vous obtenez la fenêtre suivante. La structure du projet ressemble à ceci:
Artifact Id
Créer 2 répertoires
Java et resources
Dans le répertoire main.
8
Framework SPRING
Spring est un framework open source rendant simple l’utilisation de JEE. Spring est né du constat que
l’utilisation des EJBs (Enterprise JavaBean) est très complexe et n’est adaptée que pour des projets de
très grande envergure.
Il se base sur le concept de conteneur léger et s’appuie sur des concepts modernes :
- inversion de contrôle (IOC: Inversion Of Control).

- programmation orientée aspect (POA)
Il peut s’intégrer facilement avec d’autres frameworks tels que Struts, Hibernate, etc.
Spring propose donc une intégration des frameworks tiers9 les plus répandus.
A ce point Spring propose une architecture applicative générique capable de s’adapter aux
choix technologiques.
9
Conteneur léger
La notion de conteneur EJB est une technologie lourde à mettre en œuvre, inadaptée pour les objets
de faible granularité, intrusive dans le code et en partie dépendante du serveur d’applications, ne
serait-ce qu’en terme de configuration.
Un conteneur léger adopte une autre démarche: fournir une infrastructure de gestion de l’ensemble
des composants de l’application.
Ceci s’effectue:
- au travers de mécanismes de configuration comme les fichiers XML pour initialiser
les composants
- au travers de la gestion du cycle de vie des composants
- au travers de la gestion des dépendances entre les composants
Les conteneurs légers sont indépendants des technologies JEE et peuvent fonctionner sur
tout type de serveur d’application, voire sans eux en utilisant une simple JVM.
Ils rendent les applications qui les utilisent à la fois plus flexibles et mieux testables, car le
couplage entre les composants est géré par le conteneur et non plus directement dans le code source
de l’application. 10
Le support de la POA
La POA est un nouveau paradigme (ensemble de principes qui structurent la manière de

modéliser les applications et en conséquence la façon de les développer) qui étend et complète
les autres paradigmes de programmation structurale et POO.
Elle offre des mécanismes afin de mieux séparer les différentes préoccupations d’une application
en introduisant une nouvelle dimension de modularisation : l’aspect.
Elle se concentre sur les éléments transversaux, c’est-à-dire ceux qui se trouvent dupliqués ou
utilisés dans un grand nombre d’entités comme les classes ou les méthodes, sans pouvoir être
centralisés au sein d’une entité unique avec les concepts classiques.
Ainsi grâce à la notion d’aspects qui capturent en leur sein les préoccupations transversales,
la séparation des préoccupations est nettement améliorée.
11
Modèles de conception (design pattern)
Une modélisation appropriée des applications nécessite souvent de passer par des moyens
génériques (modèles) pour bien séparer les notions fonctionnelles manipulées par ces
applications, leur gestion et leur persistance.
Les fondements d’une bonne modélisation s’appuient sur deux piliers fondamentaux:
Séparation claire entre les notions fonctionnelles manipulées par l’application, leur gestion et
leur persistance. L’idée est d’améliorer la réutilisation et l’évolution de services autour des
notions fonctionnelles. Il s’agit d’une architecture en couches:
- une couche modèle contenant les notions fonctionnelles
- une couche service qui peut gérer les notions techniques
- une couche pour la persistance des données.
Séparation claire entre les interfaces et les implémentations pour rendre transparentes les
modifications des implémentations qui n’impactent pas les interfaces.
A partir de ces deux choix, nous pouvons choisir les modèles de conception suivants:
12
Modèles de conception (design pattern)
La fabrique (factory): ce modèle de conception permet d’associer une implémentation à une

interface. Si vous désirez rendre une application indépendante des
implémentations, il est nécessaire de faire appel à une classe spécifique
la fabrique qui saura instancier l’implémentation correspondant à une
interface donnée.
Le singleton: ce modèle de conception définit des classes n’ayant qu’une seule
instance pour l’ensemble de l’application.
L’objet d’accès aux données (DAO): ce modèle isole la problématique de l’accès aux données
dans des classes prévues exclusivement à cet effet. Cela permet d’éviter
la prolifération du code d’accès aux données au sein de l’application
en le concentrant dans quelques classes spécialisées, plus faciles à gérer.
13
Inversion de contrôle
IoC (Inversion of Control)
Il s’agit du contrôle du flot d’exécution d’une application. Ce concept propose une gestion
des dépendances entre objets et leur instanciation, notamment dans le cadre d’une dissociation
entre des interfaces et leur implémentation.
Dans les applications complexes, souvent beaucoup d’objets fabriques et singletons sont
nécessaires. Et l’application devrait être en mesure de maîtriser la création des objets dont
elle a besoin et la gestion de leurs dépendances, ce qui assez fastidieux.
Un framework de création doit pouvoir prendre en charge cette problématique de
manière générique. C’est en ce moment que l’inversion de contrôle entre ne jeu.
Le résultat attendu: disparution pure et simple des fabriques et de l’implémentation des
Singletons.
Grâce au conteneur les mécanismes (explicites) de fabrication des objets et des dépendances
devient générique.
Pour réaliser l’inversion de contrôle, Spring utilise le concept d’injection de dépendances
pour rendre cette dernière transparente.
L’injection peut se faire:
- par le contructeur,
- par les modifieurs ou mutateurs (setter) 14
- par des interfaces.
Injection par modifieurs (setter injection): la propriété (champ) à modifier doit appartenir à un
JavaBean
public class namebean <bean id="bean1" class="namebean">

{
String name; <property name="name" >
<value>ndong</value>
public void setName (String a) </property>
{
name = a; </bean>
}
public String getName ( )
{
return name;
}
}
15
Injection par constructeur :
public class namebean

{
String name;
public namebean (String a)
{ <bean id="bean1" class="namebean">
name = a; <constructor-arg>
} <value> ndong </value>
} </constructor-arg>
</bean>
16
Comment intégrer les APIs des Framework dans votre application (fichier POM) ?
Il suffit de chercher les dépendances qui sont fournies dans le MVNRepository

à l’adresse https://mvnrepository.com/
17
Par exemple, pour chercher Spring Core.
Spring Core
18
19
Copier cette dépendance dans votre pom.xml. 20
Utilisation du POM Maven pour intégrer Spring IOC pour la gestion des objets ?
(…)
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>

<dependency>
<artifactId>spring-core</artifactId>
</dependency>
(…)
21

<dependency>
<artifactId>spring-expression</artifactId>
</dependency>


<dependency>
<artifactId>spring-beans</artifactId>
</dependency>
22

<dependency>
<artifactId>spring-aop</artifactId>
</dependency>

<dependency>
<artifactId>spring</artifactId>
<type>pom</type>
</dependency>
23
Gestion de pools d’objets par Spring (1/2)
Dans une application d’entreprise, il faut éviter d’instancier les classes

à chaque fois que le besoin se pose. Chaque classe métier doit être
instanciée une seule fois. Spring permet de mettre en œuvre le design
pattern Singleton pour assurer que chaque modèle de votre tiers
métier soit instancié une et une seule fois.
Spring déclare les objets métier de l’application dans un fichier XML.
Dans une vraie application d’entreprise, il faut, avant d’utiliser Spring IOC,
générer tous vos modèles par un outil de Reverse Engineering.
24
Gestion de pools d’objets par Spring (2/2)
Le contenu de ce fichier doit ressembler à ceci:
Ici je déclare un bean d’une référence de type Personne.
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<bean id="pers" class="models.Personne"/>

</beans>
SpringBeans.xml 25
Emplacement du fichier dans le projet MAVEN
Le fichier de configuration de Spring doit se trouver dans le répertoire resources.
26
Comment utiliser les beans de Spring dans l’application ?
package beans;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import modelsandDAO.Personne;
import modelsandDAO.PersonneHome;
public class Essai {

private static Personne p;
public static void main(String[] args) {
p =(Personne)getContext ( ). getBean("pers");
p.setNom("Test Spring Bean by IOC");
System.out.println (p.getNom());
}
public static ApplicationContext getContext() {
ApplicationContext context= new ClassPathXmlApplicationContext ("SpringBeans.xml");
return context;
}
} 27
Framework Hibernate
Pour utiliser un framework ORM tel que Hibernate pour gérer les transations vers la base de
données, on insère les dépendances suivantes dans le POM.xml.


<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.10.Final</version>
</dependency>

<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>
28

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
</dependency>

<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId> Il faut insérer le driver du SGBDR
<version>42.2.9</version>
</dependency>
29
Emplacement des fichiers Hibernate lors du Reverse Engineering
Si vous réaliser le reverse engineering par Hibernate, le fichier hibernate.cfg.xml

doit se trouver dans votre CLASSPATH
Vous pouvez créer un paquetage dans

lequel vous mettez les classes Hibernate
de construction de la SessionFactory. Ici
je propose le package
hibernate,sessionfactory.open où je crée
les deux classes HibernateUtil et
SessionFactoryProvider.
30
package hibernate.sessionfactory.open;
import org.hibernate.HibernateException; import org.hibernate.SessionFactory;
import org.hibernate.boot.Metadata; import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration; import org.hibernate.service.ServiceRegistry;
public class HibernateUtil {
private static final SessionFactory sessionFactory = buildSessionFactory();
private static SessionFactory buildSessionFactory() {
try {
StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder()
.configure("hibernate.cfg.xml").build();
Metadata metadata = new MetadataSources(standardRegistry).getMetadataBuilder().build();
return metadata.getSessionFactoryBuilder().build();
} catch (HibernateException he) {

System.out.println("Session Factory creation failure");
throw he;
}
}
public static SessionFactory getSessionFactory() { return sessionFactory;}
} 31
package hibernate.sessionfactory.open;
Remarque très importante:

import org.hibernate.SessionFactory; Cette classe est fondamentale, elle assure que
l’initialisation de la SessionFactory se fera
une et seule fois dans le bloc static.
public final class SessionFactoryProvider {
private static final SessionFactory sessionFactory;
static {
sessionFactory =HibernateUtil.getSessionFactory();
}
public static SessionFactory getSessionFactory() {

return sessionFactory;
}
private SessionFactoryProvider() {
}
}
32
Framework MVC 2 Primefaces
Voici les dépendances à inclure dans le POM
On donne l’URL de téléchargement des dépendances de Primefaces:
<repositories>
<repository>
<id>prime-repo</id>
<name>Prime Repo</name>
<url>http://repository.primefaces.org</url>
</repository>
<repositories>
33
On donne la dépendance de Primefaces pour spécifier la version:


<dependency>
<groupId>org.primefaces</groupId>
<artifactId>primefaces</artifactId>
<version>7.0</version>
</dependency>
34
Primefaces s’appuie sur les Java Server Faces 2.x, donc il faut inclure les dépendances de JSF


<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-api</artifactId>
</dependency>

<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-impl</artifactId>
</dependency> 35
Primefaces s’appuie aussi sur les Java Standard Tag Library (JSTL) et l’API Servlet:


<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
</dependency>

<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
36
</dependency>
Fichier de configuration de Primefaces: faces-config.xml
Le fichier faces-config.xml de configuration doit se trouver dans WEB-INF
37
Autres fichiers ressources
Si vous avez des fichiers particuliers comme des logos et images, vous pouvez les placer dans des sous-répertoire de webapp.
Vos pages web doivent être également sous le répertoire webapp.
38
Utilisation MANUELLE des THEMES sous
Primefaces
Primefaces utilise un ensemble important de THEMES que vous pouvez utilisez dans votre application,
Créer un sous répertoire nommé lib dans WEB-INF et copiez-y les JARs nécessaires pour les thèmes souhaités:
NB: vous pouvez manuellement télécharger ces Ici il y a 3 thèmes

jars depuis le site de Primefaces Repository:
https://repository.primefaces.org/org/primefaces/themes/
39
Configurations nécessaires (1/2)
Si vous utilisez un framework MVC 2, il est nécessaire de configuration la servlet fournie
dans votre descripteur de déploiement web.xml.
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<welcome-file-list>
<welcome-file>./vues/login.jsf</welcome-file> Page d’acceuil de l’application
</welcome-file-list>
<context-param>
<param-name> primefaces.THEME</param-name> Configuration du thème blitzer
<param-value>blitzer</param-value>
</context-param>
(…)
40
Configurations nécessaires (2/2)
Si vous utilisez un framework MVC 2, il est nécessaire de configuration la servlet fournie
dans votre descripteur de déploiement web.xml.
(…)
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<url-pattern>*.jsf</url-pattern>
</servlet-mapping>
<servlet-mapping>
<url-pattern>/faces/*</url-pattern>
</servlet-mapping>
41
</web-app>
Si tout est fait correctement, vous lancez l’application et vous obtenez cette magnifique page web
http://localhost:8088/primefacesmaven/
42

Maven Spring Hibernate Prime Faces

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Maven Spring Hibernate Prime Faces

Transféré par

Droits d'auteur :

Formats disponibles

Développement WEB en JEE avec les Frameworks:

- inversion de contrôle (IOC: Inversion Of Control).

La POA est un nouveau paradigme (ensemble de principes qui structurent la manière de

La fabrique (factory): ce modèle de conception permet d’associer une implémentation à une

public class namebean <bean id="bean1" class="namebean">

public class namebean

Il suffit de chercher les dépendances qui sont fournies dans le MVNRepository

Dans une application d’entreprise, il faut éviter d’instancier les classes

Spring déclare les objets métier de l’application dans un fichier XML.

<bean id="pers" class="models.Personne"/>

Le fichier de configuration de Spring doit se trouver dans le répertoire resources.

public class Essai {

Si vous réaliser le reverse engineering par Hibernate, le fichier hibernate.cfg.xml

Vous pouvez créer un paquetage dans

} catch (HibernateException he) {

Remarque très importante:

public static SessionFactory getSessionFactory() {

Voici les dépendances à inclure dans le POM

On donne l’URL de téléchargement des dépendances de Primefaces:

Le fichier faces-config.xml de configuration doit se trouver dans WEB-INF

Vos pages web doivent être également sous le répertoire webapp.

NB: vous pouvez manuellement télécharger ces Ici il y a 3 thèmes

Vous aimerez peut-être aussi