1

Introdução ao Framework Spring Boot - (Material Curso Dio)

#Spring Boot
Anderson Froes
Anderson Froes
Professor: 
Rodrigo Peleias

Link para Download do Artigo:
https://drive.google.com/file/d/14N2DY_vlNX6pzAjir78RfWHqA2l2ywdc/view?usp=sharing

Link para Material GitHub: (Professor)
https://github.com/rpeleias/springboot_digital_innovation_one

Capitulo 1 - O que é o Spring Boot?
**Objetivos da Aula:**
- O que é e quais problemas resolvem o Spring Boot?
- Auto Configuration
- Fat Jar / Uber Jar.

**Requisitos Básicos:**
- Java 8 ou versões superiores.
- Maven 3.5.2 ou versões superiores.
- Intellij IDEA Community Edition ou sua IDE favorita.
- Muita vontade de aprender e compartilhar conhecimento.

**Parte 1: O que é Spring Boot?**
**Problemas do Spring**
- Configurações de beans em arquivox xml.
- Dipatcher Servlet e view resolve em web.xml
- Setup manual de Banco de Dados.
- Muito tempo gasto em configuração.
- Perda de foco em valor.

**O que é o Spring Boot?**
- Criado pela Spring Source em 2012.
- Facilita setup de projetos Spring.
- Sem necessidade de criar arquivos de configuração.
- Foco em produtividade.
- Maior tempo no desenvolvimento de valor.

**Quais problemas resolve?**
- Produtividade: setup simplificado de projeto
- Starters: dependências auto configuráveis pelo Spring Boot
- Execução simplificada: sem deploy em servidor externo.
- Configuração: arquivo externo para configuração.
- Valor: maior tempo em desenvolvimento.

**Exercício juntos**
- Criação de um projeto no site http://start.spring.io
- Importar o projeto na sua IDE favorita.
- Adicionar spring-boot-starter-mvc no pom.xml.
- Adicionar classe HelloController e o método hello( ).
- Executar o projeto através do terminal.

**Arquivo criado na aula: HelloController**
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

  @GetMapping("/")
  public String helloMessage() {
    return "Hello, Digital Innovation One!";
  }
}


**Comandos usados no terminal (VSCODE ou PowerShell)**
- mvn spring-boot:run = Iniciar projeto
- http://localhost:8080/ = (Abrir esse endereço no seu navegador)

**Parte 2: Auto Configuration**
**Configuração Manual**
- Múltiplos arquivos XML.
- Configuração manual do Spring MVC: Dispatcher Servlet, web.xml, spring-mvc.xml.
- Configuração manual dos beans Spring.
- Aplicado também ao Spring Data, Spring Security, etc.

**Auto Configuration**
- Starters: dependências simplificadas e auto configuráveis.
- Identificação e configuração automática da dependência.
- Spring Boot detecta as dependências e configura para nós!
- Projeto simplificado e pronto para foco no valor!

**Exercício Juntos**
- Adicionar propriedade debug=true no application.properties.
- Executar projeto no terminal e analisar o log.
- Identificar e visualizar o auto configuration do spring mvc.
- Visualizar a dependência do auto configuration no projeto.

**Parte 3: FatJar / UberJar** 
**Antes do Spring Boot**
- Spring tradicional: war precisa de servidor de aplicação.
- Dependência de um container web ou servidor de aplicação.
- Complexidade para configurações.
- Atualizações frequentes, junto com versão do projeto.
- Gerenciamento manual de configurações.

**FatJar / UberJar** 
- Artefato do projeto pronto para execução.
- Container web embutido na geração e execução (TomCat).
- Deploy embarcado com outros containers são opcionais.
- Dependências principais do projeto embarcado.
- Execução direta através de um único java -jar
  Exemplo: mvn package java -jar target/spring-boot-example-0.1.0.jar
- Podemos também gerar o war tradicional.

**Exercícios juntos**
- Fazer o build do projeto.
- Explorar conteúdo do arquivo .jar gerado.
- Executar o projeto no terminal com java -jar.
- Trocar o formato do artefato para .war e executar no TomCat.

**Comandos usados:**
- mvn clean package = (fazer limpeza e empacotamento).
- arquivo e gerado por padrão na pasta target. (springboot.jar).
- java -jar springboot.jar = (subir projeto).
- jar tf springboot.jar | less = (mostrar o conteúdo do arquivo).
- mv target/springboot.war apache-tomcat-9.0.26/webapps = (mover arquivo para o TomCat).
- ll apache-tomcat-9.0.26/webapps = (listar arquivos do tomcat)
- cd apache-tomcat-9.0.26 = (entrar na pasta tomcat)
- cd bin = (entrar na pasta bin do tomcat)
- ./startup.sh = (subir projeto).
- Caminho localhost no tomcat = localhost:8080/springboot

Capitulo 2 - Trabalhando com Profiles e Configurações
**Objetivos da Aula:**
- Importância do uso de Profiles.
- Configurações com arquivos properties.
- Configurações com arquivos YAML.
- Configurações com command line.
- Configurações com variáveis de ambientes.

**Requisitos Básicos:**
- Java 8 ou versões superiores.
- Maven 3.5.2 ou versões superiores.
- Intellij IDEA Community Edition ou sua IDE favorita.
- Muita vontade de aprender e compartilhar conhecimento.

**Parte 1: Importância dos Profiles**
**Múltiplos ambientes**
- Ambientes para desenvolvimento, teste e produção.
- Bancos de dados para cada ambiente.
- Execução de testes unitários em ambiente local.
- Suíte de testes completas em ambiente de teste.
- Simulação do ambiente real em staging.
- Deploy simplificado em produção.

**Spring Boot Profiles**
- Configurações próprias para cada ambiente.
- Ambientes com sua configuração: dev, production.

**Parte 2: Configurações com Properties**

**Exercícios juntos**
- Projeto com spring.initialzr e importar na IDE.
- Arquivos application.properties para dev e prod.
- Classe de configuração de BD e anotar com @Configuration.
- Mapear propriedades com @configurationProperties.
- Criar métodos para instanciar Beand de cada env.
- Criar classe anotada com @RestController.
- Injetar propriedade appMessage com @Value.
- Criar método que retorna a mensagem acima.
- Executar projeto no browser.

**Códigos usados na aula:**

**Arquivo: application-dev.properties** 
#DEV environment

app.message=This is the property file fo the ${spring.application.name} specific to DEV Envirnoment

spring.datasource.driver-class-name=org.h2.Driver 
spring.datasource.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
spring.datasource.username=sa
spring.datasource.password=sa


**Arquivo: application-prod.properties** 
#PROD environment

app.message=This is the property file fo the ${spring.application.name} specific to PROD Envirnoment

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 
spring.datasource.url=<MYSQL_URL>
spring.datasource.username=<USERNAME>
spring.datasource.password=<PASSWORD>


**Arquivo: [application.properties](http://application.properties)** 
spring.profiles.active=dev

spring.application.name=Spring Boot Configuration Project


**Arquivo: DBConfiguration.java** 
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.annotation.Bean;
import org.springframework.boot.context.annotation.Configuration;
import org.springframework.boot.context.annotation.Profile;

@configuration
@ConfigurationProperties("spring.datasource")
@Getter
@Setter
 public class DBConfiguration {

  private String driverClassName;
  private String url;
  private String username;
  private String password;

  @Profile("dev")
  @Bean
  public String testDatabaseConnection() {
    System.out.println("DB connection for DEV - H2");
    System.out.println(driverClassName);
    System.out.println(url);
    return "DB Connection H2_TEST - Test instance";
  }

  @Profile("prod")
  @Bean
  public String productionDataBaseConnection() {
    Syste.out.println("DB connection for Production - MySQL");
    System.out.println("DB connection for DEV - H2");
    System.out.println(driverClassName);
    System.out.println(url);
    return "DB Connection MYSQL_PROD - Production instance";
  }
}


**Arquivo: AppController.java**
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AppController {

  @Value("${app.message}")
  private String appMessage;

  @GetMapping("/")
  public String getAppMessage() {
    return appMessage;
  }
}


**Comando usado no Terminal:**
- mvn spring-boot:run (subir projeto).

**Parte 3: Configurações com YAML**
- Troca no formato de configurações: formato .YML

**Exercício juntos**
- Migrar app.properties do profile dev para YML.
- Executar o projeto pelo Terminal.

**Arquivo: application-dev.properties** 
#DEV environment

app:
	message: This is the property file fo the ${spring.application.name} specific to DEV Envirnoment

spring:
	datasource:
		driver-class-name: org.h2.Driver 
		url: jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
		username: sa
		password: sa


**Parte 4: Configurações com command line**
- Propriedades do arquivo de configuração na linha de comando.
- Sobrescreve as propriedades definidas no arquivo de configurações padrão.
- Valores passados como argumento na execução do projeto.

**Exercício juntos**
- Passar como argumento a propriedade server.port=8085
- Executar o projeto no terminal com o argumento
- Abrir o browser no endereço http://localhost:8085

**Comando usado no Terminal**
- mvn spring-boot:run -Dserver.port=8085

**Parte 5: Configurações com variáveis de ambiente**
- Variável de ambiente pode ser injetada através da anotação @Value no projeto.
- Linux e Mac: export comum de variável

  export ENV_DB_URL=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1 

- Windows: padrão de variável de ambiente.
- Injeção com anotaçao @Value({NOME_VARIAVEL}).
- Definição de valor default quando não há variável.

**Exercício juntos**
- Injetar a variável com o @Value em AppController.
- Definição de valor default junto com a anotação @Value.
- Criar método para chamada do novo método e exibir o valor.
- Executar projeto no terminal e exibir no browser.

**Arquivo: AppController.java**
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AppController {

  @Value("${app.message}")
  private String appMessage;

		@Value("${ENV_DB_URL:NENHUMA}")
		private String dvEnvironmentVariable;

  @GetMapping("/")
  public String getAppMessage() {
    return appMessage;
  }

		@GetMapping("/envVariable")
		public String getEnvironmentVariable() {
				return "A seguinte variável de ambiente foi passada: " + dbEnvironmentVariable;
		}
}


**Comando usado no Terminal**
- export ENV_DB_URL=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
- mvn spring-boot:run


0
33

Comentários (0)

Um ser humano buscando conhecimento e sucesso em sua vida profissional

Brasil