Exercício – Criar um aplicativo Web JavaServer Faces no Tomcat
Você deve criar um aplicativo Web JSF (Java Server Faces) que possa manipular envios de formulário. Você criará um aplicativo Web e o implantará localmente em um servidor Tomcat.
Criar um aplicativo Web JSF simples no Tomcat
Neste exercício, criaremos um projeto Maven para seu aplicativo Web Java. Depois de criar o projeto, você precisará definir três configurações. A primeira delas é adicionar as bibliotecas de dependências ao arquivo pom.xml. A segunda é criar um arquivo de configuração de CDI como beans.xml para usar CDI (Contextos e injeção de dependência). A terceira é configurar o JSF no arquivo web.xml. Depois das configurações, poderemos criar uma página da Web do JSF e criar o backing bean para a operação de back-end do lado do servidor. Por fim, vamos avaliá-lo no ambiente Tomcat local.
Criar um projeto Maven
Execute o comando de arquétipo do Maven a seguir. Este comando criará um projeto Maven para seu aplicativo Web Java.
mvn archetype:generate \
-DgroupId=com.microsoft.azure.samples \
-DartifactId=azure-javaweb-app \
-DarchetypeArtifactId=maven-archetype-webapp \
-Dversion=1.0-SNAPSHOT \
-DinteractiveMode=false
Você verá a seguinte saída:
[INFO] Parameter: package, Value: com.microsoft.azure.samples
[INFO] Parameter: groupId, Value: com.microsoft.azure.samples
[INFO] Parameter: artifactId, Value: azure-javaweb-app
[INFO] Parameter: packageName, Value: com.microsoft.azure.samples
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: /private/tmp/TMP/azure-javaweb-app
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 5.416 s
[INFO] Finished at: 2020-11-02T11:12:58+09:00
[INFO] ------------------------------------------------------------------------
Os arquivos e diretórios a seguir já estão disponíveis.
├── pom.xml
└── src
└── main
├── resources
└── webapp
├── WEB-INF
│ └── web.xml
└── index.jsp
Modificar o arquivo pom.xml do Maven
Para usar as bibliotecas do JSF, precisamos adicionar as bibliotecas de dependências a seguir ao pom.xml.
Substitua o conteúdo de pom.xml pelo seguinte código:
<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.microsoft.azure.samples</groupId>
<artifactId>azure-javaweb-app</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>azure-javaweb-app Maven Webapp</name>
<url>http://maven.apache.org</url>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<failOnMissingWebXml>false</failOnMissingWebXml>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.glassfish</groupId>
<artifactId>javax.faces</artifactId>
<version>2.4.0</version>
</dependency>
<dependency>
<groupId>org.primefaces</groupId>
<artifactId>primefaces</artifactId>
<version>8.0</version>
</dependency>
<dependency>
<groupId>org.jboss.weld.servlet</groupId>
<artifactId>weld-servlet</artifactId>
<version>2.4.8.Final</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>2.23.0</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>azure-javaweb-app</finalName>
</build>
</project>
Se você deseja usar o Java SE 11 em vez do Java 8, modifique a seguinte entrada pom.xml:
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
Habilitar Contextos e injeção de dependência
Em seguida, disponibilize o CDI para seu aplicativo Web. Crie um arquivo beans.xml no diretório src/main/WEB-INF e descreva o seguinte conteúdo:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd"
bean-discovery-mode="all">
</beans>
Habilitar o JSF
Em seguida, para reconhecer todos os arquivos com a extensão xhtml como o Facelets do JSF, faça as alterações a seguir em web.xml no diretório WEB-INF.
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="4.0" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd">
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<context-param>
<param-name>primefaces.THEME</param-name>
<param-value>nova-light</param-value>
</context-param>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.xhtml</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.xhtml</welcome-file>
</welcome-file-list>
</web-app>
Modificar o nome de index.jsp
Agora que as configurações de ambiente para a execução do JSF foram concluídas, é hora de criar a página do JSF. As páginas da Web do JSF são escritas no formato de arquivo Extensible HTML em vez de JSP, conforme web.xml no exemplo anterior. Portanto, altere o nome do arquivo index.jsp que foi gerado automaticamente quando o projeto foi criado para index.xhtml.
mv index.jsp index.xhtml
Criar uma página da Web básica para JSF
Exclua todo o conteúdo descrito em index.xhtml e copie o seguinte código:
<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://xmlns.jcp.org/jsf/html" xmlns:p="http://primefaces.org/ui">
<h:head>
<title>Input Value Counter Sample</title>
</h:head>
<h:body>
<h:form>
<p:outputLabel value="Basic" /><br />
<p:inputText value="#{indexcontroller.inputValue}" /><br />
<p:commandButton update="ajaxUpdateText" value="Submit" action="#{indexcontroller.submitButtonAction()}" />
<br />
<p:outputLabel id="ajaxUpdateText" value="Input Value: #{indexcontroller.inputValue}" /><br />
</h:form>
</h:body>
</html>
Criar um backing bean do JSF
Em seguida, crie um backing bean para implementar o processamento de back-end do lado do servidor. Crie um diretório para seu pacote Java, que você usará para criar o backing bean no diretório src/main.
mkdir src/main/java
mkdir src/main/java/com
mkdir src/main/java/com/microsoft
mkdir src/main/java/com/microsoft/azure
mkdir src/main/java/com/microsoft/azure/samples
Em seguida, crie um arquivo IndexController.java e copie e cole o seguinte código de backing bean do JSF:
package com.microsoft.azure.samples;
import java.io.Serializable;
import javax.faces.view.ViewScoped;
import javax.inject.Named;
import lombok.Getter;
import lombok.Setter;
@Named("indexcontroller")
@ViewScoped
public class IndexController implements Serializable{
private static final long serialVersionUID = 8485377386286855408L;
@Setter @Getter
private String inputValue;
private int counter;
public void submitButtonAction(){
inputValue = inputValue + " : " + counter;
counter++;
}
}
Essa última ação conclui seu programa. A estrutura de diretório após a implementação do programa é esta:
├── pom.xml
└── src
└── main
├── java
│ └── com
│ └── microsoft
│ └── azure
│ └── samples
│ └── IndexController.java
├── resources
└── webapp
├── WEB-INF
│ ├── beans.xml
│ └── web.xml
└── index.xhtml
Fazer a execução em um ambiente Tomcat local
Se você instalou o Tomcat 9.0.x em seu ambiente local, passe para a próxima etapa. Caso contrário, vá para a próxima seção.
Compile o código-fonte e execute-o em um ambiente Tomcat instalado localmente. Execute o comando a seguir.
Compilar e empacotar o projeto Java
Execute o comando a seguir para compilar o código:
mvn clean package
Copiar o artefato para o diretório de implantação no Tomcat
Copie o arquivo war do artefato para o diretório no Tomcat"
cp target/azure-javaweb-app.war /$INSTALL_DIR/apache-tomcat-9.0.39/webapps/
Iniciar o Tomcat Server
Inicie o Tomcat Server.
$INSTALL_DIR/apache-tomcat-9.0.39/bin/startup.sh
Depois de iniciar o Tomcat, navegue até http://localhost:8080/azure-javaweb-app/ e você verá a seguinte tela:
Você executou com êxito o aplicativo Web JSF em seu ambiente Tomcat local.