Crie um novo projeto JSP, configure o Tomcat, adicione a biblioteca Java Servlet e rode ele. Baixe a biblioteca Java Servlet daqui: http://www.java2s.com/Code/Jar/j/Downloadjavaxservletapi310jar.htm
Nas novas versões, prefira este jar: https://search.maven.org/artifact/jakarta.servlet/jakarta.servlet-api/6.0.0/jar
No arquivo web.xml, da pasta WEB-INF, deixe assim:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee">
<display-name>NomeDoProjeto</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
A página inicial é a index.jsp, que tem uma sintaxe desse tipo:
<%--
Document : teste
Created on : 18 de nov de 2019, 20:45:15
Author : eu
--%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<h1>Hello World!</h1>
</body>
</html>
Tal como acontece com PHP, podemos inserir qualquer tag HTML no corpo de uma página JSP (diferente do JSF que integra arquivos .java com XHTML). Podemos mudar o título, por exemplo.
As supertags JSP já são feitas assim:
<%
// Aqui inserimos o código JSP
%>
PS: Assim como no PHP, é possível ter várias supertags JSP na mesma página, e nada escrito em JSP aparece pro cliente no código-fonte, por este ser processado apenas no servidor.
Para excluir a favicon padrão do Apache, exclua ele na pasta webapps/ROOT
Por padrão, o Netbeans pede como senha do Apache Tomcat o Login "tomcat" e a senha "admin", para alterar a senha, altere o arquivo tomcat80 (no Windows é localizado em AppData\Roaming\Netbeans\8.2\). Não esqueça de configurar a senha no arquivo tomcat-users.xml (localizado na pasta conf do Apache).
Para executar o servidor Tomcat sem abrir o Netbeans, execute o arquivo startup.bat em Windows ou startup.sh no Linux, e mantenha ele executando. Para interromper o funcionamento basta interromper a execução do script. Quando for colocar o site no ar, coloqueo arquivo WAR dentro da pasta WEBAPPS do Tomcat.
Crie um formulário assim:
<form action="teste.jsp" method="get">
<label for="cNome">Nome:</label>
<input type="text" name="tNome" id="cNome" size="40" maxlength="100" placeholder="Insira seu Nome Aqui"/>
<input type="submit" value="Enviar"/>
</form>
E na página teste.jsp, abra uma supertag e coloque isso:
out.print(request.getParameter("tNome"));
Como sabemos, em HTML, quando usamos o método GET ele passa os parâmetros pela URL, e quando é POST por pacotes.
Altere o código da página teste assim:
String nome = "Nome recebido: " + request.getParameter("tNome");
out.print(nome);
Podemos usar a tag expressão para exibir mensagens diretamente, sem recorrer ao out.print, assim:
<%= "Testando a supertag expressão" %>
Como visto acima, a diferença é apenas um símblo de igual após o símbolo de porcentagem.
PS: Não será possível usar código Java puro dessa forma, mas dá pra colocar variáveis ou métodos que retornem um valor, como o getParameter do objeto request.
A supertag declarativa tem um ponto de exclamação após a porcentagem, o que permite fazer por exemplo, isso:
<%! int cont = 2; %>
<%= cont %>
Podemos usar na tag expressão métodos também, desde que retornem algo, e consequentemente, a tag declarativa pode ter métodos, assim:
<%!
public int retorna(int n) {
return n * 3;
}
%>
<%= retorna(8) %>
Objetos implícitos são aqueles que existem nativamente no Java e no JSP, como o request que é uma implementação de uma interface chamada HttpServletRequest, como no código abaixo:
<%= "Nome recebido: " + request.getParameter("tNome") %>
<br/>
<%= "Endereço do contexto: " + request.getContextPath() %>
Como vimos, do objeto request podemos utilizar vários métodos, como os citados acima.
Também temos o objeto response, que é uma implementação da interface HttpServletResponse, por exemplo:
<!-- Para links locais: -->
<% response.sendRedirect("contato.jsp"); %>
<!-- Para links externos: -->
<% response.sendRedirect("https://www.google.com.br/"); %>
No arquivo web.xml, coloque essas tags, dentro de web-app:
<context-param>
<param-name>estado</param-name>
<param-value>São Paulo</param-value>
</context-param>
E no index.jsp, colocamos assim:
<%= application.getInitParameter("estado") %>
O application também é um objeto implícito do JSP.
O session também é um objeto implícito, usado para controlar dados de variáveis ou do usuário. Como sabemos, a sessão é enquanto o usuário está trabalhando na página.
No index.jsp, colocamos assim:
<%
session.setAttribute("curso", "Curso de JSP");
// O primeiro é o nome e o segundo o valor.
%>
E em outra página, fazemos o resgate desse valor, usando seu nome:
<%= session.getAttribute("curso") %>
PS: Esse método acima pode ser concatenado com strings.
Para usar as diretivas, coloque um arroba na frente da porcentagem, veja um exemplo abaixo pra usar com datas:
<%@ page import="java.util.Date" %>
<%= "Data de hoje: " + new Date() %>
Para usarmos a info, por exemplo, fazemos assim:
<%@ page info="Página do Curso de JSP" %>
Pra página de erro, fazemos assim, na página suscetível à erro:
<%@ page errorPage="erro.jsp" %>
<!-- Forçando um erro abaixo: -->
<%= 100 / 0 %>
E na página de erro coloque isso:
<%@ page isErrorPage="true" %>
<%= exception %>
PS: A maioria das classes de pacotes padrões usadas no Java funcionam em web, mas algumas não funcionam por conter código exclusivamente para aplicações Java desktop, como por exemplo:
| Pacotes e Classes do Java 8 |
|---|
| java.util.Scanner |
| java.awt.* |
| javax.swing.* |
| javafx.* |
No entanto, temos vários pacotes usados exclusivamente na web.
Para usarmos o include, vamos criar uma página apenas sem as tags HTML e alguma coisa escrita.
Para incluir a página, usamos assim:
<%@ include file="teste.jsp" %>
PS: Pode ser incluídas páginas HTML também, dessa forma.
Crie uma classe Java, dentro de um pacote na pasta de código-fonte com esse nome e esse código:
package classes;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import javax.servlet.jsp.JspWriter;
public class TagsJSP extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
JspWriter out = getJspContext().getOut();
out.println("Essa é uma tag customizada!");
}
}
PS: Nas versões mais atuais do JSP, use jakarta no lugar de javax.
E em WEB-INF salve um arquivo chamado teste.tld (Tag Library Description) com esse código:
<taglib>
<tlib-version>1.0</tlib-version>
<jsp-version>2.0</jsp-version>
<short-name>Custom Tag</short-name>
<tag>
<name>minhatag</name>
<tag-class>classes.TagsJSP</tag-class>
<body-content>empty</body-content>
</tag>
</taglib>
E na página, antes do DOCTYPE, coloque isso:
<%@ taglib prefix="myprefix" uri="WEB-INF/teste.tld" %>
E podemos usar na mesma página, a tag assim:
<myprefix:minhatag/>
Para alterar a frase, basta modificar o arquivo Java e recompilar.
Temos a tag jsp:forward para uma outra página ser exibida.
Vamos ver como se usa ela, colocando no index.jsp:
<jsp:forward page="teste.jsp"></jsp:forward>
Podemos também passar parâmetros por tags, por exemplo:
<jsp:forward page="teste.jsp">
<jsp:param name="paramforward" value="Curso de JSP"/>
</jsp:forward>
E na página teste.jsp fazemos assim:
<%= request.getParameter("paramforward") %>
Primeiramente, crie as páginas cabecalho.jsp e rodape.jsp, e coloque código HTML referente à essas sessões.
Depois é só usar as tags assim, nas páginas desejadas:
<jsp:include page="cabecalho.jsp"/>
<jsp:include page="rodape.jsp"/>
Como sabemos, o Java Bean é uma classe Java que processa dados em memória de execução.
Crie um pacote Java com o nome beans e uma classe Java com o nome CursoJSPBean, com esse código:
package beans;
public class CursoJSPBean {
public int calcula(int num) {
return num * 100;
}
}
Pra usar ele no JSP, coloque no começo da página teste.jsp, antes de tudo, como primeiro item, isso:
<jsp:useBean id="calcula" class="beans.CursoJSPBean" type="beans.CursoJSPBean" scope="page"/>
E em outra parte da mesma página, usamos assim:
<%= calcula.calcula(50) %>