Forem: Adilson Oliveira

Docker Multi-Stage para Aplicações JAVA 21

Adilson Oliveira — Tue, 11 Jun 2024 15:53:52 +0000

Para criar um Dockerfile com dois estágios para uma aplicação Java 21, você pode seguir um processo de multi-stage build. Isso ajuda a reduzir o tamanho da imagem final e garante que apenas os artefatos necessários sejam incluídos na imagem final de execução. Vamos seguir um exemplo com 2 estágios:

Primeiro estágio (build): Compilar a aplicação usando uma imagem que tenha o JDK 21.
Segundo estágio (runtime): Criar uma imagem mais leve apenas com o JRE para rodar a aplicação.

Estrutura do projeto

Deixei um projeto bem simples, feito em Spring Boot 3.3.0 que você pode baixar no meu github, que iremos seguir como exemplo:

/meu-projeto
|-- src
|   `-- main
|       `-- java
|           `-- com
|               `-- exemplo
|                   `-- DemoApplication.java
|                   `-- HelloWorldController.java
|-- pom.xml

Exemplo de Dockerfile

Se você baixar o projeto de exemplo, o Dockerfile já existe e você pode apenas acompanhar o artigo, caso esteja com no seu projeto crie um arquivo chamado Dockerfile na raiz do seu projeto:

# Etapa 1: Compilar a aplicação
FROM maven:3.9.7-eclipse-temurin-21-alpine AS build

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copia o arquivo pom.xml e os arquivos de dependências para o diretório de trabalho
COPY pom.xml ./
COPY src ./src

# Compila a aplicação
RUN mvn package

# Etapa 2: Criar a imagem final para execução
FROM eclipse-temurin:21-jre-alpine

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Cria um argumento para o nome da aplicação
ARG JAR_FILE=target/*.jar

# Copia o jar compilado da etapa anterior
COPY --from=build /app/${JAR_FILE} app.jar

# Expõe a porta da aplicação
EXPOSE 8080

# Define o comando padrão para rodar a aplicação
CMD ["java", "-jar", "app.jar"]

Explicação do Dockerfile

Primeiro estágio (build):

FROM maven:3.9.7-eclipse-temurin-21-alpine AS build: Usa uma imagem oficial do Maven base no Eclipse Temurin JDK 21 para compilar a aplicação.
WORKDIR /app: Define /app como o diretório de trabalho.
COPY pom.xml ./ e COPY src ./src: Copia os arquivos do projeto para dentro do contêiner.
RUN mvn package: Compila e cria o artefato da aplicação usando Maven.

Segundo estágio (runtime):

FROM eclipse-temurin:21-jre-alpine: Usa uma imagem oficial do Eclipse Temurin JRE 21 para executar a aplicação, resultando em uma imagem mais leve.
WORKDIR /app: Define /app como o diretório de trabalho.
COPY --from=build /app/target/minha-aplicacao.jar ./minha-aplicacao.jar: Copia o arquivo JAR compilado da etapa anterior para o diretório de trabalho.
CMD ["java", "-jar", "minha-aplicacao.jar"]: Define o comando padrão para executar a aplicação.

Passos para construir e rodar a imagem

Construir a imagem:

docker build -t minha-aplicacao:latest .

Executar o contêiner:

docker run -p 8080:8080 minha-aplicacao:latest

Teste a aplicação:

GET http://localhost:8080/hello

Vantagens da construção em dois estágios

Imagens mais leves:

Quando usamos multi-stage builds, a imagem final só contém os artefatos necessários para rodar a aplicação. Isso significa que todas as ferramentas de compilação e dependências de desenvolvimento não são incluídas, resultando em uma imagem mais leve e eficiente.

Segurança melhorada:

Reduzir o número de componentes na imagem final diminui a superfície de ataque, melhorando a segurança. Menos dependências e ferramentas significam menos possíveis vulnerabilidades.

Desempenho otimizado:

Imagens menores são mais rápidas para baixar e iniciar, o que é especialmente importante em ambientes de produção onde a eficiência e a velocidade são cruciais.

Separação de responsabilidades:

Dividir o processo em estágios distintos ajuda a manter uma separação clara entre as etapas de construção e execução. Isso facilita a manutenção e a compreensão do Dockerfile.

Conclusão

Construir imagens Docker em dois estágios é uma prática poderosa que traz eficiência e simplicidade. Com essa técnica, você cria imagens mais leves, seguras e fáceis de manter.
Espero que este guia tenha ajudado você a entender melhor essa prática e como implementá-la em seus projetos. Boa sorte e feliz codificação!

Codigo fonte: github

Você sabe o que é SOLID❓

Adilson Oliveira — Mon, 11 Mar 2024 02:32:28 +0000

Não tenha medo, S.O.L.I.D é um acrônimo que representa cinco princípios de design de software orientado a objetos. Cada letra corresponde a um princípio específico. Aqui está uma breve descrição de cada um, juntamente com um exemplo de código em Java:

➡️ S - Single Responsibility Principle (Princípio da Responsabilidade Única):

Descrição: Uma classe deve ter apenas um motivo para mudar, ou seja, ela deve ter apenas uma responsabilidade.

class Calculadora {
    public int soma(int a, int b) {
        return a + b;
    }
}

➡️ O - Open/Closed Principle (Princípio Aberto/Fechado):

Descrição: Uma classe deve estar aberta para extensão, mas fechada para modificação. Isso significa que você pode adicionar novas funcionalidades sem alterar o código existente.

interface Forma {
    double calcularArea();
}

class Quadrado implements Forma {
    public double calcularArea() {
        // lógica de cálculo de área para quadrado
    }
}

class Circulo implements Forma {
    public double calcularArea() {
        // lógica de cálculo de área para círculo
    }
}

➡️ L - Liskov Substitution Principle (Princípio da Substituição de Liskov):

Descrição: Subtipos devem ser substituíveis por seus tipos base sem alterar a corretude do programa.

class Retangulo {
    protected int largura;
    protected int altura;

    public void setLargura(int largura) {
        this.largura = largura;
    }

    public void setAltura(int altura) {
        this.altura = altura;
    }
}

class Quadrado extends Retangulo {
    public void setLargura(int lado) {
        this.largura = lado;
        this.altura = lado;
    }

    public void setAltura(int lado) {
        this.largura = lado;
        this.altura = lado;
    }
}

➡️ I - Interface Segregation Principle (Princípio da Segregação de Interfaces):

Descrição: Uma classe não deve ser forçada a implementar interfaces que ela não utiliza. Interfaces devem ser específicas para os clientes que as utilizam.

interface Trabalhador {
    void trabalhar();
    void descansar();
}

class Programador implements Trabalhador {
    public void trabalhar() {
        // lógica específica para programador
    }

    public void descansar() {
        // lógica específica para programador
    }
}

class Gerente implements Trabalhador {
    public void trabalhar() {
        // lógica específica para gerente
    }

    public void descansar() {
        // lógica específica para gerente
    }
}

➡️ D - Dependency Inversion Principle (Princípio da Inversão de Dependência):

Descrição: Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender de abstrações. Além disso, abstrações não devem depender de detalhes, mas detalhes devem depender de abstrações.

class Motor {
    public void ligar() {
        // lógica para ligar o motor
    }
}

interface Veiculo {
    void acelerar();
}

class Carro implements Veiculo {
    private Motor motor;

    public Carro(Motor motor) {
        this.motor = motor;
    }

    public void acelerar() {
        motor.ligar();
        // lógica específica para acelerar o carro
    }
}

Em conclusão, compreender e aplicar os princípios SOLID é crucial para desenvolver software robusto e flexível. Estes princípios fornecem uma base sólida para a construção de sistemas escaláveis, de fácil manutenção e extensíveis. 📚Ao continuar estudando e praticando esses conceitos, você estará investindo no aprimoramento das suas habilidades de design de software. Lembre-se de que a busca constante pelo conhecimento é essencial no campo do desenvolvimento de software, pois as tecnologias evoluem e novos desafios surgem. Continue explorando, participando de comunidades e projetos, e desafiando-se a aplicar esses princípios em seus próprios códigos. O compromisso com a excelência no design de software contribuirá significativamente para o seu desenvolvimento profissional. Continue estudando e progredindo!🚀

Formatar moeda de forma simples e rápida em JAVA

Adilson Oliveira — Wed, 15 Feb 2023 00:29:46 +0000

A formatação de moeda é uma tarefa comum em aplicativos Java que lidam com transações financeiras. A linguagem Java fornece uma classe java.text.NumberFormat para ajudar na formatação de valores numéricos, incluindo valores monetários. Neste artigo, vamos ver como usar a classe NumberFormat para formatar moeda.

Passo 1: Importe a classe NumberFormat
Para usar a classe NumberFormat, primeiro você precisa importá-la no seu código Java. Adicione a seguinte linha no início do seu código:

import java.text.NumberFormat;

Passo 2: Crie uma instância de NumberFormat
Para formatar um valor monetário, você precisa criar uma instância da classe NumberFormat. A classe NumberFormat é uma classe abstrata, portanto, você não pode criar uma instância diretamente. Em vez disso, você pode usar um dos métodos estáticos fornecidos pela classe NumberFormat para criar uma instância. Por exemplo, o método getCurrencyInstance() retorna uma instância da classe NumberFormat que pode ser usada para formatar valores monetários. Aqui está um exemplo:

NumberFormat currencyFormat = NumberFormat.getCurrencyInstance();

Passo 3: Formate o valor monetário
Depois de criar uma instância de NumberFormat, você pode usá-la para formatar um valor monetário. O método format() da classe NumberFormat recebe um valor numérico como parâmetro e retorna uma string formatada que representa o valor monetário. Aqui está um exemplo:

double value = 1234.56;
String formattedValue = currencyFormat.format(value);
System.out.println(formattedValue);

O resultado desse código seria:

R$1.234,56

O símbolo da moeda e o formato da string podem variar de acordo com a localidade padrão do sistema.

Passo 4: Personalize o formato
Você pode personalizar o formato da string formatada usando os métodos fornecidos pela classe NumberFormat. Por exemplo, o método setMaximumFractionDigits() define o número máximo de dígitos após a vírgula decimal na string formatada. Aqui está um exemplo:

currencyFormat.setMaximumFractionDigits(0);
String formattedValue = currencyFormat.format(value);
System.out.println(formattedValue);

O resultado desse código seria:

R$1.235

Isso define o número máximo de dígitos fracionários como zero, o que arredonda o valor para o inteiro mais próximo.

Conclusão
A classe NumberFormat fornece uma maneira fácil de formatar valores monetários em Java. Com algumas linhas de código, você pode criar uma instância de NumberFormat, formatar um valor monetário e personalizar o formato da string formatada. Usando a classe NumberFormat, você pode garantir que seus valores monetários sejam apresentados de forma consistente e fácil de entender para seus usuários.