Manual de Jsp

5/14/2018 Manual de Jsp - slidepdf.com

http://slidepdf.com/reader/full/manual-de-jsp-55ab4de11c99e 1/23

Manuais e recursos para desenvolvimento webwww.criarweb.com

Manual de JSP

Autores do manual

Este manual foi criado pelos seguintes colaboradores de Criarweb.com:

Miguel Angel Alvarez -Tradução de JML (2 capítulos)

Fernando Arturihttp://www.arturi.com.ar (3 capítulos)

Julio N. Argota Quiroz (1 capítulo)

Roberto Canales Morahttp://www.adictosaltrabajo.com (1 capítulo)

Manual de JSP: http://www.criarweb.com/jsp/ © Os manuais de CriarWeb.com têm copyright dos autores. Não reproduzir sem autorização.

1

http://www.desarrolloweb.com/

http://www.arturi.com.ar/


http://www.adictosaltrabajo.com/


http://www.criarweb.com/jsp/








O que é JSP

JSP é a abreviação de Java Server Pages, que em português seria algo como Páginas de

Servidor Java. É então, uma tecnologia orientada a criar páginas web com programação emJava.

Bibliografia: Esta descrição de JSP está extraída de um PDF em inglês muito completo que introduz atecnologia, que pode ser encontrada na página corporativa de Java de Sun Microsystems, em sua seçãode aprendizado on-line. Por sua vez, tal manual provém do portal Java jGuru .

jGuru: Introduction to JavaServer Pages technology

Com JSP podemos criar aplicações web que se executam em vários servidores web, demúltiplas plataformas, já que Java é em essência uma linguagem multiplataforma. As páginasJSP estão compostas de código HTML/XML misturado com etiquetas especiais para programarscripts de servidor em sintaxe Java. Portanto, poderemos escrever as JSP com nosso editorHTML/XML habitual.

Motor JSP

O motor das páginas JSP está baseado nos servlets de Java -programas em Java destinados ase executar no servidor-, embora o número de desenvolvedores que podem afrontar aprogramação de JSP é muito maior, dado que é muito mais simples de aprender que osservlets.

Em JSP criamos páginas de maneira parecida a como se criam em ASP ou PHP -outras duastecnologias de servidor. Geramos arquivos com extensão .jsp que incluem, dentro da estruturade etiquetas HTML, as sentenças Java a executar no servidor. Antes que os arquivos sejamfuncionais, o motor JSP realiza uma fase de tradução dessa página em um servlet,implementado em um arquivo class (Byte codes de Java). Esta fase de tradução se realizahabitualmente quando se recebe a primeira solicitação da página .jsp, embora exista a opçãode pré-compilar em código para evitar esse tempo de espera na primeira vez que um clientesolicita a página.

Exemplo de página JSP

Na imagem seguinte pode-se ver um exemplo extremamente simples de uma página JSP e oesquema de conversão dessa página em um servlet.


2


http://java.sun.com/

http://developer.java.sun.com/developer/onlineTraining/


http://www.jguru.com/



http://developer.java.sun.com/developer/onlineTraining/JSPIntro/


http://www.criarweb.com/artigos/200.php?manual=11



http://java.sun.com/













Pré-requisitos

Para aprender JSP, a parte de conhecer HTML, será necessário compreender e ter algo deexperiência na programação em Java, que é uma Linguagem de Programação Orientada aObjetos por completo. Uma vez conhecida a programação em Java pode-se estudar por alto osistema de Servlets, o que nos dará uma melhor idéia do funcionamento interno do motor JSP.

Ademais, necessitaremos baixar e instalar Tomcat, o contêiner de servlets usado na referênciaoficial de implementação de JSP. Podemos acessar a um exercício para aprender a realizar estainstalação, disponível também na referência de aprendizagem da página de Java.

Artigo por Miguel Angel Alvarez - Tradução de JML

Comparando JSP com ASP

JSP e ASP servem para fazer, mais ou menos, o mesmo tipo de aplicações web. Entretanto, nofundo têm bastantes diferenças. Depois de minha experiência no trabalho com JSP, um dia, umcliente me perguntou por que não programava a página em ASP no lugar de JSP, já que haviaescutado falar que o sistema de Microsoft tinha umas características muito apropriadas paraseu modelo de negócio. A partir desta sugestão, e para que meu cliente ficasse satisfeito coma tecnologia JSP -que é a que prefiro utilizar-, preparei uma lista de vantagens de utilizarpáginas dinâmicas Java frente às de Microsoft.

Plataforma e independência do servidor

JSP segue a filosofia da arquitetura JAVA de "escreve uma vez, executa onde quiser". Aimplantação de ASP está limitada para arquiteturas baseadas em tecnologia Microsoft.

Assim, JSP pode ser executado nos sistemas operativos e servidores web mais populares,


3





http://jakarta.apache.org/tomcat/

http://developer.java.sun.com/developer/onlineTraining/JSPIntro/exercises/SetupTomcat/index.html


http://developer.java.sun.com/





http://jakarta.apache.org/tomcat/



http://developer.java.sun.com/






como por exemplo, Apache, Netscape ou Microsoft IIS. Enquanto que ASP só tem suportenativo para os servidores IIS e Personal Web Server, que são os dois servidores web parasistemas Microsoft, o primeiro com tecnologia NT e o segundo para sistemas Windows 98 e

similares.

Processo de desenvolvimento aberto (open source)

O API JSP se beneficia da extensa comunidade JAVA existente, pelo contrário a tecnologia ASPé específica de Microsoft que desenvolve seus processos internamente.

TAGS

Enquanto que tanto JSP como ASP usam uma combinação de tags e scripts para criar páginasweb dinâmicas, a tecnologia JSP permite aos desenvolvedores criar novas tags. Assim osdesenvolvedores podem criar novas tags e não depender tanto dos scripts.

Reusabilidade entre plataformas.

Os componentes JSP são reusáveis em distintas plataformas (UNIX, Windows).

A vantagem Java

A tecnologia JSP usa Java como linguagem de Script enquanto que ASP usa VBScript ouJscript. Java é uma linguagem mais potente e com mais escalas que as linguagens de Script.As páginas JSP são compiladas em Servlets pelo qual atuam como uma porta a todos osserviços Java de Servidor e livrarias Java para aplicações http. Java faz o trabalho dodesenvolvedor mais fácil p. e. ajuda a proteger o sistema contra as "caídas" enquanto que asaplicações ASP sobre sistemas NT são mais suscetíveis a sofrê-las, também ajuda no manejoda memória protegendo contra falhas de memória e o duro trabalho de buscar os falhos deperda de ponteiros de memória que podem tornar mais lento o funcionamento de umaaplicação.

Manutenção

As aplicações que usam JSP têm uma manutenção mais fácil que as que usam ASP.

• As linguagens de Script estão bem para pequenas aplicações, mas não se encaixambem para aplicações grandes. Java é uma linguagem estruturada e é mais fácil deconstruir e possui manutenções grandes como aplicações modulares.

• A tecnologia JSP faz maior ênfase nos componentes do que nos Scripts, isto faz com

que seja mais fácil revisar o conteúdo sem que afete a lógica ou revisar a lógica semmudar o conteúdo.• A arquitetura EJB encapsula a lógica de p. e.: acesso a BD, segurança, integridade

transacional e isolamento da aplicação.• Devido a que a tecnologia JSP é aberta e multiplataforma, os servidores web,

plataformas e outros componentes podem ser facilmente atualizados ou mudados semque afete às aplicações baseadas na tecnologia JSP.

Conclusão

As vantagens sobre utilizar a tecnologia Java em relação à proprietária de Microsoft (ASP) são,como se pode ver, diversas e interessantes. Entretanto, podemos apontar uma vantagem daprogramação em ASP, pois é bastante mais fácil de aprender que JSP, pelo menos se não se


4








tem uma experiência prévia em programação. Isto é devido a que Java é uma linguagemmuito potente, mas um pouco mais complicada de usar porque é orientada a objetos e amaneira de escrever os programas é mais rígida.

Artigo por Miguel Angel Alvarez - Tradução de JML

Conexão a um database server com JSP

Neste artigo trataremos o tema da conexão a uma database desde uma página JSP, para isto,criaremos uma classe (ConnectionCreator) , que será usada por nossa página. Em primeirolugar nos conectaremos a um SQL Server, logo poderemos ver como modificando um pouco aclasse também se pode usar para MySql.

Começamos então escrevendo o código da primeira versão da classe, para logo explica-la commais detalhes:

Linha 1: definição do package que conterá a classe, necessário para logo importar a classedentro da página.

Linhas 3 e 4: Importamos duas classes standard de Tomcat.

Linha 6 : Definição da classe, como pública, com o nome ConnectionCreator.

Linha 8: Definição do único método da classe, getSqlServerConnection, que receberá comoparâmetros uma lista de valores, para devolver logo, um objeto java.sql.Connection.


5








Os parâmetros que a classe recebe são: database (nome do database), servername (nome ouip do database server), port (porta de conexão, no caso de SQL geralmente é 1433), username

e password.

Linha 10: try, é o começo do bloco de código que executaremos

Linha11: Instancia-se o driver de SQL, que obviamente deve estar presente já seja nasbibliotecas de Tomcat ou nas de nosso site (pasta \WEB-INF\lib). Estes drivers se baixamgratuitamente da Internet e vêem empacotados sob a forma de arquivos JAR.

Linhas 12 a 14: Construímos uma cadeia de caracteres chamada url, que será utilizada logopara abrir a conexão. A estrutura deste texto é standard, só há que intercalar os parâmetrosrecebidos.

Linha 15: Finalmente chegamos ao coração da classe, instanciamos um objeto Connection e,através do DriverManager, tratamos de nos conectar ao servidor, passando como parâmetro aurl construída anteriormente.

Linhas 16 a 19: Não são estritamente necessárias, porém servem como ajuda ao programador.Controlamos que a conexão tenha sido bem-sucedida e que esteja aberta (por padrão sempreestá) e mandamos à console de Tomcat a mensagem correspondente. O mesmo no caso deque o processo tenha falhado.

Linha 21: a função devolve o objeto.

Linhas 23 a 26: No caso de que se produza um erro dentro da estrutura try, o mesmo éprocessado pela estrutura catch, que imprime a mensagem de erro produzido.

A esta altura o método terminou, e não nos resta mais do que ver como se utiliza dentro dapágina JSP.

Vejamos:

<%@ page language="java" %><%@ page import = "notas.ConnectionCreator"%><%@ page import = "java.sql.Connection"%><%

Connection minhaConexao = ConnectionCreator.getSqlServerConnection("Orders", "127.0.0.1",1433,"sa", "");

if (minhaConexao.isClosed())

out.print("FUNCIONA !"); /* CORPO DA PAGINA */

miConexion.close(); /* nao se esquecer de fechar as conexoes. */

%>

Aqui simplesmente criamos um objeto Connection e , através do métodogetSqlServerConnection de nossa classe, nos conectamos ao database.Ao final da página, fechamos a conexão.

No caso de querer conectar um servidor MySql, convém agregar um segundo método à classe,específico para este tipo de server. Por suposto que deverão existir também os drivers de


6








MySql em nosso site.

Vejamos como seria o método getMySqlConnection

Basicamente a lógica é a mesma, muda obviamente o driver iniciado, e a estrutura da url, jáque neste caso não contém nem usuário e nem password, dados estes que são passadosdiretamente ao DriverManager.

Artigo por Fernando Arturi

Construção dinâmica de menus de seleção utilizando JSP

Acontece quando temos que gerar menus de seleção dentro de páginas HTML. Muitas vezesestes menus são idênticos ou muito parecidos, e pode ocorrer de ocuparem muito lugar dentrode nossa página web.

A idéia é passar a esta função os parâmetros que nos interessam, e deixar que ela se ocupe doresto. Vejamos o código da página, com uma breve explicação abaixo de cada bloco de código.

<%@ page language="java"%><%!

private void writeMenu(javax.servlet.jsp.JspWriter out, int startValue,int endValue, int selectedValue){try{

// esta linha eh opcional...out.println("<option value=\"-1\" selected>

Selecione uma opcao</option>");

// comeco o ciclo com a classe de valores dado.for (int i=startValue; i<(endValue+1); i++){

// se o valor atual corresponde ao valor do ciclo, //faco aparecer como selecionado

if (i == selectedValue){


7








out.println("<option value=\""+i+"\"selected>"+i+"</option>");}else{

out.println("<option value=\""+i+"\">"+i+"</option>");}}

}catch(java.io.IOException e1){System.out.println(e1);}

}%>

Esta é a função que gera o menu, recebe como parâmetros o valor inicial, o valor final, o valoratual e o objeto JspWriter, que permite escrever dinamicamente sobre a página.

<%

java.util.GregorianCalendar cal = new java.util.GregorianCalendar();int day = cal.get(cal.DAY_OF_MONTH);int month = (cal.get(cal.MONTH)) + 1;int year = cal.get(cal.YEAR);

%>

Criamos variáveis de página, que nos servirão somente para provar a função.

<html><head><title>Construção dinâmica de menus de seleção</title></head>

<body>

<table><h1>construcao dinamica de menus de selecao</h1><tr><td>Dia:<select><% writeMenu(out,1,31,day); %></select></td>

<td>Mes:<select><% writeMenu(out,1,12,month); %></select>

</td><td>Ano:<select><% writeMenu(out,2000,2010,year); %></select>

</td>

</tr></table>

</body></html>


8








Finalmente o html, muito simples, que mostra como se usa a funcao.Uma variante deste procedimento seria, por exemplo, ler dados de uma database. Porexemplo, se quisermos gerar um clássico menu com a lista de países do mundo, poderemos

fazer uma função deste tipo:public void writeCountryMenu(Connection connection,

javax.servlet.jsp.JspWriter out, int currentValue){try{String sqlString = " SELECT id,Name from T_Countries order by orderview ";

Statement stmt = connection.createStatement();ResultSet rs = stmt.executeQuery(sqlString);while (rs.next()){String selected = "";

int countryId = rs.getInt("id");if (countryId==currentValue)selected = "SELECTED";

out.print("<option value=\""+countryId+"\" "+selected+">"+rs.getString("Name")+"</option>");

}rs.close();stmt.close();

}catch(Exception e){System.out.println(e);

}}

Neste caso obviamente temos que passar uma conexão a um database (pode ser MsSQL,MySql, etc.) no qual temos a tabela T_countries, com os campos id, name e orderview.


Instalação de Tomcat para utilizar servlets ou JSP

Este processo é bastante simples, porém consta de uma série de pasos que devem serrealizados ao pé da letra:

a) Instalar o servidor Tomcat e alguma versão do J2SDK (recomenda-se 1.4.01 ou a EnterpriseEdition), indicando o lugar onde se encontra instalada a JVM (Java Virtual Machine), e depreferência, deixando como porto o 4848 para o acesso do servidor.

b) Posteriormente, procede-se a configurá-lo no computador. Para isto cria-se uma "variável deambiente". Se usar Windows 95/98/2000/XP, cria-se modificando o arquivo autoexec.batlocalizado em c:\ (está como arquivo oculto). Sua modificação se faz agregando-lhe a seguintelinha:

set classpath = "rota"

Onde "rota" é a localização dos arquivos jsp-api.jar e servlet-api.jar que se encontram napasta: rota_de_instalacao_do_servidor_tomcat/common/lib.

A seguir um exemplo de linha para agregar ao autoexec.bat, supondo que o servidor tomcat seinstalou em c:\arquivos de programa:


9








SET CLASSPATH= C:\Arquivos de programa\Apache Software Foundation\Tomcat 5.0\common\lib\jsp-api.jar;C:\Arquivos de programa\Apache Software Foundation\Tomcat 5.0\common\lib\jsp-api.jar

Lembrando que também se agrega ao claspath o endereço da rota onde se encontra a pasta\bin do j2sdk (compilador de java).

c) Uma vez feito o anterior, para agregar o primeiro servlet ao site, busca-se o arquivoweb.xml, o qual se encontra em rota_de_instalacao_do_servidor_tomcat\Apache SoftwareFoundation\Tomcat 5.0\webapps\ROOT\WEB-INF\ e se agrega à pasta webapps onovo_servlet.class (que é o resultado da compilação do novo_servlet.java). Além disso, há queacrescentar estas linhas ao arquivo web.xml:

<servlet><servlet-name>novo_servlet</servlet-name><servlet-class>novo_servlet</servlet-class>

</servlet><servlet-mapping>

<servlet-name>novo_servlet</servlet-name><url-pattern>novo_servlet</url-pattern>

</servlet-mapping>

Porém, como o arquivo já tem escrito, acomoda-se de tal maneira que ficará assim:

<servlet><servlet-name>org.apache.jsp.index_jsp</servlet-name><servlet-class>org.apache.jsp.index_jsp</servlet-class>

</servlet><servlet>

<servlet-name>novo_servlet</servlet-name><servlet-class>novo_servlet</servlet-class>

</servlet><servlet-mapping><servlet-name>org.apache.jsp.index_jsp</servlet-name><url-pattern>/index.jsp</url-pattern>

</servlet-mapping><servlet-mapping>

<servlet-name>novo_servlet</servlet-name><url-pattern>novo_servlet</url-pattern>

</servlet-mapping>

d) Por último prova-se o servlet escrevendo no explorador http:\\localhost:484\novo_servlet epronto! Com isso você deverá ver o resultado.

Artigo por Julio N. Argota Quiroz

Uso de XML e XSL em JSPs

Utilizando JSP 2.0, podemos combinar JSP e XSL para formatar documentos XML no servidor.

Nem sempre é possível (nem conveniente) utilizar o último do último. Se observarem, asgrandes organizações normalmente padronizam uma versão de Java, JSP, EJB, etc... e até quese não passe um tempo e se consolidam as tecnologias (e aparecem remendos) não se mudade versão.


10








Então, é possível que tenhamos que nos virar para fazer o mesmo ..... com versões anterioresde JSP.

Vocês verão que é bastante simples e lhes mostraremos como se faz passo a passo....utilizando o patrono MVC.

Colocaremos os exemplos com NetBeans. Muita gente me pergunta por que o utilizo..... Arazão é simples, parece muito intuitivo... embora haja outras opções mais potentes.

Criar o Projeto

Criamos em NetBeans um projeto

Vamos criar alguns documentos XML e XSL com os geradores de código.


11








Selecionamos dentro do grupo XML

Atribuímos um nome

Vamos utilizar este documento como base:

<?xml versao="1.0" encoding="UTF-8"?><tutoriais><tutorial><autor>[email protected]</autor><nome>JSP 2.0</nome><link>jspel</link><descricao>Novas caracteristicas de JSPs 2.0</descricao>

</tutorial><tutorial><autor>[email protected]</autor>

<nome>Struts e Eclipse</nome><link>struts</link><descricao>Configuração do ambiente Struts em Eclipse</descricao>


12








</tutorial></tutoriais>

Repetimos, porém agora selecionamos um documento XSL

Escrevemos nosso XSL

<?xml versao="1.0" encoding="UTF-8" ?>

<xsl:stylesheet versao="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:output method="html"/>

<xsl:template match="/"><table border="1"><tr><td><b>Autor</b></td><td><b>Nome</b></td><td><b>Link</b></td><td><b>Descrição</b></td></tr><xsl:for-each select="//tutorial"><tr><td><xsl:value-of select="autor"/></td><td><xsl:value-of select="nome"/></td>

<td><xsl:value-of select="link"/></td><td><xsl:value-of select="descrição"/></td></tr>

</xsl:for-each></table>

</xsl:template></xsl:stylesheet>

Provar a transformação em NetBeans

Vamos usar as características de NetBeans para provar como ficaria....


13








Selecionamos, clicando o botão direito sobre o XML ou XSL

Selecionamos os arquivos


14








E vemos o resultado

Ativamos nosso diretório como uma WebApp


15








Introduzir o código Java

Agora, vamos escrever uma classe Java que seja capaz de fazer uma transformação e retorna-

la como uma cadeia.

Escrever a classe Java de prova

Neste caso, vamos utilizar uma interface para motores de transformação denominado JAXP(ver documentação em SUN)

Não temos que incluir nada extraordinário pela versão de Java que estamos usando.

import java.io.*;import javax.xml.transform.*;import javax.xml.transform.sax.*;import javax.xml.transform.stream.*;import org.xml.sax.*;

/**** @author Roberto Canales*/

public class transformador{void depura (String pCadeia){System.out.println("Mensagem: " + pCadeia);}

public static void main(String [] args) {transformador p = new transformador();

try{p.depura("Comecamos transformacao");p.depura(p.transformar());p.depura("Terminamos");


16


http://java.sun.com/webservices/jaxp/


http://java.sun.com/webservices/jaxp/






}catch(Exception e){p.depura("Erros em aplicacao");

e.printStackTrace();}}

public String transformar() throws Exception{String xmlOrigem = "C:\\exemplos\\jaxpjsp\\xmlbase.xml";String xslOrigem = "C:\\exemplos\\jaxpjsp\\xslbase.xsl";

Source xmlSource = new StreamSource(new File(xmlOrigem));Source xsltSource = new StreamSource(new File(xslOrigem));

StringWriter cadeiaSaida = new StringWriter();

Result bufferResultado = new StreamResult(cadeiaSaida);

TransformerFactory fabricaTrans = TransformerFactory.newInstance();Transformer transformador = fabricaTrans.newTransformer(xsltSource);

transformador.transform(xmlSource, bufferResultado);

return cadeiaSaida.toString();}}Se executamos este código, veremos na tela de saída:

Mensagem: Começamos transformaçãoMensagem: <table border="1"><br>

<tr>

<td><b>Autor</b></td><td><b>Nome</b></td><td><b>Link</b></td><td><b>Descrição</b></td>

</tr>

<tr>

<td>[email protected]</td><td>JSP 2.0</td><td>jspel</td><td>Novascaracteristicas de JSPs 2.0</td></tr>

<tr><td>[email protected]</td><td>Struts eEclipse</td><td>struts</td><td>Configuração do ambiente Structs em Eclipse</td></tr></table>Mensagem: Terminamos

Ou seja, funciona......

Criar o MVC

Agora, vamos criar um servlet, que gerará um XML e o passará (em MVC) a um JSP. Vamosintroduzir diretamente o XML em uma cadeia de caracteres.... dando por suposto que se


17








obteria de outro modo (por exemplo, usando um Banco de Dados XML)

Este JSP, pode executar o código da transformação com diferentes técnicas:

• Scriplet (Código Java no JSP)• Um Java Bean• Um TAG de usuário• Usando JSTL de JSP 2.0

Mostraremos como fazê-lo com um JSP com Scriplet... o resto dos métodos é muito simples.

O servlet

import java.io.*;import java.net.*;

import javax.servlet.*;import javax.servlet.http.*;

public class controlador extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException{try{String elXML = "<tutoriais><tutorial><autor>[email protected]</autor>

<nome>JSP 2.0</nome><link>jspel</link><descricao>Novas características de JSPs 2.0</descricao>

</tutorial><tutorial><autor>[email protected]</autor><nome>Struts e Eclipse</nome>

<link>struts</link><descricao>Configuração do ambiente Structs em Eclipse</descrição>

</tutorial></tutoriais>";

request.setAttribute ("xml",elXML);getServletConfig().getServletContext().getRequestDispatcher("/apresentacao.jsp").forward(request, response);}

catch (Exception ex){ex.printStackTrace ();

}}

}

O JSP

<%@page contentType="text/html" import="java.io.*,javax.xml.transform.*,javax.xml.transform.sax.*, javax.xml.transform.stream.*,org.xml.sax.*"%><html><head><title>JSP Page</title></head><body>

<center><H1>JSP, transformando XML com XSL</h1><br>

<%String xmlOrigem = (String)request.getAttribute("xml");String xslOrigem = "C:\\exemplos\\jaxpjsp\\xslbase.xsl";


18








Source xmlSource = new StreamSource(new StringBufferInputStream(xmlOrigem));Source xsltSource = new StreamSource(new File(xslOrigem));

StringWriter cadeiaSaiida = new StringWriter();

Result bufferResultado = new StreamResult(cadeiaSaida);

TransformerFactory fabricaTrans = TransformerFabrica.newInstance();Transformer transformador = fabricaTrans.newTransformer(xsltSource);

transformador.transform(xmlSource, bufferResultado);out.print(cadeiaSaida.toString());

%></center>

</body></html>

A saída é:

Bom, já sabem como fazer ..... e com Struts.... seria também assim de simples!

Artigo por Roberto Canales Mora

Manejo de arquivos com JSP

Os comentários escritos dentro do código, explicam passo a passo que coisa está sendoexecutada em cada momento.

• A função readFile, dado um nome de arquivo (com o "caminho" incluído. Ex.D:\files\prova.txt), devolve um objeto de tipo StringBuffer com o conteúdo do mesmo.

• O método saveFile , toma como primeiro parâmetro o nome do arquivo que se desejagerar ou modificar, o segundo parâmetro é o conteúdo que se deseja introduzir no talarquivo. Por fim, o terceiro parâmetro é uma variável do tipo boolean, que se recebe ovalor "true" , agrega a informação recebida no final do arquivo (si este arquivo existir).Se, em troca, recebe "false" como parâmetro, apaga o conteúdo atual do arquivo e o

substitui com o segundo parâmetro.


19








• Finalmente a terceira função serve para buscar um ou mais valores dentro de umarquivo de uma cadeia de texto e substitui-los por uma série de valores dados.

Por exemplo, poderia ser usado deste modo:String[] busca = {"NOME","SOBRENOME"};String[] substituo = {"FERNANDO","ARTURI"};FileManager fm = new FileManager();String resultado = fm.replaceValues("D:\myFiles\prova.txt", busca, substituo);

A seguir o código da classe:

package notas;

import java.io.File;import java.io.FileReader;import java.io.FileWriter;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.IOException;import java.io.FileNotFoundException;

/*** <p>Title: FileManager</p>** <p>Description: Manejo de arquivos de texto</p>** <p>Copyright: Copyright (c) 2006</p>** @author Fernando Arturi* @version 1.0*/

public class FileManager {

public void FileManager(){}

/*** O metodo readFile le um arquivo de texto e retorna seu conteudo em* formato de StringBuffer* @param filename String* @return StringBuffer*/

public StringBuffer readFile(String filename){StringBuffer sb = new StringBuffer();try{

/*** Aqui criamos um objeto File que representa o arquivo de texto que* queremos ler*/File file = new File(filename);

/*** Variavel temporaria que usaremos para ler cada uma das linhas do* arquivo de texto*/

String line = null;

/*** BufferReader - Eh o encarregado de ler o arquivo de texto.

* O construtor recebe como parametro um objeto FileReader, que

* a s vez recebe o objeto File criado precedentemente.


20








*/

BufferedReader br = new BufferedReader(new FileReader(file));

/*** Atraves deste ciclo o BufferReader le todo o arquivo, e vai acumulando (sb.append) em um StringBuffer*/while ((line = br.readLine()) != null) {sb.append(line);

}

/*** No final da leitura fechamos o objeto*/br.close();

} catch (FileNotFoundException fnfe){ /*** Se damos um nome de arquivo que nao existe o sistema gera automaticamente um erro.

*/System.out.println("Nao foi possivel encontrar o arquivo "+ filename);}catch (IOException ioe){ /**

* Foi produzido um erro durante a leitura do arquivo*/System.out.println("Foi produzido um erro durante a leitura do arquivo "+ filename);

}return sb;

}

/*** Este metodo permite, dada uma cadeia de caracteres determinada,* salvar a mesma como um arquivo de texto, ou agrega-la a um arquivo ja existente** @param filename String* @param dataToWrite String* @param append boolean*/public void saveFile(String filename, String dataToWrite, boolean append) {

try { /*** Criacao do objeto FileWriter dado um nome de arquivo determinado* O segundo parametro (append) contem um valor booleano que* indica se a informacao recebida deve ser agregada no final do

* arquivo ou, caso contrario, substituir a informacao ja* existente.*/

FileWriter fw = new FileWriter(filename, append);

/*** Escritura da informacao no arquivo*/fw.write(dataToWrite);

/*** fecha-se o arquivo*/

fw.close();} catch (IOException ioe) {

/*** Foi produzido um erro durante a leitura/escritura do arquivo*/

System.out.println("Foi produzido um erro durante a leitura do arquivo " + filename);


21








}}

/*** Esta funcao permite, dado um arquivo em particular, buscar dentro o mesmo* determinados valores e muda-los por uma serie de novos valores dados,* gerando um objeto de tipo String com o resultado** @param path String* @param valuesToSearch String[] Ejemplo {"NOME", "SOBRENOME"}* @param valuesToReplace String[] Ejemplo {"Fernando Augusto", "Arturi"}* @return String*/public String replaceValues (String path, String [] valuesToSearch, String [] valuesToReplace){String line;StringBuffer textComplete = new StringBuffer();String tempText = "";

/*** Leitura do arquivo de texto dado*/try {

BufferedReader br = new BufferedReader(new FileReader(path));while ((line = br.readLine()) != null){

textComplete.append(line);}br.close();

} catch (FileNotFoundException fnfe){ /*** Se damos um nome de arquivo que nao existe o sistema* gera automaticamente um erro.*/System.out.println("Nao foi possivel encontrar o arquivo "+ filename);

}

catch (IOException ioe) { /*** foi produzido um erro durante a leitura/escritura do arquivo*/System.out.println(

"Foi produzido um erro durante a leitura do arquivo " + filename);}

/*** Uma vez completada a fase de leitura do arquivo, passamos a* busca e substituicao dos valores dados.* Para isto geramos um ciclo que percorremos tantas vezes como valores* que tivermos que processar.*/for (int i=0; i<valuesToSearch.length; i++){

int position = textComplete.indexOf(valuesToSearch[i]);if (position>0 ){

tempText = textComplete.substring(0,position); /*** busca e substituicao da cadeia.*/

tempText = tempText + valuesToReplace[i] +textComplete.substring(position+valuesToSearch[i].length(),textComplete.length());

textComplete = new StringBuffer(tempText);}

}return tempText;

}


22








}



23





Documents

Manual de Jsp