Introdução

Antes de falar de Spring Boot, microsserviços, Kafka e arquitetura bonita, tem uma coisa básica que muita gente apanha: ambiente de desenvolvimento.

E aqui não tem glamour. Se o Java tá mal instalado, se o JAVA_HOME tá torto, se o Maven aponta pra outra versão ou se o terminal não reconhece nada, acabou a festa. É aquele clássico: o dev quer subir um backend enterprise, mas o terminal responde “comando não encontrado”. Bonito igual fusca sem roda.

Neste tutorial, vamos configurar um ambiente Java moderno para 2026 usando Java 26, tanto no Windows quanto no macOS, com ferramentas reais de mercado.

Java 26 é a versão mais recente do Java SE Platform, enquanto Java 25 é a versão LTS mais recente. Isso é importante: para estudo, artigos e features novas, Java 26 faz sentido; para projeto corporativo conservador, Java 25 LTS pode ser mais seguro.

1. O que vamos instalar

Neste guia, vamos preparar:

Java 26
Maven
Gradle
Git
IntelliJ IDEA
VS Code
Docker
Postman ou Insomnia
SDKMAN no macOS
NVM para Node.js

Para backend Java moderno, o kit base é esse. O resto vem depois.

2. Instalando o Java 26 no Windows

2.1 Baixar o JDK 26

Você pode baixar pelo site oficial da Oracle ou pelos builds OpenJDK. A página da Oracle lista o JDK 26 como release atual, e o OpenJDK também disponibiliza builds do JDK 26.

Procure por:

Windows x64 Installer

Baixe e instale normalmente.

2.2 Verificar instalação

Abra o PowerShell e rode:

java --version

Resultado esperado parecido com:

java 26.x.x
Java(TM) SE Runtime Environment
Java HotSpot(TM) 64-Bit Server VM

Depois:

javac --version

Se aparecer javac 26, está no caminho certo.

3. Configurando JAVA_HOME no Windows

Agora vem a parte onde muita gente tropeça.

3.1 Descobrir onde o Java foi instalado

Normalmente fica em:

C:\Program Files\Java\jdk-26

ou algo parecido:

C:\Program Files\Java\jdk-26.0.1

3.2 Criar variável JAVA_HOME

No Windows:

Menu Iniciar
Pesquisar: variáveis de ambiente
Editar as variáveis de ambiente do sistema
Variáveis de Ambiente
Nova variável do sistema

Crie:

Nome: JAVA_HOME
Valor: C:\Program Files\Java\jdk-26

Ajuste o caminho conforme sua instalação.

3.3 Adicionar Java no PATH

Na variável Path, adicione:

%JAVA_HOME%\bin

Depois feche e abra o terminal novamente.

Teste:

echo $env:JAVA_HOME
java --version
javac --version

4. Instalando Java 26 no macOS

No macOS, o jeito mais organizado é usar SDKMAN. Tradicionalmente, dev Java sempre sofreu com várias versões instaladas. SDKMAN resolve isso com elegância. Menos gambiarra, mais paz.

4.1 Instalar SDKMAN

No terminal:

curl -s "https://get.sdkman.io" | bash

Depois:

source "$HOME/.sdkman/bin/sdkman-init.sh"

Teste:

sdk version

4.2 Instalar Java 26

Liste versões disponíveis:

sdk list java

Procure uma distribuição com Java 26, por exemplo:

sdk install java 26-open

Ou outra distribuição disponível na sua lista.

Definir como padrão:

sdk default java 26-open

Verificar:

java --version
javac --version

5. Configurando JAVA_HOME no macOS

Se usar SDKMAN, normalmente ele já ajusta o ambiente. Mas para conferir:

echo $JAVA_HOME

Se precisar adicionar manualmente no ~/.zshrc:

export JAVA_HOME=$(/usr/libexec/java_home -v 26)
export PATH="$JAVA_HOME/bin:$PATH"

Depois:

source ~/.zshrc

Teste:

java --version

6. Instalando Maven

Maven continua sendo obrigatório em muito projeto Java corporativo. Pode reclamar, mas ele está lá firme, igual boleto no fim do mês.

Windows

Baixe o Apache Maven, extraia em:

C:\dev\apache-maven

Crie variável:

MAVEN_HOME=C:\dev\apache-maven

Adicione no Path:

%MAVEN_HOME%\bin

Teste:

mvn -version

macOS com Homebrew

brew install maven

Teste:

mvn -version

Confirme se o Maven está usando Java 26:

mvn -version

Ele deve mostrar algo como:

Java version: 26

7. Instalando Gradle

Gradle é muito usado em projetos modernos, principalmente com Spring Boot, Android e builds mais flexíveis.

Windows

Recomendo instalar via SDKMAN no WSL ou baixar manualmente. No Windows puro, baixe o Gradle e configure:

GRADLE_HOME=C:\dev\gradle

No Path:

%GRADLE_HOME%\bin

Teste:

gradle -version

macOS

brew install gradle

Teste:

gradle -version

8. Instalando Git

Windows

Instale o Git for Windows.

Depois teste:

git --version

Configure:

git config --global user.name "Seu Nome"
git config --global user.email "seu-email@email.com"

macOS

brew install git

Teste:

git --version

Configure:

git config --global user.name "Seu Nome"
git config --global user.email "seu-email@email.com"

9. Instalando IntelliJ IDEA

Para Java, o IntelliJ ainda é o padrão ouro. VS Code é bom, mas para Spring Boot pesado, IntelliJ segue sendo o canivete suíço.

Instale:

IntelliJ IDEA Community ou Ultimate

Plugins úteis

Lombok
Spring Boot
Docker
Database Tools
GitToolBox
SonarLint
CheckStyle

No IntelliJ:

File > Project Structure > SDKs > Add JDK 26

Depois:

Settings > Build Tools > Maven
Settings > Build Tools > Gradle

Garanta que Maven/Gradle usem o JDK 26.

10. Configurando VS Code para Java

Instale o VS Code e os plugins:

Extension Pack for Java
Spring Boot Extension Pack
Docker
GitLens
REST Client
Maven for Java
Gradle for Java

No terminal do VS Code:

java --version
mvn -version
gradle -version

Se funcionar dentro do terminal, está bonito.

11. Instalando Docker

Docker virou obrigatório. Backend moderno sem Docker é igual churrasco sem sal: até existe, mas ninguém respeita.

Windows

Instale:

Docker Desktop

Ative WSL 2 se necessário.

Teste:

docker --version
docker compose version

macOS

Instale Docker Desktop ou use alternativa como OrbStack.

Teste:

docker --version
docker compose version

12. Instalando Postman ou Insomnia

Para testar APIs:

Postman
Insomnia
HTTPie
REST Client no VS Code

Eu gosto do REST Client no VS Code para documentação junto do projeto:

GET http://localhost:8080/api/v1/users
Authorization: Bearer token

Simples e versionável. Coisa fina.

13. Criando primeiro projeto Java 26 com Maven

Crie uma pasta:

mkdir java26-lab
cd java26-lab

Crie o projeto:

mvn archetype:generate \
  -DgroupId=com.nexucodeplay \
  -DartifactId=java26-lab \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

Entre:

cd java26-lab

Compile:

mvn clean package

Execute:

java -cp target/java26-lab-1.0-SNAPSHOT.jar com.nexucodeplay.App

14. Configurando Maven para Java 26

No pom.xml:

<properties>
    <maven.compiler.source>26</maven.compiler.source>
    <maven.compiler.target>26</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

Melhor ainda:

<properties>
    <java.version>26</java.version>
    <maven.compiler.release>26</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

15. Criando projeto Spring Boot com Java 26

Acesse o Spring Initializr e configure:

Project: Maven
Language: Java
Spring Boot: versão atual
Java: 26
Packaging: Jar

Dependências iniciais:

Spring Web
Spring Data JPA
PostgreSQL Driver
Validation
Lombok
Spring Boot DevTools
Spring Security
Actuator

Estrutura recomendada:

src/main/java/com/nexucodeplay/demo
 ├── DemoApplication.java
 ├── modules
 │   └── users
 │       ├── controller
 │       ├── service
 │       ├── repository
 │       ├── dto
 │       └── entity
 └── shared
     ├── exception
     ├── config
     └── response

16. Docker Compose para PostgreSQL

Crie docker-compose.yml:

services:
  postgres:
    image: postgres:17
    container_name: java26-postgres
    environment:
      POSTGRES_DB: java26db
      POSTGRES_USER: java26
      POSTGRES_PASSWORD: java26
    ports:
      - "5432:5432"
    volumes:
      - java26_postgres_data:/var/lib/postgresql/data

volumes:
  java26_postgres_data:

Subir:

docker compose up -d

Testar:

docker ps

17. application.yml base

server:
  port: 8080

spring:
  application:
    name: java26-api

  datasource:
    url: jdbc:postgresql://localhost:5432/java26db
    username: java26
    password: java26

  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: true
    properties:
      hibernate:
        format_sql: true

  flyway:
    enabled: true

18. Checklist final do ambiente

Rode tudo:

java --version
javac --version
mvn -version
gradle -version
git --version
docker --version
docker compose version

Se tudo responder bonito, ambiente fechado.

19. Erros comuns

Erro: java não reconhecido

Windows:

JAVA_HOME errado ou PATH sem %JAVA_HOME%\bin

macOS:

source ~/.zshrc

Maven usando Java antigo

Rode:

mvn -version

Se aparecer Java 17/21 em vez de 26, ajuste o JAVA_HOME.

IntelliJ usando outro JDK

Ajuste:

File > Project Structure > Project SDK
Settings > Build Tools > Gradle > Gradle JVM

Docker não sobe no Windows

Verifique:

WSL 2 instalado
Virtualização habilitada na BIOS
Docker Desktop iniciado

Conclusão

Ambiente Java bem configurado é a base do backend profissional.

Em 2026, um dev Java precisa dominar mais do que código:

JDK
Maven
Gradle
Git
Docker
IDE
Terminal
Banco
Spring Boot

Sem isso, qualquer projeto vira briga com máquina. E máquina ganha de teimoso, sempre.

Java 26 é excelente para estudar as novidades da linguagem e produzir conteúdo moderno. Para empresas mais conservadoras, Java 25 LTS continua sendo uma escolha mais estável por ser a versão LTS mais recente.