Quiz: Primeiros Passos com Spring Boot

Teste seus conhecimentos sobre a criação e estrutura de um projeto Spring Boot.

30 questões - Clique em cada pergunta para revelar a resposta.

Questões 1-10: Spring Initializr e Estrutura

Pergunta 1: O que é o Spring Initializr?

Resposta: Spring Initializr é uma ferramenta web (start.spring.io) que gera a estrutura básica de um projeto Spring Boot:

Escolha do tipo de projeto (Maven/Gradle)
Versão do Java e Spring Boot
Dependências iniciais
Metadados do projeto (groupId, artifactId)

Pergunta 2: Qual é a estrutura padrão de um projeto Spring Boot?

Resposta:

src/
├── main/
│   ├── java/
│   │   └── com/example/demo/
│   │       └── DemoApplication.java
│   └── resources/
│       ├── application.properties
│       ├── static/
│       └── templates/
└── test/
    └── java/
pom.xml

Pergunta 3: Para que serve o arquivo pom.xml?

Resposta: O arquivo pom.xml (Project Object Model) define:

Metadados do projeto (groupId, artifactId, version)
Dependências
Plugins Maven
Configuração de build
Parent Spring Boot (spring-boot-starter-parent)

Pergunta 4: O que é o spring-boot-starter-parent?

Resposta: Um parent Maven que fornece:

Gerenciamento de versões de dependências
Configuração padrão de plugins
Codificação UTF-8
Versão do Java configurada
Perfis de build

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

Pergunta 5: O que é um starter do Spring Boot?

Resposta: Um starter é um conjunto de dependências pré-configuradas para um uso específico:

Starter	Uso
`spring-boot-starter-web`	API REST
`spring-boot-starter-data-jpa`	Banco de dados
`spring-boot-starter-security`	Segurança
`spring-boot-starter-test`	Testes

Pergunta 6: Onde colocar o arquivo application.properties?

Resposta: Em src/main/resources/application.properties ou application.yml.

Este arquivo contém a configuração da aplicação (porta, banco de dados, etc.).

Pergunta 7: Qual a diferença entre application.properties e application.yml?

Resposta:

# application.properties
server.port=8080
spring.datasource.url=jdbc:postgresql://localhost/db

# application.yml
server:
  port: 8080
spring:
  datasource:
    url: jdbc:postgresql://localhost/db

YAML é mais legível para configurações hierárquicas.

Pergunta 8: Para que serve a pasta static/?

Resposta: A pasta src/main/resources/static/ contém arquivos estáticos servidos diretamente:

CSS
JavaScript
Imagens
Arquivos HTML estáticos

Acessível via http://localhost:8080/arquivo.css

Pergunta 9: Para que serve a pasta templates/?

Resposta: A pasta src/main/resources/templates/ contém os templates do lado do servidor:

Thymeleaf (.html)
FreeMarker (.ftl)
Mustache (.mustache)

Usado para aplicações web com renderização no servidor.

Pergunta 10: Como executar uma aplicação Spring Boot?

Resposta:

# Com Maven
mvn spring-boot:run

# Ou compilando o JAR
mvn clean package
java -jar target/app.jar

# Pela IDE
# Execute a classe main

Questões 11-20: Classe Principal e Anotações

Pergunta 11: O que contém a classe principal?

Resposta:

@SpringBootApplication
public class DemoApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

É o ponto de entrada que inicia o contexto Spring.

Pergunta 12: O que faz a @SpringBootApplication?

Resposta: @SpringBootApplication combina três anotações:

@Configuration: classe de configuração
@EnableAutoConfiguration: auto-configuração do Spring Boot
@ComponentScan: varredura de componentes

Pergunta 13: O que é auto-configuração?

Resposta: O Spring Boot configura automaticamente os beans de acordo com:

As dependências presentes
As propriedades definidas
Os beans existentes

Exemplo: adicionar spring-boot-starter-data-jpa configura automaticamente um DataSource.

Pergunta 14: O que é @RestController?

Resposta: Anotação que combina:

@Controller: componente web
@ResponseBody: retorna JSON/XML

@RestController
public class UserController {
    
    @GetMapping("/users")
    public List<User> getAll() {
        return userService.findAll();
    }
}

Pergunta 15: Quais são as anotações de mapeamento HTTP?

Resposta:

Anotação	Método HTTP
`@GetMapping`	GET
`@PostMapping`	POST
`@PutMapping`	PUT
`@DeleteMapping`	DELETE
`@PatchMapping`	PATCH
`@RequestMapping`	Todas (configurável)

Pergunta 16: Como recuperar um parâmetro da URL?

Resposta:

// Path variable: /users/123
@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id) {
    return userService.findById(id);
}

// Query param: /users?name=John
@GetMapping("/users")
public List<User> search(@RequestParam String name) {
    return userService.findByName(name);
}

Pergunta 17: Como recuperar o corpo de uma requisição?

Resposta:

@PostMapping("/users")
public User create(@RequestBody UserRequest request) {
    return userService.create(request);
}

@RequestBody desserializa o JSON em um objeto Java.

Pergunta 18: Para que servem @Component, @Service, @Repository?

Resposta: São estereótipos do Spring que marcam as classes como beans:

Anotação	Uso
`@Component`	Bean genérico
`@Service`	Lógica de negócio
`@Repository`	Acesso a dados
`@Controller`	Camada web

Todos são variantes de @Component.

Pergunta 19: O que são @Configuration e @Bean?

Resposta:

@Configuration
public class AppConfig {
    
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Configuration: classe de configuração
@Bean: método que produz um bean

Pergunta 20: Como injetar uma dependência?

Resposta:

@Service
public class UserService {
    
    private final UserRepository userRepository;
    
    // Injeção por construtor (recomendado)
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Questões 21-30: Configuração e Repositórios

Pergunta 21: Como definir a porta do servidor?

Resposta:

# application.properties
server.port=9090

# application.yml
server:
  port: 9090

Padrão: 8080

Pergunta 22: Como usar perfis?

Resposta:

# application.yml (comum)
spring:
  profiles:
    active: dev

# application-dev.yml
server:
  port: 8080

# application-prod.yml
server:
  port: 80

Ativação: --spring.profiles.active=prod

Pergunta 23: Como ler uma propriedade de configuração?

Resposta:

@Value("${app.name}")
private String appName;

@Value("${app.timeout:5000}")  // Valor padrão
private int timeout;

Pergunta 24: O que é JpaRepository?

Resposta: Interface do Spring Data JPA que fornece métodos CRUD:

public interface UserRepository extends JpaRepository<User, Long> {
    // Métodos herdados: save, findById, findAll, delete, count...
}

Pergunta 25: Como criar uma entidade JPA?

Resposta:

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    private String email;
    
    // Getters, setters
}

Pergunta 26: Como configurar o H2 em memória?

Resposta:

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
  h2:
    console:
      enabled: true  # Console: /h2-console

Perfeito para desenvolvimento e testes.

Pergunta 27: Como o Spring Data gera as queries?

Resposta: Pelo nome do método:

List<User> findByName(String name);
// SELECT * FROM users WHERE name = ?

List<User> findByEmailContaining(String email);
// SELECT * FROM users WHERE email LIKE '%?%'

List<User> findByAgeGreaterThanOrderByNameAsc(int age);
// SELECT * FROM users WHERE age > ? ORDER BY name ASC

Pergunta 28: Como iniciar a aplicação com dados?

Resposta:

@Component
public class DataInitializer implements CommandLineRunner {
    
    private final UserRepository repository;
    
    @Override
    public void run(String... args) {
        repository.save(new User("Admin", "admin@example.com"));
    }
}

Ou com src/main/resources/data.sql.

Pergunta 29: Como ver as queries SQL executadas?

Resposta:

spring:
  jpa:
    show-sql: true
    properties:
      hibernate:
        format_sql: true

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.orm.jdbc.bind: TRACE

Pergunta 30: Como criar um JAR executável?

Resposta:

mvn clean package

# Resultado: target/app-0.0.1-SNAPSHOT.jar

java -jar target/app-0.0.1-SNAPSHOT.jar

O JAR contém a aplicação e um servidor Tomcat embarcado.

Pontuação

Pontuação	Nível
27-30	Excelente - Fundamentos dominados
21-26	Bom - Algumas revisões
15-20	Médio - Releia os capítulos
Menos de 15	Precisa revisar

Voltar ao Módulo 2

Questões 1-10: Spring Initializr e Estrutura​

Questões 11-20: Classe Principal e Anotações​

Questões 21-30: Configuração e Repositórios​

Pontuação​

Questões 1-10: Spring Initializr e Estrutura

Questões 11-20: Classe Principal e Anotações

Questões 21-30: Configuração e Repositórios

Pontuação