Prefácio
Ao aprender uma nova tecnologia, não se preocupe com seus princípios, processos, como organizar o código etc. Basta copiar uma pequena demonstração do site ou blog oficial, executá -lo e depois ler o grupo de explicações que fazem as pessoas formigando o escalpeiro, e você será relativamente fácil de entender.
Atualmente, existem muitos artigos introdutórios sobre a Spring Boot na Internet, todos muito úteis. Eu tenho estudado a Spring Cloud em profundidade recentemente. Quando eu estava construindo o primeiro programa Hello World, sinto que, para iniciantes, não é um exagero apresentar o artigo em detalhes. Como existem muitas armadilhas, postarei as etapas da primeira prática aqui para progredir com todos.
1. O que é maven? Que ajuda isso pode trazer?
Quando usamos o Eclipse para desenvolver projetos, definitivamente apresentaremos pacotes JAR que suportam funções específicas. Por exemplo, a partir da figura abaixo, podemos ver que este projeto precisa introduzir pacotes JAR que suportam o MySQL.
A partir da imagem acima, podemos ver que o pacote JAR que suporta o MySQL é colocado no caminho local; portanto, se ele funcionar localmente, ficará bem. Mas se quisermos publicar este projeto no servidor, haverá um problema, porque no arquivo .classPath deste projeto, um certo caminho do pacote MySQL JAR no disco D local foi especificado, conforme mostrado na figura abaixo.
Uma vez publicado no servidor, o projeto ainda procurará esse caminho sob o disco D de acordo com a configuração do .classPath. De fato, é impossível para esse pacote de caminho e jar no servidor.
Também podemos resolver esse problema especificando caminhos relativos no .classpath. No código a seguir, podemos especificar que este projeto introduzirá o pacote JAR no diretório "Project Path/Webroot/lib".
<ClassPathentry Kind = "Lib" Path = "Webroot/Lib/Jar Nome do pacote.jar"/>
Ao fazer isso, ao publicar no servidor, todos os arquivos em todo o caminho do projeto serão enviados, para que não haja erros. Mas isso ainda nos causará inconvenientes. Por exemplo, implantamos 5 projetos neste servidor e todos eles usam o pacote de suporte MySQL, por isso precisamos fazer upload deste pacote JAR 5 vezes e expandi -lo. Se 20 pacotes de jar são usados nos 5 projetos, realmente precisamos copiá -lo várias vezes. Se queremos atualizar um dos pacotes JAR, realmente precisamos fazer muitas ações duplicadas de cópia e colar.
O modo de trabalho esperado deve ser que haja um "repositório" para colocar todos os pacotes JAR ao mesmo tempo. Ao desenvolver um projeto, você pode introduzir os pacotes necessários através de arquivos de configuração em vez de copiar os pacotes neste projeto. É isso que o MAVEN faz.
Em termos simples, o Maven é um plug-in com o Eclipse. Seu valor central é ser capaz de endireitar as dependências entre os projetos. Especificamente, ele pode gerenciar uniformemente os pacotes JAR para serem usados neste projeto através do arquivo de configuração do POM.XML. Depois de introduzir o plug-in maven no projeto, os desenvolvedores não precisam adicionar manualmente o pacote JAR, que também pode evitar uma série de problemas causados por isso.
2. Desenvolva o programa Helloworld da Spring Boot através do Maven
O primeiro passo é criar um projeto Maven. Este livro usa o Myeclipse como ambiente de desenvolvimento, e o plug-in MAVEN foi introduzido, para que possamos criar diretamente o projeto Maven através do menu "arquivo"-> "novo", conforme mostrado na figura abaixo.
Na figura acima, depois de clicar no botão "Avançar", você verá a interface mostrada na figura abaixo, onde podemos definir propriedades como o ID do grupo.
Entre eles, o ID do grupo representa o nome da empresa, que está definido como "com.springboot", enquanto o ID do artefato é o nome do projeto, e a versão e o packag usam valores padrão. Depois de concluir a configuração, você pode ver o projeto recém -criado myfirstspringboot
A segunda etapa é reescrever pom.xml. Depois de criarmos o projeto Maven, podemos ver o arquivo pom.xml. Nos projetos Maven, as informações básicas deste projeto e os pacotes JAR que precisam ser introduzidos são geralmente especificados através do POM.XML. O código -chave aqui é o seguinte.
<PupidId> com.springboot </roupidId> <TRAFACTID> myfirstspringboot </artifactId> <versão> 0.0.1-snapshot </versão </packaging> jar </cacaging> <name> myfirstspringboot </name> <url> http:/maven.Apten.ache.ache. <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>1.5.4.RELEASE</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> </dependências>
Entre eles, os códigos nas linhas 1 a 4 são gerados automaticamente e são usados para especificar as informações básicas deste projeto, que são consistentes com as informações que preenchemos quando criamos o projeto MAVEN antes.
A partir dos atributos de dependências das linhas 7 a 19, podemos especificar o pacote JAR usado neste projeto. Aqui, usamos duas dependências para especificar a introdução de dois tipos de pacotes JAR nas linhas 8 e 13, respectivamente. Das linhas 8 a 12, é especificada uma coleção de frascos chamada Spring-Boot-Starter-Web que precisa ser introduzida para desenvolver projetos de inicialização da mola e, nas linhas 13 a 18, é especificado um pacote JUNIT para teste de unidade.
A partir do código acima, podemos ver a maneira geral de gerenciar arquivos de dependência do projeto através do MAVEN. Por exemplo, no snippet de código abaixo, é através das linhas 2 a 4, indicando que é necessário introduzir um conjunto de pacotes de jar chamado Spring-Boot-Starter-Web, que é publicado pela organização da empresa Org.SpringFramework.Boot (a organização que publica pacotes de jarra de mola) que suporta a bota de mola e o número de versão 4.
Dessa forma, neste projeto, não precisamos adicionar manualmente pacotes JAR localmente. Esses pacotes estão na verdade no repositório remoto. Nosso projeto especifica que esses pacotes precisam ser introduzidos através da configuração do POM.XML.
O terceiro passo é reescrever o app.java.
Ao criar um projeto MAVEN, o pacote que especificamos é com.springboot.myfirstspringboot e haverá um app.java nele. Reescrevemos esse arquivo no estilo a seguir.
pacote com.springboot.myfirstspringboot; importar org.springframework.boot.springApplication; importar org.springframework.boot.autoconfigure.springbootApplication; importar org.springframework.web.bind.annotation.requestmapping; importar org.springframework.web.bind.annotation.restcontroller; @Restcontroller @springbootapplication public class App {@RequestMapping ("/helloworld") public string sayhello () {return "Hello World!"; } public static void main (string [] args) {springapplication.run (app.class, args); }}Como é a primeira vez que o MAVEN, enfatizaremos novamente aqui que, embora não tenhamos introduzido jarros manualmente no projeto, uma vez que o pacote de dependência a ser introduzido é especificado no POM.xml, especificamente, precisamos contar com a Web-Star-Star-Web da Org.SpringFramework.Boot. Portanto, nas linhas 2 a 5 do código, podemos usar a biblioteca de classe Spring-Boot-Starter-Web (ou seja, Spring Boot) através da instrução Import.
Na linha 8, introduzimos a anotação @springbootApplication para declarar que a classe é um aplicativo de inicialização de primavera. Nas linhas 10 a 13, especificamos o método Sayhello usado para lidar com solicitações /helloworld através do @RequestMapping. Na função principal na linha 14, iniciamos o serviço da web através do código na linha 15.
Até agora, concluímos o trabalho de redação de código. Inicie o App.java no projeto MyFirstsPringboot e digite http: // localhost: 8080/helloworld no navegador. Como a solicitação /helloworld pode ser correspondente ao @RequestMapping do método Sayhello nas linhas 11 a 13, o conteúdo do Hello World! será emitido através do método Sayhello, conforme mostrado na figura abaixo.
A partir deste programa, podemos entender a diferença entre o desenvolvimento da inicialização da primavera e os programas tradicionais de primavera.
Primeiro, na estrutura anterior do MVC da primavera, tivemos que definir um ouvinte de primavera em web.xml e, para usar a classe do @Controller Controller, tivemos que adicionar muitas configurações, mas na inicialização da primavera, precisamos adicionar apenas uma anotação de @springbootApplication.
Segundo, geralmente precisamos publicar projetos tradicionais de MVC de primavera em servidores da Web, como o TomCat. Depois de iniciar o servidor da Web, podemos inserir uma solicitação no navegador para ver o efeito em execução. Aqui, precisamos apenas iniciar a classe App.java para obter efeitos semelhantes, que podem salvar a etapa de implantação no servidor da Web.
Resumir
O acima é o conteúdo inteiro deste artigo. Espero que o conteúdo deste artigo tenha certo valor de referência para o estudo ou trabalho de todos. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Obrigado pelo seu apoio ao wulin.com.