Do Caos à Simplicidade: Começando com Spring Boot

Se você já trabalhou com Java antes da popularização do Spring Boot, deve lembrar como era desgastante configurar uma aplicação do zero. Criar um simples serviço web envolvia arquivos XML enormes, configurações manuais para o servidor, e um verdadeiro malabarismo para resolver conflitos entre dependências.

Imagine a seguinte situação: você precisa construir uma API REST para gerenciar um cadastro de clientes. Antes do Spring Boot, isso significava:

• Configurar um servidor web, como Tomcat ou Jetty.
• Declarar todas as dependências manualmente no Maven ou Gradle.
• Criar configurações XML para que o Spring reconhecesse os componentes corretamente.
• Definir todas as configurações de conexão com banco de dados, pool de conexões, dialetos do Hibernate, entre outros detalhes.
• Escrever código extra apenas para iniciar a aplicação, antes mesmo de chegar à lógica de negócio.

No fim, o projeto acumulava uma pilha de arquivos antes mesmo de exibir um “Hello, World” no navegador. Era trabalhoso e cansativo.

Spring Boot e a Revolução da AutoConfiguração

O Spring Boot surgiu como uma resposta direta a esse excesso de configuração. A ideia central era simples: e se a maior parte dessas configurações fosse feita automaticamente?

Em vez de forçar o desenvolvedor a definir cada detalhe, o framework assume configurações padrão inteligentes e permite que o código seja escrito de forma mais fluida.

Por exemplo, digamos que queremos criar um simples endpoint REST para listar clientes. Em um projeto tradicional, isso exigiria várias configurações. Com Spring Boot, basta adicionar a dependência certa e escrever um controlador como este:

<span>@RestController</span>
<span>@RequestMapping</span><span>(</span><span>"/clientes"</span><span>)</span>
<span>public</span> <span>class</span> <span>ClienteController</span> <span>{</span>
    <span>@GetMapping</span>
    <span>public</span> <span>String</span> <span>listarClientes</span><span>()</span> <span>{</span>
        <span>return</span> <span>"Lista de clientes"</span><span>;</span>
    <span>}</span>
<span>}</span>
<span>@RestController</span>
<span>@RequestMapping</span><span>(</span><span>"/clientes"</span><span>)</span>
<span>public</span> <span>class</span> <span>ClienteController</span> <span>{</span>

    <span>@GetMapping</span>
    <span>public</span> <span>String</span> <span>listarClientes</span><span>()</span> <span>{</span>
        <span>return</span> <span>"Lista de clientes"</span><span>;</span>
    <span>}</span>
<span>}</span>
@RestController
@RequestMapping("/clientes")
public class ClienteController {

    @GetMapping
    public String listarClientes() {
        return "Lista de clientes";
    }
}

Enter fullscreen mode Exit fullscreen mode

Rodamos a aplicação e pronto: o servidor já está no ar, ouvindo requisições na porta 8080, sem que precisássemos configurar nada manualmente.

E Quanto ao Banco de Dados?

A facilidade se estende à camada de persistência. Em um projeto sem Spring Boot, configurar um banco PostgreSQL, por exemplo, exigiria definir um DataSource, configurar dialetos do Hibernate, ajustar propriedades do JPA e muito mais.

Com Spring Boot, basta adicionar as dependências certas no pom.xml:

<span><dependency></span>
    <span><groupId></span>org.springframework.boot<span></groupId></span>
    <span><artifactId></span>spring-boot-starter-data-jpa<span></artifactId></span>
<span></dependency></span>
<span><dependency></span>
    <span><groupId></span>org.postgresql<span></groupId></span>
    <span><artifactId></span>postgresql<span></artifactId></span>
<span></dependency></span>
<span><dependency></span>
    <span><groupId></span>org.springframework.boot<span></groupId></span>
    <span><artifactId></span>spring-boot-starter-data-jpa<span></artifactId></span>
<span></dependency></span>

<span><dependency></span>
    <span><groupId></span>org.postgresql<span></groupId></span>
    <span><artifactId></span>postgresql<span></artifactId></span>
<span></dependency></span>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
</dependency>

Enter fullscreen mode Exit fullscreen mode

E definir as propriedades no application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/meubanco
spring.datasource.username=usuario
spring.datasource.password=senha
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:postgresql://localhost:5432/meubanco
spring.datasource.username=usuario
spring.datasource.password=senha
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:postgresql://localhost:5432/meubanco
spring.datasource.username=usuario
spring.datasource.password=senha
spring.jpa.hibernate.ddl-auto=update

Enter fullscreen mode Exit fullscreen mode

A partir daí, o Spring Boot detecta as configurações e faz todo o trabalho pesado por nós. Criamos uma entidade e um repositório, e já conseguimos salvar e recuperar dados do banco:

<span>@Entity</span>
<span>public</span> <span>class</span> <span>Cliente</span> <span>{</span>
    <span>@Id</span>
    <span>@GeneratedValue</span><span>(</span><span>strategy</span> <span>=</span> <span>GenerationType</span><span>.</span><span>IDENTITY</span><span>)</span>
    <span>private</span> <span>Long</span> <span>id</span><span>;</span>
    <span>private</span> <span>String</span> <span>nome</span><span>;</span>
    <span>// Getters e setters</span>
<span>}</span>
<span>public</span> <span>interface</span> <span>ClienteRepository</span> <span>extends</span> <span>JpaRepository</span><span><</span><span>Cliente</span><span>,</span> <span>Long</span><span>></span> <span>{</span>
<span>}</span>
<span>@Entity</span>
<span>public</span> <span>class</span> <span>Cliente</span> <span>{</span>
    <span>@Id</span>
    <span>@GeneratedValue</span><span>(</span><span>strategy</span> <span>=</span> <span>GenerationType</span><span>.</span><span>IDENTITY</span><span>)</span>
    <span>private</span> <span>Long</span> <span>id</span><span>;</span>
    <span>private</span> <span>String</span> <span>nome</span><span>;</span>

    <span>// Getters e setters</span>
<span>}</span>

<span>public</span> <span>interface</span> <span>ClienteRepository</span> <span>extends</span> <span>JpaRepository</span><span><</span><span>Cliente</span><span>,</span> <span>Long</span><span>></span> <span>{</span>
<span>}</span>
@Entity
public class Cliente {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nome;

    // Getters e setters
}

public interface ClienteRepository extends JpaRepository<Cliente, Long> {
}

Enter fullscreen mode Exit fullscreen mode

O Verdadeiro Impacto do Spring Boot

A grande sacada do Spring Boot não é apenas reduzir o código de configuração, mas mudar a maneira como desenvolvemos aplicações. Antes, grande parte do tempo era gasto apenas para fazer a infraestrutura funcionar. Agora, conseguimos focar no que realmente importa: a lógica de negócio.

Isso não significa que o Spring Boot seja perfeito para qualquer cenário. Em sistemas muito grandes, pode ser necessário otimizar algumas dessas configurações padrão para evitar sobrecarga desnecessária. Mas para a maioria dos projetos, a economia de tempo e esforço é significativa.

No final das contas, Spring Boot não eliminou a complexidade do desenvolvimento Java. Ele apenas decidiu que os desenvolvedores não deveriam lidar com ela o tempo todo.

E você, já passou pelo sofrimento das configurações manuais no Java? Como foi sua experiência com o Spring Boot?

原文链接：Do Caos à Simplicidade: Começando com Spring Boot