java - À quoi sert exactement Spring Framework?


J'entends beaucoup parler du printemps , les gens disent partout sur le web que le printemps est un bon cadre pour le développement web. À quoi sert exactement Spring Framework? Comment puis-je l'utiliser pour mon développement d'application Web-Java? des exemples?



Answers



Fondamentalement Spring est un framework pour l' injection de dépendances qui est un modèle qui permet de construire des systèmes très découplés.

Le problème

Par exemple, supposons que vous deviez lister les utilisateurs du système et ainsi déclarer une interface appelée UserLister :

public interface UserLister {
    List<User> getUsers();
}

Et peut-être une implémentation accédant à une base de données pour obtenir tous les utilisateurs:

public class UserListerDB implements UserLister {
    public List<User> getUsers() {
        // DB access code here
    }
}

À votre avis, vous aurez besoin d'accéder à une instance (juste un exemple, rappelez-vous):

public class SomeView {
    private UserLister userLister;

    public void render() {
        List<User> users = userLister.getUsers();
        view.render(users);
    }
}

Notez que le code ci-dessus n'a pas initialisé la variable userLister . Que devrions nous faire? Si j'instancie explicitement l'objet comme ceci:

UserLister userLister = new UserListerDB();

... Je couplerais la vue avec mon implémentation de la classe qui accède à la DB. Que faire si je veux passer de l'implémentation DB à une autre qui récupère la liste des utilisateurs à partir d'un fichier séparé par des virgules (rappelez-vous, c'est un exemple)? Dans ce cas, je retournerais à mon code et changerais la dernière ligne par:

UserLister userLister = new UserListerCommaSeparatedFile();

Cela n'a aucun problème avec un petit programme comme celui-ci mais ... Ce qui se passe dans un programme qui a des centaines de vues et un nombre similaire de classes d'affaires. La maintenance devient un cauchemar!

L'approche du printemps (injection de dépendances)

Ce que fait Spring est de câbler les classes en utilisant un fichier XML, de cette façon tous les objets sont instanciés et initialisés par Spring et injectés aux bons endroits (Servlets, Web Frameworks, Business classes, DAO, etc, etc., etc.). .).

Pour en revenir à l'exemple de Spring, nous avons juste besoin d'un setter pour le champ userLister et d'un XML comme ceci:

<bean id="userLister" class="UserListerDB" />

<bean class="SomeView">
    <property name="userLister" ref="userLister" />
</bean>

De cette façon, lorsque la vue est créée, elle aura magiquement un UserLister prêt à fonctionner.

List<User> users = userLister.getUsers();  // This will actually work
                                           // without adding any line of code

C'est super! N'est-ce pas?

  • Que faire si vous voulez utiliser une autre implémentation de votre interface UserLister ? Changez simplement le XML
  • Que faire si une implémentation UserLister n'est pas prête? Programmer une implémentation UserLister temporelle de UserLister et faciliter le développement de la vue
  • Que faire si je ne veux plus utiliser Spring? Ne l'utilisez pas! Votre application n'est pas couplée. Inversion of Control indique: "L'application contrôle le framework, et non le framework contrôle l'application".

Il y a d'autres options pour Dependency Injection, ce qui à mon avis a rendu Spring si célèbre en plus de sa simplicité, son élégance et sa stabilité, les gars de SpringSource ont programmé beaucoup de POJOs qui aident à intégrer Spring avec beaucoup d'autres frameworks communs sans être intrusif dans votre application. Spring a également plusieurs bons sous-projets tels que Spring MVC, Spring WebFlow, Spring Security et encore une liste d'etcetera.

J'espère que cela t'aides. Quoi qu'il en soit, je vous encourage à lire l'article de Martin Fowler sur l'injection de dépendance et l'inversion du contrôle parce qu'il le fait mieux que moi. Après avoir compris les bases, jetez un coup d'oeil à la documentation de printemps , à mon avis, il est utilisé pour être le meilleur livre de printemps.




Spring contient ( comme Skaffman l'a souligné à juste titre ) un framework MVC. Pour expliquer en un mot, voici mes entrées. Spring prend en charge la ségrégation de la couche de service, de la couche Web et de la couche de gestion, mais ce qu'elle fait de mieux, c'est "l'injection" d'objets. Donc, pour expliquer cela avec un exemple, considérons l'exemple ci-dessous:

public interface FourWheel
{
   public void drive();
}

public class Sedan implements FourWheel
{
   public void drive()
   {
      //drive gracefully
   }
}

public class SUV implements FourWheel
{
   public void drive()
   {
      //Rule the rough terrain
   }
}

Maintenant, dans votre code, vous avez une classe appelée RoadTrip comme suit

public class RoadTrip
{
    private FourWheel myCarForTrip;
}

Maintenant, quand vous voulez une instance de Trip; parfois vous pouvez vouloir un SUV pour initialiser FourWheel ou parfois vous pouvez vouloir Sedan. Cela dépend vraiment de ce que vous voulez en fonction de la situation spécifique.

Pour résoudre ce problème, vous voudriez avoir un motif d'usine comme motif de création. Où une usine renvoie la bonne instance. Donc, finalement, vous finirez avec beaucoup de code de la colle juste pour instancier les objets correctement. Le printemps fait le travail du code de colle sans ce code de colle. Vous déclarez les mappages en XML et initialisez automatiquement les objets. Il fait également beaucoup en utilisant l'architecture singleton pour les instances et cela aide à optimiser l'utilisation de la mémoire.

Ceci est également appelé Inversion Of Control. D'autres cadres pour ce faire sont Google guice, conteneur Pico etc.

En dehors de cela, Spring dispose d'un cadre de validation, un support étendu pour la couche DAO en collaboration avec JDBC, iBatis et Hibernate (et bien d'autres). Fournit un excellent contrôle transactionnel sur les transactions de base de données.

Il y a beaucoup plus au printemps qui peut être lu dans de bons livres comme "Pro Spring".

Les URL suivantes peuvent également être utiles.
http://static.springframework.org/docs/Spring-MVC-step-by-step/
http://en.wikipedia.org/wiki/Spring_Framework
http://www.theserverside.com/tt/articles/article.tss?l=SpringFramework




À quoi sert le printemps? Je vais répondre à cette question sous peu, mais d'abord, jetons un autre regard sur l'exemple de Victor Hugo. Ce n'est pas un bon exemple, car cela ne justifie pas la nécessité d'un nouveau cadre.

public class BaseView {
  protected UserLister userLister;

  public BaseView() {
    userLister = new UserListerDB(); // only line of code that needs changing
  }
}

public class SomeView extends BaseView {
  public SomeView() {
    super();
  }

  public void render() {
    List<User> users = userLister.getUsers();
    view.render(users);
  }
}

Terminé! Alors maintenant, même si vous avez des centaines ou des milliers de vues, vous avez juste besoin de changer la ligne de code, comme dans l'approche Spring XML. Mais changer une ligne de code nécessite encore une recompilation, par opposition à l'édition de XML que vous dites? Eh bien mon ami difficile, utilisez Ant et le script loin!

Alors à quoi sert le printemps? C'est pour:

  1. Les développeurs aveugles qui suivent le troupeau
  2. Les employeurs qui ne veulent jamais embaucher des programmeurs diplômés parce qu'ils n'enseignent pas de tels cadres à Uni
  3. Des projets qui ont commencé avec un mauvais design et qui ont besoin de patchwork (comme le montre l'exemple de Victor Hugo)

Pour en savoir plus: http://discuss.joelonsoftware.com/?joel.3.219431.12




Les vieux jours, le printemps était un travail de base d'injection de dépendance seulement comme ( Guice , PicoContainer , ...), mais maintenant un jour c'est une solution totale pour construire votre application d'entreprise .

L'injection de dépendance au printemps, qui est bien sûr le cœur du printemps, est toujours là (et vous pouvez passer en revue d'autres bonnes réponses ici), mais il y en a d'autres à partir du printemps ....

Le printemps a maintenant beaucoup de projets, chacun avec quelques sous-projets ( http://spring.io/projects ). Quand quelqu'un parle du printemps, vous devez savoir de quel projet de printemps il parle, est-il seulement le noyau de printemps, qui est connu comme le cadre de printemps , ou c'est un autre projet de printemps.

Certains projets de printemps qui méritent d'être mentionnés sont:

Si vous avez besoin de plus de fonctionnalités pour votre application, vous pouvez le trouver aussi:

  • cadre de lot lot de printemps conçu pour permettre le développement de
    application par lots
  • spring HATEOAS création facile de base REST api sur HATEOAS principal
  • ressort mobile et ressort andriod pour le développement d'applications mobiles
  • Spring Shell construit une application shell complète (aka ligne de commande)
  • nuage de printemps et flux de données de nuage de printemps pour les applications de cloud

Il y a aussi quelques petits projets par exemple spring-social-facebook ( http://projects.spring.io/spring-social-facebook/ )

Vous pouvez utiliser le printemps pour le développement web car il a le module Spring MVC qui fait partie du projet de cadre de printemps . Ou vous pouvez utiliser le printemps avec un autre travail de trame web, comme struts2 .




Très court résumé, je dirai que le printemps est la "colle" dans votre application. Il est utilisé pour intégrer différents frameworks et votre propre code.




Le printemps est trois choses.

  1. Spring gère Dependency Injection et je vous recommande de lire l'excellente introduction de Martin Fowler sur l'injection de dépendance.
  2. La deuxième chose que Spring fait est de mettre en place d'excellentes bibliothèques Java d'une manière très élégante à utiliser dans vos applications. Pour un bon exemple, voyez comment Spring enveloppe les Task Executors et Quartz Scheduler.
  3. Troisièmement Spring fournit un tas d'implémentations de trucs web comme REST, un framework web MVC et plus encore. Ils comprennent que vous utilisez Spring pour les deux premiers, peut-être que vous pouvez simplement l'utiliser pour tout ce dont votre application web a besoin.

Le problème est que Spring DI est vraiment bien pensé, les wrappers autour d'autres choses sont vraiment bien pensés en ce sens que les autres choses ont pensé à tout et que Spring l'enveloppe bien. Les implémentations Spring de MVC et REST et toutes les autres choses ne sont pas aussi bien faites (YMMV, IMHO) mais il y a des exceptions (Spring Security is da bomb). J'ai donc tendance à utiliser Spring pour DI, et ses wrappers cool mais je préfère d'autres choses pour le Web (j'aime beaucoup Tapestry), REST (Jersey est vraiment robuste), etc.




Ce que vous voudriez probablement dans une application web avec Spring -

  • Spring MVC, qui avec 2.5+ vous permet d'utiliser les POJO comme classes de contrôleur, ce qui signifie que vous ne devez pas étendre à partir d'un framework particulier (comme dans Struts ou Spring pre-2.5). Les classes de contrôleurs sont aussi simples à tester grâce en partie à l'injection de dépendances
  • Intégration de printemps avec Hibernate, qui simplifie le travail avec cette solution ORM (dans la plupart des cas)
  • L'utilisation de Spring pour une application web vous permet d'utiliser vos objets de domaine à tous les niveaux de l'application - les mêmes classes qui sont mappées à l'aide d'Hibernate sont les classes que vous utilisez comme "beans de formulaire". Par nature, cela conduira à un modèle de domaine plus robuste, en partie parce qu'il va réduire le nombre de classes.
  • Les étiquettes de forme de ressort facilitent la création de formulaires sans trop de tracas.

En outre, le printemps est énorme - il y a donc beaucoup d'autres choses que vous pourriez vouloir utiliser dans une application Web comme Spring AOP ou Spring Security. Mais les quatre choses énumérées ci-dessus décrivent les composants communs de Spring qui sont utilisés dans une application Web.




Je vois deux parties à cela:

  1. "Qu'est-ce que le printemps est exactement pour" -> voir la réponse acceptée par Victor Hugo.
  2. "[...] Le printemps est [un] bon cadre pour le développement web" -> les gens disent que cela parle de Spring MVC. Spring MVC est l'une des nombreuses parties de Spring, et est un framework web qui utilise les fonctionnalités générales de Spring, comme l'injection de dépendance. C'est un framework assez générique en ce qu'il est très configurable: vous pouvez utiliser différentes couches de db (Hibernate, iBatis, plain JDBC), différentes couches de vue (JSP, Velocity, Freemarker ...)

Notez que vous pouvez parfaitement utiliser Spring dans une application web sans utiliser Spring MVC. Je dirais que la plupart des applications web Java le font, tout en utilisant d'autres frameworks web comme Wicket, Struts, Seam, ...




Le printemps est idéal pour coller des instances de classes ensemble. Vous savez que vos classes Hibernate auront toujours besoin d'une source de données, Spring les relie (et a aussi une implémentation de la source de données).

Vos objets d'accès aux données auront toujours besoin d'un accès Hibernate, Spring câblera les classes Hibernate dans vos DAO pour vous.

De plus, Spring vous donne essentiellement des configurations solides d'un tas de bibliothèques, et vous guide dans les librairies que vous devriez utiliser.

Le printemps est vraiment un excellent outil. (Je ne parlais pas de Spring MVC, juste le cadre de base).




Spring est une bonne alternative à la technologie Enterprise JavaBeans (EJB) . Il a également un cadre Web et un composant de cadre de services Web.




L'avantage est l' injection de dépendances (DI) . Cela signifie externaliser la tâche de création d'objet. Laissez-moi vous expliquer avec un exemple.

public interface Lunch
{
   public void eat();
}

public class Buffet implements Lunch
{
   public void eat()
   {
      // Eat as much as you can 
   }
}

public class Plated implements Lunch
{
   public void eat()
   {
      // Eat a limited portion
   }
}

Maintenant dans mon code j'ai une classe LunchDecide comme suit:

public class LunchDecide {
    private Lunch todaysLunch;
    public LunchDecide(){
        this.todaysLunch = new Buffet(); // choose Buffet -> eat as much as you want
        //this.todaysLunch = new Plated(); // choose Plated -> eat a limited portion 
    }
}

Dans la classe ci-dessus, en fonction de notre humeur, nous choisissons Buffet () ou Plated (). Cependant, ce système est étroitement couplé. Chaque fois que nous avons besoin d'un type d'objet différent, nous devons changer le code. Dans ce cas, commenter une ligne! Imaginez qu'il y ait 50 classes différentes utilisées par 50 personnes différentes. Ce serait un sacré bordel. Dans ce cas, nous devons découpler le système. Réécrivons la classe LunchDecide.

public class LunchDecide {
    private Lunch todaysLunch;
    public LunchDecide(Lunch todaysLunch){
        this.todaysLunch = todaysLunch
        }
    }

Notez qu'au lieu de créer un objet en utilisant un nouveau mot-clé, nous avons passé la référence à un objet de type déjeuner en tant que paramètre de notre constructeur. Ici, la création d'objet est externalisée. Ce code peut être câblé soit en utilisant le fichier de configuration Xml (ancien) ou Java Annotations (moderne). D'une manière ou d'une autre, la décision sur le type d'objet qui sera créé sera prise lors de l'exécution. Un objet serait injecté par Xml dans notre code - Notre code dépend de Xml pour ce travail. Par conséquent, l'injection de dépendance (DI). DI contribue non seulement à rendre notre système faiblement couplé, mais aussi à simplifier l'écriture de tests unitaires car il permet de se moquer des dépendances. Dernier point, mais non le moindre, DI simplifie la programmation orientée sur l'aspect (AOP), ce qui entraîne un découplage supplémentaire et une augmentation de la modularité. Notez également que ci-dessus DI est Constructor Injection. DI peut être fait aussi par Setter Injection - même méthode de setter vieille vieille de l'encapsulation.




La réponse acceptée n'implique pas l'utilisation des annotations depuis que Spring a pris en charge diverses annotations pour la configuration.

L'approche du printemps (injection de dépendances)

Il existe une autre façon de câbler les classes à côté d'un fichier XML: les annotations. Utilisons l'exemple de la réponse acceptée et enregistrons le bean directement dans la classe en utilisant la seule annotation @Bean :

@Bean
public class UserListerDB implements UserLister {
    public List<User> getUsers() {
        // DB access code here
    }
}

De cette façon, lorsque la vue est créée, elle aura magiquement un UserLister prêt à fonctionner.

La déclaration ci-dessus est valable avec un petit bonus d'aucun besoin d'utilisation de fichier XML et de câblage avec une autre annotation @Autowired qui trouve une implémentation pertinente et l'injecte dedans.

@Autowired
private UserLister userLister;



Le printemps a commencé comme un système d'injection de dépendance assez simple. Maintenant, il est énorme et a tout ce qu'il contient (à l'exception de l'évier de cuisine proverbiale).

Mais n'ayez pas peur, c'est assez modulaire pour que vous puissiez utiliser seulement les pièces que vous voulez.

Pour voir où tout a commencé, essayez:

http://www.amazon.com/Expert-One-Design-Development-Programmer/dp/0764543857/ref=sr_1_1?ie=UTF8&s=books&qid=1246374863&sr=1-1

Il pourrait être vieux mais c'est un excellent livre.

Pour un autre bon livre cette fois exclusivement consacré au printemps voir:

http://www.amazon.com/Professional-Java-Development-Spring-Framework/dp/0764574833/ref=sr_1_2?ie=UTF8&s=books&qid=1246374863&sr=1-2

Il fait également référence à des versions plus anciennes de Spring, mais vaut vraiment la peine d'être regardé.




Le printemps a été l'injection de dépendance au début, puis ajouter le roi des wrappers pour presque tout (wrapper sur les implémentations JPA, etc).

Longue histoire ... la plupart des parties de Spring preffer des solutions XML (moteur de script XML ... brrrr), donc pour DI j'utilise Guice

Bonne bibliothèque, mais avec depnedenciec croissant, par exemple Sprong JDBC (peut-être une solution Java jdbc avec des paramètres de noms réels) prendre de maven 4-5 ensuite.

Utiliser Spring MVC (partie de "big spring") pour le développement web ... c'est un framework "request based", il y a la guerre sainte "request vs component" ... à Toi