Spring Framework 5.0 Tutorial de Introdução

1. Por que aprender a primavera?

Com o contato contínuo e o entendimento de Java EE, você descobrirá que a primavera desempenha um papel cada vez mais importante em várias empresas e projetos. O Mastering Spring se tornou uma das habilidades obrigatórias em nossa indústria de TI.

1. A Spring Framework é uma estrutura de aplicativos de pilha completa Java/Java EE de código aberto, lançado sob a licença Apache, e também possui uma versão portada na plataforma .NET.
2. A estrutura é baseada no código do livro de especialista em Java EE, especialista em um especialista em Java EE (ISBN 0-7645-4385-7) e foi originalmente desenvolvido por Rod Johnson e Juergen Hoeller, entre outros.
3. A Spring Framework fornece um método de desenvolvimento simples que evitará um grande número de arquivos de propriedade e aulas de ajuda que podem fazer com que o código subjacente se torne complicado e confuso.

Spring Framework A versão mais recente atual é a Spring Framework 5. Quando você abre o site oficial, poderá ver as imagens promocionais do site oficial.

Há uma notícia relacionada aqui em que você está interessado. Clique para visualizar a versão original em inglês. Clique para ver a versão chinesa.

De acordo com as notícias oficiais do site e as informações que conheço, o site oficial da Spring continuará apoiando o MVC da primavera porque possui muitas melhorias.

Mas acho que a tendência futura será a Spring Boot+ Springweb Flux+ Spring Cloud .

Então, qual é a diferença entre o MVC da primavera e o fluxo da web da primavera?

O site oficial fornece esta imagem de comparação:

Traduzido abaixo:

1. Spring MVC é construído na API do servlet e usa uma estrutura da web que a arquitetura de E/S de bloqueio síncrono e um modelo de thread de solicitação de thread único
2. O Spring Webflux é uma estrutura da Web não bloqueada, construída a partir deste grupo, alavancando processadores de vários núcleos e de próxima geração e um grande número de conexões simultâneas.

Resumir:

1. O Spring MVC é uma estrutura da web para E/S de bloqueio síncrono construído com base na API do servlet.
2. O Spring Webflux é uma excelente estrutura da Web não bloqueadora e pode lidar melhor com um grande número de conexões simultâneas.

Depois de ver isso, acredito que você é inteligente neste momento, você deve saber por que eu disse isso antes.

2. Introdução ao site oficial da primavera

Site oficial da primavera: https://spring.io/ primavera

Documentação: https://spring.io/guides

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

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

Projeto Gerador Quick: https://start.spring.io/

Acredito que muitas pessoas conhecem os links acima, mas, na verdade, geralmente não sabemos qual link para usar.

Site oficial da primavera: Siga as notícias do site oficial da primavera e os mais recentes anúncios de tecnologia da primavera e versão

Documentação da primavera: o que você quer fazer? Que tipo de projeto você deseja desenvolver? Introduções e documentação relacionadas podem ser encontradas aqui rapidamente.

Spring IDE: Se você planeja usar a versão Eclipse, recomendo usar o site oficial STS, porque deve ser a versão mais amigável e solidária da primavera. Obviamente, se as condições estiverem bem, eu ainda recomendo que você use a idéia Intellij.

Projeto de primavera: isso é dividido de acordo com os módulos do projeto, como da configuração a segurança, aplicativos da Web e Big Data e você pode aprender qual deseja aprender de acordo com a classificação.

Gerador de projeto: Esta é uma ferramenta muito conveniente fornecida pelo site oficial da Spring. Quais dependências são necessárias e qual versão é necessária? Você pode configurá -lo aqui e depois baixá -lo.

3. Spring Framework

O núcleo da estrutura da mola suporta injeção de dependência, gerenciamento de transações, aplicativos da Web, acesso a dados, mensagens, teste e muito mais

Dicas: Aqui está a tradução https://projects.spring.io/spring-framework/

3.1 Introdução

O Spring Framework fornece um modelo abrangente de programação e configuração para aplicativos corporativos modernos baseados em Java - em qualquer tipo de plataforma de implantação.

Um elemento-chave do Spring é o suporte à infraestrutura no nível do aplicativo: o Spring se concentra no "pipeline" dos aplicativos corporativos para que as equipes possam se concentrar na lógica de negócios no nível do aplicativo sem ter que formar conexões desnecessárias com ambientes de implantação específicos.

3.2 Recursos funcionais

1. Tecnologias principais: injeção de dependência, eventos, recursos, i18n, verificação, ligação de dados, conversão de tipo, spel, AOP.
2. Teste: Mock Objects, TestContext Framework, Spring MVC Testing, WebTestClient.
3. Acesso de dados: transações, suporte ao, jdbc, orm, marecha xml.
4. Spring MVC e Spring Webflux Web Frameworks
5. Integração: processamento remoto, JMS, JCA, JMX, email, tarefas, agendamento, cache.
6. Idioma: Kotlin, Groovy, linguagem dinâmica.

Dicas: Aqui está uma captura de tela do documento oficial do site, acredito que isso ajudará você a entender melhor.

3.3 Requisitos mínimos

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

Dicas: então seu computador agora recomenda usar o JDK1.8+

3.4 Início rápido

A maneira recomendada de começar com o quadro de primavera em seu projeto é usar um sistema de gerenciamento de dependência - o seguinte snippet de código pode ser copiado e colado em sua construção.

Precisar de ajuda? Veja nosso guia de início da construção com Maven e Gradle.

De fato, não é apenas o site oficial da primavera. A maioria das nossas principais empresas hoje também deve recomendar que usemos o Maven e o Gradle para gerenciar as dependências do pacote de jarra de projeto.

Se você estiver usando o maven:

 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId> spring-context</artifactId> <version>5.1.0.BUILD-SNAPSHOT</version> </dependency></dependencies><repositories> <repository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url> https://repo.spring.io/libs-snapshot </erl> <snapshots> <bility> true </ilabled> </snapshots> </positório> </positório>

Se você está usando gradle

 Dependências {compile 'org.springframework: spring-Context: 5.1.0.build-snapshot'} repositórios {maven {url 'https://repo.spring.io/libs-snapshot'}}

Dicas: na verdade, acho que o Gradle deve ser uma ferramenta de gerenciamento de dependência de versão mais avançada do que o Maven. No entanto, parece que as principais empresas não usam Gradle muitas vezes. Talvez seja porque o apoio do Eclipse a Gradle não é tão perfeito quanto a idéia intellij.

A estrutura da mola contém muitos módulos diferentes. Aqui, mostramos o contexto da mola que fornece funcionalidade central. Para opções adicionais, consulte o guia de início da direita.

Depois de configurar sua compilação com a dependência do contexto da mola, você pode fazer o seguinte:

Depois de chegar aqui, o site oficial não é detalhado, então adicione -o.

Método 1: Use a ferramenta STS para construir este projeto com o contexto da primavera-contexto

Preparação:

1. JDK 1.8
2. STS IDE

Dicas: há uma armadilha ao fazer o download. Se o seu JDK for de 64 bits e o STS que for baixado diretamente por padrão for de 32 bits, esse erro ocorrerá.

Portanto, ao baixar, você deve baixar a versão correspondente do JDK. Move: https://spring.io/tools/sts/all

Depois que o download aqui for concluído, clicaremos com o botão direito do mouse no espaço em branco do nosso IDE -> Novo -> Outros ...

Digite a pesquisa do Maven, selecione o Maven Project e crie um projeto Maven

Selecione o espaço de trabalho padrão

Selecione o tipo padrão

Insira as informações básicas do projeto e clique em Concluir para concluí -las

Então devemos poder ver a estrutura do projeto como esta

Primeiro modifique 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 http://maven.apache.org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </modelVersion> <puperid> com.xingyun </groupId> <artifactId> spring-context-sample </stifactid> <iplys> 0.1-snnapshot> Spring-Context-sample </Artifactid> <ipers> 0.1-snnapshot> spring-context </artifactid> <name>spring-context-sample</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <dependency> <groupId>junit</groupId> <TarifactId> Junit </stifactId> <versão> 3.8.1 </version> <cope> test </cope> </dependency> <pendencency> <voundid> org.springframework </dependent> <TarfactId> Spring-Context </ArtifactId> </dependente> 5.1.0.build-snapsht> <repositories> <repository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url>https://repo.spring.io/libs-snapshot</url> <snapshots> <enabled>true</enabled> </snapshots> </repository> </repository> </repository> </repository> </positório> </ject>

Criar um arquivo

Olá/MessageService.java

 pacote com.xingyun.spring_context_sample.hello; interface pública MensagemService {String getMessage ();}

Olá/MessagePrinter.java

 pacote com.xingyun.spring_context_sample.hello; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.tereotype.comPONN; @AUTowired Public MessagePrinter (MessageService Service) {this.service = Service; } public void printMessage () {System.out.println (this.service.getMessage ()); }}

Dicas: preste atenção a esta anotação e não se esqueça

App.java

 package com.xingyun.spring_context_sample;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.Annotation.AnnotationConfigApplicationContext;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.comONENTSCAN; importar org.springframework.context.annotation.configuration; importar com.xingyun.spring_context_sample.hello.messagePrinter; import.xingyun.spring_contemample.hello.messagePrinter; import.xingyun.Orcation; App {@Bean MessageService MockMessageService () {return new messenservice () {public String getMessage () {return "Hello World!"; }}; } public static void main (string [] args) {ApplicationContext context = new AnotationConfigApplicationContext (app.class); MessagePrinter Printer = Context.getBean (MessagePrinter.class); printMessage (); }}

Dicas: Observe que existem duas anotações na classe e uma anotação no método. Não se esqueça. Você pode alterar o nome da classe para o aplicativo no site oficial ou manter o nome do aplicativo padrão.

A estrutura do projeto deve ser assim após a criação bem -sucedida

Obviamente, você pode se sentir desconfortável quando olha para a estrutura deste projeto, para que também possa optar por alterá -lo.

A estrutura do projeto se torna a seguinte:

Run App.main () Método Principal

Download do código-fonte do projeto: https://github.com/geekxingyun/javaee-framework-sample/tree/master/spring-context-sample

Apêndice: dependências do pacote principal do jar

Dicas: Se você não estiver escrevendo um aplicativo da Web Java, não precisará do módulo Spring Web.

O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.