Arquivo da categoria ‘Java’

JSP – JavaBeans Scope – Session – Java

Publicado: 2 de novembro de 2014 em Java

O escopo de um objeto descreve a disponibilidade de sua abrangência e quem tem acesso a ele. Por exemplo, se um objeto é definido para ter alcance a uma pagina página, então ele está disponível apenas durante a duração da solicitação atual nessa página antes de ser destruído pelo contêiner. Neste caso, somente a página atual tem acesso a esses dados, e ninguém mais pode lê-lo. No outro extremo da escala, se um objeto tem espaço de aplicação, em seguida, qualquer página pode utilizar os dados porque ele estará disponível durante toda a aplicação, o que significa até que o contêiner seja destruído.

Escopos de um JavaBean

  • Page: Os objetos com escopo de página são acessíveis apenas dentro da página em que são criados.
  • Request: Os objetos com escopo de solicitação são acessíveis a partir de páginas que processão o o mesmo pedido em que eles foram criados.
  • Session: Os objetos com escopo de sessão são acessíveis a partir de páginas processadas que estão na mesma sessão em que eles foram criadas.
  • Application: Os objetos com escopo de aplicação são acessíveis a partir de páginas JSP que residem na mesma aplicação. Isso cria um objeto global que está disponível para todas as páginas.

 

Criando uma aplicação com o escopo de Sessão

Caso você não defina um escopo quando você declara o uso de um Bean em uma pagina JSP, o escopo padrão estabelecido será por pagina, ou seja apenas a pagina no qual o Bean pertence poderá acessar os valores das propriedades nelas modificadas.

Quando utilizamos o escopo por sessão os Beans funcionam de certo modo como objetos estáticos ou seja toda a sessão poderá acessar os mesmos valores de suas propriedades não importa a quantidade de paginas existentes na aplicação que utilizam o mesmo Bean. Se aberto uma nova sessão o Bean então será  inicializado de acordo com seus valores no construtor do objeto.

1 – Crie uma aplicação Web com duas paginas JSP chamadas de index.jsp e index2.jsp. Crie um classe chamada de MeuBean.java e utilize os códigos abaixo em cada respectivo arquivo. Note que estamos utilizando o método que altera a propriedade Setter do Bean com parâmetros. Assim que você compilar sua aplicação o construtor do Bean inicializará o valor da propriedade cor do texto do Box como vermelho (Red), utilize manualmente o parâmetro para mudar a cor do texto para azul (Blue) dentro do navegador do Eclipse cujo nos propicia uma sessão única:

?cor=blue
Session - parâmetro cor

Session – parâmetro cor

2 – Apague o parâmetro e mude manualmente a URL do navegador do Eclipse para a index2.jsp, você notará que o Bean manteve a cor da propriedade que definimos na pagina anterior, isto é devido estarmos na mesma sessão, deste modo o construtor da classe não reinicializou o valor da propriedade cor:

Session - Página 2

Session – Página 2

3 – Para abrir outra sessão você precisa somente copiar a URL da pagina 2 do navegador do Eclipse e colar no seu Browser, você verá que quando outra sessão da aplicação web é inicializada o Bean é inicializado novamente. Você pode agora brincar com a aplicação no navegador do Eclipse e no navegador externo, para entender melhor como funciona os JavaBeans por sessão:

Sessão - Firefox

Sessão – Firefox

Exemplo:

Neste exemplo criamos duas paginas JSP e um JavaBean que interage entre as paginas pela sessão do navegador, você poderá brincar com as propriedades de cores no texto da pagina para entender como é utilizado o recurso de sessão de um objeto Bean utilizando o navegador do Eclipse e um navegador externo ao mesmo tempo.

Java

package org.desenvolvimento.aberto;

public class MeuBean {

  // Declara atributo
  private String cor;

  // Construtor da classe
  public MeuBean()
  {
	  cor = "Red";
  }

  // Método Getter
  public String getCor()
  {
	  return cor;
  }

  // Método Setter
  public void setCor(String cor)
  {
	  this.cor = cor;
  }

}

JSP – index.jsp

<html>
<head>
<title>Desenvolvimento Aberto</title>

<!-- Inicializa o JavaBean -->
<jsp:useBean id="meubean" class="org.desenvolvimento.aberto.MeuBean" scope="session" />
<style type="text/css">

div {
    background-color: lightgrey;
    width: 300px;
    padding: 25px;
    border: 25px solid black;
    margin: 25px;
}

</style>
</head>
<body>

	<h1>JavaBeans e Páginas JSP</h1>

	<h2>Escopo: Session - Pagina 1 </h2>

	<h4>Este é o valor da cor:</h4>

	<jsp:setProperty name="meubean" property="cor" param="cor" /> 

	<div style="color: <jsp:getProperty name="meubean" property="cor" />">
	Desenvolvimento Aberto <br> Página 1</div>

	<p>
		<jsp:getProperty name="meubean" property="cor" />
	</p>

</body>
</html>

JSP – index2.jsp

<html>
<head>
<title>Desenvolvimento Aberto</title>

<!-- Inicializa o JavaBean -->
<jsp:useBean id="meubean" class="org.desenvolvimento.aberto.MeuBean" scope="session"/>
<style type="text/css">

div {
    background-color: lightgrey;
    width: 300px;
    padding: 25px;
    border: 25px solid black;
    margin: 25px;
}

</style>
</head>
<body>

	<h1>JavaBeans e Páginas JSP</h1>

	<h2>Escopo: Session - Pagina 2 </h2>

	<h4>Este é o valor da cor:</h4>

	<jsp:setProperty name="meubean" property="cor" param="cor" /> 

	<div style="color: <jsp:getProperty name="meubean" property="cor" />">
	Desenvolvimento Aberto <br> Página 2</div>

	<p>
		<jsp:getProperty name="meubean" property="cor" />
	</p>

</body>
</html>

A especificação JavaBeans foi desenvolvida com o proposito de criar componentes gráficos, mas os JavaBeans representam um padrão de Design Patterns para componentes também sem rosto em um aplicativo do lado do servidor. Os componentes JavaBeans podem ser usado como blocos de construção em aplicações, assim, um usuário pode estar usando algum tipo de ferramenta de criação para se conectar e personalizar um conjunto de componentes para atuar como um aplicativo, por exemplo, um botão em uma aplicação gráfica seria um Bean.

Outros componentes JavaBeans são como aplicações regulares, que pode então ser criadas em conjunto em documentos compostos. Assim, uma planilha Bean pode ser incorporada dentro de uma página Web.

Especificações JavaBean: http://www.oracle.com/technetwork/java/javase/tech/spec-136004.html

Propriedades – Getter e Setter

Propriedades são atributos que afetam a aparência ou o comportamento de um Bean, em algumas linguagens de scripts estas são acessadas diretamente pelos campos de seu objeto, como em javascript:

objeto.label = "rotulo"; // escrita
objeto.label;            // leitura

Um JavaBean por convenção possui propriedades que devem sempre ser acessadas ​​através de chamadas de métodos em seu objeto proprietário. Para propriedades legíveis haverá um método Getter para ler o valor da propriedade. Para propriedades graváveis ​​haverá uma método Setter para permitir que o valor da propriedade seja atualizado:

objeto.setLabel("rotulo"); // escrita
objeto.getLabel();         // leitura

Tipos de Propriedades JavaBeans

  • Read-only – Somente métodos Getters.
  • Write-only – Somente métodos Setters.
  • Read/write – Getters e Setters.

Utilizando Propriedades de um Bean

Em paginas JSP podemos acessar os métodos Getter e Setter de um JavaBean através de propriedades das tags <jsp: / >, que também são conhecidos pelo nome de Scriptlets. Utilizamos um projeto do tipo Maven com o arquétipo Web App, mas caso você queira pode utilizar um projeto dinâmico para web. Crie uma pagina JSP e uma classe Java e utilize o código abaixo para cada respectivo arquivo:

1 – Você pode notar que o primeiro valor utilizado é inicializado no construtor do Bean, para isto você deve excluir a primeira chamada do método Setter da pagina JSP, utilize os comentários no código para saber mais onde excluir:

Valor inicializado no construtor

Getter – Valor inicializado no construtor

2 – Escrevendo a chamada do primeiro método Setter de volta na pagina JSP você estará definindo o valor para o Bean dinamicamente:

Setter - Valor dinâmico

Setter – Valor dinâmico

3 – Se você utilizar um parâmetro na URL do navegador o segundo método Setter irá definir um valor para a propriedade, use este exemplo e ao final da URL digite:

?parametro=Valor+Modificado+Pelo+parametro
Setter - Parâmetros

Setter – Parâmetros

Exemplo:

Neste exemplo criamos um JavaBean e utilizamos suas propriedades para definir e recuper valores em uma pagina JSP.

Java

package org.desenvolvimento.aberto;

public class MeuBean {

  // Declara atributo
  private String nome;

  // Construtor da classe
  public MeuBean()
  {
	  nome = "Desenvolvimento Aberto";
  }

  // Método Getter
  public String getNome()
  {
	  return nome;
  }

  // Método Setter
  public void setNome(String nome)
  {
	  this.nome = nome;
  }

}

JSP

<html>
<head>
<title>Desenvolvimento Aberto</title>
  <style type="text/css">
    p { color:blue }
  </style>
</head>
<body>
	<!-- Inicializa o JavaBean -->

	<jsp:useBean id="meubean" class="org.desenvolvimento.aberto.MeuBean" /> 

	<!-- Exclua está propriedade para utilizar o valor incializado no construtor do Bean --> 

	<jsp:setProperty name="meubean" property="nome" value="Valor modificado pelo metodo Setter" />	

	<!-- Para usar o Setter utilizando um parâmetro: -->

	<jsp:setProperty name="meubean" property="nome" param="parametro" />

	<h1>JavaBeans e Páginas JSP</h1>

	<h2>Propriedades - Getter e Setter</h2>

	<h4>Este é o valor do meu método Getter do Bean:</h4>

	<p>
	   <jsp:getProperty name="meubean" property="nome" />
	</p>		

</body>
</html>

JSP – JavaBean Components – Java

Publicado: 31 de outubro de 2014 em Java

Um JavaBean também conhecido como Bean é uma especificação que define um conjunto de convenções de programação para classes Java que são usadas como componentes conectáveis​​. Os Beans geralmente representam classes como Produtos, Fornecedores, Pessoas entre outras e podem ser utilizados em paginas JSP puras ou juntamente com os Servlets. É importante não confundir os JavaBeans com os Enterprise JavaBeans, ambos são amplamente utilizados em aplicações web escritas em Java, e veremos muito mais sobre eles nos próximos posts da categoria Java.

Um JavaBean pode encapsular todas as informações sobre o item que ele representa em um pacote simples. Suponha que você tenha um Bean contendo informações sobre um funcionário, como o nome do funcionário, data de admissão, e-mail, endereço e etc. Você pode passar este Bean para outros componentes, fornecendo todas as informações sobre o funcionário de uma única vez. Você também pode adicionar mais informações sobre o funcionário, basta criar mais propriedades no JavaBean. Um outro benefício da utilização de um Bean é poder encapsular todas as regras sobre suas propriedades.

JavaBean

JavaBean

Para usar um Javabean em uma página, você deve informar ao contêiner JSP o tipo de Bean e associá-lo com um nome e uma classe, em outras palavras, você deve declarar o Bean. Você pode fazer isto utilizando as tags JSP:

<jsp:useBean id="meubean" class="org.desenvolvimento.aberto.MeuBean" />

Após ter declarado o JavaBean você pode utilizar suas propriedades para retornar ou adicionar o valor correspondente a uma propriedade, para retornar um valor você pode utilizar a instrução getProperty, adicionando aos atributos o identificador do seu Bean e a propriedade que deseja retornar:

<jsp:getProperty name="meubean" property="arquivos" />

Exemplo:

Neste exemplo utilizamos o JavaBean criando uma classe Java bem comum que serve para inicializar uma lista de imagens em uma pagina JSP.

Obs: O projeto criado no Eclipse na imagem acima utiliza o tipo Apache Maven com um arquétipo webapp e o Apache Tomcat, apesar de você poder utilizar um projeto web dinâmico padrão do Java EE, o ideal é manter esta configuração pois é a configuração utilizada em projetos profissionais, você encontra informações de como instalar, configurar e utilizar o Apache Maven e o Tomcat ou qualquer outra ferramenta utilizada neste site na categoria Java.

Java

package org.desenvolvimento.aberto;

import java.util.*;

public class MeuBean {

	// declara propriedades
	private static int indice = -1;
	private List<String> arquivos;

	// Construtor da classe
	// Por convenção um Java Bean não possui
	// parâmentros no construtor
	public MeuBean() {
		listaInicial();
	}

	// Método Getter
	public String getArquivos() {

		indice++;

		if (indice > arquivos.size() - 1)
		{
			indice = 0;
		}

		return (String) arquivos.get(indice);
	}

	// Metodo inicializado no construtor da classe
	private void listaInicial()
	{
		arquivos = new ArrayList<String>();
		arquivos.add("imagem-verde.jpg");
	}
}

JSP

<html>
<head>
<title>Desenvolvimento Aberto</title>
</head>
<body>
	<h1>JavaBean e Páginas JSP</h1>

	<jsp:useBean id="meubean" class="org.desenvolvimento.aberto.MeuBean" />

	<img src="<jsp:getProperty name="meubean" property="arquivos" />">		

</body>
</html>

 

O Apache Maven é uma ferramenta de gerenciamento de projetos de software e compreensão de pacotes. Baseado no conceito de um modelo de objeto do projeto (POM), O Maven pode gerir um projeto de construção (compilação), elaboração de relatórios e documentação de uma única central de informações.

Um Project Object Model, fornece todas as configurações para um único projeto. A configuração geral cobre o nome do projeto, seu proprietário e suas dependências de outros projetos. Também pode configurar fases individuais do processo de construção, que são implementados como plug-ins. Projetos maiores poderiam ser divididos em vários módulos, ou subprojetos, cada um com seu próprio POM. Cada um pode então escrever um POM raiz através do qual pode-se compilar todos os módulos com um único comando.

O Maven utiliza templates chamados de Archetypes ou arquétipos que são um conjunto de ferramentas de modelagem do projeto Maven. Um arquétipo é definido como um padrão ou modelo inicial a partir da qual todos os outros objetos do mesmo tipo são feitos contemplando as melhores praticas para cada modelo. Os Arquétipos ajudam autores a criar modelos de projeto Maven para os usuários, e oferece aos usuários os meios para gerar versões parametrizadas desses modelos de projeto.

Para instalar o Maven e o M2Eclipse: clique aqui

Criando Uma Aplicação Web com Maven

Após instalar e testar o Apache Maven em seu sistema operacional e também ter instalado o plug-in para utilização do Maven no Eclipse, vamos criar um primeiro projeto Maven para nos aproximar desta ferramenta. Estes projeto vai cobrir primeiramente as funcionalidades básicas do Maven, se você abrir o arquivo pom.xml na raiz do projeto, você verá que existe uma dependência padrão do JUnit.

O JUnit é um framework que nos possibilita realizar testes unitários em nossos programas Java. Por enquanto não vamos utilizar mais nenhuma dependência do Maven pois adicionaremos outras dependências gradualmente assim que utilizarmos outros frameworks em nossa aplicação, vamos utilizar um arquétipo e seu recurso de compressão no formato WAR para que possamos efetuar um Deploy da aplicação na instancia principal do Tomcat.

1 – Clique em File-> New -> Other procure e expanda a pasta Maven, selecione Maven Project e clique em Next:

Maven Project

Maven Project

2 – Aqui você pode configurar a localização do seu projeto, deixe o padrão e clique em Next:

Local do Projeto

Local do Projeto

3 – Esta tela nos possibilita escolher entre vários tipos de arquétipos do Maven, escolha maven-archetype-webapp e clique em Next:

Maven Archetype

Maven Archetype

4 – Preencha os parâmetros para seu arquétipo, basicamente você vai utilizar a convenção utilizada para pacotes Java e um nome de projeto (DaMaven) e clique em Finish quando terminar de preencher os parâmetros, utilize a figura abaixo para referencia:

Propriedades do Arquetipo

Propriedades do Archetype

5 – Assim que o projeto for criado você percebe que há um erro, por falta de dependência: “The superclass “javax.servlet.http.HttpServlet” was not found on the Java Build Path“. Precisamos configurar o projeto para suprir as configurações necessárias. Clique com o botão direito do mouse em cima do projeto e escolha propriedades:

Configuração do projeto

Configuração do projeto

6 – Na janela de propriedades selecione a opção Java Build Path -> Add Library…-> Server Runtime e clique em Next:

Propriedades

Propriedades

7 – Clique em Apache Tomcat e clique em Finish:

Apache Tomcat

Apache Tomcat

8 – Seu projeto já possui todos os requisitos necessários. Abra a pagina index.jsp e utilize o código abaixo e rode o programa:

Testando Aplicação

Testando Aplicação

9 – Com a aplicação já testada, vamos compilar o projeto utilizando o Maven para que seja gerado um arquivo de pacote com nossa aplicação no formato War que será utilizado para efetuar um Deploy no servidor Tomcat. Na barra de ferramentas clique nas opções de compilação e escolha Maven Build:

Maven Build

Maven Build

10 – Na configuração de compilação em Goals, digite: clean install e clique em Run:

Configuração do Build

Configuração do Build

11 – Após o Build bem sucedido, abra a pasta Target e você verá o arquivo comprimido com nossa aplicação DaMaven.war.

Target - DaMaven.war

Target – DaMaven.war

12 – É isso! O Maven já cumpriu seu primeiro proposito, agora fora do Eclipse vamos importar este arquivo para o servidor Tomcat, certifique-se que a instancia principal do Tomcat está rodando em seu computador:

Configuração Tomcat - Instancia Principal

Configuração Tomcat – Instancia Principal

13 – Abra a instancia local do Tomcat no seu navegador:

Tomcat - Localhost

Tomcat – Localhost

14 – Clique em Manager App para acessar as configurações do seu servidor, digite seu login e senha. Em Deploy escolha a opção War File Deploy e acesse o seu arquivo DaMaven.war compilado pelo Maven no Eclipse, o arquivo esta localizado na pasta Target no diretório do seu projeto:

War File Deploy

War File Deploy

15 – Após o Deploy sua aplicação já esta na lista de aplicações do servidor Tomcat e pode ser manuseada:

Lista de Aplicações Web - Tomcat

Lista de Aplicações Web – Tomcat

16 – Para abrir clique no link da sua aplicação ou digite seu nome no seu navegador:

DaMaven - WebApp - Projeto Maven

DaMaven – WebApp – Projeto Maven

Exemplo:

Neste exemplo criamos um projeto Maven com o Archetype do tipo WebApp, sua dependência padrão é do JUnit, responsável por testes unitários na aplicação Java, que por padrão já comtempla  está dependência, compilamos o projeto básico e utilizamos o arquivo compresso de extensão War para efetuar um deploy da aplicação pronta no servidor Tomcat.

JSP – index.jsp

<!DOCTYPE html>
<html>
<head>
<style>
#header {
    background-color:DarkGreen;
    color:white;
    text-align:center;
    padding:5px;
}
#nav {
    line-height:30px;
    background-color:#eeeeee;
    height:400px;
    width:100px;
    float:left;
    padding:5px;
}
#section {
    width:450px;
    float:left;
    padding:10px;
}
#footer {
    background-color:DarkGreen;
    color:white;
    clear:both;
    text-align:center;
   padding:5px;
}
h2 {color: DarkGreen}

</style>
</head>

<body>

<div id="header">
<h1>Desenvolvimento Aberto</h1>
</div>

<div id="nav">
Java<br>
Maven<br>
JSP<br>
JPA<br>
JSF<br>
Servlet<br>
Spring<br>
Hibernate<br>
Tomcat<br>
Oracle DB<br>

</div>

<div id="section">
<h2>Desenvolvimento Aberto</h2>
<p>
Desenvolvimento Aberto é uma organização voltada para o aprendizado e discussão de técnicas de
desenvolvimento focado em algumas linguagens de programação sendo parcialmente/totalmente abertas
ou com licenças gratuitas para desenvolvedores de cada uma de suas respectivas marcas registradas.
</p>
<p>
Desenvolvimento Aberto foi escrito e desenvolve utilizando ferramentas gratuitas disponibilizadas
pelas melhores empresas de software da atualidade, incluindo a própria hospedagem e design deste
site, sendo assim, também proporciona conteúdo gratuito, isso quer dizer que você não paga nada
para aprender e utilizar as tecnologias de ponta que podem ser manuseadas através das linguagens
de programação mais requisitadas pelas empresas no mercado atual.
</p>
</div>

<div id="footer">
Desenvolvimento Aberto © desevolvimento.aberto@live.com
</div>

</body>
</html>

No contexto de um Servlet é possível definir um objeto que recebe as solicitações do cliente e envia-os para qualquer recurso (como um outro servlet, arquivo HTML ou arquivo JSP) no servidor. O container do servlet cria o objeto RequestDispatcher, que é usado como um wrapper em torno de um recurso de servidor localizado em um determinado caminho ou dado por um nome particular. Este método permite que um servlet faça o processamento preliminar de um pedido e outro recurso gere a resposta.

Passando Parâmetros Entre um Servlet e Duas Paginas JSP

Crie uma aplicação Web dinâmica chamada DaWeb002 e uma pagina JSP chamada index.jsp e outra chamada resultado.jsp. Crie um Servlet com o método service chamado MeuResultado, utilize o código abaixo para completar cada respectivo arquivo.

1 – A pagina inicial da aplicação oferece duas combinações na qual você pode selecionar, as opções pertencem umas as outras e o Servlet processa a camada de negocio, avalia os resultados e os envia para a pagina de resultado:

Passando Parâmetros

Passando Parâmetros

2 – O Servlet envia três parâmetros para a pagina JSP, dois são os parâmetros que você escolheu, somente a nível de descrição, pois o processamento já foi efetuado no servlet, o terceiro parâmetro é o resultado da combinação escolhida é uma variável criada no próprio servlet e enviada para a pagina de resultado para que a mensagem possa ser corretamente exibida para o usuário utilizando ainda um código Java através de um Scriptlet:

Exibe Resultado

Exibe Resultado

Exemplo:

Neste exemplo criamos duas paginas JSP e um Servlet no qual processa um resultado para uma seleção do usuário e o exibe através de parâmetros processados na pagina de resultado por meio de Scriptlet.

JSP – index.jsp

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Desenvolvimento Aberto</title>
</head>
<body>
<p>
        <!-- Este é o modo de escrever código Java em uma pagina html -->
        <!-- utilize a marcação abaixo: -->
        <%
            out.println("Desenvolvimento Aberto - Usando Servlets");
        %>
    </p>
    <br />
    <form action="MeuResultado">
        <fieldset>
            <legend>Escolha o vocalista da banda correspondente:</legend>

            <br /> Vocalistas:  <br />

            <select name="vocalistas">
                    <option value="Eddie Vedder">Eddie Vedder</option>
                    <option value="Kurt Cobain">Kurt Cobain</option>
                    <option value="Scott Weiland" selected>Scott Weiland</option>
                    <option value="Layne Staley">Layne Staley </option>
            </select> <br>
            <br /> Bandas: <br /> 

            <select name="bandas">
                    <option value="Stone Temple Pilots">Stone Temple Pilots</option>
                    <option value="Alice in Chains">Alice in Chains</option>
                    <option value="Nirvana" selected>Nirvana</option>
                    <option value="Pearl Jam">Pearl Jam</option>
            </select> <br></br> 

            <input type="submit" value="Enviar">
        </fieldset>
    </form>
</body>
</html>

JSP – resultado.jsp

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Desenvolvimento Aberto - Resultado</title>
</head>
<body>
<!-- Imprime Resultado -->
 <h2>Desenvolvimento Aberto - Resultado</h2>
 <%

    boolean valida = (boolean) request.getAttribute("valida");
    String  nome   = (String)  request.getAttribute("vocalistas");
    String  banda  = (String)  request.getAttribute("bandas");

    if (valida == true)
    {
    	out.println("Você acertou!!!");
    	out.println("O vocalista: " + nome + " pertence a banda: " + banda);
    }
    else
    {
    	out.println("Você errou!!!");
    	out.println("O vocalista: " + nome + " não pertence banda: " + banda);
    } 

 %>
</body>
</html>

Java – MeuResultado.java

package org.desenvolvimento.aberto;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/MeuResultado")
public class MeuResultado extends HttpServlet {
	private static final long serialVersionUID = 1L;       

    public MeuResultado() {
        super();

    }

	protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		// Validador do resultado
		boolean valida = false;

        // Recupera parametros
        String nome = request.getParameter("vocalistas");
        String banda = request.getParameter("bandas");

        // Se nome e banda são iguais OK ou proxima tentativa senão falso
        if ((nome.equals("Eddie Vedder") && banda.equals("Pearl Jam")) ||
        	(nome.equals("Kurt Cobain") && banda.equals("Nirvana")) ||
        	(nome.equals("Scott Weiland") && banda.equals("Stone Temple Pilots")) ||
        	(nome.equals("Layne Staley") && banda.equals("Alice in Chains")))
        {
        	valida = true;
        }

        // Verifica saida no console
        System.out.println(nome);
        System.out.println(banda);
        System.out.println(valida);

        // Define parametros para a sessão
        request.setAttribute("vocalistas", nome);
        request.setAttribute("bandas", banda);
        request.setAttribute("valida", valida);

        // Chama pagina de resposta
        getServletContext().getRequestDispatcher("/resultado.jsp").forward(request, response); 

	}

}

Servlet – Entendendo o doGet e doPost – Java

Publicado: 13 de outubro de 2014 em Java

O protocolo HTTP define oito métodos (GET, HEAD, POST, PUT, DELETE, TRACE, OPTIONS e CONNECT) que indicam a ação a ser realizada no recurso especificado. o método determina o que o servidor deve fazer com a URL fornecida no momento da requisição de um recurso. A classe HTTPServlet Fornece uma classe abstrata para ser uma subclasse de um servlet HTTP adequados a um website. A subclasse de HTTPServlet deve substituir pelo menos um método, normalmente um deles é doGet, se o servlet suporta solicitações HTTP GET ou  doPost, para solicitações HTTP POST ou os outros método suportados pela classe HTTPServlet.

HTTPServlet: http://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpServlet.html

Basicamente você utiliza o método doGet sempre que a requisição que você faz não altere o estado do servidor, como uma consulta, uma busca e etc. O método doPost envia dados para serem processados (por exemplo, dados de um formulário HTML) para o recurso especificado. Os dados são incluídos no corpo do comando.

Utilizando os métodos doGet e doPost

1 – Crie uma aplicação do tipo Dynamic Web Project e chame seu projeto de DaServlet001, crie um novo Servlet chamado MeuServlet, você pode deixar que ele herde os métodos padrões do Wizard da IDE Eclipse que são o doGet e  o doPost, copie o programa abaixo e rode sua aplicação:

Servlet - doGet e doPost

Servlet – doGet e doPost

2 – Como você pode ver nós criamos uma pagina html através do método doGet, ele é automaticamente disparado assim que o servidor processa a url da nossa aplicação :

doGet - url - servlet

doGet – url – servlet

3 – Porem, o método doGet é utilizado para passar informações do navegador para o servidor, isto significa que vamos efetuar uma requisição Client-Server, vamos passar um parâmetro através do nosso browser para que o valor seja processado no servidor de aplicação Java, vamos fazer isto de um modo manual. O método para se passar parâmetros para o servidor é utilizando o caractere de “?” (interrogação) seguido sem espaço pelo nome do parâmetro adicionado do sinal de “=” (igual) e o valor desejado, caso haja mais que um parâmetros separe-os como o caractere “&” (E comercial ou Ampersand). Coloque a seguinte url e digite a tecla enter, mas atente-se a porta correta do seu servidor Tomcat:

http://localhost:9080/DAServlet001/MeuServlet?Parametro1=Meu parametro de teste

Assim que o Servlet executar o método doGet novamente ele vai automaticamente identificar o parâmetro utilizando na requisição GET e imprimir uma linha na pagina HTML.

Parâmetros - doGet

Parâmetros – doGet

4 – O método doPost é disparado quando você clica no botão do formulário html e a ação solicita uma requisição ao Servlet, o nosso método apenas imprime uma linha no navegador:

Servlet - doPost

Servlet – doPost

Exemplo:

Neste exemplo nos criamos uma aplicação web dinâmica e um Servlet e utilizamos os métodos doGet e doPost da classe HTTPServlet. Utilizamos também a manipulação simples de um parâmetro para a requisição doGET.

Java

package org.desenvolvimento.aberto;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class MeuServlet
 *
 * Classe do Servlet
 */
@WebServlet("/MeuServlet")
public class MeuServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;

    /**
     * @see HttpServlet#HttpServlet()
     *
     * Construtor do Servlet
     */
    public MeuServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 *
	 * Método GET
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		String meuHtml = "<html xmlns=\"http://www.w3.org/1999/xhtml\">" +
						 "<head><title>Desenvolvimento Aberto</title></head>" +
						 "<body>" +
						 "<h1>Desenvolvimento Aberto</h1> <br />" +
						 "<h3>Java - Servlet - doGet</h3>" +
						 "Pagina criada pelo metodo do Servlet <br />" +

						 // Para que o método post seja disparado
						 // o form precisa saber o método - method="post"
						 // também funciona com o metodo get

						 "<form action=\"MeuServlet\" method=\"post\"> <br />" +
						 "<input type=\"submit\" value=\"Enviar\">" +
						 "</form>" +
						 "</body>" +
						 "</html>";

		PrintWriter imprimir = response.getWriter();

		imprimir.println(meuHtml);      

		// Recupera Parametros da URL

		String parametro = request.getParameter("Parametro1");	

		if (parametro != null )
		{
			imprimir.println("O parametro digitado foi: " + parametro);
		}

	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 *
	 * Método POST
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		PrintWriter imprimir = response.getWriter();

		imprimir.println("Método POST foi disparado!");
	}

}

JSP – JavaServer Pages – Java

Publicado: 10 de outubro de 2014 em Java

A tecnologia JavaServer Pages (JSP) permite que você crie facilmente conteúdo da web de modo estático e dinâmico. A Tecnologia JSP disponibiliza todas as capacidades dinâmicas da tecnologia Java Servlet, mas fornece uma abordagem mais natural para a criação de conteúdo estático. Uma página JSP é um documento de texto que contém dois tipos de texto: dados estáticos, que podem ser expressos em qualquer formato baseado em texto como o HTML, SVG, WML e XML, e elementos JSP, que constroem conteúdo dinâmico.

Um Scriptlet pode conter instruções da linguagem Java, declarações de variáveis, método, ou expressões que são válidas na língua e podem ser utilizadas em páginas JSP.

Para saber mais sobre a linguagem de scripts utilizada neste exemplo, em especial HTML Forms, você pode utilizar a documentação aberta para web fornecida pela Mozilla no seguinte link:

MDN: https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Forms

Criando um Projeto JSP Utilizando Servlet

1 – Crie um novo projeto do tipo Dynamic Web Project, e o nomeie de DaJSP. Com o botão direito no nome do projeto escolha New e selecione JSP File, o nomeie de index.jsp e clique em Next:

Arquivo JSP

Arquivo JSP

2 – Escolha o arquivo do tipo JSP (xhtml):

JSP - XHTML

JSP – XHTML

3 – Crie um novo Servlet chamado de ServletAcao apenas com o método service, utilize o código abaixo para completar os dois arquivos gerados automaticamente pela IDE Eclipse, o index.jsp e a classe ServletAcao. Clique em Run com o arquivo index.jsp aberto na IDE e o teste:

Rodando a Página JSP

Rodando a Página JSP

4 – Utilize a URL do Eclipse no navegador para ver como a pagina JSP se comporta em um Browser:

Index.jsp

Index.jsp

5 – Após clicar no botão da pagina o Servlet é utilizado através da ação do formulário HTML e o conteúdo Java da classe ServletAcao é executado:

Servlet - Java

Servlet – Java

Exemplo:

Neste exemplo criamos um projeto para web dinâmico que utiliza uma pagina JSP e um Servlet, utilizamos o Java no HTML através de declarações de Scriptlets e utilizamos o Servlet em conjunto com a ação da tag Form da pagina XHTML para que classe do Servlet execute seu conteúdo.

JSP

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Desenvolvimento Aberto - Servlet & Java Server Pages</title>
</head>
<body>
	<p>
		<!-- Este é o modo de escrever código Java em uma pagina html -->
		<!-- utilize a marcação abaixo: -->
		<%
			out.println("Desenvolvimento Aberto (Titulo Java Dinâmico)");
		%>
	</p>
	<br />
	<form action="servletacao">
		<fieldset>
			<legend>Escolha uma banda:</legend>
			<br /> Seu Nome:<br /> <input type="text" name="Nome"> <br />
			<br /> Bandas: <br /> <select name="bandas">
					<option value="Stone Temple Pilots">Stone Temple Pilots</option>
					<option value="Alice in Chains">Alice in Chains</option>
					<option value="Screaming trees" selected>Screaming trees</option>
					<option value="Mother Love bone">Mother Love bone</option>
			</select> <br></br> <input type="submit" value="Enviar">
		</fieldset>
	</form>
</body>
</html>

Java – Servlet

package org.desenvolvimento.aberto;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class ServletAcao Classe do Servlet
 */
@WebServlet("/servletacao")
public class ServletAcao extends HttpServlet {
	private static final long serialVersionUID = 1L;

	/**
	 * @see HttpServlet#HttpServlet() Construtor do Servlet
	 */
	public ServletAcao() {
		super();

	}

	/**
	 * @see HttpServlet#service(HttpServletRequest request, HttpServletResponse
	 *      response) Metodo de serviço do Servlet
	 * 
	 *      Utilizando Request e Response
	 */
	protected void service(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		PrintWriter imprimir = response.getWriter();

		// Recupera parametros
		String nome = request.getParameter("Nome");
		String banda = request.getParameter("bandas");

		// Você também pode criar html dinâmico utilizando o Servlet
		imprimir.println("Desenvolvimento Aberto Servlet/JSP:");
		imprimir.println("Nome: " + nome);
		imprimir.println("Banda escolhida: " + banda);

	}

}

 

O Apache Tomcat Project mais recente inclui várias correções para problemas identificados em suas versões anteriores, bem como uma série de outras melhorias e mudanças. Configurar o Tomcat no Eclipse é fácil pois a IDE já comtempla uma integração com a empresa Apache tornando todo o procedimento muito simples. Atente-se que para utilizar a versão 8 do Tomcat no Eclipse você precisa ter a ultima versão do Eclipse ou atualizar a sua IDE com os releases mais recentes.

Configurando o Tomcat

Para configurar o Tomcat com sucesso, primeiro você precisa atribuir os direitos para que seu usuário possa acessar as configurações do Tomcat através da IDE Eclipse, digite o seguinte comando no terminal do Linux:

sudo chown -R user1 /var/local/apache-tomcat-8.0.14

1 – Abra a IDE Eclipse e no menu Window, na opção Show View e escolha Servers. A janela de servidores aparecerá no canto inferior do Eclipse dizendo que não há nenhum servidor disponível, clique em novo servidor e expanda a pasta Apache e selecione a opção Apache Tomcat V8.0 Server, em seguida clique em Next:

Apache Tomcat - Novo Servidor

Apache Tomcat – Novo Servidor

2 – Na janela seguinte escolha a pasta onde se encontra a instalação do Tomcat, em seguida o JRE de sua maquina e clique em Finish:

Local da Instalação e JRE

Local da Instalação e JRE

3 – Com o servidor já criado precisamos inicia-lo, porem o Tomcat roda por instancia e se a instancia principal do servidor já estiver rodando em seu computador encontraremos um conflito nas portas de comunicação do servidor, você pode parar (Stop) a instancia principal, ou modificar as portas da sua instancia dinâmica clicando duas vezes no seu servidor, na aba Serves, localizado no painel inferior do Eclipse, e mudar as portas para que não exista conflito entre instancias do Tomcat:

Tomcat - Instancia e Portas

Tomcat – Instancia e Portas

Pronto, basta iniciar o servidor clicando na seta verde ou na opção Start e já temos uma configuração básica do Tomcat para criar nossos programas web em Java.

 

Criando uma Aplicação Java Servlet e testando o Tomcat

A API Java Servlet encontrada no pacote javax.servlet proporciona ao desenvolvedor a possibilidade de adicionar conteúdo dinâmico em um servidor web usando a plataforma Java. Os Servlets são classes Java usadas para estender as funcionalidades de um servidor. Apesar dos Servlets poderem responder a quaisquer tipos de requisições, eles normalmente são usados para estender as aplicações hospedadas por servidores web. Podemos dizer que Servlets são os equivalentes Java a outras tecnologias de conteúdo Web dinâmico, como PHP, ASP.NET e muitos outros.

1 – Crie um novo projeto dinâmico para a web, para isto abra no menu a opção Project, New e escolha Dynamic Web Project, coloque o nome do projeto de DaServets e clique em Next:

Servlet - Novo Projeto

Servlet – Novo Projeto

2 – Na tela seguinte marque o cheque Generate web.xml deployment descriptor e clique em Finish:

Xml

Xml

3 – Agora precisamos criar um novo Servlet que é nada mais que uma classe no qual vamos programar. No nome do projeto na janela Project Explorer, clique com o botão direito, escolha New e escolha Servlet. Para o pacote nomeie como org.desenvolvimento.aberto e para a classe, MeuServlet e clique em Next:

Novo servlet

Novo servlet

4 – Na opção url mappings, para padronizar você pode editar a url e mudar todas as letras para caracteres em minúsculos e clique em Next:

Url - Mappings

Url – Mappings

5 – Na opção seguinte você pode escolher quais métodos serão criados automaticamente, desmarque o doPost e doGet e deixe somente service:

Métodos Automaticos

Métodos Automaticos

6 – Utilize o código abaixo para completar seu código gerado automaticamente e clique em Run para rodar o programa, escolha o servidor Tomcat e clique em Finish:

Escolhe Servidor

Escolhe Servidor

7 – Pronto, sua primeira aplicação web dinâmica foi executada com sucesso:

Hello World - Servlet Tomcat

Hello World – Servlet Tomcat

8 – Você pode abrir o seu navegador web e digitar a url do servidor para ver sua aplicação, utilize o seguinte endereço: http://localhost:9080/DaServets/meuservlet

Servlet - Navegador

Servlet – Navegador

Agora você já pode utilizar outros exemplos Java EE para saber mais sobre Java Enterprise.

Java

package com.desenvolvimento.aberto;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class MeuServlet
 * Classe
 */
@WebServlet("/meuservlet")
public class MeuServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;

    /**
     * @see HttpServlet#HttpServlet()
     * Construtor da classe
     */
    public MeuServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#service(HttpServletRequest request, HttpServletResponse response)
	 * Metodo service
	 */

	protected void service(HttpServletRequest request, HttpServletResponse response)
	                   		throws ServletException, IOException {

		PrintWriter imprimir = response.getWriter();
		imprimir.println("Desenvolvimento Aberto - Hello World");

	}
}

O Apache Tomcat Project mais recente inclui várias correções para problemas identificados em suas versões anteriores, bem como uma série de outras melhorias e mudanças. Configurar o Tomcat no Eclipse é fácil pois a IDE já comtempla uma integração com a empresa Apache tornando todo o procedimento muito simples. Atente-se que para utilizar a versão 8 do Tomcat no Eclipse você precisa ter a ultima versão do Eclipse ou atualizar a sua IDE com os releases mais recentes.

Configurando o Tomcat

1 – Abra a IDE Eclipse e no menu Window na opção Show View e escolha Servers. A janela de servidores aparecerá no canto inferior do Eclipse dizendo que não há nenhum servidor disponível, clique em novo servidor e expanda a pasta Apache e selecione a opção Apache Tomcat V8.0 Server, em seguida clique em Next:

Apache Tomcat - Novo Servidor

Apache Tomcat – Novo Servidor

2 – Na janela seguinte escolha a pasta onde se encontra a instalação do Tomcat, em seguida o JRE de sua maquina e clique em Finish:

Local e JRE

Local e JRE

3 – Com o servidor já criado precisamos inicia-lo, porem o Tomcat roda por instancia e se a instancia principal do servidor já estiver rodando em seu computador encontraremos um conflito nas portas de comunicação do servidor, você pode parar (Stop) a instancia principal, ou modificar as portas da sua instancia dinâmica clicando duas vezes no seu servidor, na aba Serves, localizado no painel inferior do Eclipse, e mudar as portas para que não exista conflito entre instancias do Tomcat:

Tomcat - Instancias e portas

Tomcat – Instancias e portas

Pronto, basta iniciar o servidor clicando na seta verde ou na opção Start e já temos uma configuração básica do Tomcat para criar nossos programas web em Java.

 

Criando uma Aplicação Java Servlet e testando o Tomcat

A API Java Servlet encontrada no pacote javax.servlet proporciona ao desenvolvedor a possibilidade de adicionar conteúdo dinâmico em um servidor web usando a plataforma Java. Os Servlets são classes Java usadas para estender as funcionalidades de um servidor. Apesar dos Servlets poderem responder a quaisquer tipos de requisições, eles normalmente são usados para estender as aplicações hospedadas por servidores web. Podemos dizer que Servlets são os equivalentes Java a outras tecnologias de conteúdo Web dinâmico, como PHP, ASP.NET e muitos outros.

1 – Crie um novo projeto dinâmico para a web, para isto abra no menu a opção Project, New e escolha Dynamic Web Project, coloque o nome do projeto de DaServets e clique em Next:

Dynamic Web Project

Dynamic Web Project

2 – Na tela seguinte marque o cheque Generate web.xml deployment descriptor e clique em Finish:

xml.web

xml.web

3 – Agora precisamos criar um novo Servlet que é nada mais que uma classe no qual vamos programar. No nome do projeto, na janela Project Explorer, clique com o botão direito, escolha New e escolha Servlet. Para o pacote nomeie como org.desenvolvimento.aberto e para a classe, MeuServlet e clique em Next:

New Servlet

New Servlet

4 – Na opção url mappings, para padronizar você pode editar a url e mudar todas as letras para caracteres em minúsculos e clique em Next:

Url Mappings

Url Mappings

5 – Na opção seguinte você pode escolher quais métodos serão criados automaticamente, desmarque o doPost e doGet e deixe somente service:

Métodos automaticos

Métodos automáticos

6 – Utilize o código abaixo para completar seu código gerado automaticamente e clique em Run para rodar o programa, escolha o servidor Tomcat e clique em Finish:

Servidor

Servidor

7 – Pronto, sua primeira aplicação web dinâmica foi executada com sucesso:

Hello World - Servlet - Tomcat

Hello World – Servlet – Tomcat

8 – Você pode abrir o seu navegador web e digitar a url do servidor para ver sua aplicação, utilize o seguinte endereço: http://localhost:9080/DaServets/meuservlet

Navegador Web

Navegador Web

Agora você já pode utilizar outros exemplos Java EE para saber mais sobre Java Enterprise.

Java

package com.desenvolvimento.aberto;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class MeuServlet
 * Classe
 */
@WebServlet("/meuservlet")
public class MeuServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;

    /**
     * @see HttpServlet#HttpServlet()
     * Construtor da classe
     */
    public MeuServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#service(HttpServletRequest request, HttpServletResponse response)
	 * Metodo service
	 */

	protected void service(HttpServletRequest request, HttpServletResponse response)
	                   		throws ServletException, IOException {

		PrintWriter imprimir = response.getWriter();
		imprimir.println("Desenvolvimento Aberto - Hello World");

	}
}

 

Eclipse – Spring Tool Suite – Linux – Java

Publicado: 10 de outubro de 2014 em Java, Linux

O Spring IO é uma plataforma 100% open source, leve e modular que reúne as principais APIs Spring em uma plataforma fundamentalmente coesa e com versão para aplicações modernas. No topo desta fundação também oferece ambientes de execução de domínio específico (DSRs) otimizados para tipos de aplicativos selecionados. Spring IO é composta por camadas de execução, como o Spring IO Foundation e Spring IO Execution layers.

A camada de fundação representa os módulos do núcleo do Spring e dependências de terceiros associados que tenham sido harmonizadas para garantir uma experiência de desenvolvimento suave. As DSRs fornecidos pelo Execution Layer do Spring IO simplificam, drasticamente a construção, as cargas de trabalho baseadas em JVM prontos para produção.

Spring Tool Suite for Eclipse

O Spring Tool Suite é um ambiente de desenvolvimento baseado em Eclipse que é personalizado para desenvolvimento de aplicações Spring. Ele fornece um ambiente de pronto para usar e para implementar, depurar, executar e implantar seus aplicativos Spring, incluindo integrações para Pivotal tc Server, Pivotal Cloud Foundry, Git, Maven, AspectJ, que integram os últimos lançamentos do Eclipse.

Spring IO: http://spring.io/tools/eclipse

Instalando o  Spring Tool Suite Windows

1 – Para instalar o STS abra a sua versão do Eclipse, no menu Help clique em Eclipse Market Place, no campo de pesquisa digite spring e execute a busca, localize a versão do STS para sua versão do Eclipse e clique em Install:

Marketplace - Linux

Marketplace – Linux

2 – Na tela de confirmação aguarde as opções serem carregadas e clique em Confirm:

Comfirmar - Linux

Comfirmar – Linux

3 – Aceite a licença e clique em Finish:

Licença - Linux

Licença – Linux

4 – Pronto, você pode utilizar o Spring Dashboard localizado no menu Help para saber mais e ficar atualizado sobre as novidades do Spring:

STS - Linux

STS – Linux

Você também pode utilizar nossos exemplos Java Enteprise para saber como funciona o Spring.