Conséquences sur les dépendances </bean> «classpath*:application-context.

xml»Spring charge tous les Créer une annotation personnalisée :

+ Les dépendances ne permettent pas : <bean id="utilisateurRepository" class="com.sqli.spring.DefaultRepository"/> fichiers:«application-context.xml» présent dans le classpath. @Retention(RetentionPolicy.RUNTIME)
-d’installer A sans installer B Equivalent en Java Transtypage : Cast @Target(ElementType.TYPE)
-donc de réutiliser A sans réutiliser B UtilisateurService utilisateur = new UtilisateurServiceImpl(); Depuis la version 3 de Spring, il est possible de récupérer un bean sans @Service
-une modification de B (changement de signature de méthode, …) Utilisateur.setRepository(new DefaultRepository()); transtypage (sans cast) @Transactional(timeout=60)
-peut entraîner une modification de A +Avantages de l’injection par accesseurs : Le cycle de vie d’une application Spring public @interface MonServiceTransactionnel {…}
-une recompilation de A + L’injection par accesseur permet les dépendances facultatives + La phase d’initialisation : les beans sont initialisés et injectés. <context:component-scan base-package="com.sqli.app.service,
+Il y a perte de réutilisation et de modularité + L’injection par accesseur décrit les dépendances de façon claires donc plus + La phase d’exécution : l’application s’exécute. com.sqli.app.controller" >
+Une mauvaise gestion des dépendances entraîne pour l'application… lisible + La phase de destruction : les beans sont supprimés du contexte Spring. <context:include-filter …. />
-Rigidité : Application difficile à modifier car chaque changement affecte -d'autres + Les accesseurs sont hérités automatiquement Initialisation des instances de bean <context:exclude-filter…./>
parties du logiciel + Lève automatiquement les ambiguïtés sur les types + Par défaut, Spring instancie les beans lors du démarrage du Contexte Component-Scanning :
-Fragilité : modification entraîne des effets de bords : BUG -Inconvénients de l’injection par accesseurs Applicatif </context:component-scan base-package=’’com.example.service‘’>
-Immobilité : de reprendre une partie de l'application car elle ne peut pas être - Notation très verbeuse L’instantiation est réalisée dans l’ordre et toutes les dépendances sont //optimisé
indépendante des autres parties - Le contrat d’interface est trop lâche (risque de lever des exceptions de type injectées. Injection par Constructeur
Couplage fort entre classes : NullPointerException). + Dès l’injection des dépendances réalisée, la phase de post traitement peut @Autowired
+ Refactoring systématique si l’on désire modifier l’implémentation ou le mécanisme Injection par accesseur & constructeur au même remps : débuter public TransfertServiceImpl(IReferentielDAO refernetiel) {
d’instanciation. <bean id="service" class="com.sqli.spring.service.oneServiceImpl"> Les actions de configuration plus poussée des instances sont réalisées. this.referentiel = refernetiel; }
+ Impossible de choisir l’implémentation en cours d’exécution de l’application. <constructor-arg ref="domainManager"/> + Après la phase de post-traitement, le bean est complètement initialisé et Injection par méthode
Injection de dépendances <property name="directoryRepository" ref="directoryRepository"/> prêt à l’emploi @Autowired
Comment fournir l’implémentation ? </bean> Chaque bean est utilisé jusqu’à sa destruction. public void setReferentiel(IReferentielDAO referentiel) {
+ Nous avons besoin d’une entité externe pour gérer les dépendances. Equivalent : + L’interface «BeanPostProcessor » permet de s’insérer dans le flux this.referentiel = referentiel; }
+ Plus précisément, d’un outil réalisant l’injection de dépendances. DomainManagerImpl domainManager = new DomainManagerImpl(); d’initialisation Injection par membre
Spring est un outil permettant de satisfaire les dépendances entres objets par injection DefaultRepositoryImpl directoryRepository = new @Autowired
+ Configuration centralisée – programmation déclarative des dépendances. DefaultRepositoryImpl(); private IReferentielDAO referentiel;
+ Spring est non intrusif via à vis du code. OneServiceImpl service = new OneServiceImpl(domainManager);
+ Une application est un assemblage de composants. service.setDirectoryRepository(directoryRepository);
IoC == Inversion of Control (en general) Le choix
Permet d’avoir des composants « faiblement couplés » en appliquant les deux principes : Injection par constructeur : Dépendances obligatoires
+ Améliore la qualité du code (avantage1) +L’inversion de contrôle(principe1) Injection par les accesseurs :
+ Facilite les tests(avantage2) +La dépendance inversée(principe2) + Dépendances facultatives
Les avantages de DI dans Spring + Le nombre de dépendances obligatoires devient très importante
+ Les objets injectés peuvent être modifiés par Spring factory-method
+ Par exemple, les rendre transactionnels ou sécurisés <bean id="-- " class="--" factory-method="getInstance"/>
+ Ceci est permis grâce à la Programmation Orientée Aspect //getInstance must be static
+ C’est ainsi que Spring peut fournir la « plomberie technique », sans que le développeur factory-bean
« BeanPostProcessor » est un point d’extension important
n’ait à faire quoi que ce soit <bean id="-- " factory-bean="monServiceFactory" factory-
- Permet de modifier une instance de bean après sa création par le
Spring et les serveurs d’applications method="getInstance"/>
conteneur Spring.
*Spring n’est pas un serveur d’applications //getInstance n’est plus static
- Permet la prise en charge de fonctionnalités spécifiques.
+ Il peut fonctionner sans serveur d’applications (application «standalone», par A quoi sert « FactoryBean » ? L ’annotation « @Qualifier » permet de résoudre l’ambiguïté↑
+ Spring fournit un certain nombre d’implémentations
exemple un batch) + Utile pour instancier des beans dont la configuration est trop complexe à
- Il est possible mais assez rare d’écrire soit même une implémentation. L’annotation « @Primary » indique à Spring le bean à injecter
+ Il peut fonctionner à l’intérieur d’un serveur d’applications effectuer XML. par défaut.
+ Exemples d’implémentation
- Il peut alors utiliser les fonctionnalités du serveur, pour en simplifier ou en + Intégration de code existant. @Bean définit un bean.
- RequiredAnnotationBeanPostProcessor
abstraire le fonctionnement + L’injection s’effectue comme avec n’importe quel bean. - L’identifiant du bean est déterminé par le nom de la
Fourni par Spring.
- Il peut également remplacer certaines fonctionnalités du serveur, si on juge que Scopes (Portés des Beans) méthode.
Assure que les attributs annotés par « @Required » sont peuplés.
Spring propose une meilleure alternative + Singleton : une seule instance par contexte. C’est la portée par défaut. - L’injection est effectuée dans le corps de la méthode.
@postConstruct : appelée après l’injection (avant fct init)
*Généralement Spring est utilisé conjointement à un serveur d’applications léger : + Prototype : nouvelle instance crée chaque fois que le bean est injecté. - Spring s’appuie sur la librairie CGLIB pour réaliser les injections
(<bean id= ‘’ init-method=’’init’’>
Tomcat ou Jetty + Session : nouvelle instance crée par session utilisateur. Environnement Web. de dépendances
Implementer InitializingBean)
Injection par constructeur : + Request : nouvelle instance crée pour chaque requête. Environnement Web.
@PostDestroy : appelée avant la supp d’1 bean du ctxt
<bean id="utilisateurService" class="com.sqli.spring.service.UtilisateurServiceImpl"> + Custom : définition de nouvelles règles de gestions.
(<bean id= ‘’ destroy-method=’’destroy’’>
<constructor-arg ref="utilisateurRepository"/> Programmation avancée.
Implementer DisposableBean)
<constructor-arg ref="directoryRepository"/> EX :<bean id= ‘’ ‘’ class=’’ ‘’ scop= ‘’prototype ‘’/>
Injection via les annotations :
<constructor-arg index="0" value="Robert"/> CONTEXTE APPLICATIF @Component
<constructor-arg index="1" value="Durand"/> ClassPathXmlApplicationContext : Chargement du context depuis une source public class TransfertServiceImpl implements ITransfertService {
//index : enlever les ambigüités XML présente dans le classpath @Autowired
</bean> FileSystemXmlApplicationContext : Chargement du context depuis XML public TransfertServiceImpl(IReferentielDAO refernetiel) { this.referentiel =
<bean id="utilisateurRepository" class="com.sqli.spring.DefaultRepository"/> depuis le système de fichier refernetiel; }}
Equivalent en Java XmlWebApplicationContext : Chargement du context depuis une source Un stereotype permet de caractériser
UtilisateurService utilisateur = new UtilisateurServiceImpl(new DefaultRepository(), XML dans le context d’une app web le rôle d’un bean au sein du contexte.
DirectoryRepositoryImpl());// 1st constructor AnnotationConfigApplicationContext : Chargement du contexte à partir
+Avantages de l’injection par constructeur : de classes annotées
+ L’injection par constructeur permet de définir un contrat de dépendance fort (besoin AnnotationConfigWebApplicationContext : Chargement de context à
de toutes ses dépendances). partir de classes annotées au sein d’une app Web.
+ L’injection par constructeur fait un usage concis des déclarations de beans. Via le classpath : new ClassPathXmlApplicationContext
+ L’injection par constructeur évite le surcoût de création des méthodes « set ». ("applicationContext.xml");
-Inconvénients de l’injection par constructeur : Via le système de fichier :
- Si le bean possède de nombreuses dépendances, la liste des paramètres de + new FileSystemXmlApplicationContext ("c:/config/application-
construction peut être très longue. config.xml");
- S’il existe plusieurs possibilités pour construire le bean, la définition des constructeurs + new FileSystemXmlApplicationContext
peut devenir complexe. ("./application-config.xml");
- Ambiguïté des paramètres de même type. Un contexte Spring peut être initialisé à partir de plusieurs fichiers de @Component
- Problème de l’héritage et de l’appel à la méthode super() pour mettre à jour des données configuration @Service : couche service
privées. ApplicationContext context = new @Repository : couche DAO
Injection par accesseurs ClassPathXmlApplicationContext("application-context.xml", "mysql- @Controller : couche vue
<bean id="utilisateurService" class="com.sqli.spring.service.UtilisateurServiceImpl"> database.xml"); @Configuration : config java
<property name="repository"ref="utilisateurRepository"/> Le caractère « * » (joker)
//or <property name="repository" value="hello"/>
 - Eviter les accès multiples sur les fichiers XML partagés par Dans une class PersonDAOImpl ↓: ResultSetExtractor: Adapté lorsqu’un ensemble de tuples
Cycle de vie : l’équipe de développement. correspond à un seul object métier.
XML/Annotations/Javan
JDBC
Problèmes d’Accès en base de données (old way)
+ Etablir une connexion
+ Initier une transaction
+ Effectuer un commit ou rollback de la transaction
L’insertion & l’update:
+ Fermer la connexion
=>polluer le code applicatif
=>Elles n’apportent aucune valeur ajoutée métier
Solutions : apporter une couche d’abstraction
+ Automatiser la gestion des connexions
- Acquisitions/libérations des connections automatique QueryForInt(in case count)
- Eviter les fuites mémoires QueryForMap(return 1 row)
+ Faciliter la gestion des transactions QueryForList(return list)
- Configuration des transactions externalisées ---------------------------
- Utilisation d’un gestionnaire de transaction (pas forcément
Java EE) Rappels sur la Programmation java :
+ Simplifier la gestion des erreurs. Count↑  Un environnement d’exécution (JRE)
Solution1: intégration avec les outils de persistance suivants :  Boxing :la conversion d’un type primitif en un object
Usage de <context:annotation-config/>; l’utilisation des @Componenet n’est plus necessaire - JDBC et Hibernate Wrapper (int=>Integer)
<beans>  Unboxing :le processus inverse
- Ibatis, EJB, JPA.
<context:annotation-config/> seul tuple↑  String toString() : Renvoie la forme text d’un Object
Solution2: Utilisation du design pattern « Template Method »
<bean id="transfertService" o Les exceptions non vérifiées, telles que
pour effectuer les accès des données
class="com.sqli.spring.service.impl.Transfer NullPointerException… sont souvent causées par des
- Fournit un « patron » spécifique pour chaque technologie.
tServiceImpl"/> erreurs de programmation et peuvent survenir à tout
- Masque les détails technique au développeur.
<bean id="referentielDao" plusieurs tuples↑ moment pendant l'exécution du programme.
Runtime Exception : au moment d’execution (NullPointerExcep) o
class="com.sqli.spring.dao.impl.JdbcRefentie Rq :JDBCTemplate se base sur la technique du ‘’CallBack’’
Les exceptions vérifiées, comme IOException, sont
Checked Exception : lors de la compilation (IOExcep, SQLExcep) souvent liées à des problèmes d'entrée-sortie et
lDAOImpl"/> Solution 2 : Respecter DI
+ Spring fournit la hiérarchie « DataAccessException » doivent être traitées explicitement par le programmeur.
</bean> Créer le fichier XML
- Type « Runtime » unchecked.  Collections :
utilisation de @Import - Encapsule les types d’exceptions quelle que soit la technologie Solution 3 : ½ XML et ½ Annotation  List : stockag d’une manière séquentielle
@Configuration Travailler avec les bdd embedded Dans XML, ajouter la ligne : List<Integer>myList=new ArrayList<>() ;
@Import({SecurityConfig.class,DaiConfig.class}) public class ServiceConfig{…}  Avec XML <context :component-scan base-package=’’—‘’/> .add(5) .get(0) .remove(2) .size() .clear() .contains(4)
XML vs Annotations <jdbc:embedded-database id="dataSource" type=”HSQL,H2,DERBY”/> jdbcTemplate permet de faire des requêtes sur :  Set : stockag des éléments sans doublons
<jdbc:initialize-database data-source="dataSource"> - Des types primitifs et simples (int, long, String, etc…). Set<Integer>mySet=new HashSet<>() ;
Annotations
<jdbc:script location="classpath:schema.sql" /> - Des collections (Map, List, etc…). .add(5) .get(0) .remove(2) .size() .clear() .contains(4)
Pratique pour des beans changeant souvent
- Des objects Métiers. .isEmpty()
+ Avantages </jdbc:initialize-database>
+ JdbcTemplate permet d’associer les données sous forme  Map : stockag des paires key-value
- Modification au sein même de la classe en cours de codage. //<jdbc:embedded-database> met à disposition d’une
d’objets métiers Map<String,Integer>myMapt=new HashMap<>() ;
- Favorise les temps de développement rapide. datasource. .put(‘’Java’’,5) .get(‘’java’’) .remove(‘’java’’)
// <jdbc:initialize-database> initialise une base de données. + JdbcTemplate s’appuie sur la technique du « callback »
+ Inconvénients .containsKey(key) .containsValue(value) .size() .isEmpty()
//exemples : HSQL (par défaut), H2 et Derby RowMapper(for reading data)
- La configuration est éparpillée sur l’ensemble des classes. .keySet() .values() .entrySet()
 Avec Java (dans une class anotée @Configuration↓) + Adapté lorsque chaque tuple est associé à un objet métier.
- Impossible d’intégrer du code existant dont les sources ne sont pas disponibles.
E1 : Creation de la methode (Définition): + Ce mapping est équivalent à celui utilisé par les outils ORM tel Introduction Spring :
XML
@Bean que Hibernate L’importance du Spring: +Facilité de déveleoppement
Destiné à la configuration de beans de type
public DataSource dataSource() { + JdbcTemplate met à disposition l’interface « RowMapper »
« infrastructure » et relativement invariants
DriverManagerDataSource dataSource = new pour associer les données +Modularité +Intégration facile +Sécurité +Evolutivité
+ Avantages
DriverManagerDataSource(); - Peut être utilisé aussi pour des requêtes uniques ou sur des
- Centralisation de la configuration.
dataSource.setDriverClassName("org.h2.Driver");//or com.my.. ensembles. -La configuration XML –Dépendance de version -performance
- Ecriture XML assez connue parmi les équipes de développement.
- Permet l’intégration d’application tierces parties. dataSource.setUrl("jdbc:h2:~/h2/material_db");
- Complétion XML Spring avec certains outils (MyEclipseIDE, STS). dataSource.setUsername("sa"); Le conteneur Spring: Le conteneur est l'un des principaux
+ Inconvénients dataSource.setPassword("sa"); composants de Spring Framework. se charge de
- Options de configuration relativement limitées. return dataSource; créer les instances, de les configurer et de gérer les objets requis
- Beaucoup de personnes détestent l’écriture XML. } par l'application, plus la gestion des dépendances, il y’a deux:
Java Configuration E2 : Creation d’une 2e methode (Population) :
+ Contrôle total sur l’instanciation et la configuration @Bean  ApplicationContext vs BeanFactory: l'ApplicationContext
- Alternative à l’implémentation d’une FactoryBean. public DataSource dataSource() { est préférable pour les applications en production, D'autre
+ Avantages // …. seul tuple↑ part, le BeanFactory est plus léger et est donc préférable
- Configuration externalisée vis-à-vis du code applicatif. Resource initSchema = new pour les applications avec des ressources limitées.
- Facilité l’intégration de code en provenance des tiers parties. ClassPathResource("script/schema.sql");
- Possibilité d’appeler du code tel que addDataSource(Datasource d). DatabasePopulator databasePopulator = new
ResourceDatabasePopulator(initSchema); plusieurs tuples↑
+ Inconvénients
DatabasePopulatorUtils.execute(databasePopulator, RowCallbackHandler
- Pas d’équivalence avec les espaces de noms en XML.
dataSource); + Adapté lorsqu’un aucun résultat ne doit être retourné pour
- Le maillage n’est pas visualisable au travers d’outils tels que Spring Tool Suite (STS).
return dataSource; chaque tuple.
Conclusion
} + Spring fournit l’interface « RowCallbackHandler » dans le cas où
Chaque technique possède ses avantages et inconvénients
+Creation d’une bdd H2 aucun object ne doit être retourné
- Certains préfèrent conserver l’injection proche du code.
java -cp libs/h2-1.4.197.jar org.h2.tools.Shell - Stocker les données dans un fichier. Les Composants de Spring: Spring Security: Protéger les
- D’autres considèrent que les classes annotées ne sont plus des
+ ouvrir une bdd h2 sur chrome (localhost :8082) - Convertir les tuples sous format XML. applications Spring contre les attaques de sécurité.
POJOs et préfèrent garder une vue d’ensemble via le XML.
java -jar libs/h2-1.4.197.jar -baseDir ~/h2 - Appliquer des règles de filtrage sur les données
+ Aucune méthode ne se démarque clairement
Solution 1 : Travailler avec JDBC Template -Plus performant en SQL. Spring Data: faciliter l’acces aux données
+ Bonnes pratiques:
Définition des beans « infrastructures » en XML : E1 : créer une classe student
- Définition des sources de données, connexion LDAP, etc… E2 : créer une interface studentDAO Spring Core, Spring cloud, Spring boot,
- Interchanger les fichiers XML selon l’environnement cible. (Definir les fonctions insert…)
Définition des beans « métiers » par les annotations E3 : Créer une classe StudentImpl qui implemente StudentDAO
- Temps de développement plus rapide.
 TPs ApplicationContext factoryContext = new //StudentRepository Interface return new InMemoryStudentRepository();
ClassPathXmlApplicationContext("factory-beans.xml"); public interface StudentRepository { }
TP1 void save(Student student); }
 une classe de bean appelée Country contient 2 attributs : name, Student findById(int id); //main.java
population, les constructeur, les getters et setters Country countryFactoryMethodWithParams = List<Student> findAll(); public class Main {
//beans.xml (Country) } public static void main(String[] args) {
<beans> factoryContext.getBean("countryFactoryMethodWithPa //StudentServiceImpl
AnnotationConfigApplicationContext context = new
<!-- Bean with constructor injection --> rams"); public class StudentServiceImpl implements StudentService {
private StudentRepository studentRepository; AnnotationConfigApplicationContext(ApplicationConfig.
<bean id="countryConstructor" class="com.example.beans.Country"> System.out.println("Country (Factory with Params):
<constructor-arg value="France"/> public StudentServiceImpl(StudentRepository class);
" + countryFactoryMethodWithParams.getName() + ",
<constructor-arg value="67000000"/> studentRepository) { StudentService studentService =
Population: " + this.studentRepository = studentRepository;
</bean> context.getBean(StudentService.class);
countryFactoryMethodWithParams.getPopulation()); } Student student1 = new Student(1, "Bob",
<!-- Bean with setter injection --> @Override
"Williams");
<bean id="countrySetter" class="com.example.beans.Country"> Country countryFactoryMethodWithoutParams = public void createStudent(Student student) {
studentRepository.save(student); Student student2 = new Student(2, "Jane",
<property name="name" value="Germany"/> (Country)
<property name="population" value="83000000"/> } "Smith");
factoryContext.getBean("countryFactoryMethodWitho
</bean> @Override Student student3 = new Student(3, "Alice",
utParams"); public Student findStudentById(int id) {
</beans> "Johnson");
System.out.println("Country (Factory without return studentRepository.findById(id);
//main.java Student student4 = new Student(5, "Emily",
public class Main {
Params): " + }
@Override
"Brown");
public static void main(String[] args) { countryFactoryMethodWithoutParams.getName() + ",
public void getAllStudents() { studentService.createStudent(student1);
ApplicationContext context = new Population: " +
List<Student> students = studentRepository.findAll(); studentService.createStudent(student2);
ClassPathXmlApplicationContext("beans.xml"); countryFactoryMethodWithoutParams.getPopulation())
System.out.println("List des Etudiants:"); studentService.createStudent(student3);
; for (Student student : students) {
Country countryConstructor = (Country) studentService.createStudent(student4);
---------------------------------------------------------------------------- System.out.println(student.getFirstName()+"
context.getBean("countryConstructor"); TP2
Student foundStudent =
"+student.getLastName());
System.out.println("Country (Constructor): " + studentService.findStudentById(1);
countryConstructor.getName() + ", Population: " + Étape 1 : Configuration du projet }
} System.out.println("Student found: " +
countryConstructor.getPopulation()); +Créez un nouveau projet Java Spring dans votre IDE
} foundStudent.getFirstName()+"
préféré.
Country countrySetter = (Country)
//StudentServiceMock "+foundStudent.getLastName());
+Configurez les dépendances nécessaires dans pom.xml
public class StudentServiceMock implements StudentService { studentService.getAllStudents();
context.getBean("countrySetter"); (pour Maven) incluant spring-core, spring-context, et @Override context.close();
System.out.println("Country (Setter): " + countrySetter.getName() +
springboot-starter. public void createStudent(Student student) {
", Population: " + countrySetter.getPopulation()); }
} Étape 2 : Création des classes System.out.println("Création de l'étudiant : "
+student.getFirstName()+" "+student.getLastName()); }
} +Modèle étudiant: Créez la classe Student avec les
} L’Architecture de Spring :
propriétés et méthodes d'accès nécessaires.
@Override
 une classe de bean appelée CountryServiceFactory avec une nouvelle +Service des étudiants: Créez l'interface StudentService
public Student findStudentById(int id) {
fonction getInstance() avec 2 attributs : name et population et qui définissant les opérations de gestion des étudiants return new Student(id,"firstName","lastName");
retourne une nouvelle instance d’objet country+une fonction (création, recherche par ID, affichage). }
getInstance() mais sans paramètres et qui retourne une instance d’objet +Référentiel des étudiants: Créez l'interface @Override
country? StudentRepository définissant les méthodes d'accès aux public void getAllStudents() {
public class CountryServiceFactory { System.out.println("Affichage de tous les étudiants!");
données des étudiants (save, findById, findAll, etc.).
}
public Country getInstance(String name, int population) {
+Implémentation du service: Implémentez
}
return new Country(name, population); StudentService dans la classe StudentServiceImpl, //InMemoryStudentRepository
} utilisant un objet StudentRepository. @Repository
+Service de simulation: Créez StudentServiceMock public class InMemoryStudentRepository implements
public Country getInstance() { implémentant aussi StudentService pour des données StudentRepository {
return new Country("DefaultCountry", 123456); fictives.
} private Map<Integer, Student> studentMap;
} +Référentiel en mémoire: Implémentez public InMemoryStudentRepository() {
 un nouveau fichier xml pour créer une instance du type StudentRepository dans InMemoryStudentRepository this.studentMap = new HashMap<>();
country avec l’utilisation du CountryServiceFactory en pour simuler un stockage en mémoire. }
utilisant : factory-bean et factory-method Étape 3 : Configuration du contexte Spring @Override
//factory-beans.xml +Annotez ApplicationConfig avec @Configuration pour public void save(Student student) {
<bean id="countryServiceFactory" indiquer qu'elle est une configuration Spring. studentMap.put(student.getId(),student);
class="com.example.factory.CountryServiceFactory" /> }
+Définissez les beans dans ApplicationConfig avec les
annotations appropriées.
@Override
<!-- Bean using factory-method with parameters --> Étape 4 : Utilisation des dépendances injectées
public Student findById(int id) {
<bean id="countryFactoryMethodWithParams" factory- +Dans la classe Main, utilisez les dépendances injectées en
return studentMap.get(id);
récupérant le bean StudentService à partir du contexte Spring et
bean="countryServiceFactory" factory-method="getInstance"> }
en appelant les méthodes nécessaires.
<constructor-arg value="Spain"/> //Student.ava
<constructor-arg value="46000000"/> @Override
public class Student {
public List<Student> findAll() {
</bean> private int id;
return new ArrayList<>(studentMap.values());
private String firstName;
}
<!-- Bean using factory-method without parameters --> private String lastName; //constructor //getters //setters…}
}
//StudentService Interface
<bean id="countryFactoryMethodWithoutParams" factory- //ApplicationConfig
public interface StudentService {
bean="countryServiceFactory" factory-method="getInstance" /> void createStudent(Student student); @Configuration
------------------------- public class ApplicationConfig {
Student findStudentById(int id);
Dans la classe main : @Bean
void getAllStudents();
 Récupérer la configuration d’après le nouveau fichier xml } public StudentService studentService(StudentRepository
 Créer une instance du bean studentRepository) {
 Récupérer les informations de ce dernier return new StudentServiceImpl(studentRepository);
//main.java }
// Load the factory-beans.xml configuration
@Bean
public StudentRepository studentRepository() {