Configurando um ambiente local para desenvolvimento Java EE

Neste artigo iremos configurar um ambiente de trabalho para executar aplicações Java EE. Deixe-me lembrá-lo: no material anterior abordamos o básico do Java EE . Por ambiente entendemos um conjunto de vários componentes de software:

• SDK JavaEE;
• Servidor de aplicação Java EE GlassFish;
• Configurando o IntelliJ IDEA.

Os principais objetivos deste material:

1. Mostre como você pode preparar um ambiente de trabalho para trabalhar com aplicativos Java EE.
2. Mostre como você pode implantar e executar aplicativos Java EE do IntelliJ IDEA no servidor GlassFish.

Aqui está o que faremos para isso:

1. Baixe e instale o Java EE 7 SDK.
2. Vamos criar o Java EE Application Server GlassFish.
3. Vamos aprender como iniciar e parar o servidor através da linha de comando.
4. Vamos configurar o IntelliJ IDEA para implantar aplicativos neste servidor.
5. Vamos implantar e executar o aplicativo de demonstração, que, junto com o servidor de aplicativos GlassFish, está incluído no Java EE 7 SDK.

Este artigo será útil para desenvolvedores Java novatos que estão se familiarizando com o desenvolvimento empresarial em Java. Considere isso como uma pequena preparação do terreno para práticas futuras. Você entenderá o material se estiver familiarizado com as habilidades básicas de linha de comando do Windows (PowerShell). Versões dos componentes de software usados ​​neste artigo:

• GlassFish 4.0;
• IntelliJ IDEA 2019.3.1 (Ultimate);
• SDK Java EE 7.

Instalando Java EE SDK

Condição importante. Antes de instalar o Java EE SDK, você deve certificar-se de que o Java SE SDK esteja pré-instalado.

1. Primeiro, precisamos baixar o SDK. Para fazer isso, você pode digitar em um mecanismo de busca: “Java EE SDK 7”, ou ir diretamente para a página de download do SDK no site da Oracle.

2. Na lista de SDKs apresentada, você precisa selecionar aquele que é adequado para sua plataforma. O artigo descreve a instalação da distribuição: “java_ee_sdk-7-jdk7-windows-x64-ml.exe”

3. Execute o arquivo de instalação. Durante a inicialização, pode ocorrer o seguinte erro (se não ocorrer, você pode simplesmente continuar com a instalação):

   Isso significa que o instalador não conseguiu encontrar o caminho para o Java Runtime Environment pré-instalado. O erro pode ser corrigido passando o caminho para o JRE manualmente usando a linha de comando. Para fazer isso, você precisa executar o arquivo de instalação via PowerShell e passar o caminho para o JRE pré-instalado através do parâmetro -j.

   Por exemplo, assim:

4. O procedimento de instalação adicional é bastante típico para a maioria dos programas. Tudo que você precisa fazer é clicar nos botões Avançar e Instalar.

   O programa instalará o Java EE SDK, bem como o servidor GlassFish, que, após a conclusão da instalação, estará instalado e pronto para uso.

5. Para ter certeza de que o servidor GlassFish está funcionando, após a conclusão da instalação, você pode abrir o painel de administração do servidor, que estará disponível em: http://localhost:4848/

   Captura de tela abaixo:

GlassFish iniciando e parando via linha de comando

Portanto, o servidor está instalado e funcionando, mas a inicialização do servidor foi iniciada pelo programa de instalação. Abaixo, tentaremos descobrir como iniciar e parar o servidor por conta própria. Primeiro, vamos revelar tal entidade como um domínio. Um domínio é um conjunto de uma ou mais instâncias do servidor GlassFish gerenciadas por um servidor de administração. Ao instalar o servidor GlassFish, um domínio padrão é criado - domínio1. Os seguintes componentes estão associados a ele:

• Porta do servidor (padrão 8080);
• Porta do servidor de administração (padrão 4848);
• Nome de usuário e senha do administrador (o padrão é admin e nenhuma senha é necessária por padrão).

Domínio1 possui valores padrão atribuídos a ele. Para iniciar e parar o servidor, a distribuição GlassFish inclui vários scripts, que por padrão estão localizados no seguinte diretório: C:\glassfish4\glassfish\bin Para iniciar e parar o servidor GlassFish através da linha de comando, você pode usar o script asadmin e seus comandos:

asadmin start-domain domain_name
asadmin stop-domain domain_name

Vamos tentar parar o servidor (já que ele já está em execução após a instalação) executando o PowerShell no subdiretório C:\glassfish4\glassfish\bin : O servidor está parado. Agora vamos executá-lo:

Analisamos a primeira aplicação Java EE, dukes-age

A seguir, veremos uma aplicação Java EE de demonstração: dukes-age. Este aplicativo está incluído no Java EE SDK junto com o aplicativo first-cup. As descrições desses aplicativos são apresentadas no site oficial de documentação da Oracle nas seções 3 e 4 do curso introdutório ao Java EE para desenvolvedores Java EE iniciantes . Neste artigo, examinaremos brevemente o aplicativo dukes-age e examinaremos com mais detalhes o processo de inicialização desse aplicativo no servidor GlassFish a partir do ambiente de desenvolvimento IntelliJ IDEA. O aplicativo está localizado dentro do diretório do servidor glassfish. Se você não alterou o caminho padrão para o servidor glassfish ao instalar o Java EE SDK, poderá encontrar este aplicativo na pasta: C:\glassfish4\docs\firstcup\example\dukes-age . Provavelmente todo desenvolvedor Java, iniciante e experiente, já viu pelo menos uma vez o mascote da linguagem de programação Java - Duke: Poucas pessoas sabem que Duke faz aniversário. Ele nasceu em 23 de maio de 1995, quando foi publicada a primeira versão demo da tecnologia Java. O aplicativo dukes-age, como o nome sugere, fornece informações sobre a idade de Duke. Vamos abrir esta aplicação no IntelliJ IDEA: Arquivo -> Novo -> Projeto de fontes existentes... Em seguida vá para a pasta com a aplicação dukes-age, localizada por padrão em C:\glassfish4\docs\firstcup\example\dukes- age , selecione o arquivo pom.xml e clique em OK: Será aberta uma aplicação com a seguinte estrutura: Vamos dar uma olhada no código da classe DukesAgeResource:

package firstcup.dukesage.resource;

import java.util.Calendar;
import java.util.GregorianCalendar;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;

/**
 * REST Web Service
 *
 */
@Path("dukesAge")
public class DukesAgeResource {

    /** Creates a new instance of DukesAgeResource */
    public DukesAgeResource() {
    }

    /**
     * Retrieves representation of an instance of DukesAgeResource
     * @return an instance of java.lang.String
     */
    @GET
    @Produces("text/plain")
    public String getText() {
        // Create a new Calendar for Duke's birthday
        Calendar dukesBirthday = new GregorianCalendar(1995, Calendar.MAY, 23);
        // Create a new Calendar for today
        Calendar now = GregorianCalendar.getInstance();

        // Subtract today's year from Duke's birth year, 1995
        int dukesAge = now.get(Calendar.YEAR) - dukesBirthday.get(Calendar.YEAR);
        dukesBirthday.add(Calendar.YEAR, dukesAge);

        // If today's date is before May 23, subtract a year from Duke's age
        if (now.before(dukesBirthday)) {
            dukesAge--;
        }
        // Return a String representation of Duke's age
        return "" + dukesAge;
    }
}

Este é um serviço da web RESTful JAX-RS com um método - getText(). Se você examinar o código desse método, ficará claro que o método retorna o número de anos que se passaram desde o nascimento de Duke. Ou seja, o método retorna a idade de Duke. Uma classe é um recurso em um contexto REST.

1. A anotação acima da classe @Path("dukesAge")define o caminho URI para o qual as chamadas serão processadas por esta classe.
2. A anotação acima do método @GETnos diz que este método processa solicitações GET.
3. A anotação @Produces("text/plain")especifica o tipo de mídia da resposta à solicitação. Não é difícil adivinhar que o método getText()irá gerar respostas com tipo de mídia: text/plain.

Vamos também dar uma olhada no arquivo de configuração web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <servlet>
        <servlet-name>javax.ws.rs.core.Application</servlet-name>
    </servlet>
    <servlet-mapping>
        <servlet-name>javax.ws.rs.core.Application</servlet-name>
        <url-pattern>/webapi/*</url-pattern>
    </servlet-mapping>
</web-app>

Neste arquivo, dentro da tag servlet-mapping, é definida uma tag url-patterncom o valor /webapi/*. Aqui é definido um determinado ponto raiz, cujas chamadas serão processadas posteriormente pelo serviço. Se combinado com a anotação @Path("dukesAge"), verifica-se que para obter informações sobre a idade de Duke, você precisa entrar em contato com o endereço /webapi/dukesAge.

Configurando o IntelliJ IDEA para executar uma aplicação Java EE em um servidor GlassFish

Agora que temos uma ideia bem geral da aplicação dukes-age (leia mais sobre ela no site da Oracle ), vamos configurar o IntelliJ IDEA para que possamos rodar esta aplicação a partir do nosso IDE. Configurando o IntelliJ IDEA

1. Para fazer isso, vá ao menu Executar -> Editar configurações.
2. O painel Configurações de execução/depuração será aberto:
3. Precisamos adicionar uma nova configuração. Para fazer isso, clique no sinal de mais ou use a tecla de atalho Alt+Insert. Na lista que se abre, selecione GlassFish Server -> Local:
4. Na janela que se abre, vamos começar a definir a configuração:
5. A próxima etapa é indicar os artefatos que precisarão ser implantados no servidor. Isso pode ser feito através da aba Implantação clicando no sinal de mais -> Artefato...
6. Selecione dukes-age:war e clique em OK:
7. A seguir, salve nossa configuração clicando em Aplicar e depois em OK.

A configuração foi criada!

Iniciando o aplicativo

Agora vamos tentar executar o aplicativo.

1. Para fazer isso, você pode usar a tecla de atalho Alt+Shift+F10, ou através do menu Executar -> Executar...

   E selecione a configuração dukes-age que criamos:

2. Depois disso, vemos os logs de inicialização no painel Serviços:

3. Então, se tudo for feito conforme as instruções, o navegador será aberto e ficará claro que nada está funcionando:

Esse é o mundo da TI. Mesmo que tudo seja feito corretamente, algo pode não funcionar. Mas não se preocupe: você poderia descrever imediatamente como fazer isso da maneira certa, mas algumas das nuances seriam menos óbvias. Por exemplo, como é gerada a url para a qual o IDEA nos direciona ao lançar a aplicação? Vamos prestar atenção nisso. Fomos redirecionados para http://localhost:8080/dukes-age-7.0.1/ . Para entender de onde veio isso (/dukes-age-7.0.1/), vamos ao painel de administração do servidor GlassFish. No menu esquerdo, clique em Aplicativos. A seguir, você verá os aplicativos implantados, incluindo dukes-age. Ao selecionar o aplicativo dukes-age, você pode ver algumas de suas características, incluindo o item Context-Root: dukes-age-7.0.1 é o nome e a versão do aplicativo. Ponto raiz. Todas as solicitações que o dukes-age processará devem começar com o prefixo /dukes-age-7.0.1/. Portanto, temos um ponto raiz: /dukes-age-7.0.1. Além disso, discutimos anteriormente que nosso aplicativo tratará solicitações para /webapi/dukesAge. Vamos combinar essas duas coisas e atualizar nossa configuração.

1. Para fazer isso, vamos voltar ao IntelliJ IDEA, depois ao menu: Executar -> Editar configurações...

2. Vamos selecionar a configuração salva anteriormente e atualizar a URL conforme imagem abaixo:

3. Vamos salvar a configuração e reiniciar nossa aplicação usando a tecla de atalho Ctrl+Shift+F10, ou usando um botão especial no painel Serviços:

4. Após reiniciar, se tudo foi feito corretamente, veremos a idade de Duke:

Ótimo. Finalmente descobrimos que Duke tem 24 anos. Se você não repetir todas as etapas descritas acima nos próximos meses, a partir de abril de 2020, o Duke provavelmente envelhecerá um pouco.

Conclusão

Neste artigo, vimos como você pode configurar seu ambiente local para funcionar com aplicativos Java EE usando o exemplo do servidor GlassFish 4.0, o ambiente de desenvolvimento IntelliJ IDEA 2019.3.1 (Ultimate), bem como o Java EE SDK versão 7. Vimos como você pode:

• baixe e instale o Java EE SDK, bem como o servidor GlassFish;
• pare e inicie o servidor GlassFish via PowerShell;
• configure o IntelliJ IDEA para que você possa implantar aplicativos Java EE do IDE no servidor GlassFish e iniciá-los imediatamente.

Tarefa bônus

1. Repita você mesmo todas as etapas descritas.
2. Faça um curso introdutório ao Java EE para desenvolvedores Java EE iniciantes da Oracle .
3. Item com um asterisco. Tente implantar você mesmo o segundo aplicativo de demonstração da primeira xícara. Este aplicativo é mais interativo e também interage com o aplicativo dukes-age. Para concluir esta etapa, você precisará compreender de forma independente as seguintes questões:
   1. Como habilitar o banco de dados dentro do servidor glassFish;
   2. Como integrar dois aplicativos entre si (dentro do first-cup indique o caminho para o endpoint dukes-age, que discutimos neste artigo);
   3. Como criar uma nova configuração no Intellij IDEA para implantação do primeiro copo (semelhante ao que foi mostrado neste artigo);
   4. Possivelmente muitas outras perguntas)

PS A barreira de entrada é alta, mas não é isso que te motiva?