Spring Framework 5.0 Introduction Tutoriel

1.Pour pourquoi apprendre le printemps?

Avec un contact continu et une compréhension de Java EE, vous constaterez que le printemps joue un rôle de plus en plus important dans diverses entreprises et projets. La maîtrise du printemps est devenue l'une des compétences incontournables de notre industrie informatique.

1. Spring Framework est un framework d'application Full-Stack open source Java / Java EE, publié sous la licence Apache, et dispose également d'une version portée sur la plate-forme .NET.
2. Le cadre est basé sur le code dans l'expert du livre en tête-à-tête conception et développement Java EE (ISBN 0-7645-4385-7) et a été initialement développé par Rod Johnson et Juergen Hoeller, entre autres.
3. Spring Framework fournit une méthode de développement simple qui évitera un grand nombre de fichiers de propriétés et d'aide aux classes qui peuvent entraîner la complication et le désordre du code sous-jacent.

Spring Framework La dernière version actuelle est Spring Framework 5. Lorsque vous ouvrez le site officiel, vous devriez pouvoir voir les photos promotionnelles du site officiel.

Il y a une nouvelle connexe ici qui vous intéresse. Cliquez pour voir la version anglaise originale. Cliquez pour afficher la version chinoise.

Selon le site officiel des nouvelles et les informations que je connais, le site officiel de Spring continuera à soutenir Spring MVC car il a de nombreuses améliorations.

Mais je pense que la tendance future sera Spring Boot + Springweb Flux + Spring Cloud .

Alors, quelle est la différence entre Spring MVC et Spring Web Flux?

Le site officiel donne cette image de comparaison:

Traduit ci-dessous:

1. Spring MVC est construit sur l'API Servlet et utilise un cadre Web qui bloque une architecture d'E / S synchrone et un modèle de thread de demande unique
2. Spring WebFlux est un cadre Web non bloquant construit à partir de ce groupe, tirant parti des processeurs multi-core, de nouvelle génération et un grand nombre de connexions simultanées.

Résumer:

1. Spring MVC est un framework Web pour les E / S de blocage synchrone construits sur la base de l'API Servlet.
2. Spring WebFlux est un excellent cadre Web non bloquant et peut mieux gérer un grand nombre de connexions simultanées.

Après avoir vu cela, je crois que vous êtes intelligent en ce moment, vous devez savoir pourquoi j'ai déjà dit cela.

2. Introduction au site officiel du printemps

Site officiel du printemps: https://spring.io/ printemps

Documentation: https://spring.io/guides

IDE de printemps: https://spring.io/tools/sts

Projet de printemps: https://spring.io/projects

Projet Générateur rapide: https://start.spring.io/

Je crois que beaucoup de gens connaissent les liens ci-dessus, mais en fait, nous ne savons souvent pas quel lien utiliser.

Site officiel du printemps: Suivez les nouvelles du site officiel du printemps et les dernières annonces de la technologie de printemps et de version de Spring

Documentation du printemps: que voulez-vous faire? Quel type de projet souhaitez-vous développer? Des présentations et des documents connexes peuvent être trouvés ici rapidement.

Spring IDE: Si vous prévoyez d'utiliser la version Eclipse, je recommande d'utiliser le site officiel STS, car il devrait être la version la plus conviviale et la plus favorable du printemps. Bien sûr, si les conditions sont OK, je vous recommande toujours fortement d'utiliser Intellij Idea.

Projet de printemps: Ceci est divisé en fonction des modules de projet, tels que de la configuration à la sécurité, des applications Web aux mégadonnées, et vous pouvez apprendre celui que vous souhaitez apprendre en fonction de la classification.

GÉNÉRATEUR DE PROJET: Il s'agit d'un outil très pratique fourni par le site officiel de Spring. Quelles dépendances sont requises et quelle version est requise? Vous pouvez le configurer ici, puis le télécharger.

3. Framework de printemps

Spring Framework Core prend en charge l'injection de dépendance, la gestion des transactions, les applications Web, l'accès aux données, la messagerie, les tests et plus

Conseils: Voici la traduction https://projects.spring.io/spring-framework/

3.1 Introduction

Le Spring Framework fournit un modèle complet de programmation et de configuration pour les applications d'entreprise basées sur Java modernes - sur tout type de plate-forme de déploiement.

Un élément clé de Spring est le support d'infrastructure au niveau de l'application: Spring se concentre sur le «pipeline» des applications d'entreprise afin que les équipes puissent se concentrer sur la logique métier au niveau de l'application sans avoir à établir des connexions inutiles avec des environnements de déploiement spécifiques.

3.2 Caractéristiques fonctionnelles

1. Core Technologies: injection de dépendance, événements, ressources, i18n, vérification, liaison des données, conversion de type, Spel, AOP.
2. Test: Mock Objectts, TestContext Framework, Spring MVC Testing, WebTestClient.
3. Accès aux données: transactions, support DAO, JDBC, ORM, Marshalling XML.
4. Spring MVC et Spring Webflux Web Frameworks
5. Intégration: Traitement à distance, JMS, JCA, JMX, e-mail, tâches, planification, cache.
6. Langue: Kotlin, Groovy, Dynamic Language.

Conseils: Voici une capture d'écran du document officiel du site Web, je pense que cela vous aidera à mieux comprendre.

3,3 Exigences minimales

1. JDK 8+ pour Spring Framework 5.x
2. JDK 6+ pour Spring Framework 4.x
3. JDK 5+ pour Spring Framework 3.x

Conseils: votre ordinateur recommande donc d'utiliser JDK1.8 +

3.4 Démarrage rapide

La façon recommandée de commencer avec Spring-Framework dans votre projet est d'utiliser un système de gestion des dépendances - l'extrait de code suivant peut être copié et collé dans votre version.

Besoin d'aide? Voir notre guide de démarrage sur la construction avec Maven et Gradle.

En fait, ce n'est pas seulement le site officiel du printemps. Aujourd'hui, la plupart de nos grandes entreprises devraient également recommander que nous utilisons Maven et Gradle pour gérer les dépendances du package de JAR du projet.

Si vous utilisez Maven:

 <Dependances> <Dependency> <GroupId> org.SpringFramework </proupId> <ArtifActid> Spring-Context </ Artifactid> <DERSE> 5.1.0.Build-Snapshot </DERNIFRES> </ Dependency> </Detences> <Name> Spring snapshots </ name> <url> https://repo.spring.io/libs-snapshot </url> <napshots> <cabled> true </ableable> </napshots> </ Repository> </ Repository>

Si vous utilisez Gradle

 dépendances {compile 'org.springframework: printemps-context: 5.1.0.build-snapshot'} Repositories {maven {url 'https://repo.spring.io/libs-snapshot'}}

Conseils: en fait, je pense que Gradle devrait être un outil de gestion de dépendance de version plus avancée que Maven. Cependant, il semble que les grandes entreprises n'utilisent pas Gradle plusieurs fois. C'est peut-être parce que le soutien d'Eclipse pour Gradle n'est pas aussi parfait que Intellij Idea.

Le cadre de ressort contient de nombreux modules différents. Ici, nous montrons le Spring-Context qui fournit des fonctionnalités de base. Pour des options supplémentaires, consultez le guide de démarrage à droite.

Une fois que vous avez configuré votre version avec la dépendance à Spring-Context, vous pouvez effectuer ce qui suit:

Après son arrivée ici, le site officiel n'est pas détaillé, alors ajoutez-le.

Méthode 1: Utilisez l'outil STS pour construire ce projet avec le contexte Spring-Context

Préparation:

1. JDK 1.8
2. Sts ide

Conseils: il y a un piège lors du téléchargement. Si votre JDK est 64 bits et que le STS qui est directement téléchargé par défaut est 32 bits, cette erreur se produira.

Par conséquent, lors du téléchargement, vous devez télécharger la version correspondante JDK. Déplacer: https://spring.io/tools/sts/all

Une fois le téléchargement ici terminé, nous cliquerons avec le bouton droit sur l'espace vide de notre IDE -> Nouveau -> Autre ...

Entrez la recherche Maven, sélectionnez Maven Project et créez un projet Maven

Sélectionnez l'espace de travail par défaut

Sélectionnez le type par défaut

Entrez les informations de base du projet et cliquez sur Terminer pour le terminer

Ensuite, nous devrions pouvoir voir la structure du projet comme celle-ci

Modifier d'abord pom.xml

 <project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </ ModelVersion> <ProupId> com.xingyun </ groupeid> <ArtifActid> Spring-Context-Sample </ Artifactid> </ Version> 0.0.1-Snapshot </ Version> <packaging> <name> Spring-Context-échantillon </name> <url> http://maven.apache.org </url> <properties> <project.build.sourceencoding> utf-8 </project.build.sourceencoding> </properfact> <fedences> </stiposctid> junit </prepperdid> <version> 3.8.1 </ version> <ccope> Test </cope> </ Dependency> <Dedency> <ProupId> org.springFramework </prouved> <ArtefactId> Spring-Context </ Artifactid> <Dersond> 5.1.0.Build-Snapshot </De version> </Dedency> </Dedency> </Dependantsc <Id> Spring-Snapshots </id> <name> Spring Snapshots </name> <url> https://repo.spring.io/libs-snapshot </url> <stapshots> </abled> true </velow

Créer un fichier

Bonjour / MessageService.java

 package com.xingyun.spring_context_sample.hello; Interface publique messageService {String getMessage ();}

bonjour / messageprinter.java

 package com.xingyun.spring_context_sample.hello; import org.springframework.beans.factory.annotation.autowired; import org.springframework.sterreoType.component; @componentpublic class messagePrinter {final private messService Service; @Autowired Public MessagePrinter (MessageService Service) {this.service = service; } public void printMessage () {System.out.println (this.service.getMessage ()); }}

Conseils: faites attention à cette annotation et n'oubliez pas

App.java

 package com.xingyun.spring_context_sample; import org.springframework.context.applicationContext; import org.springframework.context.annotation.annotation.annotationConfigApplicationContex; import org.springframework.context.annotation.configuration; import com.xingyun.spring_context_sample.hello.messageprinter; import com.xingyun.spring_context_sample.hello.messageService; @ configuration @ componentsCanpublic class app {@bean messuvice mockmessage) {public String getMessage () {return "Hello World!"; }}; } public static void main (String [] args) {applicationContext context = new AnnotationConfigApplicationContext (app.class); MessagePrinter Imprimante = context.getBean (MessagePriner.Class); PrintMessage (); }}

Conseils: Notez qu'il y a deux annotations sur la classe et une annotation sur la méthode. N'oubliez pas. Vous pouvez modifier le nom de la classe en application sur le site officiel ou conserver le nom de l'application par défaut.

La structure du projet devrait être comme ça après une création réussie

Bien sûr, vous pouvez vous sentir mal à l'aise lorsque vous regardez la structure de ce projet, afin que vous puissiez également choisir de le changer.

La structure du projet devient ceci:

Exécuter app.main () méthode principale

Téléchargement du code source du projet: https://github.com/geekxingyun/javaee-framework-sample/tree/master/spring-context-sample

Annexe: dépendances de package de pot de base

Conseils: Si vous n'écrivez pas une application Web Java, vous n'aurez pas besoin du module Spring-Web.

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.