Guia de desenvolvimento Java com Spring Boot

Configuração do Ambiente de Desenvolvimento

  1. Instale o Java Development Kit (JDK) em sua máquina. Você pode baixá-lo e instalá-lo a partir do site oficial da Oracle ou utilizar uma distribuição OpenJDK.

  2. Instale uma IDE (Ambiente de Desenvolvimento Integrado) de sua preferência para desenvolvimento Java. Algumas opções populares incluem IntelliJ IDEA, Eclipse e Spring Tool Suite (baseado no Eclipse e otimizado para desenvolvimento Spring).

  3. Instale o Spring Boot CLI (Command Line Interface) se preferir trabalhar com a linha de comando. Você pode baixá-lo do site oficial do Spring Boot.

Criação de um Projeto Spring Boot

  1. Crie um novo projeto Spring Boot usando uma IDE ou o Spring Initializr (https://start.spring.io/).

  2. Escolha as dependências necessárias para o seu projeto, como Spring Web, Spring Data JPA (para acesso a banco de dados), Spring Security (para segurança), etc.

  3. Importe o projeto em sua IDE e configure as dependências e configurações conforme necessário.

Configuração Básica do Projeto

Ao iniciar um projeto Spring Boot, é importante configurar corretamente o ambiente de desenvolvimento e as dependências do projeto. Aqui estão algumas práticas recomendadas para configurar um projeto Spring Boot de forma básica:

  1. Gradle com Kotlin como Melhor Alternativa ao Maven: Utilize o Gradle com Kotlin como uma alternativa mais moderna e flexível ao Maven para gerenciamento de dependências e construção de projetos. Aqui está um exemplo de um arquivo build.gradle.kts configurado com dependências do Spring Boot:
plugins {
    id("org.springframework.boot") version "2.6.3"
    id("io.spring.dependency-management") version "1.0.11.RELEASE"
}

group = "br.com.rea"
version = "1.0-SNAPSHOT"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}
repositories {
    mavenCentral()
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("org.springframework.boot:spring-boot-starter-security")
    implementation("org.springframework.boot:spring-boot-starter-validation")
    runtimeOnly("org.postgresql:postgresql")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
    testImplementation("org.springframework.boot:spring-boot-testcontainers")
    testImplementation("org.testcontainers:junit-jupiter")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

tasks.withType<Test> {
    useJUnitPlatform()
}

  1. Incluindo Dependências por Meio do Spring Starter IO: Use o Spring Initializr para incluir facilmente dependências do Spring Boot em seu projeto. Por exemplo, você pode adicionar as dependências do Spring Web, Spring Data JPA e Spring Security selecionando as opções correspondentes no Spring Initializr e gerando um projeto inicial com as dependências desejadas.

  2. Versão 21 do Java como Preferível: Utilize a versão mais recente e estável do Java, como a versão 17, como a preferível para desenvolver aplicativos Spring Boot. Garanta que sua IDE esteja configurada para usar a versão correta do JDK em seu projeto.

  3. Domínio das Aplicações como br.com.rea: Adote uma convenção de nomenclatura consistente para o domínio das suas aplicações, seguindo o padrão de mercado. Por exemplo, você pode definir o pacote base da sua aplicação como br.com.rea.myapp.

Desenvolvimento de Aplicações

  1. Criando Controladores: Crie controladores para definir endpoints da API. Use anotações como @RestController para definir um controlador REST e @RequestMapping para mapear endpoints.

  2. Definindo Entidades e Repositórios: Defina entidades JPA para representar dados no banco de dados e crie repositórios usando Spring Data JPA para acessar esses dados.

  3. Serviços: Crie serviços para implementar a lógica de negócios da sua aplicação. Injete repositórios e outras dependências necessárias nos serviços.

  4. Configuração de Segurança (Opcional): Se sua aplicação exigir autenticação e autorização, configure a segurança usando Spring Security. Defina configurações de segurança e crie classes de detalhes de usuário (user details) e provedores de autenticação conforme necessário.

Configurações em Geral

As configurações desempenham um papel importante em uma aplicação Spring Boot, permitindo personalizar o comportamento da aplicação, definir beans gerenciados pelo Spring e acessar valores de propriedades externas. Aqui estão algumas práticas recomendadas para lidar com configurações em uma aplicação Spring Boot:

  1. Definindo Beans com @Bean: Use a anotação @Bean para definir beans gerenciados pelo Spring. Isso permite que você crie e configure instâncias de classes e as disponibilize para injeção de dependência em outros componentes.
@Configuration
public class MyConfiguration {

    @Bean
    public MyService myService() {
        return new MyService();
    }
}
  1. Utilidade da Configuração @Configuration: Use a anotação @Configuration para indicar que uma classe contém métodos de configuração de beans do Spring. Isso permite que o Spring Boot carregue automaticamente essas configurações durante a inicialização da aplicação.
@Configuration
public class MyConfiguration {

    @Bean
    public MyService myService() {
        return new MyService();
    }
}
  1. Trabalhando com Injeção de Variáveis com @Value: Use a anotação @Value para injetar valores de propriedades externas em seus componentes Spring. Isso permite que você configure facilmente propriedades como URLs de banco de dados, chaves de API, entre outras.
@Service
public class MyService {

    @Value("${myapp.api.url}")
    private String apiUrl;

    // Métodos do serviço
}
  1. Utilizando application.yml em vez de application.properties: Prefira usar o formato YAML (application.yml) para configurar propriedades externas em sua aplicação Spring Boot em vez de usar o formato de propriedades (application.properties). O YAML oferece uma sintaxe mais legível e organizada para definir configurações.
# application.yml
myapp:
  api:
    url: https://api.example.com

Criando Controladores (Controllers)

Os controladores desempenham um papel crucial em uma aplicação Spring Boot, pois são responsáveis por definir endpoints RESTful e lidar com solicitações HTTP. Aqui estão algumas práticas recomendadas ao criar controladores em uma aplicação Spring Boot:

  1. Anote os Controladores com @RestController: Use a anotação @RestController para indicar que uma classe é um controlador RESTful. Isso permite que o Spring Boot trate automaticamente a serialização e desserialização de objetos JSON para as solicitações HTTP.
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    // Métodos do controlador aqui
}
  1. Anote os Controladores com @RequestMapping: Sempre use a anotação @RequestMapping para definir o ponto de partida do recurso REST. Dessa forma os controladores podem centralizar a oferta de recursos do mesmo tipo. Os nomes dos recursos centrais devem refletir a entidade de domínio a que se destina e sempre no plural.
@RestController
@RequestMapping(value = "/usuarios")
public class UserController {
    // Métodos do controlador aqui
}
  1. Defina Endpoints HTTP: Use métodos de instância para definir endpoints HTTP em seu controlador. Anote esses métodos com anotações como @GetMapping, @PostMapping, @PutMapping e @DeleteMapping para mapear solicitações HTTP GET, POST, PUT e DELETE, respectivamente.
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@GetMapping("/{id}")
public User getUserById(@PathVariable Long id) {
    // Lógica para recuperar um usuário pelo ID
}
  1. Sempre utilize ResponseEntity: A classe utilitária ResponseEntity auxilia na construção da resposta REST, trazendo uma estrutura completa e padronizada de conteúdo e status http. Ela facilita inclusive na devolução de respostas dependendo do resultado da execução, utilizando a interface java Optional.

Exemplo de Listagem:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@GetMapping
public ResponseEntity<List<User>> getAll() {
    return ResponseEntity.ok(
            // Lógica para recuperar usuários
    );
}

Neste exemplo uma lista será retornada caso haja valores e uma lista vazia será retornada caso contrário. De qualquer forma o requisitante não ficará sem resposta.

Exemplo de resposta unitária:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@GetMapping("/{id}")
public ResponseEntity<User> getUserById(@PathVariable Long id) {
    return ResponseEntity.of(
            Optional.ofNullable(
                    // Lógica para recuperar um usuário pelo ID
            )
    );
}

Neste exemplo, um valor unitário será devolvido e caso não seja encontrado uma resposta 404 será automaticamente gerada pelo Spring.

  1. Sempre valide os objetos de entrada: Objetos de entrada devem ser POJOs, sendo a melhor forma de utilizados dentro das camadas da aplicação como DTOs. Estes DTOs, devem estar corretamente anotados com as validações necessárias a não permitir a entrada de dados inválidos para as demais camadas.

Exemplo de utilização das anotações de validação:

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;

public class UserDTO {

    @NotNull(message = "ID não pode ser nulo")
    private Long id;

    @NotBlank(message = "O nome é obrigatório")
    @Size(min = 2, max = 30, message = "O nome deve ter entre 2 e 30 caracteres")
    private String name;

    @NotBlank(message = "O email é obrigatório")
    @Email(message = "Email deve ser válido")
    private String email;

}

Exemplo de ativação da funcionalidade de validação em nível de endpoint:

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import jakarta.validation.Valid;

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

    @PostMapping
    public ResponseEntity<String> createUser(@Valid @RequestBody UserDTO userDTO) {
        // Lógica para salvar o usuário
        return new ResponseEntity<>("Usuário criado com sucesso", HttpStatus.CREATED);
    }
}

É responsabilidade da camada de Controle a filtragem de dados inválidos.

  1. Sempre utilize @ControllerAdvice: @ControllerAdvice é uma anotação poderosa usada para tratar exceções de forma centralizada em toda a aplicação. Ela permite que você defina métodos que serão executados automaticamente quando determinadas exceções forem lançadas pelos seus controladores.

Exemplo de Listagem:

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<?> handleResourceNotFoundException(ResourceNotFoundException ex, WebRequest request) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<?> handleGlobalException(Exception ex, WebRequest request) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

É um bom padrão utilizar esta classe para definir a resposta padrão para Exceções Inesperadas e Exceções de Negócio, padronizando respostas com status corretos como 400 em caso de erro de negócios.

  1. Injeção de Dependência por Meio do Construtor: Prefira a injeção de dependência por meio do construtor em vez do @Autowired. Isso torna o código mais limpo, legível e testável, seguindo o princípio de inversão de controle (IoC).
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@RestController
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }
}
  1. Evite Lógica de Negócios no Controlador: Mantenha seus controladores simples e focados em lidar com solicitações HTTP e delegue a lógica de negócios para serviços separados. Isso torna seu código mais modular, reutilizável e fácil de testar.

Criando Serviços (Services)

Os serviços desempenham um papel fundamental em uma aplicação Spring Boot, encapsulando a lógica de negócios e facilitando a separação de responsabilidades. Aqui estão algumas práticas recomendadas ao criar serviços em uma aplicação Spring Boot:

  1. Injeção de Dependência por Meio do Construtor: Prefira a injeção de dependência por meio do construtor em vez do @Autowired. Isso torna o código mais limpo, legível e testável, seguindo o princípio de inversão de controle (IoC).
import org.springframework.stereotype.Service;

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

  1. Separação de Responsabilidades: Mantenha seus serviços focados em tarefas específicas e relacionadas à lógica de negócios. Evite incluir lógica relacionada à infraestrutura ou à apresentação em seus serviços, mantendo a separação de responsabilidades e tornando seus serviços mais coesos e reutilizáveis.

  2. Importância de Métodos Mnemônicos: Use nomes significativos e mnemônicos para os métodos em seus serviços, seguindo as convenções de nomenclatura Java. Isso torna o código mais legível e compreensível para outros desenvolvedores que podem precisar revisar ou dar manutenção ao seu código no futuro.

public class UserService {
    public User getUserById(Long id) {
        // Implementação do método
    }

    public void saveUser(User user) {
        // Implementação do método
    }

    // Outros métodos do serviço
}
  1. Preocupação com a Complexidade Ciclomática: Evite a complexidade excessiva em seus métodos e classes, especialmente a complexidade ciclomática, que pode tornar o código difícil de entender e manter. Procure dividir métodos complexos em métodos menores e mais simples, seguindo o princípio de responsabilidade única (SRP).
public class UserService {
    public List<User> getUsersWithAgeGreaterThan(int age) {
        // Implementação do método
    }

    public List<User> getUsersWithRole(Role role) {
        // Implementação do método
    }

    // Outros métodos do serviço
}

Criando Repositórios (Repositories)

Os repositórios desempenham um papel fundamental em uma aplicação Spring Boot, facilitando o acesso e a manipulação de dados no banco de dados. Aqui estão algumas práticas recomendadas ao criar repositórios em uma aplicação Spring Boot:

  1. Uso de Projeção com Constructor Query ou Interfaces: Ao recuperar dados do banco de dados, é importante considerar o uso de projeções para evitar o carregamento desnecessário de toda a entidade. Use Constructor Query ou interfaces para selecionar apenas os campos necessários, reduzindo o tráfego de rede e melhorando o desempenho.
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Projeção usando Constructor Query
    @Query("SELECT new com.example.dto.UserProjection(u.id, u.name) FROM User u WHERE u.id = :userId")
    UserProjection findUserProjectionById(@Param("userId") Long userId);

    // Ou projeção usando interfaces
    UserProjectionByIdAndName findById(Long id);
}
  1. Utilização de Text Blocks para Escrita de Queries: Use text blocks (bloco de texto) para escrever consultas SQL mais complexas de forma mais legível e organizada. Os text blocks estão disponíveis a partir do Java 13 e permitem que você insira diretamente consultas SQL no código Java sem a necessidade de concatenar strings.
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    @Query("""
            SELECT u FROM User u
            WHERE u.age > :age
            AND u.isActive = true
            """)
    List<User> findActiveUsersWithAgeGreaterThan(@Param("age") int age);
}
  1. Forma Mais Atual de Passar Parâmetros para as Queries: Utilize o @Param ou :nome_parametro para passar parâmetros para as queries. Essa é a forma mais atual e recomendada de passar parâmetros, garantindo a segurança contra injeção de SQL e facilitando a legibilidade do código.
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Usando @Param
    @Query("SELECT u FROM User u WHERE u.email = :email")
    User findByEmail(@Param("email") String email);

    // Ou usando :nome_parametro
    @Query("SELECT u FROM User u WHERE u.username = :username")
    User findByUsername(String username);
}

Testando e Executando

  1. Testes Unitários e de Integração: Escreva testes unitários e de integração para testar sua lógica de negócios e endpoints da API. Use ferramentas como JUnit e Mockito para escrever e executar testes.

  2. Executando o Projeto: Execute o projeto Spring Boot em sua IDE ou usando a linha de comando. O Spring Boot fornece um servidor embutido, tornando o processo de execução simples.

Testando com Testcontainers para Simular o Banco de Dados

Testcontainers é uma biblioteca Java que permite criar e gerenciar contêineres Docker durante os testes de unidade e integração. Isso é especialmente útil para simular o banco de dados em testes, garantindo que o ambiente de teste seja o mais próximo possível do ambiente de produção. Aqui estão os passos para usar Testcontainers em seus testes com Spring Boot:

  1. Adicione as Dependências do Testcontainers: No arquivo build.gradle.kts ou pom.xml do seu projeto, adicione as dependências necessárias para Testcontainers. Por exemplo, no Gradle:
dependencies {
    testImplementation("org.testcontainers:testcontainers:1.16.3")
    testImplementation("org.testcontainers:junit-jupiter:1.16.3")
    // Dependências específicas para o banco de dados que você deseja testar, como PostgreSQL, MySQL, etc.
}
  1. Escreva Testes Utilizando Testcontainers: Escreva testes de unidade ou integração que usem Testcontainers para iniciar um contêiner Docker com o banco de dados desejado antes dos testes e encerre o contêiner após os testes. Aqui está um exemplo de teste que usa um contêiner PostgreSQL:
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.beans.factory.annotation.Value;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@SpringBootTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
public class UserRepositoryIntegrationTest {

    @Container
    private static final PostgreSQLContainer<?> postgreSQLContainer = new PostgreSQLContainer<>("postgres:latest")
            .withDatabaseName("test")
            .withUsername("test")
            .withPassword("test");

    @Value("${spring.datasource.url}")
    private String dataSourceUrl;

    @Test
    public void testSaveUser() {
        // Lógica do teste aqui
    }
}
  1. Configuração do Banco de Dados no application.yml: Configure o application.yml do seu projeto Spring Boot para usar o banco de dados do Testcontainers durante os testes. Por exemplo, para usar o PostgreSQL:
spring:
  datasource:
    url: jdbc:tc:postgresql:///test
    username: test
    password: test
    driver-class-name: org.testcontainers.jdbc.ContainerDatabaseDriver
  1. Execute os Testes: Execute os testes normalmente usando sua IDE ou ferramenta de build preferida. Testcontainers iniciará automaticamente o contêiner Docker com o banco de dados necessário antes dos testes e encerrará o contêiner após a conclusão dos testes.

Observando e debugando

A observabilidade em um microserviço Spring Boot é crucial para monitorar, debugar, e manter a aplicação em funcionamento de maneira eficiente. A observabilidade inclui logging, tracing e métricas, todos essenciais para entender o comportamento da aplicação.

  1. Logging com Logback: Logback é uma implementação popular do SLF4J (Simple Logging Facade for Java) usada frequentemente com Spring Boot para logging. A configuração do Logback pode ser feita usando um arquivo XML (logback.xml).
<configuration>

    <!-- Define the log level for the application -->
    <logger name="com.example" level="DEBUG"/>

    <!-- Console appender configuration -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- File appender configuration -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/app.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- Daily rollover -->
            <fileNamePattern>logs/app.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!-- Keep 30 days worth of history -->
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Root logger configuration -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>

</configuration>
  1. Utilizando o log: Após a configuração do logback é possível utiliza-lo para declarar informações durante a execução do código. Por meio da anotação @Slf4j a classe estática log estará disponível para utilização dos métodos de declaração, cada um oferecendo um nível de criticidade.
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("/api")
public class LoggingController {

    @GetMapping("/log")
    public String logExample() {
        log.info("Endpoint /log foi acessado");
        log.debug("Mensagem de debug para o endpoint /log");
        return "Logging Example";
    }
}

É de suma importancia que os logs sejam utilizados com parcimonia. O uso exagerado dos logs pode acarretar em custos e dificuldades de análise corretiva.

  1. Tracing com Micrometer: Tracing ajuda a monitorar e rastrear a execução das requisições em uma arquitetura de microserviços, facilitando a identificação de problemas de desempenho e gargalos. A dependencia micrometer-tracing-bridge-brave integra automaticamente o suporte ao tracing distribuído nos aplicativos Spring Boot.

Basta incluir a dependencia:

dependencies {
  implementation("io.micrometer:micrometer-tracing-bridge-brave")
}
  1. Monitoramento e métricas com Actuator: O Spring Boot Actuator fornece endpoints que permitem monitorar e gerenciar a aplicação. Ele oferece métricas, informações de saúde, e mais.

Incluindo a dependencia:

dependencies {
  implementation("org.springframework.boot:spring-boot-starter-actuator")
}

Configurando os endpoints disponíveis:

management:
  endpoints:
   health:
     show-details: always
   web:
    exposure:
      include: *

Após esta configuração, é possível acessar endpoints como /actuator/health, /actuator/metrics, /actuator/env, etc.

  1. Implementando o próprio heath-check: Por vezes é necessário verificar os recursos que a aplicação utiliza estão saudáveis para oferecer uma informação mais consistente a respeito da disponibilidade da própria aplicação. O Actuator oferece uma interface simples para a construção de uma verificação detalhada da saúda do serviço.
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class HealthConfig {

    @Bean
    public HealthIndicator exampleHealthIndicator() {
        return () -> Health.up().withDetail("example", "All systems operational").build();
    }
}

Padrões de nomenclatura

A padronização dos nomes de métodos em projetos Java é crucial para manter o código limpo, compreensível e fácil de manter. Deve ser utilizado o padrão de nomes e comentários em:

Em Inglês:

  1. Padrão Internacional: O inglês é amplamente utilizado na comunidade de desenvolvimento, o que facilita a colaboração com desenvolvedores internacionais e a utilização de bibliotecas e frameworks que já seguem essa convenção.
  2. Consistência com Frameworks: Muitos frameworks Java (incluindo Spring) utilizam nomes em inglês, então seguir essa convenção pode tornar a integração mais natural.
  3. Documentação e Exemplos: A maioria da documentação e exemplos encontrados online estará em inglês, o que pode ser uma vantagem.

Nomeação de Métodos por Camada

Repositories

Na camada de repositórios, os métodos geralmente remetem a operações específicas no banco de dados. Nomes comuns incluem: - findBySomething: Busca por um ou mais atributos. - save: Salva uma entidade. - deleteById: Deleta uma entidade pelo ID. - existsBySomething: Verifica a existência de uma entidade com base em um atributo. - count: Conta o número de entidades.

Exemplos: - findByUsername(String username) - save(User user) - deleteById(Long id) - existsByEmail(String email)

Service

Na camada de serviço, os métodos geralmente representam operações de negócios. Nomes comuns incluem: - getSomething: Recupera algo. - createSomething: Cria algo. - updateSomething: Atualiza algo. - deleteSomething: Deleta algo. - processSomething: Processa alguma informação.

Exemplos: - getUserById(Long id) - createUser(UserDto userDto) - updateUser(Long id, UserDto userDto) - deleteUser(Long id) - processOrder(OrderDto orderDto)

Controller

Na camada de controle, os métodos geralmente representam endpoints de API e seguem convenções de operações HTTP. Nomes comuns incluem: - get: Para operações HTTP GET. - post: Para operações HTTP POST. - put: Para operações HTTP PUT. - delete: Para operações HTTP DELETE.

Exemplos: - getUser(Long id) (HTTP GET) - createUser(UserDto userDto) (HTTP POST) - updateUser(Long id, UserDto userDto) (HTTP PUT) - deleteUser(Long id) (HTTP DELETE)

Boas Práticas

  1. Consistência: Independentemente de escolher português ou inglês, mantenha a consistência em todo o projeto.
  2. Clareza: Nomes de métodos devem ser descritivos e refletir claramente a operação realizada.
  3. Padrões de Nomenclatura: Siga as convenções de nomenclatura do Java (camelCase para métodos e variáveis, PascalCase para classes).

Implantação e Gerenciamento

  1. Empacotamento e Implantação: Empacote sua aplicação Spring Boot em um arquivo JAR executável usando o plugin Spring Boot Maven ou Gradle. Você pode implantar o arquivo JAR em servidores de aplicativos, contêineres Docker ou em plataformas de nuvem.

  2. Monitoramento e Gerenciamento: Use ferramentas de monitoramento e gerenciamento como Spring Boot Admin, Actuator e outros para monitorar e gerenciar o desempenho e a saúde da sua aplicação em produção.