Maven vs Gradle em projetos Java: Qual escolher?

No ecossistema Java, ferramentas de build automation são fundamentais para compilar código, gerenciar dependências, executar testes e gerar artefatos como JAR ou WAR. As duas ferramentas mais utilizadas são Apache Maven e Gradle.

Ambas resolvem o mesmo problema, automatizar o ciclo de build de aplicações Java, porém utilizam abordagens diferentes.

No presente artigo vamos analisar:

• O que são Maven e Gradle
• Como cada um funciona
• Prós e contras
• Quando usar cada ferramenta em projetos Java

O que é Maven?

Apache Maven é uma ferramenta de build criada pela Apache Software Foundation e lançada em 2004.

Seu principal objetivo é padronizar o processo de build em projetos Java.

Ele utiliza um arquivo chamado pom.xml (Project Object Model) onde são declarados:

• dependências
• plugins
• versão do projeto
• configuração de build
• repositórios

Exemplo do arquivo pom.xml para o projeto Spring Framework 7 com Java 21 + JUnit + cobertura mínima de 80%

pom.xml

O Maven segue o princípio Convention over Configuration, ou seja, ele já possui uma estrutura padrão:

src/main/java
src/main/resources
src/test/java
src/test/resources

Essa padronização facilita a colaboração entre equipes.

O que é Gradle?

Gradle surgiu em 2012 como uma alternativa mais flexível e performática ao Maven.

Ele utiliza uma DSL baseada em Groovy ou Kotlin para definir o build.

Exemplo de arquivo build.gradle para o projeto Spring Framework 7 e Java 21 + JUnit + cobertura mínima de 80%:

build.gradle

O Gradle foi projetado para:

• builds mais rápidos
• maior flexibilidade
• melhor suporte a projetos complexos

Hoje ele é amplamente usado em projetos modernos, incluindo o build padrão do Android Studio.

Diferenças conceituais

Característica	Maven	Gradle
Configuração	XML (pom.xml)	DSL baseada em Groovy ou Kotlin
Filosofia	Convention over Configuration	Alta flexibilidade e customização
Performance	Mais lento em builds grandes	Mais rápido com incremental build e cache
Curva de aprendizado	Mais simples para iniciantes	Maior devido à DSL programável
Customização	Limitada via plugins	Muito alta, com scripts programáveis

Prós do Maven

1. Padronização

O Maven impõe uma estrutura padrão para projetos.

Isso facilita:

onboarding de novos desenvolvedores

manutenção de projetos

integração entre equipes

2. Ecossistema maduro

O Maven possui milhares de plugins prontos.

Exemplos:

compilação

geração de documentação

análise de código

empacotamento

3. Simplicidade conceitual

Apesar do XML ser verboso, o modelo é simples:

clean
compile
test
package
install
deploy

Esse ciclo é chamado de build lifecycle.

4. Alta adoção corporativa

Muitas empresas utilizam Maven em aplicações enterprise, especialmente em projetos baseados em:

• Spring Framework
• Spring Boot
• aplicações legadas Java

Contras do Maven

1. XML verboso

Configurações simples podem virar arquivos grandes.

Exemplo comum: pom.xml com centenas de linhas.

2. Customização limitada

Criar pipelines complexos pode ser difícil.

3. Performance menor

Comparado ao Gradle, o Maven:

• recompila mais coisas
• possui menos otimizações

Prós do Gradle

1. Build mais rápido

Gradle implementa várias otimizações:

• incremental build
• build cache
• execução paralela

Isso reduz bastante o tempo de build em projetos grandes.

2. DSL mais expressiva

A configuração é escrita em Groovy ou Kotlin, permitindo:

• lógica condicional
• loops
• funções
• scripts reutilizáveis
3. Melhor para projetos grandes

Gradle funciona muito bem com:

• monorepos
• microservices
• builds multi-módulo
4. Flexibilidade extrema

É possível construir praticamente qualquer pipeline de build.

Contras do Gradle

1. Curva de aprendizado maior

Desenvolvedores precisam entender:

• Groovy ou Kotlin
• conceitos de tasks
• lifecycle do Gradle
2. Menos padronização

Como tudo pode ser customizado, projetos podem ficar inconsistentes entre equipes.

3. Debug de build mais complexo

Scripts muito dinâmicos podem dificultar troubleshooting.

Maven vs Gradle em projetos reais

Na prática, a escolha depende do tipo de projeto.

Use Maven quando:

• o projeto é corporativo tradicional
• a equipe prefere padronização
• builds não são extremamente complexos
• onboarding rápido é importante

Use Gradle quando:

• o projeto é grande ou modular
• erformance de build é crítica
• pipelines precisam de customização
• o projeto envolve Android

Tendências do ecossistema Java

Nos últimos anos, Gradle tem crescido bastante, especialmente em projetos modernos.

Entretanto, Maven ainda domina grande parte do mercado corporativo devido à sua estabilidade e padronização.

Ou seja:

• Maven -> estabilidade e padrão
• Gradle -> flexibilidade e performance

Considerações finais

Tanto Apache Maven quanto Gradle são excelentes ferramentas de build para projetos Java.

A escolha correta depende de fatores como:

• complexidade do projeto
• tamanho da equipe
• necessidade de customização
• tempo de build

Em termos simples:

• Maven é previsível e padronizado
• Gradle é poderoso e flexível

Um engenheiro de software moderno deve conhecer ambos, pois cada um continua sendo amplamente utilizado nas empresas.

Feito!

Conectando ao MS SQL Server com autenticação do usuário do Windows (Windows Authentication) em Java

Ao trabalhar com sistemas corporativos que utilizam o Microsoft SQL Server, é comum encontrar ambientes configurados para autenticação integrada do Windows. Isso significa que o acesso ao banco de dados é feito com base nas credenciais do usuário logado no sistema operacional, dispensando o uso de nome de usuário e senha definidos diretamente no banco.

Quando desenvolvemos aplicações Java que precisam se conectar ao SQL Server usando esse tipo de autenticação, é necessário realizar uma configuração específica no driver JDBC. Caso contrário, a aplicação não conseguirá autenticar corretamente o usuário e a conexão falhará.

Por que é necessário o arquivo msql-jdbc_auth.dll?

O driver oficial do SQL Server para Java, conhecido como Microsoft JDBC Driver for MS QL Server, oferece suporte à autenticação integrada do Windows através de uma biblioteca nativa chamada msql-jdbc_auth.dll.

Essa DLL atua como uma ponte entre o Java e as APIs do Windows responsáveis pela autenticação. Sem ela, o Java não teria acesso ao contexto de segurança do sistema operacional, e a tentativa de conexão com autenticação integrada resultaria em erro.

Em resumo, o Java precisa desse componente nativo para poder "herdar" as credenciais do usuário logado e repassá-las ao SQL Server de forma segura.

Passo a passo para configurar

1. Download o driver JDBC oficial

Acesse o site oficial da Microsoft e baixe o driver JDBC mais recente.

No momento da escrita deste artigo, a versão disponível é a 12.8.1, e o link direto de download é: https://go.microsoft.com/fwlink?linkid=2283744

2. Descompactar o pacote

Após o download, descompacte o arquivo. Dentro da pasta extraída você encontrará o driver mssql-jdbc-12.8.1.jar (ou .jre11, .jre17, conforme sua versão do Java) e também a biblioteca nativa msql-jdbc_auth-12.8.1.x64.dll.

3. Copiar a DLL para o diretório correto

Copie o arquivo msql-jdbc_auth-12.8.1.x64.dll para o diretório bin da instalação do Java.

Exemplo de caminho no Windows:

C:\Program Files\Java\jdk-17\bin

Esse diretório faz parte do java.library.path, o que garante que a JVM consiga localizar a DLL durante a execução.

4. Configurar a string de conexão

A string de conexão deve informar que será usada a autenticação integrada.

Exemplo:

String connectionUrl = "jdbc:sqlserver://localhost:1433;"
+ "databaseName=MinhaBase;"
+ "integratedSecurity=true;";
Connection conn = DriverManager.getConnection(connectionUrl);

Para projetos Spring Boot, configure no arquivo application.properties:

spring.datasource.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;integratedSecurity=true;
spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver

Caso use Quarkus, a configuração fica assim:

quarkus.datasource.jdbc.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;integratedSecurity=true;
quarkus.datasource.jdbc.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver

Observe o parâmetro integratedSecurity=true, que é o que ativa o uso da DLL para autenticação.

5. Executar a aplicação

Com a DLL no diretório correto e o driver JDBC configurado no classpath, sua aplicação Java será capaz de se conectar ao SQL Server utilizando as credenciais do usuário do Windows atual.

Configuração para Linux com Windows Authentication

Em sistemas Linux, a autenticação integrada não funciona nativamente com a DLL, pois ela é específica do Windows.

Nesse caso, o método recomendado é usar Kerberos, o mesmo protocolo que o Active Directory utiliza para autenticação entre domínios.

Passos para configurar no Linux

1. Instale os pacotes necessários

Em distribuições baseadas em Debian/Ubuntu:

sudo apt install krb5-user libsasl2-modules-gssapi-mit

No Fedora:

sudo dnf install krb5-workstation
2. Configure o arquivo /etc/krb5.conf

Adicione o domínio e o servidor KDC da sua rede corporativa.

Exemplo:

[libdefaults]
    default_realm = MINHAEMPRESA.LOCAL
    dns_lookup_kdc = true
    dns_lookup_realm = true

[realms]
    MINHAEMPRESA.LOCAL = {
        kdc = dc1.minhaempresa.local
    }

3. Obtenha um ticket Kerberos com seu usuário do domínio
kinit usuario@MINHAEMPRESA.LOCAL

Após autenticar, você pode confirmar o ticket com:

klist
4. Configure a conexão JDBC

No application.properties (Spring Boot ou Quarkus), a URL deve indicar o uso do principal Kerberos:

Spring

spring.datasource.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;authenticationScheme=JavaKerberos;
spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver

Quarkus

quarkus.datasource.jdbc.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;authenticationScheme=JavaKerberos;
quarkus.datasource.jdbc.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver

A opção authenticationScheme=JavaKerberos instrui o driver JDBC a usar o ticket obtido via kinit.

Considerações finais

Essa configuração é especialmente útil em ambientes corporativos onde a política de segurança exige Single Sign-On (SSO) e o gerenciamento centralizado de permissões. Além disso, evita o armazenamento de senhas no código-fonte ou em arquivos de configuração, o que aumenta a segurança da aplicação.

Vale lembrar que a autenticação integrada funciona apenas quando a aplicação Java está sendo executada em um ambiente Windows. Para servidores Linux, é necessário configurar o Kerberos e utilizar parâmetros adicionais no driver.

Em resumo, a presença da DLL msql-jdbc_auth é fundamental para que o Java consiga usar a autenticação nativa do Windows ao se conectar ao MS SQL Server. Com ela corretamente posicionada e o driver JDBC configurado, o processo de autenticação se torna transparente e seguro, aproveitando os recursos já disponíveis no sistema operacional.

Feito!

Entendendo a anotação @Transient no Hibernate

Se você já trabalhou com Hibernate ou JPA, é provável que tenha se deparado com a anotação @Transient. Embora simples, seu uso adequado evita persistir dados desnecessários e pode te livrar de uma dor de cabeça lá na frente.

No presente artigo, vamos entender o propósito da anotação @Transient, quando e por que usá-la, e ver um exemplo prático com Hibernate.

O que é @Transient?

A anotação @Transient indica que um determinado campo de uma entidade não deve ser persistido no banco de dados. Ou seja, o Hibernate (ou qualquer implementação JPA) irá ignorar esse campo no momento de salvar ou atualizar a entidade.

É equivalente ao uso da palavra-chave transient do Java, mas no contexto da persistência ORM.

Por que usar @Transient

Algumas situações comuns onde @Transient se torna útil:

• Campos calculados: Você quer exibir um valor derivado de outros campos, mas não precisa armazená-lo no banco.
• Campos auxiliares: Dados que são úteis apenas em tempo de execução, como flags de controle ou estruturas temporárias.
• Evitar dados desnecessários: Ajuda a manter seu modelo de dados enxuto e evita redundância.

Exemplo prático

Vamos imaginar uma entidade Produto que calcula seu valor com desconto apenas em tempo de execução:

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Table(name = "TB01_PRODUTO")
@Getter
@Setter
public class Produto {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String nome;

    private Double preco;

    private Double desconto;

    @Transient
    private Double precoFinal;

    
    public Double getPrecoFinal() {
        if (preco != null && desconto != null) {
            return preco - (preco * desconto);
        }
        return preco;
    }
}

Nesse exemplo:

• O campo precoFinal não será criado na tabela produto.
• Ele é útil apenas para retorno em uma API ou exibição na UI (User Interface).
• Ele é calculado dinamicamente sempre que for chamado.

Obervações:

• Se você esquecer o @Transient e o campo não tiver um setter, o Hibernate pode lançar exceções.
• @Transient é da JPA, não confundir com transient do Java, que é usado para serialização de objetos Java (por exemplo, em Serializable).

Considerações finais:

A anotação @Transient é uma daquelas ferramentas simples que, quando bem usadas, deixam seu modelo limpo, objetivo e mais alinhado com as boas práticas de arquitetura.

Se um campo não precisa ser persistido, não insista em forçar sua presença no banco. Use @Transient e mantenha a clareza do seu modelo.

Feito!

Entendendo a JVM

O que é a JVM e por que ela é tão importante?

A Java Virtual Machine (JVM) é um dos pilares mais importantes da linguagem Java. Ela permite que o Java alcance seu objetivo principal de ser portável, com o famoso lema "Write Once, Run Anywhere" (Escreva uma vez, execute em qualquer lugar).

Mas o que exatamente é a JVM? Em resumo, é uma máquina virtual que interpreta e executa o bytecode Java (arquivos .class), traduzindo-o para instruções compreensíveis pelo sistema operacional e hardware subjacente.

Graças à JVM, aplicações Java podem ser executadas em diferentes plataformas sem que o código precise ser reescrito, garantindo portabilidade, segurança e eficiência.

Arquitetura da JVM: Explorando os Componentes Internos

A JVM é composta por várias partes que trabalham juntas para executar programas Java.

1. Class Loader (Carregador de Classes)

O Class Loader é responsável por carregar os arquivos .class na memória no momento da execução. Ele organiza e gerencia as classes em diferentes níveis:

• Bootstrap Class Loader:

Carrega as classes fundamentais do Java.

• Extension Class Loader:

Lida com bibliotecas adicionais.

• Application Class Loader:

Carrega as classes da aplicação.

2. Área de Memória da JVM

A memória da JVM é organizada em várias áreas, cada uma com uma função específica:

• Heap:

Onde os objetos e instâncias são armazenados.

• Stack:

Armazena frames de métodos em execução e variáveis locais.

• Method Area:

Contém metadados das classes e bytecode.

• PC Register:

Rastrea a posição atual da instrução sendo executada em cada thread.

• Native Method Stack:

Suporte para métodos escritos em linguagens nativas, como C ou C++.

3. Execution Engine (Motor de Execução)

Essa é a parte da JVM que transforma o bytecode em instruções executáveis.

• Interpretador:

Executa o bytecode linha a linha.

• JIT Compiler (Just-In-Time):

Compila o bytecode em código nativo para acelerar a execução.

4. Native Interface

Permite que o Java interaja com bibliotecas nativas do sistema, facilitando a execução de código fora da JVM.

5. Garbage Collector (Coletor de Lixo)

Um recurso essencial da JVM que gerencia automaticamente a memória, removendo objetos não utilizados e evitando problemas como vazamentos de memória (memory leaks).

Como a JVM executa o código?

O processo de execução de um programa Java na JVM segue estas etapas:

• O compilador Java (javac) converte o código-fonte (.java) em bytecode (.class).
• O Class Loader carrega o bytecode na memória da JVM.
• O Motor de Execução interpreta ou compila o bytecode para código nativo.
• O código nativo é executado pelo hardware subjacente.

Diferenciando JVM, JRE e JDK

Ao trabalhar com Java, você encontrará três termos comuns:

JVM (Java Virtual Machine): É o ambiente de execução para programas Java.

JRE (Java Runtime Environment): Inclui a JVM e bibliotecas padrão necessárias para rodar aplicações.

JDK (Java Development Kit): Inclui o JRE, ferramentas de desenvolvimento (compilador, depurador, etc.) e bibliotecas adicionais.

Benefícios da JVM

• Portabilidade:

O bytecode é independente de plataforma, e a JVM específica de cada sistema operacional cuida da execução.

• Eficiência:

O JIT Compiler otimiza o desempenho em tempo de execução.

• Segurança:

Oferece isolamento entre o código Java e o hardware real, protegendo contra execuções maliciosas.

• Multithreading:

Suporte nativo para execução simultânea de threads.

• Gerenciamento de Memória:

O Garbage Collector simplifica o desenvolvimento e reduz problemas como vazamentos de memória.

Considerações finais

A Java Virtual Machine é a espinha dorsal do Java. Sua arquitetura robusta e características inovadoras garantem que aplicações sejam executadas de forma confiável, segura e eficiente em diferentes plataformas.

Entender como a JVM funciona não é apenas importante para desenvolvedores Java, mas também para quem deseja otimizar aplicações, resolver problemas de desempenho ou explorar áreas como DevOps e segurança.

Feito!

Uma revolução Java para a nuvem

O mundo da programação Java está em constante evolução, e o Quarkus surge como uma das tecnologias mais promissoras para o desenvolvimento de aplicações modernas e escaláveis. Com foco em otimização para containers e a geração de executáveis nativos, o Quarkus promete revolucionar a forma como desenvolvemos aplicações Java.

Quarkus é um framework Java nativo do Kubernetes que combina o melhor dos mundos Java EE e frameworks reativos. Ele é projetado para ser extremamente rápido, leve e fácil de usar, tornando-o ideal para o desenvolvimento de microserviços e aplicações serverless.

Principais características do Quarkus:

• Nativo do Kubernetes:

O Quarkus é otimizado para rodar em ambientes Kubernetes, proporcionando um excelente desempenho e escalabilidade.

• Compilação nativa:

O Quarkus permite a geração de executáveis nativos, reduzindo significativamente o tempo de inicialização e o consumo de memória.

• Full-stack:

O Quarkus oferece uma ampla gama de funcionalidades, incluindo suporte a RESTful APIs, bancos de dados, messaging e muito mais.

• Extensibilidade:

O Quarkus é altamente extensível, permitindo a integração com diversas tecnologias e frameworks.

Configurando o ambiente de desenvolvimento Quarkus no Linux (qualquer distro)

Para começar a desenvolver com Quarkus, você precisará de um ambiente Linux configurado com as ferramentas necessárias. Siga os passos abaixo:

Instale o JDK: Certifique-se de ter o Java Development Kit (JDK) instalado em sua máquina. A versão mínima recomendada é o JDK 11.

Instale o Maven: O Maven é o gerenciador de dependências padrão do Quarkus.

Instale a ferramenta de linha de comando do Quarkus:

curl -Ls https://sh.jbang.dev | bash -s - trust add https://repo1.maven.org/maven2/io/quarkus/quarkus-cli/

curl -Ls https://sh.jbang.dev | bash -s - app install --fresh --force quarkus@quarkusio

Criando seu primeiro projeto Quarkus

Com o ambiente configurado, você está pronto para criar seu primeiro projeto Quarkus. Abra seu terminal e execute o seguinte comando:

quarkus create helloworld-app

Isso criará um novo projeto Quarkus chamado "helloworld-app". Entre no diretório do projeto e inicie o servidor de desenvolvimento:

cd helloworld-app

quarkus:dev

Agora você pode acessar sua aplicação em http://localhost:8080.

Considerações finais

O Quarkus é uma excelente opção para desenvolvedores Java que buscam criar aplicações modernas e escaláveis. Com sua facilidade de uso e alto desempenho, o Quarkus está rapidamente se tornando um dos frameworks Java mais populares.

Referências

https://pt.quarkus.io/

Feito!

Configurando o VSCode para Java

Na postagem Configurando ambiente de desenvolvimento Java no Linux foi detalhado a instalação e configurado do setup Java na máquina. O objetivo deste post é explicar que pode utilizar o editor VSCode para programar em Java. Então, considerando que o seu setup Java está já funcional, caso contrário, verifique no link da postagem anterior, ok?

Instalar o VSCode

No Linux (Debian/Ubuntu)

$ wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg

$ sudo install -o root -g root -m 644 packages.microsoft.gpg /etc/apt/trusted.gpg.d/

$ sudo sh -c 'echo "deb [arch=amd64,arm64,armhf signed-by=/etc/apt/trusted.gpg.d/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" < /etc/apt/sources.list.d/vscode.list'
$ sudo apt install apt-transport-https

$ sudo apt update

$ sudo apt install code

Habilitar as extensões

Com o VSCode instalado, abre em seguida e vai em "Extensions" (Ctrl+Shift+K) e pesquise as extensões que ajudam ao programar em Java para instalar.

Extensões: Java Extension Pack,Spring Boot Extension Pack, Spring Boot Dashboard, lombok

Se versiona o projeto com Git, então a extensão "Git Blame" não deve faltar. 😂

Criar projeto Java pelo VSCode

Pressione o atalho Ctrl+Shift+P digite Java overview

Para Projeto Java simples com JUnit, escolha maven-archetype-quickstart

Para Projeto Java Web com Maven, escolha maven-archetype-webapp

Para Projeto Java com Spring Boot, Ctrl+Shift+P Ctrl+Shift+P, digite Spring "Initializr: Generate a Maven Project" OU "Spring Initializr: Generate a Grandle Project"segue os passos normalmente.

Adicionar e remover dependências no projeto rapidamente

No arquivo pom.xml aberto, clica com botão direito, seleciona "Edit starters" e escolhe as dependências que deseja adicionar ou remover.

Tomcat

No Java overview instalar a extensão Tomcat

Adicionar o caminho do diretório Tomcat em TOMCAT SERVERS

clicar em "+" e adicionar o diretório do Apache Tomcat

clicar com botão direito em apache-tomcat e iniciar

Em MAVEN PROJECTS, verifique em war

war
  war:war clicar na seta ->

Verificar em target que foi gerado o arquivo.war

Clicar com botão direito do arquivo.war e "Run on Tomcat Server"

Clicar com botão direito do arquivo.war e "Open on Browser"

Irá abrir o browser default na URL http://localhost:8080/ContextoProjeto

OBS: No lugar de "ContextoProjeto" corresponde ao nome do projeto

Referências

https://code.visualstudio.com/docs/java/extensions

Feito!

Configurando ambiente de desenvolvimento Java no Linux

O objetivo deste post é explicar os procedimentos de configuração do ambiente de desenvolvimento Java Web no Linux na distro Debian e Ubuntu.

openJDK

Usando PPA

Adicionar o repositório openJDK para facilitar o gerenciamento de versões

$ sudo add-apt-repository ppa:openjdk-r/ppa

Atualizar a lista de repositório

$ sudo apt-get update

Instalação da versão openJDK 8

$ sudo apt-get install openjdk-8-jdk

Substitua o 8 pela versão outra versão do openJDK que desejar, como 9, 10, 11, 12, 13, 14, 15, 16, 17, 18

Pelo repositório oficial da distro

Outra opção de instalação do openJDK, caso não costuma instalar pacotes com PPA, mas sim apenas no repositório oficial da distro, então é descrito nessa seção.

$ sudo apt install default-jdk

Irá instalar a versão corrente do openJDK disponível no repositório oficial da distro Debian/Ubuntu

Caso por necessidade do projeto precise instalar o openJDK 8, segue os procedimentos

$ sudo apt install apt-transport-https ca-certificates wget dirmngr gnupg software-properties-common

$ wget -qO - https://adoptopenjdk.jfrog.io/adoptopenjdk/api/gpg/key/public | sudo apt-key add -

$ sudo add-apt-repository --yes https://adoptopenjdk.jfrog.io/adoptopenjdk/deb/

$ sudo apt install adoptopenjdk-8-hotspot

Verificar a versão

$ java -version

Alterar a versão do openJDK default no PATH

$ sudo update-alternatives --config java

Irá listar as versões openJDK disponíveis no sistema e selecione a versão openJDK que deseja utilizar como default

Definir o caminho absoluto do openJDK default na variável JAVA_HOME

$ sudo vim /etc/environment

JAVA_HOME="/usr/lib/jvm/java-11-openjdk-amd64"

ESC + :x (salvar e sair do editor Vim)

Testar

$ source /etc/environment

$ echo $JAVA_HOME

Apache Maven

Download do Apache Maven

O Apache Maven é um gerenciador de bibliotecas e suas dependências do projeto Java. O Maven mantém o arquivo pom.xml para centralizar as bibliotecas que o projeto irá precisar.

Até a data de publicação deste post, a versão atual do Maven é 3.8.2, caso por eventual motivo desejar obter uma versão anterior ou dependendo da data que estiver seguindo esse post, acesse a URL https://downloads.apache.org/maven/ e escolha a versão mais recente.

$ wget https://downloads.apache.org/maven/maven-3/3.8.2/binaries/apache-maven-3.8.2-bin.tar.gz -P /tmp

$ sudo tar -xzvf /tmp/apache-maven-3.8.2-bin.tar.gz -C /opt

Configuração do ambiente para o Maven

Para que o Maven funcione corretamente, precisa configurar as variáveis de ambiente. Isso inclui: JAVA_HOME, M3_HOME, MAVEN_HOME, PATH

Adicione o conteúdo abaixo no arquivo /etc/profile.d/maven.sh

$ sudo vim /etc/profile.d/maven.sh

export JAVA_HOME=/usr/lib/jvm/default-java
export M3_HOME=/opt/maven
export MAVEN_HOME=/opt/maven
export PATH=$M2_HOME/bin:$PATH

ESC +:x (salvar e sair do editor Vim)

Permissão ao script /etc/profile.d/maven.sh

$ sudo chmod +x /etc/profile.d/maven.sh

Load do script setado nas variáveis de ambiente

$ source /etc/profile.d/maven.sh

Download e configuração do Apache Tomcat

Criar um grupo e usuário no Tomcat sem acesso ao terminal

$ sudo groupadd tomcat
$ sudo useradd -s /bin/false -g tomcat -d /opt/tomcat tomcat

De forma análoga que foi comentado na versão do Maven, segue o mesmo para versão do Tomcat. Até a data de publicação deste post, a versão recente do Tomcat é 9.0.53.

$ wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.53/bin/apache-tomcat-9.0.53.tar.gz

$ sudo tar -xzvf apache-tomcat-9.0.53.tar.gz -C /opt --strip-components=1

$ sudo chgrp -R tomcat /opt/tomcat

$ sudo chown -R tomcat /opt/tomcat/webapps/ /opt/tomcat/work/ /opt/tomcat/temp/ /opt/tomcat/logs/

$ sudo chmod -R g+r /opt/tomcat/conf

$ sudo chmod g+x /opt/tomcat/conf

$ sudo vim /etc/systemd/system/tomcat.service

SystemD Arquivo tomcat.service

[Unit] Description=Apache Tomcat Web Application Container
After=network.target
[Service]
Type=forking
Environment=JAVA_HOME=/usr/lib/jvm/default-java
Environment=CATALINA_PID=/opt/tomcat/temp/tomcat.pid
Environment=CATALINA_Home=/opt/tomcat
Environment=CATALINA_BASE=/opt/tomcat
Environment='CATALINA_OPTS=-Xms512M -Xmx1024M -server -XX:+UseParallelGC'
Environment='JAVA_OPTS.awt.headless=true -Djava.security.egd=file:/dev/v/urandom'
ExecStart=/opt/tomcat/bin/startup.sh
ExecStop=/opt/tomcat/bin/shutdown.sh
User=tomcat
Group=tomcat
UMask=0007
RestartSec=10
Restart=always
[Install]
WantedBy=multi-user.target

ESC +:x (salvar e sair do editor Vim)

$ sudo systemctl daemon-reload

Configurar a interface de gerenciamento Tomcat

Edite o arquivo tomcat-users.xml

$ sudo vim /opt/tomcat/conf/tomcat-users.xml

Arquivo tomcat-users.xml simplificado

<tomcat-users . . .>
<tomcat-users . . .>
>user username="admin" password="password" roles="manager-gui,admin-gui"/>
</tomcat-users>

Gerenciador de host no Tomcat: /opt/tomcat/webapps/manager/META-INF/context.xml

Iniciar/Reiniciar o serviço Tomcat

$ sudo systemctl start tomcat

$ sudo systemctl restart tomcat

Acesso gerenciador Tomcat pela interface web

http://IP:8080/manager

Feito!

Aumentando memória JVM no Tomcat

Esse post é apenas uma dica de como aumentar memória JVM no Tomcat, pois dependendo da aplicação Java web, quando faz o deploy da aplicação e ao reiniciar o Tomcat pode não iniciar, então analisei o log (#tail -f $TOMCAT_HOME/logs/catalina.out) e notei que era problema de memória JVM do Tomcat.
Considerando um servidor de 2GB, fiz a configuração conforme descrita abaixo:
Adicionando $TOMCAT_HOME no path do sistema Linux
#vim /etc/profile
TOMCAT_HOME="/opt/tomcat"
PATH="$TOMCAT_HOME:$PATH
Atualizando variável ambiente
#source /etc/profile
edite o arquivo catalina.sh
#vim $TOMCAT_HOME/bin/catalina.sh

JAVA_OPTS="-Xms=1g -Xmx=1g -XX:PermSize=512m -XX:MaxPermSize=512m -server"
:x (salva e sai do editor vim)
PS: No sistema Windows se aplica o mesmo, a única diferença é na configuração da variável de ambiente e extensão do arquivo catalina.sh para catalina.bat. Feito!

Configurando servidor Tomcat no Linux

Introdução

O Tomcat é um servidor Java, mais especificamente um container de servlets. Desenvolvido pela Apache Software Foundation, é distribuído como software livre dentro do conceituado projeto Apache Jakarta, sendo oficialmente endossada pela Oracle como a implementação de referência para as tecnologias Java Servlet e JavaServer Pages (JSP). Cobre parte da especificação J2EE como tecnologias como servlet e JSP, e tecnologias de apoio relacionadas como Realms e segurança, JNDI Resources e JDBC DataSources.

Preparação do Ambiente Java
Antes de instalar o Tomcat é necessário ter instalado e configurado o JAVA_HOME no path do sistema. Se caso ainda não tiver configurado acesse e segue os passos corretamente instalação e configuração do JAVA_HOME no path

Instalação e configuração do Tomcat

Acesse o site do Tomcat no endereço http://tomcat.apache.org/index.html
Ou se preferir fazer o download no terminal via wget.

wget -c "http://apache.mirror.pop-sc.rnp.br/apache/tomcat/tomcat-7/v7.0.37/bin/apache-tomcat-7.0.37.zip"

Após feito o download do Tomcat, vamos copiar para o diretório /opt, extrair, setar permissão de execução nos scripts catalina.sh e startup.sh, por fim startamos o tomcat, posteriormente testamos no navegador.

#cp apache-tomcat-7.0.37.zip /opt
#cd /opt
#unzip apache-tomcat-7.0.37.zip
#ln -s apache-tomcat-7.0.37 tomcat
#cd tomcat/bin
#chmod +x catalina.sh
#chmod +x startup.sh
#chmod +x shutdown.sh
#./startup.sh
Agora no navegador digite: http://localhost:8080

Estrutura de diretórios do Tomcat

tomcat
bin - executáveis e scripts do Tomcat
conf - arquivos de configuração do Tomcat
logs - arquivos de logs das aplicações, inclusive do Tomcat
temp - diretório temporário do Tomcat
webapps - diretório com os contextos (similar ao /var/www do Apache)
work - arquivos de servlets gerados pelo Tomcat a partir de JSPs
lib - bibliotecas comuns a todas as aplicações e ao Tomcat

Script Tomcat para inicializar junto com o sistema
rc.tomcat.sh
PS: Não é recomendado copiar e colar esse script direto no terminal com editor vi/vim, pois pode copiar caracteres desconhecidos acarretando erros desse tipo. Portanto antes de prosseguir com o passo seguinte, teste da seguinte forma: bash rc.tomcat.sh e source rc.tomcat.sh, estando ok, segue com os passos seguintes, caso contrário deve revisar e analisar o erro e tentar novamente.
Agora para o script seja inicializado junto com o sistema, devemos fazer o que procede abaixo:
No Debian:
#mv rc.tomcat.sh /etc/init.d
#chmod +x /etc/init.d/rc.tomcat.sh
#update-rc.d rc.tomcat.sh defaults 99

No Slackware:
#mv rc.tomcat.sh /etc/rc.d
#chmod +x /etc/rc.d/rc.tomcat.sh

Feito!

Jasypt criptografia em Java

Jasypt é uma biblioteca Java que permite ao desenvolvedor adicionar recursos de criptografia básicas em seus projetos com o mínimo esforço, e sem a necessidade de ter um conhecimento profundo de como funciona a criptografia.
Como utilizar ?
Irei explicar de duas formas de utilização da biblioteca Jasypt, uma é modo manual sem uso de IDE Netbeans, e a outra usando a IDE Netbeans.
Primeiramente é necessário fazer o download do Jasypt em: http://sourceforge.net/projects/jasypt/files/jasypt/
Até data deste tutorial a versão atual é: jasypt-1.9.0, então utilizarei essa versão nos passos seguintes.
Utilizando sem uso de IDE Netbeans
1. Extraia o jasypt-1.9.0-dist.zip
2. Em seguida acesse o diretório que extraiu jasypt-1.9.0/lib
3. Copie o jasypt-1.9.0.jar para o diretório de sua preferência onde irá salvar o código de exemplo (ExemploCriptografia.java)
4. Extraia o jasypt-1.9.0.jar
5. Irá gerar o diretório org/jasypt/outros diretórios dentro que compõe essa biblioteca
6. Copie o código abaixo para o diretório de sua preferência.
Sugestão: criar um diretório cripto e dentro desse diretório deve conter org/jasypt.
Se baseia com o meu exemplo.
[reginaldo@Saitam:~/cripto] $ls
ExemploCriptografia.class ExemploCriptografia.java~ jasypt-1.9.0-dist.zip
ExemploCriptografia.java jasypt-1.9.0 org
ExemploCriptografia.java
*Usando biblioteca jasypt de criptografia/descriptografia em Java
*http://www.jasypt.org/*/
import org.jasypt.util.text.BasicTextEncryptor;
public class ExemploCriptografia {
public static void main(String[] args) {
String seuTexto = "Viva o Linux";
System.out.println("Texto sem criptografia: " + seuTexto);
//instanciamos a classe BasicTextEncryptor
BasicTextEncryptor bte = new BasicTextEncryptor();
//inserimos uma senha qualquer
bte.setPassword("A senha que voce quizer");
//criamos uma String que recebe a senha criptografada
String seuTextoCriptografado = bte.encrypt(seuTexto);
System.out.println("Seu texto criptografado = " + seuTextoCriptografado);
//criamos uma String que recebe a senha descriptografada
String seuTextoNovamenteDescriptografado = bte.decrypt(seuTextoCriptografado);
System.out.println("Texto descriptografado = " + seuTextoNovamenteDescriptografado);
}
}
ExemploCriptografia.java
7. Compile e execute
[reginaldo@Saitam:~/cripto] $javac ExemploCriptografia.java
[reginaldo@Saitam:~/cripto] $java ExemploCriptografia
Texto sem criptografia: Viva o Linux
Seu texto criptografado = 9eVWc8WZZDzT4Z61cp0ep8qnXtNpBY0R
Texto descriptografado = Viva o Linux
Agora utilizando o jasypt com IDE Netbeans
1. Crie o projeto com nome sugestivo criptografia
2. Copie o código acima adicionando apenas o package com o nome que definiu na criação do projeto.
3. Dentro do projeto clicar com botão direito do mouse em Add JAR/pasta e localize a biblioteca jasypt-1.9.0.jar para adicionar no projeto.
4. Compile o projeto (Shift+F6).

Para conhecer mais sobre a biblioteca Jasypt acesse em: Jasypt
Feito!

Convertendo .class para código Java

Se você tem ou já baixou algum arquivo.jar, e ao extrair percebeu que apenas tinha arquivos .class (bytecodes do Java). Então você estava pesquisando sobre como converter os .class para código Java até que encontrou nas suas pesquisas esse post nos resultados do Google, na qual apresento sobre JD-GUI.
JD-GUI é uma ferramenta que converte os .class para código fonte Java. Você terá acesso ao código fonte reconstruído com o JD-GUI para saber como foi implementado o arquivo.jar que você tem ou baixou em algum site na internet.
Não precisa extrair o arquivo.jar, pode ter apenas os arquivos .class* e abrir no JD-GUI, que irá converter .class* para código Java.
O JD-GUI tem versões nas plataformas Windows, Linux, MacOS.
Onde encontrar?
Acesse: JD-GUI e faça o download conforme sua plataforma.
Como usar ?
1. Acesse o diretório onde você salvou o JD-GUI
2. Abre o aplicativo jd-gui
3. File>Open File>[acesse o diretório onde salvou os arquivos .class* ou .jar]
4. Pronto, após abrir o arquivo .class* ou .jar já mostra o código correspondente do .class* ou .jar gerado pelo JD-GUI.
Veja o screenshot abaixo:

Feito!

Instalação e configuração do Java e PATH

Linux
A instalação e configuração do PATH do Java deste post é independente de distribuição Linux, pois é mostrado os passos manualmente, porém foi testado na distro Slackware :-)
Acesse o site da Oracle: http://www.oracle.com/technetwork/java/javase/downloads/java-se-jdk-7-download-432154.html
Escolha a versão Linux x86 - Compressed Binary e aceite a licença do Java, marcando no rádio button para liberar o download. Logue-se como root e crie o diretório java dentro do diretório opt na raiz do sistema de arquivo segue os passos:
1)$su - [ENTER]
2)Password: [digite a senha de root]
3)Entando no diretório que fez o download
$tar -xzvf jdk-7u3-linux-i586.tar.gz irá gerar o diretório jdk1.7.0_03
4)#mkdir /opt/java
Mova o arquivo, que extraiu para dentro do diretório java criado acima
5)#mv jdk1.7.0_03 /opt/java
6)cd /opt/java
criar link simbólico
#ln -s jdk1.7.0_03 jdk
configuração do PATH
Edite o arquivo /etc/profile com seu editor favorito
7)#vim /etc/profile
adicione no início do arquivo

export JAVA_HOME="/opt/java/jdk"
export CLASSPATH="$JAVA_HOME/lib":$CLASSPATH
export PATH="$JAVA_HOME/bin":$PATH
export MANPATH="$JAVA_HOME/man":$MANPATH
Salve e saia do editor! [# No vi/vim faça ESQ + :x]
Criando link simbólico
#ln -s /opt/java/jdk/bin/java /usr/local/bin/
#ln -s /opt/java/jdk/bin/javac /usr/local/bin/
Linkando para bibliotecas do Mozilla Firefox
#ln -s /opt/java/jdk/jre/plugin/i386/ns7/libjavaplugin_oji.so /usr/lib/firefox/plugins/
#ln -s /opt/java/jdk/jre/lib/i386/libnpjp2.so /usr/lib/firefox/plugins/


Para testar o funcionamento do java, digite no terminal: $java -version e $javac [se aparecer uma lista de opções, é sinal, que foi instalado corretamente, caso contrário, revise os passos e tente novamente].

Agora faça o teste no terminal como segue abaixo:
[reginaldo@Saitam ~$]$ java -version
java version "1.7.0_03"
Java(TM) SE Runtime Environment (build 1.7.0_03-b04)
Java HotSpot(TM) Client VM (build 22.1-b02, mixed mode)

[reginaldo@Saitam ~$]javac Teste.java
[reginaldo@Saitam ~$]java Teste
Teste Java no Linux-Slackware!

Feito!

Windows
Acesse o site da Oracle: http://www.oracle.com/technetwork/java/javase/downloads/java-se-jdk-7-download-432154.html
Escolha a versão da arquitura do seu Windows (x86 ou x64)
Windows x86 79.48 MB jdk-7-windows-i586.exe
Windows x64 80.25 MB jdk-7-windows-x64.exe
e aceite a licença do Java, marcando no rádio button para liberar o download.
Após o download e instalado, localize os arquivos nos respectivos diretórios:
C:\Arquivos de Programas\Java\jdk1.7.0\src.zip
C:\Arquivos de Programas\Java\jdk1.7.0\lib\tools.jar

Lembrando que pode ser diferente, depende qual diretório escolheu na instalação, e claro pode variar apenas na versão do JDK.
Segue os passos:
1)Clique com botão auxiliar do mouse no ícone “Meu computador” e vá em “Propriedades”. Clique em “Configurações avançadas do sistema” e depois em “Variáveis de ambiente”. Em “Variáveis do sistema” você irá clicar em “Nova”.
O nome da variável você coloca: ClassPath
Em valor da variável você coloca os endereços guardados anteriormente de modo que fique dessa maneira:
;C:\Arquivos de Programas\Java\jdk1.7.0\src.zip;C:\Arquivos de Programas\Java\jdk1.7.0\lib\tools.jar;.
Clique em OK
2)Configurar a variável Path que está em Variáveis do sistema também
Você seleciona a variável Path e clica em Editar, em Valor da variável você vai ACRESCENTAR (nada de apagar valores) o seu endereço do jdk, no meu caso ficaria assim:
variável Path
;C:\Arquivos de Programas\Java\jdk1.7.0\bin
Depois de feito isso clique em Ok e depois em Ok de novo para sair das Variáveis de ambiente e depois em Aplicar e Ok para sair das Propriedades do sistema.

Agora abre o terminal(prompt) do Windows e faça um teste
C:\Users\Reginaldo>java -version
java -version "1.7.0"
Java(TM) SE Runtime Environment (build 1.7.0)
Java HotSpot(TM) 64-Bit Server VM (build 19.0-b09, mixed mode)

C:\Users\Reginaldo>javac -version
javac 1.7.0

C:\Users\Reginaldo>javac teste.java

C:\Users\Reginaldo>java teste
Testando programa Java no Windows 7 Professional

Feito!