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.
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:
Resumir:
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
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
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:
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.
Grupo | Artifactid | Descrição |
org.springframework | Spring-AOP | Suporte de AOP baseado em proxy |
org.springframework | Especas de primavera | Aspectos baseados em aspectos |
org.springframework | Feiteiro de primavera | Apoio de feijões, incluindo Groovy |
org.springframework | Spring-Context | Tempo de execução do contexto do aplicativo, incluindo abstrações programadas e remotas |
org.springframework | Spring-Context-support | Apoiar aulas para integrar bibliotecas comuns de terceiros em um contexto de aplicativo de primavera |
org.springframework | Spring-Core | Utilitários principais, usados por muitos outros módulos de primavera |
org.springframework | expressão da primavera | Linguagem de expressão de primavera (SPEL) |
org.springframework | Spring-Instrument | Agente de instrumentação para bootstrapping de JVM |
org.springframework | Spring-Instrument-Tomcat | Agente de instrumentação para tomcat |
org.springframework | Spring-JDBC | Pacote de suporte ao JDBC, incluindo Configuração do DataSource e Suporte ao Acesso JDBC |
org.springframework | Spring-jms | Pacote de suporte JMS, incluindo aulas de auxiliar para enviar/receber mensagens JMS |
org.springframework | Mensagem da primavera | Suporte para arquiteturas e protocolos de mensagens |
org.springframework | Spring-ATM | Mapeamento de objeto/relacional, incluindo JPA e Suporte de Hibernato |
org.springframework | Spring-oxm | Mapeamento de objeto/xml |
org.springframework | teste de primavera | Suporte para testes de unidade e componentes de mola de teste de integração |
org.springframework | Spring-tx | Infraestrutura de transação, incluindo suporte da DAO e integração da JCA |
org.springframework | Spring web | Suporte da Web fundamental, incluindo cliente da Web e remoção baseada na Web |
org.springframework | Spring-webmvc | Controlador de visualização de modelo baseado em HTTP e terminais de descanso para pilhas de servlet |
org.springframework | Spring-WebMVC-Portlet | Implementação de MVC a ser usada em um ambiente de portlet |
org.springframework | Spring-websocket | Infraestrutura WebSocket e SockJS, incluindo suporte de mensagens Stomp |
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.