Capítulo 8: "O que é...?" — Os 40 conceitos mais cobrados em entrevistas

Objetivo

Este capítulo reúne as perguntas do tipo "O que é um DTO?", "O que é MVC?" — as perguntas de vocabulário e conceitos que todo entrevistador faz primeiro. Se você só puder revisar um capítulo, escolha este.

---

1. O que é um DTO (Data Transfer Object)?

Um DTO é um objeto simples usado para transportar dados entre as camadas da aplicação, sem lógica de negócio.

Por que não usar a Entity diretamente?

Entity	DTO
Mapeada ao banco de dados	Apenas um contêiner de dados
Contém relações JPA (lazy loading)	Contém somente os campos necessários
Pode expor dados sensíveis (senha, papel)	Você escolhe exatamente o que expor
Alterar o BD = alterar a API	API independente do BD

Exemplo prático

// ENTITY (ligada ao BD)
@Entity
public class User {
    @Id @GeneratedValue
    private Long id;
    private String name;
    private String email;
    private String password;     // ← nunca deve ser exposto!
    private String role;

    @OneToMany(mappedBy = "user")
    private List<Order> orders;  // ← lazy loading, pode causar N+1
}

// DTO (o que o cliente recebe)
public record UserDTO(
    Long id,
    String name,
    String email
    // sem password, sem role, sem orders
) {}

// Conversão no Service
@Service
public class UserService {
    public UserDTO toDto(User user) {
        return new UserDTO(user.getId(), user.getName(), user.getEmail());
    }
}

Frase de entrevista

"Um DTO é um objeto simples usado para transferir dados entre camadas. Eu uso DTOs para evitar expor entidades JPA na API — isso previne vazamento de campos sensíveis como senhas e evita problemas de lazy-loading."

---

2. O que é MVC (Model-View-Controller)?

Um padrão arquitetural que separa a aplicação em 3 responsabilidades:

Componente	Papel	No Spring Boot
Model	Os dados e a lógica de negócio	Entity, Service, Repository
View	A apresentação (o que o usuário vê)	JSON (API REST) ou Thymeleaf (HTML)
Controller	O maestro que recebe as requisições e coordena	@Controller ou @RestController

No Spring Boot REST, a "View" é o JSON

@RestController   // Controller
@RequestMapping("/api/users")
public class UserController {

    @GetMapping("/{id}")
    public UserDTO getUser(@PathVariable Long id) {
        return userService.findById(id);  // Model → convertido em JSON (View)
    }
}

Frase de entrevista

"MVC separa a aplicação em Model (dados/lógica), View (apresentação) e Controller (tratamento de requisições). Em uma API REST, a View é a resposta JSON serializada automaticamente pelo Jackson."

---

3. O que é uma API REST?

API = Application Programming Interface (interface para dois programas se comunicarem)

REST = Representational State Transfer (estilo arquitetural para APIs web)

As 6 regras do REST

Regra	Significado
Cliente-Servidor	Cliente e servidor são separados
Sem estado (Stateless)	Cada requisição contém toda a informação necessária
Cache	As respostas podem ser cacheadas
Interface uniforme	URLs consistentes, métodos HTTP padrão
Sistema em camadas	O cliente não sabe se fala com o servidor final
Código sob demanda (opcional)	O servidor pode enviar código executável

Os métodos HTTP

Método	Ação	Exemplo	Código de retorno
GET	Ler	GET /api/users/1	200 OK
POST	Criar	POST /api/users	201 Created
PUT	Substituir completamente	PUT /api/users/1	200 OK
PATCH	Modificar parcialmente	PATCH /api/users/1	200 OK
DELETE	Remover	DELETE /api/users/1	204 No Content

Frase de entrevista

"REST é um estilo arquitetural para APIs web. Ele usa métodos HTTP (GET, POST, PUT, DELETE) para realizar operações CRUD em recursos identificados por URLs. É stateless — cada requisição é independente."

---

4. O que é CRUD?

As 4 operações básicas sobre dados:

Letra	Operação	SQL	HTTP	Spring Data
C	Create	INSERT	POST	save()
R	Read	SELECT	GET	findById(), findAll()
U	Update	UPDATE	PUT/PATCH	save()
D	Delete	DELETE	DELETE	deleteById()

---

5. O que é um POJO?

POJO = Plain Old Java Object

Um objeto Java simples, sem qualquer dependência de framework:

// É um POJO — apenas campos, getters, setters
public class User {
    private String name;
    private String email;

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

Um Java Bean é um POJO que segue convenções: construtor sem argumentos, getters/setters, serializável.

Um Spring Bean é um objeto gerenciado pelo container Spring (pode ser um POJO anotado com @Component, @Service, etc.).

---

6. O que é um Bean Spring?

Um objeto criado e gerenciado pelo container Spring (ApplicationContext).

// Isto é um Bean Spring — o Spring cria e gerencia
@Service
public class UserService {
    // O Spring instancia automaticamente na inicialização
    // O Spring injeta onde for necessário
    // O Spring gerencia o ciclo de vida
}

// Isto NÃO é um Bean — criado manualmente
UserService service = new UserService();

Como criar um Bean?

Método	Exemplo
Anotações estereótipo	@Component, @Service, @Repository, @Controller
@Bean em @Configuration	Método que retorna um objeto
@Import	Importa uma classe de configuração

Frase de entrevista

"Um Spring Bean é um objeto gerenciado pelo container IoC do Spring. O Spring cria, injeta as dependências e gerencia o ciclo de vida. Por padrão, beans são singletons."

---

7. O que é IoC (Inversion of Control)?

Sem IoC: o código cria suas próprias dependências.

Com IoC: o container cria as dependências e as fornece ao código.

// SEM IoC — o código controla a criação
public class OrderService {
    private UserRepository repo = new UserRepository();  // Cria ele mesmo
    private EmailService email = new EmailService();     // Cria ele mesmo
}

// COM IoC — o Spring controla a criação
@Service
public class OrderService {
    private final UserRepository repo;   // Spring fornece
    private final EmailService email;    // Spring fornece

    public OrderService(UserRepository repo, EmailService email) {
        this.repo = repo;    // Injetado pelo Spring
        this.email = email;  // Injetado pelo Spring
    }
}

A injeção de dependências (DI) é o mecanismo concreto que implementa IoC.

---

8. O que é ORM, JPA e Hibernate?

Termo	Definição	Analogia
ORM	Object-Relational Mapping — técnica que mapeia objetos Java para tabelas SQL	O tradutor entre Java e SQL
JPA	Jakarta Persistence API — a especificação (interface) do ORM em Java	O contrato / o padrão
Hibernate	A implementação mais popular do JPA	O software que faz o trabalho

JPA (especificação)    →  Hibernate (implementação)
      ↓                          ↓
 "assim deveria funcionar"   "aqui está o código que
                             faz funcionar"

// Anotações JPA (padrão)
@Entity                // JPA: "esta classe é uma entidade"
@Table(name = "users") // JPA: "mapeada para a tabela users"
public class User {
    @Id                // JPA: "esta é a chave primária"
    @GeneratedValue    // JPA: "auto-incremento"
    private Long id;

    @Column(name = "full_name") // JPA: "mapeado para esta coluna"
    private String name;
}

// O Hibernate faz o trabalho por trás: gera queries SQL,
// gerencia cache, lazy loading, transações...

Frase de entrevista

"JPA é a especificação que define como objetos Java são mapeados para tabelas de banco de dados. Hibernate é a implementação mais popular do JPA. Eu uso anotações JPA para não acoplar meu código ao Hibernate especificamente."

---

9. O que é Maven?

Uma ferramenta de gerenciamento de build e dependências para projetos Java.

Funcionalidade	Descrição
Dependências	Baixa automaticamente as bibliotecas (do Maven Central)
Build	Compila, testa, empacota a aplicação (.jar)
Lifecycle	mvn clean → mvn compile → mvn test → mvn package
pom.xml	O arquivo de configuração do projeto

<!-- pom.xml — o coração do Maven -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Maven vs Gradle: Maven usa XML (verboso mas padrão), Gradle usa Groovy/Kotlin (mais conciso mas curva de aprendizado).

---

10. O que é Tomcat?

Um servidor web / container de servlets que executa aplicações Java.

O Spring Boot integra o Tomcat diretamente:

java -jar minhaapp.jar
       ↓
  ┌──────────────────────┐
  │     Spring Boot      │
  │  ┌──────────────────┐ │
  │  │  Tomcat embutido │ │  ← escuta na porta 8080
  │  │  (embedded)      │ │
  │  └──────────────────┘ │
  │  ┌──────────────────┐ │
  │  │  Seu código      │ │
  │  │  Controllers     │ │
  │  │  Services        │ │
  │  └──────────────────┘ │
  └──────────────────────┘

Não é necessário instalar o Tomcat separadamente — o Spring Boot já inclui no .jar.

---

11. O que é JSON?

JSON = JavaScript Object Notation — um formato de dados leve e legível.

{
    "id": 1,
    "name": "Jean Dupont",
    "email": "jean@mail.com",
    "active": true,
    "roles": ["USER", "ADMIN"],
    "address": {
        "city": "Montréal",
        "postalCode": "H2X 1Y4"
    }
}

No Spring Boot, o Jackson converte automaticamente objetos Java em JSON e vice-versa:

// Java → JSON (serialização)
@GetMapping("/users/1")
public UserDTO getUser() {
    return new UserDTO(1L, "Jean", "jean@mail.com");
    // O Jackson transforma automaticamente em JSON
}

// JSON → Java (desserialização)
@PostMapping("/users")
public void create(@RequestBody UserDTO dto) {
    // O Jackson transforma o JSON do body em objeto UserDTO
}

---

12. O que é Postman e Swagger?

Ferramenta	Papel
Postman	Cliente HTTP para testar manualmente APIs REST (enviar GET, POST, etc.)
Swagger / OpenAPI	Gera automaticamente uma documentação interativa da API

Swagger no Spring Boot:

<!-- Adicionar no pom.xml -->
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.3.0</version>
</dependency>

Depois, acesse http://localhost:8080/swagger-ui.html para testar seus endpoints direto no navegador.

---

13. O que é Docker?

Docker cria containers: ambientes isolados que contêm sua aplicação + todas as dependências.

Sem Docker:                 Com Docker:
"Funciona na minha máquina" "Funciona EM QUALQUER LUGAR"

Meu PC:                     Container:
├── Java 17                 ├── Java 17
├── Maven 3.9               ├── Maven 3.9
├── PostgreSQL 15           ├── App.jar
└── Minha App               └── (tudo incluso)
    ↕ Possíveis conflitos       ↕ Isolado e portátil

# Dockerfile para Spring Boot
FROM eclipse-temurin:17-jre
COPY target/app.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

---

14. O que é CI/CD?

Termo	Significado	Quando
CI — Continuous Integration	Compilar + testar automaticamente a cada git push	A cada commit
CD — Continuous Delivery	Fazer deploy automático em produção	Após os testes

Ferramentas: GitHub Actions, Jenkins, GitLab CI, CircleCI.

---

15. O que é Git e GitHub?

Termo	Definição
Git	Ferramenta de controle de versão — acompanha o histórico de alterações do código
GitHub	Plataforma web que hospeda repositórios Git + colaboração

git add .              # Preparar as alterações
git commit -m "fix"    # Salvar no histórico local
git push origin main   # Enviar para o GitHub
git pull               # Buscar alterações dos outros
git branch feature-x   # Criar uma branch
git merge feature-x    # Mesclar uma branch

---

16. O que é arquitetura em camadas (Layered Architecture)?

Regra de ouro

Cada camada só se comunica com a camada imediatamente abaixo.

✅ Controller → Service → Repository → Database
❌ Controller → Repository (nunca diretamente!)
❌ Controller → Database (nunca diretamente!)

Frase de entrevista

"Eu sigo uma arquitetura em camadas: Controller trata HTTP, Service contém a lógica de negócio, Repository faz o acesso a dados. Cada camada só conversa com a imediatamente abaixo. Essa separação torna o código testável e fácil de manter."

---

17. O que é o Spring IoC Container (ApplicationContext)?

O container que cria, configura e monta todos os beans Spring na inicialização:

Inicialização da aplicação:

1. @SpringBootApplication → inicia o scan
2. Encontra @Component, @Service, @Repository, @Controller
3. Cria as instâncias (beans)
4. Resolve as dependências (@Autowired)
5. Injeta as dependências
6. Chama @PostConstruct
7. ══════ Aplicação pronta ══════

---

18. O que é @Autowired? O que é injeção de dependências?

3 formas de injetar no Spring:

// ✅ 1. Injeção por CONSTRUTOR (recomendada)
@Service
public class OrderService {
    private final UserRepository userRepo;
    private final EmailService emailService;

    public OrderService(UserRepository userRepo, EmailService emailService) {
        this.userRepo = userRepo;
        this.emailService = emailService;
    }
}

// ⚠️ 2. Injeção por SETTER
@Service
public class OrderService {
    private UserRepository userRepo;

    @Autowired
    public void setUserRepo(UserRepository userRepo) {
        this.userRepo = userRepo;
    }
}

// ❌ 3. Injeção por CAMPO (não recomendado)
@Service
public class OrderService {
    @Autowired
    private UserRepository userRepo;
}

Por que o construtor é o melhor?

Critério	Construtor	Setter	Campo
Imutabilidade (final)	✅	❌	❌
Testável sem Spring	✅	⚠️	❌
Dependências obrigatórias	✅	❌	❌
Detecta dependências circulares	✅	❌	❌

Frase de entrevista

"Prefiro injeção por construtor porque permite campos finais (imutabilidade), torna as dependências explícitas e funciona sem o Spring para testes. Desde o Spring 4.3, @Autowired é opcional em construtores únicos."

---

19. O que é um Record Java?

Um Record (Java 16+) é um tipo especial para objetos imutáveis que contêm apenas dados:

// Antes (POJO clássico — 30 linhas)
public class UserDTO {
    private final Long id;
    private final String name;
    private final String email;

    public UserDTO(Long id, String name, String email) {
        this.id = id; this.name = name; this.email = email;
    }
    public Long getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }
    // + equals(), hashCode(), toString()...
}

// Depois (Record — 1 linha!)
public record UserDTO(Long id, String name, String email) {}
// Gera automaticamente: construtor, getters, equals, hashCode, toString

Ideal para: DTOs, requisições, respostas, eventos.

---

20. O que é Lombok?

Uma biblioteca que gera automaticamente código repetitivo (boilerplate) na compilação:

// Sem Lombok — 50+ linhas
public class User {
    private Long id;
    private String name;
    private String email;
    // construtor, getters, setters, equals, hashCode, toString...
}

// Com Lombok — 5 linhas
@Data                    // getters, setters, equals, hashCode, toString
@NoArgsConstructor       // construtor sem argumentos
@AllArgsConstructor      // construtor com todos os argumentos
@Builder                 // padrão Builder
public class User {
    private Long id;
    private String name;
    private String email;
}

Anotação Lombok	Gera
@Getter / @Setter	Getters e/ou setters
@ToString	toString()
@EqualsAndHashCode	equals() e hashCode()
@Data	Tudo acima
@Builder	Padrão Builder
@NoArgsConstructor	Construtor vazio
@AllArgsConstructor	Construtor completo
@Slf4j	Logger log

---

21. O que é ResponseEntity?

Um objeto Spring que representa a resposta HTTP completa (status + headers + body):

// Sem ResponseEntity — sem controle do status
@GetMapping("/{id}")
public UserDTO getUser(@PathVariable Long id) {
    return userService.findById(id);  // sempre 200 OK
}

// Com ResponseEntity — controle total
@GetMapping("/{id}")
public ResponseEntity<UserDTO> getUser(@PathVariable Long id) {
    return userService.findById(id)
        .map(ResponseEntity::ok)                      // 200 OK
        .orElse(ResponseEntity.notFound().build());    // 404 Not Found
}

@PostMapping
public ResponseEntity<UserDTO> create(@Valid @RequestBody CreateUserRequest req) {
    UserDTO created = userService.create(req);
    return ResponseEntity
        .status(HttpStatus.CREATED)     // 201 Created
        .header("Location", "/api/users/" + created.id())
        .body(created);
}

@DeleteMapping("/{id}")
public ResponseEntity<Void> delete(@PathVariable Long id) {
    userService.delete(id);
    return ResponseEntity.noContent().build();  // 204 No Content
}

---

22. O que é @Valid e validação Bean Validation?

// DTO com restrições de validação
public record CreateUserRequest(
    @NotBlank(message = "O nome é obrigatório")
    String name,

    @Email(message = "Email inválido")
    @NotBlank
    String email,

    @Size(min = 8, message = "Mínimo 8 caracteres")
    String password,

    @Min(value = 18, message = "Mínimo 18 anos")
    int age
) {}

// Controller — @Valid dispara a validação
@PostMapping
public ResponseEntity<UserDTO> create(@Valid @RequestBody CreateUserRequest req) {
    // Se a validação falhar → 400 Bad Request automático
    return ResponseEntity.status(HttpStatus.CREATED)
        .body(userService.create(req));
}

Anotação	Verifica
@NotNull	Não nulo
@NotBlank	Não nulo, não vazio, não só espaços
@NotEmpty	Não nulo, não vazio
@Email	Formato de email válido
@Size(min, max)	Tamanho entre min e max
@Min / @Max	Valor numérico min/max
@Pattern(regexp)	Corresponde a uma expressão regular
@Past / @Future	Data no passado/futuro

---

23. O que é application.properties / application.yml?

O arquivo de configuração da aplicação Spring Boot:

# application.yml
server:
  port: 8080

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: admin
    password: secret
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

app:
  jwt:
    secret: mySecretKey
    expiration: 86400000

Acesse os valores com @Value:

@Value("${app.jwt.secret}")
private String jwtSecret;

@Value("${server.port}")
private int port;

---

24. O que é Spring Security?

O framework de segurança do Spring para autenticação e autorização:

Conceito	Pergunta	Exemplo
Autenticação	"Quem é você?"	Login + senha, JWT
Autorização	"Você tem permissão?"	Papel USER, ADMIN

---

25. O que é JWT (JSON Web Token)?

Um token enviado em cada requisição para provar a identidade do usuário:

JWT = HEADER.PAYLOAD.SIGNATURE

eyJhbGciOiJIUzI1NiJ9.          ← Header (algoritmo)
eyJzdWIiOiJhbGljZSJ9.          ← Payload (dados: usuário, papel, expiração)
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c  ← Signature (verificação)

O fluxo

1. POST /api/auth/login  { "email": "alice@mail.com", "password": "123" }
2. Servidor verifica → Gera um JWT → Retorna para o cliente
3. Cliente armazena o JWT
4. GET /api/users  Header: Authorization: Bearer eyJhbG...
5. Servidor valida o JWT → Autoriza a requisição

---

26. O que é CORS?

CORS = Cross-Origin Resource Sharing

Quando seu frontend (localhost:3000) chama seu backend (localhost:8080), o navegador bloqueia a requisição por segurança. O CORS permite essas requisições cross-origin.

@Configuration
public class CorsConfig {
    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/api/**")
                    .allowedOrigins("http://localhost:3000")
                    .allowedMethods("GET", "POST", "PUT", "DELETE");
            }
        };
    }
}

---

27. O que é Singleton no Spring?

Por padrão, cada bean Spring é um Singleton — uma única instância compartilhada em toda a aplicação:

@Service
public class UserService { ... }  // UMA única instância, compartilhada em todo lugar

// Em toda a app, é o MESMO objeto UserService
@RestController
class UserController {
    private final UserService userService; // mesma instância
}

@RestController
class AdminController {
    private final UserService userService; // mesma instância!
}

---

28. Qual a diferença entre PUT e PATCH?

Método	Ação	Exemplo
PUT	Substitui todo o objeto	Enviar todos os campos
PATCH	Modifica parcialmente	Enviar apenas os campos a modificar

// PUT — substitui tudo
@PutMapping("/{id}")
public UserDTO update(@PathVariable Long id, @RequestBody UserDTO dto) {
    // Todos os campos são sobrescritos
}

// PATCH — modifica parcialmente
@PatchMapping("/{id}")
public UserDTO patch(@PathVariable Long id, @RequestBody Map<String, Object> updates) {
    // Apenas os campos enviados são modificados
}

---

29. O que é uma Exception Custom?

// Exception personalizada
@ResponseStatus(HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

// Uso
public User findById(Long id) {
    return userRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("User not found: " + id));
}

// Tratamento global
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {
        return ResponseEntity.status(404)
            .body(new ErrorResponse(404, ex.getMessage()));
    }
}

public record ErrorResponse(int status, String message) {}

---

30. O que é Spring Actuator?

Endpoints de monitoramento prontos para uso:

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health, info, metrics

Endpoint	O que mostra
/actuator/health	Se a app está UP ou DOWN
/actuator/info	Informações da app
/actuator/metrics	Métricas (memória, CPU, requisições)
/actuator/env	Variáveis de ambiente

---

Resumo — Os 30 conceitos em 1 frase

Conceito	Em 1 frase
DTO	Objeto para transportar dados sem expor a entidade
MVC	Model (dados), View (apresentação), Controller (requisições)
API REST	Interface web que usa GET/POST/PUT/DELETE em URLs
CRUD	Create, Read, Update, Delete
POJO	Objeto Java simples sem dependência de framework
Bean	Objeto criado e gerenciado pelo Spring
IoC	O Spring cria as dependências em vez do código
ORM/JPA	Mapear objetos Java para tabelas SQL
Maven	Gerenciamento de dependências e build
Tomcat	Servidor web embutido no Spring Boot
JSON	Formato de dados leve (chave-valor)
Postman	Cliente para testar APIs
Swagger	Documentação automática da API
Docker	Container isolado para a aplicação
CI/CD	Build + teste + deploy automático
Git	Controle de versão do código fonte
Camadas	Controller → Service → Repository → DB
@Autowired	Injeção automática de dependências
Record	Classe imutável auto-gerada (Java 16+)
Lombok	Gera getters/setters/equals automaticamente
ResponseEntity	Resposta HTTP completa (status + body)
@Valid	Dispara a validação das entradas
application.yml	Arquivo de configuração do Spring Boot
Spring Security	Autenticação + autorização
JWT	Token para identificar o usuário
CORS	Permitir requisições cross-origin
Singleton	Uma única instância do bean em toda a app
PUT vs PATCH	PUT substitui tudo, PATCH modifica parcialmente
Exception Custom	Exception personalizada com código HTTP
Actuator	Monitoramento e métricas da aplicação

---

⬅️ Capítulo 7: Coleções Java | ⬅️ Voltar ao Módulo 18