Examen Génie Logiciel

Friday, May 26, 2023 10:51 AM

Q1. En REST , le type de retour de la ressource demandée sera décidé par :

A le serveur
B le client

R1. En REST, le type de retour de la ressource demandée est décidé par le client. Le client peut
spécifier le type de retour souhaité en utilisant l'en-tête Accept dans la requête HTTP. Par
exemple, si le client souhaite recevoir une réponse au format JSON, il peut inclure l'en-tête
Accept: application/json dans la requête. Le serveur renverra alors une réponse au format JSON si
possible.
Donc, la réponse correcte à cette question est B: le client.

Q2.
Soit le code suivant :
package ma.ensa;
public class Reservation {
private Logger resLogger = Logger.getLogger(this.getClass().getName());
private Logger ensaLogger = Logger.getLogger("org.ensa");
private Logger orgLogger = Logger.getLogger("org");
private Logger logger3 = Logger.getRootLogger();
...}
→ On associe à logger3 un appender3 et un niveau de criticité FATAL
→ On associe à resLogger un resAppender
→ On associe à ensaLogger
1 - Donner la hierarchie des loggers définis ci-dessus .
2 - Donner les appendres que seront appelés dans les cas suivants :
orgLogger.info("message 1");
orgLogger.fatal("message 2");
ensaLogger.info("message 3");
resLogger.error("message 4");

La hiérarchie des loggers est basée sur les noms des loggers. Les loggers sont organisés en une
structure d'arbre où chaque logger a un parent (en l'appelle aussi l’ancêtre) et peut avoir des
enfants. Le logger racine est le parent ou l’ancêtre de tous les autres loggers et n'a pas de parent
lui-même.
Dans le code que vous avez fourni, les loggers sont nommés de la manière suivante :
- resLogger a pour nom ma.ensa.Reservation.
- ensaLogger a pour nom org.ensa.
- orgLogger a pour nom org.
- logger3 est le logger racine.

La hiérarchie des loggers est donc la suivante :

- logger3 est le logger racine.
- orgLogger est un enfant de logger3 car son nom commence par org.
- ensaLogger est un enfant de orgLogger car son nom commence par org.ensa.
- resLogger est un enfant de ensaLogger car son nom commence par ma.ensa.

Un appender est un composant de la bibliothèque de logging qui est responsable de la sortie des
messages de log.
L’enregistrement des événements de journalisation est délégué à des objets spécifiques appelés
Appenders,
Ces objets implémentent l’interface org.apache.log4j.Appender
Chaque logger peut avoir un ou plusieurs appenders associés.

Cours Page 1
 Chaque logger peut avoir un ou plusieurs appenders associés.
Lorsqu'un logger reçoit un message de log, il vérifie d'abord si le niveau de criticité du message
est supérieur ou égal au niveau de criticité du logger (priorité(message) >= priorité(log)).
Si c'est le cas, le logger appelle tous les appenders qui lui sont associés pour écrire le message de
log. Si aucun appender n'est associé au logger, il remonte la hiérarchie des loggers jusqu'à ce
qu'il trouve un logger avec un appender associé.

Dans le code que vous avez fourni, les appels de méthode suivants sont effectués :
- orgLogger.info("message 1") n'appellera aucun appender car le niveau de criticité de logger3
est FATAL et INFO est inférieur à FATAL.
- orgLogger.fatal("message 2") appellera l'appender appender3 car le niveau de criticité du
message est supérieur ou égal au niveau de criticité du logger et appender3 est associé à
logger3.
- ensaLogger.info("message 3") n'appellera aucun appender pour la même raison que pour le
premier appel de méthode.
- resLogger.error("message 4") appellera l'appender resAppender car le niveau de criticité du
message est supérieur ou égal au niveau de criticité du logger et resAppender est associé à
resLogger.

Donnant la classe suivante :

public class Person {
private String cin;
private String firstName;
private String secondName;
private String nationality;
...
}
Donner les unités de traitement des controleurs Rest qui traiteront les req :
→ http://localhost:8080/springrest/persons
⇒ Retourne en json la liste des personnes
→ http://localhost:8080/springrest/persons/jc19000c4
⇒ Retourne en json la personne ayant le cin exprimé dans la requete
→ http://localhost:8080/springrest/persons?nationality=marocain
⇒ Retourne en json la liste des personnes ayant comme nationalité “marocain”

@RestController
@RequestMapping("/springrest/persons")
public class PersonController {

@Autowired
private PersonService personService;

@GetMapping
public List<Person> getPersons(@RequestParam(required = false) String nationality) {
if (nationality != null) {
return personService.findByNationality(nationality);
} else {
return personService.findAll();
}
}

Cours Page 2
 }

@GetMapping("/{cin}")
public Person getPersonByCin(@PathVariable String cin) {
return personService.findByCin(cin);
}
}
Ce contrôleur utilise l'annotation @RestController pour indiquer qu'il s'agit d'un contrôleur REST et
l'annotation @RequestMapping pour spécifier l'URL de base pour toutes les méthodes du contrôleur.

La méthode getPersons utilise l'annotation @GetMapping pour indiquer qu'elle traite les requêtes GET à
l'URL /springrest/persons. Elle utilise également l'annotation @RequestParam pour récupérer la valeur du
paramètre nationality de la requête. Si ce paramètre est présent, la méthode appelle la méthode
findByNationality du service PersonService pour renvoyer la liste des personnes ayant la nationalité
spécifiée. Sinon, elle appelle la méthode findAll pour renvoyer la liste de toutes les personnes.

La méthode getPersonByCin utilise également l'annotation @GetMapping, mais avec un paramètre pour
indiquer qu'elle traite les requêtes GET à l'URL /springrest/persons/{cin}. Elle utilise l'annotation
@PathVariable pour récupérer la valeur du paramètre cin de l'URL. Elle appelle ensuite la méthode
findByCin du service PersonService pour renvoyer la personne ayant le CIN spécifié.

Soit la configuration spring :

<bean id="task" class="ma.ensa.Task">
<constructor-arg ref="subtask 1" />
<constructor-arg ref="subtask 2" />
</bean>
<bean id="subtask 1" class="ma.ensa.Subtask1" />
<bean id="subtask 1" class="ma.ensa.Subtask2" />
Ecrire un code minimale de la class Task

package ma.ensa;

public class Task {

private Subtask1 subtask1;
private Subtask2 subtask2;

public Task(Subtask1 subtask1, Subtask2 subtask2) {

this.subtask1 = subtask1;
this.subtask2 = subtask2;
}

// autres méthodes et attributs

}
Cette classe Task a deux attributs privés de type Subtask1 et Subtask2, qui
correspondent aux deux beans subtask 1 et subtask 2 définis dans la configuration
Spring. Elle a également un constructeur qui prend en paramètres deux objets de
type Subtask1 et Subtask2, qui sont utilisés pour initialiser les attributs
correspondants.

Quels patterns Spring Core permet-il de mettre en place ?

A. MVC
B. Injection de dépendance
C. IOC
D. Service Locator

Cours Page 3
 Spring Core permet de mettre en place les patterns suivants :
- Injection de dépendance (B)
- Inversion de contrôle (IOC) (C)

L'injection de dépendance (DI) est un pattern qui permet de découpler les dépendances entre les composants
d'une application. Au lieu de créer les dépendances directement dans le code, elles sont injectées dans les
composants par un conteneur d'injection de dépendances, comme Spring.

L'inversion de contrôle (IoC) est un principe étroitement lié à l'injection de dépendance. Il s'agit de transférer
le contrôle de la création et de la gestion des objets d'une application à un conteneur externe, comme Spring.

MVC (A) est un pattern architectural qui sépare une application en trois parties : le modèle (Model), la vue
(View) et le contrôleur (Controller). Spring fournit un module appelé Spring MVC qui permet de mettre en
place ce pattern, mais il ne fait pas partie du noyau de Spring.

Service Locator (D) est un pattern qui permet d'obtenir des instances de services à partir d'un registre central.
Bien que Spring puisse être utilisé pour mettre en place ce pattern, il n'est pas considéré comme une bonne
pratique

Comment peut-on declarer un bean, dans un context Spring ?

A. Repository
B. Bean
C. Service
D.
E. Component

A et B et C et E
Dans un contexte Spring, un bean peut être déclaré de plusieurs manières. Voici les options valides parmi
celles que vous avez mentionnées :
- En utilisant l'annotation @Bean (B) sur une méthode dans une classe de configuration. Cette méthode doit
renvoyer une instance du bean et sera appelée par Spring pour créer le bean.
- En utilisant l'annotation @Component (E) sur la classe du bean. Spring détectera automatiquement cette
classe et créera un bean à partir d'elle.
- En utilisant des annotations stéréotypées dérivées de @Component, telles que @Service (C) ou
@Repository (A), sur la classe du bean. Ces annotations fonctionnent de la même manière que @Component,
mais fournissent des informations supplémentaires sur le rôle du bean dans l'application.

Quels sont les différents types d’injection de Bean ?

A. constructeur et getter
B. setter , getter et constructeur
C. constructeur et setter
D. getter et setter

C
Il existe plusieurs types d'injection de bean dans Spring. Les options valides parmi celles que vous
avez mentionnées sont :
- Injection par constructeur (C) : les dépendances sont passées en tant qu'arguments au
constructeur du bean lors de sa création.
- Injection par setter (C) : les dépendances sont définies en appelant des méthodes setter sur le bean
après sa création.

L'injection par getter (A, B, D) n'est pas un type d'injection valide dans Spring. Les getters sont des
méthodes utilisées pour récupérer les valeurs des attributs d'un objet, mais ils ne sont pas utilisés
pour injecter des dépendances.

Cours Page 4
 pour injecter des dépendances.

Cocher la ou les bonnes réponses

A. par défaut , l’annotation @Autowired impose une dépendance obligatoire. Il est
possible de rendre une dépendance optionnelle
B. par défaut , l’annotation @Autowired impose une dépendance obligatoire. Si spring
n’arrive pas à résoudre la dépendance , une exception est générée

Les deux réponses sont correctes :

- A. Par défaut, l'annotation @Autowired impose une dépendance obligatoire. Il est possible de rendre
une dépendance optionnelle en définissant l'attribut required de l'annotation @Autowired à false.
- B. Par défaut, l'annotation @Autowired impose une dépendance obligatoire. Si Spring n'arrive pas à
résoudre la dépendance, une exception de type BeanCreationException est générée.

Dans un développement piloté par le test TDD, laquelle des énoncés suivantes est incorrecte :
A. TDD est une méthode de dev de logiciel pour développer des tests automatisés réutilisables
B. Les classes de tests sont écrites avant les classes métiers
C. Les TDD est utilisé en continu jusqu’à la livraison du logiciel
D. Les résultats du TDD sont des classes de tests aidant les dév à développer un jeu de test

L'énoncé incorrect est A. TDD (Test Driven Development) est une méthode de développement de logiciel
qui consiste à écrire les tests avant d'écrire le code de production. L'objectif de TDD n'est pas de
développer des tests automatisés réutilisables, mais plutôt d'utiliser les tests pour guider la conception
et l'implémentation du code de production.

Cours Page 5
Il est recommendé de résoudre les injections de dépendances obligatoires
via des injections par constructeur
Vrai
Faux

Vrai. Il est recommandé de résoudre les injections de dépendances obligatoires via des injections par
constructeur. L'injection par constructeur garantit que toutes les dépendances obligatoires d'un
bean sont satisfaites avant que le bean ne soit utilisé. Cela permet d'éviter les erreurs liées à
l'utilisation d'un bean qui n'a pas toutes ses dépendances satisfaites.
L'injection par constructeur a également d'autres avantages. Elle rend le code plus facile à tester, car
les dépendances peuvent être facilement remplacées par des mocks dans les tests unitaires.

Pour injecter une propriété dans une classe, on utilise le tag

A. La classe doit contenir un setter pour cette propriété
B. La classe doit contenir un constructeur par défaut sans paramètre
C. La classe doit contenir un constructeur ayant comme paramètre cette propriété

A
Pour injecter une propriété dans une classe en utilisant le tag <property> dans la configuration XML de
Spring, la classe doit contenir un setter pour cette propriété (A). Le setter doit suivre la convention de
nommage JavaBeans, c'est-à-dire que son nom doit commencer par set suivi du nom de la propriété
avec la première lettre en majuscule.
Par exemple, pour injecter une propriété name dans une classe Person, la classe Person doit contenir
une méthode setName qui prend en paramètre la valeur à injecter pour la propriété name.

Dans une architecture logicielle, la communication entre couches suit les règles suivantes :
A. une couche ne doit pas ignorer la couche supérieure
B. une couche ne connait que la couche inférieure et elle ne doit jamais faire référence à la
couche supérieure
C. En termes de langage objet, la communication entre couches s’effectue en établissant
des contrats via des interfaces

Cours Page 6
 Les énoncés B et C sont corrects :
- B. Dans une architecture en couches, une couche ne connaît que la couche inférieure et ne doit jamais faire
référence à la couche supérieure. Cela garantit que les couches sont indépendantes les unes des autres et
peuvent être modifiées sans affecter les autres couches.
- C. En termes de langage objet, la communication entre les couches s'effectue en établissant des contrats via
des interfaces. Les interfaces définissent les méthodes que la couche inférieure doit implémenter pour être
utilisée par la couche supérieure. Cela permet de découpler les couches et de faciliter les tests et la
maintenance.

L'énoncé A est incorrect. Dans une architecture en couches, une couche ne doit pas ignorer la couche
supérieure. Au contraire, chaque couche doit fournir des services à la couche supérieure en respectant les
contrats établis via des interfaces.

un code lève l’exception souhaitée ou non

Vrai
Faux

Vrai. L'annotation @Test avec l'attribut expected peut être utilisée pour tester si un code lève
l'exception souhaitée ou non. L'attribut expected prend en paramètre la classe de l'exception attendue.
Si le code testé lève cette exception, le test réussit. Si le code ne lève pas cette exception ou lève une
exception différente, le test échoue.
Voici un exemple de test qui utilise l'attribut expected de l'annotation @Test pour vérifier si un code
lève une exception ArithmeticException :

[java]
@Test(expected = ArithmeticException.class)
public void testDivideByZero() {
int result = 1 / 0;
}
Ce test réussira car le code testé lève une exception ArithmeticException lorsqu'il tente de diviser par
zéro.

Cours Page 7
Cours Page 8
 Instanciation d’un conteneur spring permet de charger immédiatement
l’ensemble des beans du conteneur
Vrai
Faux

Avec Spring MVC , la méthode de controle suivante @RequestMapping(value="/reqparam" ,

method=RequestMethod.GET ,
params={"auth=true" , "refresh","!authenticate"})
public String methodControl() {
return "pagejsp";
}
Traitera la requete http suivante :
A. http://localhost:8080/nP/reqparam?auth=true&refresh=valeur&authenticate
B. http://localhost:8080/nP/reqparam?auth=true&refresh=valeur
C. http://localhost:8080/nP/reqparam?auth=true&refresh

La méthode de contrôle traitera la requête HTTP suivante: B.

http://localhost:8080/nP/reqparam?auth=true&refresh=valeur. Cette méthode
spécifie que les paramètres "auth" doivent être égaux à "true", que le paramètre
"refresh" doit être présent et que le paramètre "authenticate" ne doit pas être
présent.

Quelle est la portée d’un bean stateless dans Spring ? 1 rep)

A . singleton scope

Cours Page 9
 A . singleton scope
B. Prototype scope
C. Request scope
D. Application scope

La portée d'un bean stateless dans Spring est A. singleton scope. Cela signifie
que Spring ne crée qu'une seule instance de ce bean et le partage entre toutes
les demandes.

Un serveur d’application , en Rest , est sans état par rapport aux requetes traitées.Cet état doit étre géré
par le client.
Vrai
Faux

Vrai. Dans une architecture REST, le serveur est sans état par rapport aux requêtes
traitées. Cela signifie que chaque requête doit contenir toutes les informations
nécessaires pour être traitée par le serveur. L'état de la session doit être géré par le
client.

Le conteneur spring est :

A. conteneur lourd
B. conteneur d’injection de dépendance
C. un conteneur d’inversion de controle
D. conteneur léger

Le conteneur Spring est B. un conteneur d'injection de dépendance et C. un conteneur

d'inversion de contrôle. Il est également considéré comme D. un conteneur léger par
rapport aux conteneurs lourds tels que les serveurs d'applications Java EE.

Soit f une méthode static d’une classe A ,à un seul paramètre, et qui lève une exception de type
illegalArgumentException lorsqu’on l’execute avec le paramètre 0.
Ecrire le code pour tester cette fonction en junit4

Spring Core et la programmation orientés aspect sont à la base du framework spring ?

Cours Page 10
Spring Core et la programmation orientés aspect sont à la base du framework spring ?
Vrai
Faux

Vrai. Spring Core et la programmation orientée aspect (AOP) sont à la base du framework
Spring. Spring Core fournit les fonctionnalités de base pour la gestion des beans et
l'injection de dépendances, tandis que Spring AOP fournit des fonctionnalités pour la
programmation orientée aspect.

Cours Page 11