Algoritmos y Algo Más

Para todos los amantes de la programación.
Skip to content
  • C/C++
  • Java
  • .NET
  • Pseint
  • Youtube

Etiqueta: jsp

Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 3 – 4

Posted on 4 noviembre, 20202 enero, 2022 by ayam

Esta publicación es la continuación de la parte 2 la cual puedes encontrarla aquí: https://algoritmosyalgomas.com/login-java-web-usuario-password-conexion-base-datos-mysql-n-capas-parte2/

Configuración de Eclipse para ver la aplicación en el navegador

Hasta el momento, la aplicación se nos está mostrando dentro de la interfaz del IDE Eclipse. Sin embargo, no es muy cómodo probar la aplicación de esta manera, por lo que para trabajar con mayor comodidad vamos a configurar Eclipse para que de ahora en adelante la aplicación se nos muestre en un navegador externo: Chrome, Firefox, Opera, etc.  En mi caso elegiré Chrome. Para ello hacemos clic en el menú Windows > Web Browser > Chrome

Para ver que la configuración se aplicó correctamente vamos a volver a ejecutar la aplicación web:  Hacemos clic derecho en el archivo index.jsp > Run As > Run on Server. A partir de ahora se nos abrirá el navegador seleccionado (Chrome)

 

Si nos fijamos en la url del navegador, tenemos lo siguiente:

http://localhost:8080/JavaWeb/index.jsp

Allí podemos observar que luego de localhost aparece el número 8080. Este es el puerto donde se está ejecutando el contenedor de servlets Tomcat. Este número de puerto se puede cambiar dependiendo del caso (en algunas situaciones va a ser necesario cambiar el número de puerto debido a conflictos con otros servicios o procesos que ya se estén ejecutando bajo el mismo puerto).

Ahora, ¿qué pasaría si en la url pegamos la siguiente dirección: http://localhost:8080/JavaWeb/principal.jsp ?

Lo que sucede es que se nos muestra la página que contiene el mensaje de Bienvenido salteándonos así el login del principio. 

En una aplicación “real” esto no debería suceder. A los visitantes de la aplicación solamente se les debería ser permitido visualizar a página principal.jsp (o cualquier otra página interna de la aplicación) luego de haber iniciado sesión con un usuario y clave en la página del login. Debería existir un mecanismo que nos permita decirle a la aplicación web que tenemos permisos para poder visualizar la página principal.jsp (o cualquier otra página interna del sitio web). Este tipo de mecanismo existe y se denomina Sesión web.

Sesiones web en Java

La sesión web es un mecanismo que permite identificar a un usuario que se encuentra interactuando con un sitio web.

Para implementar sesiones web en java se utiliza un objeto sesión. El objeto sesión debe ser creado al momento que el usuario termina el proceso de inicio de sesión (cuando se logea), y se debe destruir al instante en que el usuario se cierra la sesión (cuando se deslogea) del sitio web.

Vamos a poner en práctica el uso de sesiones en nuestra aplicación web para hacerla más segura y cercana a una aplicación web real. Para ello procederemos a modificar algunos archivos del código fuente:

index.jsp

En este archivo hemos añadido un nuevo elemento html en la línea 11. Se trata del elemento html input con los siguientes atributos:

  • name=”tipo”
  • value=”iniciarSesion”

El texto “iniciarSesion”, el cual es el valor asignado al input hidden, será enviado al servlet Usuario de manera oculta al momento de realizar el logeo y será útil para que desde el servlet podamos identificar de forma más precisa el tipo de operación que se está realizando, en este caso, un inicio de sesión. 

En varias situaciones los inputs hidden son muy útiles para mandar valores al servidor y para que desde este, mediante algún servlet, pueda realizar diversas operaciones, validaciones, etc.

ServletUsuario.java

También vamos a modificar el servlet ServletUsuario para que reciba el parámetro adicional llamado “tipo” (el que fue enviado desde la página index.jsp) con el cual podremos identificar el tipo de acción u operación que queremos realizar. 

Para esta ocasión, vamos a definir en el servlet dos posibles acciones: 

  1. Procesar el login o inicio de sesión, el cual ya habíamos implementado en las entradas anteriores, pero esta vez vamos a añadir la creación del objeto sesión dentro del método iniciarSesión.
  2. Procesar el logout o cierre de sesión. Esto lo haremos dentro del método cerrarSesion.

En la línea 21 se recupera el valor del parámetro tipo que llega al Servlet junto con la petición dentro del objeto request. En la línea 23 se evalúa el valor recibido y en base a eso se invoca al método iniciarSesion o cerrarSesion en las líneas 24 y 26 respectivamente.

Procesamiento del inicio de sesión: En la línea 41 se declara una variable de tipo HttpSession llamada sesion. A esta se le asigna el resultado de la llamada al método getSession en el objeto request (HttpServletRequest). 

El funcionamiento del método getSession es el siguiente: retorna la sesión actual si existe; en caso contrario, crea una nueva. Para nuestro caso, debido a que en ningún momento hemos creado una sesión, se creará una nueva.

En la línea 42 se está seteando dentro del objeto session mediante el método setAttribute, el objeto usuario con la información del usuario que se está logeando. El nombre asignado al atributo es “usuario”, y será con este nombre que lo vamos a leer/recuperar desde el jsp correspondiente como se explica más adelante.

Algo importante que se debe aclarar es que todos los servlets y jsps accesados por un mismo cliente (navegador) compartirán la misma sesión (el mismo objeto sesión). 

Procesamiento del cierre de sesión: En la línea 48 se obtendrá una referencia a la sesión para después invalidarla o destruirla en la línea 49 con el método invalidate. En la línea 50 seteamos un atributo “mensaje” con el mensaje “Iniciar sesión”. En la línea 51 hacemos una redirección de la petición hacia el archivo index.jsp y reenviamos los objetos request y response. El mensaje seteado en la línea 50 lo vamos a recuperar en el archivo index.jsp luego de ejecutarse la redirección.

validar.jsp

Vamos a crear una nueva página JSP llamada validar.jsp dentro de la carpeta WebContent (recuerda que si no tienes la carpeta WebContent, en su lugar tendrás la carpeta webapp dentro de src/main/webapp.), la cual tendrá como objetivo evitar que la página principal.jsp sea visible cuando no haya existido un proceso previo de logeo, es decir, no exista un objeto usuario seteado en la sesión actual (en un objeto sesión).

Para esto, en la línea 2 procedemos a hacer referencia a un objeto session el cual, ya existe en cualquier JSP por lo cual se puede hacer referencia a este sin problemas (es un objeto implícito). Con el método getAttribute y el nombre “usuario” se intenta traer, en caso exista, el objeto usuario. En caso de que no exista, el método traerá null con lo cual podemos concluir que el usuario actual no se logeado en el sitio web, por lo cual se redireccionará hacia la página index.jsp para que realice su logeo respectivo.

 

encabezado.jsp

Este jsp nos permitirá crear una página reutilizable dentro de otras. Es útil para incluir barras de navegación, links, etc que normalmente se repiten en todas las páginas de una aplicación web.

Para empezar, únicamente vamos a incluir dentro de esta página un link que permita cerrar la sesión.

Veamos que en la línea 10, en el atributo href del link tenemos como valor: “usuario?cerrarSesion”. Aquí podemos identificar dos cosas:

  • usuario: es el nombre del Servlet a invocar luego de hacer clic en el link.
  • tipo=cerrarSesion: vendría a ser el nombre de un parámetro: “tipo” y su valor “cerrarSesion”. Este parámetro es enviado al servlet “usuario” para que éste sepa el tipo de operación a realizar.

principal.jsp

La página principal.jsp como ya habíamos visto es la primera página a la que nos redirecciona el sistema una vez que nos hayamos logeado. 

En la primera línea de esta página estamos usando la etiqueta jsp de inclusión dinámica jsp:include para incluir el contenido de la página validar.jsp con el objetivo de que primero se ejecute toda su lógica, el cual consiste en validar de que exista un objeto usuario en la sesión.

Si tuviéramos más páginas internas en nuestra aplicación, es decir, páginas que solo deben ser visibles para usuarios logeados, entonces deberíamos reusar e incluir la página validar.jsp de la misma manera como lo estamos haciendo ahora.

Además de incluir la página validar.jsp también incluimos en la línea 11 el contenido de la página encabezado.jsp para reutilizar su contenido.

Por último, en la línea 12 estamos mostrando el nombre del usuario que se está logeando. Este nombre lo obtenemos del objeto usuario que está almacenado en el objeto sesión. Podríamos haberlo hecho con scriptlets pero en esta ocasión estamos usando el lenguaje de expresiones EL: ${sessionScope.usuario.nombre}

 

Prueba de la aplicación web

Para probar la aplicación volvemos a hacer clic derecho sobre la aplicación JavaWeb y elegimos Run As / Run on server

Vamos a intentar ingresar directamente a la página principal.jsp sin logearnos previamente:

http://localhost:8081/JavaWeb/principal.jsp

Podrás notar que que inmediatamente el sitio web te redireccionará hacia el login y te mostrará el mensaje de error que habíamos definido en la página validar.jsp. Este es debido a que no existe ninguna sesión en memoria ya que no nos hemos logeado.

Ahora procedemos a iniciar sesión con el usuario “jose” y password “123”

Podrás ver que ahora sí el sistema te muestra la página principal.jsp.

Internamente lo que ha ocurrido es lo siguiente:

  • El servlet que procesa la petición de login crea un objeto sesión donde guarda el objeto usuario con su información e inmeditamente redirecciona hacia la página principal.jsp.
  • Dentro de la página principal.jsp: primero carga el contenido de la página validar.jsp que como ya sabemos, valida que exista el objeto usuario dentro de la sesión (en caso negativo nos redireccionaría hacia el login). Luego carga el resto del contenido de la página.

Para cerrar sesión solo damos clic al link “Cerrar sesión” de la página, con la cual haremos una petición hacia el Servlet el cual ejecutará el método correspondiente encargado de destruir la sesión y volveremos a ser redirigidos hacia la página de login.

A partir de ahora, ya no podremos ingresar a la página principal.jsp a menos que nos hayamos logeado.

Si te fue de ayuda esta entrada, déjame en los comentarios para seguir subiendo contenido así.

Próximamente vamos a terminar el aplicativo de login añadiendo hojas de estilos, lógica de validación con javascript y utilizando etiquetas de la librería JSTL para aplicar validaciones en la página jsp del login.

La continuación está aquí: https://algoritmosyalgomas.com/login-java-web-usuario-password-conexion-base-datos-mysql-n-capas-parte4/

La lista completa de entradas relacionadas a esta son las siguientes:

Parte 1: Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 1 – 4

Parte 2: Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 2 – 4

Parte 3: Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 3 – 4

Parte 4: Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 4 – 4

Base de datos, Java web eclipse, java, java web, jsp, login, mysql, servlet, tomcat
3

Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 2 – 4

Posted on 25 octubre, 202019 abril, 2022 by ayam

Esta publicación es la continuación de la parte 1, la cual puedes encontrarla en el siguiente enlace: https://algoritmosyalgomas.com/login-java-web-usuario-password-conexion-base-datos-mysql-n-capas/

Como ya te había mencionado en la entrada anterior, nuestro objetivo será tener una aplicación java web estructurada en varias capas. Para ello, vamos a crear la siguiente estructura de paquetes y carpetas en nuestro proyecto web “JavaWeb”. Cada paquete representará una capa (aunque no siempre tiene que ser así).

 

Hasta el post anterior, en nuestro proyecto teníamos creados los paquetes conexion y test. Para este post deberán crear los paquetes restantes: controlador, entidad y modelo.

En total tendremos los siguientes paquetes (se añade una breve descripción del uso que se le dará):

  • conexion: Paquete que contiene la clase reutilizable Conexion.java la cual tiene la lógica de conexión entre la aplicación Java y la base de datos MySQL.
  • controlador: Paquete que contendrá todos los Servlets, los cuales son clases Java que permiten recibir y responder peticiones HTTP.
  • entidad: Paquete que contendrá todas las clases que representarán a cada tabla de la base de datos. 
  • modelo: Paquete que contendrá todas las clases de tipo model, las cuales se encargarán de interactuar con las tablas de la base de datos.
  • test: Es un paquete donde tendremos algunas clases de prueba, será borrada al final.

Dentro de la carpeta WebContent debemos crear las siguientes carpetas:

  • css: Más adelante Incluiremos algunos archivos de estilos css.
  • js: Posteriormente Incluiremos algunos archivos javascript para realizar ciertas validaciones y darle más interactividad a las páginas en caso se requiera.
  • img: En esta carpeta guardaremos algunas imágenes.

Recuerda que si no tienes la carpeta WebContent, en su lugar tendrás la estructura de carpetas src/main/webapp.

Creación de la Entidad Usuario

Creamos la clase Usuario.java dentro del paquete entidad con el código que se muestra a continuación.

Nota que los atributos de la clase Usuario.java están coincidiendo con las columnas de la tabla usuario de la base de datos. Esto lo hacemos así porque allí es donde se van a recuperar los datos de la tabla usuario.

A la columna idUsuario (cuyo tipo de dato es INT) de la tabla usuario le corresponde el atributo idUsuario de tipo int en la clase Usuario.

A la columna nombre (cuyo tipo de dato es VARCHAR) de la tabla usuario le corresponde el atributo nombre de tipo String en la clase Usuario.

A la columna clave (cuyo tipo de dato es VARCHAR) de la tabla usuario le corresponde el atributo clave de tipo String en la clase Usuario.

A esto que estamos haciendo se le suele denominar mapeo objecto relacional. Aquí estamos realizando un mapeo manual, sin embargo, ya existen herramientas que realizan este mapeo de forma automática tales como Hibernate, MyBatis, etc. A dichas herramientas se les denomina ORM’s.

Si la aplicación que estamos desarrollando tiene más tablas, lo más común es crear una clase por cada tabla y realizar el mapeo entre columnas y atributos, teniendo en cuenta de manejar un tipo de datos similar.

El tipo INT en SQL se corresponde con el tipo int o Integer en Java.

El tipo VARCHAR, CHAR, etc en SQL se corresponde con String en Java.

Creación del Modelo Usuario

Se creará la clase ModeloUsuario.java dentro del paquete modelo:

Las clases de tipo Model, en general, son las que interactúan con la base de datos ya sea recuperando o guardando datos. Para nuestro proyecto web, la clase ModeloUsuario es una clase que engloba la lógica para interactuar con la tabla usuario de la base de datos. Por lo general, se creará una clase Model por cada tabla de la base de datos. 

Dentro de la clase ModeloUsuario hemos definido un método llamado iniciarSesion, el cual espera recibir dos parámetros de tipo String: nombre y clave, y cuyo tipo de retorno es un objeto de la clase Usuario.

En la línea 18 se observa cómo se reutiliza la clase Conexion (del paquete conexion) para obtener la referencia de la conexión [a la base de datos] mediante la invocación del método estático getConexion. Luego, se almacena dicha referencia en una variable cn de tipo Connection. 

En la línea 19 se define el String “SELECT U.idUsuario, U.nombre, U.clave FROM usuario U WHERE U.nombre = ? AND U.clave = ?“, la cual es una sentencia SQL de forma parametrizada que permite consultar en la tabla usuario por aquellos registros cuyas columnas nombre y clave coincidan con los valores que se establezcan luego (actualmente los valores tienen signos de interrogación).

Entre las líneas 20 y 22 se hace uso del objeto pstm PreparedStatement para preparar una sentencia parametrizada y se setean los parámetros nombre y clave que vienen como argumento del método iniciarSesion. En la línea 23 se ejecuta el método executeQuery el cual ejecutará la sentencia SQL ya preparada y seteada, el resultado obtenido se asigna a la variable rs de tipo ResultSet.

En la línea 25 a 30 se usa un while para evaluar la variable rs en busca de posibles resultados mediante el método next. En caso haya al menos un resultado, el bucle while se ejecutará una vez y se encapsularán los datos obtenidos de la tabla usuario de las columnas idUsuario, nombre y clave en los correspondientes atributos idUsuario, nombre y clave de un objeto Usuario.

En la línea 52 se retorna la variable usuario, el cual puede ser nulo en caso de que la sentencia SQL no haya obtenido resultados o un objeto Usuario con datos seteados en caso de que la consulta haya sido exitosa.

Entre las 32 a 49 se manejan posibles excepciones mediante el bloque catch y se liberan los recursos dentro del bloque finally (se cierran conexiones abiertas por los objetos rs (ResultSet), pstm (PreparedStatement) y cn (Connection). Se recomienda que se cierren dichas conexiones en el orden inverso en el que fueron abiertas).

Creación del Servlet Usuario

Un Servlet es un componente Java que se ejecuta en un servidor y permite atender peticiones que provienen desde un navegador (cliente), procesarlas y devolver respuestas (generalmente páginas web). 

En nuestra aplicación, el servlet Usuario atenderá dos tipos de peticiones que le hagamos:

– iniciar sesión: En esta petición o solicitud o request, le mandaremos como parámetros dos datos: nombre de usuario y clave. El servlet los procesará, consultará a la base de datos reutilizando la clase ModeloUsuario y si existe o no el usuario en la base de datos, armará una respuesta adecuada.

– cerrar sesión: En esta petición, no le mandaremos parámetros de entrada y solo se indicará que elimine la sesión del usuario actual.

Vamos a crear la clase “ServletUsuario”. Para ellos hacemos clic derecho en el paquete controlador, elegimos “New” y luego “Other…”

Nos aparecerá la ventana “New” en la cual buscaremos la opción “Web” y dentro hacemos clic en “Servlet”. Luego damos clic en el botón “Next”.

En la siguiente ventana debemos elegir un nombre para el Servlet. Pondremos para esta ocasión ServletUsuario, posteriormente hacemos clic en Next.

En esta ventana vamos a seleccionar el elemento “/ServletUsuario” de la lista de URL mappings y vamos a dar clic en el botón “Edit…”

 

En la nueva ventana que se abrirá, le asignaremos el siguiente nombre: “/usuario”. Este nombre se usará para hacer referencia al Servlet desde las páginas JSP. Más adelante veremos el uso de esta característica. Luego damos clic en el botón “OK”

Damos clic en Next.

En la ventana actual nos aseguraremos de desmarcar el checkbox “Constructors from superclass“. Y también desmarcaremos “doPost” y “doGet“, y dejaremos marcado el checkbox “service“, luego damos clic en Finish.

Estos pasos lo estamos haciendo de esta manera para construir un Servlet que sea lo más simple posible.

El IDE se encargará de crearnos el Servlet con las características que seleccionamos durante los pasos previos.

Para programar con mayor comodidad podemos eliminar los comentarios autogenereados. Al final tendremos el código como se muestra a continuación.

Dentro de esta clase ServletUsuario podremos codificar lo siguiente:

El Servlet será la clase Java encargada de recibir las peticiones o solicitudes realizadas por el cliente hacia el servidor y también de enviar las respuestas siguiendo alguna lógica. Toda la información que el cliente mande al servidor en la petición lo hará a través del objeto request (HttpServletRequest). El servlet usará dicho objeto para recuperar la data enviada por el cliente en cada solicitud. El Servlet también recibe un objeto response (clase HttpServletResponse) el cual contiene la respuesta del servlet ante la petición, es decir, toda la información de salida.

Para el servlet ServletUsuario, el objeto request de la petición que viene desde el cliente, trae consigo dos parámetros: nombre y clave. En las líneas 20 y 21 se muestra cómo acceder al objeto request y recuperar los parámetros nombre y clave para luego asignarlos a las variables String del mismo nombre.

En la línea 23 se instancia la clase ModeloUsuario y en la línea 24 se utiliza el modelo creado para poder ejecutar el método iniciarSesion pasándole como argumentos el nombre y clave recibidos desde la petición. El método iniciarSesion retornará un objeto Usuario y lo almacenará en la variable usuario en caso de que exista un registro usuario en la tabla usuario para el usuario/clave dados, o en caso contrario null.

En la línea 26 se examina el valor de la variable usuario declarada en la línea 24. Tendremos dos posibilidades:

  • Si el valor de la variable usuario es null:
    • Línea 27: Utilizamos el objeto request para setear un atributo llamado mensaje con el string “Error nombre de usuario y/o clave” con la finalidad de recuperarlo y mostrarlo más adelante en caso de que el inicio de sesión falle.
    • Línea 28: Redirigimos la petición hacia una página index.jsp (que será creada más adelante) y le volveremos a pasar los objetos request y response con toda la información de entrada y salida que se tiene hasta el momento.
  • Si el valor de la variable usuario no es null, es decir, es un objeto:
    • Línea 30: Se utiliza el objeto response para responder con una redirección hacia la página principal.jsp. Esto quiere decir, que se realizó correctamente el inicio de sesión.
Por ahora mantendremos el servlet de una forma sencilla y simple. Tampoco estamos haciendo uso de sesiones, sino hasta más adelante.

Creación de las páginas JSP: index.jsp y principal.jsp

Dentro de la carpeta WebContent vamos a crear los archivos JSP index.jsp y principal.jsp. Para ello hacemos clic derecho en la carpeta “WebContent“, elegimos “New” y luego “JSP File”.

OBS: Recordar que si su proyecto no tiene la carpeta “WebContent“, debería tener “src/main/webapp“.

index.jsp

La página index.jsp es la página en donde estará el formulario de inicio de sesión.

Dentro del cuerpo, es decir, entre las etiquetas <body> definimos un formulario mediante la etiqueta <form>, allí definimos los atributos:

  • action: usuario, aquí indicamos quién será el encargado de recibir los datos del formulario y de procesar la petición. Por lo tanto, debemos hacer referencia al servlet ServletUsuario que creamos previamente.
  • method: post, es el tipo de método de la petición HTTP

Luego básicamente definimos una tabla con 3 filas mediante el uso de las etiquetas table, tr y td para las columnas. Definimos dos cuadros de texto, cuyos atributos name son: “nombre” y “clave“, mediante la etiqueta input.

Un botón de tipo submit para enviar los datos ingresados en el formulario de inicio de sesión hacia el servidor.

Hay que tener presente que los atributos name de los input text del formulario del archivo index.jsp deben coincidir con los nombres de los parámetros desde donde se recupera la información en el servlet ServletUsuario tal y como se observa en la siguiente imagen:

principal.jsp

La página principal.jsp será la primera página a la que nos redireccione el sistema una vez que nos hayamos logeado correctamente.

Prueba de la aplicación web

Vamos a ejecutar la aplicación web para verla en funcionamiento. Nos situamos encima del archivo index.jsp y le damos clic derecho. En el menú contextual elegimos la opción Run As y luego damos clic en Run on Server.

Aparecerá una ventana llamada Run On Server, en esta debemos asegurarnos de que se encuentre seleccionada Tomcat v8.5.

Luego damos clic en el botón Finish.

En el editor de código se abrirá una nueva pestaña con un navegador interno en el cual se muestra el formulario html de la página index.jsp.

Vamos a probar la aplicación ingresando las credenciales incorrectas, por ejemplo:

  • usuario: jose
  • clave: xyz

Luego damos clic en el botón “Iniciar sesión”

Se recargará la página y se nos mostrará el mensaje de error que definimos en el servlet: “Error nombre de usuario y/o clave“.

Ahora vamos a probar ingresando correctamente el nombre de usuario y la clave:

  • usuario: jose
  • clave: 123

Damos clic en el botón “Iniciar sesión”.

Ahora sí podremos notar que la aplicación nos redirecciona hacia la página correcta, es decir, hacia principal.jsp

Hasta aquí termina la parte 2 de esta entrada. Para ver la continuación puedes entrar a este enlace:

Login en Java web y MySQL N capas (JSP’s y Servlets) Parte 3

La lista completa de entradas relacionadas a esta son las siguientes:

Parte 1: Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 1 – 4

Parte 2: Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 2 – 4

Parte 3: Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 3 – 4

Parte 4: Login en Java web y MySQL – N capas (JSP’s y Servlets) Parte 4 – 4

Base de datos, Java web eclipse, java, java web, jsp, login, mysql, servlet, tomcat
3
  • 1
  • 2
  • »

Contenido

  • julio 2022 (7)
  • marzo 2022 (1)
  • diciembre 2021 (2)
  • octubre 2021 (3)
  • septiembre 2021 (3)
  • abril 2021 (7)
  • diciembre 2020 (4)
  • noviembre 2020 (1)
  • octubre 2020 (2)
  • julio 2020 (1)
  • octubre 2019 (1)
  • junio 2019 (1)
  • abril 2019 (1)
  • febrero 2019 (4)
  • noviembre 2018 (2)
  • octubre 2018 (8)
  • septiembre 2018 (1)

Lo último de este blog

  • Pregunta final resuelta de principios de algoritmos UTP en Pseint 3 30 julio, 2022
  • UTP Ejercicios de prueba de escritorio de principios de algoritmos Nº 4 26 julio, 2022
  • UTP Ejercicios de prueba de escritorio de principios de algoritmos Nº 3 26 julio, 2022
  • UTP Ejercicios de prueba de escritorio de principios de algoritmos Nº 2 25 julio, 2022
  • UTP Ejercicios de prueba de escritorio de principios de algoritmos Nº 1 25 julio, 2022
  • Ejercicios resueltos de principios de algoritmos UTP en Pseint 2 24 julio, 2022
  • Ejercicios resueltos de principios de algoritmos UTP en Pseint 1 24 julio, 2022
  • Principios de algoritmos UTP – resolución de examen final Nº 3 13 marzo, 2022
  • Principios de algoritmos UTP – resolución de examen final Nº 2 30 diciembre, 2021
  • Principios de algoritmos UTP – resolución de examen final Nº 1 30 diciembre, 2021

Categorías

Etiquetas

algoritmos (16) archivos binarios (3) bootstrap (2) bucle (10) c (3) c++ (18) ciclos (9) conio (2) cpp (6) diagramas de flujo (10) eclipse (7) editores (2) estructura repetitiva (9) estructuras de control (10) examenes finales (6) herramientas de programación (2) IDE (2) ides (2) int (2) java (7) java web (4) jquery (2) jsp (3) juegos (3) login (7) matemática (3) mcm (2) menú (4) menú de opciones (6) mysql (5) paso por referencia (1) paso por valor (1) principios de algoritmos (6) programación (7) pseint (10) pseudocódigo (10) punteros (1) registro de usuarios (2) servlet (5) swap (1) teclas direccionales (2) tomcat (4) utp (6) validación (2) while (2)
Este sitio web utiliza cookies para mejorar su experiencia. Asumiremos que está de acuerdo con esto, pero puede optar por no participar si lo desea.AceptoCancelar Read More
Privacy & Cookies Policy

Privacy Overview

This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary
Siempre activado
Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.
Non-necessary
Any cookies that may not be particularly necessary for the website to function and is used specifically to collect user personal data via analytics, ads, other embedded contents are termed as non-necessary cookies. It is mandatory to procure user consent prior to running these cookies on your website.
GUARDAR Y ACEPTAR