Spring Framework 5.0 Tutorial de introducción

1. ¿Por qué aprender la primavera?

Con contacto continuo y comprensión de Java EE, encontrará que la primavera juega un papel cada vez más importante en varias empresas y proyectos. Mastering Spring se ha convertido en una de las habilidades de aprendizaje obligatoria en nuestra industria de TI.

1. Spring Framework es un marco de aplicación completo de código abierto Java/Java EE, lanzado bajo la licencia Apache, y también tiene una versión portada en la plataforma .NET.
2. El marco se basa en el código de diseño y desarrollo de Java EE Expert en el libro (ISBN 0-7645-4385-7), y fue desarrollado originalmente por Rod Johnson y Juergen Hoeller, entre otros.
3. Spring Framework proporciona un método de desarrollo simple que evitará una gran cantidad de archivos de propiedades y clases de ayuda que pueden hacer que el código subyacente sea complicado y desordenado.

Spring Framework La última versión actual es Spring Framework 5. Cuando abre el sitio web oficial, debería poder ver las imágenes promocionales del sitio web oficial.

Aquí hay una noticia relacionada que le interesa. Haga clic para ver la versión en inglés original. Haga clic para ver la versión china.

Según las noticias oficiales del sitio web y la información que conozco, el sitio web oficial de Spring continuará apoyando a Spring MVC porque tiene muchas mejoras.

Pero creo que la tendencia futura será Spring Boot+ SpringWeb Flux+ Spring Cloud .

Entonces, ¿cuál es la diferencia entre Spring MVC y Spring Web Flux?

El sitio web oficial ofrece esta imagen de comparación:

Traducido a continuación:

1. Spring MVC se basa en la API de Servlet y utiliza un marco web que bloquea la arquitectura de E/S de bloqueo sincrónico y un modelo de subproceso de solicitud de un solo hilo
2. Spring WebFlux es un marco web sin bloqueo construido a partir de este grupo, aprovechando procesadores de múltiples núcleos, próxima generación y una gran cantidad de conexiones concurrentes.

Resumir:

1. Spring MVC es un marco web para la E/S de bloqueo sincrónico construido en base a la API Servlet.
2. Spring WebFlux es un excelente marco web sin bloqueo y puede manejar mejor grandes cantidades de conexiones concurrentes.

Después de ver esto, creo que eres inteligente en este momento, debes saber por qué dije eso antes.

2. Introducción al sitio web oficial de primavera

Sitio web oficial de primavera: https://spring.io/ primavera

Documentación: https://spring.io/guides

Spring IDE: https://spring.io/tools/sts

Proyecto de primavera: https://spring.io/projects

Project Quick Generator: https://start.spring.io/

Creo que muchas personas conocen los enlaces anteriores, pero de hecho, a menudo no sabemos qué enlace usar.

Sitio web oficial de primavera: siga las noticias del sitio web oficial de Spring y los últimos anuncios de lanzamiento de la tecnología de primavera y versión

Documentación de primavera: ¿Qué quieres hacer? ¿Qué tipo de proyecto quieres desarrollar? Introducciones y documentación relacionadas se pueden encontrar aquí rápidamente.

Spring IDE: si planea usar la versión de Eclipse, le recomiendo usar el sitio web oficial STS, porque debería ser la versión más amigable y de apoyo de Spring. Por supuesto, si las condiciones están bien, todavía te recomiendo que uses la idea IntelliJ.

Proyecto de primavera: esto se divide de acuerdo con los módulos de proyecto, como desde la configuración hasta la seguridad, las aplicaciones web y los big data, y puede aprender cuál desea aprender de acuerdo con la clasificación.

Generador de proyectos: esta es una herramienta muy conveniente proporcionada por el sitio web oficial de Spring. ¿Qué dependencias se requieren y qué versión se requiere? Puede configurarlo aquí y luego descargarlo.

3. Marco de primavera

Spring Framework Core admite inyección de dependencia, gestión de transacciones, aplicaciones web, acceso a datos, mensajes, pruebas y más

Consejos: Aquí está la traducción https://projects.spring.io/springframework/

3.1 Introducción

Spring Framework proporciona un modelo integral de programación y configuración para aplicaciones empresariales modernas basadas en Java, en cualquier tipo de plataforma de implementación.

Un elemento clave de la primavera es el soporte de infraestructura a nivel de aplicación: Spring se centra en la "tubería" de las aplicaciones empresariales para que los equipos puedan centrarse en la lógica comercial a nivel de aplicación sin tener que formar conexiones innecesarias con entornos de implementación específicos.

3.2 Características funcionales

1. Tecnologías básicas: inyección de dependencia, eventos, recursos, I18n, verificación, enlace de datos, conversión de tipo, SPEL, AOP.
2. Prueba: Objetos simulados, TestContext Framework, Spring MVC Testing, WebtestClient.
3. Acceso a datos: Transacciones, Soporte DAO, JDBC, ORM, Marshalling XML.
4. Spring MVC y Spring WebFlufux Web Frameworks
5. Integración: procesamiento remoto, JMS, JCA, JMX, correo electrónico, tareas, programación, caché.
6. Lenguaje: Kotlin, lenguaje dinámico y groovy.

Consejos: Aquí hay una captura de pantalla del documento oficial del sitio web, creo que lo ayudará a comprender mejor.

3.3 Requisitos mínimos

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

Consejos: Entonces, su computadora ahora recomienda usar JDK1.8+

3.4 Inicio rápido

La forma recomendada de comenzar con Spring -Framework en su proyecto es utilizar un sistema de gestión de dependencias: el siguiente fragmento de código se puede copiar y pegar en su compilación.

¿Necesitar ayuda? Vea nuestra guía de inicio sobre el edificio con Maven y Gradle.

De hecho, no es solo el sitio web oficial de primavera. La mayoría de nuestras principales empresas hoy también deberían recomendar que usemos Maven y Gradle para administrar las dependencias de los paquetes de proyectos JAR.

Si está usando Maven:

 <Spendencies> <Spendency> <MoupRid> org.springframework </proupid> <artifactID> Spring-Context </artifactid> <verserse> 5.1.0.build-snapshot </versión> </dependency> </pendencs> <Repositories> <Repositorio> <Di> Spring-SnapShots </di> <niem> Springshots <Name> <URL> https://repo.spring.io/libs-snapshot </srl> <stapshots> <Enedably> true </habilitado> </snapshots> </ repository> </spository>

Si estás usando Gradle

 Dependencias {compilar 'org.springframework: spring-context: 5.1.0.build-snapshot'} repositorios {maven {url 'https://repo.spring.io/libs-snapshot'}}

Consejos: En realidad, creo que Gradle debería ser una herramienta de gestión de dependencia de versiones más avanzada que Maven. Sin embargo, parece que las principales empresas no usan Gradle muchas veces. Quizás sea porque el apoyo de Eclipse para Gradle no es tan perfecto como la idea de IntelliJ.

El marco de resorte contiene muchos módulos diferentes. Aquí mostramos el Spring-Context que proporciona funcionalidad central. Para obtener opciones adicionales, consulte la guía de inicio a la derecha.

Una vez que configure su compilación con la dependencia de Spring-Context, puede hacer lo siguiente:

Después de llegar aquí, el sitio web oficial no es detallado, así que agréguelo.

Método 1: Use la herramienta STS para construir este proyecto con contexto de contexto de primavera

Preparación:

1. JDK 1.8
2. STS IDE

Consejos: hay una trampa al descargar. Si su JDK tiene 64 bits y el STS que se descarga directamente de forma predeterminada es de 32 bits, este error ocurrirá.

Por lo tanto, al descargar, debe descargar la versión de juego JDK. Move: https://spring.io/tools/sts/all

Después de completar la descarga aquí, haremos clic con el botón derecho en el espacio en blanco de nuestro IDE -> Nuevo -> Otro ...

Ingrese la búsqueda Maven, seleccione el proyecto Maven y cree un proyecto Maven

Seleccione el espacio de trabajo predeterminado

Seleccione el tipo predeterminado

Ingrese la información básica del proyecto y haga clic en Finalizar para completarla

Entonces deberíamos poder ver la estructura del proyecto como esta

Primero modificar pom.xml

 <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.xingyun</groupId> <artifactId>spring-context-sample</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name> Spring-Context-Sample </name> <sl> http://maven.apache.org </sl> <properties> <jecter.build.sourceEncoding> utf-8 </project.build.sourceEncoding> </propiedadies> <dependency> <Ententency> <grupid> junit </groupid> <tifactid> <Persion> 3.8.1 </versión> <cope> test </cope> </dependency> <epardency> <uproupid> org.springframework </groupid> <artifactid> spring-context </artifactid> <version> 5.1.0.build-snapshot </ledentency> </ententency> </dependency> </pendences> <repositorios> <repositorios> <Di> Spring-Snapshots </id> <name> Spring Snapshots </name> <url> https://repo.spring.io/libs-snapshot </url> <stapshots> <NAVATION

Crear un archivo

Hola/MessageService.java

 paquete com.xingyun.spring_context_sample.hello; interfaz public messageservice {string getMessage ();}

hola/messageprinter.java

 paquete com.xingyun.spring_context_sample.hello; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.stereotype.component; @ComponentPublic MessagePrinter {Servicio final de mensajes privados; @AUTOWIRED Public MessagePrinter (MessageService Service) {this.service = servicio; } public void printMessage () {System.out.println (this.service.getMessage ()); }}

Consejos: Presta atención a esta anotación y no olvides

App.java

 paquete com.xingyun.spring_context_sample; import org.springframework.context.applicationContex org.springframework.context.annotation.componentscan; import org.springframework.context.annotation.configuration; import com.xingyun.spring_context_sample.hello.messagePrinter; import com.xingyun.spring_context_sample.hello.messageResservice;@configurationcanpUnation {@Bean MessageService MockMessageService () {return New MessageService () {public String getMessage () {return "¡Hello World!"; }}; } public static void main (string [] args) {applicationContext context = new AnnotationConfigApplicationContext (app.class); Impresora de MessagePrinter = context.getBean (MessagePrinter.Class); printMessage (); }}

Consejos: Tenga en cuenta que hay dos anotaciones en la clase y una anotación en el método. No te olvides. Puede cambiar el nombre de la clase a la aplicación en el sitio web oficial o retener el nombre predeterminado de la aplicación.

La estructura del proyecto debe ser así después de la creación exitosa

Por supuesto, puede sentirse incómodo cuando mira la estructura de este proyecto, por lo que también puede elegir cambiarlo.

La estructura del proyecto se convierte en esto:

Ejecutar el método principal app.main ()

Código fuente del proyecto Descargar: https://github.com/geekxingyun/javaee-framework-sample/tree/master/spring-context-sample

Apéndice: Dependencias de paquetes Core JAR

Consejos: si no está escribiendo una aplicación web Java, no necesitará el módulo Spring-WEB.

Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.