Quarkus e Dropwizard (microframeworks Java)

Duas alternativas ao Spring Boot para criar serviços Java enxutos e prontos para produção: o Quarkus, pensado para contêineres, Kubernetes e imagens nativas, e o Dropwizard, um kit minimalista que junta bibliotecas maduras. Comparar os três é pergunta comum em entrevistas de arquitetura e de microsserviços.

	Spring Boot	Quarkus	Dropwizard
Foco	Ecossistema completo, produtividade	Kubernetes-native, GraalVM, inicialização rápida	Simplicidade: "um JAR, um processo"
DI	Spring (IoC)	CDI (ArC, em tempo de build)	HK2 (opcional; Guice por bundle)
REST	Spring MVC / WebFlux	JAX-RS (RESTEasy; RESTEasy Reactive)	JAX-RS (Jersey)
Servidor HTTP	Tomcat/Jetty/Undertow/Netty	Vert.x/Netty (Undertow opcional)	Jetty
Persistência	Spring Data/JPA	Hibernate ORM com Panache	JDBI ou Hibernate
Configuração	application.properties/yml	application.properties/yaml	YAML + classe de configuração
Tamanho do ecossistema	Enorme	Grande e crescendo	Pequeno e estável

Quarkus

Definição: Quarkus

Quarkus é uma pilha Java "Kubernetes-native", otimizada para GraalVM e OpenJDK HotSpot, montada a partir de bibliotecas padrão do mercado (CDI, JAX-RS, JPA, MicroProfile, Vert.x). Faz muito trabalho em tempo de build (análise de anotações, geração de código) para iniciar rápido e gastar pouca memória.

Por que importa: processos de inicialização de milissegundos e poucas centenas de megabytes viabilizam serverless e escala a zero, densidade alta de contêineres e scale-out rápido; a aplicação pode ser compilada em executável nativo (GraalVM, -Pnative).

Começando e empacotando

# gerar um projeto (ou use code.quarkus.io)
mvn io.quarkus.platform:quarkus-maven-plugin:create -DprojectGroupId=org.acme -DprojectArtifactId=hello

./mvnw quarkus:dev                 # modo desenvolvimento (live coding)
./mvnw clean package               # JAR "fast-jar" (quarkus-app/) para a JVM
./mvnw clean package -Pnative      # executável nativo (precisa de GraalVM ou contêiner de build)

@Path("/hello")
public class GreetingResource {
    @GET @Produces(MediaType.TEXT_PLAIN)
    public String hello() { return "hello"; }
}

Tipos de empacotamento (quarkus.package.type): jar (padrão, "fast-jar"), uber-jar (tudo em um arquivo), legacy-jar e native. Há ainda modo de comando (@QuarkusMain / QuarkusApplication, integração com Picocli) para criar aplicações de linha de comando.

Experiência de desenvolvimento

• Modo dev com live coding: salva o arquivo e a aplicação recarrega sozinha.
• Dev Services: sobe automaticamente contêineres de apoio (banco, Kafka, Keycloak, Redis...) em desenvolvimento e testes, sem configuração.
• Dev UI: interface em /q/dev para explorar extensões, beans, configuração e executar ações.
• Testes contínuos: ao salvar, os testes relacionados rodam em segundo plano.
• Extensões (quarkus:add-extension) integram bibliotecas; cada recurso é uma extensão (Hibernate ORM, Kafka, OIDC...).

Configuração, perfis e injeção

• application.properties (ou YAML) com perfis: %dev., %test., %prod.; variáveis de ambiente sobrepõem propriedades (configuração externa ao código, boa prática de aplicações em contêineres). Injete com @ConfigProperty(name = "greeting.message") ou interfaces @ConfigMapping.
• CDI: @ApplicationScoped, @RequestScoped, @Inject, qualificadores (@Named), @Produces, interceptors e @Alternative; os beans são resolvidos em tempo de build (ArC), então beans não usados são removidos. Beans por perfil de Quarkus com @IfBuildProfile.
• JSON com Jackson ou JSON-B; validação com Bean Validation; logging configurável (quarkus.log.*, saída JSON/GELF); REST Client declarativo (@RegisterRestClient).

Persistência: Hibernate ORM com Panache

Panache simplifica o JPA: padrão Active Record (a entidade herda de PanacheEntity e tem persist(), find(), listAll()) ou Repository (PanacheRepository<T>). Suporta paginação, consultas simplificadas (find("nome", nome)), @NamedQuery, múltiplos datasources, transações com @Transactional, Hibernate Reactive e REST Data Panache (gera endpoints CRUD). Também há extensões para Flyway/Liquibase (migrações), MongoDB com Panache, Redis, Cassandra, Neo4j, DynamoDB, Elasticsearch (Hibernate Search) e multi-tenancy.

Reativo, mensageria e protocolos

• Mutiny (Uni/Multi) para programação reativa sobre Vert.x; RESTEasy Reactive executa na event loop (não bloqueie!).
• SmallRye Reactive Messaging para Kafka, AMQP, JMS: métodos com @Incoming/@Outgoing; também Kafka Streams (EDA).
• GraphQL, gRPC, WebSockets e Funqy (funções serverless portáveis para AWS Lambda, Azure Functions, Knative).

Segurança, resiliência e observabilidade

• Segurança: RBAC (@RolesAllowed), OpenID Connect/Keycloak, OAuth2, JWT, realms JDBC/JPA/LDAP, Vault (Segurança).
• Tolerância a falhas (MicroProfile Fault Tolerance): @Retry, @Timeout, @CircuitBreaker, @Fallback, @Bulkhead.
• Observabilidade: /q/health (liveness e readiness, @Liveness/@Readiness), métricas (Micrometer/MicroProfile, exportação Prometheus), traces com OpenTelemetry (SRE); OpenAPI e Swagger UI.

Testes

@QuarkusTest sobe a aplicação para o teste (injeção funciona nos testes), @QuarkusTestResource e QuarkusTestProfile ajustam o ambiente, e @QuarkusIntegrationTest/@NativeImageTest testam o artefato empacotado ou nativo. Use Rest-Assured para chamadas HTTP e o relatório de cobertura (JaCoCo).

Contêineres e Kubernetes

Extensões geram imagens de contêiner (quarkus-container-image-jib, Docker, Buildpacks) e manifestos Kubernetes/OpenShift/Knative a partir de anotações e propriedades (quarkus.kubernetes.*), além de um cliente Kubernetes e configuração via ConfigMap/Secret (Contêineres).

Dropwizard

Definição: Dropwizard

Dropwizard é um framework leve que reúne bibliotecas estáveis e maduras em um pacote simples para criar serviços web RESTful prontos para produção rapidamente, entre biblioteca e framework: Jetty (HTTP), Jersey (REST), Jackson (JSON), Metrics, Logback/SLF4J, Hibernate Validator, JDBI/Hibernate, Liquibase e outras.

Estrutura de uma aplicação:

Peça	Papel
Configuration	Classe Java mapeada de um arquivo YAML (validada com Hibernate Validator); aceita variáveis de ambiente
Application	Classe principal: initialize (registra bundles e comandos) e run (registra recursos, health checks, objetos gerenciados no Environment)
Representation	Classes de dados serializadas por Jackson (JSON)
Resource	Classe JAX-RS (Jersey) com @Path, @GET, @POST, @Produces; as dependências validam entradas (@Valid)
Health check	Verificação de saúde exposta pelo admin (/healthcheck), usada por balanceadores e monitoração
Managed objects	Objetos com start()/stop() ligados ao ciclo de vida do servidor (pools, schedulers)
Bundle	Pacote reutilizável que configura a aplicação (assets, migrações, Hibernate, autenticação)
Command	Comando de linha: server (sobe a aplicação), check (valida a configuração), db migrate
Task	Ação administrativa por HTTP (porta admin), como limpar cache

public class HelloApplication extends Application<HelloConfiguration> {
    public static void main(String[] args) throws Exception { new HelloApplication().run(args); }

    @Override
    public void run(HelloConfiguration config, Environment env) {
        env.jersey().register(new HelloResource(config.getTemplate()));
        env.healthChecks().register("template", new TemplateHealthCheck(config.getTemplate()));
    }
}

mvn package                                   # gera um "fat JAR" (shade), com tudo dentro
java -jar target/hello-1.0.jar server hello.yml   # aplicação na 8080 e admin na 8081

• Uma aplicação = um JAR = um processo: nada de servidor de aplicação; ideal para microsserviços.
• Dois portos: o de aplicação e o de administração (health checks, métricas, tasks).
• Dados: JDBI 3 (SQL direto com mapeamento leve), Hibernate com @UnitOfWork para transações em métodos de recurso e migrações com Liquibase (db migrate, db rollback).
• Cliente: Jersey Client ou Apache HttpClient com métricas e timeouts configuráveis. Autenticação: módulos de autenticação básica/OAuth/JWT. Validação: Hibernate Validator. Testes: DropwizardAppExtension (sobe a aplicação) e ResourceExtension (testa um recurso isolado).
• Logging com Logback (console, arquivo rotativo, syslog, JSON, assíncrono) configurável no YAML e ajustável em tempo de execução via task.
• Métricas embutidas (timers, meters, histogramas), exportáveis para Prometheus/Graphite.

Quando escolher

• Spring Boot: equipes grandes, ecossistema vasto (Data, Security, Cloud), contratação mais fácil.
• Quarkus: serviços em Kubernetes/serverless com necessidade de inicialização rápida e baixo consumo, uso de imagem nativa, padrões Jakarta/MicroProfile.
• Dropwizard: serviços REST simples e estáveis, com poucas dependências e comportamento previsível; menos ativo que os outros dois hoje.

Para responder em entrevista

Pergunta	Ideias para a resposta
"O que é Quarkus e por que é rápido?"	Pilha Kubernetes-native; trabalho em tempo de build (DI, análise), suporte a GraalVM native, menos reflexão em runtime
"Quarkus x Spring Boot?"	Spring: ecossistema e produtividade; Quarkus: startup/memória, native, CDI/JAX-RS/MicroProfile; ambos suportam REST, ORM, segurança e observabilidade
"O que é Panache?"	Camada sobre Hibernate ORM com Active Record ou Repository para reduzir código repetitivo
"O que são Dev Services?"	Contêineres de apoio iniciados automaticamente em dev/teste
"O que é o Dropwizard?"	Kit de bibliotecas (Jetty, Jersey, Jackson, Metrics...) para serviços REST em um JAR, com health checks e admin
"Native image: prós e contras?"	Início instantâneo e pouca memória; build lento, reflexão e dinamismo restritos