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.
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:
Resumir:
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
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
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:
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.
Groupid | Artefácido | Descripción |
org.springframework | Spring-AOP | Soporte de AOP basado en el poder |
org.springframework | apegos de primavera | Aspectos basados en el aspecto |
org.springframework | ballena de primavera | Soporte de frijoles, incluido Groovy |
org.springframework | contexto de primavera | Tiempo de ejecución del contexto de la aplicación, incluidas las abstracciones programadas y remotas |
org.springframework | soporte de contexto de primavera | Clases de apoyo para integrar bibliotecas comunes de terceros en un contexto de aplicación de primavera |
org.springframework | núcleo de primavera | Utilidades centrales, utilizadas por muchos otros módulos de primavera |
org.springframework | expresión de primavera | Lenguaje de expresión de primavera (Spel) |
org.springframework | instrumento de primavera | Agente de instrumentación para Bootstrapping JVM |
org.springframework | primavera-instrumento-Tomcat | Agente de instrumentación para Tomcat |
org.springframework | Spring-JDBC | Paquete de soporte de JDBC, incluida la configuración de la fuente de datos y el soporte de acceso JDBC |
org.springframework | Spring-JMS | Paquete de soporte de JMS, incluidas las clases de ayuda para enviar/recibir mensajes JMS |
org.springframework | posesor de primavera | Soporte para las arquitecturas y protocolos de mensajería |
org.springframework | resorte | Mapeo de objetos/relacionales, incluidos JPA y soporte de hibernación |
org.springframework | oxm de primavera | Mapeo de objeto/xml |
org.springframework | prueba de primavera | Soporte para pruebas unitarias y pruebas de integración componentes de resorte |
org.springframework | Spring-TX | Infraestructura de transacciones, incluida el soporte de DAO y la integración de JCA |
org.springframework | Web Spring-Web | Soporte web fundamental, que incluye un cliente web y un control remoto basado en la web |
org.springframework | Spring-Webmvc | Modelo-View-View-Controller basado en HTTP y puntos finales REST para pilas de servlet |
org.springframework | spring-webmvc-portlet | Implementación de MVC que se utilizará en un entorno de portlet |
org.springframework | bandeja | Infraestructura de WebSocket y SockJS, incluido el soporte de mensajería STOMP |
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.