À quoi sert exactement Spring Framework? [fermé]

J'entends beaucoup parler de Spring , les gens disent partout sur le web que Spring est un bon cadre pour le développement web. À quoi sert exactement Spring Framework?

Fondamentalement, le printemps est un cadre pour dépendance-injection ce qui permet de construire des systèmes très découplés.

Le problème

Par exemple, supposons que vous deviez répertorier les utilisateurs du système et déclarer ainsi 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 devrez 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 base de données. Que faire si je veux passer de l'implémentation de la base de données à une autre qui obtient la liste des utilisateurs à partir d'un fichier séparé par des virgules (rappelez-vous, c'est un exemple)? Dans ce cas, j'irais à nouveau dans mon code et changerais la ligne ci-dessus en:

UserLister userLister = new UserListerCommaSeparatedFile();

Cela n'a aucun problème avec un petit programme comme celui-ci mais ... Que se passe-t-il dans un programme qui a des centaines de vues et un nombre similaire de classes affaires? L'entretien devient un cauchemar!

Approche Spring (Dependency Injection)

Ce que Spring fait est de câbler les classes en utilisant un fichier XML ou des annotations, 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., etc. ...).

Pour revenir à l'exemple de Spring, nous avons juste besoin d'avoir un setter pour le userListerchamp et d'avoir soit un fichier XML comme celui-ci:

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

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

ou plus simplement annotez le fichier déposé dans notre classe d'affichage avec @Inject:

@Inject
private UserLister userLister;

De cette façon, lorsque la vue est créée, elle aura comme par magie un UserListerprêt à fonctionner.

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

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

• Et si vous souhaitez utiliser une autre implémentation de votre UserListerinterface? Modifiez simplement le XML.
• Et si vous n'avez pas d' UserListerimplémentation prête? Programmer une implémentation temporelle simulée UserListeret faciliter le développement de la vue.
• Et si je ne veux plus utiliser Spring? Ne l'utilisez pas! Votre application n'y est pas associée. L'inversion du contrôle indique: "L'application contrôle le cadre, pas le cadre contrôle l'application".

Il y a d'autres options pour l'injection de dépendance autour de moi, ce qui à mon avis a rendu Spring si célèbre en plus de sa simplicité, de son élégance et de sa stabilité, c'est que les gars de SpringSource ont programmé de nombreux POJO qui aident à intégrer Spring avec de nombreux autres cadres communs sans être intrusif dans votre application. De plus, Spring a plusieurs bons sous-projets comme Spring MVC, Spring WebFlow, Spring Security et encore une longue liste de etceteras.

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 de contrôle car il le fait mieux que moi. Après avoir compris les bases, jetez un œil à la documentation Spring , à mon avis, elle est utilisée pour être le meilleur livre Spring jamais.

Spring contient ( comme Skaffman l'a souligné à juste titre ) un framework MVC. Pour expliquer en bref voici mes entrées. Spring prend en charge la séparation de la couche de service, de la couche Web et de la couche métier, mais ce qu'il fait le 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, chaque fois que vous voulez une instance de Trip; parfois, vous voudrez peut-être qu'un SUV initialise FourWheel ou parfois vous voudrez peut-être 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 retourne la bonne instance. Donc, vous finirez par vous retrouver avec beaucoup de code de colle juste pour instancier correctement les objets. Spring fait le travail du code de colle mieux sans ce code de colle. Vous déclarez des mappages en XML et cela initialisait automatiquement les objets. Il utilise également l'architecture singleton pour les instances et aide à optimiser l'utilisation de la mémoire.

Ceci est également appelé inversion de contrôle. D'autres cadres pour ce faire sont Google guice, Pico container, etc.

En dehors de cela, Spring a 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 à Spring 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

Autrefois , Spring était un cadre d'injection de dépendances fonctionnant uniquement comme ( Guice , PicoContainer , ...), mais de nos jours c'est une solution totale pour construire votre application d'entreprise .

L'injection de dépendance du printemps, qui est, bien sûr, le cœur du printemps est toujours là (et vous pouvez consulter d'autres bonnes réponses ici), mais il y en a plus 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-ce seulement le noyau de printemps, qui est connu sous le nom de charpente de printemps , ou c'est un autre projet de printemps.

Quelques projets printaniers qui méritent également d'être mentionnés sont:

• Spring Security - http://projects.spring.io/spring-security/
• Webservices de printemps - http://projects.spring.io/spring-ws/
• Intégration Spring - http://projects.spring.io/spring-integration/

Si vous avez besoin d'une fonctionnalité plus précise pour votre application, vous pouvez également la trouver ici:

• Cadre de traitement par lots de Spring Batch conçu pour permettre le développement d'
  applications par lots
• Spring HATEOAS création facile d'API REST basée sur le principal HATEOAS
• Spring Mobile et Spring Andriod pour le développement d'applications mobiles
• Spring Shell crée une application shell complète (également appelée ligne de commande)
• Spring Cloud et Spring Cloud Data Flow pour les applications cloud

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

Vous pouvez utiliser spring pour le développement web car il a le Spring MVCmodule qui fait partie du projet Spring Framework . Ou vous pouvez utiliser spring avec un autre framework web, comme struts2 .

À quoi sert le printemps? Je répondrai à cette question sous peu, mais d'abord, regardons de nouveau 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, il vous suffit de changer la seule ligne de code, comme dans l'approche XML de Spring. Mais changer une ligne de code nécessite toujours une recompilation par opposition à l'édition XML, vous dites? Eh bien mon ami difficile, utilisez Ant et le script!

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

1. Des 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. 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

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

Le printemps, c'est trois choses.

1. Le ressort gère l'injection de dépendance 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 d'encapsuler d'excellentes bibliothèques Java d'une manière très élégante à utiliser dans vos applications. Pour un bon exemple, voyez comment Spring encapsule les exécuteurs de tâches et le planificateur Quartz.
3. Thirdly Spring fournit un tas d'implémentations de trucs Web comme REST, un cadre Web MVC et plus encore. Ils figurent puisque vous utilisez Spring pour les deux premiers, vous pouvez peut-être simplement l'utiliser pour tout ce dont votre application Web a besoin.

Le problème est que Spring DI est vraiment bien pensé, les enveloppes autour d'autres choses sont vraiment bien pensées en ce sens que les autres choses ont tout pensé et que Spring les 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 est da bomb). J'ai donc tendance à utiliser Spring pour DI, et ses emballages sympas, 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 des POJO en tant que classes Controller, ce qui signifie que vous n'avez pas à étendre à partir d'un framework particulier (comme dans Struts ou Spring antérieur à 2.5). Les classes de contrôleur sont également très simples à tester grâce en partie à l'injection de dépendance
• Intégration de Spring avec Hibernate, qui fait un bon travail de simplification du 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 de 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 balises de formulaire Spring facilitent la création de formulaires sans trop de tracas.

De plus, Spring est ÉNORME - il y a donc beaucoup d'autres choses qui pourraient vous intéresser dans une application web comme Spring AOP ou Spring Security. Mais les quatre éléments énumérés ci-dessus décrivent les composants communs de Spring utilisés dans une application Web.

J'y vois deux parties:

1. "À quoi sert exactement le printemps" -> voir la réponse acceptée par victor hugo.
2. "[...] Spring est [un] bon cadre pour le développement web" -> les gens qui disent cela parlent de Spring MVC. Spring MVC est l'une des nombreuses parties de Spring, et est un framework web utilisant les fonctionnalités générales de Spring, comme l'injection de dépendances. C'est un framework assez générique en ce sens qu'il est très configurable: vous pouvez utiliser différentes couches 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 font cela, tout en utilisant d'autres cadres 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 ensemble (et a également 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 relie les classes Hibernate à vos DAO pour vous.

De plus, Spring vous donne essentiellement des configurations solides d'un tas de bibliothèques, et en cela, vous donne des conseils sur les bibliothèques que vous devez utiliser.

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

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

Approche Spring (Dependency Injection)

Il y a une autre façon de câbler les classes avec un fichier XML: les annotations. Prenons l'exemple de la réponse acceptée et enregistrez le haricot directement sur la classe en utilisant l' une des annotations @Component, @Service, @Repositoryou @Configuration:

@Component
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 comme par magie un UserLister prêt à fonctionner.

L'instruction ci-dessus est valide avec un petit bonus de pas besoin d'utilisation de fichier XML et de câblage avec une autre annotation @Autowiredqui trouve une implémentation pertinente et l'injecte.

@Autowired
private UserLister userLister;

Utilisez l' @Beanannotation sur une méthode utilisée pour obtenir l'implémentation du bean à injecter.

L'avantage est l' injection de dépendance (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, selon 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, commentez une ligne! Imaginez qu'il existe 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 à l'aide d'un nouveau mot-clé, nous avons transmis la référence à un objet de type déjeuner en tant que paramètre à notre constructeur. Ici, la création d'objets est externalisée. Ce code peut être câblé à l'aide du fichier de configuration Xml (hérité) ou des annotations Java (moderne). Dans les deux cas, la décision sur le type d'objet à créer se fera à cet endroit pendant 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 aide non seulement à rendre notre système faiblement couplé, il simplifie l'écriture des tests unitaires car il permet de se moquer des dépendances. Dernier point mais non le moindre, DI rationalise la programmation orientée aspect (AOP), ce qui conduit à un découplage supplémentaire et à une augmentation de la modularité. Notez également que DI ci-dessus est injection de constructeur.

• Spring est un framework léger et flexible comparé à J2EE.
• Le conteneur à ressort agit comme une inversion de contrôle.
• Spring utilise AOP, c'est-à-dire des proxys et des modèles Singleton, Factory et Template Method Design.
• Architectures à plusieurs niveaux: séparation des préoccupations et des couches réutilisables et maintenance facile.

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

Spring a commencé comme un système d'injection de dépendances assez simple. Maintenant, il est énorme et contient tout (sauf l'évier de cuisine proverbial).

Mais n'ayez crainte, il est assez modulaire, vous pouvez donc utiliser uniquement les pièces que vous souhaitez.

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

C'est peut-ê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 examiné.

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

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

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

Utilisation de Spring MVC (partie de "big spring") pour le développement web ... c'est un framework "basé sur les requêtes", il y a la guerre sainte "request vs component" ... à vous de choisir

Dans le passé, j'ai pensé au framework Spring d'un point de vue purement technique.

Étant donné une certaine expérience du travail d'équipe et du développement de Webapps d'entreprise - je dirais que Spring est pour un développement plus rapide des applications (applications web) en découplant ses éléments individuels (beans). Un développement plus rapide le rend si populaire. Spring permet de déplacer la responsabilité de construire (câbler) l'application sur le framework Spring. L' injection de dépendances du framework Spring est responsable de la connexion / du câblage de beans individuels dans une application fonctionnelle.

De cette façon, les développeurs peuvent se concentrer davantage sur le développement de composants individuels (beans) dès que les interfaces entre les beans sont définies.

Le test d'une telle application est facile - l'accent principal est mis sur les haricots individuels. Ils peuvent être facilement découplés et moqués, de sorte que les tests unitaires sont rapides et efficaces.

Le framework Spring définit plusieurs beans spécialisés tels que @Controller ( @Restcontroller ), @Repository , @Component à des fins Web. Spring et Maven fournissent une structure intuitive aux développeurs. Le travail en équipe est facile et rapide car certains éléments sont séparés et peuvent être réutilisés.

Le framework Spring est certainement bon pour le développement web et pour être plus spécifique pour les services api reposants.

Il est bon pour ce qui précède en raison de son injection de dépendance et de l' intégration avec d' autres modules tels que la sécurité du printemps , aop printemps , cadre mvc , microservices

Avec n'importe quelle application, la sécurité est très probablement une exigence.
Si vous visez à construire un produit qui nécessite une longue maintenance, vous aurez besoin d'utiliser le concept Aop.

Si votre application a un trafic important augmentant ainsi la charge, vous devez utiliser le concept de microservices.

Spring offre toutes ces fonctionnalités sur une seule plateforme. Prise en charge de nombreux modules .
Plus important encore, Spring est open source et un framework extensible, a un crochet partout pour intégrer du code personnalisé dans le cycle de vie.

Spring Data est un projet qui permet l'intégration avec votre projet.

Le ressort peut donc s'adapter à presque toutes les exigences.