Ejemplo Modelo Vista Controlador

Ejemplo Modelo Vista Controlador
En la entrada sobre patrones de Diseo se habla

sobre el patrn MVC, en esta oportunidad vamos explicar un ejemplo
practico donde se aplica este modelo mostrando la forma de
independizar los componentes de nuestro sistema, adems lo
combinaremos con los patrones DAO y VO para facilitar el manejo de
la informacin.
Por cuestiones de tamao no vamos a hacer la aplicacin paso a
paso, pero si se explicar la lgica de la misma, al final se presenta
una opcin de descarga del cdigo fuente donde veremos la
aplicacin en funcionamiento.
El problema.
Se solicita desarrollar un sistema de administracin de usuarios con
un CRUD(Create, Read, Update, Delete) bsico nos advierten que la
aplicacin es un prototipo inicial el cual esta propenso a cambios,
pues an no se tienen definidas las ventanas con las que se va a
trabajar ni la informacin requerida, por le momento se trabajar con
una BD MySql, pero posiblemente se tenga que migrar a otro
sistema gestor....
La solucin.
Se aplica el MVC permitiendo independizar la lgica y la parte visual
del sistema usando para eso un controlador que administra los
procesos sirviendo como puente entre estos.
para la BD se usa MySql, reutilizando la BD creada en el ejemplo

de conexin con Java, el Scritp es el siguiente.
CREATE DATABASE /*!32312 IF NOT EXISTS*/`codejavu` /*!40100 DEFAULT CHARACTER SET lati
1
2
USE `codejavu`;
3
4
/*Table structure for table `persona` */
5
6
7
DROP TABLE IF EXISTS `persona`;
8
9
CREATE TABLE `persona` (
10
ìd` int(10) NOT NULL,
11
`nombre` varchar(30) default NULL,
èdad` int(3) default NULL,
12
`profesion` varchar(30) default NULL,
13
`telefono` decimal(10,0) default NULL,
14
PRIMARY KEY (ìd`)
15
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
16
17
/*Data for the table `persona` */
18
De esta forma se crea la Base de Datos a la que se va a apuntar, la
cual contiene solo una tabla Persona con la que se realizan todas las
operaciones CRUD.
La agrupacin de clases de nuestro sistema es:
Como vemos tenemos la parte visual compuesta por las

clasesVentanaPrincipal, VentanaRegistro, VentanaBuscar,
la lgica de negocio se establece en el modelo el cual se compone por
la clase Logica y Conexin y aplicamos los patrones DAO y VO por
medio de las clases PersonaDao yPersonaVo y por ultimo el
controlador se define en la clase Coordinador, encargada de
establecer todas las relaciones del sistema, la clase Principalprepara
las instancias iniciales del sistema y posteriormente lo ejecuta.
Veamos
como
funciona
el
Patrn:
El
Modelo.
Como se mencion, en el modelo tenemos la lgica de negocio, sern

todas las clases vinculadas con el CRUD a nivel interno, que en
ultimas
es
en
lo
que
gira
nuestro
sistema.
Clase
Logica.
Esta clase permite realizar las operaciones asociadas a

la lgica de negocio como tal, desde ella realizamos las validaciones y
llamados
a
las
operaciones CRUD del
sistema.
En caso de que se requieran procesos adicionales asociados a
la lgica de negocio, aqu ser donde se creen los mtodos para
dichos procesos, por ejemplo el mtodo validarRegistrodetermina si
los datos son correctos y permite registrar la persona en el Dao.
1
2
3
4
5
6
7
8
9
10
11
public void validarRegistro(PersonaVo miPersona) {

PersonaDao miPersonaDao;
/*Valida que solo se ingresen id de 3 digitos*/
if (miPersona.getIdPersona() > 99) {
miPersonaDao = new PersonaDao();
miPersonaDao.registrarPersona(miPersona);
}else {
JOptionPane.showMessageDialog(null,"El documento de la persona debe" +
" ser mas de 3 digitos","Advertencia",JOptionPane.WARNING_MESSAGE);
}
}
Clase
Conexin.
En esta clase tenemos la cadena de conexin con la que

trabajar nuestra aplicacin, en ella se define la base de datos, el
usuario, password y driver de conexin, si por ejemplo en un futuro
se nos pide conectarnos a una base de datos diferente o establecer
un sistema gestor distinto (pero con la misma estructura de tablas y
campos), tan solo modificaremos esta clase y dicho cambio sera
transparente
para
el
resto
del
sistema.
(Tener en cuenta que los datos de login y password corresponden a
los que yo dej por defecto al instalar MySql, es decir login root y sin
contrasea)
1
2
public Conexion() {
3
try{
4
//obtenemos el driver de para mysql
Class.forName("com.mysql.jdbc.Driver");
5
//obtenemos la conexin
6
conn = DriverManager.getConnection(url,login,password);
7
8
if (conn!=null){
9
System.out.println("Coneccin a base de datos "+bd+" OK");
}
10
}
11
catch(SQLException e){
12
System.out.println(e);
13
}catch(ClassNotFoundException e){
14
}catch(Exception e){
15
16
}
17
}
18
19
Clase
PersonaVo.
Al utilizar este tipo de clases, aplicamos

el patrn Value Object o VO (Anteriormente conocidas como DTO
Data Transfer Object) en el que representamos las entidades
(Tablas) de la base de datos, la tabla persona tiene los campos id,
nombre, edad, profesin telfono entonces nuestra clase Vo tendr
estos mismos atributos y de esta manera podremos transportar un
objeto persona con todos estos valores por medio de los
mtodos set y get de cada
atributo.
Este patrn nos facilita enormemente el transporte de la informacin,
evitando
que
se enven gran
cantidad
de parmetros a
un mtodo cuando
queremos
hacer
un
registro
o
actualizacin, tambin en caso de que se modifique la tabla de la BD,
nuestra clase deber ser modificada as como los mtodos que
obtienen la informacin, mas no los mtodos que la transportan.
1
2
3
4
5
6
7
8
9
10
11
12
/**
* @return the idPersona
*/
public Integer getIdPersona() {
return idPersona;
}
/**
* @param idPersona the idPersona to set
*/
public void setIdPersona(Integer idPersona) {
this.idPersona = idPersona;
}
Clase
PersonaDao.
Cuando
utilizamos
estas
clases,
aplicamos
el patrn Data
Access
Object o DAO, bsicamente este patrn consiste en centralizar los
procesos de acceso a la base de datos evitando inconsistencias y
posibles problemticas cuando esto se realiza a lo largo de la
aplicacin.
Con este patrn independizamos la lgica de negocio de la lgica de
acceso a datos obteniendo mayor organizacin y flexibilidad en el
sistema.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void eliminarPersona(String codigo)

{
Conexion conex= new Conexion();
try {
Statement estatuto = conex.getConnection().createStatement();
estatuto.executeUpdate("DELETE FROM persona WHERE id='"+codigo+"'");
JOptionPane.showMessageDialog(null, " Se ha Eliminado" +
" Correctamente","Informacin",JOptionPane.INFORMATION_MESSAGE);
estatuto.close();
conex.desconectar();
} catch (SQLException e) {
System.out.println(e.getMessage());
JOptionPane.showMessageDialog(null, "No se Elimino");
}
La
Vista.
Aqu se define la parte visual del sistema, en la vista estableceremos

todas las ventanas o interfaces grficas de usuario, mediante las
cuales representamos todo el modelo permitiendo la interaccin entre
la
aplicacin
y
el
cliente.
Clase VentanaPrincipal.
Esta clase representa la ventana inicial de la aplicacin, posee

un rea de texto con una pequea descripcin y 2 botones
que darn inicio
a
los
eventos
principales
del
sistema.
se comunica con el modelo mediante la clase coordinador y desde
esta
se
cargan
las
otras
ventanas
de
la
aplicacin.
Clase VentanaRegistro.
Permite el ingreso de informacin a la BD, en ella se evidencian todos

los campos de la tabla Persona y presenta un medio grfico para las
clases PersonaVo yPersonaDao, al ejecutar el evento de registro
se
establece
comunicacin
entre
el
coordinador
y
la
clase Lgica donde se encuentran todas las validaciones y casos para
el
ingreso
de
informacin.
Clase VentanaBuscar.
Esta clase permite realizar las operaciones de Consulta, Actualizacin

y eliminacin de la tabla Persona, igual que la anterior representa la
parte visual del modelo y se ejecutan los eventos para la lgica de los
procesos anteriores, la forma de obtener los datos y como se
le envan parmetros de
consulta
a
la
BD.
El
Controlador.
Esta parte del patrn es la que define la lgica de administracin del

sistema, establece la conexin entre la vista y el modelo.
Clase
Principal.
Esta clase contiene el mtodo main que ejecuta la

aplicacin, el mtodo hace un llamado al mtodo iniciar el cual crea
las instancias de las clases ventanas y la clase Logica estableciendo
las
relaciones
con
la
clase Coordinador.
A cada instancia de las clases se les enva una instancia de la
clase Coordinador, y a la instancia de Coordinador se le enva cada
instancia de las clases, esto por medio de los mtodos set y get
estableciendo las relaciones necesarias y por ultimo se usa la
instancia de la clase VentanaPrincipal para cargarla en pantalla.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private void iniciar() {

/**Se instancian las clases*/
miVentanaPrincipal=new VentanaPrincipal();
miVentanaRegistro=new VentanaRegistro();
miVentanaBuscar= new VentanaBuscar();
miLogica=new Logica();
miCoordinador= new Coordinador();
/**Se establecen las relaciones entre clases*/
miVentanaPrincipal.setCoordinador(miCoordinador);
miVentanaRegistro.setCoordinador(miCoordinador);
miVentanaBuscar.setCoordinador(miCoordinador);
miLogica.setCoordinador(miCoordinador);
/**Se establecen relaciones con la clase coordinador*/
miCoordinador.setMiVentanaPrincipal(miVentanaPrincipal);
miCoordinador.setMiVentanaRegistro(miVentanaRegistro);
miCoordinador.setMiVentanaBuscar(miVentanaBuscar);
miCoordinador.setMiLogica(miLogica);
miVentanaPrincipal.setVisible(true);
}
Clase
el
aplicativo,
Coordinador.
Esta clase contiene toda la lgica de relaciones en

es el puente entre el modelo y las vistas.
Puede contener instancias locales tanto de clases de la vista como de

clases
del
modelo,
estas
instancias
tienen
sus respectivos mtodos set y get permitiendo el flujo de llamados

del
sistema.
Cuando
se
desea
registrar
una
persona
desde
la
claseVentanaRegistro se
hace
un
llamado
al mtodo registrarPersona() de
la
clase
Coordinador,
posteriormente esta clase llama al mtodo ValidarRegistro() de la
clase Logica y esta a su vez realiza las validaciones correspondientes
para determinar si se llama o no al mtodo RegistrarPersona() de
la clase PersonaDao.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public Logica getMiLogica() {

return miLogica;
}
public void setMiLogica(Logica miLogica) {
this.miLogica = miLogica;
}
public void mostrarVentanaRegistro() {
miVentanaRegistro.setVisible(true);
}
public void mostrarVentanaConsulta() {
miVentanaBuscar.setVisible(true);
}
public void registrarPersona(PersonaVo miPersona) {
miLogica.validarRegistro(miPersona);
}
La Aplicacin.
El Sistema esta desarrollado como un

proyecto Eclipse, En la siguiente imagen vemos que se crearon tres
paquetes principales y de esta forma se tiene independiente la parte
de la vista, el modelo y el controlador, el paquete modelo posee los
paquetes conexin dao y vo ya que aunque pertenecen al modelo y
la lgica de negocio debe establecerse tambin su independencia con
respecto a las operaciones, es decir, las clases Vo por ejemplo no
poseen mtodos de operaciones asociadas a la lgica de negocio, tan
solo deben representar las tablas de la BD, entonces en el paquete vo
se agruparn todas las clases equivalente a entidades.
El proyecto tiene los directorios db y conector, estos directorios se
crearon solamente para agregar el script de creacin de la BD y el
mysql connector, este ultimo debe ser agregado al build path para
que el sistema pueda funcionar (sobre el proyecto, clic
derecho/configure
Build
path... ).
Conclusiones.
Como vimos tenemos un proyecto funcional que realiza las

operaciones bsicas del CRUD, y donde todas sus partes se
encuentran separadas por funcionalidades, separando la parte visual
de la lgica de negocio y estableciendo relaciones entre ellas............
en si se desarroll como ejemplo practico, existen validaciones
muy bsicas y procesos simples pero pensado en modo de ejemplo
sin mayor complejidad, tambin se utilizan algunos conceptos vistos
en entradas anteriores como es el caso del manejo de excepciones,

patrones
entre
otros...
Descarga.
En el link de descarga se encuentra el archivo .rar con la aplicacin,
solo
es cuestin de
descomprimir
y abrir con Eclipse pero si
usas NetBeans te interesar esta entrada con un vdeo paso a
paso de como abrirlo en el............ (recuerden que es
gratis.....nada cuesta opinar, compartir o agradecer :))
Y Listo, como se mencion es un ejemplo simple, sin mucha lgica
para aplicar, pero la intencin es dar a conocer un poquito mas claro
como se puede aplicar elMVC, espero que este ejemplo sea de
utilidad..... ;)
Ejemplo Conectando Java con MySql
En esta entrada vamos a tocar uno de los puntos fundamentales en el

desarrollo de software, no vamos a entrar en detalles de que es una
BD, ni los tipos existentes ni como crearlas entre muchos otros temas
en torno a esto, solamente muestro una pequea aplicacin (muy
bsica) donde veremos de forma fcil como conectarnos a una BD
para
consultar
y
registrar
informacin
....adems daremos paso a futuras entradas sobre los Patrones de
Diseo, ya que en esta aplicaremos los Patrones VO (Value Object)
y DAO (Data Access Objetc).
Requisitos.
Ambiente de desarrollo (En este caso Eclipse)
JDK instalado.
MySql Instalado
mysql-connector-java-5.0.8-bin (lo pueden bajar desde aqu)
Conocimientos Basicos de Programacin.
Ganas de Continuar.
En Marcha.
Bueno, vamos a hacer una aplicacin simple, la idea de este tutorial
es ver como conectarnos a MySql desde Java, por eso no nos
preocuparemos tanto en como se presentaran nuestra informacin, ni
los tipos de datos, ni que tan ptimo sea nuestro cdigo,
simplemente vamos a crear una base desde donde podamos trabajar.
La Aplicacin.
El siguiente diagrama muestra la estructura de nuestra aplicacin

(Ojo no es un diagrama de clases completo, es mas usado para dar
claridad al sistema, por eso no nos enfocaremos en asociaciones,
tipos de datos o etc)
Como vemos la aplicacin es bsica, nos conectaremos a una BD

donde tenemos una nica tabla y mediante Java vamos a acceder a
dicha BD para poder registrar y consultar informacin, la idea es
poder registrar y consultar personas, en la aplicacin tendremos un
Men principal con estas opciones.....
La Base de Datos.
Nuestra base de datos solo tendr la tabla persona con los datos
bsicos de registro (si se desea se puede dar otro enfoque a la tabla
o trabajar con muchas mas), el Script para la creacin es el
siguiente:
1
CREATE DATABASE /*!32312 IF NOT EXISTS*/`codejavu` /*!40100 DEFAULT CHARACTER SET lat
2
3
USE `codejavu`;
4
5
/*Table structure for table `persona` */
6
7
DROP TABLE IF EXISTS `persona`;
8
9
CREATE TABLE `persona` (
10
ìd` int(10) NOT NULL,
11
`nombre` varchar(30) default NULL,
12
èdad` int(3) default NULL,
13
`profesion` varchar(30) default NULL,
14
`telefono` decimal(10,0) default NULL,
15
PRIMARY KEY (ìd`)
16
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
17
18
/*Data for the table `persona` */
Empecemos!!!
Para iniciar vamos a crear un proyecto java en Eclipse, por cuestiones
de organizacin crearemos las clases de nuestro diagrama
separndolas por paquetes, esto con el fin de tener nuestro proyecto
mas estructurado y fcil de entender, as.
Como vemos tenemos un paquete por cada clase, en estos

momentos la aplicacin es pequea por lo tanto no nos da problemas
de organizacin, sin embargo a medida que vaya creciendo se hace
importante tener nuestras clases agrupadas facilitando as el trabajo
futuro
y
la
mantenibilidad
de
nuestro
sistema.
Clase
DbConnection.
Esta clase ser nuestra cadena de conexion, aqu definiremos los

parmetros requeridos para conectarnos a la BD creada
anteriormente.
1
package prueba.connection;
import java.sql.*;
3
4
5
6
/**
* Clase que permite conectar con la base de datos
* @author chenao
*
7
8
*/
public class DbConnection {
/**Parametros de conexion*/
10
static String bd = "codejavu";
11
12
13
14
15
16
17
static String login = "root";

static String password = "";
static String url = "jdbc:mysql://localhost/"+bd;
Connection connection = null;
/** Constructor de DbConnection */

public DbConnection() {
18
try{
19
//obtenemos el driver de para mysql
20
Class.forName("com.mysql.jdbc.Driver");
21
//obtenemos la conexin
22
connection = DriverManager.getConnection(url,login,password);
23
if (connection!=null){
24
System.out.println("Conexin a base de datos "+bd+" OK\n");
25
}
26
}
27
catch(SQLException e){
28
29
}catch(ClassNotFoundException e){
30
31
}catch(Exception e){
32
33
34
35
/**Permite retornar la conexin*/
36
public Connection getConnection(){
37
38
return connection;
39
}
40
41
public void desconectar(){
42
connection = null;
43
44
}
}
45
46
En la clase estamos aplicando el manejo de excepciones, tema

tratado en el articulo anterior, vemos como se tiene contemplada la
jerarqua
de
excepciones
pertinente.
Clase
PersonaVO.
Esta clase nos permite dar un manejo mucho mas organizado y

seguro a nuestra informacin, en ella estamos aplicando el
patrn VO (Value Object) con el cual nos aseguramos que los datos
viajen en un solo objeto, evitando no solo el envi de gran cantidad
de parmetros sino tambin un mayor control............Debemos saber
que por cada tabla de nuestra BD se tiene que construir su
equivalente clase VO.
1
package prueba.vo;
2
3
4
/**
* CLase VO con los atributos del campo empleado
* @author chenao
*
*/
public class PersonaVO{
9
10
private Integer idPersona;
11
private String nombrePersona;
12
private Integer edadPersona;
13
14
private String profesionPersona;

private Integer telefonoPersona;
15
16
/**
* @return the idPersona
17
18
*/
public Integer getIdPersona() {
19
20
21
return idPersona;
}
/**
22
* @param idPersona the idPersona to set
23
*/
24
public void setIdPersona(Integer idPersona) {

this.idPersona = idPersona;
25
26
27
/**
* @return the nombrePersona
28
*/
29
30
31
32
public String getNombrePersona() {

return nombrePersona;
}
/**
33
* @param nombrePersona the nombrePersona to set
34
35
*/
public void setNombrePersona(String nombrePersona) {
36
37
this.nombrePersona = nombrePersona;
}
38
/**
39
* @return the edadPersona
40
*/
41
public Integer getEdadPersona() {

return edadPersona;
42
43
44
}
/**
* @param edadPersona the edadPersona to set
45
46
*/
public void setEdadPersona(Integer edadPersona) {
47
this.edadPersona = edadPersona;
48
49
/**
50
* @return the profesionPersona
51
*/
52
public String getProfesionPersona() {

return profesionPersona;
53
54
55
}
/**
* @param profesionPersona the profesionPersona to set
56
57
58
59
60
*/
public void setProfesionPersona(String profesionPersona) {
this.profesionPersona = profesionPersona;
}
/**
61
* @return the telefonoPersona
62
*/
63
public Integer getTelefonoPersona() {
64
return telefonoPersona;
65
66
/**
67
* @param telefonoPersona the telefonoPersona to set
68
69
70
*/
71
public void setTelefonoPersona(Integer telefonoPersona) {
72
this.telefonoPersona = telefonoPersona;
73
74
}
}
75
76
77
Como vemos cada campo de la tabla persona es reflejado en la Clase

PersonaVO,
tambien
aplicamos
un
poco
el
concepto
de Encapsulacin tratado en un articuloanterior mediante la
creacin de metodos setter y getter por cada dato privado.
Clase
PersonaDAO.
Esta clase sera la encargada de gestionar el acceso a los datos, con

ella aplicamos un patrn DAO (Data Access Objetc) no entraremos en
detalle (mas adelante se presentara una entrada sobre este Patrn)
ya que bsicamente necesitamos saber que este patrn nos ensea la
forma de obtener informacin de la BD mediantemtodos CRUD
(Create, Read, Update y Delete), as que por cada tabla de nuestra BD
debemos tener una clase DAO que la represente!!!
1
package prueba.dao;
2
3
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
6
7
import java.sql.Statement;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import prueba.connection.DbConnection;
import prueba.vo.PersonaVO;
10
11
12
/**
* Clase que permite el acceso a la base de datos
13
* @author chenao
14
15
16
17
*/
public class PersonaDAO
{
18
19
/**
20
* Permite registrar un empleado
21
* @param persona
22
*/
23
public void registrarPersona(PersonaVO persona)
24
25
DbConnection conex= new DbConnection();
26
try {
Statement estatuto = conex.getConnection().createStatement();
27
estatuto.executeUpdate("INSERT INTO persona VALUES ('"+persona.getIdPersona()+
28
+persona.getNombrePersona()+"', '"+persona.getEdadPersona()+"', '"
29
+persona.getProfesionPersona()+"', '"+persona.getTelefonoPersona()+"')");
30
JOptionPane.showMessageDialog(null, "Se ha registrado Exitosamente","Informaci
31
estatuto.close();
32
33
34
} catch (SQLException e) {
35
System.out.println(e.getMessage());
36
37
JOptionPane.showMessageDialog(null, "No se Registro la persona");

}
38
39
40
/**
41
* permite consultar el empleado asociado al documento enviado
42
* como parametro
43
44
45
46
47
* @param documento
* @return
*/
public ArrayList< personavo> consultarPersona(int documento) {
ArrayList< personavo> miEmpleado = new ArrayList< personavo>();
48
49
try {
50
PreparedStatement consulta = conex.getConnection().prepareStatement("SELECT *
51
consulta.setInt(1, documento);
52
ResultSet res = consulta.executeQuery();
53
54
if(res.next()){
55
PersonaVO persona= new PersonaVO();
56
persona.setIdPersona(Integer.parseInt(res.getString("id")));
57
persona.setNombrePersona(res.getString("nombre"));
58
persona.setEdadPersona(Integer.parseInt(res.getString("edad")));
59
60
61
62
63
64
persona.setProfesionPersona(res.getString("profesion"));
persona.setTelefonoPersona(Integer.parseInt(res.getString("telefono")));
miEmpleado.add(persona);
}
res.close();
consulta.close();
65
66
67
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "no se pudo consultar la Persona\n"+e);
68
69
70
return miEmpleado;
71
72
73
74
75
76
77
78
/**
* permite consultar la lista de empleados
* @return
*/
public ArrayList< personavo> listaDePersonas() {
ArrayList< personavo> miEmpleado = new ArrayList< personavo>();
79
80
try {
81
PreparedStatement consulta = conex.getConnection().prepareStatement("SELECT *
82
ResultSet res = consulta.executeQuery();
83
while(res.next()){
84
PersonaVO persona= new PersonaVO();
85
persona.setIdPersona(Integer.parseInt(res.getString("id")));
86
persona.setNombrePersona(res.getString("nombre"));
87
persona.setEdadPersona(Integer.parseInt(res.getString("edad")));
persona.setProfesionPersona(res.getString("profesion"));
88
persona.setTelefonoPersona(Integer.parseInt(res.getString("telefono")));
89
miEmpleado.add(persona);
90
91
res.close();
92
consulta.close();
93
94
95
96
97
JOptionPane.showMessageDialog(null, "no se pudo consultar la Persona\n"+e);

}
98
99
100
101
return miEmpleado;
102
103
104
105
106
107
Por cuestiones de tiempo no realizaremos todo el CRUD, tan solo

vamos a trabajar con los mtodos de registro y consulta (Los
mtodos de actualizacin y eliminacin sern una buena tarea en
casa
;)
)
Cada mtodo usa la cadena de conexin creada anteriormente y se
enfoca en una tarea en especifico, adems en cada uno hacemos uso
de un objeto de tipoPersonaVO, mediante el cual asignamos la
informacin de nuestra tablapersona, tanto para el registro como
para
la
consulta
de
informacin.
Clase
Principal.
En esta clase vamos a hacer el llamado a todos los procesos de

nuestra aplicacin, tendremos un men en el cual presentamos todas
las opciones del sistema, as mismo se validaran las entradas del
usuario para evitar posibles inconsistencias y posteriormente se hace
el llamado a la clase DAO que permite ejecutar los procesos de
conexin con la BD.
1
package prueba.principal;
2
3
import java.util.ArrayList;
import javax.swing.JOptionPane;
import prueba.dao.PersonaDAO;
import prueba.vo.PersonaVO;
7
8
9
public class Principal {
10
11
PersonaDAO miPersonaDAO;
12
13
/**
* Mtodo principal, hace el llamado al men donde se
14
* presentan todas las opciones del sistema
15
* @param args
16
17
*/
public static void main(String[] args) {
18
19
Principal miPrincipal = new Principal();
20
21
miPrincipal.verMenu();
}
22
23
/**
24
* Mtodo que permite presentar las opciones del sistema.
25
* solicita el ingreso de un numero y se envia a su
26
* correspondiente proceso
27
*/
28
private void verMenu() {
29
30
31
32
33
34
35
String textoMenu="Men Principal\n\n";

textoMenu+="Ingrese alguna de las opciones del Men
textoMenu+="1. Registrar Persona\n";
textoMenu+="2. Consultar Persona\n";
textoMenu+="3. Ver Lista Personas\n";
textoMenu+="4. Salir.\n\n";
\n";
36
37
try {
38
int seleccion= Integer.parseInt(JOptionPane.showInputDialog(textoMenu));
39
defineSeleccion(seleccion);
40
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null,"Error en el ingreso de Datos, " +
41
"solo se permiten valores nmericos","ERROR",JOptionPane.ERROR_MESSAGE);
42
verMenu();
43
44
JOptionPane.showMessageDialog(null,"Error en el ingreso de Datos, " +
45
"solo se permiten valores nmericos","ERROR",JOptionPane.ERROR_MESSAGE);
46
verMenu();
47
48
}
}
49
50
/**
51
* Permite determinar que accion ejecutar dependiendo del parametro de
52
* ingreso correspondiente a las opciones del sistema
53
* @param seleccion
54
*/
55
private void defineSeleccion(int seleccion) {
56
57
System.out.println("Selecciona "+seleccion);
58
59
60
61
62
63
64
65
switch (seleccion) {
case 1:
registrarPersona();
verMenu();
break;
case 2:
int doc=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero" +
" de documento de la persona"));
66
67
buscarPersona(doc);
68
verMenu();
69
break;
case 3:
70
obtenerRegistros();
71
verMenu();
72
break;
73
case 4:
74
System.exit(0);
75
break;
76
default:
77
JOptionPane.showMessageDialog(null, "Ingrese un " +
78
"numero valido","ADVERTENCIA",JOptionPane.WARNING_MESSAGE);
79
verMenu();
80
break;
}
81
82
83
84
85
86
87
88
89
/**
* Permite solicitar los datos de la persona a registrar, se solicitan mediante
* una ventana de ingreso y se almacenan en un arreglo con toda la informacion u

* para esto un ciclo for, posteriormente estos datos son almacenados en el
* atributo correspondiente del objeto persona para ser enviado al metodo de reg
* en la clase DAO
*/
90
private void registrarPersona() {
91
miPersonaDAO = new PersonaDAO();
92
PersonaVO miPersona=new PersonaVO();
93
94
95
String mensajeIngreso="Ingrese\n\n";
String datosSolicitados[] = {"Documento : ","Nombre : ",
96
"Edad: ","Profesin: ","Telefono: "};
97
98
String datosPersona[] = new String[5];
99
for (int i = 0; i < datosSolicitados.length; i++) {

//solicita el ingreso del dato y se almacena en el arreglo de datosPersona
100
datosPersona[i]=JOptionPane.showInputDialog(null, mensajeIngreso+
101
datosSolicitados[i],"Datos Persona",JOptionPane.INFORMATION_MESSAGE);
102
103
System.out.println(datosSolicitados[i]+datosPersona[i]);
104
105
106
miPersona.setIdPersona(Integer.parseInt(datosPersona[0]));
107
miPersona.setNombrePersona(datosPersona[1]);
108
miPersona.setEdadPersona(Integer.parseInt(datosPersona[2]));
109
miPersona.setProfesionPersona(datosPersona[3]);
110
miPersona.setTelefonoPersona(Integer.parseInt(datosPersona[4]));
111
112
miPersonaDAO.registrarPersona(miPersona);
113
114
115
116
/**
117
* Permite obtener la lista de personas almacenada en la tabla persona
118
* si la lista se encuentra vacia quiere decir que no hay personas registradas
119
120
121
122
123
124
125
* acto seguido se presenta un mensaje en pantalla, sino se imprime la lista de

* todas las personas registradas en la BD
*/
private void obtenerRegistros() {
PersonaVO miPersona;
126
//Se obtiene la lista de personas
127
ArrayList< personavo> listaPersonas = miPersonaDAO.listaDePersonas();
128
//se valida si se obtubo o no informacion
129
if (listaPersonas.size()>0) {
int numeroPersona=0;
130
//se recorre la lista de personas asignandose cada posicion en un objeto perso
131
for (int i = 0; i < listaPersonas.size(); i++) {
132
numeroPersona++;
133
miPersona=listaPersonas.get(i);
134
System.out.println("****************Persona "+numeroPersona+"****************
135
System.out.println("Id Persona: "+miPersona.getIdPersona());
136
System.out.println("Nombre Persona: "+miPersona.getNombrePersona());
137
System.out.println("Edad Persona: "+miPersona.getEdadPersona());
138
System.out.println("Profesin Persona: "+miPersona.getProfesionPersona());
139
System.out.println("Telefono Persona: "+miPersona.getTelefonoPersona());
140
System.out.println("*************************************************\n");
}
141
}else{
142
JOptionPane.showMessageDialog(null,"Actualmente no " +
143
"existen registros de personas","INFORMACIN",JOptionPane.INFORMATION_MESSAG
144
}
145
146
147
148
149
150
/**
* Permite la consulta de una persona en especifico mediante el envio de
* su documento de identidad como parametro, en caso de que no se retorne
151
* informacion se presenta un mensaje en pantalla, sino entonces se imprimen los
152
* datos de la persona encontrada
153
* @param documento
154
*/
155
private void buscarPersona(int documento) {
156
157
158
159
160
161
PersonaVO miPersona;
162
ArrayList< personavo> personasEncontrada = miPersonaDAO.consultarPersona(docume
163
//se valida que se encuentre la persona
164
if (personasEncontrada.size()>0) {
165
//se recorre la lista y se asignan los datos al objeto para imprimir los valor
166
for (int i = 0; i < personasEncontrada.size(); i++) {

miPersona=personasEncontrada.get(i);
167
System.out.println("****************Persona*************************");
168
System.out.println("Id Persona: "+miPersona.getIdPersona());
169
System.out.println("Nombre Persona: "+miPersona.getNombrePersona());
170
System.out.println("Edad Persona: "+miPersona.getEdadPersona());
171
System.out.println("Profesin Persona: "+miPersona.getProfesionPersona());
172
System.out.println("Telefono Persona: "+miPersona.getTelefonoPersona());
173
System.out.println("*************************************************\n");
174
175
}else{
176
JOptionPane.showMessageDialog(null,"El documento ingresado " +
177
"no corresponde a ninguna persona","INFORMACIN",JOptionPane.INFORMATION_MES

}
178
}
179
180
181
182
183
184
Como se ve, tenemos la clase principal dividida en metodos para

cada proceso, eso hace que podamos darle un tratamiento individual
a cada uno, asi en caso de algun error facilmente podremos
identificar en que metodo sucedio....... tambien vemos que en el
mtodo verMenu() validamos por medio de bloques try - catchlos
posibles errores en el ingreso de datos por parte del usuario.
Ejecutando la Aplicacin.
Al ejecutar la aplicacin se presenta el men principal donde

ingresamos las opciones correspondientes, pero hay que tener
presente que previamente debimos haber agregado el mysqlconnector al build path del proyecto, sino nos aparecera algo como
esto :
Para solucionarlo sobre el proyecto damos clic derecho/configure

Build path..., buscamos al jar desde la ruta donde lo descargamos y
damos ok
despus de esto ya tendremos nuestra aplicacin en funcionamiento
Como se mencion al principio, es una aplicacin bsica y no nos

enfocamos en muchos detalles.........tan solo en la logica de conexin
que nos servira como base para futuros desarrollos....
Mas adelante continuaremos con otros temas de interes donde

aplicaremos los conceptos vistos en esta entrada!!!
Tambin te podra Interesar.
Manejo de Excepciones en Java
String Vrs StringBuffer Vrs StringBuilder ?
Comparando Fechas En Java
Integracin Continua, Primeros Pasos Con Jenkins
Leer Archivo Properties en Java
Tutorial Proyecto Web Con Eclipse
Instalacin del servidor de aplicaciones JBoss
Instalacin Apache ANT
Hay algo que quieras anexar o comentar sobre esta entrada?

no dudes en hacerlo.....y si te gust, te invito a
compartir y Suscribirte ingresando al botn "Participar en
este sitio" para darte cuenta de mas entradas como esta ;)
Manejo de Excepciones en Java
Vamos a hablar un poco sobre las Excepciones en Java,

que son?, de donde vienen? y como evitarlas entre, otras.......
debemos tener presente que siempre estamos propensos a
encontrarnos con errores o Excepciones cuando estamos
desarrollando, por eso de la importancia de conocerlas y saber como
tratarlas....
Bsicamente una excepcion es un Objeto descendiente de la

clasejava.lang.Object, podemos pensar en ellas como una condicin
excepcional en nuestro sistema el cual altera la correcta ejecucin del
mismo, las excepciones nos indican que hay algo anmalo,
inconsistente o simplemente un Error, lo cual impide que el sistema
se
ejecute
como
debera
de
ser...
Tal vez se preguntaran si pero Anmalo, inconsistente o Error no es

bsicamente lo mismo?...... podra ser, pero en este enfoque no
necesariamene lo es, ya que lo que vamos a conocer como una
excepcion no siempre es un error (hablando como excepcion en
general, ya que en java una Exception es muy diferente a unError),
muchas veces necesitaremos trabajar con excepciones controladas
para indicar alguna inconsistencia en nuestro sistema que podra
provocar
errores.......
A
modo
de
ejemplo,
podemos
encontrarnos
con
el
famoso NullPointerExceptionel cual nos indica que un objeto se
encuentra vaci, pero esto no es un error ya que nosotros podemos
trabajar con objetos null, entonces veamoslo como si la excepcion
nos dijera "Es un objeto nulo y no se puede efectuar el proceso",
mientras que hay errores como NoClassDefFoundError el cual nos
indica que la maquina virtual de Java (JVM) no puede encontrar una
clase que necesita, debido a por ejemplo que no encuentra un .class,
esto
si
se
maneja
como
un
error
en
java
Para hacer mas claridad sobre el tema veamos la Jerarqua de
Excepciones de Java (puede que no se encuentren algunas
excepciones, pero se contemplan las mas comunes)
Jerarqua de excepciones
Vemos que se tiene un claro rbol de herencia mediante el cual se

pueden definir las categoras de Excepciones o de Error que se puede
dar en el sistema.
La importancia de Prever!!!
Cuando se esta programando debemos tener claro que nuestro

cdigo no es perfecto, as tengamos mucha experiencia en desarrollo
siempre esta la posibilidad de que algo falle, sea por nuestro cdigo o
por otros factores, por eso de la importancia de contemplar todo
desde antes, posibles fallos o lo que pueda afectar el sistema.
Veamos un ejemplo Simple:
private void metodoDividir(int dividendo, int divisor){
2
3
String resultado+=dividendo/divisor;
System.out.println(resultado);
5
6
el metodoDividir(int, int) tericamente esta bien, claro, a simple

vista si tenemos : dividendo = 4 y divisor = 2 pues el resultado
es 2 ......bsico....... pero y si el divisor es 0? pues con ese caso
puntual
el
resultado
seria
el
siguiente.
Vemos
que
nos
indican
que
se
produjo
una ArithmeticException debido a una divisin por cero, adems se
muestra cual fue la traza del error pasando por el mtodo main hasta
el metodoDividir().
La anterior es una Excepcion simple, algo que se supone no debera

pasar, es obvio, no se puede dividir por cero, o no?.........pues
no, en programacin no podemos asumir ni pensar as, ya que
muchas veces nos olvidamos de las cosas obvias y las pasamos por
alto, el problema es que eso tan obvio puede detener toda la
ejecucin
del
programa.
Trabajando con try - catch - finally
con los bloques Try - Catch podemos capturar y procesar una

posible excepcion, evitando que el sistema se detenga sin necesidad
cuando el motivo de esto puede ser corregido facilmente, la
estructura bsica es la siguiente.
1
try {
2
3
//Bloque de cdigo que vamos a procesar

} catch(excepcion) {
4
5
//Tratamiento que se le da a la posible excepcin

} finally {
//Bloque de cdigo que se ejecutar despues del try o del catch
6
7
Apliquemos esto a nuestro ejemplo anterior...

1
2
private void metodoDividir(int dividendo, int divisor){

String resultado="";
try {
resultado+=dividendo/divisor;
}catch (Exception e) {
resultado="Se intent dividir por cero";
JOptionPane.showMessageDialog(null,"Error: No se puede dividir por cero ",

"Advertencia",JOptionPane.WARNING_MESSAGE);
8
}
finally{
10
System.out.println("Termino el proceso : el resultado es = "+resultado);
11
}
12
13
Como vimos aplicamos la estructura de los bloques y de esta manera

nos aseguramos que la excepcin anterior fue controlada evitando
que el sistema se detenga, en el catch podemos hacer el proceso
que consideremos conveniente, ya sea solo informar del error o
solicitar
nuevos
parmetros
de
entrada.
la salida es la siguiente:
Algunas
Consideraciones.
Veamos un poco mas lo que debemos tener en cuenta cuando

usamos
estos
bloques:
try : Aqu vamos a escribir todo el bloque de cdigo que
posiblemente llegue a lanzar unas excepcin la cual queremos
manejar, aqu va tanto el cdigo como llamados a mtodos que
puedan
arrojar
la
excepcin.
En este bloque solo se detectara la primera excepcion lanzada, hay
que tener en cuenta que por cada try se debe especificar un catch
y/o
un
finally.
catch : en caso de que en el try se encuentre alguna excepcin, se
ingresara automaticamente al bloque catch donde se encontrara el
cdigo o proceso que queremos realizar para controlar la excepcin.
Se pueden especificar cualquier cantidad de catch de ser necesario,
estos deben ser ubicados despus del try y antes del finally (en caso
de que este ultimo se especifique), cada catch que se ponga debe
manejar una excepcion diferente (no se puede repetir) y el orden de
estos depende de la jerarqua de herencia que se tenga, ingresando
al primer catch que pueda suplir la necesidad a corregir, por ejemplo.
1
2
3
try {
//Sentencias con posibles errores;
} catch(InterruptedException e){
4
5
//manejo de la exepcion
} catch(IOException e){
} catch(Exception e){
Si se genera una excepcin en el try, se valida a cual de los 3 catch

se ingresa, dependiendo si InterruptedException puede controlarlo se
ingresa a esa, sino entonces a IOException o si no a la superClase
que seria Exception (ver la jerarqua de herencia anterior).
En el ejemplo que del metodoDividir() trabajamos directamente con
Exception e, de esta forma nos aseguramos que capture cualquier
excepcin, sin embargo se recomienda usar la jerarqua en los catch
para
poderle
dar
un
mejor
manejo.
finally : Este bloque es opcional, lo podremos si queremos ejecutar
otro proceso despus del try o el catch, es decir, siempre se ejecutara
sin importar que se encuentre o no una excepcin.
Conclusiones.
Esta entrada es un abrebocas de lo que son el manejo de
excepciones, ya que un solo post no es suficiente para todo lo que
tiene que ver con ellas, quedan pendiente definir aspectos
como checked y unchecked (ya que aqu esto se trabajo de forma
muy general) o la forma de crear nuestras propias excepciones,
propagacin, clausulas throws entre otras.
En general vimos la importancia de controlar excepciones ya que eso
hace parte de la seguridad y calidad de nuestros desarrollos, mas
adelante se irn vinculando en otros post el uso de las mismas.........
Conceptos Bsicos de Programacin Orientada a

Objetos
En esta entrada veremos algunos conceptos de la
programacin
orientada
a
Objetos
(POO)...............................................
Muchas veces cuando empezamos a trabajar con lenguajes de
programacin nos dicen que son orientados a Objetos y nos dan la
teora del"porqu" pero puede que al trabajar con ellos en la
practica no sepamos interpretarlo desconociendo el "como", y
entonces seguimos desarrollando por simple inercia porque as fue
que aprendimos pero tal vez no de la forma mas ptima.
Vamos a ver algunos conceptos de POO de forma general, mas
adelante trabajaremos estos conceptos en casos prcticos para ver su
aplicacin...... Empecemos!!!
Programacin OO.
La programacin orientada a Objetos bsicamente define una serie
de conceptos y tcnicas de programacin para representar acciones o
cosas de la vida real basada en objetos, a diferencia de otras formas
de programacin como por ejemplo la estructurada, con la POO
trabajamos de manera distinta vinculando diferentes conceptos tales
como clases, objetos, mtodos, propiedades, estados, herencia,
encapsulacin entre otros, generando cada vez interrelaciones en
nuestro desarrollo en pro del funcionamiento del sistema principal,
definiendo el programa como un conjunto de estos objetos
relacionados
entre
si.
Veamos algunos de los conceptos principales.....
Clases.
Las clases son uno de los principales componentes de un lenguaje de
programacin, pues en ellas ocurren todos los procesos lgicos
requeridos para un sistema, en si podemos definirlas como
estructuras que representan objetos del mundo real, tomando como
objetos a personas, lugares o cosas, en general las clases poseen
propiedades, comportamientos y relaciones con otras clases del
sistema. (Ver Ejemplo...)
una clase se compone por tres partes fundamentales:
Nombre :
Contiene
el
Nombre
de
la
Clase.
Atributos : Representan las propiedades que caracterizan la clase.
Mtodos : Representan el comportamiento u operaciones, la forma
como interacta la clase con su entorno.
En java se representa as :
/**Principal define el nombre de la Clase*/
3
4
public String atributo="Esto es un atributo";
5
6
7
/**Esto es un mtodo, donde se definen las operaciones*/

public void metodo(){
/**aqui van las sentencias que definen
8
9
10
* el comportamiento del mtodo*/

}
11
Objeto.
Los objetos representan una entidad concreta o abstracta del mundo
real, en programacin bsicamente se le conoce como la instancia de
una clase en si es lo que da el sentido a estas.
Al igual que las clases se componen de tres partes fundamentales:
Estado: Representa los atributos o caractersticas con valores
concretos del objeto. Comportamiento : Se define por los mtodos
u operaciones que se pueden realizar con el. Identidad : Es la
propiedad nica que representa al objeto y lo diferencia del resto.
en la imagen, los moldes representan las clases,

mientras que las galletas obtenidas de estos moldes representan los
objetos instancias de estas clases, por ejemplo atributos del objeto
galleta
podra
ser
sabor,
color,
tamao
etc......
En java se representa creando una instancia de la clase por medio de
la palabra new al hacer eso creamos el objeto de la clase y podemos
hacer uso de los mtodos o atributos de esta (dependiendo de la
visibilidad de los mismos ) por medio de un punto (.) as:
1
2
/**Creamos el objeto como instancia de la clase Principal*/

Principal miObjeto= new Principal();
miObjeto.atributo="Este es el nuevo valor del atributo para el objeto";
miObjeto.metodo();
Herencia.
La herencia en java representa lo que conocemos de herencia en el

mundo
real,
bsicamente
mediante
esta
obtenemos
las
caractersticas o rasgos comunes de nuestros padres o abuelos, en
java es el mismo enfoque permitiendo la creacin de nuevas clases
basadas en clases ya existentes, con las cuales podemos obtener las
caractersticas de las clases padres, heredando campos, atributos,
mtodos
o
funcionalidades.
En Java solo se puede heredar de una sola clase padre y se
representa mediante la palabra extends (Ver Ejemplo...)
public class Animal{

public String tamao;
2
3
public void comer(){
/**Comportamiento.....*/
5
}
6
7
8
class Perro extends Animal{
9
10
public int dientes;
11
12
public void correr(){
13
14
15
16
}
}
17
class Paloma extends Animal{
18
19
public int plumas;
20
21
public void volar(){
22
23
24
}
}
25
Encapsulamiento.
Este concepto es uno de los mas importantes en trminos de
seguridad dentro de nuestra aplicacin, la encapsulacin es la forma
de proteger nuestros datos dentro del sistema, estableciendo
bsicamente los permisos o niveles de visibilidad o acceso de
nuestros
datos
Se
representa
por
niveles
Pblico: Se puede acceder a todos los atributos o

mtodos de la clase. Protegido: Se puede acceder a los atributos o
mtodos solo en la misma jerarqua de herencia. Privado: Solo se
puede acceder a los atributos o mtodos de la clase en la que se
encuentran.
con la Encapsulacin mantenemos nuestros datos seguros, ya que
podemos evitar que por ejemplo se hagan modificaciones al estado o
comportamiento de un objeto desde una clase externa, una buena
practica es trabajar con mtodos setter y getter que permiten
manipular
nuestros
datos
de
forma
segura.
en Java lo representamos as:

1
2
public class Principal{
public String atributo1;
private String atributo2;
protected String atributo3;
6
7
/**Mtodos Set y Get para trabajar con las variables*/
8
9
public String getAtributo2() {
10
return atributo2;
11
12
13
public void setAtributo2(String atributo2) {

this.atributo2 = atributo2;
14
15
16
17
Clases
Abstractas.
La abstraccin permite resaltar la parte mas representativa de algo,

ignorando
detalles
para
centrarse
en
lo
principal.
La imagen es muy fcil de identificar, con base a ella podemos crear
una clase persona, o la
clase hombre, humano entre otras, pero obviamente

vemos que la imagen no tiene elementos como ojos, nariz, boca,
rostro en general, ni dedos, pies, manos o cuello....... pero entonces
porque decimos que es una persona?.........Precisamente aqu
estamos aplicando el concepto de abstraccin, ya que nos fijamos en
lo mas representativo de algo, en este caso vemos que se tiene una
cabeza, tronco, brazos y pies, con esto es suficiente para saber que
es una persona sin fijarnos en los detalles mencionados
anteriormente.
Las clases abstractas permiten crear mtodos generales con un
comportamiento comn para otras clases concretas sin importar sus
caractersticas ni el comportamiento que usen para dichos mtodos.
La Abstraccin en java solo tiene lgica mediante la Herencia, ya que
una clase abstracta posee al menos un mtodo abstracto el cual no
tiene implementacin, el comportamiento de estos mtodos lo
definen
las
clases
concretas
que
lo
hereden.
Podemos usarlos cuando existan varias clases con caractersticas o
acciones
comunes
pero
con
diferentes
comportamientos..............mediante el uso de la herencia y
componentes abstractos hacemos mas ptima y organizada nuestra
aplicacin. (hay que tener en cuenta que a diferencia de las clases
concretas, las clases abstractas no se pueden instanciar). (Ver
Ejemplo...)
En Java representamos
reservada abstract,
1
2
3
4
5
la
abstraccin
mediante
public abstract class Principal{
/**Mtodo Abstracto sin implementacin*/

public abstract void metodoAbstracto();
la
palabra
as:
7
8
class subClase extends Principal{
9
10
@Override
11
public void metodoAbstracto() {

/**Implementacin definida por la clase concreta*/
12
}
13
14
15
Interfaces.
Las interfaces son el mecanismo que utiliza Java para

simular la herencia mltiple, como mencionamos en Java solo se
puede extender de una sola clase, mediante el uso de interfaces esto
se puede simular ya que el lenguaje permite implementar el numero
de
interfaces
que
necesitemos,
bsicamente
son
clases
completamente abstractas, es comn relacionarlas con un contrato
en el que se define que se debe hacer, as cada clase concreta que
implemente una interfaz esta obligada a implementar todos los
mtodos que la compongan.
las interfaces definen lo que la clase que la implemente deber hacer,
mas
no
la
forma
como
lo
har.
al decir que las interfaces son clases completamente abstractas
significa que todos sus mtodos lo son y por ende no poseen
implementacin,
no
requieren
el
uso
de
la
palabra
reservada abstract, ya que al ser completamente abstracta todo
dentro de ella lo es, al igual que las clases abstractas la
implementacin de los mtodos depende de las clases concretas que
las
usen.
Se debe tener en cuenta que toda variable definida en una

interfaz automticamente se convierte en una constante, adems
tampoco se puede instanciar una interfaz..... (Ver Ejemplo...)
En java se representan con la palabra interface y se usan con la
palabraimplements as:
1
2
interface InterfacePrincipal {
public void metodoAbstracto();
4
5
public String otroMetodoAbstracto();
6
7
8
9
public class Principal implements InterfacePrincipal{
10
11
public void metodoAbstracto() {
12
13
14
15
public String otroMetodoAbstracto() {
16
17
return "retorno";
}
18
19
Polimorfismo.
Este tal vez sea uno de los conceptos de la programacin orientada a

objetos mas usados pero muchas veces sin saber que se aplica ya
que el concepto inicialmente puede ser un poco confuso, bsicamente
mediante el polimorfismo programamos de forma general en lugar de
hacerlo de forma especifica, se usa cuando se trabajen con la
herencia y objetos de caractersticas comunes los cuales comparten
la misma superClase y rbol jerrquico, al trabajar con este concepto
optimizamos y simplificamos en gran medida nuestro trabajo.
bsicamente podemos definirlo como la capacidad que tienen los

objetos de comportarse de mltiples formas sin olvidar que para esto
se requiere de la herencia, en si consiste en hacer referencia a
objetos de una clase que puedan tomar comportamientos de objetos
descendientes
de
esta.
con el polimorfismo usamos la generalizacin olvidando los detalles

concretos de los objetos para centrarnos en un punto en comn
mediante
una
clase
padre.
Tomando como ejemplo la imagen anterior, podemos decir que un
objeto de la clase FiguraGeometrica puede usarse para referirse a
cualquier
objeto
de
cualquier subClase de FiguraGeometrica..............
en
otras
palabras una figura geomtrica puede ser un cuadro, un tringulo, un
cuadrado o cualquier figura que en trminos generales sea
geomtrica......
(Ejemplo1)
(Ejemplo2)
Veamos
1
2
3
4
este
proceso
class FiguraGeometrica{
como
se
representa
en
Java.
5
6
class Cuadrado extends FiguraGeometrica {
7
8
9
10
11
12
13
class Triangulo extends FiguraGeometrica {
class Circulo extends FiguraGeometrica{
14
15
16
17
public class Principal{
18
19
public void metodo(){
20
/**Puedo crear objetos concretos*/
21
FiguraGeometrica miFiguraGeometrica = new FiguraGeometrica();
22
Cuadrado miCuadro=new Cuadrado();
23
24
/**Puedo crear objetos polimorficos*/
25
miFiguraGeometrica=miCuadro;
26
27
/**Objeto Cuadrado de tipo FiguraGeometrica*/
28
FiguraGeometrica miCuadrado= new Cuadrado();

/**Objeto Circulo de tipo FiguraGeometrica*/
29
FiguraGeometrica miCirculo=new Circulo();
30
/**Objeto Triangulo de tipo FiguraGeometrica*/
31
FiguraGeometrica miTriangulo=new Triangulo();
32
33
34
}
}
Como vemos en el ejemplo la clase FiguraGeometrica puede

convertirse en cualquier figura que se encuentra en su jerarqua de
Herencia pudiendo utilizar las propiedades que compartan entre ellas,
hay que tener presente que solo se permite el polimorfismo de clases
padre a clases hija mas no al contrario, mas adelante explicaremos
este
concepto
en
detalle...
Hasta aqu vimos algunos de los principales conceptos de la

programacin Orientada a Objetos, en futuras entradas trabajaremos
otros ejemplos y aplicaciones, ya que cada concepto posee sus
restricciones con respecto al proceso de desarrollo.
String Vrs StringBuffer Vrs StringBuilder ?
Esta entrada hace parte de algunas enfocadas a repasos o

conceptos
de
Java,
en
esta
ocasin
trabajaremos
con
las
Clases String, StringBuffer yStringBuilder las cuales permiten el trabajo con
cadenas de caracteres, a continuacin veremos algunos ejemplos bsicos con
estas Clases y sus mtodos principales y mas adelante las compararemos a
nivel de rendimiento....
La Clase String.
Es comn que se confundan los String con tipos de datos primitivos como un
int o un double pero eso es incorrecto ya que cuando decimos que trabajamos
con una variable String en realidad estamos trabajando con un Objeto y al
momento de declararlo lo que hacemos es crear instancias del mismo.
Algo que debemos tener claro es que esta clase esta enfocada a trabajar con
cadenas de caracteres constantes entonces cuando definimos un objeto String
este ser inmutable, es decir que dicho objeto no puede cambiar, si
modificamos nuestro String inicial, en realidad lo que hacemos es crear un
nuevo objeto de tipo String......
Para crear Objetos de la clase String se puede realizar de 2 formas, mediante

su constructor o a partir de cadenas constantes o literales:
Ej:
String
cadena1
=
String cadena2 = new String("CoDejaVu");
"CoDejaVu";
cualquiera de las 2 formas anteriores es valida, sin embargo la primera es mas

efectiva en cuestiones de rendimiento (aunque esto con un solo objeto no es
tan relevante) ya que en la segunda se hace un doble llamado al constructor de
la Clase, mientras que en la primera se hace implcito y directo....
Algunos Mtodos de la Clase String
charAt(int) : Permite retornar un caracter del String dependiendo del ndice

enviado como parmetro.
indexOf(String) : Permite retornar el ndice desde donde inicia la cadena
enviada
como
parametro.
length() : Retorna el tamao basado en la cantidad de caracteres que posee la
cadena.
replace(Char,Char) : Busca en la cadena inicial donde se encuentre el
carcter o cadena enviada en el segundo parmetro y la reemplaza por el
primero.
toUpperCase() :
Convierte
toda
la
cadena
en
maysculas.
toLowerCase() :
Convierte
toda
la
cadena
en
minsculas.
trim() : Elimina los espacios en blanco al inicio y final de la cadena.
concat(String) : Concatena el String enviado como parmetro a la cadena
original (este metodo tiene su equivalente al usar el operador +)
substring(int) : Elimina la cadena desde la posicin 0 hasta la enviada por
parmetro
-1
substring(int,int) : Elimina la cadena desde la posicin del primer parmetro
hasta
la
posicin
del
segundo.
equalsIgnoreCase(String) : Indica si dos cadenas son iguales, sin tener en
cuenta
las maysculas.
Existen muchos mas mtodos de la clase String, sin embargo estos son
algunos a mi parecer mas importantes (Necesitaramos muchas mas entradas
para hablar solo del String :S ), ahora veamos como funcionan, para esto
creamos el siguiente mtodo...
1
2
private void metodosString() {

String cadena1=" Esto Es Un String ";
3
4
/**Imprime la cadena original*/
System.out.println("Cadena Original = "+cadena1);
/**retorna la letra s (cuenta tomando el primer caracter como 0 )*/
System.out.println("Usando charAt(2) = "+cadena1.charAt(2));
/**retorna la posicion 9 (cuenta tomando el primer caracter como 0 )*/
System.out.println("Usando indexOf(\"Un\") = "+cadena1.indexOf("Un"));
10
/**retorna el tamao 19 */
11
12
13
14
15
16
System.out.println("Usando length() = "+cadena1.length());

/**reemplaza la cadena "un" por la cadena "xxx"*/
System.out.println("Usando replace(\"Un\", \"xxx\") = "+cadena1.replace("Un", "

/**convierte la cadena en mayusculas*/
System.out.println("Usando toUpperCase() = "+cadena1.toUpperCase());
/**convierte en minusculas*/
System.out.println("Usando toLowerCase() = "+cadena1.toLowerCase());
17
/**Elimina los espacios en blanco al principio y final de la cadena*/
18
System.out.println("Usando trim() = "+cadena1.trim());
19
/**Concatena al String el valor enviado*/
20
System.out.println("Usando concat(\" En CoDejaVu\") = "+cadena1.concat("En CoDe
21
/**elimina la cadena de la posicion 0 a la 5*/
22
System.out.println("Usando substring(6) = "+cadena1.substring(6));
23
/**elimina la cadena de la posicion 4 a la 14*/
24
25
26
System.out.println("Usando substring(4, 14) = "+cadena1.substring(4, 14));

/**indica si dos cadenas son iguales, enviamos la misma cadena, retorna true*/
System.out.println("Usando equalsIgnoreCase(cadenaOriginal) = "+cadena1.equalsI
27
/**indica si dos cadenas son iguales, enviamos otra cadena, retorna false*/
28
29
System.out.println("Usando equalsIgnoreCase(otroString) = "+cadena1.equalsIgnor

}
30
Al ejecutar el metodoString() obtenemos los siguientes resultados.
Podemos ver las funciones de los mtodos mencionados, sin embargo hay que
tener en cuenta que en el ejemplo anterior trabajamos siempre con el Objeto
String inicial, ya que en ningn momento le asignamos ningn valor ni creamos
otro explicitamente, si imprimimos la cadena original nos arroja " Esto Es Un
String
".....
Las
Clases
StringBuffer
StringBuilder.
En estas clases a diferencia de la Clase String las cadenas si se pueden

modificar trabajando desde el objeto original, recordemos que si hacemos un
cambio en un objeto String en realidad estamos trabajando con un nuevo
Objeto (es decir si tenemoscadena=cadena+"hola"; en realidad lo que
hacemos es crear un nuevo objeto String apuntando a la misma referencia del
Objeto Cadena...) mientras que con StringBuffer o StringBuilder siempre
trabajamos desde el mismo Objeto aprovechando el mismo espacio de
memoria.
La forma de crear un Objeto de alguna de estas clases es la siguiente.
StringBuffer
StringBuilder
cadena1=new
cadena2=new
StringBuffer("CoDejaVu");
y
StringBuilder("CoDejaVu");
Cuando vamos a utilizar muchas cadenas podemos usar estas clases ya que al
trabajar con el mismo objeto original hacen mas optimo el proceso, StringBuffer
y StringBuilder son prcticamente iguales (posen la misma API), la diferencia
es que StringBuilder no es Multihilo, es decir, sus metodos no se encuentran
sincronizados hacindola un poco mas veloz que su equivalente StringBuffer
por eso se recomienda que al trabajar con hilos se use esta ultima en vez de
StringBuilder....
Algunos Mtodos de StringBuffer
StringBuilder.
appened(String) : Concatena la cadena enviada como parmetro,

este mtodo es sobrecargado, quiere decir que acepta cualquier tipo de dato.
delete(int_inicial, int_final) : Elimina la cadena desde la posicin inicial hasta
la
final.
insert(int, String) : Inserta la cadena enviada en la posicin definida,
este mtodo es sobrecargado, quiere decir que acepta cualquier tipo de dato.
replace(int_inicial, int_final, String) : Reemplaza la cadena enviada en las
posiciones
de
la
inicial
a
la
final.
reverse(): imprime
la
cadena
al revs.
Igual que en el ejemplo de la clase String existen muchos mas mtodos pero
estos son solo algunos, se recomienda consultar en la API de java sobre
estos.......veamos un pequeo ejemplo del funcionamiento.................como lo
mencionamos anteriormente dichas clases comparten la misma API por lo cual
usan los mismos mtodos, por eso solo mostraremos el ejemplo usando
StringBuilder....
1
2
private void metodosStringBuilder() {

StringBuilder cadena1=new StringBuilder(" Esto Es Un StringBuilder ");
/**Imprime la cadena original*/
System.out.println("Cadena Original = "+cadena1);
/**concatena la cadena enviada como parametro*/
System.out.println("Usando append(\"En CoDejaVu\") = "+cadena1.append("En CoDejaVu
/**Elimina la cadena desde la posicion inicial hasta la final*/
System.out.println("Usando delete(32, 37) = "+cadena1.delete(32, 37));
/**Inserta la cadena enviada desde la posicion inicial*/
10
System.out.println("Usando insert(32, String) = "+cadena1.insert(32, "ejaVu Otra V
11
/**Reemplaza la cadena enviada en las posiciones definidas*/
12
System.out.println("Usando replace(2, 4, String) = "+cadena1.replace(2, 4, "xxx"))
13
/**Imprime la cadena en reversa*/
14
System.out.println("Usando reverse() = "+cadena1.reverse());
15
Al ejecutar el mtodo anterior obtenemos el siguiente resultado:
a diferencia del ejemplo usando String, aqu todas las operaciones se asignan
al objeto inicial, evidenciando que este cada vez va cambiando dependiendo
de
los mtodos que
utilicemos.
String
Vrs
StringBuffer
Vrs
StringBuilder
Con lo anterior podemos decir que las 3 clases sirven para lo mismo, es mas,
la Clase String permite un manejo mucho mas simple teniendo en cuenta que
podemos omitir crear la instancia de un Objeto simplemente con un " = " que
hace ese proceso implcito, o que con el "+" podemos evitar el uso del concat()
o con el "+=" podemos realizar la operacin y asignarla directamente al objeto
String tal como se hace con algunos tipos de datos primitivos entre otras
facilidades que nos brinda................ y a decir verdad casi todos nos
acostumbramos a usar String por estas y otras razones, sin embargo a nivel de
rendimiento son mucho mas efectivas las otras clases que estamos evaluando,
ya que como dijimos los String son inmutables por ende dependiendo de lo que
realicemos
cada
vez crearamos objetos
de
este
tipo
y
dependiendo tambin de la cantidad de cadenas que usemos esto seria una
carga en tiempo de ejecucin, pues se tendra una gran cantidad de objetos en
memoria....
A diferencia de este, StringBuffer y StringBuilder siempre trabajarn con el

mismo objeto inicial y de esta manera la carga en el heap sera mucho menor.
Como experiencia personal, alguna vez un compaero y yo desarrollamos una
aplicacin en la cual se Debin realizar muchas operaciones con cadenas las
cuales se concatenaban y mostraban en consola, inicialmente usamos obtejos
String pero a medida que crecan los datos este proceso tomaba demasiado
tiempo hasta que decidimos usar objetos StringBuffer y de esta manera el
tiempo
se
redujo
significativamente.
A continuacin veremos un ejemplo muy comn donde podremos simular lo
anterior, en este ejemplo se solicita el ingreso de un texto y se calcula la
velocidad de concatenacin para cada uno de los 3 casos, el calculo se realiza
en ciclos (for) cada uno con una constante de 100000 iteraciones, se evidencia
la diferencia de tiempos respectivamente.
1
2
/**
*/
* @author HENAO
public class Cadenas {
6
7
/**
* constante que determina el numero de repeticiones
* en cada uno de los tres metodos de concatenacion
10
*/
11
12
13
14
15
16
17
18
public final long ITERA = 100000;

/**determina el tiempo total de concatenacion*/
private long tiempo;
/**
* @param args
*/
19
Cadenas objetoCadenas=new Cadenas();
20
String valorCadena="CoDejaVu";
21
String usoString=objetoCadenas.calculaTiempoString(valorCadena);
22
String usoStringBuffer=objetoCadenas.calculaTiempoStringBuffer(valorCadena);
String usoStringBuilder=objetoCadenas.calculaTiempoStringBuilder(valorCadena);
23
24
System.out.println("Tiempo Concatenacion String : "+usoString+
25
"\nTiempo Concatenacion StringBuffer : "+usoStringBuffer+
26
27
"\nTiempo Concatenacion StringBuilder : "+usoStringBuilder);

}
28
29
30
/**
31
* Metodo que calcula el tiempo de concatenacion de la cadena
32
* usando la clase String
33
* @param valor dato ingresado por el usuario
34
* @return tiempo en milisegundos
35
*/
36
public String calculaTiempoString(String valor)
37
38
String cadena = "";
39
tiempo = System.currentTimeMillis();
for (int i = 0; i < ITERA ; i++) {
40
cadena += valor;
41
42
tiempo = System.currentTimeMillis() - tiempo;
43
44
return tiempo + " milisegundos";

}
45
46
47
48
/**
49
* usando la clase StringBuffer
50
51
52
*/
public String calculaTiempoStringBuffer(String valor)
53
54
StringBuffer cadena = new StringBuffer();
55
long tiempo = System.currentTimeMillis();
56
57
cadena.append(valor);
58
59
60
61
62
/**
63
64
* usando la clase StringBuilder
65

66
*/
67
public String calculaTiempoStringBuilder(String valor)
68
69
StringBuilder cadena = new StringBuilder();
70
tiempo = System.currentTimeMillis();
71
72
cadena.append(valor);
73
74
75

}
76
77
78
79
80
81
De esta manera obtenemos el siguiente resultado:
y podemos ver la gran diferencia entre los diferentes tipos de objetos,

dependiendo de la cantidad de cadenas con las que vamos a trabajar estos
resultados varan y en ocasiones el tiempo de concatenacin del StringBuffer
es igual al del StringBuilder pues como ya mencionamos comparten la misma
API, pero siempre se presentar una gran distancia con respecto al String.
Conclusin.
Como conclusin, vimos las diferentes formas que tenemos al momento de
trabajar con datos de tipo cadena, se recomienda usar objetos String cuando
no tengamos que manipular gran cantidad de cadenas y que estas no vayan a
cambiar, usaremos StringBuffer cuando necesitemos trabajar con cadenas
cambiantes adems de que tambin trabajemos con varios hilos y StringBuilder
cuando no trabajamos con hilos o solo se tiene uno en ejecucin.
Comparando Fechas En Java
En esta entrada veremos uno de los procesos obligados cuando se

trabaja en este campo del desarrollo de Software, sin importar el lenguaje que
manejemos en algn momento tendremos que realizar operaciones con
fechas.
En esta Ocasin y gracias a la inquietud de alguien vamos a realizar un

pequeo ejemplo de como comparar dos fechas, veremos una forma fcil para
definir si una fecha es menor, mayor o igual a otra, para esto usaremos la
clase java.util.Date
En el siguiente ejemplo asumiremos que ingresamos una fecha a nuestra
aplicacin y vamos a compararla con la fecha actual del sistema, para esto
almacenaremos la fecha ingresada con un formato "dd/mm/yyyy" , luego
obtendremos la fecha del sistema y la convertiremos a este formato para poder
realizar las comparaciones.
1
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
4
5
6
7
8
9
10
11
12
13
14
/**
* @author HENAO
*
*/
/**
* @param args
*/
15
16
/**Objeto de la clase */
17
Principal objetoPrincipal=new Principal();
18
19
String fecha1 = "12/05/2013";
20
String fecha2 = "13/05/2013";
21
String fecha3 = "14/05/2013";
22
23
/**Obtenemos la fecha del sistema y la convertirmos al String

*
24
25
con el formato en el que vamos a trabajar*/
Date fechaActual = new Date();

SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
26
String fechaSistema=formateador.format(fechaActual);
27
28
/**Realizamos los llamados a los metodos de ejemplo*/
29
30
System.out.println("\n********************************" +
31
"****************************\n");
32
33
34
String resultadoMenor=objetoPrincipal.compararFechasConDate(fecha1,fechaSistema);
System.out.println(resultadoMenor+"\n");
35
36
System.out.println("******************************" +
37
"******************************\n");
38
39
40
String resultadoIgual=objetoPrincipal.compararFechasConDate(fecha2,fechaSistema);
41
System.out.println(resultadoIgual+"\n");
42
43
System.out.println("******************************" +
44
"******************************\n");
45
46
String resultadoMayor=objetoPrincipal.compararFechasConDate(fecha3,fechaSistema);
47
System.out.println(resultadoMayor+"\n");
48
49
System.out.println("*****************************" +
"*******************************\n");
50
51
52
53
/**
54
* Comparamos las Fechas
55
* @author CHENAO
56
* @param fecha1
57
58
59
60
* @param fechaActual
* @return
*/
private String compararFechasConDate(String fecha1, String fechaActual) {
System.out.println("Parametro String Fecha 1 = "+fecha1+"\n" +
61
62
63
"Parametro String fechaActual = "+fechaActual+"\n");

String resultado="";
try {
64
/**Obtenemos las fechas enviadas en el formato a comparar*/
65
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
66
Date fechaDate1 = formateador.parse(fecha1);
67
Date fechaDate2 = formateador.parse(fechaActual);
68
System.out.println("Parametro Date Fecha 1 = "+fechaDate1+"\n" +
69
"Parametro Date fechaActual = "+fechaDate2+"\n");
70
71
if ( fechaDate1.before(fechaDate2) ){
72
resultado= "La Fecha 1 es menor ";
73
}else{
74
if ( fechaDate2.before(fechaDate1) ){
75
resultado= "La Fecha 1 es Mayor ";
76
}else{
77
resultado= "Las Fechas Son iguales ";
78
79
80
}
} catch (ParseException e) {
81
82
System.out.println("Se Produjo un Error!!!

}
"+e.getMessage());
83
84
85
return resultado;
86
87
}
}
88
89
Y listo, Si verificamos el proceso Obtenemos los siguientes resultados.
Podemos evidenciar que la comparacin se realiz con las 3 fechas y gracias

al mtodobefore sabemos cual es menor, mayor o si son iguales....
Leer Archivo Properties en Java
En el segundo Post de este blog se mencion la

intencin de publicar entradas sobre diversos temas, algunos complejos otros
no tanto.........hasta aqu se han publicado cositas no tan complejas pero que
pueden
llegar
a
ser
enredadas
o
de
cuidado.
En esta ocasin veremos una entrada sobre algo simple y fcil de entender
pero que nos puede ser de mucha ayuda.
Veremos de forma breve como trabajar con un archivo de propiedades desde

java, estos archivos son simplemente ficheros de texto que podemos usar para
almacenar informacin, inicializar variables, establecer mensajes o en general
definir parmetros (en tutoriales anteriores hicimos uso de este tipo de archivos
para definir rutas de servidores o parametros de configuracin).
En
java
trabajaremos
con java.util.Properties donde
bsicamente
necesitamos especificar nuestros parmetros mediante la combinacin "Clave
- Valor" y usar los mtodos bsicos que esta clase nos prove, un ejemplo
simple puede darse con el tema de la internacionalizacin, podemos crear
archivos properties para definir todos los labels o etiquetas que usaremos en la
aplicacin para diferentes idiomas y dependiendo del idioma que escogemos
buscamos el valor a presentar en pantalla en su archivo correspondiente.
Otro ejemplo es que en la empresa donde trabajo nos encontramos

desarrollando una aplicacin que genera una serie de reportes de Excel y se
deben almacenar en unas rutas especificas, son muchos reportes que se
almacenan en rutas diferentes, por eso podramos hacer que esas rutas de
directorios se puedan parametrizar en un archivo properties y no quemadas en
cdigo.
Empecemos!!!
Para este caso vamos a crear un proyecto Java bsico, donde definiremos dos
paquetes, uno para las clases y otro para el archivo.properties.
Luego desde el paquete properties damos click derecho y creamos un nuevo

archivo de propiedades.
Se carga una ventana donde ingresamos archivo.propierties, siendo este el

nombre y la extensin del archivo.
Despus de esto ya contamos con un panel donde podemos editar el archivo

de propiedades, presionando el botn Add podemos empezar a agregar
parmetros con la combinacin Clave - Valor.
O desde la vista Source podemos agregarlos directamente.
Para poder acceder a estos datos desde el cdigo fuente, haremos uso de los
mtodos load y getProperty que nos provee la clase Properties.
En la clase principal de nuestra aplicacin creamos un mtodo donde

realizaremos el cargue y obtencin de datos desde el archivo de propiedades.
1
2
3
package clases;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
7
8
/**
* @author CHENAO
10
11
*/
12
13
14
public static void main(String arg[]) {
15
Principal miPrincipal = new Principal();
16
17
18
miPrincipal.leerArchivo();
}
19
20
/**
21
* Lee un archivo de propiedades desde una ruta especifica
22
* y se imprime en pantalla.
23
*/
private void leerArchivo() {
24
try {
25
26
27
/**Creamos un Objeto de tipo Properties*/

Properties propiedades = new Properties();
28
29
/**Cargamos el archivo desde la ruta especificada*/
30
propiedades
31
.load(new FileInputStream(
32
"D:/HENAO/codejavu/Workspace/PruebaProperties/src/properties/archivo.propert
33
34
/**Obtenemos los parametros definidos en el archivo*/
35
String nombre = propiedades.getProperty("nombre");
36
String pagina = propiedades.getProperty("pagina");
37
38
/**Imprimimos los valores*/
39
System.out.println("Nombre: "+nombre + "\n" +"Pagina: "+ pagina);
40
41
} catch (FileNotFoundException e) {
42
System.out.println("Error, El archivo no exite");
43
} catch (IOException e) {
44
System.out.println("Error, No se puede leer el archivo");
45
}
46
47
48
}
}
49
Al correr nuestra aplicacin podemos ver como se obtienen los datos desde la
ruta
enviada
en
el
mtodo
load.
si queremos podemos almacenar el archivo en otra ruta, por ejemplo la del
servidor
de
aplicaciones
y
luego
enviarla
como
parmetro...................................... al final la salida es
Tutorial Proyecto Web Con Eclipse
Si se han seguido todos los tutoriales anteriores (Instalacin

Eclipse,Instalacin Plugin, Instalacin Servidor), ha estas alturas ya debemos
tener nuestro ambiente de desarrollo listo para trabajar.
En este tutorial vamos a crear un proyecto Web con un pequeo Demo de
aplicacin funcional, Mediante eclipse crearemos un nuevo proyecto JSF (Java
Server Faces) y realizaremos una serie de configuraciones que nos permitirn
generar nuestro cdigo fuente Base desde el cual podremos seguir
trabajando.......................Empecemos.
Requisitos.
IDE Eclipse
Plugin
JBoss
JDK 1.6
Variable de Entorno JBOSS_HOME
Variable de Entorno JAVA_HOME
Creacin Del Proyecto.
JBoss
Tools
4.2.3.GA
Desde Eclipse vamos a "File/New/Other..." all se cargar una ventana donde

ingresaremos en el campo la palabra jsf, de esta forma nos aparece la opcin
de JSF Project (Recordemos que para que esta opcin este disponible, debe
estar previamente instalado el plugin JBoss Tools), la seleccionamos y damos
click en Next
Posteriormente ingresamos el nombre del proyecto, dejamos el campo por

defecto
JSF
Environment y seleccionamos
en Template
la
opcin JSFKickStartWithoutLibs, con esto, le decimos a Eclipse que
vamos a crear un demo de una aplicacin web (el demo es muy bsico pero
cuenta con interfaz grfica, bean y reglas de navegacin), sino entonces
crearamos el proyecto en blanco, solo con la estructura y configuracin inicial.
Presionamos Next, acto seguido se carga una ventana donde debemos

configurar el servidor de nuestra aplicacin, (eso sucede porque no se asign
previamente el servidor) indicndonos que el server es requerido, presionamos
en New para asociar el servidor.
Se cargar una ventana donde seleccionaremos el server con el que vamos a

trabajar, para este caso usaremos JBoss4.2.3.GA que instalamos previamente
en algn directorio de nuestra mquina.
Damos Click en Next y se carga otra ventana indicndonos que se debe

asignar la ruta donde se encuentra alojado server, para esto presionamos en el
botn Browse y buscamos el directorio de instalacin del JBoss
Despus de encontrar el directorio lo seleccionamos y regresamos a la ventana

inicial con la configuracin deseada.
Como vemos ya no tenemos ningn error o advertencia, ahora solo nos queda
dar en Finishpara crear el proyecto, despus de esto se cargara una ventana
de dialogo donde nos preguntan si deseamos cambiar a la perspectiva Web
Development perspective esto es opcional.
Como vemos nuestro proyecto fue creado, y en caso de haber seleccionado

"Yes" en la ventana de dialogo, estaremos en la perspectiva mencionada (Se
puede evidenciar en la esquina superior derecha de Eclipse)
Esta perspectiva est ms orientada al diseo, puesto que simplemente con

arrastrar y soltar podemos agregar componentes a nuestras pginas, ms
adelante veremos cmo.
Si no se defini esta perfectiva igual seguiremos trabajando normalmente (para

los que no nos gusta arrastrar y soltar) pero en caso de que queramos acceder
a ella, simplemente por"Windows/Open Perspective" la buscamos y listo.
Ya teniendo nuestro proyecto creado, vamos a hacer un pequeo recorrido por

la estructura del mismo, podemos empezar ya, pero a modo personal me gusta
trabajar con la vistaNavigator ya que me parece un poquito ms ordenada, sin
embargo pueden seguir trabajando por el Project Explorer (Es cuestin de
gustos) Para esto seleccionamos Window/Show View/Navigator
y listo, tenemos la nueva opcin de navegacin, ahora s, veamos la estructura

del proyecto.
Como vemos tenemos nuestro proyecto web funcional, tenemos el archivo

index.jsp, el directorio JavaSource que contiene la clase User.java, un bean
creado por defecto, que tiene los mtodos set y get necesarios, Tenemos
tambin un archivo de propiedades donde se establecen todos los mensajes o
texto que tendrn las etiquetas del aplicativo. Tambin podemos ver un
directorio pages que contiene las pantallas de la aplicacin y dentro del WEBINF encontramos por ejemplo el archivo faces-config.xml con las reglas de
navegacin entre pginas.
Si ingresamos a la pgina inputUserName.jsp vemos que gracias al

plugin JBoss Toolspodemos trabajar con las opciones de solo cdigo, cdigo y
pantalla, adems de una vista previa de lo que estamos haciendo.
En la imagen anterior tambin se puede ver en el panel de la derecha las

opciones que brinda la perspectiva recomendada por eclipse, como se
mencion anteriormente solo sera cuestin de elegir el componente que
necesitamos y arrastrarlo al cdigo.
Carga del Servidor desde Eclipse
Para poder desplegar nuestra aplicacin, tenemos que hacer uso del servidor,
para eso desde Eclipse, en caso de que no se encuentre la vista de servidores,
se cargar desdeWindows/Show view/Server all presionamos click derecho y
agregamos new server
Se cargar nuevamente una ventana donde definiremos el servidor a utilizar,

realizando un proceso similar a los anteriores, nuevamente escogemos JBoss
v4.2 y presionamos finish.
Vemos como ha quedado agregado correctamente el servidor.
Ahora aumentaremos el tiempo de espera del servidor, ya que en ocasiones

cuando tenemos aplicaciones muy grandes, el servidor no permite el
despliegue, pues por defecto el tiempo de espera es muy corto, para esto
simplemente damos doble click en el server y aumentamos el tiempo en la
opcin TimesOuts
Ahora para el despliegue de la aplicacin desde eclipse podemos pararnos en

el servidor y dar click derecho, luego seleccionar la opcin Run o simplemente
desde este mismo icono en las opciones de la esquina.
Luego de esto se muestra el progreso del despliegue desde la consola de

Eclipse, vemos que todo est correcto y esperamos hasta que nos indique que
se ha iniciado, tambin se pueden ver otras opciones, por ejemplo desde el
cuadrito rojo podemos finalizar el despliegue (Vemos que es igual al despliegue
desde el run.bat del servidor como evidenciamos en el tutorialanterior).
Ahora para ejecutar nuestra aplicacin, damos click derecho al index.jsp y

seleccionamos run as/run on server (En algunas versiones de Eclipse,
haciendo esto no permite la ejecucin desde el index, tendramos que verificar
haciendo lo mismo pero desde la pgina inputUserName.jsp, posiblemente se
deba a algn error en el plugin)
Acto seguido se carga una ventana indicndonos el servidor configurado,

presionamos Next.
Despus se carga otra donde nos da la opcin de agregar el proyecto que

queremos desplegar, en caso de que no est agregado previamente, o si
queremos agregar otros proyectos asociados al nuestro.
Al presionar Finish se abre un navegador propio de eclipse donde podemos

ver nuestra aplicacin en funcionamiento.
La aplicacin cuenta con reglas de navegacin definidas, tambin el campo se

encuentra validado, por ejemplo, si ingresamos una cadena menor a 3
caracteres, nos informar mediante un error en pantalla.
Luego nos devolvemos usando la flecha "atrs" del navegador e ingresamos

un nombre valido, presionamos el botn y ahora si nos redirecciona a otra
pgina enviando el nombre ingresado como parmetro.
Tambin podemos ver la aplicacin desde cualquier navegador, simplemente

copiamos la ruta generada y con el servidor arriba la podemos probar.
Si vamos a la carpeta deploy de nuestro servidor, vemos que se ha generado

un archivo .war el cual es el empaquetado del proyecto, lo que permite que la
aplicacin sea desplegada.
Debemos tener en cuenta que este archivo se genera porque desplegamos el

proyecto desde Eclipse, definimos cual servidor asociar y dimos Run desde
ah, entonces el IDE lo que hace es leer esas configuraciones y almacenar el
empaquetado en la carpeta Deploy.
tambin podemos desplegar la aplicacin desde el run.bat como vimos en otro

tutorial, pero la aplicacin que se desplega es la ultima almacenada en el
server, ya que los cambios que hagamos, para que se puedan evidenciar,
tendramos que desplegarlos desde el Eclipse.
En el prximo tutorial, veremos una forma de automatizar ese proceso por

medio de tareas Ant, las cuales podemos configurar para que al ejecutar una
tarea, se realicen una serie de pasos predefinidos como por ejemplo generar el
empaquetado del proyecto, establecer la ruta del mismo, copiarlo a otro
directorio, generar documentacin, entre muchas otras opciones que esta
herramienta nos ofrece.
Nos vemos en una prxima entrada!!!

Ejemplo Modelo Vista Controlador

Загружено:

Сведения о документе

Исходное описание:

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Ejemplo Modelo Vista Controlador

Загружено:

Авторское право:

Доступные форматы

Ejemplo Modelo Vista Controlador

En la entrada sobre patrones de Diseo se habla

para la BD se usa MySql, reutilizando la BD creada en el ejemplo

La agrupacin de clases de nuestro sistema es:

Como vemos tenemos la parte visual compuesta por las

Como se mencion, en el modelo tenemos la lgica de negocio, sern

Esta clase permite realizar las operaciones asociadas a

public void validarRegistro(PersonaVo miPersona) {

En esta clase tenemos la cadena de conexin con la que

Al utilizar este tipo de clases, aplicamos

public void eliminarPersona(String codigo)

Aqu se define la parte visual del sistema, en la vista estableceremos

Esta clase representa la ventana inicial de la aplicacin, posee

Permite el ingreso de informacin a la BD, en ella se evidencian todos

Esta clase permite realizar las operaciones de Consulta, Actualizacin

Esta parte del patrn es la que define la lgica de administracin del

Esta clase contiene el mtodo main que ejecuta la

private void iniciar() {

Esta clase contiene toda la lgica de relaciones en

Puede contener instancias locales tanto de clases de la vista como de

sus respectivos mtodos set y get permitiendo el flujo de llamados

public Logica getMiLogica() {

El Sistema esta desarrollado como un

Como vimos tenemos un proyecto funcional que realiza las

en entradas anteriores como es el caso del manejo de excepciones,

Ejemplo Conectando Java con MySql

En esta entrada vamos a tocar uno de los puntos fundamentales en el

Ambiente de desarrollo (En este caso Eclipse)

mysql-connector-java-5.0.8-bin (lo pueden bajar desde aqu)

Conocimientos Basicos de Programacin.

El siguiente diagrama muestra la estructura de nuestra aplicacin

Como vemos la aplicacin es bsica, nos conectaremos a una BD

/*Table structure for table `persona` */

DROP TABLE IF EXISTS `persona`;

CREATE TABLE `persona` (

`id` int(10) NOT NULL,

`nombre` varchar(30) default NULL,

`edad` int(3) default NULL,

`profesion` varchar(30) default NULL,

`telefono` decimal(10,0) default NULL,

PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Data for the table `persona` */

Como vemos tenemos un paquete por cada clase, en estos

Esta clase ser nuestra cadena de conexion, aqu definiremos los

static String bd = "codejavu";

static String login = "root";

Connection connection = null;

/** Constructor de DbConnection */

//obtenemos el driver de para mysql

System.out.println("Conexin a base de datos "+bd+" OK\n");

/**Permite retornar la conexin*/

public Connection getConnection(){

public void desconectar(){

En la clase estamos aplicando el manejo de excepciones, tema

Esta clase nos permite dar un manejo mucho mas organizado y

* CLase VO con los atributos del campo empleado

public class PersonaVO{

private Integer idPersona;

private String nombrePersona;

private Integer edadPersona;

private String profesionPersona;

* @param idPersona the idPersona to set

/Table structure for table `persona` /

/Data for the table `persona` /