Notas en Ing. Sistemas

Desarrollo de una aplicación web con Java EE (JSF + JPA) - Parte 3

2015-07-08T22:12:00.004-05:00

En esta tercera parte terminaremos con las pruebas a la base de datos que empezamos en la parte anterior y crearemos el primer formulario de la aplicación.

En este serie vamos a desarrollar una aplicación web usando Java EE, integrando las siguientes tecnologías EclipseLink (JPA 2.1), PrimeFaces 5.0 JSF 2.0.

Para ello usaremos NetBeans IDE 8.0.2, y de base de datos MySQL 5.6.25, usando MySQL JDBC Driver 5.1.23 para conectar nuestra aplicación Java con MySQL, y MySQL Workbench 6.3 para gestionar y visualizar la base de datos.

Contenido

Terminando las pruebas a entidades

En la parte anterior hicimos una prueba de registro de información, y aprendimos cómo usar las entidades para persistir información de nuestra aplicación a la base de datos. Ahora, haremos una segunda prueba, pero ésta vez será de lectura, y veremos como obtener la información de la base de datos y usarla en nuestra aplicación.

Como vimos en la parte anterior, todo el acceso a datos se hace a través de una clase EntityManager, que se instancia a través de un EntityManagerFactory. Para recuperar información de la base de datos, usaremos una instancia de EntityManager que tiene métodos para crear objetos de tipo Query; la cual se utiliza para realizar consultas a la base de datos. Entonces, la secuencia de pasos que tenemos que implementar en el código es la siguiente:

Obtener una instancia del EntityManagerFactory
Obtener una instancia de EntityManager usando la instancia del EntityManagerFactory
Obtener una instancia de Query usando el método .createQuery() de la instancia de EntityManager
Instruir a la instancia de Query que ejecute la consulta, y procesar los datos devueltos por la misma
Una vez terminada el procesamiento de datos, cerrar el objeto EntityManager usando su método .close()
Cerrar el objecto EntityManagerFactory usando su método .close()

En NetBeans, hacemos click derecho en el nombre de nuestro proyecto y elegimos "New" > "Other" del menú contextual.

En la sección de "Categories" elegimos la carpeta "Java", y en la sección de "File Types", elegimos "Java Main Class", y damos click en "Next".

Proporcionamos un nombre al archivo, y utilizaremos el mismo paquete donde guardamos el archivo PruebaRegistro.java. (En mi caso, lo llamaré PruebaLectura que será guardada en el paquete com.nes.test). Damos click en "Finish".

Codificamos el archivo PruebaLectura usando los pasos descritos anteriormente.

PruebaLectura.java

package com.nes.test;

import com.nes.entidades.DetallePedido;
import com.nes.entidades.Pedido;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class PruebaLectura {
  
  public static void main(String[] args) {
    //Obtener una instancia de EntityManagerFactory
    EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("WebAppPU");
    //Obtener una instancia de EntityManager
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    
    //Obtener una instancia de Query
    Query query = entityManager.createQuery("SELECT p FROM Pedido p where p.id = 1");
    //Instruir a la instancia de Query que ejecute la consulta
    Pedido pedido = (Pedido) query.getSingleResult();
    //Procesar los datos devueltos
    System.out.println("Información de Pedido: ");
    System.out.println("ID: " + pedido.getId());
    System.out.println("Tienda: " + pedido.getTienda().getNombre());
    System.out.println("Usuario: " + pedido.getUsuario().getNombre());
    System.out.println("Detalle del pedido");
    for(DetallePedido detalle : pedido.getDetalle()){
      System.out.println("- Libro: " + detalle.getLibro().getNombre() +
        " Cantidad: " + detalle.getCantidad() +
        " Precio Unitario: " + detalle.getPrecioUnitario());
    }
    
    //Cerrar la instancia de EntityManager
    entityManager.clear();
    //Cerrar la instancia de EntityManagerFactory
    entityManagerFactory.close();
  }
  
}

Nótese que al momento de obtener la instancia de Query, es necesario pasarle un parámetro String al método .createQuery(). Este parámetro es la consulta a ejecutar en la base de datos, que debe estar escrita en JPQL. JPQL es un lenguaje de consulta definido por JPA. JQPL es similar a SQL, pero en vez de operar en tablas y columnas en la base de datos como lo hace SQL; JQPL opera en atributos y relaciones de nuestras entidades. Puedes leer más sobre el lenguaje JPQL en este link.

El método .getSingleResult() devuelve un objeto de tipo Object, pero como sabemos que nuestra Query retornará un pedido, es que le hacemos una conversión de tipo cast a tipo Pedido, y almacenamos su valor en una variable de trabajo. Finalmente, hacemos uso de los métodos getter y setter que codificamos en nuestras entidades para mostrar en consola la información traída de nuestra base de datos. Nótese lo fácil que es pasar de una entidad a otra: empezamos mostrando la información de la entidad Pedido, almacenada en la tabla "pedido" en la base de datos; y terminamos mostrando la información del detalle del pedido, que se encuentra almacenada en la tabla "detallepedido" en la base datos. Ésta es una de los beneficios de usar JPA; si no usáramos JPA tendríamos que haber realizado una consulta SQL a la base de datos para obtener los datos del pedido, y luego otra consulta SQL para obtener los datos del detalle del pedido. JPA hace esto por nosotros de manera automática.

Procedemos a ejecutar el archivo PruebaLectura.java. Para ello hacemos click derecho cualquier lugar del código del archivo y elegimos la opción "Run File" del menú contextual.

Se ejecuta nuestro código, y en la ventana de "Output" podemos ver el resultado de la ejecución: la consola muestra la información del pedido con ID igual a 1 y su detalle correspondiente.

En el ejemplo anterior, utilizamos JPA para buscar un pedido en particular. Ahora utilizaremos JPA para buscar una colección: mostraremos en consola todos los géneros de la base de datos. En el mismo archivo PruebaLectura.java, agregamos un poco más de código al final del archivo:

PruebaLectura.java

package com.nes.test;

import com.nes.entidades.DetallePedido;
import com.nes.entidades.Genero;
import com.nes.entidades.Pedido;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class PruebaLectura {
  
  public static void main(String[] args) {
    //Obtener una instancia de EntityManagerFactory
    EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("WebAppPU");
    //Obtener una instancia de EntityManager
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    
    //Obtener una instancia de Query
    Query query = entityManager.createQuery("SELECT p FROM Pedido p where p.id = 1");
    //Instruir a la instancia de Query que ejecute la consulta
    Pedido pedido = (Pedido) query.getSingleResult();
    //Procesar los datos devueltos
    System.out.println("Información de Pedido: ");
    System.out.println("ID: " + pedido.getId());
    System.out.println("Tienda: " + pedido.getTienda().getNombre());
    System.out.println("Usuario: " + pedido.getUsuario().getNombre());
    System.out.println("Detalle del pedido");
    for(DetallePedido detalle : pedido.getDetalle()){
      System.out.println("- Libro: " + detalle.getLibro().getNombre() +
        " Cantidad: " + detalle.getCantidad() +
        " Precio Unitario: " + detalle.getPrecioUnitario());
    }
    
    //Cerrar la instancia de EntityManager
    entityManager.clear();
    //Cerrar la instancia de EntityManagerFactory
    entityManagerFactory.close();
    
    //Obtener una instancia de EntityManagerFactory
    EntityManagerFactory entityManagerFactory1 = Persistence.createEntityManagerFactory("WebAppPU");
    //Obtener una instancia de EntityManager
    EntityManager entityManager1 = entityManagerFactory1.createEntityManager();
    
    //Obtener una instancia de Query
    Query query1 = entityManager1.createQuery("SELECT g FROM Genero g");
    //Instruir a la instancia de Query que ejecute la consulta
    List listaGeneros = (List) query1.getResultList();
    //Procesar los datos devueltos
    System.out.println();
    System.out.println("Lista de Generos");
    for(Genero g : listaGeneros) {
      System.out.println("ID: " + g.getId() + " Nombre: " + g.getNombre());
    }
    
    //Cerrar la instancia de EntityManager
    entityManager1.clear();
    //Cerrar la instancia de EntityManagerFactory
    entityManagerFactory1.close();
  }
  
}

Para procesar colecciones, hacemos uso del método .getResultList() de la clase Query. Y como sabemos que retornará información sobre genero, podemos hacer una conversión de tipo cast a List que almacenamos en una variable de trabajo. Finalmente, iteramos sobre la lista de Generos y mostramos el resultado en consola.

Volvemos a ejecutar el archivo PruebaLectura.java y ahora vemos que en la pestaña de "Output", además de la información del pedido mostrada anteriormente, también se muestra la información de los géneros registrados en la base de datos. (Me tomé la libertad de agregar más registros en la tabla Género de la base de datos para evidenciar este ejemplo)

Hasta este punto, hemos creado las entidades y hemos registrar y obtener información de nuestra base de datos; pero la idea es que los usuarios de la aplicación sean los que puedan registrar y consultar la información, y no estarla codificando nosotros mismos. En la siguiente parte, crearemos el primero formulario de la aplicación.

El primer controlador

Java Server Faces (JSF) utiliza el modelo de vista-controlador conocido como MVC. Según Wikipedia:

El modelo–vista–controlador (MVC) es un patrón de arquitectura de software que separa los datos y la lógica de negocio de una aplicación de la interfaz de usuario y el módulo encargado de gestionar los eventos y las comunicaciones. Para ello MVC propone la construcción de tres componentes distintos que son el modelo, la vista y el controlador.

El Modelo es la representación de la información con la cual el sistema opera; [..] el Controlador responde a eventos (usualmente acciones del usuario) e invoca peticiones al 'modelo' cuando se hace alguna solicitud sobre la información [..] y la Vista presenta el Modelo [..] en un formato adecuado para interactuar (usualmente la interfaz de usuario).

En nuestra aplicación, ya tenemos la parte del modelo: son nuestras entidades. En JSF, un controlador es implementado mediante una clase java con la anotación @ManagedBean. Y las vista es implementada mediante un archivo XHTML.

Vamos a crear un formulario para que los usuarios puedan registrar géneros en la base de datos. Para ello procederemos a crear el primer controlador. En la pestaña de "Projects", damos click derecho a nuestro proyecto y elegimos "New" > "Java Class" del menú contextual.

Proporcionamos un nombre para nuestro controlador, lo llamaremos "ControladorGenero" y será guardado en un nuevo paquete llamado "com.nes.controladores", y damos click en "Finish".

Codificamos el archivo ControladorGenero:

ControladorGenero.java

package com.nes.controladores;

import com.nes.entidades.Genero;
import javax.faces.bean.ManagedBean;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

@ManagedBean
public class ControladorGenero {
  private Genero genero = new Genero();
  
  public void registrarGenero() {
    //Obtener una instancia de EntityManagerFactory
    EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("WebAppPU");
    //Obtener una instancia de EntityManager
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    //Como vamos a persistir datos, abrimos una transacción
    entityManager.getTransaction().begin();
    //Persistimos la información
    entityManager.persist(genero);
    //Ejecutamos la transacción
    entityManager.getTransaction().commit();
    //Cerramos la instancia de EntityManager
    entityManager.close();
    //Cerramos la instancia de EntityManagerFactory
    entityManagerFactory.close();
  }
  
  public Genero getGenero() {
    return genero;
  }

  public void setGenero(Genero genero) {
    this.genero = genero;
  }
}

El controlador tiene un solo atributo de tipo Genero con sus respectivos métodos getter y setter. Y también tiene un método registrarGenero() que persiste la información del atributo de tipo Genero.

Programando una vista

Ahora procederemos a crear la primera vista que usará el controlador programado anteriormente. En la pestaña "Projects", expandimos el proyecto y le damos click derecho en "Web Pages", elegimos "New" > "Folder" del menú contextual.

Proporcionamos un nombre a la carpeta, la llamaremos "app", y damos click en "Finish".

Damos click derecho en la carpeta "app" y elegimos "New" > "Other" del menú contextual.

Proporcionamos un nombre, el cual llamaremos "registroGenero", y damos click en "Finish".

Editamos el contenido del archivo registroGenero.xhtml para que quede de la siguiente manera:

ControladorGenero.java

<?xml version='1.0' encoding='UTF-8' ?>
<!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"
      xmlns:h="http://xmlns.jcp.org/jsf/html"
      xmlns:p="http://primefaces.org/ui">
  <h:head>
    <title>Registro de Género</title>
  </h:head>
  <h:body>
    <h:form>
      <h:outputLabel for="txtNombre" value="Nombre: " />
      <p:inputText id="txtNombre" value="#{controladorGenero.genero.nombre}" />
      <p:commandButton action="#{controladorGenero.registrarGenero}"
                       value="Guardar" />
    </h:form>
  </h:body>
</html>

Como podemos ver, la vista se compone de un formulario, el cual contiene una label con el valor de "Nombre: ", un input text (caja de texto), y un botón con el valor de "Guardar" para enviar el formulario. Nótese que para el input le asignamos el valor del atributo de tipo Genero del ControladorGenero, y que para el botón de envío de formulario le asignamos el método .registrarGenero() del ControladorGenero. Para hacer esta asignación, hacemos un binding con nuestro controlador, utilizando Expression Language. Para saber más sobre Expression Language puede revisar la documentación de Oracle.

Finalmente ejecutamos la aplicación, para eso damos click derecho en el archivo "registrarGenero.xhtml" de nuestra aplicación y elegimos "Run File" del menú contextual. La aplicación se despliega y se abre la ventana del browser mostrando el formulario:

Proporcionamos un nombre, y damos click en el botón de Guardar.

Revisamos la base de datos, y podemos observar que en la tabla Genero se ha insertado un nuevo registro.

Conclusión - Link de Descarga del Proyecto

Recapitulando, en esta parte terminamos con las pruebas de las entidades: realizando una pequeña prueba de lectura de información de la base de datos, demostrando que nuestra aplicación Java se conecta adecuadamente con la base de datos MySQL. También creamos el primer controlador y creamos la primera vista de la aplicación, la cual contiene un formulario que permite a los usuarios registrar géneros en la base de datos. Puedes descargar el código del proyecto de NetBeans hasta este punto haciendo click en este link.

La aplicación hasta ahora permite a los usuarios registrar géneros exitosamente, pero no se muestra algún mensaje notificando a los usuarios que el registro se hizo adecuadamente o no. En la siguiente parte, mejoraremos la interfaz de usuario y continuaremos con el desarrollo de la aplicación.

Referencias:

Desarrollo de una aplicación web con Java EE (JSF + JPA) - Parte 2

2015-07-07T22:55:00.000-05:00

En esta segunda parte procederemos a crear las entidades de la aplicación, utilizando EclipseLink que implementa la especificación JPA que nos ayudará a manejar nuestra base de datos MySQL.

En este serie vamos a desarrollar una aplicación web usando Java EE, integrando las siguientes tecnologías EclipseLink (JPA 2.1), PrimeFaces 5.0 JSF 2.0.

Para ello usaremos NetBeans IDE 8.0.2, y de base de datos MySQL 5.6.25, usando MySQL JDBC Driver 5.1.23 para conectar nuestra aplicación Java con MySQL, y MySQL Workbench 6.3 para gestionar y visualizar la base de datos.

Contenido

Creación de clases

Las clases que procederemos a crear en nuestro proyecto son las que se muestran en el siguiente diagrama de clases:

En la pestaña de "Projects" expandimos nuestro proyectos, y damos click derecho en "Source Packages", elegimos New > Java Class del menú contextual.

En el cuadro de diálogo que aparece brindamos un nombre a nuestra clase en "Class Name", y en "Package" proporcionamos el nombre del paquete donde se guardarán las clases. Procedemos a crear la clase Genero, que estará dentro del paquete com.nes.entidades.

En nuestra nueva clase Genero, procedemos a codificar los atributos respectivos de la clase.

package com.nes.entidades;

public class Genero {
  private int id;
  private String nombre;
}

A continuación, procedemos a generar los getter y setters de la clase, para eso hacemos click derecho en cualquier lugar del código del archivo Género.java, elegimos "Refactor" > "Encapsulate fields" del menú.

Elegimos cuales atributos deseamos generar los getters/setters (en este caso todos los atributos), y damos click en "Refactor".

Ahora nuestra clase Genero, tiene los métodos Get y Set respectivos para poder acceder a los atributos de la clase que están marcados como privados. El archivo Genero.java debe quedar de la siguiente manera:

Genero.java

package com.nes.entidades;

public class Genero {
  private int id;
  private String nombre;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getNombre() {
    return nombre;
  }

  public void setNombre(String nombre) {
    this.nombre = nombre;
  }
}

Repetimos la misma secuencia de pasos para crear las demás clases de la aplicación: Usuario, Libro, Tienda, DetallePedido, Pedido y Stock. Procederemos a codificar las clases y sus respectivos métodos getters y setters para cada atributo. Las clases resultantes deben quedar de esta manera:

Usuario.java

package com.nes.entidades;

import java.util.ArrayList;
import java.util.List;

public class Usuario {
  private int id;
  private String nombre;
  private String usuario;
  private String clave;
  private boolean administrador;
  private List pedidos = new ArrayList<>();

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getNombre() {
    return nombre;
  }

  public void setNombre(String nombre) {
    this.nombre = nombre;
  }

  public String getUsuario() {
    return usuario;
  }

  public void setUsuario(String usuario) {
    this.usuario = usuario;
  }

  public String getClave() {
    return clave;
  }

  public void setClave(String clave) {
    this.clave = clave;
  }

  public boolean isAdministrador() {
    return administrador;
  }

  public void setAdministrador(boolean administrador) {
    this.administrador = administrador;
  }

  public List getPedidos() {
    return pedidos;
  }

  public void setPedidos(List pedidos) {
    this.pedidos = pedidos;
  }
}

Libro.java

package com.nes.entidades;

public class Libro {
  private int id;
  private String nombre;
  private float precio;
  private Genero genero;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getNombre() {
    return nombre;
  }

  public void setNombre(String nombre) {
    this.nombre = nombre;
  }

  public float getPrecio() {
    return precio;
  }

  public void setPrecio(float precio) {
    this.precio = precio;
  }

  public Genero getGenero() {
    return genero;
  }

  public void setGenero(Genero genero) {
    this.genero = genero;
  }
}

Tienda.java

package com.nes.entidades;

public class Tienda {
  private int id;
  private String nombre;
  private String direccion;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getNombre() {
    return nombre;
  }

  public void setNombre(String nombre) {
    this.nombre = nombre;
  }

  public String getDireccion() {
    return direccion;
  }

  public void setDireccion(String direccion) {
    this.direccion = direccion;
  }
  
}

DetallePedido.java

package com.nes.entidades;

public class DetallePedido {
  private int id;
  private Pedido pedido;
  private Libro libro;
  private float precioUnitario;
  private int cantidad;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public Pedido getPedido() {
    return pedido;
  }

  public void setPedido(Pedido pedido) {
    this.pedido = pedido;
  }

  public Libro getLibro() {
    return libro;
  }

  public void setLibro(Libro libro) {
    this.libro = libro;
  }

  public float getPrecioUnitario() {
    return precioUnitario;
  }

  public void setPrecioUnitario(float precioUnitario) {
    this.precioUnitario = precioUnitario;
  }

  public int getCantidad() {
    return cantidad;
  }

  public void setCantidad(int cantidad) {
    this.cantidad = cantidad;
  }
}

Pedido.java

package com.nes.entidades;

import java.util.ArrayList;
import java.util.List;

public class Pedido {
  private int id;
  private Usuario usuario;
  private Tienda tienda;
  private List detalle = new ArrayList<>();

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public Usuario getUsuario() {
    return usuario;
  }

  public void setUsuario(Usuario usuario) {
    this.usuario = usuario;
  }

  public Tienda getTienda() {
    return tienda;
  }

  public void setTienda(Tienda tienda) {
    this.tienda = tienda;
  }

  public List getDetalle() {
    return detalle;
  }

  public void setDetalle(List detalle) {
    this.detalle = detalle;
  }
}

Stock.java

package com.nes.entidades;

public class Stock {
  private int id;
  private Libro libro;
  private Tienda tienda;
  private int cantidad;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public Libro getLibro() {
    return libro;
  }

  public void setLibro(Libro libro) {
    this.libro = libro;
  }

  public Tienda getTienda() {
    return tienda;
  }

  public void setTienda(Tienda tienda) {
    this.tienda = tienda;
  }

  public int getCantidad() {
    return cantidad;
  }

  public void setCantidad(int cantidad) {
    this.cantidad = cantidad;
  }
}

Hasta este punto tenemos las clases que utilizaremos en nuestra aplicación. A continuación procederemos a convertir estas clases en Entidades de EclipseLink que representarán las tablas en nuestra base de datos.

Creación de entidades

Para que nuestras clases de Java se vuelvan entidades de EclipseLink, se hace uso de la anotación @Entity. Esto indica a EclipseLink que la clase representa una tabla en nuestra base de datos. La anotación @Entity necesita que las clases que la utilicen implementen la interfaz Serializable del paquete java.io.Serializable. Por lo que también haremos que las clases implementen dicha interfaz.

También es necesario especificar cuál atributo de la clase será usado como llave primaria en la base de datos. Como todas nuestras clases tienen un atributo id de tipo entero usaremos ese atributo para que sea la llave primaria de las tablas en nuestra base de datos. Para eso, se usa la anotación @Id.

Además, para no preocuparnos por cómo generar la llave primaria con cada nuevo registro en nuestra aplicación, usaremos la anotación @GeneratedValue para indicar a EclipseLink que la llave primaria se generará automáticamente. También especificamos que la estrategia para generar las llaves primarias será mediante el uso del Identity en MySQL (también conocido como AUTO_INCREMENT), y esto lo hacemos con la propiedad GenerationType.IDENTITY dentro de la anotación @GeneratedValue.

En una base de datos, las tablas no se encuentran aisladas. Las tablas se encuentran asociadas con otras mediante llaves foráneas, y dependiendo de la cardinalidad, se tienen asociaciones uno a uno, uno a muchos, o muchos a muchos.

En nuestra aplicación, podemos observar que tenemos muchas asociaciones entre diferentes entidades, por citar algunas:

Un libro tiene un género y a su vez; un género puede estar presente en muchos libros. Esto es una relación de uno a muchos entre Libro y Genero
Un usuario puede realizar muchos pedidos y a su vez; un pedido es realizado por un usuario. Esto es una relación de uno a muchos entre Usuario y Pedido
Un usuario puede realizar muchos pedidos y a su vez; un pedido es realizado por un usuario. Esto es una relación de uno a muchos entre Usuario y Pedido
Una tienda tiene una colección de existencias (stocks), y a su vez una existencia (stock) tiene está asignado a una tienda. Esto es una relación de uno a muchos entre Tienda y Stock.

Para especificar dichas relaciones entre tablas, se usan las anotaciones @ManyToOne y @OneToMany para representar asociaciones muchos-a-uno y de uno-a-muchos respectivamente. Mas información sobre relaciones en JPA en el WikiBook de Java Persistence.

Haciendo uso de éstas anotaciones, nuestras clases quedan de la siguiente manera:

Genero.java

package com.nes.entidades;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Genero implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;
  private String nombre;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getNombre() {
    return nombre;
  }

  public void setNombre(String nombre) {
    this.nombre = nombre;
  }
}

Libro.java

package com.nes.entidades;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Libro implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;
  private String nombre;
  private float precio;
  @ManyToOne
  private Genero genero;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getNombre() {
    return nombre;
  }

  public void setNombre(String nombre) {
    this.nombre = nombre;
  }

  public float getPrecio() {
    return precio;
  }

  public void setPrecio(float precio) {
    this.precio = precio;
  }

  public Genero getGenero() {
    return genero;
  }

  public void setGenero(Genero genero) {
    this.genero = genero;
  }
}

Stock.java

package com.nes.entidades;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Stock implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;
  @ManyToOne
  private Libro libro;
  @ManyToOne
  private Tienda tienda;
  private int cantidad;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public Libro getLibro() {
    return libro;
  }

  public void setLibro(Libro libro) {
    this.libro = libro;
  }

  public Tienda getTienda() {
    return tienda;
  }

  public void setTienda(Tienda tienda) {
    this.tienda = tienda;
  }

  public int getCantidad() {
    return cantidad;
  }

  public void setCantidad(int cantidad) {
    this.cantidad = cantidad;
  }
}

Tienda.java

package com.nes.entidades;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Tienda implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;
  private String nombre;
  private String direccion;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getNombre() {
    return nombre;
  }

  public void setNombre(String nombre) {
    this.nombre = nombre;
  }

  public String getDireccion() {
    return direccion;
  }

  public void setDireccion(String direccion) {
    this.direccion = direccion;
  }
  
}

Usuario.java

package com.nes.entidades;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;

@Entity
public class Usuario implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;
  private String nombre;
  private String usuario;
  private String clave;
  private boolean administrador;
  @OneToMany(mappedBy = "usuario")
  private List pedidos = new ArrayList<>();

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getNombre() {
    return nombre;
  }

  public void setNombre(String nombre) {
    this.nombre = nombre;
  }

  public String getUsuario() {
    return usuario;
  }

  public void setUsuario(String usuario) {
    this.usuario = usuario;
  }

  public String getClave() {
    return clave;
  }

  public void setClave(String clave) {
    this.clave = clave;
  }

  public boolean isAdministrador() {
    return administrador;
  }

  public void setAdministrador(boolean administrador) {
    this.administrador = administrador;
  }

  public List getPedidos() {
    return pedidos;
  }

  public void setPedidos(List pedidos) {
    this.pedidos = pedidos;
  }
}

Pedido.java

package com.nes.entidades;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;

@Entity
public class Pedido implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;
  @ManyToOne
  private Usuario usuario;
  @ManyToOne
  private Tienda tienda;
  @OneToMany(mappedBy = "pedido")
  private List detalle = new ArrayList<>();

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public Usuario getUsuario() {
    return usuario;
  }

  public void setUsuario(Usuario usuario) {
    this.usuario = usuario;
  }

  public Tienda getTienda() {
    return tienda;
  }

  public void setTienda(Tienda tienda) {
    this.tienda = tienda;
  }

  public List getDetalle() {
    return detalle;
  }

  public void setDetalle(List detalle) {
    this.detalle = detalle;
  }
}

DetallePedido.java

package com.nes.entidades;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class DetallePedido implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;
  @ManyToOne
  private Pedido pedido;
  @ManyToOne
  private Libro libro;
  private float precioUnitario;
  private int cantidad;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public Pedido getPedido() {
    return pedido;
  }

  public void setPedido(Pedido pedido) {
    this.pedido = pedido;
  }

  public Libro getLibro() {
    return libro;
  }

  public void setLibro(Libro libro) {
    this.libro = libro;
  }

  public float getPrecioUnitario() {
    return precioUnitario;
  }

  public void setPrecioUnitario(float precioUnitario) {
    this.precioUnitario = precioUnitario;
  }

  public int getCantidad() {
    return cantidad;
  }

  public void setCantidad(int cantidad) {
    this.cantidad = cantidad;
  }
}

Cabe resaltar que en la entidad Pedido usamos la anotación @OneToMany(mappedBy = "pedido") para especificar la relación de uno-a-muchos con la entidad DetallePedido. La propiedad mappedBy indica que la llave foránea se encuentra en el otro lado de la relación con el atributo proporcionado. En este caso particular, quiere decir en la entidad Pedido, se le indica que la llave foránea que la asocia con la entidad DetallePedido se encuentra dentro de la entidad DetallePedido en el atributo pedido. Este mismo escenario sucede entre la entidad Usuario y la entidad Pedido.

Si revisamos el código, podemos observar que la entidad DetallePedido, sí cuenta con una atributo llamado pedido, que es de tipo Pedido.

Agregando una unidad de persistencia

Si estuviste atento mientras implementabas las anotaciones en nuestras entidades, NetBeans muestra una advertencia: "The project doest not contain a persistence unit" o "El proyecto no contiene una unidad de persistencia".

Según la documentación de Oracle: "Una unidad de persistencia define un conjunto de entidades que son manejados por instancias de EntityManager en una aplicación. Este conjunto de entidades representan los datos contenidos en una única fuente de datos."

En este proyecto vamos a usar una única fuente de datos, la cual es nuestra base de datos MySQL, por lo cual es necesario crear una sola unidad de persistencia. Para crear la unidad de persistencias, en nuestro proyecto, damos click derecho, "New" > "Other".

Elegimos la carpeta "Persistence" en la sección de "Categories", y luego elegimos "Persistence Unit" de la sección "File Types", y damos click en Next.

Proveemos de un nombre a nuestra unidad de persistencia en "Persistence Unit Name" (en mi caso lo llamaré "WebAppPU"), elegimos como proveedor de persistencia ("Persistence Provider"), a EclipseLink, y en "Data Source", elegimos "New Data Source", nos aparecerá una ventana, y elegimos nuestra conexión a la base de datos creada anteriormente en la parte 1., y le proporcionamos un nombre (en mi caso lo llamaré "nes_java_db"). Toma nota del nombre de la unidad de persistencia que lo usaremos luego en esta parte.

Damos click en "Ok" para cerrar el cuadro de diálogo del Data Source, y en "Finish" para terminar de crear nuestra unidad de persistencia. NetBeans crea la unidad de persistencia en un archivo llamado "persistence.xml", bajo la carpeta "Configuration Files" en la pestaña de Projects. Damos doble click en persistence.xml para abrir el archivo.

Nos aseguramos que la opción "Use Java Transaction APIs" se encuentra deseleccionada, y que "Table Generation Strategy" se encuentre en "Create". La primera opción indica que no vamos a usar tecnología Java Transaction API (conocida como JTA), sino que nosotros mismos manejaremos las transacciones a nuestra base de datos. La segunda opción indica que las tablas se crearán en caso que no existan en la base de datos. (Si seguiste este tutorial paso a paso, recuerda que actualmente nuestra base de datos se encuentra vacía).

Nos aseguramos que la opción "Include All Entity Classes in "WebApp" Module" se encuentre deseccionada, y damos click en el botón "Add Class", elegimos todas nuestras entidades de la lista y damos click en "Ok" para agregarlas.

En el archivo persistence.xml hacemos click en el botón "Source" para visualizar el contenido del archivo, y debemos tener el contenido similar a este:

persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
  <persistence-unit name="WebAppPU" transaction-type="RESOURCE_LOCAL">
    <non-jta-data-source>nes_java_db</non-jta-data-source>
    <class>com.nes.entidades.DetallePedido</class>
    <class>com.nes.entidades.Genero</class>
    <class>com.nes.entidades.Libro</class>
    <class>com.nes.entidades.Pedido</class>
    <class>com.nes.entidades.Stock</class>
    <class>com.nes.entidades.Tienda</class>
    <class>com.nes.entidades.Usuario</class>
    <exclude-unlisted-classes>true</exclude-unlisted-classes>
    <properties>
      <property name="javax.persistence.schema-generation.database.action" value="create"/>
    </properties>
  </persistence-unit>
</persistence>

Procedemos a editar el archivo haciendo los siguientes cambios:

Cambiamos la línea "<non-jta-data-source>nes_java_db</non-jta-data-source>" por "<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>"
Bajo el nodo <properties> agregamos lo siguiente

Agregamos la cadena de conexión:
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/nes_java_db?zeroDateTimeBehavior=convertToNull"/>
Agregamos el driver de MySQL:
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
Agregamos el nombre de usuario de las credenciales de MySQL (en este caso, usaré el usuario root, tú puedes usar otro)
<property name="javax.persistence.jdbc.user" value="root"/>
Agregamos la clave del usuario de MySQL (mi clave es mysql, la tuya puede cambiar)
<property name="javax.persistence.jdbc.password" value="mysql"/>

El archivo final debe ser de la siguiente manera:

persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
  <persistence-unit name="WebAppPU" transaction-type="RESOURCE_LOCAL">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <class>com.nes.entidades.DetallePedido</class>
    <class>com.nes.entidades.Genero</class>
    <class>com.nes.entidades.Libro</class>
    <class>com.nes.entidades.Pedido</class>
    <class>com.nes.entidades.Stock</class>
    <class>com.nes.entidades.Tienda</class>
    <class>com.nes.entidades.Usuario</class>
    <exclude-unlisted-classes>true</exclude-unlisted-classes>
    <properties>
      <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/nes_java_db?zeroDateTimeBehavior=convertToNull"/>
      <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
      <property name="javax.persistence.jdbc.user" value="root"/>
      <property name="javax.persistence.jdbc.password" value="mysql"/>
      <property name="javax.persistence.schema-generation.database.action" value="create"/>
    </properties>
  </persistence-unit>
</persistence>

Con esto, ya tenemos nuestras entidades mapeadas, y nuestro proyecto configurado para que pueda conectarse con nuestra base de datos. En la siguiente parte, probaremos que las entidades se hayan programado correctamente.

Probando las entidades

En esta parte crearemos un par de archivos de prueba, para probar que las entidades hayan sido programadas correctamente, y demostrar que nuestra aplicación realmente se conecta con la base de datos.

Damos click derecho a nuestro proyecto desde la pestaña de "Projects", y vamos a "New" > "Other".

En la sección de "Categories" elegimos la carpeta "Java", y en la sección de "File Types", elegimos la opción "Java Main Class", y damos click en "Next".

Damos un nombre a nuestro archivo y especificamos el paquete donde se guardará. En mi caso, lo llamaré "PruebaRegistro" dentro del paquete "com.nes.test", y damos click en "Finish" para crear nuestro archivo.

Para registrar la información de las entidades a la base de datos en JPA, se realiza a través del EntityManager (Gestor de entidades). Para ello, se tiene un EntityManagerFactory que se encarga de crear una instancia de EntityManager que podremos usar para registrar información a la base de datos. También como especificamos anteriormente que no usaremos Java Transaction API (JTA) para la gestión de las transacciones, lo haremos nosotros mismos en el código. Entonces, la secuencia de pasos que debe seguir el código para la prueba de registro queda de la siguiente manera:

Obtener una instancia del EntityManagerFactory
Obtener una instancia de EntityManager usando la instancia del EntityManagerFactory
Como vamos a registrar datos, es necesario abrir e iniciar una transacción en el EntityManager
Instanciaremos nuestras entidades, y luego usaremos el método .persist() del EntityManager para registrarlas en la base de datos
Finalizar la transacción haciendo un commit, para que se registre la información en la base de datos
Cerrar el objeto EntityManager usando su método .close()
Cerrar el objecto EntityManagerFactory usando su método .close()

Registraremos en la base de datos una instancia de cada entidad que tenemos en nuestro proyecto, el archivo PruebaRegistro queda de la siguiente manera:

PruebaRegistro.java

package com.nes.test;

import com.nes.entidades.DetallePedido;
import com.nes.entidades.Genero;
import com.nes.entidades.Libro;
import com.nes.entidades.Pedido;
import com.nes.entidades.Stock;
import com.nes.entidades.Tienda;
import com.nes.entidades.Usuario;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class PruebaRegistro {

  public static void main(String[] args) {
    EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("WebAppPU");
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    entityManager.getTransaction().begin();
  
    //Registrar un género
    Genero genero = new Genero();
    genero.setNombre("Drama");
    entityManager.persist(genero);
    
    //Registrar un Libro
    Libro libro = new Libro();
    libro.setNombre("Hamlet");
    libro.setPrecio(22.99f);
    libro.setGenero(genero);
    entityManager.persist(libro);
    
    //Registrar un Usuario
    Usuario usuario = new Usuario();
    usuario.setNombre("Fulano de Tal");
    usuario.setUsuario("usuario");
    usuario.setClave("1234");
    usuario.setAdministrador(false);
    entityManager.persist(usuario);
    
    //Registrar una tienda
    Tienda tienda = new Tienda();
    tienda.setNombre("Tienda #1");
    tienda.setDireccion("Av. Siempreviva 742");
    entityManager.persist(tienda);
    
    //Registrar Stock
    Stock stock = new Stock();
    stock.setLibro(libro);
    stock.setTienda(tienda);
    stock.setCantidad(12);
    entityManager.persist(stock);
    
    //Registrar un Pedido
    Pedido pedido = new Pedido();
    pedido.setTienda(tienda);
    pedido.setUsuario(usuario);
    entityManager.persist(pedido);
    
    //Registrar DetallePedido
    DetallePedido detallePedido = new DetallePedido();
    detallePedido.setPedido(pedido);
    detallePedido.setLibro(libro);
    detallePedido.setPrecioUnitario(libro.getPrecio());
    detallePedido.setCantidad(1);
    entityManager.persist(detallePedido);
    
    entityManager.getTransaction().commit();
    entityManager.close();
    entityManagerFactory.close();
  }
  
}

Finalmente, ejecutamos el archivo PruebaRegistro dando doble click en cualquier lugar del código y seleccionando la opción "Run File", también podemos usar el atajo Shift+F6 desde el archivo para ejecutarlo.

El archivo se ejecuta correctamente y se evidencia en la ventana de Output con el mensaje "BUILD SUCCESFUL"

Si revisamos nuestra base de datos, podemos observar que las tablas han sido creadas automáticamente, y que además han sido pobladas con los datos de nuestra prueba de registro.

De esta manera, nuestra base de datos queda como se muestra en el siguiente diagrama:

Cabe resaltar que en el código del archivo PruebaRegistro, en ninguna entidad usamos el método setId() para establecer el Id de nuestras entidades. Pero en la base de datos nos damos cuenta que el Id se ha creado automáticamente, esto es debido a la notación @GeneratedValue que pusimos en nuestras entidades, que hace que se generen de manera automática.

Conclusión - Link de Descarga del Proyecto

Recapitulando, en esta parte creamos las clases de entidades, encapsulamos sus atributos mediante los métodos getter y setter, y usamos las anotaciones de JPA para indicar que dichas clases son las que representaran a las tablas en la base de datos, y definimos las relaciones existentes entre ellas. Puedes descargar el código del proyecto de NetBeans hasta este punto haciendo click en este link.

En la siguiente parte, haremos una pequeña prueba de lectura de información en nuestra base de datos.

Referencias:

Desarrollo de una applicación web con Java EE (JSF + JPA) - Parte 1

2015-07-06T23:28:00.000-05:00

En este serie vamos a desarrollar una aplicación web usando Java EE, integrando las siguientes tecnologías EclipseLink (JPA 2.1), PrimeFaces 5.0 JSF 2.0. En esta primera parte crearemos la base de datos en MySQL, el proyecto en NetBeans, y comenzaremos la codificación de las entidades de nuestra aplicación en Java usando la especificación JPA con EclipseLink.

Para ello usaremos NetBeans IDE 8.0.2, y de base de datos MySQL 5.6.25, usando MySQL JDBC Driver 5.1.23 para conectar nuestra aplicación Java con MySQL, y MySQL Workbench 6.3 para gestionar y visualizar la base de datos.

Contenido

Introducción a la aplicación

La aplicación de ejemplo que desarrollaremos será un gestor de libros para una cadena de librerías. Con esta aplicación, el administrador de la aplicación podrá gestionar las tiendas, y asignar qué libros se encuentran disponibles en cada tienda. Además, los clientes a través de la aplicación podrán consultar el catálogo de libros de cada tienda, y realizar pedidos.

Creación del schema en MySQL

En MySQL workbench elegimos File > New Query Tab del menú.

Creamos una base de datos, a la cual llamaremos nes_java_db, lo cual se hace con este comando:

CREATE SCHEMA nes_java_db;

Para ejecutar los comandos SQL en MySQL se puede usar el botón Execute Script, el cuál tiene un ícono de un rayo (ver imagen). Adicionalmente, se puede presionar Control+Shift+Enter si no se desea usar el botón.

Ejecutamos el comando, y una vez ejecutado en la ventana de Output nos debe salir un mensaje de confirmación. (Si no tienes la ventana de Output puedes mostrarla seleccionando View > Output desde el menú)

Si el nombre fue usado anteriormente, nos saldrá un error similar a éste: Error Code: 1007. Can't create database 'nes_java_db'; database exists
Para solucionarlo, deberás cambiarle el nombre a la BD de nes_java_db a otro de tu elección. Toma nota del nombre de la BD que lo usaremos luego.

Creación del proyecto en NetBeans

Abrimos NetBeans, y vamos a File > New Project para crear el proyecto.

En "Categories" elegimos la opción Java Web, y luego bajo "Projects" elegimos "Web Application".

Damos click en "Next", y ahora nos pide darle un nombre a nuestro proyecto, y elegir la ubicación. En mi caso lo llamaré "WebApp". Para cambiar la ruta del proyecto, se usa el botón "Browse" y se abre un cuadro de diálogo para elegir la nueva ubicación del proyecto. Cuando terminamos le damos siguiente.

A continuación se pide elegir el servidor a utilizar para nuestra aplicación, en mi caso usaré GlassFish Server 4.1 que vino con la instalación de NetBeans 8.0.2. Damos click en "Next".

Finalmente, se pide especificar si se va a utilizar algún framework en en el proyecto. En nuestro caso elegiremos Java Server Faces, con la librería JSF 2.2.

Vamos a la pestaña de "Components" y seleccionamos Primefaces, si tenemos varias versiones de Primefaces instaladas, podemos elegir la versión a usar haciendo click en el botón "More", yo utilizaré Primefaces 5.0 que vino instalada junto con NetBeans 8.0.2.

Damos click en "Finish" y NetBeans procede a crear nuestro proyecto. En este momento podemos probar que nuestra aplicación se haya creado correctamente. Para ello, damos click derecho en el nombre del proyecto y elegimos la opción "Run". (Adicionalmente, se puede ir Run > Run Project del menú)

Luego de unos momentos, se abre el explorador y muestra nuestro proyecto, con el mensaje "Hello from Facelets".

Conectando la base de datos al proyecto de NetBeans

Crearemos una nueva conexión de base de datos, para ello nos vamos a la pestaña de "Services", hacemos click derecho en "Database" y elegimos "New Connection" del menú. (Si no se tiene la pestaña de Services abierta, se puede mostrarla seleccionando "Window" > "Services" del menú principal)

Elegimos el driver adecuado, que en nuestro caso es MySQL y damos click en "Next".

Completamos la información requerida para conectarse a la base de datos, en "Database" ponemos el nombre que le proporcionamos a la base de datos de MySQL, en "User Name" y "Password" llenamos las credenciales de acceso para conectarse a MySQL. En "Host" y "Port" colocamos la información del host y el puerto de conexión para la base de datos. Como tengo MySQL instalado localmente y corriendo en el puerto por defecto, mi Host es localhost, y mi puerto es 3306. Si se desea probar si la conexión es válida, se da click en el botón "Test Connection" y de ser válido nos saldrá un mensaje "Connection Succedeed".

Finalmente damos click en "Finish" y nuestra conexión ya debería estar listada bajo "Databases".

Agregando más librerías al proyecto NetBeans

Si vamos la pestaña de "Projects" y expandimos la carpeta "Libraries" de nuestro proyecto, podemos ver que NetBeans agregó algunas librerías, pero éstas no son suficientes para el desarrollo de nuestra aplicación.

Para agregar una librería, hacemos click derecho en la carpeta de "Libraries" de nuestro proyecto y elegimos "Add Library".

Elegimos EclipseLink (JPA 2.1) que viene instalada con NetBeans 8.0.2, y también agregamos la librería del driver JDBC de MySQL que viene instalada con NetBeans 8.0.2, si no elegiste la opción de instalar el conector de MySQL a la hora de instalar NetBeans, la puedes descargar de la página de desarrolladores de MySQL. Finalmente, nuestro proyecto debe quedar con esas librerías agregadas.

Conclusión

Con esto, terminamos la configuración inicial de nuestro proyecto. Recapitulando lo que hicimos en esta parte: creamos la base de datos en MySQL, creamos el proyecto en NetBeans, agregamos una conexión de base de datos en NetBeans, y finalmente agregamos las librerías faltantes nuestro proyecto en NetBeans.

En la siguiente parte, entraremos de lleno a la codificación del proyecto. Empezaremos con la codifiación de clases Java que serán nuestras entidades, las cuales representan a las tablas de nuestra base de datos. Con ayuda de la tecnología EclipseLink, usaremos la especificación JPA para crear las tablas de la base de datos automáticamente junto con la creación de nuestras entidades.

Primera aplicación en Ruby on Rails - Primera Parte

2013-06-17T01:00:00.000-05:00

En esta entrada explicaremos paso a paso el desarrollo de una aplicación en Ruby on Rails. Nuestra primera aplicación consistirá en un blog muy simple que tendrá posts (publicaciones). En esta primera parte, crearemos una nueva aplicación en Rails y la configuraremos para que nos muestre un mensaje de Hola Mundo.

Antes de empezar, sugiero revisar un poco la teoría detrás de Rails, en mi entrada Introducción teórica a Ruby on Rails. Si no tienes instalado Rails en tu computadora puedes revisar mi entrada Instalación de Ruby on Rails en Windows y seguir los pasos descritos para instalar Rails.

Este proyecto será desarrollado en el siguiente entorno de configuración.

Ruby 1.9.3
Rails 3.2.13
Windows 7

Creando un nuevo proyecto: Blog

Empezaremos creando nuestro nuevo proyecto que llamaremos Blog. En Rails, para crear un nuevo proyecto, desde la consola escribimos el comando rails new seguido del nombre de nuestro proyecto. En esta caso, vamos a crear un proyecto llamado Blog, por lo que el comando es rails new Blog.

Rails automáticamente crea una carpeta con el nombre de nuestro proyecto y crea una serie de archivos y carpetas que es la estructura de todo proyecto en Rails. Si abrimos el directorio donde creamos nuestro proyecto en Rails podemos ver que se ha creado una carpeta Blog con el siguiente contenido.

Rails crea una serie de carpetas para nuestro proyecto, entre éstas se incluyen:

app, carpeta principal donde se guardan los archivos importantes para nuestro aplicativo. Dentro se encuentran:

controllers: carpeta donde se almacenan todos nuestros controladores
views: carpeta donde se almacenan todas nuestras vistas
models: carpeta donde se guardan todos nuestros modelos
assets: carpeta donde se almacenan los recursos de nuestro aplicativo web, dentro se encuentran las carpetas images, javascripts and stylesheets donde se deben guardar nuestras imágenes, archivos javascript y hojas de estilo respectivamente.

config, carpeta donde se almacenan las configuraciones de la aplicación. Dentro se encuentran:

database.yml: archivo de conexión a nuestra base de datos
routes.rb: archivo donde se configuran las rutas de nuestro aplicativo

public: archivo donde se guardan los recursos públicos de la aplicación (accesible por todos los usuarios a través de URLs)

Probando la aplicación

Podemos probar nuestra aplicación, ejecutando desde consola el comando rails server desde el directorio de nuestra aplicación (carpeta Blog). Si deseamos detener el servidor se hace con el comando Ctrl+C desde la consola de Windows (símbolo del sistema).

Rails por defecto utiliza el puerto 3000, a menos que se haya configurado de otra manera o el puerto se encuentre actualmente en uso, podemos ver nuestra aplicación desde la ruta http://localhost:3000 desde cualquier navegador web.

Como podemos observar, se muestra una página inicial de Rails, esta es la página de inicio por defecto de Ruby on Rails, que muestra la página web index.html ubicada en la carpeta public.

Creando la base de datos

Ahora que sabemos que nuestra aplicación funciona correctamente, es momento de crear nuestra base de datos. La gran mayoría de las aplicaciones en Rails trabaja con una base de datos. La base de datos que usaremos en nuestro proyecto debe ser especificada en un archivo de configuración llamado database.yml ubicado dentro de la carpeta config. Utilizando nuestro editor de texto favorito abrimos el archivo config/database.yml. (Yo voy a utilizar Sublime Text 2 como editor de texto, puedes usar el de tu preferencia).

Rails automáticamente configura nuestro archivo de configuración de la base de datos para usar la base de datos SQLite, esta es la base de datos por defecto para Rails 3.2.13. En este archivos especificamos la base de datos que deseamos utilizar, por ejemplo, si queremos utilizar MySQL o PostgreSQL. Sin embargo, para esta aplicación utilizaremos la base de datos por defecto, por lo que no modificaremos el archivo. Este archivo contiene tres secciones para los 3 diferentes ambientes en que Rails se ejecuta por defecto:

El ambiente de development (desarrollo) es usado para trabajar en los equipos locales o de desarrollo mientras se programa y se trabaja manualmente con la aplicación.
El ambiente de test (prueba) es usado cuando se ejecutan pruebas automatizadas.
El ambiente de production (producción) es usado para desplegar la aplicación.

Para crear la base de datos, desde la consola escribimos el comando rake db:create.

Este comando crea nuestra base de datos en blanco dentro de la carpeta db.

"Hola Mundo" en Rails

En esta parte cambiaremos la página de inicio de la aplicación por una página programad por nosotros que muestre un mensaje de "Hola Mundo". (¿Por qué un "Hola Mundo"? Revisa este enlace) Para hacer que Rails muestre un mensaje de "Hola Mundo" se necesitan crear al menos una vista y un controlador. Afortunadamente, Rails nos da las facilidades para crear una vista y un controlador con un solo comando. Crearemos un controlador llamado home con una vista llamada inicio. Desde la consola, escribimos el comando rails generate controller home index.

Rails create una serie de archivos por nosotros, incluyendo app/views/home/index.html.erb. Este archivo es una de las vistas de nuestra aplicación y es la plantilla que se usa para mostrar los resultados de la acción index de nuestro controlador home. A continuación, abrimos la vista app/views/home/index.html.erb borramos el contenido y agregamos el siguiente código HTML: <h1>Hola Mundo</h1>.

Ahora que tenemos nuestro controlador y vista generadas, debemos de configurar Rails para que nos muestre el mensaje de Hola Mundo. En este caso, queremos mostrar el mensaje cuando vayamos a la página de inicio de nuestra aplicación en vez de la página por defecto de Rails (es decir, mostrar Hola Mundo cuando vayamos a la dirección http://localhost:3000). Para ello tenemos que eliminar el archivo public/index.html y luego procedemos a indicarle a Rails dónde se encuentra nuestra página de inicio. Entonces, tenemos que editar el archivo config/routes.rb. Este archivo contiene todas las rutas de nuestra aplicación que almacena entradas en un DSL (Domain-Specific languague o Lenguaje de dominio específico) que le dice a Rails cómo conectar las peticiones de los navegadores a un controlador y una acción en particular.

Abrimos el archivo config/routes.rb y encontramos la línea que comienza con root :to y la descomentamos (eliminamos el símbolo #) y escribimos root :to => 'home#index'. Debe verse de la siguiente manera.

Ahora cuando navegamos a la URL de nuestra aplicación en http://localhost:3000 podemos ver que nos muestra el mensaje de Hola Mundo. Recuerda que si detuviste el servidor debes de volver a iniciarlo ejecutando el comando rails server desde la consola de Windows.

Y finalmente ahora Rails nos muestra nuestro mensaje de Hola Mundo. Con esto concluyo esta primera parte de nuestra primera aplicación con Ruby. Recapitulando, en esta primera parte aprendimos a:

Crear un nuevo proyecto en Rails
Explorar la estructura base de un proyecto Rails
Crear una base de datos en blanco
Crear un controlador y una vista
Cambiar la ruta de inicio de nuestra aplicación
Ejecutar y detener el servidor de Rails

Fuente: Ruby on Rails Guides: Getting started

Instalación de la gema mysql2 en Windows

2013-06-14T09:51:00.000-05:00

En esta entrada veremos como instalar correctamente la gema mysql2 en Windows para poder usar la base de datos MySQL en nuestras aplicaciones de Ruby on Rails.

Se va a realizar la instalación para el siguiente entorno de configuración:

Windows 7 o XP
Ruby 1.9.3
Rails 3.2.13

Antes de empezar, ten en cuenta que es necesario haber instalado previamente Ruby y Ruby on Rails. Si deseas saber cómo instalar Ruby y Rails en Windows puedes revisar la entrada Instalación de Ruby on Rails en Windows.

En primer lugar, debemos de descargar el Devkit desde la web oficial de Ruby Installer, como estamos usando Ruby 1.9.3 debemos de descargar el archivo "DevKit-tdm-32-4.5.2-20111229-1559-sfx.exe". Una vez descargado, lo ejecutamos y especificamos la ruta donde se desea que se extraigan los archivos. En mi caso voy a extraerlos en la ruta: C:/Devkit.

Desde la consola de Windows, nos desplazamos hacia la ruta donde se han extraído los archivos y ejecutamos el comando ruby dk.rb init.

Este comando va a generar un archivo llamado config.yml, el cual debemos de editar agregando al final la ruta de donde se ha instalado Ruby en nuestra computadora. En mi caso, como tengo instalado Rails en la ruta G:\Programas\Rails\Ruby1.9.3 el archivo config.yml queda de la siguiente manera.

Guardamos el archivo y desde la ruta donde extrajimos los archivos del Devkit ejecutamos el comando ruby dk.rb install para instalar el Devkit.

Una vez instalado el Devkit, procedemos a descargar el conector MySQL desde la web oficial de desarrolladores de MySQL, y extraemos el contenido del .zip en nuestro directorio de preferencia. Yo lo voy a extraer en la ruta C:/MySQL.

Ahora, procedemos a instalar la gema mysql2 en nuestra computadora, ejecutando el comando gem install mysql2 -- '--with-mysql-lib="c:/MySQL/bin" --with-mysql-include="c:/MySQL/include"'. Debes especificar la ruta donde extrajistes el .zip que descargamos en el paso anterior en las opciones with-mysql-lib y with-mysql-include. (Cambia el comando es si no extrajistes el .zip en la ruta C:/MySQL).

Finalmente, copiamos la DLL libmysql.dll desde la carpeta lib de donde guardamos el conector a la carpeta bin en donde tenemos instalado Rails en nuestra computadora. Como yo guarde el conector en C:/MySQL y Rails en mi computadora se encuentra instalado en G:/Programas/Rails/Ruby1.9.3, tengo que copiar el archivo C:/MySQL/lib/libmysql.dll a la ruta G:/Programas/Rails/Ruby1.9.3/bin. Finalmente, ya tenemos instalada la gema mysql2 en Windows. Ahora podemos crear un proyecto en Rails y configurarlo para que utilice MySQL como base de datos usando la gema mysql2.

Fuente: Maxivak.com

Ruby on Rails: Instalación en Windows

2013-06-11T03:00:00.000-05:00

Uno de los grandes problemas cuando quise aprender hace mucho tiempo atrás era como hacer para instalar Rails en Windows. En esta entrada voy a demostrar lo fácil que es actualmente instalar Rails en entornos Windows usando Rails Installer.

Procederemos a instalar Ruby on Rails en Windows la siguiente configuración:

Windows 7
Ruby 1.9.3
Rails 3.2.13

Visitamos la pagina de Rails Installer y nos desplazamos hacia abajo y elegimos la opción de Windows Downloads: "Windows Ruby 1.9"

Una vez descargado el instalador (aproximadamente 60 MB), lo ejecutamos y seguimos los pasos del instalador para instalar Ruby y Rails en nuestra computadora. No olvidar marcar la opción "Add executables for Ruby, DevKit and Git (if checked above) to the PATH." Si eliges la opción de Instalar Git, al finalizar la instalación debes ingresar tus datos para registrar una cuenta en Github.

Y ya tenemos instalado Rails, para confirmar que se ha instalado correctamente podemos usar los comandos ruby -v y rails -v para verificar la version que se ha instalado en nuestra computadora.

Introducción teórica a Ruby on Rails (RoR)

2013-06-08T23:10:00.000-05:00

Ruby on Rails (RoR o simplemente Rails) es un framework para desarrollar aplicaciones web basado en el lenguaje de programación Ruby. Rails esta diseñado para facilitar la programación de aplicaciones web haciendo suposiciones acerca de lo que un programador necesita para empezar a programar. Te permite escribir menos código y llegar mas lejos que muchos otros lenguajes y/o frameworks. Incluso, hasta algunos programadores expertos en Rails dicen que hace el desarrollo de aplicaciones web mas divertida.

Rails es un software obstinado. Rails asume que hay una "mejor manera" de hacer las cosas, y esta diseñado para hacerlo de esa manera - y en algunos casos, desalentarte a usar alternativas. Si uno aprende "de la forma Rails" (The Rails Way) es probable que descubras un gran aumento de la productividad. Si persistes en llevar las viejas costumbres de otros lenguajes de programación para el desarrollo de aplicaciones Rails, o tratas de utilizar patrones que has aprendido en otros lugares, es probable que tengas una experiencia menos feliz al usar Rails.

La filosofía de Rails incluye muchos principios, aqui cito algunos:

DRY (Don't repeat yourself - No te repitas) - Este principio sugiere que escribir el mismo código una y otra vez no es bueno.
Convention over configuration (Convención sobre configuración) - Significa que Rails asume cosas acerca de lo que quieres hacer y como lo vas a hacer, en vez de requerir que especifiques cada minúsculo detalle de lo que quieres o vas a hacer en una infinidad de archivos de configuración.
REST es el mejor patrón para las aplicaciones web - organizar tu aplicación en torno a recursos y verbos HTTP es la manera mas rápida de desarrollar.

1. La arquitectura MVC

Rails se encuentra basado en el patrón MVC - Model, View, Controller, (Modelo, Vista y Controlador), usualmente llamado simplemente MVC. Algunos beneficios de usar MVC incluyen:

Aislamiento de la lógica del negocio de la interfaz de usuario
Facilita mantener el código bajo el principio de DRY
Hace mas claro donde pertenece cada bloque de código para facilitar el mantenimiento

1.1 Modelo

Un modelo representa la información (datos) de la aplicación y las reglas para manipular estos datos. En el caso de Rails, los modelos son usados generalmente para manejar la interacción con su correspondiente tabla en la base de datos. En la mayoría de los casos, cada table en la base de datos corresponde a un modelo en la aplicación. La mayor parte de la lógica de negocio de la aplicación se concentra en los modelos.

1.2 Vistas

Las vistas representan la interfaz de usuario de la aplicación. En Rails, las vistas usualmente son archivos HTML con código Ruby embebido que realiza tareas asociadas solamente a la presentación de datos. Las vistas tienen a cargo la tarea de proveer de datos al navegador web u otra herramienta que se utilice para hacer peticiones a la aplicación.

1.3 Controlador

Los controladores son el pegamento que une los modelos y las vistas. En Rails, los controladores son responsables de procesar las peticiones de los navegadores web, interrogar a los modelos para obtener información y pasar esta información a las vistas para su presentación.

2. El Modelo REST

REST (Representational State of Transfer - Estado representativo de la transferencia) es la base de la arquitectura REST. En Rails, REST se usa en dos principios:

Usar identificadores de recursos como URLs para representar recursos
Transferir representaciones de estado del recurso entre componentes del sistema

Por ejemplo, si tenemos la siguiente petición HTTP:

DELETE /photos/17

se entiende que se refiere a un recurso llamado photos (fotos) con el identificador (ID) 17, e indica que la acción que se quiere realizar al recurso photos es un un DELETE - (ELIMINAR).

3. Links de Interés

Si quieres saber mas sobre Rails, o la teoría que se ha tocado en esta entrada, aquí te dejo algunos links:

Fuente: Ruby on Rails Guides

POO: El problema de los alumnos

2012-04-22T11:24:00.001-05:00

En esta entrada trataremos sobre la resolución de un problema de programación orientado a objetos: "Defina una clase Alumnos con atributos nrocarnet, nombre y promedio. Luego muestre el mejor y peor alumno y el promedio de todos los alumnos."

La clase Alumno

En primer lugar, creamos una clase Alumno en donde programaremos los atributos de los alumnos que nos pide el problema: numero de carnet, nombre y promedio. No hay que confundirse con la clase Alumnos que nos dice el problema. Esta clase Alumnos se va a encargar de mostrar el mejor alumno, el peor alumno y el promedio de todos los alumnos. Para que la clase Alumnos pueda realizar estas operaciones, debe tener una colección de objetos de tipo alumno que es lo que vamos a definir en el código siguiente.

package Principal;

public class Alumno {
    private int nroCarnet;
    private String nombre;
    private double promedio;
    
    public int getNroCarnet() {
        return nroCarnet;
    }

    public void setNroCarnet(int nroCarnet) {
        this.nroCarnet = nroCarnet;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public double getPromedio() {
        return promedio;
    }

    public void setPromedio(double promedio) {
        this.promedio = promedio;
    }
}

Como podemos observar, definimos los atributos de la clase Alumno y sus métodos get y set respectivamente.

La clase Alumnos

package Main;

import java.util.ArrayList;

public class Alumnos {
    private ArrayList<Alumno> lista;
    
    public Alumnos(){
        this.lista = new ArrayList<Alumno>();
    }
    
    public ArrayList<Alumno> getLista(){
        return this.lista;
    }
    
    public void AgregarAlumno(Alumno alumno){
        this.lista.add(alumno);
    }    
        
    public double getPromedio(){
        double contador = 0.0;
        for (int i = 0; i < this.lista.size(); i++) {
            contador += this.lista.get(i).getPromedio();
        }
        return contador / this.lista.size();
    }
    public Alumno MejorAlumno(){
        Alumno alumno = new Alumno();
        alumno.setPromedio(-1.0);
        for (int i = 0; i < this.lista.size(); i++) {
            if(this.lista.get(i).getPromedio() > alumno.getPromedio()){
                alumno = this.lista.get(i);
            }
        }
        return alumno;
    }
    
    public Alumno PeorAlumno(){
        Alumno alumno = new Alumno();
        alumno.setPromedio(10000.0);
        for (int i = 0; i < this.lista.size(); i++) {
            if(this.lista.get(i).getPromedio() < alumno.getPromedio()){
                alumno = this.lista.get(i);
            }
        }
        return alumno;
    }
}

Como podemos observar, nuestra clase Alumnos contiene una colección de la clase Alumnos. Esta colección se encuentra implementada como un objeto ArrayList (Linea 6) y se inicializa dentro del constructor de la clase (Linea 9). Ademas, si queremos mostrar al usuario todos los alumnos de la clase debemos de implementar su método get para que pueda ser llamado desde Main (Lineas 12-14). Para poder agregar objetos a nuestra colección implementamos el método AgregarAlumno(Lineas 16-18). Finalmente, las operaciones del mejor alumno, el peor alumno y el promedio de los alumnos se implementan en las lineas siguientes (Lineas 20-47)

La clase Main

En nuestra clase principal Main declaramos e inicializamos un objeto Alumnos (Linea 4) y un objeto Alumno (Linea 5), luego creamos nuevos alumnos y los agregamos a la lista de alumnos (Lineas 6-23), luego mostramos todos los alumnos de la lista de alumnos (Lineas 25-32) y finalmente mostramos el resultado de las operaciones de mejor alumno, peor alumno y promedio de los alumnos que nos pide el problema (Lineas 33-39).

package Main;
public class Main {
   public static void main(String[] args) {
        Alumnos listaAlumnos = new Alumnos();
        Alumno alumno = new Alumno();
        alumno.setNombre("Juan Perez");
        alumno.setNroCarnet(001);
        alumno.setPromedio(15.00);
        listaAlumnos.AgregarAlumno(alumno);
        alumno = new Alumno();
        alumno.setNombre("Julio Paz");
        alumno.setNroCarnet(002);
        alumno.setPromedio(09.00);
        listaAlumnos.AgregarAlumno(alumno);
        alumno = new Alumno();
        alumno.setNombre("Maria Ramirez");
        alumno.setNroCarnet(003);
        alumno.setPromedio(13.00);
        listaAlumnos.AgregarAlumno(alumno);
        alumno = new Alumno();
        alumno.setNombre("Diana Martinez");
        alumno.setNroCarnet(004);
        alumno.setPromedio(16.00);
        listaAlumnos.AgregarAlumno(alumno);
        for (int i = 0; i < listaAlumnos.getLista().size(); i++) {
            alumno = listaAlumnos.getLista().get(i);
            System.out.println("Alumno " + (i+1));
            System.out.println("NroCarnet: " + alumno.getNroCarnet());
            System.out.println("Nombre: " + alumno.getNombre());
            System.out.println("Promedio: " + alumno.getPromedio());
            System.out.println("-----------------------------");
        }
        alumno = listaAlumnos.MejorAlumno();
        System.out.println("El mejor alumno es " + alumno.getNombre() + " con promedio " 
                + alumno.getPromedio());
        alumno = listaAlumnos.PeorAlumno();
        System.out.println("El peor alumno es " + alumno.getNombre() + " con promedio " 
                + alumno.getPromedio());
        System.out.println("El promedio de todos los alumnos es de " + listaAlumnos.getPromedio()); 
   }
}

POO: El problema del empleado

2012-04-18T12:30:00.002-05:00

En esta entrada trataremos sobre la resolución de un problema de programación orientado a objetos: "Defina una clase empleado con todos sus atributos y un arreglo con los puestos que ocupa en la empresa. Use get y set." La razón de ser de este problema es darnos cuenta del uso de arreglos cuando programamos la clase Empleado.

La clase Empleado

package Principal;

public final class Empleado {

    private String nombre;
    private String apPaterno;
    private String apMaterno;
    private double sueldo;
    private String[] puestos;
    private int indice;

    public Empleado(String nombre, String apPaterno, String apMaterno, double sueldo, String[] puestos) {
        this.setNombre(nombre);
        this.setApMaterno(apMaterno);
        this.setApPaterno(apPaterno);
        this.setSueldo(sueldo);
        this.puestos = new String[5];
        indice = 0;
        if(puestos.length<= this.getPuestos().length)//Arreglo de menor tamaño del esperado
        {
            for (int i = 0; i < puestos.length; i++) {
                this.setPuesto(puestos[i]);
            }
        }else{//Arreglo de mayor tamaño del esperado
            for (int i = 0; i < this.getPuestos().length; i++) {
                this.setPuesto(puestos[i]);
            }
        }
    }

    public void setPuesto(String puesto) {
        if (indice < this.getPuestos().length) {
            this.puestos[indice] = puesto;
            indice++;
        }
    }
    public String[] getPuestos() {
        return puestos;
    }
    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getApPaterno() {
        return apPaterno;
    }

    public void setApPaterno(String apPaterno) {
        this.apPaterno = apPaterno;
    }

    public String getApMaterno() {
        return apMaterno;
    }

    public void setApMaterno(String apMaterno) {
        this.apMaterno = apMaterno;
    }

    public double getSueldo() {
        return sueldo;
    }

    public void setSueldo(double Sueldo) {
        this.sueldo = Sueldo;
    }
}

Lo más resaltante de la clase es la línea 9 en la que declaramos el arreglo puestos y la línea 17 en la que inicializamos el arreglo dentro del constructor. Las líneas 19 a 28 y las líneas 31 a 36 muestran la forma de realizar operaciones con nuestro arreglo dentro de la clase empleado.

Programación en la clase Main

package Principal;

import java.util.Random;
import java.util.Scanner;


public class Main {

    public static void main(String[] args) {
        
        String[] puestos = new String[3];
        puestos[0] = "Administrador";
        puestos[1] = "Jefe de Area";
        puestos[2] = "Subgerente";
        
        Empleado emp = new Empleado("Juan", "Perez", "Perez", 1500, puestos);
        System.out.println("Datos del empleado");
        System.out.println("Nombre: " + emp.getNombre());
        System.out.println("Apellidos: " + emp.getApPaterno() + " " + emp.getApMaterno());
        System.out.println("Sueldo: " + emp.getSueldo());
        System.out.println("Puestos: ");
        for (int i = 0; i < emp.getPuestos().length; i++) {
            if (emp.getPuestos()[i] != null) {
                System.out.println((i+1) + ") " + emp.getPuestos()[i]);
            }
        }
        
        emp.setPuesto("Jefe Comercial");
        
        System.out.println("\n" + "Nuevos Puestos: ");
        for (int i = 0; i < emp.getPuestos().length; i++) {
            if (emp.getPuestos()[i] != null) {
                System.out.println((i+1) + ") " + emp.getPuestos()[i]);
            }
        }         
    }
}

De manera análoga, en nuestro Main definimos un arreglo en la línea 11 y le asignamos valores en las líneas 12 a 14. Luego, manipulamos arreglos en las líneas 22 a 26 y en las líneas 31 a 35.

Si bien es cierto que el ejercicio está orientado a familiarizarnos con el uso de arreglos, también pudimos haber implementado una lista en vez de usar un arreglo. Para usar listas en Java, podemos programar nuestra propia clase Lista o podemos hacer uso de la clase ArrayList de Java que se encuentra en java.util.

Además, cabe resaltar que nuestra clase empleado tiene un campo Sueldo, que representa el sueldo fijo que gana el empleado en su organización. En la vida real, tenemos este tipo de empleados que ganan un sueldo fijo y se les denomina "empleados a tiempo completo". Pero también tenemos "empleados a tiempo parcial" los cuales se les paga por el número de horas que trabajan. Si quisiéramos modelar estos dos tipos de empleado, deberíamos crear una clase para empleados a tiempo completo y otra para empleados a tiempo parcial.

Resultado de la ejecución

POO: Principio de encapsulamiento

2012-04-15T20:13:00.001-05:00

En la programación orientada a objetos se denomina encapsulamiento al ocultamiento de los "datos" (en realidad, su estado) de un objeto, de tal manera que sólo se puedan cambiar dichos estados mediante las operaciones (métodos) definidas en dicho objeto.

Contenido

Introducción

El encapsulamiento es una simple idea poderosa que provee dos principales beneficios a los desarrolladores de software: la modularidad y el ocultamiento de la información. La modularidad hace que el código fuente (y también el mantenimiento) de un objeto pueda ser escrito independientemente del código fuente de otros objetos. De esta manera, un objeto puede ser transferido alrededor del sistema sin alterar su estado y conducta.

Por otro lado, el ocultamiento de la información hace que un objeto tenga una "interfaz pública" que otros objetos pueden utilizar para comunicarse con él. Esta "interfaz pública" en realidad son los métodos que se programan para cambiar los estados de los "datos" (llamados atributos) de un objeto. Estos métodos también son conocidos como accesores, y dependiendo de su función (establecer u obtener el valor de un atributo de un objeto) se le conocen también como "getters" y "setters" o como "get" y "set".

Encapsulamiento en java

Para ilustrar la programación del principio de encapsulamiento en Java, programaremos una clase Persona con sus atributos: nombre, apellido paterno y apellido paterno.

package Principal;
public class Persona{
    String nombre;
    String apellidoPaterno;
    String apellidoMaterno;
}

Hasta este punto, la clase Persona se encuentra programada, si queremos usar la clase podemos declarar e inicializar un objeto Persona y asignarle valores a sus atributos.

package Principal;

public class Main {

    public static void main(String[] args) {
        Persona persona = new Persona();
        persona.nombre = "Juan";
        persona.apellidoPaterno = "Perez";
        persona.apellidoMaterno = "Perez";
        System.out.println("Hola soy un empleado y mi nombre es " + persona.nombre + " " + persona.apellidoPaterno + " " + persona.apellidoMaterno);
    }
}

Sin embargo, no estamos aplicando el concepto de encapsulamiento. Con el encapsulamiento no se debería tener el acceso directo a los atributos de la clase persona. Nótese que estamos accediendo directamente a los atributos de nuesto objeto persona: persona.nombre, persona.apellidoPaterno y persona.apellidoMaterno.

Ahora, mejoraremos nuestra pequeña clase persona aplicando el encapsulamiento en todos sus atributos implementando métodos para establecer el valor de un atributo, a los cuales nombraremos con el prefijo set; e implementando métodos para devolver el valor de un atributo, a los cuales nombraremos con el prefijo get.

package Principal;
public class Persona{
    private String nombre;
    private String apellidoPaterno;
    private String apellidoMaterno;

    public String getNombre(){
        return this.nombre;
    }

    public String getApellidoPaterno(){
        return this.apellidoPaterno;
    }

    public String getApellidoMaterno(){
        return this.apellidoMaterno;
    }

    public void setNombre(String nombre){
        this.nombre = nombre;
    }

    public void setApellidoPaterno(String apellidoPaterno){
        this.apellidoPaterno = apellidoPaterno;
    }

    public void setApellidoMaterno(String apellidoMaterno){
        this.apellidoMaterno = apellidoMaterno;
    }
}

Aplicando el encapsulamiento, los atributos de la clase Persona se han convertido en inaccesibles para otros objetos (ya que los hemos marcado como privados usando la palabra reservada private). Ahora para poder acceder a dichos atributos deberemos de usar los métodos get y set que programamos anteriormente.

package Principal;

public class Main {

    public static void main(String[] args) {
        Persona persona = new Persona();
        persona.setNombre("Juan");
        persona.setApellidoPaterno("Perez");
        persona.setapellidoMaterno("Perez");
        System.out.println("Hola soy un empleado y mi nombre es " + persona.getNombre() + " " + persona.getApellidoPaterno() + " " + persona.getApellidoMaterno());
    }
}

Encapsulamiento de objetos en Netbeans

El IDE (Entorno integrado de desarrollo) Netbeans ofrece una funcionalidad para realizar el encapsulamiento de objetos de manera automática. Para encapsular los atributos de una clase, abrimos el archivo de la clase a encapsular y damos clic en el menú Refactor/Reestructurar.

En el menú elegimos la opción Encapsulate Fields/Encapsular campos. A continuación nos muestra un cuadro de diálogo con los atributos de la clase, elegimos que atributos deseamos encapsular, especificamos si queremos métodos get o métodos set o ambos, entre otras opciones. Para finalizar damos clic en el botón Refactor/Reestucturar.

Fuente: Conceptos de la Programación Orientada a Objetos (OOP)
Encapsulamiento (informática)

Diferencias entre C++ y Java

2012-04-08T20:01:00.000-05:00

En esta entrada trataremos sobre las diferencias existen entre los lenguajes de programación C/C++ y Java bajo los criterios de orientado a objetos, código de maquina generado, punteros, sobrecarga de funciones y operadores, entre otros.

Orientado a objetos
C++: Se pueden escribir programas orientados a objetos, no orientados a objetos, o una mezcla de ambos.
Java: Puramente orientado a objetos: cualquier función debe pertenecer a alguna clase. La función main es un método estático de la clase principal.

Código de máquina generado
C++: El compilador genera código de máquina para una plataforma concreta.
Java: El compilador genera código de máquina (bytecode) para el procesador JVM. Dicho código debe ser interpretado posteriormente para su ejecucion.

Punteros
C++: Existen punteros con una aritmética bien definida, y entre otras cosas, permiten programador explorar la memoria del computador físico.
Java: No existe el concepto de puntero; los objetos son accedidos mediante referencias (una referencia se puede considerar como el propio identificador del objeto). No existe aritmética de referencias.

Sobrecarga de funciones y operadores
C++: Existen ambos tipos de sobrecarga.
Java: Sólo existe la sobrecarga de funciones (métodos). Los operadores que existen ya vienen sobrecargados por el compilador como por el ejemplo el operador "+" para sumar números o concatenar cadenas.

Objetos
C++: Ningún ancestro común.
Java: Todos los objetos heredan automáticamente de la clase Object.

El Proceso de compilación en Java

2012-04-04T08:01:00.000-05:00

Los programas Java no son ejecutables, es decir que no se compilan como los programas en C o C++. En su lugar, son interpretados por una aplicación conocida como la máquina virtual de Java (JVM). Gracias a ello no tienen porque incluir todo el código y librerías propias de cada sistema.

Previamente el código fuente en Java se tiene que precompilar generando un código (que no es directamente ejecutable) previo conocido como bytecode o J-code. Ese código (generado normalmente en archivos con extensión .class) es el que es ejecutado por la máquina virtual de Java que interpreta las instrucciones de los bytecodes, ejecutando el código de la aplicación. Por esta razón, podemos decir que Java es híbrido, porque es compilado e interpretado a la vez.

El bytecode se puede ejecutar en cualquier plataforma, lo único que se requiere es que esa plataforma posea un intérprete adecuado (la máquina virtual específica para esa plataforma). La máquina virtual de Java, además es un programa muy pequeño y que se distribuye gratuitamente para prácticamente todos los sistemas operativos como Windows, Mac OS y Unix/Linux. Si deseamos poder ejecutar aplicaciones Java en nuestra computadora podemos descargar el Java Runtime Enviroment (JRE), en cambio si deseamos también programar y compilar nuestros propios archivos escritos en Java debemos de descargar el Java Developer Kit (JDK). En el JDK viene incluido el JRE.

En Java la unidad fundamental del código es la clase. Son las clases las que se distribuyen en el formato bytecode de Java y éstas se cargan dinámicamente durante la ejecución del programa Java.

Fuente:

POO: Características de Java

2012-04-02T13:22:00.000-05:00

En esta entrada dejo una presentación sobre las características de Java como lenguaje de programación.

Características de Java on Prezi

Prezi: Una nueva forma de hacer presentaciones

2011-12-26T16:42:00.000-05:00

En esta entrada trataremos sobre Prezi, una herramienta que permite crear presentaciones en Flash de manera rápida e innovadora.

Sobre el licenciamiento, Prezi cuenta 3 tipos de licencia: una gratis y dos pagadas. La versión gratis permite crear presentaciones en Prezi a través de Internet almacenando hasta 100 MB y permite descargar tus presentaciones para reproducirlas sin necesidad de tener una conexión a Internet. Todas tus presentaciones en Prezi creadas con una licencia gratuita son de acceso publico a toda la comunidad Prezi y si lo deseas, puedes hacer que los usuarios puedan guardar una copia de tus presentaciones para ellos mismos. Las versiones pagadas ofrecen almacenamiento a partir de 500 MB y nuevas características como crear Prezis privados, cambiar el logo de Prezi en las presentaciones por el logo de tu elección y crear Prezis sin necesidad de Internet a través de una aplicación de escritorio. Puedes encontrar licencias pagadas desde $59.00 anual.

Les dejo un ejemplo de una presentación en Prezi.

Coca Cola Company on Prezi

Fuente: Prezi

Árbol Genealógico en Prolog

2011-12-18T13:01:00.001-05:00

En esta entrada trataremos sobre la representación de un árbol genealógico en prolog mediante un ejemplo del árbol de la familia Gonzales. Luego, codificaremos los hechos en Prolog, especificando quien es padre de quien y quien es madre de quien, según se representa en el árbol genealógico y a partir de estas relaciones podremos codificar functores que expresen las demás relaciones de parentesco en la familia.

La familia Gonzales

A continuación, presentamos el árbol genealógico de la familia Gonzales (clic en la imagen para agrandar).

Codificación en Prolog

% Hechos
esMadreDe(sara, jorge).
esMadreDe(sara, gonzalo).
esMadreDe(sara, lucia).
esMadreDe(lucia, jose).
esMadreDe(lucha, martin).
esMadreDe(daniela, ana).
esMadreDe(daniela, miguel).
esMadreDe(carmen, dora).
esMadreDe(carmen, enrique).
esPadreDe(manuel, gonzalo).
esPadreDe(manuel, lucia).
esPadreDe(manuel, fernando).
esPadreDe(jorge, martin).
esPadreDe(jorge, francisco).
esPadreDe(gonzalo, ana).
esPadreDe(gonzalo, miguel).
esPadreDe(fernando, dora).
esPadreDe(fernando, enrique).

% Reglas
esAbuelaDe(A,B) :-
 esMadreDe(A, N),
 esMadreDe(N, B).
esAbuelaDe(A,B) :-
 esPadreDe(A, N),
 esPadreDe(N, B).
esAbuelaDe(A,B) :-
 esPadreDe(A, N),
 esMadreDe(N, B).
esAbuelaDe(A,B) :-
 esMadreDe(A, N),
 esPadreDe(N, B).
esNietoDe(A, B) :-
 esAbuelaDe(B, A).
esHermanoDe(A, B) :-
 esMadreDe(N, A),
 esMadreDe(N, B),
 not(A=B).
esHermanoDe(A, B) :-
 esPadreDe(N, A),
 esPadreDe(N, B),
 not(A=B).
esSobrinoDe(A, B) :-
 esHermanoDe(N, A),
 esMadreDe(N, B).
esSobrinoDe(A, B) :-
 esHermanoDe(N, A),
 esPadreDe(N, B).
esTioDe(A, B) :-
 esSobrinoDe(B, A).
esPrimoDe(A, B) :-
 esTioDe(A, N),
 esMadreDe(N, B),
 not(A=B).
esPrimoDe(A, B) :-
 esTioDe(A, N),
 esPadreDe(N, B),
 not(A=B).

Como podemos observar, a partir de los hechos obtenidos del árbol genealógico (relaciones de paternidad "EsPadreDe" y "EsMadreDe", podemos inferir todas las demás relaciones de parentesco como abuelo, primo, tío, nieto, hermano entre otros.

Ejercicios con listas en Scheme

2011-12-15T11:42:00.003-05:00

En esta entrada resolveremos algunos ejercicios con listas en Scheme.

Contenido

Concatenar dos listas

Implemente una funcion que dadas dos listas, devuelva su concatenacion. No utilice la funcion append.

(define concatena (lambda (X Y)
                    (if (null? X)
                        Y
                        (cons (car X) (concatena (cdr X) Y))
                    )
                    ))

Invertir una lista

Hacer una funcion que invierta una lista

(define invierte (lambda (L1 L2)
  (if (null? L1)
   L2
   (invierte (cdr L1) (cons (car L1) L2)
  )
))

Elementos comunes de dos listas

Dada dos listas, devolver una lista con sus elementos comunes.

(define comunes (lambda (L1 L2)
                  (if (null? L1)
                      '()
                      (if (null? (busca (car L1) L2))
                          (comunes (cdr L1) L2)
                          (cons (car L1) (comunes (cdr L1) (cdr L2)))
                      )
                  )
                  ))

(define busca (lambda (x L)
                (if (null? L)
                    '()
                    (if (= (car L) x)
                        (cons x (busca x (cdr L)))
                        (busca x (cdr L))
                    )
                )
                ))

Eliminar un numero de una lista

Elimine un numero de una lista

(define elimina (lambda (L x)
                  (if (null? L)
                      '()
                      (if (= (car L) x)
                          (elimina (cdr L) x)
                          (cons (car L) (elimina (cdr L) x))
                      )
                  )
              ))

Diferencia de dos listas

Hacer un programa que dada dos listas A y B devuelve la diferencia en el sentido de conjuntos (A-B).(A-B) son todos los elementos de A que no tiene B

(define diferencia (lambda (A B)
                     (if (null? A)
                         '()
                         (if (null? (busca (car A) B))
                             (cons (car A) (diferencia (cdr A) B))
                             (diferencia (cdr A) B)
                         )
                     )
                 ))

Intercalar elementos de dos listas

Hacer un programa que dadas dos listas intercale sus elementos.

(define intercala (lambda (A B)
                    (if (AND (null? A) (null? B))
                        '()
                        (if (null? A)
                            (cons (car B) (intercala A (cdr B)))
                            (cons (car A) (intercala B (cdr A)))
                        )
                    )
                ))

Reemplazar elementos en una lista

Dada una lista y dos numeros x e y, Reemplace todos las ocurrencias de x en la lista por y.

(define reemplaza (lambda (L x y)
                    (if (null? L)
                        '()
                        (if(= (car L) x)
                           (cons y (reemplaza (cdr L) x y))
                           (cons (car L) (reemplaza (cdr L) x y))
                        )
                    )
                    ))

Colocar un elemento al final de una lista

Dada una lista y un numero x, colocar x al final de la lista.

(define poninicio (lambda (L y)
                    (if (null? L)
                        (cons y L)
                        (cons (car L) (poninicio (cdr L) y))
                    )
                    ))

Ejemplos de polimorfismo en C#

2011-11-09T10:17:00.003-05:00

En esta entrada trataremos sobre el concepto del polimorfismo y daremos unos ejemplos.

Contenido

El polimorfismo se refiere a la posibilidad de definir múltiples clases con funcionalidad diferente, pero con métodos o propiedades denominados de forma idéntica.

Polimorfismo usando clases

Por ejemplo, tenemos una clase Empleado y otra clase Alumno, las cuales heredan de una clase abstracta Persona que tiene el metodo Saludar. En las clases hijas sobreescribiremos el metodo Saludar devolviendo el nombre de la persona y si es un empleado o un alumno.

namespace notasensistemas.blogspot.com
{
    public abstract class Persona
    {
        public string Nombre { get; set; }

        public abstract string Saludar();
    }
    public class Alumno : Persona
    {
        public Alumno(string nombre)
        {
            this.Nombre = nombre;
        }
        public override string Saludar()
        {
            string saludo = "Hola, mi nombre es " + this.Nombre + " y soy un alumno";
            return saludo;
        }
    }
    public class Empleado : Persona
    {
        public Empleado(string nombre)
        {
            this.Nombre = nombre;
        }
        public override string Saludar()
        {
            string saludo = "Hola, mi nombre es " + this.Nombre + " y soy un empleado";
            return saludo;
        }
    }
}

En vez de tener un arreglo de empleados y otro de alumnos por separado, usaremos el polimorfismo con un solo arreglo de personas, al cual agregaremos un alumno y un empleado para luego iterar y llamar al metodo saludar.

Persona[] personas = new Persona[2];
personas[0] = new Alumno("Jaime Correa");
personas[1] = new Empleado("Juan Perez");
for (int i = 0; i < personas.Length; i++)
{
     Console.WriteLine(personas[i].Saludar());
}

El resultado es el siguiente:

Hola, mi nombre es Jaime Correa y soy un alumno
Hola, mi nombre es Juan Perez y soy un alumno

Como podemos observar, a pesar de que tengamos un unico arreglo de objetos de tipo persona, cuando llamamos al metodo saludar, los objetos se comportan como un objeto de tipo alumno o un objeto de tipo empleado.

Polimorfismo usando interfaces

De la misma manera que en el ejemplo anterior, en vez de usar una clase padre Persona de la cual heredan las clases hijas Empleado y Alumno podemos definir una interfaz IPersona que defina el metodo Despedirse, y que las clases Empleado y Alumno implementen la interfaz IPersona.

public interface IPersona
    {
        String Despedirse();
    }
    public class Alumno : IPersona
    {
        public Alumno(string nombre)
        {
            this.Nombre = nombre;
        }
        public string Despedirse()
        {
            string adios = "El alumno " + this.Nombre + " se despide cordialmente";
            return adios;
        }
    }
    public class Empleado : IPersona
    {
        public Empleado(string nombre)
        {
            this.Nombre = nombre;
        }
        public string Despedirse()
        {
            string adios = "El empleado " + this.Nombre + " se despide cordialmente";
            return adios;
        }
    }

De la misma manera que en el ejemplo anterior, podemos instanciar un arreglo de tipo IPersona, agregar objetos que implementen la interfaz IPersona: un objeto alumno o un objeto empleado, para luego iterar y llamar al metodo Despedirse.

IPersona[] personas = new IPersona[2];
personas[0] = new Alumno("Jaime Correa");
personas[1] = new Empleado("Juan Perez");
for (int i = 0; i < personas.Length; i++)
{
    Console.WriteLine(personas[i].Despedirse());
}

El resultado es el siguiente:

El alumno Jaime Correa se despide cordialmente
El empleado Juan Perez se despide cordialmente

Fuente: Polymorphism

Gliffy: Modela Diagramas en la Web

2011-11-03T11:49:00.002-05:00

Navegando por Internet me encontré con Gliffy, el cual es una herramienta para crear diagramas en Internet. Gliffy ofrece una variedad de diagramas para sus usuarios como diagramas de Venn, diagramas de red, diagramas FODA, organigramas, diagramas de clase, diagramas de procesos, diagramas para esquematizar sitios web entre otros.

No es necesario registrarse o comprar el producto para empezar a modelar y probar el producto, basta con entrar al sitio y puedes empezar a usarlo. Gliffy ofrece diferentes planes y productos. La solución online permite diseñar tus modelos desde la web, eliminando la necesidad de instalar software en tu computadora para diseñar tus modelos.

Gliffy cuenta con planes pagados desde $4.95 al mes ofreciendo 200 MB de espacio para que guardes hasta 200 diagramas en Internet. Alternativamente, ofrece también un plan gratis con 2 MB de espacio y puedes tener hasta 5 diagramas con la restricción de que los diagramas que guardes son de acceso público a todos los usuarios de Gliffy.

Para terminar, les dejo un video en inglés introductorio sobre Gliffy:

Fuente: Gliffy

Tecnicas de caché en C#

2011-10-19T23:29:00.006-05:00

En esta entrada hablaremos sobre como implementar tecnicas de caché en C#.

Segun Wikipedia

"La caché es una memoria más pequeña y rápida, la cual almacena copias de datos ubicados en la memoria principal que se utilizan con más frecuencia.

[...]Cuando se necesita leer o escribir en una ubicación en memoria principal, primero verifica si una copia de los datos está en la caché. Si es así, de inmediato lee o escribe en la memoria caché, que es mucho más rápido que de la lectura o la escritura a la memoria principal"

De este extracto queda claro que la caché es una memoria secundaria cuyo acceso es mas rapido que el de la memoria principal. Sin embargo, hay que tener en cuenta que si bien es cierto que la implementacion del caché trae las ventajas mencionadas anteriormente, tambien trae riesgos a la hora de implementarlo en un ambiente de produccion. Esto es debido a que el caché tambien gasta recursos de memoria y tiempo de procesamiento, y si se hace un abuso del mismo se reduce la performance de nuestras aplicaciones.

Hablando en codigo, una implementacion de caché puede ser tan sencillo como implementar una tabla hash o un diccionario, hasta tan complicado como nuestro ingenio e imaginacion nos puedan llevar. En este ejemplo, presentaremos una clase Persona, y una clase CachePersona la cual se encargara de agregar, actualizar, listar, eliminar y comprobar la existencia de registros de la clase Persona.

Nota: La tecnica de caché presentada es un ejemplo basico de caracter ilustrativo. El proposito de este ejemplo es dar una introduccion acerca de las tecnicas de caché y como se implementan en el desarrollo de aplicativos.

La Clase Persona

public class Persona
    {
        public int Codigo { get; set; }
        public String Nombre { get; set; }
        public String Apellidos { get; set; }
    }

La Clase CachePersona

public class CachePersona
    {
        Dictionary<int, Persona> diccionario;
        public CachePersona()
        {
            diccionario = new Dictionary<int, Persona>();
        }
        public Boolean ExisteEnCache(int Codigo)
        {
            return diccionario.ContainsKey(Codigo);
        }
        public void AgregarAlCache(Persona persona)
        {
            if (!ExisteEnCache(persona.Codigo))
            {
                diccionario.Add(persona.Codigo, persona);
            }
        }
        public Persona[] ListarCache()
        {
            Persona[] personas = new Persona[diccionario.Count];
            int[] codigos = diccionario.Keys.ToArray<int>();
            for (int i = 0; i < codigos.Length; i++)
            {
                Int32 x = codigos[i];
                personas[i] = diccionario[x];
            }
            return personas;
        }
        public void EliminarDelCache(int codigo)
        {
            if (ExisteEnCache(codigo))
                diccionario.Remove(codigo);
        }
        public void VaciarCache()
        {
            diccionario.Clear();
        }
    }

Como podemos observar tenemos la clase Persona que tiene los atributos Codigo, Nombre y Apellidos. Y tenemos la clase CachePersona que maneja el caché de los objetos de tipo Persona. Esta clase internamente contiene un diccionario y expone las operaciones: ExisteEnCache para verificar si un objeto de tipo persona existe en el caché, AgregarAlCache para agregar un nuevo objeto de tipo persona al caché, ListarCache que devuelve todos los objetos de tipo persona que se encuentran en caché, EliminarDelCache que elimina un objeto de tipo persona del caché segun su codigo y VaciarCache para limpiar el caché. Para hacer uso del caché simplemente instanciamos un objeto de tipo CachePersona y hacemos uso de las operaciones de la clase.

Fuentes: Caching: Techniques and Best Practices
Caché (informatica)

Configuracion de VLANs con VTP

2011-10-11T16:37:00.005-05:00

En esta entrada trataremos sobre cómo configurar VLANs en switches Cisco usando el protocolo VTP. Como vimos en la entrada Creacion de VLANs en Switches Cisco podemos implementar muchas VLANs en un switch Cisco, pero ¿qué sucede cuando queremos implementar VLANs pero tenemos más de un switch en nuestra red? La respuesta es que debemos crear las VLANs una por una en cada Switch Cisco de nuestra red. Ahora imagine si tenemos una red con 20 switches: nuestro trabajo sería demasiado extenso y tedioso. Una solución a este problema es usar VTP.

VTP (VLAN Trunk Protocol) es un protocolo propietario de Cisco que reduce la carga administrativa en la configuración de switches Cisco porque solamente configuramos las VLANs en un switch servidor (llamado VTP server) el cual se encargara de distribuir dicha configuracion a todos los demás switches clientes (llamados VTP client) que se encuentren en un mismo dominio administrativo (VTP domain).

En este ejemplo, vamos a configurar 3 switches Cisco usando el protocolo VTP, los cuales se encontrarán en el dominio administrativo "apuntes". El switch S1 va a ser el servidor VTP en el cual configuraremos las VLANs. Este switch servidor se encargará de replicar la configuración de las VLANs a nuestros switches S2 y S3 que son los clientes VTP.

El comando para establecer el dominio administrativo es vtp domain [nombre_dominio] donde [nombre_dominio] es el nombre del dominio administrativo. Para nuestro ejemplo nuestro dominio se llamará "apuntes". El comando para asignar el modo VTP es vtp [modo] donde [modo] es el modo que le vamos a asignar al equipo el cual puede ser server para servidor o client para cliente. Además existe un tercer modo llamado transparent el cual sirve cuando deseamos que algún equipo no implemente el protocolo VTP.

Nota: En otras versiones de switches Cisco el comando para asignar el modo es vtp mode [modo], donde [modo] es el modo que le vamos a asignar al equipo (server, client o transparent).

Contenido

Configuracion de S2

Para el switch S2, configuraremos sus interfaces Fast Ethernet Fa0/1 y Fa0/2 en modo troncal como se ve en el diagrama de red presentado anteriormente y lo configuramos en modo cliente VTP.

Switch>enable
Switch#configure terminal
Switch(config)#hostname S2
S2(config)#interface fa 0/1
S2(config-if)#switchport mode trunk
S2(config-if)#no shutdown
S2(config-if)#exit
S2(config)#interface fa 0/2
S2(config-if)#switchport mode trunk
S2(config-if)#no shutdown
S2(config-if)#exit
S2(config)#exit
S2#vlan database
S2(vlan)#vtp domain apuntes
S2(vlan)#vtp client
S2(vlan)#exit
S2#exit

Configuracion de S3

De manera similar a S2, procedemos a configurar la interfaz Fa0/2 de S3 y a configurarlo en modo cliente VTP.

Switch>enable
Switch#configure terminal
Switch(config)#hostname S3
S3(config)#interface fa 0/2
S3(config-if)#switchport mode trunk
S3(config-if)#no shutdown
S3(config-if)#exit
S3(config)#exit
S3#vlan database
S3(vlan)#vtp domain apuntes
S3(vlan)#vtp client
S3(vlan)#exit
S3#exit

Configuracion de S1

Para S1, configuramos sus interfaz Fa0/1 y lo configuramos en modo servidor VTP.

Switch>enable
Switch#configure terminal
Switch(config)#hostname S1
S1(config)#interface fa 0/1
S1(config-if)#switchport mode trunk
S1(config-if)#no shutdown
S1(config-if)#exit
S1(config)#exit
S1#vlan database
S1(vlan)#vtp domain apuntes
S1(vlan)#vtp server
S1(vlan)#exit
S1#exit

Configurar las VLANs en el servidor VTP

Ahora que tenemos los equipos configurados, procedemos a crear las VLANs en nuestro servidor VTP.

S1>enable
S1#vlan database
S1(vlan)#vlan 10 name ADMINISTRACION
S1(vlan)#vlan 20 name PRODUCCION
S1(vlan)#vlan 30 name APUNTES
S1(vlan)#exit
S1#exit

Y listo, ya tenemos las VLANs creadas en todos nuestros equipos. Para comprobar que las VLANs han sido creadas usamos el comando show vlan en S2 y S3 y podemos observar que se han creado las VLANs que hemos configurado en nuestro servidor VTP S1.

Fuente: Configuring VLAN Trunk Protocol (VTP)

Manejo de los recursos de una aplicacion en Visual Studio

2011-10-06T11:17:00.005-05:00

En esta entrada trataremos sobre como manejar los recursos que necesita una aplicación para su funcionamiento en Visual Studio. Cuando desarrollamos aplicaciones, a veces necesitamos datos que no son código fuente. En Visual Studio se les llama Recursos de Proyecto y pueden ser archivos de texto, audio, video, imágenes, íconos, archivos XML u otros tipos de datos que necesitamos para el funcionamiento de la aplicación que estamos desarrollando.

Contenido

Agregar un recurso al Proyecto

Para agregar un recurso a un proyecto hacemos clic con el botón secundario del mouse en el nodo Propiedades de nuestro proyecto en el Explorador de Soluciones y damos clic en la Opcion Abrir.

Luego, vamos a la pestaña Resources (Recursos) y damos clic en la opción Add Resource (Añadir Recurso), nos aparece un cuadro de diálogo y elegimos el recurso que deseamos añadir.

En este ejemplo, agregaré una imagen en formato GIF llamada blue.gif. Una vez agregado el recurso, se visualiza en la pestaña de recursos.

Acceder a un recurso del proyecto en código

Para acceder a un recurso desde el código simplemente llamamos a Properties.Resources y elegimos el recurso que deseamos usar.

Por ejemplo, diseñamos un formulario el cual contiene un Picture Box.

Y en el código del formulario, asigno la imagen del PictureBox a una imagen de los recursos de mi aplicación. Para este ejemplo, usamos la imagen blue.gif de la sección "Agregar un recurso a un proyecto" de esta entrada.

Si ejecutamos el formulario, podemos ver que el PictureBox muestra la imagen deseada.

Advertencia: Este ejemplo se ha desarrollado usando Visual Studio 2010 Professional. Los pasos presentados en esta entrada pueden variar para otras versiones de Visual Studio

Fuente: Adding and Editing Resources (Visual C#)

Ejercicios en Prolog

2011-10-04T08:38:00.001-05:00

En esta entrada resolveremos algunos ejercicios en Prolog.

Contenido

Dados dos numeros, indique el menor de ellos

Dados dos numeros, devolver su residuo

Dada la funcion residuo y un numero, mostrar los divisores de un numero

Buscar un elemento en una lista

Insertar un elemento al inicio de una lista

Insertar un elemento al final de una lista

Sumar todos los elementos de una lista

Dadas dos listas, determinar si estas son iguales

Dado un numero, devuelva su factorial

Hacer un programa para el calculo del numero fibonacci

Dados dos numeros, indique el menor de ellos

menor(X,Y,Z) :- X>Y, Z is Y.
menor(X,Y,Z) :- Y>X, Z is X.

Z contiene el numero menor entre X e Y.

Dados dos numeros (x e y), devolver el residuo de X/Y

residuo(X,Y,Z) :- X<Y, Z is X.
residuo(X,Y,Z) :- X1 is X-Y, residuo(X1,Y,Z1), Z is Z1.

Z es la variable que contiene el residuo de dividir X/Y.

Dada la funcion residuo y un numero, mostrar los divisores de un numero

divisores(X,Y) :- Y=1.
divisores(X,Y) :- residuo(X,Y,Z), Z=0, writeln(Y,'es divisor de',X), divisores(X,Y-1).
divisores(X,Y) :- divisores(X,Y-1).
residuo(X,Y,Z) :- X<Y, Z is X.
residuo(X,Y,Z) :- X1 is X-Y, residuo(X1,Y,Z1), Z is Z1.
muestraDivisores(X) :- divisores(X,X).

En este ejercicio reutilizamos la funcion residuo del ejercicio anterior, para mostrar todos los divisores de X solo llamamos a la funcion muestraDivisores.

Buscar un elemento en una lista

pertenece(X,[M|N]) :- X=M.
pertenece(X,[M|N]) :- (X,N).

Esta funcion devuelve true o false si la variable X pertenece a la lista.

Insertar un elemento al inicio de una lista

insertaInicio(X,L,Z) :- Z is [X|L].

X es el elemento a insertar, L es la lista y Z es la nueva lista con el elemento X al inicio.

Insertar un elemento al final de una lista

insertaFinal(X,L,Z) :- L=[], Z is [X].
insertaFinal(X,[L|Lr],Z) :- insertaFinal(X,Lr,Z1), Z is [L|Z1].

X es el elemento a insertar al final, L es la lista y Z es la nueva lista con el elemento X al final.

Sumar todos los elementos de una lista

suma([H|T],Y) :- T=[], Y is H.
suma([H|T],Y) :- suma(T,Y1), Y is H+Y1.

[H|T] es la lista, Y devuelve la suma de todos sus elementos.

Dadas dos listas, determinar si estas son iguales

soniguales([M|N],[P|Q]) :- M=P, soniguales(N,Q).
soniguales(M,N) :- M=[], N=[].

Esta funcion devuelve true o false si las listas son iguales o no.

Dado un numero, devuelva su factorial

factorial(N,F) :- N>1, N1 is N-1, factorial(N1,F1), F is N*F1.
factorial(N,F) :- N=1, F is 1.

N es el numero a calcular su factoria y F es el factorial de N.

Hacer un programa para el calculo del numero fibonacci

fibo(X,N) :- X=0, N is 1.
fibo(X,N) :- X=1, N is 1.
fibo(X,N) :- X>1, fibo(X-1,N1), fibo(X-2,N2), N is N1+N2.

N devuelve el numero fibonacci de X.

Recopilacion sobre Enrutamiento en Routers Cisco

2011-10-01T11:06:00.003-05:00

En esta entrada haremos un repaso sobre la implementacion de enrutamiento estatico y el enrutamiento dinamico con RIP y con OSPF.

Como podemos ver en el diagrama, tenemos tres hosts PC1, PC2 y PC3 los cuales se encuentran en redes diferentes. Estos hosts se conectan a los routers R1, R2 y R3. Tambien vemos que R1 y R2 estan conectados mediante la red 1.1.1.0/30 a traves de sus interfaces seriales Se1/0 y que R2 y R3 estan conectados mediante la red 2.2.2.0/30 a traves de sus interfaces seriales Se1/1 y Se1/0 respectivamente. Los detalles de la conexion serial se detallan en la siguiente tabla.

Router	Interfaz	Tipo de Interfaz	Direccion IP
R1	Se1/0	DCE	1.1.1.1/30
R2	Se1/0	DTE	1.1.1.2/30
R2	Se1/1	DCE	2.2.2.1/30
R3	Se1/0	DTE	2.2.2.2/30

En este ejemplo, vamos a configurar los equipos R1, R2 y R3 mediante las tres formas de enrutamiento que hemos visto en las entradas Enrutamiento Estatico en Routers Cisco, Enrutamiento Dinamico con RIP en Routers Cisco y Enrutamiento Dinamico con OSPF en Routers Cisco para que PC1, PC2 y PC3 tengan conectividad entre si.

Contenido

1. Configuracion del enrutamiento estatico en R1, R2 y R3
2. Configuracion del enrutamiento dinamico con RIP en R1, R2 y R3
3. Configuracion del enrutamiento dinamico con OSPF en R1, R2 y R3

Antes de pasar a configurar el enrutamiento en los routers, tenemos que configurar las interfaces fastEthernet y seriales de cada router en la red. Tenga en cuenta que tenemos que usar el comando clock rate en las interfaces de los router que son DCE. A continuacion procederemos a configurar las interfaces de cada router.

Configuracion para R1

Router>enable
Router#configure terminal
Router(config)#hostname R1
R1(config)#interface fastEthernet0/0
R1(config-if)#ip address 192.168.20.1 255.255.255.0
R1(config-if)#no shutdown
R1(config-if)#exit
R1(config)#interface serial 1/0
R1(config-if)#ip address 1.1.1.1 255.255.255.252
R1(config-if)#clock rate 64000
R1(config-if)#no shutdown
R1(config-if)#exit
R1(config)#exit
R1#exit

Configuracion para R2

Router>enable
Router#configure terminal
Router(config)#hostname R2
R2(config)#interface fastEthernet 0/0
R2(config-if)#ip address 192.168.50.1 255.255.255.0
R2(config-if)#no shutdown
R2(config-if)#exit
R2(config)#interface serial 1/0
R2(config-if)#ip address 1.1.1.2 255.255.255.252
R2(config-if)#no shutdown
R2(config-if)#exit
R2(config)#interface serial 1/1
R2(config-if)#ip address 2.2.2.1 255.255.255.252
R2(config-if)#clock rate 64000
R2(config-if)#no shutdown
R2(config-if)#exit
R2(config)#exit
R2#exit

Configuracion para R3

Router>enable
Router#configure terminal
Router(config)#hostname R3
R3(config)#interface fastEthernet0/0
R3(config-if)#ip address 192.168.80.1 255.255.255.0
R3(config-if)#no shutdown
R3(config-if)#exit
R3(config)#interface serial 1/0
R3(config-if)#ip address 2.2.2.2 255.255.255.252
R3(config-if)#no shutdown
R3(config-if)#exit
R3(config)#exit
R3#exit

Hasta este punto hemos configurado los nombres de los equipos, sus interfaces fastEthernet y sus interfaces seriales. Entonces, podemos probar la conectividad entre los routers. En R1, probamos la conectividad con R2 mediante el comando ping 1.1.1.2. En R2, probamos la conectividad con R3 mediante el comando ping 2.2.2.2.

Luego procedemos a la configuracion de la direccion IP, mascara de la red y direccion IP de la puerta de enlace para PC1, PC2 y PC3 como se muestra en el diagrama. Para PC1 su puerta de enlace es 192.168.20.1, para PC2 su puerta de enlace es 192.168.50.1 y para PC3 es 192.168.80.1. Luego, probamos la conectividad de cada host a su puerta de su enlace mediante el comando ping. Por ejemplo, para probar la conectividad de PC1 a su puerta de enlace el comando es ping 192.168.20.1.

Configuracion del enrutamiento estatico en R1, R2 y R3

Una vez que tenemos las interfaces configuradas en R1, R2 y R3 procedemos a configurar el enrutamiento estatico en cada equipo.

Configuracion del enrutamiento estatico para R1

R1>enable
R1#configure terminal
R1(config)#ip route 192.168.50.0 255.255.255.0 1.1.1.2
R1(config)#ip route 192.168.80.0 255.255.255.0 1.1.1.2
R1(config)#exit
R1#exit

Configuracion del enrutamiento estatico para R2

R2>enable
R2#configure terminal
R2(config)#ip route 192.168.20.0 255.255.255.0 1.1.1.1
R2(config)#ip route 192.168.80.0 255.255.255.0 2.2.2.2
R2(config)#exit
R2#exit

Configuracion del enrutamiento estatico para R3

R3>enable
R3#configure terminal
R3(config)#ip route 192.168.50.0 255.255.255.0 2.2.2.1
R3(config)#ip route 192.168.20.0 255.255.255.0 2.2.2.1
R3(config)#exit
R3#exit

Y listo, ya tenemos los routers configurados mediante enrutamiento estatico. Ahora podemos probar la conectividad entre los hosts haciendo ping a sus direcciones IP. Por ejemplo, en PC1 para probar la conectividad con PC3 el comando es ping 192.168.80.3.

Para ver la configuracion del enrutamiento estatico en el equipo usamos el comando show ip route.

Configuracion del enrutamiento dinamico con RIP en R1, R2 y R3

Una vez que tenemos las interfaces configuradas en R1, R2 y R3 procedemos a configurar el enrutamiento dinamico con el protocolo RIP en cada equipo.

Configuracion del enrutamiento dinamico RIP para R1

R1>enable
R1#configure terminal
R1(config)#router rip
R1(config-router)#network 192.168.20.0
R1(config-router)#network 1.0.0.0
R1(config-router)#exit
R1(config)#exit
R1#exit

Configuracion del enrutamiento dinamico RIP para R2

R2>enable
R2#configure terminal
R2(config)#router rip
R2(config-router)#network 192.168.50.0
R2(config-router)#network 1.0.0.0
R2(config-router)#network 2.0.0.0
R2(config-router)#exit
R2(config)#exit
R2#exit

Configuracion del enrutamiento dinamico RIP para R3

R3>enable

R3#configure terminal

R3(config)#router rip

R3(config-router)#network 192.168.80.0

R3(config-router)#network 2.0.0.0

R3(config-router)#exit

R3(config)#exit

R3#exit

Y listo, ya tenemos los routers configurados mediante enrutamiento dinamico con el protocolo RIP. Ahora podemos probar la conectividad entre los hosts haciendo ping a sus direcciones IP. Por ejemplo, en PC1 para probar la conectividad con PC2 el comando es ping 192.168.50.5.

Para ver la configuracion del enrutamiento dinamico en el equipo usamos el comando show ip protocols.

Configuracion del enrutamiento dinamico con OSPF en R1, R2 y R3

Una vez que tenemos las interfaces configuradas en R1, R2 y R3 procedemos a configurar el enrutamiento dinamico con el protocolo OSPF en cada equipo.

Configuracion del enrutamiento dinamico OSPF para R1

R1>enable
R1#configure terminal
R1(config)#router ospf 2
R1(config-router)#network 192.168.20.2 0.0.0.255 area 0
R1(config-router)#network 1.1.1.0 0.0.0.3 area 0
R1(config-router)#exit
R1(config)#exit
R1#exit

Configuracion del enrutamiento dinamico OSPF para R2

R2>enable
R2#configure terminal
R2(config)#router ospf 2
R2(config-router)#network 192.168.50.0 0.0.0.255 area 0
R2(config-router)#network 1.1.1.0 0.0.0.3 area 0
R2(config-router)#network 2.2.2.0 0.0.0.3 area 0
R2(config-router)#exit
R2(config)#exit
R2#exit

Configuracion del enrutamiento dinamico OSPF para R3

R3>enable
R3#configure terminal
R3(config)#router ospf 2
R3(config-router)#network 192.168.80.0 0.0.0.255 area 0
R3(config-router)#network 2.2.2.0 0.0.0.3 area 0
R3(config-router)#exit
R3(config)#exit
R3#exit

Y listo, ya tenemos los routers configurados mediante enrutamiento dinamico con el protocolo OSPF. Ahora podemos probar la conectividad entre los hosts haciendo ping a sus direcciones IP. Por ejemplo, en PC2 para probar la conectividad con PC3 el comando es ping 192.168.80.8.

Para ver la configuracion del enrutamiento dinamico en el equipo usamos el comando show ip protocols.

Fuentes: Internetworking Technology Handbook
Specifying a Next Hop IP Address for Static Routers

Conectividad en VLANs con Switches Cisco

2011-10-01T02:54:00.007-05:00

En esta entrada hablaremos sobre como poder comunicar hosts que pertenecen en diferentes VLANs. En la entrada Creacion de VLANs en Switches Cisco vimos como se crea una VLAN y se asignan las interfaces del equipo a una VLAN en particular. Ahora veremos como podemos interconectar diferentes VLANs para poder tener conectividad en hosts que perteneces a diferentes VLANs.

Como podemos ver en el diagrama, tenemos dos hosts PC1 y PC2 que pertenecen a la VLAN20 y VLAN30 respectivamente y que se conectan al switch S1. El switch S1 se conecta al router R1 y tanto S1 como R1 pertenecen a la VLAN10.

En este ejemplo, vamos a configurar los equipos S1 y R1 para que los hosts PC1 y PC2 que se encuentran en VLANs separadas puedan tener conectividad entre si. Las puertas de enlace para los hosts que pertenezcan a la VLAN10 y VLAN20 se detallan en la siguiente tabla:

VLAN	Puerta de Enlace
VLAN10	192.168.10.1
VLAN20	192.168.20.1
VLAN30	192.168.30.1

Contenido

1. Configuracion del Switch S1
2. Configuracion del Router R1

Configuracion del Switch S1

Como vimos en la entrada Configuracion Basica de Switches y Routers Cisco cambiamos el nombre del host a S1 y le asignamos sus claves de acceso correspondientes (Para este ejemplo no le asignaremos claves de acceso al equipo). Luego, como vimos en la entrada Creacion de VLANs en Switches Cisco procedemos a crear las VLANs de nuestra red: VLAN10, VLAN20 y VLAN30 para despues asignar las interfaces Fa0/2 y Fa0/3 a las VLANs VLAN20 y VLAN30 respectivamente. Finalmente, configuramos la interfaz Fa0/1 la cual es una conexion troncal con R1 y le asignamos la direccion IP a S1 como se muestra en el diagrama. Para asignar la direccion IP a un switch Cisco se usa el comando configure interface vlan [vlan_id] donde [vlan_id] es el ID de la VLAN a la cual queremos que pertenezca la direccion IP que vamos a asignarle al equipo, y seguidamente usamos el comando ip address [direccion] [mascara] donde [direccion] es la direccion IP y [mascara] es la mascara de la red. En nuestro ejemplo asignaremos la direccion IP 192.168.10.2/24 a S1 en la VLAN10.

Switch>enable
Switch#configure terminal
Switch(config)#hostname S1
S1(config)#exit
S1#vlan database
S1(vlan)#vlan 10 name VLAN10
S1(vlan)#vlan 20 name VLAN20
S1(vlan)#vlan 30 name VLAN30
S1(vlan)#exit
S1#configure terminal
S1(config)#interface fastEthernet0/2
S1(config-if)#switchport mode access
S1(config-if)#switchport access vlan 20
S1(config-if)#no shutdown
S1(config-if)#exit
S1(config)#interface fastEthernet0/3
S1(config-if)#switchport mode access
S1(config-if)#switchport access vlan 30
S1(config-if)#no shutdown
S1(config-if)#exit
S1(config)#interface fastEthernet0/1
S1(config-if)#switchport mode trunk
S1(config-if)#no shutdown
S1(config-if)#exit
S1(config)#interface vlan 10
S1(config-if)#ip address 192.168.10.2 255.255.255.0
S1(config-if)#no shutdown
S1(config-if)#exit
S1(config)#exit
S1#exit

Para verificar que las VLANs fueron creadas correctamente y comprobar que las interfaces se asignaron correctamente a las VLANs se usa el comando show vlan, para ver las interfaces troncales del equipo se usa el comando show interface trunk. Debemos de verificar que la interfaz troncal Fa0/1 de S1 permita el acceso de todas nuestras VLANs creadas anteriormente las cuales son 10, 20 y 30.

Configuracion del Router R1

Procedemos a cambiar el nombre del equipo a R1 y procederemos a configurar subinterfaces en el equipo, asignando la direccion IP de la puerta de enlace respectiva para cada VLAN. Estas subinterfaces son las que proporcionan el enrutamiento entre las VLANs. En el diagrama de red de este ejemplo podemos ver que todos los paquetes de las VLANs VLAN10, VLAN20 y VLAN30 llegan a R1 mediante su interfaz Fa0/0. Por tanto crearemos las subinterfaces en la interfaz Fa0/0. Para configurar una subinterfaz simplemente agregamos un punto (.) seguido del ID de la VLAN al comando de configuracion de interfaz que conocemos. Tambien debemos especificar el protocolo de trunking que vamos a usar, ya sea ISL (InterSwitchLink, protocolo propietario de Cisco) o 802.11q (Estandar de la IEEE) mediante el comando encapsulation [protocol] [vlan_id] donde [protocol] es el protocolo de trunking y [vlan_id] es el ID de la VLAN. Por ejemplo, para crear la subinterfaz para la VLAN10 en la interfaz Fa0/0 con el protocolo 802.1q los comandos son configure fastEthernet 0/0.10 y encapsulation dot1q 10.

Router>enable

Router#configure terminal

Router(config)#hostname R1

R1(config)#interface fastEthernet0/0.10

R1(config-if)#encapsulation dot1q 10

R1(config-if)#ip address 192.168.10.1 255.255.255.0

R1(config-if)#no shutdown

R1(config-if)#exit

R1(config)#interface fastEthernet0/0.20

R1(config-if)#encapsulation dot1q 20

R1(config-if)#ip address 192.168.20.1 255.255.255.0

R1(config-if)#no shutdown

R1(config-if)#exit

R1(config)#interface fastEthernet0/0.30

R1(config-if)#encapsulation dot1q 30

R1(config-if)#ip address 192.168.30.1 255.255.255.0

R1(config-if)#no shutdown

R1(config-if)#exit

R1(config)#interface fastEthernet0/0

R1(config-if)#no shutdown
R1(config)#exit
R1#exit

Y listo, ya contamos con la conectividad entre VLANs. Para probar la conectividad entre los hosts PC1 y PC2 solo es necesario configurar la direccion IP del host, la mascara de la red y la direccion IP de la puerta de enlace. Para PC1 que pertenece a la VLAN20 su puerta de enlace es 192.168.20.1 y para PC2 que pertenece a la VLAN30 su puerta de enlace es 192.168.30.1. Y solo queda probar la conectividad realizando el comando ping. Desde PC1 verificamos la conectividad con PC2 mediante el comando ping 192.168.30.3 y desde PC2 verificamos la conectividad con PC1 mediante el comando ping 192.168.20.2.

Fuente: Configuring InterVLAN Routing

Diferencias entre Enrutamiento Estático y Dinámico, Protocolo Vector-Distancia y Estado de Enlace

2011-09-30T09:49:00.006-05:00

En esta entrada tratermos sobre las diferencias existentes entre el enrutamiento estático y el enrutamiento dinámico, y también hablaremos sobre las diferencias entre el protoco vector-distancia y estado de enlace.

Contenido

1. Diferencias entre Enrutamiento Estático y Dinámico
2. Diferencias entre Protocolo Vector-Distancia y Protocolo Estado de Enlace

Para dar una visión general, sabemos que en el tema de enrutamiento tenemos el enrutamiento estático y el enrutamiento dinámico. En el enrutamiento dinámico tenemos dos protocolos: el protocolo vector-distancia y el protocolo estado de enlace. En la práctica, una implementación del protocolo vector-distancia es RIP (Routing Information Protocol) y una implementación del protocolo estado de enlace es OSPF (Open Shortest Path First).

Diferencias entre Enrutamiento Estático y Dinámico

Enrutamiento Estático	Enrutamiento Dinámico
Genera carga administrativa y consume tiempo del administrador de red en redes grandes. El administrador debe configurar el enrutamiento en cada router de la red.	No genera mucha carga administrativa porque los routers aprenden a enrutarse de los demás routers de la red.
El router no comparte su tabla de enrutamiento con los routers vecinos.	El router comparte su tabla de enrutamiento con los routers vecinos.
Los routers no tienen capacidad de reacción ante un fallo en la red.	Los routers tienen capacidad de reacción ante un fallo en la red.

Diferencias entre Protocolo Vector-Distancia y Protocolo Estado de Enlace

Protocolo Vector-Distancia	Protocolo Estado de Enlace
Consume menos memoria y capacidad de procesamiento del router que el protocolo estado de enlace.	Consume más memoria y capacidad de procesamiento del router que el protocolo vector-distancia.
Las actualizaciones de las tablas de enrutamiento se hacen periódicamente, o cuando cambia la topología de la red.	Las actualizaciones de las tablas de enrutamiento son desencadenadas por eventos.
Los routers envían toda su tabla de enrutamiento a los routers vecinos.	Los routers envían solo los cambios de sus tablas de enrutamiento a los routers vecinos.
La convergencia de la red depende del período con que se actualizan las tablas de enrutamiento.	La convergencia de la red es más rápida, dado que ante un cambio, éste se anuncia inmediatamente.

Para ver cómo se configuran los equipos Cisco mediante enrutamiento estático puedes ver la entrada Enrutamiento Estático con Routers Cisco, también te pueden interesar las entradas Enrutamiento Dinámico con RIP en Routers Cisco y Enrutamiento Dinámico con OSPF en Routers Cisco, donde vemos la configuración de equipos Cisco para los protocolos RIP y OPSF respectivamente.

Fuentes: Routing Basics
Internetworking Technology Handbook