Programación en Capas Java

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.

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.apellidoMaterno=apellidoMaterno; } public String GetApellidoMaterno() { return this.apellidoMaterno; } public void SetDNI(String dNI) { this.dNI=dNI; } public String GetDNI() { return this.dNI; } public void SetDireccion(String direccion) { this.direccion=direccion; } public String GetDireccion() { return this.direccion; } public void SetEdad(int edad) { this.edad=edad; } public int GetEdad() { return this.edad; } public void SetSexo(char sexo) { this.sexo=sexo; } public char GetSexo()

{ return this.sexo; } }

La Clase DbTPersona

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

public static List LeerTodo(JTable miTablaDeDatos) { List listaTPersona=new ArrayList<>(); for(int i=0;i
La Clase NegocioFrmPersona

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package CAPADENEGOCIO; import CAPADEDATOS.DbTPersona; import ENCAPSULAMIENTO.TPersona; import java.util.ArrayList; import java.util.List; import javax.swing.JOptionPane; import javax.swing.JTable; /** * * @author kaaf */ public class NegocioFrmPersona { public void Registrar(TPersona tPersona, JTable miTabla)

{ try { miTabla.setModel(DbTPersona.Registrar(tPersona, miTabla)); } catch(Exception ex) { JOptionPane.showMessageDialog(null, ex.getMessage()); } } public List LeerDatosPersona(JTable tablaDeDatos) { List listaTPersona=new ArrayList<>(); try { listaTPersona=DbTPersona.LeerTodo(tablaDeDatos); } catch(Exception ex) { JOptionPane.showMessageDialog(null, ex.getMessage()); } finally { return listaTPersona; } } }

Botón "Ingresar Datos" -actionPerformed

TPersona tPersona=new TPersona(); tPersona.SetNombre(txtNombre.getText()); tPersona.SetApellidoPaterno(txtApellidoP.getText()); tPersona.SetApellidoMaterno(txtApellidoM.getText()); tPersona.SetDNI(txtDNI.getText()); tPersona.SetDireccion(txtDireccion.getText()); tPersona.SetEdad(Integer.parseInt(txtEdad.getText())); tPersona.SetSexo(rbM.isSelected() ? rbM.getText().charAt(0) : rbF.getText().charAt(0)); new NegocioFrmPersona().Registrar(tPersona, jTableDatos);

Botón "Leer Datos Ingresados"-actionPerformed

List listaTPersona=new NegocioFrmPersona().LeerDatosPersona(jTableDatos); DefaultTableModel modeloTabla=new DefaultTableModel(); modeloTabla.addColumn("Nombre"); modeloTabla.addColumn("Apellido P."); modeloTabla.addColumn("Apellido M."); modeloTabla.addColumn("DNI"); modeloTabla.addColumn("Dirección"); modeloTabla.addColumn("Edad"); modeloTabla.addColumn("Sexo"); for(TPersona tPersona:listaTPersona) { Object[] registroLeido= { tPersona.GetNombre(), tPersona.GetApellidoPaterno(), tPersona.GetApellidoMaterno(), tPersona.GetDNI(), tPersona.GetDireccion(), tPersona.GetEdad(), tPersona.GetSexo() }; modeloTabla.addRow(registroLeido); } jTableDatosLeidos.setModel(modeloTabla);

Compilando la Aplicación Una vez se realizó todos estos pasos la aplicación debería correr de la siguiente manera.

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, hay cosas que no debería estar; como pasar el JTable desde la capa de presentación hasta la capa de datos. 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. En un próximo post ya estaremos viendo programación orientada a objetos con el uso de una base de datos real, herencia, polimorfismo entre otros.

Programación en tres Capas con java Tutorial teórico y práctico para entender la programación de software por capas, 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. Modelo MCV, (vista, controlador, modelo).

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, ventas) de la lógica de presentación gráfica y de datos. También le conocer como modelo MCV, (vista, controlador, modelo). La ventaja de este estilo es que el desarrollo es la facilidad de reutilización y mantenimiento , ya que en caso de algún cambio, solo se modifica la capa necesaria sin tener que revisar todo el código.

Identificando las capas Capa lógica de presentación

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

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, capa de datos y capa de negocios. Aunque aquí hablamos de tres capas, también podemos crear otras capas de servicios y recursos para otras clases, configuraciones, etc


Tendremos así creadas las tres capas y el archivo Jautos.java que sera el que contiene el método main que es el punto de partida de cualquier programa java. El inicio de la aplicación por defecto sera el siguinete código. package jautos;  

1. 2. 3. 4. 5. 6. 7.

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. La aplicación tiene por finalidad gestionar un listado de vehículos donde poder insertar datos de automóviles y leerlos para

luego mostrarlos en una tabla tipo Jtable. Para ello añadiremos otra capa que encapsule los datos de la clase Vehículos en otra capa de recursos, crearemos una cuarta capa que se denominara CapaRecursos y dentro la clase Vehiculos que contendrá el siguiente código.  

1. package CapaRecursos; 2. 3. 4. public class Vehiculos { 5. 6. private String marca; 7. private String modelo; 8. private String color; 9. 10. 11. public void SetMarca(String marca) 12. { 13. this.marca=marca; 14. } 15. 16. public String GetMarca() 17. { 18. return this.marca; 19. } 20. 21. { 22. this.marca=marca; 23. } 24. 25. 26. public void SetModelo(String modelo) 27. { 28. this.modelo=modelo; 29. } 30. 31. public String GetModelo() 32. { 33. return this.modelo; 34. } 35. 36. public void SetColor(String color) 37. { 38. this.color=color; 39. } 40. 41. public String GetColor() 42. { 43. return this.color; 44. } 45.

46. 47. 48.

} }

Definimos los tributos de la clase que sera marca, modelo y color del vehículo, podemos añadir mas si quiere, pero con esos pocos es mas fácil de entender el código. Crearemos ahora el diseño de pantalla en la capa aplicación, allí podremos un Jframe podemos insertarlo con el botón derecho le daremos el nombre de frmAutos.


Ahora añadiremos los controles necesarios para nuestra aplicación:


El código es el siguiente:  

1. package CapaAplicacion; 2. import CapaRecursos.Vehiculos 3. /** 4. * 5. * @author alumno 6. */ 7. public class frmAutos extends javax.swing.JFrame { 8. 9. /** 10. * Creates new form frmAutos 11. */ 12. public frmAutos() { 13. initComponents(); 14. } 15. 16. /** 17. * This method is called from within the constructor to initialize the form. 18. * WARNING: Do NOT modify this code. The content of this method is always 19. * regenerated by the Form Editor. 20. */ 21. @SuppressWarnings("unchecked") 22. // 23. private void initComponents() { 24.

25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36.

jLabel1 = new javax.swing.JLabel(); jScrollPane1 = new javax.swing.JScrollPane(); jTable1 = new javax.swing.JTable(); txtMarca = new javax.swing.JTextField(); txtModelo = new javax.swing.JTextField(); jLabel2 = new javax.swing.JLabel(); jLabel3 = new javax.swing.JLabel(); txtColor = new javax.swing.JTextField(); btRegistrar = new javax.swing.JButton(); btLeer = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE) ; 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57.

jLabel1.setText("Marca"); jTable1.setModel(new javax.swing.table.DefaultTableModel( new Object [][] { {null, null, null, null}, {null, null, null, null}, {null, null, null, null}, {null, null, null, null} }, new String [] { "Title 1", "Title 2", "Title 3", "Title 4" } )); jScrollPane1.setViewportView(jTable1); txtMarca.setName("marca"); // NOI18N

txtModelo.setToolTipText(""); txtModelo.setName("modelo"); // NOI18N txtModelo.addActionListener(new java.awt.event.ActionListener() { 58. public void actionPerformed(java.awt.event.ActionEvent evt) { 59. txtModeloActionPerformed(evt); 60. } 61. }); 62. 63. jLabel2.setText("Modelo"); 64. 65. jLabel3.setText("Color"); 66. 67. txtColor.setToolTipText(""); 68. 69. btRegistrar.setText("Registrar"); 70. btRegistrar.setActionCommand("btRegistrar"); 71. btRegistrar.setName("btRegistrar"); // NOI18N 72. btRegistrar.addActionListener(new java.awt.event.ActionListener() { 73. public void actionPerformed(java.awt.event.ActionEvent evt) { 74. btRegistrarActionPerformed(evt); 75. }

76. 77. 78. 79. 80. 81. 82.

}); btLeer.setText("Leer"); btLeer.setToolTipText(""); btLeer.setName("btLeer"); // NOI18N

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); 83. getContentPane().setLayout(layout); 84. layout.setHorizontalGroup( 85. layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADIN G) 86. .addGroup(layout.createSequentialGroup() 87. .addContainerGap() 88. .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignm ent.LEADING) 89. .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 375, javax.swing.GroupLayout.PREFERRED_SIZE) 90. .addGroup(layout.createSequentialGroup() 91. .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignm ent.LEADING) 92. .addComponent(jLabel1) 93. .addComponent(jLabel2) 94. .addComponent(jLabel3)) 95. .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELAT ED) 96. .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignm ent.LEADING, false) 97. .addComponent(txtModelo) 98. .addComponent(txtMarca) 99. .addComponent(txtColor, javax.swing.GroupLayout.DEFAULT_SIZE, 196, Short.MAX_VALUE)) 100. .addGap(18, 18, 18) 101. .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignm ent.LEADING, false) 102. .addComponent(btRegistrar, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) 103. .addComponent(btLeer, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))))

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

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

168. java.util.logging.Logger.getLogger(frmAutos.class.getName()).log(ja va.util.logging.Level.SEVERE, null, ex); 169. } 170. // 171. 172. /* Create and display the form */ 173. java.awt.EventQueue.invokeLater(new Runnable() { 174. public void run() { 175. new frmAutos().setVisible(true); 176. } 177. }); 178. } 179. 180. // Variables declaration - do not modify 181. private javax.swing.JButton btLeer; 182. private javax.swing.JButton btRegistrar; 183. private javax.swing.JLabel jLabel1; 184. private javax.swing.JLabel jLabel2; 185. private javax.swing.JLabel jLabel3; 186. private javax.swing.JScrollPane jScrollPane1; 187. private javax.swing.JTable jTable1; 188. private javax.swing.JTextField txtColor; 189. private javax.swing.JTextField txtMarca; 190. private javax.swing.JTextField txtModelo; 191. // End of variables declaration 192. }

Importamos la capa y su clase frmAutos, luego en el main indicamos que la variable frmvehiculos, es una instancia del formulario o pantalla frmAutos y por lo ttno se incie y muestre al ejecutarse la aplicación.


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. Crearemos en la capa de datos el archivo DBAutos.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. Necesitaremos acceder a datos por lo tanto importamos las variables credas en la capa recursos con el código. i  

1. mport CapaRecursos.Vehiculos;

Necesitaremos importar otros compoentes para manejar la tabla:

 

1. package CapaDatos; 2. 3. import CapaRecursos.Vehiculos; 4. import java.util.ArrayList; 5. import java.util.List; 6. import javax.swing.JTable; 7. import javax.swing.table.DefaultTableModel; 8. 9. /** 10. * 11. * @author alumno 12. */ 13. public class DBAutos { 14. 15. public static DefaultTableModel Registrar(Vehiculos vehiculo, JTable Jtable1) { 16. DefaultTableModel modeloDeDatosTabla = (DefaultTableModel) Jtable1.getModel(); 17. 18. Object[] datosRegistro 19. = { 20. vehiculo.GetMarca(), 21. vehiculo.GetModelo(), 22. vehiculo.GetColor() 23. }; 24. 25. modeloDeDatosTabla.addRow(datosRegistro); 26. 27. return modeloDeDatosTabla; 28. } 29. 30. 31. public static List LeerTodo(JTable lsVehiculos) 32. { 33. List listaVehiculo=new ArrayList<>(); 34. for(int i=0;i
Creamos el método Registrar para registrar un vehículo y definimos cual es la estructura por default de la tabla. También creamos el método para leer los registro que ingresemos a la matriz. Nos queda ahora implementar la capa de negocios. Para ello crearemos dentro del paquete Capa de negocios el archivo negocioautos.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. El código de la capa de negocios es el siguiente  

1. package CapaNegocio; 2. 3. import CapaDatos.DBAutos; 4. import CapaRecursos.Vehiculos; 5. import java.util.ArrayList; 6. import java.util.List; 7. import javax.swing.JOptionPane; 8. import javax.swing.JTable; 9. /** 10. * 11. * @author alumno 12. */ 13. public class negocioautos { 14. 15. public void Registrar(Vehiculos vehiculo, JTable Jtable1) 16. { 17. try 18. { 19. Jtable1.setModel(DBAutos.Registrar(vehiculo, Jtable1)); 20. } 21. catch(Exception ex) 22. { 23. 24. } 25. 26. } 27. 28. public List Leer(JTable tabla) 29. { 30. List listaAutos=new ArrayList<>(); 31. 32. try

33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46.

{ listaAutos=DBAutos.LeerTodo(tabla); } catch(Exception ex) { } finally { return listaAutos; } } }

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. Antes de colocar los botones debe asegurarnos de haber importado las capas de recursos y negocios, además de los componente para manejar la matriz de datos que en este caso cumple la función de base de datos, importamos en la capa de presentación o aplicación sino las tenemos añadidas anteriormente.  

1. 2. 3. 4. 5. 6.

import import import import import import

CapaRecursos.Vehiculos; CapaNegocio.negocioautos; java.util.ArrayList; java.util.List; javax.swing.JTable; javax.swing.table.DefaultTableModel;

En el botón Registrar en el action performed escribimos el siguiente código  

1. private void btRegistrarActionPerformed(java.awt.event.ActionEvent evt) {

2. Vehiculos auto=new Vehiculos(); 3. 4. auto.SetMarca(txtMarca.getText()); 5. auto.SetModelo(txtModelo.getText()); 6. auto.SetColor(txtColor.getText()); 7. 8. 9. new negocioautos().Registrar(auto, jTable1); 10. 11. } 12.

El Resultado al ejecutar será el siguiente:


Al pulsar el botón Registrar en la pantalla de listado de autos se invoca al método new negocioautos().Registrar(auto, jTable1); 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. Vamos a añadir otra tabla para clonar los datos de la primera

mediante el botón leer. Para ello añadimos una Jtable debajo y los dejamos sin configurar sus propiedades ya que la modificaremos desde código. Si queremos inspeccionar como modificar los parámetros por defecto de una tabla, 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, añadir o quitar columnas o filas, implementar distintos comportamientos al iniciar la aplicación.


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. 



1. private void btLeerActionPerformed(java.awt.event.ActionEvent evt) { 2. // TODO add your handling code here: 3. 4. 5. List listaVehiculo=new negocioautos().Leer(jTable1); 6. 7. DefaultTableModel Tabla=new DefaultTableModel(); 8. Tabla.addColumn("Marca"); 9. Tabla.addColumn("Modelo"); 10. Tabla.addColumn("color"); 11. 12. 13. for(Vehiculos vehiculo:listaVehiculo) 14. { 15. Object[] registroLeido= 16. { 17. vehiculo.GetMarca(), 18. vehiculo.GetModelo(), 19. vehiculo.GetColor() 20. }; 21. 22. Tabla.addRow(registroLeido); 23. } 24. 25. jTable2.setModel(Tabla); 26. 27. }

Veamos como queda la funcionalidad con el botón leer y la segunda tabla añadida.


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. 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, no es una técnica rígida que debe

implementarse de una manera estructurada. 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, se puede implementar una capa en otro proyecto. 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. Algunas desventajas de este modelo de programación es cuando se implementa se debe llegar a un balance entre la cantidad capas, recursos, subsistemas o subcapas, clases y sus interrelaciones. 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, para que un cambio no afecte a todo el sistema. 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. Se debe evitar también caer en el error de generar mucha dependencia entre los objetos, métodos, propiedades y atributos de cada clase y cada capa que justamente contradice el objetivo de la programación en 3 o N capas. Algunas tecnologías actuales que soportan la Programación en Capas. En la actualidad, la mayoría de los programas hacen uso de .Java, PHP y Net. Microsoft Visual Studio.NET Este framework implementa la posibilidad de programacion en N capas tanto en web como software de escritorio. La capa de datos se implementa mediante herramientas como Data Set y Data Reader.

Programación en Capas Java

Recommend Documents