UNIVERSIDAD NACIONAL PEDRO RUIZ GALLO

FACULTAD DE INGENIERÍA CIVIL, DE SISTEMAS Y ARQUITECTURA

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS

MATERIAL DIDÁCTICO
ASIGNATURA: TALLER DE PROGRAMACIÓN
MÓDULO: MANEJADOR DE ARCHIVOS TXT
Contenido
Introducción al módulo ................................................................................................................. 2
Competencia que se espera lograr ............................................................................................... 3
Integrantes .................................................................................................................................... 3
Parte I: Creación del proyecto ....................................................................................................... 4
Parte II: Menú Principal ................................................................................................................. 6
Parte III: Menú de búsqueda de archivo txt .................................................................................. 7
Parte IV : Creacion de la clase de lectura de archivos txt ............................................................. 9
Parte V: Creación de la clase de conexión .................................................................................. 12
Parte VI: Visualización de los datos leídos del .txt ...................................................................... 14
Parte VII : Método de inserción de información a la Base de Datos........................................... 16
Parte VIII: Formato de inserción de datos a la BD ...................................................................... 18
Parte IX: Clase java básica para la exportación de búsquedas en un .txt de la BD ..................... 19
Parte X: Clase en java que se utiliza para realizar la consulta a la BD......................................... 21
Parte XI: Clase en jsp que da el formato de muestra de datos antes de crear el txt .................. 22
Parte XII: Clase final que se utiliza para la creación y exportación del txt de consulta a la BD .. 26
Conclusiones ............................................................................................................................... 27
Recomendaciones ....................................................................................................................... 28
Referencias bibliográficas ........................................................................................................... 28

1
 Introducción al módulo

En esta guía se presenta una forma específica de como leer, guardar y

exportar archivos de extensión “.txt” en el lenguaje JSP, describiendo en
cada parte lo que se realiza en su codificación desde un inicio hasta su fin
y posterior ejecución.
El presente proyecto abarca una porción de lo que softwares de hoy se
han especializado sobre el almacenamiento de datos, la presente guía
adquirirá una forma básica de cómo funciona un proyecto de almacén de
información. En su utilización los usuarios tendrán una forma sencilla de
poder escoger y guardar el archivo seleccionado, además de hacer una
consulta y poder guardar el resultado en un “.txt”.
Esta guía será la herramienta inicial para un programador que desea
comprender el trabajo que se realiza con una base de datos cuando se
quiere guardar un archivo “.txt” y luego exportar la información que desea
extraer de la base.

2
Competencia que se espera lograr

 Que al término de esta guía el alumno haya adquirido los conocimientos

necesarios para el uso de los manejadores de archivos TXT (Lectura y Escritura)
en el entorno del lenguaje JSP y HTML.
 Además tendrá la capacidad de poder utilizar una base de datos diseñada en
phpMyAdmin.

Integrantes

 BAUTISTA CASTAÑEDA AARON MANUEL

 SALAZAR VILLANUEVA KEVIN WILLIAMS

3
Parte I: Creación del proyecto

Comenzamos por la creación de un proyecto web como se aprecia en la (imagen01), donde

realizaremos todo nuestro trabajo posterior.

(Imagen 01)

Llamaremos a nuestro proyecto con el nombre de “LecturaArchivotxt” (imagen 02)

(Imagen 02)

4
Elegimos el servidor que se de nuestro agrado y creamos nuestro proyecto web (Imagen 03)

(Imagen 03)

5
Parte II: Menú Principal
En la clase “index.jsp” que se crea por defecto crearemos la interfaz principal la cual tendrá las
opciones de leer los archivos txt y de poder crearlos con los datos de la base

(Imagen 04)

Ejecutamos el programa para poder apreciar el formulario de opciones (Imagen 04) que
hemos realizado en “index.jsp”

(Imagen 05)

6
Parte III: Menú de búsqueda de archivo txt

Creamos un JSP llamado “Buscartxt.jsp” donde crearemos la interfaz de búsqueda.

(Imagen 06)

7
Comenzamos con la creación de la interfaz de búsqueda, como se explica

Etiqueta de tipo “file” que

nos permite darle acción
de búsqueda de archivo a
nuestra caja de texto

Creación de un botón que será el

encargado de accionar nuestras
conexiones de los siguientes JSP

(Imagen 07)

Ejecutamos el programa para poder apreciar el formulario de búsqueda (Imagen 04) que
hemos realizado en “index.jsp”

(Imagen 08)

8
Parte IV : Creacion de la clase de lectura de archivos txt
Creamos un paquete llamado “clases” donde contendrá las clases java destinadas a la lectura
del archivo txt

(Imagen 09)

Dentro del paquete “clases” (Imagen 06) creamos la clase Leertxt que será la que contenga los
métodos que leerán nuestro archivo txt

(Imagen 10)

9
En la clase “Leertxt” creamos el método “Leer” que será static con el fin de poderlo utilizar sin
crear un objeto de la clase archivo y devolverá como parámetro una cadena.

El método “Leer” necesitara como parámetro la ruta o URL del archivo txt a analizar. En
síntesis lo que hará este método será analizar el archivo txt y almacenar su contenido en una
variable de tipo String que posterior mente devolverá.
Es necesario capturar los errores
que pueden surgir al buscar el
archivo

Creamos las variables de clases que

necesitamos para analizar el archivo txt y
las variables de tipo String que servirán
para almacenar el contenido obtenido

Instanciamos las variables de clases

para crear los objetos respectivos y
les asignamos la ruta y el archivo

Variable encargada de almacenar

todo el contenido del archivo txt

Bucle while encargado de

almacenar todos los datos que
tenga el txt en la variable
contenido

Retorna la variable contenido

(Imagen 11)

Después de elaborar el método “Leer” (Imagen 08) creamos en la clase Leertxt una lista static
llamada “datos” que almacenara matrices de tipo String y creamos el método “get” de dicha
lista.

Creación de la lista estática

Creación del método “get” de la

lista datos

(Imagen 12)

10
Continuando en la clase “Leertxt” Creamos el metodo “AnalizarContenido” que sera static
,este metodo necesitara que le pasemos como parametro el contenido que se octenga del
metodo “Leer”(Imagen 08) para que pueda dividir y almacenar de forma mas odenada los
datos del txt

El metodo “AnalizarContenido” nos devolvera como parametro una lista en la cual almaceno
los datos de manera ordenada del txt.Tengase en cuenta que los datos del txt tienen que estar
separado por algun referente ya sea por un punto un guion etc.

Creamos las variables de los separadores de objeto y

de atributo dependiendo de cómo este escrito el txt,
también creamos la lista y una matriz de String que
será donde almacenaremos los datos obtenidos

El código “contenido.split(separadorObjeto)” va segmentado

el contenido del texto que tenga el txt, guiándose de donde
se encuentra los signos de las variables creadas “/” , “-”

(Imagen 13)

Podemos Observar la estructura del archivo “TablaEstudiante.txt” que es el que analizaremos,

fijémonos en la forma de cómo está escrito dividido las palabras con una serie de conectores
que serán necesarios para poder separar los atributos al momento de leerlo

(Imagen 14)

11
Parte V: Creación de la clase de conexión

Creamos la clase “Conexión.java” en el paquete “clases” la cual será con la que nos
conectemos a nuestra base de datos.

(Imagen 15)

12
En la clase “Conexión.java” creamos el método conexión que será de tipo static y devolverá
como parámetro un elemento de tipo Connection el cual nos servirá para poder manejar la
conexión con la base de datos

Creamos el elemento de tipo

Connection y lo llamamos con
y le asignamos un valor nulo

Creamos todos los elementos

necesarios para poder hacer la
conexión con la base

Retorna el valor de Connection

con la conexión establecida

(Imagen 16)

13
Parte VI: Visualización de los datos leídos del .txt
Creamos un nuevo JSP llamado “Tabla.jsp” donde se mostraran todos los datos obtenidos del
txt

(Imagen 17)

En el JSP “Tabla.jsp” comenzamos creando las variables que necesitaremos para la captura de
la Ruta del archivo txt que se dio en “index.jsp” y para poder almacenar los datos que nos
devolverán los métodos de la clase “Archivo

Creación de las variables necesarias para la

captura y almacenamiento de datos

(Imagen 18)

14
Continuando en “Tabla.jsp” capturamos los datos que nos devuelven los métodos de “Archivo”
y capturamos la ruta que se obtuvo en “index.jsp”

Capturamos la ruta almacenada

en “archivo” de “”index.jsp”

Obtenemos el contenido del txt con el

método “leer”

Almacenamos los datos ordenados

que nos devuelve el método
“AnalizarContenido”en la lista
“datos”
(Imagen 19)

Luego de obtener todos los datos necesarios creamos la tabla donde mostraremos dichos
datos de una manera ordenada

Colocamos los nombres de

los tipos de los atributos
que contiene nuestro txt

En esta parte llenamos la tabla

con los datos que hemos
obtenido anteriormente

Creamos dos botones de los

cuales tendrán la función de
regresar al “index.jsp” y
guardar los datos en la base

(Imagen 20)

15
Parte VII : Método de inserción de información a la Base de Datos

Creamos la el jsp “InsertarDatostxt.jsp” dentro del paquete “clases” donde crearemos el

código necesario para la inserción de los datos a la base.

(Imagen 21)

16
Comenzamos utilizando la conexión con la base que se realizó en la clase “Conexión.java”
luego creamos las consultas necesarias para poder guardar los datos que leímos del txt en la
base de datos, y creamos un captador de errores que nos dirá si el guardado de los datos se
realizó de forma exitosa.

Asignamos la conexión al elemento

“sql” de tipo Statement

Creamos dos bucles for que son los

encargados de leer los datos
obtenidos del txt

Con los datos que estamos leyendo

creamos las consultas necesarias
para poder guardar los datos

Asignamos la consulta con la

conexión que hicimos arriba para
que se agreguen los datos a la base

Creamos un captador de errores para

verificar si el guardado de los datos se
hizo de forma exitosa

(Imagen 22)

17
Parte VIII: Formato de inserción de datos a la BD

Creamos la clase “Separadores.java” dentro del paquete “clases”

(Imagen 23)

Dentro de la clase “Separadores.java” creamos los objetos que servirán para poder escribir el
txt de una manera ordenada, permitiéndonos poder separar los objetos y los atributos entre sí
para un mayor orden y entendimiento del usuario

Creamos los separadores de tipo String

y static, con la finalidad de que nos
permitan escribir nuestro txt de
manera ordenada

(Imagen 24)

18
Parte IX: Clase java básica para la exportación de búsquedas en un
.txt de la BD
Creamos la clase “Exportartxt.java” dentro del paquete “clases” que será la encargada de crear
el txt.

(Imagen 25)

Dentro de la clase “Exportartxt” creamos primeramente una variable String staic llamada
“datos” que será la que almacene todos los datos que va a contener nuestro txt a crear, luego
creamos el método formato que será static que será la encargada de ordenar de forma
correcta los datos a almacenar.

Exportartxt {
Creamos la variable String de tipo
static llamada datos

Creamos el método “formato” de tipo

static que ordenara los datos del txt

(Imagen 26)

19
Luego seguidamente creamos el método “Escribir” de tipo static que será el encargado de crear
el txt y de asignar el separador correcto a cada uno de los elementos a guardar, nos pedirá el
método Escribir como parámetros la ruta donde guardaremos el archivo la extensión y el
contenido del mismo.

Creamos los objetos necesarios

para la creación del archivo

Instanciamos los objetos creados

dándole sus parámetros
correspodientes a cada uno

(Imagen 27)

20
Parte X: Clase en java que se utiliza para realizar la consulta a la
BD
Creamos la Clase “Filtrar” dentro del paquete “clases” que será la encargada de filtrar los datos
antes de crear el archivo.

(Imagen 28)

Dentro de la clase “Filtrar” creamos el método “filtrar” que será static el cual se encargara de
crear la consulta que filtrara los datos dependiendo de la elección del usuario.

Creamos la variable String “fil”

static que se encargara de
almacenar la consulta de filtro

Creamos el método “filtrar” que

será el encargado de crear la
consulta de filtro con la elección
del usuario

(Imagen 29)

21
Parte XI: Clase en jsp que da el formato de muestra de datos
antes de crear el txt
Creamos un nuevo JSP de nombre “TablaFiltro.jsp”, esta clase se utilizara para realizar las
consultas a la base de datos que hemos obtenido.

(Imagen 30)

22
Iniciamos planteando el esquema de los botones y las cajas de texto que necesitamos para el
filtro y guardado de la consulta hacia la base de datos.

Creamos el esquema de los

botones Crear txt, Regresar y
una caja de texto donde ira
el nombre del txt de la
consulta a la base de datos.

Se crea el botón Filtrar y una caja de

texto donde se escribirá la palabra
que se buscara en la base datos

Obtiene la palabra de la caja de

texto que se quiere buscar en la BD,
(Imagen 31) y se le envía al método filtrar de la
clase Filtrar

Al correr la aplicación se quedaría de la siguiente forma:

(Imagen 32)

23
Planteamos la conexión hacia la base de datos.

Se escribe el método para conectar a

la base de datos y se le envía lo que ha
procesado el método filtrar, además
se inicializa la variable “datos” de la
clase “Importartxt”

(Imagen 33)

Seguimos con el planteo de como mostrar los datos extraídos de la búsqueda, además
empezamos a enviar el formato de cómo se guardara en el txt de resultado de búsqueda.

Se crea el formato de las columnas de la tabla

Se utiliza el método
formato de la clase
Importartxt, enviando
los separadores y el
valor del objeto( de
fila en fila)

Donde se mostrara el
resultado de fila en fila
de la búsqueda

Se insertara un separador especial

que indica el final del objeto
persona

(Imagen 34)

24
Al hacer una consulta, en este caso consultaremos todos los elementos de una basa de datos se
mostraran así:

(Imagen 35)

25
Parte XII: Clase final que se utiliza para la creación y exportación
del txt de consulta a la BD

Creamos el jsp “Creartxt” dentro del paquete “clases” que será el encargado de llamar a los
métodos antes creados para crear el archivo y decirnos si se creó correctamente.

(Imagen 36)

26
En el jsp “Creartxt” obtenemos el nombre del archivo que escribió el usuario en la clase
“TablaFiltro” para poder asignarle el nombre al archivo txt luego llamamos al método escribir
de la clase “Importartxt” que se encargar de crear el Archivo

Creamos la variable String

“nombre” donde obtendremos el
nombre que escribió el usuario
para el archivo

Con el método
request.getParameter (“nomb”);
obtenemos el nombre que
escribió el usuario

Por ultimo llamamos al método

escribir que será el encargado de
crear el archivo

(Imagen 37)

Conclusiones
o La guía presente se ha elaborado con la mejor explicación posible para el alumno que
desea ponerla en práctica, utilizando herramientas relativamente sencillas para su
elaboración (Netbeans, phpMyAdmin, leguaje JSP).
La guía tiene la intensión de que el estudiante no rechace el aprender a programar en
lenguaje JSP y además a entender cómo utilizar herramientas que serán útiles en
diferentes trabajos de su vida estudiantil.

27
Recomendaciones
 Tener una carpeta creada en el disco “D” llamada “archivostxt”.
 Crear una base de datos antes de crear el proyecto, además una tabla con sus
atributos definidos de dicha tabla, se recomienda “phpMyAdmin” como base de datos.

Referencias bibliográficas

Gómez Fuentes , M., & Cervantes , O. J. (2017). Introduccion a la Programación web con java:
JSP y Servlets, JavaServer Faces . Ciudad de Mexico: Consejo Editorial de la UAM
Unidad Cuajimalpa.

28