Engatinhando em Java para a web - Parte 1

Klaus Peter Laube

28 de novembro de 2019 - 7 minutos de leitura

Uma constante nesses dois últimos anos da minha vida profissional tem sido "reavaliar" algumas opiniões que tive durante a minha carreira. Não à toa costumo escrever alguns artigos do tipo "eu me rendo". Já me rendi ao VS Code, ao uso de IDEs, e até mesmo ao React. Agora chegou a hora do Java.

Python ainda é de longe a minha linguagem favorita. Mas acabei "caindo de paraquedas" no mundo Java (principal linguagem usada aqui na Tradeshift), e assim como o Python enriqueceu o meu conhecimento quando me rendi a ele (minha primeira linguagem foi o PHP), o Java tem feito o mesmo.

Imagem com o Darth Vader — Come join the dark side (craigblower.wordpress.com)

Após essa longa argumentação exibindo a motivação por trás desse post, vamos ao que interessa: Java para a web pode ser divertido...

... só precisa ter um pouquinho de paciência.

Linguagem x Ambiente

Parece chover no molhado, mas quando falamos em Java temos que levar sempre em consideração que estamos referenciando duas coisas: A linguagem de programação e a plataforma.

Sobre a linguagem, é exatamente aquele mesmo discurso que a gente já está cansado de ouvir: Orientada a objetos, de alto nível, estática e de tipagem forte.

Luke gritando no — Noooooooooooooooooooooooo (starwarsanon.wordpress.com)

Plataformas e a sopa de letrinha

As plataformas Java possuem a Java Virtual Machine (JVM) e uma API (Application Programming Interface). A primeira é quem "executa" aplicações Java para uma determinada plataforma de hardware e software. Já a segunda é uma coleção de componentes usados para criação de outros componentes e aplicações.

A Java Runtime Environment (JRE) provê o ambiente necessário para executar aplicações Java. Inclui implementação da JVM juntamente com bibliotecas e outros arquivos necessários para sua execução.

Diagrama da relação entre a JRE e a JVM (javatpoint.com)

Para escrever código Java utiliza-se um conjunto de ferramentas de desenvolvimento chamado de Java Development Kit (JDK). Entre essas ferramentas está o compilador, o debugger Java, e a própria JRE.

Diagrama da relação entre a JDK, JRE e a JVM (javatpoint.com)

O Java é uma linguagem de propósito genérico, portanto, há diferentes especificações (e fatalmente implementações) que auxiliam na construção de soluções para diferentes fins. As mais mencionadas sendo:

Java Standard Edition (SE): Disponibiliza as funcionalidades "core" da linguagem. De tipos básicos a classes de alto nível que lidam com networking, segurança, parsing, math, entre outros. Além disso, consiste de máquina virtual, ferramentas de desenvolvimento, tecnologias de deployment, etc;
Java Enterprise Edition (EE): Construída em cima da anterior, disponibiliza API e ambiente de execução para ambientes "enterprise" de larga escala e distruídos. Aqui encontraremos os componentes mais comuns para construção de aplicações web;
Java Micro Edition (ME): Também construída em cima da SE, disponibiliza uma máquina virtual própria para dispositivos menores (como smartphones e embarcados).

Confuso? Isso que nem falamos de OpenJDK...

Tudo começa pelo servidor de aplicação

O motivo no qual estamos lidando com essa quantidade de acrônimos é para compreendermos que, quando estamos falando do servidor de aplicações (que será o ambiente no qual executaremos a nossa aplicação web), estamos falando do "domínio" do Java EE.

Segundo a apostila de Java para web, da Caelum:

(...) o Java EE é um grande conjunto de especificações. Essas especificações, quando implementadas, vão auxiliar bastante o desenvolvimento da sua aplicação, pois você não precisará se preocupar com grande parte de código de infraestrutura, que demandaria muito trabalho.

Ainda citando a fonte acima:

Existem diversas dessas implementações. Já que esse software tem papel de servir sua aplicação para auxiliá-la com serviços de infraestrutura, esse software ganha o nome de servidor de aplicação. A própria Sun/Oracle desenvolve uma dessas implementações, o Glassfish que é open source e gratuito (...).

Vamos utilizar uma ferramenta que implementa apenas parte da especificação do Java EE, não sendo por definição um "servidor de aplicação completo", mas nem por isso deixando de atender nossos requisitos. No momento, só estamos interessados no Java ServerPages (JSP) e em Servlets, e há um software extremamente popular que entrega isso para a gente.

Tomcat

Segundo o Wikipedia:

Apache Tomcat (sometimes simply "Tomcat") is an open source implementation of the Java Servlet, JavaServer Pages, Java Expression Language and WebSocket technologies. (...) provides a "pure Java" HTTP web server environment in which Java code can run.

Exatamente o que precisamos!

Instalá-lo é simples:

Faça o download no tomcat.apache.org;
Descompacte no diretório de sua preferência;
Tenha certeza que o arquivo startup.sh tem permissão de execução;
Execute o arquivo;
Abra o endereço http://localhost:8080;
Se tudo estiver certo, você deve ver a mensagem em verde If you're seeing this, you've successfully installed Tomcat. Congratulations!.

Exemplo de execução do Tomcat via terminal

Mas a maneira que considero mais prática é manuseá-lo através de alguma ferramenta de build. No caso desse tutorial, usaremos o Maven.

Não esqueça de desligar o Tomcat através do ./shutdown.sh.

Maven

Com o Maven você controlará grande parte do ciclo de vida da sua aplicação, resolvendo dependências, executando testes, compilando o projeto, etc. Com ele você pode também criar o projeto utilizando o arquétipo de webapp, como ilustrado no exemplo abaixo:

$ mvn archetype:generate
    -DgroupId=com.kplaube
    -DartifactId=ola-mundo
    -DarchetypeArtifactId=maven-archetype-webapp
    -DinteractiveMode=false

Onde:

-DgroupId: O namespace utilizado para empacotamento
-DartifactId: O nome do projeto
-DarchetypeArtifactId: O nome do "template" usado como base para criar arquivos e diretórios
-DinteractiveMode: Desabilitar o modo interativo

Uma porção de pacotes serão baixados. Sente e relaxe... aproveite para ver mais informações sobre como instalar o Maven.

Ainda falta "linkar" o Tomcat ao processo de build. Entre no diretório ola-mundo, recém criado, e abra o arquivo pom.xml (Project Object Model, arquivo utilizado pelo Maven). Altere-o para ficar parecido com o exemplo abaixo:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.kplaube</groupId>
    <artifactId>ola-mundo</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>ola-mundo Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <build>
        <finalName>ola-mundo</finalName>
        <plugins>
            <!-- Tomcat plugin -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/</path>
                    <webapps>
                        <webapp>
                            <contextPath>/</contextPath>
                            <groupId>com.kplaube</groupId>
                            <artifactId>ola-mundo</artifactId>
                            <version>1.0-SNAPSHOT</version>
                            <type>war</type>
                            <asWebapp>true</asWebapp>
                        </webapp>
                    </webapps>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

De volta à linha de comando:

$ mvn tomcat7:run

O Maven "baixará toda a internet" novamente. Ao final do processo, ao acessar o endereço http://localhost:8080, será possível ver a página com Hello World!.

"Só" precisou de um post inteiro para chegarmos até aqui. Sucesso!

Considerações finais

Um monte de mágica aconteceu, e você (assim como eu no meu cotidiano) terá que confiar que as coisas simplesmente estão funcionando.

Por enquanto, vamos abstrair os detalhes do Maven. Corremos um pouco aqui no final para ter algo prático como exemplo, mas com certeza abordaremos a ferramenta com frequência nos próximos posts.

Por hora, é preciso "aceitar" que com o uso do tomcat7-maven-plugin ganhamos o utilitário de linha de comando tomcat7:run, do qual empacota e executa a aplicação. E embora tenhamos investido parágrafos falando de Java EE, e posteriormente de Tomcat, na prática nota-se que pouco precisamos nos importar com isso para ter um "hello world" up and runnig com "investimento modesto".

No próximo artigo partiremos enfim para os Servlets e Java ServerPages.

Até lá!

Referências

desenvolvimento-web java servlet