Apprendre Spring.Net

Développer des applications logiciels est assez difficile même avec les bons outils et les bonnes technologies. Spring fournit un moyen cohérent et transparent pour configurer votre application et intégrer la programmation orientée aspet (AOP) dans vos solutions logiciels. Les fonctionnalités de Spring sont de fournir une gestion déclarative des transactions pour votr application de niveau intermédiaire en complémentarité du Framework Asp.net complet.

Spring peut être utiliser dans de nombreux domaine d’application d’entreprise. Il est modulaire et permet d’utiliser uniquement les parties dont vous avez besoin sans avoir à importer le reste. Vous pouvez par exemple uniquement utiliser le conteur d’inversion de contrôle IOC pour configurer votre application et utiliser le code d’accès au base de données ADO.Net traditionnel mais vous pouvez aussi choisir d’intégrer l’ORM Hibernate ou la couche d’abstraction ADO.Net. String a été et continue d’être conçu de façon non intrusif, cela signifie que les dépendances du Framework lui-même n’existe pas ou sont minimale en fonction du domaine d’utilisation.

1 – Introduction à Spring .Net

1-1 Aperçu

Spring.NET est une infrastructure d’application qui fournit un support infrastructurel complet pour le développement d’applications .NET d’entreprise.
Il permet de cacher la complexité lors de l’utilisation des bibliothèques de classes et d’utiliser les meilleures pratiques : telles que le développement piloté par les tests et les pratiques easy. Spring.NET est créé et est pris en charge et soutenu par SpringSource.

La conception de Spring.NET est basée sur la version Java du très connu Framework Spring qui a montré des avantages concrets et est utilisé dans des milliers d’applications d’entreprise à travers le monde. Spring .NET n’est pas uniquement un portage de la version Java mais plutôt un «portage» basé sur des modèles architecturaux et de conception éprouvés qui ne sont pas liés à une plate-forme particulière. L’ensemble des fonctionnalités Spring .Net couvre tous les niveau de la conception d’une application. Cependant cela ne veut pas dire qu’il est nécessaire d’utiliser tous ces composants. Vous pouvez n’en utiliser qu’une partie.Ce n’est pas une solution tout ou rien. Vous pouvez donc utiliser les fonctionnalités de ce module indépendamment.

Les applications d’entreprise sont généralement composés d’un certain nombre de couches physiques et au niveau de chacune de ces couches leur fonctionnalités sont souvent décomposés en sous-couches fonctionnelles . La couche métier par exemple est typiquement utilisée par des objets accédant à la couche de données pour répondre à un cas d’utilisation. Qu’importe la façon dont votre application est architecturée , en fin de développement, il existe une variété d’objets qui collaborent les uns avec les autres pour former l’application proprement dite. On peut donc constaté qu’une application est ensemble d’objet ayant des dépendances entre eux.


La plate-forme .NET offre une multitude de fonctionnalités pour l’architecture et la création d’applications, alliant des blocs de construction très basiques, des types et classes primitives au travers de serveurs d’application et de framework web riches et complets. Il existe un certain nombre de modèles de conception consacrés à la composition des différentes classes et instances d’objet qui constituent une application.Les patrons de conception(Design Pattern) tels que Factory, Decorator, Abstract Factory, Builder et Service Locator sont très largement répandu dans le domaine du développement logiciel. Ces patrons regroupent un ensemble de bonnes pratiques auxquels on a donné un nom, généralement avec une description de ce que fait le modèle …


Le Spring Framework reprend les meilleures pratiques qui ont fait leurs preuves au fil des ans dans de nombreuses applications et ont été formalisées sous forme de patron de conception(Design Pattern) que vous pouvez en tant que développeur intégrer dans vos applications.
Ceci est une très bonne chose , comme en témoignent les nombreuses organisations et institutions qui ont utilisé le Framework String pour concevoir des applications robustes et maintenables depuis de nombreuses années. Par le composant IOC du Framework Spring répond au préoccupation de l’entreprise de savoir comment gérer les classes et les objets au sein d’une application en formalisant diverses composants disparates prêt à l’emploi et opérationnels dans une application.

2-1 Les modules

Le Framework Spring.Net fournit de nombreuses fonctionnalités comme en témoigne le diagramme ci-dessous , il composé des modules suivants :

  • Spring Core : Il s’agit de la partie fondamentale du Framework (comme son nom l’indique le coeur du Framework) vous permettant de configurer cotre application en utilisant l’injection de dépendance. les autres fonctionnalités supportées , listes ci-dessous, se situe dans Spring.Core.
  • Spring.Aop : Ce module est utilisé pour effectuer de l’AOP(Aspect Oriented Programming (en Français Programmation orienté par Aspet) . AOP centralise les fonctionnalités communes qui peuvent être ensuite déclarée de manière déclarative dans votre application de manière ciblée. Les bibliothèques de Spring.Aop fournissent des aspets prédéfinis facile d’utilisation pour effectuer par exemple des : transactions, de la journalisation, de la surveillance des performances, de la mise en cache , l’accès aux méthodes et la gestions des exceptions.
  • Spring.Data.NHibernate : Ce module est utilisé pour intégrer NHibernate (Traduction de l’ORM Hibernate sous Java pour .Net) à la fonctionnalité de gestion déclarative de transaction de Spring, permettant de manipuler facilement les opérations ADO.Net et NHibernate dans la même transaction. Les utilisateurs de NHibernate 1.0 bénéficieront de la facilité d’utilisation des API pour effectuer des opérations d’accès aux données.
  • Spring.Messaging : Ce module est utilisé pour interagir avec le middleware chargé de la mise en file d’attente des messages de Microsoft MSMQ.
  • Spring.Messaging.NMS : Ce module est utilisé pour interagir avec le middleware chargé de la mise en file d’attente de message d’Apache ActiveMQ (NMS).
  • Spring.Messaging.EMS : Ce module est utilisé pour interagir avec le middleware chargé de la mise en file d’attente de message de Tibco Enterprise Message Service (EMS).
  • Spring.Web : Ce module est utiliser pour gérer l’écriture d’application web Asp .Net. Il permet en autre : la liaison et la validation des données et la configuration des modules , des pages , des controles et des providers.
  • Spring.Web.Mvc: Ce module permet d’intégrer les fonctionnalités des modules Spring.Core et Spring.Aop dans vos projets ASP.NET MVC 2.
  • Spring.Web.Mvc3: Ce module permet d’intégrer les fonctionnalités des modules Spring.Core et Spring.Aop dans vos projets ASP.NET MVC 3.
  • Spring.Web.Mvc4: Ce module permet d’intégrer les fonctionnalités des modules Spring.Core et Spring.Aop dans vos projets ASP.NET MVC 4.
  • Spring.Web.Mvc5: Ce module permet d’intégrer les fonctionnalités des modules Spring.Core et Spring.Aop dans vos projets ASP.NET MVC 5.
  • Spring.Web.Extensions: Ce module est utiliser pour gérer l’écriture d’application web Asp .Net. Il permet en autre : la liaison et la validation des données et la configuration des modules , des pages , des controles et des providers.
  • Spring.Services: Ce module est utiliser pour transformer les objets de la CLR dans un format de communication spécifique tel que .Net Remoting, Enterprise Services et ASMX Web Services. Ces services peuvent être configuré via l’injection de dépendance et « décorés » en utilisant l’AOP.
  • Spring.Testing.NUnit : Ce module est utilisé pour permettre l’intégration de tests unitaires avec NUnit.
  • Spring.Testing.MSTest : Ce module est utilisé pour permettre l’intégration de tests unitaires avec MSTest.
  • Spring.Scheduling.Quartz : Ce module permet d’interagir avec l’infrastructure de planification de travaux : Quartz.NET

Le module Spring.Core comprend également les fonctionnalités supplémentaires suivantes :

  • Expression Language: Permet d’interroger et de manipuler efficacement des objets graphiques au moment de l’exécution.
  • Validation Framework : il s’agit un famework robuste indépendant de l’interface utilisateur permettant de créer des règles de validation de données complexes pour les objets métier soit par programmation, soit en mode déclaratif.
  • Data binding Framework : Il s’agit d’un framework indépendant de l’interface utilisateur permettant d’effectuer la liaison de données.
  • Threading : Fournit une abstration de la gestion de la concurrence tels que les latches , les sémaphores et la mémoire local de thread (Thread Local Storage).
  • Resource abstraction : fournit une interface commune pour traiter le InputStream à partir d’un fichier et d’une URL indépendamment du protocole.

2-2 Les scénarios d’utilisations

Grace au différents modules décrits précédemment, vous pouvez utiliser Spring dans toutes sortes de scénarios : des simples applications de console autonomes aux applications d’entreprise à part entière en utilisant la fonctionnalité de gestion des transactions de Spring et l’intégration du framework Web.

Il est important de comprendre que Spring ne vous oblige à utiliser toute sa boite à outil, vous êtes libre d’utiliser ses composants comme vous plait. Ce n’est pas une solution tout en un ! Elle est modulable et c’est tout son intérêt. Les composants déjà existant dans ASP.Net Standard peuvent être parfaitement intégré à un niveau intermédiaire basé sur Spring.par exemple vous pouvez uniquement utiliser les fonctionnalités les transactions et d’accès aux bases de données offertes par Spring. L’unique chose à faire est de cabler votre logique métier à l’aide de votre conteneur de dépendance IOCet de l’intégrer à votre couche web à l’aide WebApplicationContext pour localiser les services de niveau intermédiaire et configurer vos pages ASP .net standard avec l’injection de dépendance.

Important : Bien que le framework Spring ne force aucune architecture d’application particulière, il encourage l’utilisation d’une architecture d’application en couches avec des niveaux distincts pour : la présentation, le service, l’accès aux données et la base de données.

2-3 Les projets associés à Spring .Net

Il existe de nombreux projet gravitant autour de Spring.Net et qui l’enrichissent.

On peut citer par exemple :

  • Spring.NET CodeConfig (http://springframework.net/codeconfig/) : Ce projet permet de configurer un conteneur Spring en utilisant du code .Net au lieu de fichier de configuration XML.
  • Spring.NET REST Client (http://springframework.net/rest/) : Ce projet simplifie la communication avec le serveur HTTP et applique les principes du RestFull. Il gère les connexions HTTP, gère les url au travers du code .Net et en extrait un résultat. Ce projet est utilisé pour développer des API Rest à l’aide de Spring.Net.
  • Spring.NET AMQPhttp://springframework.net/amqp/) : Ce projet prend en charge la programmation Spring avec AMQP dont par exemple RabbitMQ mais s’en s’y limiter.
  • Spring.NET Visual Studio Add-In (http://springframework.net/vsaddin/) : Ce projet fournit une assistance intellisense pour la création de fichiers de configuration Spring XML dans Visual Studio 2010.

2-4 La licence Spring.Net

Spring.Net utilise la licence open source Apache 2 qui est la suivante :

Apache License

Version 2.0, January 2004

http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

« License » shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.

« Licensor » shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.

« Legal Entity » shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, « control » means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.

« You » (or « Your« ) shall mean an individual or Legal Entity exercising permissions granted by this License.

« Source » form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.

« Object » form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.

« Work » shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).

« Derivative Works » shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.

« Contribution » shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, « submitted » means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as « Not a Contribution.« 

« Contributor » shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:

  1. You must give any other recipients of the Work or Derivative Works a copy of this License; and
  2. You must cause any modified files to carry prominent notices stating that You changed the files; and
  3. You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
  4. If the Work includes a « NOTICE » text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.

    You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an « AS IS » BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

3 – Les technologies Core

3-1 Le conteneur d’inversion de contrôle (IOC)

3-1-1 Présentation

Le présent chapitre couvre la mise en œuvre dans le Framework de l’implémentation de l’inversion du contrôle (IoC).

L’assemblage Spring.Core est la base du conteneur IoC de Spring.NET. L’interface IObjectFactory fournit un mécanisme de configuration avancé capable de gérer n’importe quel type d’objet. IApplicationContext est une sous-interface d’IObjectFactory. Il ajoute une intégration facile aux fonctionnalités de programmation orientée aspect (AOP) de Spring.NET, la gestion des ressources de messages (pour une utilisation dans l’internationalisation), la propagation d’événements et le contexte spécifique à la couche d’application tels que WebApplicationContext pour une utilisation dans les applications Web.

En résumé, IObjectFactory fournit la configuration et les fonctionnalités de base, et IApplicationContext ajoute des fonctionnalités d’entreprise plus spécifiques. IApplicationContext est un superset complet d’ ObjectFactory et est utilisé exclusivement dans ce chapitre pour les descriptions du conteneur IoC de Spring.

3-2-2 Aperçu du conteneur d’inversion de contrôle

L’interface IApplicationContext représente le conteneur IoC de Spring.Net et est responsable de l’instanciation, de la configuration et de l’assemblage de nombreux objets de votre application. Le conteneur obtient ses instructions sur les objets à instancier, à configurer et à assembler en lisant les métadonnées de configuration.

Plusieurs implémentations de l’interface IApplicationContext sont fournis de base avec Spring. Dans une application autonome, il est courant de créer une instance d’un XmlApplicationContext par programmation ou par configuration déclarative dans le fichier d’application App.config.

Le diagramme suivant est une réprésentation de haut niveau du fonctionnement de Spring. Vos classes d’application sont combinées avec des métadonnées de configuration de sorte qu’après la création et l’initialisation de l’application, vous disposez d’un système ou d’une application entièrement configuré et exécutable.

3-2-3 Les métadonnées de configuration

Comme le montre le diagramme précédent, le conteneur IoC de Spring consomme des métadonnées de configuration. La configuration de Spring se compose d’un certain nombre de définitions d’objet que le conteneur doit gérer.

Ces définitions d’objets correspondent aux objets réels qui composent votre application. Vous définissez généralement des objets de la couche de service, des objets d’accès aux données (DAO), des objets de présentation tels que des instances de page ASP.Net, des objets d’infrastructure tels que les fabriques de session NHibernate etc. En règle générale, on ne configure pas les objets de domaine dans le conteneur.Il est en effet généralement de la responsabilité des DAO et de la logique métier de créer/charger des objets de domaine.

L’exemple suivant montre la structure de base des métadonnées de configuration XML :

<objects xmlns="http://www.springframework.net">

  <object id="..." type="...">
    <!-- collaborators and configuration for this object go here -->
  </object>

  <object id="...." type="...">
    <!-- collaborators and configuration for this object go here -->
  </object>
 
  <!-- more object definitions go here -->

</objects>

L’attribut id est une chaîne de caractères que vous utilisez pour identifier la définition d’objet individuel. L’attribut de type définit le type de l’objet et utilise le nom de type entièrement qualifié, y compris le nom de l’assemblage. La valeur de l’attribut id fait référence aux objets collaborateurs.

Spring.Net est livré avec un schéma XSD pour rendre la validation des définitions d’objets XML beaucoup plus facile. Le document XSD est soigneusement documenté. Le XSD est actuellement utilisé dans le code d’implémentation pour valider le document XML. Le schéma XSD sert un double objectif en ce sens qu’il facilite également l’édition des définitions d’objets XML à l’intérieur d’un éditeur prenant en charge XSD tel que Visual Studio (validation et prise en charge Intellisense).

3-2-4 Instanciation du conteneur d’inversion de contrôle

L’instanciation d’un conteneur IoC sous Spring est simple. Le chemin d’accès fourni en paramètre du constructeur IApplication est en fait une chaîne de ressource permettant au conteneur de charger les métadonnées de configuration à partir d’une variété de ressources externes tels que : un système de fichier locale, des ressources d’assemblage intégrés et ainsi de suite …

IApplicationContext context = new XmlApplicationContext("services.xml", "data-access.xml");

L’exemple suivant montre la configuration de la couche objet des service (Fichier services.xml).

<objects xmlns="http://www.springframework.net"> 

  <object id="PetStore" type="PetStore.Services.PetStoreService, PetStore">
    <property name="AccountDao" ref="AccountDao"/>
    <property name="ItemDao" ref="ItemDao"/>
    <!-- additional collaborators and configuration for this object go here -->
  </object>

  <!-- more object definitions for services go here -->

</objects>

L’exemple suivant montre le fichier de configuration des objets d’accès au données (Fichier dao.xml):

<objects xmlns="http://www.springframework.net"> 

  <object id="AccountDao" type="Petstore.Dao.HibernateAccountDao, PetStore">
    <!-- additional collaborators and configuration for this object go here -->
  </object>

  <object id="ItemDao" type="Petstore.Dao.HibernateItemDao, PetStore">
    <!-- additional collaborators and configuration for this object go here -->
  </object>
  
  <!-- more object definitions for data access objects go here -->
</objects>

3-2-5 Chargement des métadonnées de configuration à partir d’emplacements de ressources non définis par défaut

Dans l’exemple précédent, les ressources de configuration sont supposées être situées dans le répertoire bin\Debug. Vous pouvez utiliser l’interface IResource de Spring pour charger des ressources à partir d’autres emplacements.

L’exemple suivant montre comment créer un conteneur IoC faisant référence aux ressources situées dans le répertoire racine du système de fichiers en tant que ressource d’assemblage embarqué.

IApplicationContext context = new XmlApplicationContext(
                 "file:///services.xml",
                 "assembly://MyAssembly/MyDataAccess/data-access.xml");

L’interface IResource fournit une interface simple et uniforme à un large éventail de ressources IO qui peuvent se représenter elles-mêmes en tant que System.IO.Stream. Ces ressources sont le plus souvent des fichiers ou des URL, mais peuvent également être des ressources qui ont été embarqué à l’intérieur d’un assemblage .NET. Une syntaxe URI simple est utilisée pour décrire l’emplacement de la ressource. Il existe des conventions standard comme par exemple pour les fichiers , par exemple : file:///services.xml et d’autres protocoles bien connus tels que http.

L’extrait suivant montre l’utilisation de la syntaxe URI afin de référencer une ressource qui a été incorporée à l’intérieur d’un assemblage .NET à savoir :

assembly://<AssemblyName>/<NameSpace>/<ResourceName>.

Pour créer une ressource incorporée à l’aide de Visual Studio, vous devez définir l’action de génération du fichier de configuration .xml sur Ressource incorporée dans l’éditeur de propriétés de fichier.

3-2-6 Configuration déclarative du conteneur depuis le fichier App.config ou Web.config

Vous pouvez également créer un conteneur à l’aide d’une section de configuration personnalisée dans le fichier de configuration d’une application .NET(soi App.config soit Web.config).

La section de configuration suivante permet de créer le même IApplicationContext que dans l’exemple précédent :

<spring>
  <context>
    <resource uri="file://services.xml"/>
    <resource uri="assembly://MyAssembly/MyDataAccess/data-access.xml"/>
  </context>
</spring> 

Le contexte type (spécifié comme valeur de l’attribut type de l’élément de contexte) est facultatif. Dans une application autonome, le type de contexte par défaut est la classe Spring.Context.Support.XmlApplicationContext et dans une application Web, le type de contexte par défaut est la classe WebApplicationContext.

Voici un exemple de configuration explicite :

<spring>
  <context type="Spring.Context.Support.XmlApplicationContext, Spring.Core">
    <resource uri="file:///services.xml"/>
    <resource uri="assembly://MyAssembly/MyDataAccess/data-access.xml"/>
  </context>
</spring>

Pour récupérer une référence d’IApplicationContext à partir d’une section de configuration personnalisée, on utilise simplement le code suivant:

IApplicationContext ctx = ContextRegistry.GetContext();

Le ContextRegistry est utilisé à la fois pour instancier le contexte d’application et pour effectuer le chargement des services des sifférents objets. Ce qui rend cela possible est une implémentation de l’interface IConfigurationSectionHandler fournie par la bibliothèque de classes de base (BCL), à savoir la classe Spring.Context.Support.ContextHandler. La classe de gestionnaire doit être enregistrée dans la section configSections du fichier de configuration .NET comme indiqué ci-dessous.

<configSections>
  <sectionGroup name="spring">
    <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core"/>
  </sectionGroup>
</configSections>


ette déclaration permet désormais d’utiliser une section de contexte personnalisée à partir de l’élément racine de Spring.

Dans certains scénarios d’utilisation, le code utilisateur n’aura pas à instancier explicitement une interface IApplicationContext d’implémentation appropriée, car le code Spring.NET le fera pour vous. Par exemple, la couche Web ASP.NET fournit un code de prise en charge pour charger automatiquement un Spring.NET WebApplicationContext dans le cadre du processus de démarrage normal d’une application Web ASP.NET. En tant que tel, une fois que le conteneur a été créé pour vous, il arrive souvent que vous n’ayez plus jamais besoin d’interagir explicitement avec lui dans votre code, par exemple lors de la configuration de pages ASP.NET.

Vos définitions d’objet XML peuvent également être définies dans le fichier de configuration d’application .NET en enregistrant la classe Spring.Context.Support.DefaultSectionHandler en tant que gestionnaire de section de configuration lors de la définition des objets. Cela vous permet de configurer complètement une ou plusieurs instances IApplicationContext dans un seul fichier de configuration d’application .NET , comme l’illustre l’exemple suivant:

<configuration>

  <configSections>
    <sectionGroup name="spring">
      <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core"/>
      <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core" />
    </sectionGroup>
  </configSections>

  <spring>

    <context>
      <resource uri="config://spring/objects"/>
    </context>
       
    <objects xmlns="http://www.springframework.net">
        ...
    </objects>

  </spring>

</configuration>

3-2-5 Utilisation du conteneur

IApplicationContext est l’interface d’une fabrique avancée capable de maintenir un registre de différents objets et de leurs dépendances.

IApplicationContext vous permet de lire les définitions d’objets et d’y accéder comme suit:

// create and configure objects
IApplicationContext context = new XmlApplicationContext("services.xml", "daos.xml");

// retrieve configured instance
PetStoreService service = (PetStoreService) context.GetObject("PetStoreService");

// use configured instance
IList userList = service.GetUserNames();

Vous utilisez la méthode GetObject pour récupérer des instances de vos objets. L’interface IApplicationContext possède quelques autres méthodes pour récupérer des objets.Cependant votre code d’application ne devrait jamais les utiliser. En effet, votre code d’application ne doit avoir aucun appel à la méthode GetObject, et donc aucune dépendance vis-à-vis des API Spring. Par exemple, l’intégration de Spring avec les frameworks Web permet l’injection de dépendances pour diverses classes de framework Web telles que les pages ASP.NET et les contrôles utilisateur.