You are on page 1of 31

Programación en Capas

Hoy haremos un tema que es bastante interesante y muy usado en el desarrollo de software.
Realizaremos un ejemplo de la programación orientada a capas.
La programación orientada a capas es una técnica que se usa para el desarrollo de software
el cual permita que dicho software sea escalable, mantenible, consistente y que tenga una
aspecto mucho más profesional de desarrollo, no como la clásica programación secuencial.
La programación orientada a capas se caracteriza por ser un tipo de diseño en el desarrollo
de software mediante clases las cuales se separan generalmente en:
-La capa de datos.
-La capa de negocios.
-La capa de presentación.

Bien, como se sabe que lo que Ud. quiere es la parte técnica más no la parte teórica,
pasaremos a realizar el ejemplo de la programación orientada a capas.
Tener en cuenta que la programación en capas generalmente va de la mano con la
programación orientada a objetos para la optimización de este.

Estructura del proyecto
Creamos el proyecto, luego creamos 4 paquetes uno para la capa de datos, otro para la capa
de negocio, otro para la capa de presentación y el último para los encapsulamientos. Tener
en cuenta que para poder trabajar de forma más ordenada es mejor separar la lógica de
negocio de los datos, así mismo sería bueno separar componentes aislados al código fuente
en otro paquete como las imágenes, formato de reportes y otros.
Ahora que tenemos los 4 paquetes, creamos en cada uno de ellos la clase respectiva para
trabajar. En este caso haremos un ejemplo que consista en manejar mediante la
Programación en capas la inserción y lectura de los datos de una persona. Para dicho caso
en el paquete de encapsulamiento creamos una clase TPersona, en la capa de datos (Paquete
que se creo para los datos) creamos otra clase DbTPersona, en la capa de presentación
(Paquete para los formularios) creamos un formulario frmPersona y e la capa de negocio
(Paquete para negociar los datos) creamos la clase NegocioFrmPersona.
Debemos tener en cuenta que en la Programación sobre capas, generalmente se debe crear
un encapsulado y una clase de la capa de datos por cada tabla existente en nuestra base de
datos y un negocio por cada formulario el cual será quien maneje toda la negociación de
datos entre las capas de datos que se usen en el formulario y la capa de presentación.

También recordar que en la capa de datos se puede crear una clase exclusivamente para las
consultas relacionales ya que la programación orientada a objetos que va de la mano con la
programación en capas no permite encapsular este tipo de consultas.
Como en nuestro caso no tenemos una base de datos, simularemos dicho caso con un
formulario que tenga los campos para registrar una persona que lo pasará a un JTable y
luego tendremos un botón que permita leer tales datos almacenados en nuestro JTable.
La estructura de nuestro árbol con las clases creadas debería quedar de la siguiente manera.

Diseño del formulario
Con lo mencionado anteriormente, nuestro formulario debería quedar de la siguiente forma.

Código Fuente
La Clase TPersona
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package ENCAPSULAMIENTO;
/**
*
* @author kaaf
*/
public class TPersona {
private String nombre;
private String apellidoPaterno;
private String apellidoMaterno;
private String dNI;
private String direccion;
private int edad;
private char sexo;
public void SetNombre(String nombre)
{
this.nombre=nombre;
}
public String GetNombre()
{
return this.nombre;
}
public void SetApellidoPaterno(String apellidoPaterno)
{
this.apellidoPaterno=apellidoPaterno;
}
public String GetApellidoPaterno()
{
return this.apellidoPaterno;
}

public void SetApellidoMaterno(String apellidoMaterno) { this.edad=edad. } public char GetSexo() .edad.sexo=sexo.apellidoMaterno.direccion=direccion. } public void SetDNI(String dNI) { this. } public void SetDireccion(String direccion) { this. } public int GetEdad() { return this. } public String GetDireccion() { return this. } public String GetDNI() { return this. } public void SetSexo(char sexo) { this. } public String GetApellidoMaterno() { return this.dNI.apellidoMaterno=apellidoMaterno. } public void SetEdad(int edad) { this.direccion.dNI=dNI.

GetApellidoMaterno(). return modeloDeDatosTabla. /** * * @author kaaf */ public class DbTPersona { public static DefaultTableModel Registrar(TPersona tPersona.GetEdad(). } .JTable. tPersona. import ENCAPSULAMIENTO. tPersona.GetSexo() }.sexo. tPersona.GetApellidoPaterno(). Object[] datosRegistro= { tPersona.swing. modeloDeDatosTabla. tPersona. */ package CAPADEDATOS.GetDireccion().table.GetDNI(). JTable miTabla) { DefaultTableModel modeloDeDatosTabla=(DefaultTableModel)miTabla. import java.DefaultTableModel.TPersona.{ return this.swing.ArrayList.util. choose Tools | Templates * and open the template in the editor.util.addRow(datosRegistro). import javax.List.GetNombre(). } } La Clase DbTPersona /* * To change this template. tPersona.getModel(). import javax. tPersona. import java.

import ENCAPSULAMIENTO.toString()). /** * * @author kaaf */ public class NegocioFrmPersona { public void Registrar(TPersona tPersona. 0).SetDNI(miTablaDeDatos.SetApellidoMaterno(miTablaDeDatos. 6). 5). tPersona. } } La Clase NegocioFrmPersona /* * To change this template. import javax. tPersona. tPersona.toString()).toString()). tPersona.ArrayList.getValueAt(i. */ package CAPADENEGOCIO.toString())).swing.util. tPersona.JTable.getValueAt(i.SetEdad(Integer.i<miTablaDeDatos.toString()).toString()).getValueAt(i.parseInt(miTablaDeDatos.toString()). for(int i=0.getRowCount(). 4).JOptionPane.add(tPersona).SetNombre(miTablaDeDatos. 1).DbTPersona.util.SetApellidoPaterno(miTablaDeDatos.getValueAt(i.SetDireccion(miTablaDeDatos.swing.getValueAt(i. 2). tPersona. } return listaTPersona. JTable miTabla) .SetSexo((miTablaDeDatos.getValueAt(i. listaTPersona.TPersona.getValueAt(i. 3). choose Tools | Templates * and open the template in the editor.charAt(0)).List. import CAPADEDATOS. import javax. tPersona. import java.public static List<TPersona> LeerTodo(JTable miTablaDeDatos) { List<TPersona> listaTPersona=new ArrayList<>().i++) { TPersona tPersona=new TPersona(). import java.

getMessage()).getText())). jTableDatos). } catch(Exception ex) { JOptionPane.Registrar(tPersona.{ try { miTabla. .charAt(0) : rbF.showMessageDialog(null. new NegocioFrmPersona().SetDNI(txtDNI.SetNombre(txtNombre.getText()).showMessageDialog(null. tPersona. tPersona. ex.SetApellidoMaterno(txtApellidoM.setModel(DbTPersona.getText()).getText()). tPersona.getText()). miTabla)). } finally { return listaTPersona. tPersona.SetDireccion(txtDireccion. } } public List<TPersona> LeerDatosPersona(JTable tablaDeDatos) { List<TPersona> listaTPersona=new ArrayList<>(). } catch(Exception ex) { JOptionPane. } } } Botón "Ingresar Datos"-actionPerformed TPersona tPersona=new TPersona(). tPersona.SetEdad(Integer. tPersona.isSelected() ? rbM. tPersona.getText()).Registrar(tPersona.LeerTodo(tablaDeDatos). ex. try { listaTPersona=DbTPersona.SetSexo(rbM.getMessage()).getText().SetApellidoPaterno(txtApellidoP.parseInt(txtEdad.getText().charAt(0)).

GetApellidoMaterno().LeerDatosPersona(jTableDatos). tPersona. modeloTabla.addColumn("DNI").").setModel(modeloTabla).addColumn("Apellido M.GetDNI().addColumn("Sexo"). tPersona.addColumn("Edad").GetEdad().GetApellidoPaterno(). modeloTabla. DefaultTableModel modeloTabla=new DefaultTableModel(). modeloTabla."). modeloTabla.GetNombre(). tPersona. tPersona. modeloTabla. Compilando la Aplicación Una vez se realizó todos estos pasos la aplicación debería correr de la siguiente manera. .GetDireccion().addColumn("Nombre"). tPersona.Botón "Leer Datos Ingresados"-actionPerformed List<TPersona> listaTPersona=new NegocioFrmPersona(). for(TPersona tPersona:listaTPersona) { Object[] registroLeido= { tPersona. tPersona.GetSexo() }. modeloTabla.addColumn("Dirección").addColumn("Apellido P. modeloTabla. modeloTabla.addRow(registroLeido). } jTableDatosLeidos.

En un próximo post ya estaremos viendo programación orientada a objetos con el uso de una base de datos real. ventas) de la lógica de presentación gráfica y de datos. ya que en caso de algún cambio. polimorfismo entre otros. modelo). . controlador. controlador. La ventaja de este estilo es que el desarrollo es la facilidad de reutilización y mantenimiento. modelo). (vista. También le conocer como modelo MCV. (vista. solo se modifica la capa necesaria sin tener que revisar todo el código.Tener en cuenta que los datos no fueron validados por lo que debería ingresarse datos correctos sin dejar ningún dato vacío. Por otro lado. Pero se hace esto porque no se está trabajando con una base de datos real y se está tomando como base de datos nuestra primera tabla donde estamos ingresando los datos de la persona. como pasar el JTable desde la capa de presentación hasta la capa de datos. Modelo MCV. que es una arquitectura en la que se separa el código o lógica que hace tareas de negocios (facturar. ventas) de la lógica de presentación gráfica y de datos. herencia. hay cosas que no debería estar. Programación en tres Capas con java Tutorial teórico y práctico para entender la programación de software por capas. La programación de software por capas es una arquitectura en la que buscamos separar el código o lógica que hace tareas de negocios (facturar.

la capa de presentación solicita mediante funciones que se ejecutan en la capa de la lógica de negocio. listar productos. . ni realizar operaciones de ningún tipo solo muestra datos en pantalla. así la capa de presentación podría estar en un pc y las otras capas en un servidor como servicio se software Saas. Aquí se ejecutan e invocan reglas o funciones de negocios por ejemplo. Recibe peticiones o eventos del usuario. pero la capa de negocios no se conecta a la base de datos. El objetivo es separar todo aquellos que se muestra al usuario. Capa de lógica de negocio Aquí es donde se encuentran las funciones clases y funciones o procedimientos que serán invocados a través de la interfaz gráfica. procesa esas peticiones y luego envía la respuesta a la interfaz gráfica. solo recibe datos o los procesa. modificar o eliminar información en la base de datos. etc. Aquí ejecutaremos consultas sql de forma que ninguna de las otras capas saben donde esta la base de datos. facturar. esta capa no tiene conexión a base de datos.Identificando las capas Capa lógica de presentación Hace referencia a como se va a presentar la información del programa al usuario. insertar. Capa de datos Aquí tendremos clases y funciones que se conectan a la base de datos y es donde se realizan transacciones con sql para leer. si es necesario esta capa se comunicara con la capa de datos.

A modo ejemplo realizaremos una aplicación en java con tres capas: Estructura del proyecto Agencia de Autos Utilizaremos Netbeans para el ejemplo pero puede aplicarse cualquier otro ide de programación para java. Creamos el proyecto con Netbeans. como una aplicación java que se denominará JAutos .

Pulsa en la imágen para agrandarla Luego los paquetes de java que serán las capas de presentación o aplicación. configuraciones. Aunque aquí hablamos de tres capas. también podemos crear otras capas de servicios y recursos para otras clases. etc . capa de datos y capa de negocios.

7. 6. public class JAutos { /** Metodo main de inicio */ public static void main(String[] args) { // TODO code application logic here } } Comenzaremos ahora a programar las funcionalidades capa por capa.Pulsa en la imágen para agrandarla Tendremos así creadas las tres capas y el archivo Jautos. package jautos. 2. 5.   1. 3. El inicio de la aplicación por defecto sera el siguinete código. 4.java que sera el que contiene el método main que es el punto de partida de cualquier programa java. La aplicación tiene por finalidad gestionar un listado de vehículos donde poder insertar datos de automóviles y leerlos para .

public class Vehiculos { 5. 14. { 33. public String GetColor() 42. 9. 11. private String modelo. 34. public void SetColor(String color) 37.modelo.color=color. 41. 7. 3. { 28.luego mostrarlos en una tabla tipo Jtable. return this. 6. 29. 31. 19.marca=marca. package CapaRecursos. this. 25. public String GetMarca() 17. Para ello añadiremos otra capa que encapsule los datos de la clase Vehículos en otra capa de recursos. 44. public void SetModelo(String modelo) 27. this. 26. public void SetMarca(String marca) 12. private String marca. { 38. private String color.   1. this. 2. { 22.marca=marca. } 24.color. 23. { 43. 36. } 30. return this. return this. . crearemos una cuarta capa que se denominara CapaRecursos y dentro la clase Vehiculos que contendrá el siguiente código. } 15. 16.modelo=modelo. } 20. } 35. } 45. } 40. 10. 8. public String GetModelo() 32. 4.marca. 39. this. { 18. 21. { 13.

} 47. modelo y color del vehículo. Pulsa en la imágen para agrandarla Ahora añadiremos los controles necesarios para nuestra aplicación: .46. allí podremos un Jframe podemos insertarlo con el botón derecho le daremos el nombre de frmAutos. Crearemos ahora el diseño de pantalla en la capa aplicación. pero con esos pocos es mas fácil de entender el código. podemos añadir mas si quiere. 48. } Definimos los tributos de la clase que sera marca.

/** 4. 2. /** 10. * This method is called from within the constructor to initialize the form. public class frmAutos extends javax.Pulsa en la imágen para agrandarla El código es el siguiente:   1. * 5. // <editor-fold defaultstate="collapsed" desc="Generated Code"> 23. */ 21. package CapaAplicacion. */ 7. * @author alumno 6. * WARNING: Do NOT modify this code. @SuppressWarnings("unchecked") 22. /** 17. initComponents(). } 15.swing. . * regenerated by the Form Editor. 16. private void initComponents() { 24. * Creates new form frmAutos 11. 18.Vehiculos 3. 9. */ 12. import CapaRecursos.JFrame { 8. The content of this method is always 19. 14. 20. public frmAutos() { 13.

55. null. btRegistrar. txtModelo.event. 65. jTable1 = new javax.setActionCommand("btRegistrar"). txtModeloActionPerformed(evt). 37. null.setViewportView(jTable1). 57. 69. null. null. jLabel2 = new javax.setName("marca"). txtColor.JLabel(). null. 52.swing. null}. 35.swing.setToolTipText(""). 38. jLabel3. txtModelo = new javax.swing. 71. jScrollPane1 = new javax. 67. 63.JButton(). 50. 56. txtMarca = new javax.WindowConstants. btRegistrar.JScrollPane().awt. 64. jLabel1.setName("modelo"). {null. btLeer = new javax.JTable().awt. jScrollPane1. null}. "Title 2".JTextField().swing.setText("Marca").setText("Registrar"). 40. } 61.swing.setName("btRegistrar"). 31. 62. btRegistrar. // NOI18N txtModelo.JTextField().addActionListener(new java.swing.JButton(). public void actionPerformed(java.event.EXIT_ON_CLOSE) .ActionEvent evt) { 74.swing.JLabel(). 34. null.JLabel(). 28. null. jLabel1 = new javax. 68.JTextField(). jTable1.awt. {null.swing. 53. 47. setDefaultCloseOperation(javax. }). 49. txtMarca.setText("Modelo"). 27. txtColor = new javax. 32.DefaultTableModel( new Object [][] { {null. 26. 48. 44. {null.swing. jLabel3 = new javax. null. null}. 42. jLabel2. 51.swing. "Title 4" } )). "Title 3". 43. // NOI18N txtModelo. 75.awt.addActionListener(new java. 39. } . public void actionPerformed(java. 54. 60. btRegistrarActionPerformed(evt).swing. btRegistrar.ActionListener() { 58.event.event. null} }. new String [] { "Title 1".ActionEvent evt) { 59. 45. 30.ActionListener() { 73. 36. btRegistrar = new javax. 70.25. 46.setModel(new javax. // NOI18N 72.swing.setToolTipText("").table.setText("Color"). 66. 41. 33. 29.

addGroup(layout. .MAX_VALUE)))) . btLeer. .GroupLayout(getContentPane()).swing.DEFAULT_SIZE.addComponent(btRegistrar.swing. javax.swing.MAX_VALUE)) 100. javax.addGroup(layout.createParallelGroup(javax. Short.createParallelGroup(javax. javax.addComponent(jLabel2) 94.GroupLayout. 196.PREFERRED_SIZE. .swing.swing.DEFAULT_SIZE.addComponent(txtColor.swing. . .ComponentPlacement. Short. 83. .LEADING) 92. .swing. getContentPane().LayoutStyle.GroupLayout. // NOI18N javax.Alignm ent.createParallelGroup(javax.LEADING) 89.swing. javax. Short. . .Alignm ent.addContainerGap() 88. 78.createSequentialGroup() 91.LEADING.UNRELAT ED) 96. . 375.GroupLayout. javax.addGroup(layout. layout.addComponent(jLabel1) 93.addComponent(btLeer.setToolTipText("").swing.GroupLayout.DEFAULT_SIZE. . false) 97. .GroupLayout.GroupLayout.createSequentialGroup() 87.addComponent(jScrollPane1.addGroup(layout. . }).DEFAULT_SIZE.GroupLayout.GroupLayout layout = new javax.MAX_VALUE) 103.swing. false) 102.addComponent(txtModelo) 98.swing. .swing.setName("btLeer").createParallelGroup(javax. 81. 79. 18. 77.DEFAULT_SIZE.LEADIN G) 86.addPreferredGap(javax. 84.addGroup(layout.setText("Leer").GroupLayout.swing.setHorizontalGroup( 85.PREFERRED_SIZE) 90.setLayout(layout). .GroupLayout.76. layout.GroupLayout.GroupLayout.addComponent(jLabel3)) 95. .addComponent(txtMarca) 99. 18) 101.swing. .LEADING. btLeer.GroupLayout. 80.Alignm ent.addGroup(layout. javax.Alignment.swing. 82.addGap(18.Alignm ent.createParallelGroup(javax. javax. . btLeer.

DEFAULT_SIZE.addComponent(jLabel3) 124.GroupLayout.GroupLayout.addGroup(layout. javax.GroupLayout.swing.swing.addGroup(layout. javax. 15) 127. .addGap(15.createParallelGroup(javax.Alignm ent.ComponentPlacement.GroupLayout.addComponent(btRegistrar)) 115.addGroup(layout. .addComponent(txtMarca.addComponent(txtModelo.addPreferredGap(javax.DEFAULT_SIZE. javax.swing. javax. . .GroupLayout. . .GroupLayout. .createSequentialGroup() 109.LEADIN G) 108.swing.swing.GroupLayout.GroupLayout.LayoutStyle. 15. 15.swing.PREFERRED_SIZE.BASELINE) 119.swing.swing.PREFERRED_SIZE. 26.Alignment.PREFERRED_SIZE.addComponent(btLeer))) 128. javax.createParallelGroup(javax.swing.Alignm ent.LEADING) 116.BASELINE) 123. .BASELINE) 112.createParallelGroup(javax.swing.LEADING) 111.swing. javax.swing. Short. . . layout.PREFERRED_SIZE)) 114.GroupLayout.swing. .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.MAX_VALUE)) 105. .Alignm ent. ). 26) .createSequentialGroup() 126.addComponent(jLabel2) 120.addContainerGap(javax.addGroup(layout.PREFERRED_SIZE))) 125.Alignm ent. .addGap(26. javax.createSequentialGroup() 117.UNRELAT ED) 122. .swing.GroupLayout. .Alignm ent.GroupLayout. . .RELATED ) 118.addGroup(layout.addPreferredGap(javax. javax.104.DEFAULT_SIZE. .GroupLayout. . .ComponentPlacement.addContainerGap() 110.addGroup(layout.LayoutStyle.addComponent(jLabel1) 113.GroupLayout. layout.addComponent(txtColor.addGroup(layout.setVerticalGroup( 107.createParallelGroup(javax. 106.swing.createParallelGroup(javax. .GroupLayout. .PREFERRED_SIZE)) 121.swing.

/* If Nimbus (introduced in Java SE 6) is not available. } catch (InstantiationException ex) { 164.UIManager.oracle. try { 155. 142.addComponent(jScrollPane1.getName()).log(ja va. pack(). 167. */ 154.awt. java. /* Set the Nimbus look and feel */ 150.util.getClassName()).swing.ActionEvent evt) { 137.GroupLayout. ex). null. ex). null.logging. 152. java.util.Logger.129. javax.SEVERE.getName()).awt.swing.setLookAndFeel(info. 158.event.Level. 165. stay with the default look and feel.getLogger(frmAutos. } 161.class. 140.swing.logging. 143.log(ja va.UnsupportedLookAndFeelException ex) { . null.getLogger(frmAutos.addContainerGap(32. }// </editor-fold> 135. . 133. 159. java. break.equals(info.swing.PREFERRED_SIZE.UIManager. */ 148.log(ja va. public static void main(String args[]) { 149. } 144. } 139. 145. ).util.Level.getInstalledLookAndFeels()) { 156. . private void btRegistrarActionPerformed(java. //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) "> 151.LookAndFeelInfo info : javax.GroupLayout. private void txtModeloActionPerformed(java. for (javax. * @param args the command line arguments 147.getName()).logging.util.UIManager.ActionEvent evt) { 141. } catch (ClassNotFoundException ex) { 162. } 160.Level.class.SEVERE. 136.getLogger(frmAutos.class. // TODO add your handling code here: 138.SEVERE. ex).PREFERRED_SIZE) 130. javax.logging. * For details see http://download. 134. if ("Nimbus".html 153. /** 146.getName())) { 157.util. 163. } catch (javax.MAX_VALUE)) 131.event. 181. Short. 132.swing. javax.logging.Logger.util.com/javase/tutorial/uiswing/lookandfeel/plaf .swing.Logger. } catch (IllegalAccessException ex) { 166.logging.

190.Logger. 182. 178.getName()).swing.class.swing.168.swing. luego en el main indicamos que la variable frmvehiculos. private javax. private javax. java.swing.do not modify 181. 183. private javax.util.awt. // End of variables declaration 192. private javax.JLabel jLabel2.JLabel jLabel3. 172.swing. public void run() { 175.getLogger(frmAutos.JScrollPane jScrollPane1. new frmAutos().Level.JButton btLeer. private javax.swing. 184.logging.swing.JTable jTable1.swing.invokeLater(new Runnable() { 174.log(ja va. es una instancia del formulario o pantalla frmAutos y por lo ttno se incie y muestre al ejecutarse la aplicación.JTextField txtModelo. 187. ex). /* Create and display the form */ 173. } 170. .swing.JTextField txtMarca. 191. 189.swing. 169.JTextField txtColor. private javax. 180.EventQueue. private javax. private javax. // Variables declaration . }).setVisible(true). private javax.SEVERE. 176. 186.JButton btRegistrar. //</editor-fold> 171. } Importamos la capa y su clase frmAutos.util. private javax. } 179.JLabel jLabel1. 185. 188. } 177.logging. null. java.

aquí podríamos crear conexiones a bases de datos y consultas sql en este caso para hacer pruebas independientes de cualquier base de datos utilizaremos una matriz que luego podría ser grabada en cualquier base de datos o exportada a un archivo xml o lo que quisiéramos.Pulsa en la imágen para agrandarla Vemos como queda la aplicación al ejecutarse por primera vez con los controles y llamando a la capa de aplicación o presentación Ahora debemos crear las demás capas.java. Necesitaremos importar otros compoentes para manejar la tabla: . mport CapaRecursos. i   1. Crearemos en la capa de datos el archivo DBAutos. Necesitaremos acceder a datos por lo tanto importamos las variables credas en la capa recursos con el código.Vehiculos.

GetColor() 23.JTable. * 11.add(vehiculo).toString()).util. return modeloDeDatosTabla. 25.i++) 35. package CapaDatos. 15. DefaultTableModel modeloDeDatosTabla = (DefaultTableModel) Jtable1. 2). 18. 44. vehiculo. 8. vehiculo. } 29. 9.swing. JTable Jtable1) { 16. } 43. listaVehiculo.DefaultTableModel. 4. public static List<Vehiculos> LeerTodo(JTable lsVehiculos) 32. for(int i=0.i<lsVehiculos.GetMarca().getValueAt(i.SetMarca(lsVehiculos. 0). 2. }. { 36. vehiculo.ArrayList.util. /** 10. vehiculo. Vehiculos vehiculo=new Vehiculos(). 41. public static DefaultTableModel Registrar(Vehiculos vehiculo. vehiculo.getModel().table.SetModelo(lsVehiculos. */ 13. Object[] datosRegistro 19. 26. 34. = { 20. 28. 27.GetModelo(). 39.Vehiculos. 40. import java. 5. 1). 30.List.getValueAt(i. 24. 31. public class DBAutos { 14. 6.addRow(datosRegistro).getRowCount(). import javax. import java.  1. 22. 17. 7. import CapaRecursos. } 47. import javax. } 46. 45. 21. vehiculo. return listaVehiculo.toString()).SetColor(lsVehiculos. modeloDeDatosTabla. 42. * @author alumno 12. List<Vehiculos> listaVehiculo=new ArrayList<>(). { 33.swing.getValueAt(i.toString()). 38. 3. 37. .

public class negocioautos { 14. */ 13.setModel(DBAutos. 15. import javax. Nos queda ahora implementar la capa de negocios.JTable. 8.java que sera la clase de la capa de negocios y quien tendrá la funcionalidad para intermediar entre la capa de presentacion o aplicación y la capa de datos. Jtable1. } 21.List. /** 10. 3. * 11. package CapaNegocio.ArrayList. El código de la capa de negocios es el siguiente   1. 26. { 17.Registrar(vehiculo. catch(Exception ex) 22. 20. * @author alumno 12. import CapaRecursos.Vehiculos. try . Para ello crearemos dentro del paquete Capa de negocios el archivo negocioautos.JOptionPane. 6.Creamos el método Registrar para registrar un vehículo y definimos cual es la estructura por default de la tabla.util. 2. List<Vehiculos> listaAutos=new ArrayList<>(). 32. 7. 31. import java.DBAutos. public List<Vehiculos> Leer(JTable tabla) 29. { 19. 24. También creamos el método para leer los registro que ingresemos a la matriz. 28. 4. import java. JTable Jtable1) 16. } 27. } 25.swing.swing. try 18.util. { 30. Jtable1)). import javax. { 23. 9. public void Registrar(Vehiculos vehiculo. 5. import CapaDatos.

43. importamos en la capa de presentación o aplicación sino las tenemos añadidas anteriormente. java. CapaNegocio.negocioautos.table.ArrayList. 3.Vehiculos. javax.DefaultTableModel.LeerTodo(tabla). Antes de colocar los botones debe asegurarnos de haber importado las capas de recursos y negocios. 4. además de los componente para manejar la matriz de datos que en este caso cumple la función de base de datos.33.List. 36. } { listaAutos=DBAutos. 44.awt. 6. 46. 2.event.ActionEvent evt) { . 39. 35.   1. 38. import import import import import import CapaRecursos. private void btRegistrarActionPerformed(java.swing. } catch(Exception ex) { } finally { return listaAutos. javax. 34. 5. java. 40. 42.JTable. En el botón Registrar en el action performed escribimos el siguiente código   1. 37.swing. 41.util. } Queda demás para que todo funciones colocar en la pantalla de presentación dos botones uno para insertar datos y otro para leer datos que son las dos funciones que tenemos en la capa de negocios que consulta a la capa de datos. } 45.util.

9. Vehiculos auto=new Vehiculos(). jTable1). auto. 6.Registrar(auto.SetModelo(txtModelo. 7. 8.2.getText()). auto.SetColor(txtColor. new negocioautos(). de la capa de negocios y se le envía como parámetros los datos que se encuentran en la matriz autos y la tabla donde se mostraran los datos insertados.Registrar(auto.getText()). 11. } 12. 5. jTable1). El Resultado al ejecutar será el siguiente: Pulsa en la imágen para agrandarla Al pulsar el botón Registrar en la pantalla de listado de autos se invoca al método new negocioautos(). 10.getText()). auto. Vamos a añadir otra tabla para clonar los datos de la primera .SetMarca(txtMarca. 3. 4.

 . añadir o quitar columnas o filas. podemos verlos haciendo clic derecho sobre la tabla y luego en el menu vamos a la opcion propiedades alli podremos modificar distintas opciones como los titulos de las columnas. Pulsa en la imágen para agrandarla Veremos en el código como cambiar los nombres de las columnas y vaciar la tabla para que tome los datos de la tabla principal donde se introducen los datos. Luego en el action performed del botón leer escribimos el siguiente código para poder leer los datos y volcarlos completamente en otra tabla para demostrar el funcionamiento y como podemos clonar una tabla con los datos que vamos introduciendo en otra o bien incluso usarlo para mostrar en las cajas de texto o guardarlo datos en un archivo de backup o comparar datos con facilidad. Si queremos inspeccionar como modificar los parámetros por defecto de una tabla. implementar distintos comportamientos al iniciar la aplicación. Para ello añadimos una Jtable debajo y los dejamos sin configurar sus propiedades ya que la modificaremos desde código.mediante el botón leer.

7. Tabla. 6. } 24. Tabla. 27. vehiculo. { 15. vehiculo. jTable2. Tabla. }. List<Vehiculos> listaVehiculo=new negocioautos(). 12. 1. 13.awt. 25. 23. vehiculo. Tabla.ActionEvent evt) { 2.GetMarca().addColumn("color"). 26. 9.GetColor() 20. Object[] registroLeido= 16. // TODO add your handling code here: 3.event.addColumn("Marca"). 5. for(Vehiculos vehiculo:listaVehiculo) 14. 11. 19. . 10. private void btLeerActionPerformed(java.Leer(jTable1). DefaultTableModel Tabla=new DefaultTableModel(). { 17. 8.setModel(Tabla). } Veamos como queda la funcionalidad con el botón leer y la segunda tabla añadida.addColumn("Modelo"). 4.GetModelo(). 22. 21.addRow(registroLeido). 18.

no es una técnica rígida que debe . De esta forma se puede ver como se ha separado en capas las distintas funcionalidades de la aplicación. Ventajas y Desventajas La programación en capas es una metodologia que permite trabajar con total libertad.Pulsa en la imágen para agrandarla Luego de cargar la tabla al pulsar el botón leer esta se clona en una segunda tabla si añadimos mas datos a la primera tabla y luego pulsamos leer se volverá a clonar la primer tabla sobre la segunda.

. recursos. En la actualidad. Microsoft Visual Studio.implementarse de una manera estructurada. para que un cambio no afecte a todo el sistema.NET Este framework implementa la posibilidad de programacion en N capas tanto en web como software de escritorio. Algunas desventajas de este modelo de programación es cuando se implementa se debe llegar a un balance entre la cantidad capas. La capa de datos se implementa mediante herramientas como Data Set y Data Reader. Dentro de las desventajas tenemos que analizar la pérdida de eficiencia si se comienza a hacer trabajo redundante o se programan varias capas que hacen lo mismo pero con distintos datos o conexiones constantes a la base de datos sin sentido que ralentizan la aplicación además de consultas sql mal optimizadas que pueden volver el software muy lento. subsistemas o subcapas. clases y sus interrelaciones. PHP y Net. La tendencia a utilizar el modelo de programación en N capas en grande proyecto con varios equipos de desarrolladores y cuando se trata principalmente de aplicaciones empresariales donde se deben manejar gran cantidad de subsistemas y módulos. propiedades y atributos de cada clase y cada capa que justamente contradice el objetivo de la programación en 3 o N capas. la mayoría de los programas hacen uso de . se puede implementar una capa en otro proyecto.Java. métodos. Debemos documentar muy bien un desarrollo en capas y debe ser fácilmente comprensible suficiente para realizar un trabajo específico con eficiencia y ser lo más modular e independiente posible. Algunas tecnologías actuales que soportan la Programación en Capas. Se debe evitar también caer en el error de generar mucha dependencia entre los objetos. Los desarrolladores de software e incluso de proyectos web tienen múltiples formas de implementarlas según sus necesidades y poder reutilizar muchas librerías de código desarrollado en capas.

tambien en desarrollo de escritorio con las que se construyen y conectan las interfaces gráficas con la capa de lógica del negocio. . que se utiliza para mapear bases de datos con objetos creados en Java algo como lo que vimos en el ejemplo con la clase vehiculos salvo que el mapeo lo hicimos construyendo la clase en forma manual.net La otra herramienta muy utilizada en Java es Hibernate. Muy similar a C# en . La capa de datos se implementa mediante herramientas como Data Set y Data Reader. Servlets.Java La capa de presentación se implementa por median te las herramientas JSP.