 | | | + title | Ref. /chapter[1]/title[1] |
| | Original | Traduction | | Introduction |
|
sect1
| | | + title | Ref. /chapter[1]/sect1[1]/translation[1] |
| | Original | Traduction | | Overview | Vue d'ensemble |
| | + para | Ref. /chapter[1]/sect1[1]/translation[2] |
| | Original | Traduction | |
Spring contains a lot of functionality and features, which are
well-organized in seven modules shown in the diagram below.
This section discusses each the of modules in turn.
| Spring contient un grand nombre de fonctionnalités et de dispositifs, qui
sont bien organisés dans sept modules comme décrit sur le diagramme
suivant. Cette section décrit chaque module à tour de rôle.
|
| | + para | Ref. /chapter[1]/sect1[1]/para[1]/mediaobject[1]/caption[1]/translation[1] |
| | Original | Traduction | | Overview of the the Spring Framework
| Vue d'ensemble du framework Spring
|
| | + para | Ref. /chapter[1]/sect1[1]/translation[3] |
| | Original | Traduction | |
The Core package is the most fundamental part of the framework and
provides the Dependency Injection features allowing you to manage
bean container functionality. The basic concept here is the
BeanFactory, which provides a factory pattern removing the need for
programmatic singletons and allowing you to decouple the configuration
and specification of dependencies from your actual program logic.
| Le package Core est la partie la plus fondamentale
du framework et fournit la fonctionnalité Injection de Dépendance, vous permettant
de gérer le conteneur de beans. Le concept de base ici est la BeanFactory qui
fournit une implémentation dy pattern fabrique tout en supprimant la nécessité
de programmer des singletons et permettent de découpler la configuration et la
spécification des dépendances de la logique applicative elle-même.
|
| | + para | Ref. /chapter[1]/sect1[1]/translation[4] |
| | Original | Traduction | |
On top of the Core package sits the
Context package,
providing a way to access beans in a framework-style manner,
somewhat resembling a JNDI-registry. The context package inherits
its features from the beans package and adds support for text
messaging using e.g. resource bundles,
event-propagation, resource-loading and transparent
creation of contexts by, for example, a servlet container.
| Au sommet du package Core se trouve le
package Context, fournissant un moyen d'accéder
aux beans à la manière d'un framework ressemblant à un registre JNDI.
Le package context hérite des fonctionnalités du package beans et
ajoute le support des messages (i.e. "resource bundles"), la propagation
d'événements, le chargement des ressourceset la création transparente
de contextes, par exemple, par un conteneur de servlets.
|
| | + para | Ref. /chapter[1]/sect1[1]/translation[5] |
| | Original | Traduction | |
The DAO package provides a JDBC-abstraction
layer that removes the need to do tedious JDBC coding and parsing
of database-vendor specific error codes.
Also, the JDBC package provides a way to do
programmatic as well as declarative transaction
management, not only for classes implementing special interfaces,
but for all your POJOs (plain old java objects).
| Le package DAO fournit un niveau d'abstraction
à JDBC qui supprime le besoin de code JDBC pénible et de gérer les codes
erreurs spécifiques aux bases de données. De plus, le package JDBC fournit
un moyen de gérer les transactions de manière déclarative ou par la
programmation pas seulement pour les classes implémentant des interfaces
spécifiques mais pour tous les POJOs (plain old java objects).
|
| | + para | Ref. /chapter[1]/sect1[1]/translation[6] |
| | Original | Traduction | |
The ORM package provides integration layers
for popular object-relational mapping APIs, including JDO, Hibernate
and iBatis. Using the ORM package you can use all those O/R-mappers
in combination with all the other features Spring offers, like
simple declarative transaction management mentioned before.
| Le package ORM fournit des niveaux d'abstraction
pour l'intégration des outils populaires de mappage objet-relationnel
comme JDO, Hibernate et iBatis. En utilisant le package ORM, vous pouvez
utiliser tous ces outils en combinaison de toutes les autres fonctionnalités
qu'offre Spring, comme notamment la gestion déclarative des transactions
mentionnée précédemment.
|
| | + para | Ref. /chapter[1]/sect1[1]/translation[7] |
| | Original | Traduction | |
Spring's AOP package provides an
AOP Alliance compliant aspect-oriented
programming implementation allowing you to define, for example,
method-interceptors and pointcuts to cleanly decouple code
implementing functionality that should logically speaking be separated.
Using source-level metadata functionality you can
incorporate all kinds of behavioral information into your code,
a little like .NET attributes.
| Le package AOP de Spring fournit une
implémentation de la programmation orientée aspect conforme à
AOP Alliance qui permet par exemple, de définir
des intercepteurs de méthodes et des points de jonction en découplant
proprement le code fonctionnel qui devrait être bien séparé.
En utilisant les annotations au niveau des sources, il est possible
d'intégrer toute sorte d'informations dans le code, un peu comme
avec les attributs .Net.
|
| | + para | Ref. /chapter[1]/sect1[1]/translation[8] |
| | Original | Traduction | |
Spring's Web package provides basic
web-oriented integration features, such as multipart functionality,
initialization of contexts using servlet listeners and
a web-oriented application context. When using
Spring together with WebWork or Struts, this is the package to
integrate with.
| Le package Web de Spring fournit des
fonctionnalités d'intégration de base pour les applications web
comme la gestion des requêtes multipart,
l'initialisation des contextes en utilisant les listeners des
servlets et un contexte d'application orienté web. Pour utiliser
Spring avec WebWork ou Struts, il est indispensable d'intégrer
ce package.
|
| | + para | Ref. /chapter[1]/sect1[1]/translation[9] |
| | Original | Traduction | |
Spring's Web MVC package provides a
Model-View-Controller implementation for web-applications.
Spring's MVC implementation is not just any implementation,
it provides a clean separation between domain model code and
web forms and allows you to use all the other features of the Spring
Framework like validation.
| Le package Web MVC de Spring fournit
une implémentation Model-View-Controller pour les applications web.
Spring MVC n'est pas une implémentation comme les autres, car elle
fournit une séparation nette entre le code du modèle et les
formulaires web et permet d'utiliser toutes les autres fonctionnalités
du framework Spring comme la validation.
|
| |
sect1
| | | + title | Ref. /chapter[1]/sect1[2]/translation[1] |
| | Original | Traduction | | Usage scenarios | Scenarios d'utilisation |
| | + para | Ref. /chapter[1]/sect1[2]/translation[2] |
| | Original | Traduction | |
With the building blocks described above you can use Spring in all sorts
of scenarios, from applets up to fully-fledged enterprise applications
using Spring's transaction management functionality and Web framework.
| Avec les modules décrits ci-dessus, il est possible d'utiliser
Spring dans toute sorte de scénarios allant des applets aux applications
d'entreprise complexes utilisant la fonctionnalité de gestion des transaction
de Spring et le framework web.
|
| | + para | Ref. /chapter[1]/sect1[2]/para[1]/mediaobject[1]/caption[1]/translation[1] |
| | Original | Traduction | | Typical full-fledged Spring web application
| Application web typique basée sur Spring
|
| | + para | Ref. /chapter[1]/sect1[2]/translation[3] |
| | Original | Traduction | |
A typical web application using most of Spring's features. Using
TransactionProxyFactoryBeans the web application is fully transactional,
just as it would be when using container managed transaction as provided by Enterprise
JavaBeans. All your custom business logic can be implemented using simple POJOs, managed
by Spring's Dependency Injection container. Additional services such as sending email and
validation, independent of the web layer enable you to choose where to execute
validation rules. Spring's ORM support is integrated with Hibernate, JDO and iBatis. Using
for example HibernateDaoSupport, you can re-use your existing Hibernate
mappings. Form controllers seamlessly integrate the web-layer with the domain model, removing
the need for ActionForms or other classes that transform
HTTP parameters to values for your domain model.
| Une application web typique utilise la plupart des fonctionnalités de
Spring. En utilisant TransactionProxyFactoryBeans, l'application
web est complètement transactionnelle comme elle l'aurait été en utilisant les
transactions gérées par le conteneur des EJBs. Toute la logique métier peut être
implémentée en utilisant des POJOs simples gérés par le conteneur d'Injection
de Dépendance de Spring.
Des services additionnels comme l'envoi de messages et la validation, indépendante de
la couche web, permettent de choisir quand exécuter les règles de validation.
Le support de Spring pour les ORMs est intégré avec Hibernate, JDO, iBatis. En utilisant,
par exemple, HibernateDaoSupport, il est possible de réutiliser vos
mappages existants. Les controleurs de formulaires s'intègrent de manière transparentes
dans la couche web avec le modèle, supprimant de ce fait le besoin d'ActionForms
ou d'autres classes transformant les paramètres HTTP en valeurs disponibles pour le modèle.
|
| | + para | Ref. /chapter[1]/sect1[2]/para[2]/mediaobject[1]/caption[1]/translation[1] |
| | Original | Traduction | | Spring middle-tier using a third-party web framework
| Le tier utilisant Spring et basé le framework web
|
| | + para | Ref. /chapter[1]/sect1[2]/translation[4] |
| | Original | Traduction | |
Sometimes the current circumstances do not allow you to
completely switch to a different framework. Spring does
not force
you to use everything within it; it's not an all-or-nothing
solution. Existing frontends using WebWork, Struts, Tapestry,
or other UI frameworks can be integrated perfectly well with
a Spring-based middle-tier,
allowing you to use the transaction features that Spring
offers. The only thing you need to do is wire up your business
logic using an ApplicationContext and
integrate your Web UI layer using a
WebApplicationContext.
| Parfois, il arrive qu'il soit impossible de complètement
changer de framework. Spring ne force en aucun cas, l'utilisation
complète du framework; il ne s'agit pas d'une solution tout ou rien.
Des frameworks de présentation utilisant WebWork, Struts, Tapestry
ou autre peuvent être parfaitement intégrer avec un tier métier basé
sur Spring et permettant ainsi d'utiliser les fonctionnalités
transactionnelles offertes par Spring. La seule chose qui doit être
faite, est de récupérer la logique métier en utilisant un ApplicationContext
et de l'intégrer à la couche de présentation web en utilisant
WebApplicationContext.
|
| | + para | Ref. /chapter[1]/sect1[2]/para[3]/mediaobject[1]/caption[1]/translation[1] |
| | Original | Traduction | | Remoting usage scenario
| Scenario d'utilisation de la rupture de protocole
|
| | + para | Ref. /chapter[1]/sect1[2]/translation[5] |
| | Original | Traduction | |
When you need to access existing code via webservices, you can use
Spring's Hessian-,
Burlap-, Rmi- or JaxRpcProxyFactory classes.
Enabling remote access to existing application is all of a sudden not that hard anymore.
| Quand il est nécessaire d'accéder à du code existant via des
services web, il est possible d'utiliser les classes Hessian-,
Burlap-, Rmi- or JaxRpcProxyFactory.
Utiliser l'accès distant dans une application existante n'est pas plus difficile
que cela.
|
| | + para | Ref. /chapter[1]/sect1[2]/para[4]/mediaobject[1]/caption[1]/translation[1] |
| | Original | Traduction | | EJBs - Wrapping existing POJOs
| EJBs - Envelopper des POJOs existants
|
| | + para | Ref. /chapter[1]/sect1[2]/translation[6] |
| | Original | Traduction | |
Spring also provides an access layer and abstraction layer for Enterprise JavaBeans,
enabling you to reuse your existing POJOs and wrap them in Stateless Session Beans,
for use in scalable failsafe web applications, that might need declarative security.
| Spring fournit également une couche d'accès et un niveau d'abstraction pour les EJBs,
permettant d'utiliser les POJOs existants et de les envelopper dans des Beans Session sans
Etat, pour un usage dans des applications web scalables et résistantes aux erreurs qui
nécessitent de la sécurité déclarative.
|
| |
|
