«
»

Modelando con ArgoUML aplicaciones en PHP

ArgoUML (Argo para abreviar) es una de esas aplicaciones que dan la impresión de no ser utilizadas por mucha gente pero que, sin embargo, continúan desarrollandose con un ritmo incansable. Para los que no lo sepan se trata de una herramienta CASE para modelar software en UML.

En mi caso elegí Argo porque quería modelar con una herramienta libre que me generase código en PHP. Además debería correr tanto en Windows como en Linux.

Pero antes de eso y después de probar unas cuantas herramientas veía difícil encontrar una aplicación que cumpliera estos tres requisitos: podía producir código PHP con Umbrello pero no corría en Windows, Visual Paradigm era hasta bonito pero no libre, etc. Finalmente llegué hasta Argo y aunque en una primer vistazo puede parecer una herramienta tosca en comparación con otras, cuando te acostumbras te das cuenta de que es bastante rápido trabajar con ella.


Para los fanáticos de Eclipse existe un proyecto paralelo llamadoargoeclipse que nos permite tenerlo integrado en dicho IDE. Sin embargo este proyecto siempre va un paso por detrás de su hermano mayor y creo que cuando lo probé no generaba código PHP.

Modelando

Tenemos a nuestra disposición los diagramas de casos de uso, clases, secuencia, colaboración, estado y despliegue.


Particularmente suelo utilizar el de casos de uso para definir historias o partes del entorno de usuario, el de clases para el análisis, desarrollo y documentación.

Ocasionalmente uso el de actividades para definir algún proceso que me interesa plasmar por su complejidad y el de despliegue como apoyo de algún documento.

Dada su flexibilidad, no importa que tipo de modelado queramos hacer. Por ejemplo, para un diagrama de clases, si modelamos desde el punto de vista del diseño de aplicación podemos ocultar atributos y funciones:

Por el contrario podemos profundizar un poco más en el análisis y definir atributos y funciones de las clases:

Por último si modelamos orientado a la implementación conviene que veamos la privacidad y los parámetros que utilizamos:

También nos es muy útil para documentar independientemente del nivel al que modelemos, ya que podemos insertar documentación sobre las clases, atributos, funciones, etc. Cuando generémos el código se nos insertarán los comentarios de forma que más tarde podremos procesarlo mediante PHPDocumentor y obtener un pdf o páginas html de documentación.

En la práctica

Volviendo a los diagramas que se pueden ver más arriba imaginemos que después de definir los casos de uso y de hacer un modelado de las clases a nivel de diseño, vamos profundizando hasta el punto de vista de implementación. Llegados a este punto es el momento de generar código. Para ello nos vamos hasta nuestro diagrama de clases y elegimos en el menú Generar la opción Generar todas las clases… y elegimos las clases que queramos generar y la ruta donde se crearán los archivos.

Después de esto obtendremos un fichero por cada una de las clases, por ejemplo para la clase artículo tendremos:

view plainprint?
  1. if (0 > version_compare(PHP_VERSION, ‘5′)) {  
  2. die(‘This file was generated for PHP 5′);  
  3. }  
  4.   
  5. /** 
  6. * include Comentario 
  7. * 
  8. * @author firstname and lastname of author, author@example.org 
  9. */  
  10. require_once(‘class.Comentario.php’);  
  11.   
  12. /* user defined includes */  
  13. // section -84-16-6-101-32d97df8:117d1aeef8e:-8000:0000000000000846-includes begin  
  14. // section -84-16-6-101-32d97df8:117d1aeef8e:-8000:0000000000000846-includes end  
  15.   
  16. /* user defined constants */  
  17. // section -84-16-6-101-32d97df8:117d1aeef8e:-8000:0000000000000846-constants begin  
  18. // section -84-16-6-101-32d97df8:117d1aeef8e:-8000:0000000000000846-constants end  
  19.   
  20. /** 
  21. * Esta clase representa los artículos que se escriben para el blog. 
  22. * 
  23. * @access public 
  24. * @author firstname and lastname of author, author@example.org 
  25. */  
  26. class Articulo  
  27. {  
  28. // — ATTRIBUTES —  
  29.   
  30. /** 
  31. * Identificador único 
  32. * 
  33. * @access private 
  34. * @var Integer 
  35. */  
  36. private $idarticulo = null;  
  37.   
  38. /** 
  39. * Título del artículo 
  40. * 
  41. * @access private 
  42. * @var String 
  43. */  
  44. private $titulo = null;  
  45.   
  46. /** 
  47. * Texto del artículo 
  48. * 
  49. * @access private 
  50. * @var String 
  51. */  
  52. private $cuerpo = null;  
  53.   
  54. /** 
  55. * Fecha de creación 
  56. * 
  57. * @access private 
  58. * @var Integer 
  59. */  
  60. private $fecha_creacion = null;  
  61.   
  62. // — OPERATIONS —  
  63.   
  64. /** 
  65. * En realidad esta función debería insertar un nuevo 
  66. * artículo en la BD pero de momento sólo tiene código de prueba 
  67. * 
  68. * @access public 
  69. * @author firstname and lastname of author, author@example.org 
  70. * @param  String titulo 
  71. * @param  String cuerpo 
  72. * @return Boolean 
  73. */  
  74. public function nuevoArticulo( String $titulo,  String $cuerpo)  
  75. {  
  76. $returnValue = null;  
  77.   
  78. // section -84-16-6-100–4073085f:118d2dc4603:-8000:000000000000086C begin  
  79. // section -84-16-6-100–4073085f:118d2dc4603:-8000:000000000000086C end  
  80.   
  81. return $returnValue;  
  82. }  
  83.   
  84. } /* end of class Articulo */  

Como se puede observar hay comentarios introducidos por nosotros y unas extrañas marcas que nos permitirán volver a generar código sin perder lo que hayamos escrito entre ellas. Por ejemplo añadimos la instrucción:

view plainprint?
  1. $returnValue=true;  

o sea:

view plainprint?
  1. public function nuevoArticulo( String $titulo,  String $cuerpo)  
  2. {  
  3. $returnValue = null;  
  4.   
  5. // section -84-16-6-100–4073085f:118d2dc4603:-8000:000000000000086C begin  
  6. $returnValue=true;  
  7. // section -84-16-6-100–4073085f:118d2dc4603:-8000:000000000000086C end  
  8.   
  9. return $returnValue;  
  10. }  

Ahora volvemos a Argo, añadimos otra función y volvemos a generar código:

view plainprint?
  1. */  
  2.   
  3. if (0 > version_compare(PHP_VERSION, ‘5′)) {  
  4. die(‘This file was generated for PHP 5′);  
  5. }  
  6.   
  7. /** 
  8. * include Comentario 
  9. * 
  10. * @author firstname and lastname of author, author@example.org 
  11. */  
  12. require_once(‘class.Comentario.php’);  
  13.   
  14. /* user defined includes */  
  15. // section -84-16-6-101-32d97df8:117d1aeef8e:-8000:0000000000000846-includes begin  
  16. // section -84-16-6-101-32d97df8:117d1aeef8e:-8000:0000000000000846-includes end  
  17.   
  18. /* user defined constants */  
  19. // section -84-16-6-101-32d97df8:117d1aeef8e:-8000:0000000000000846-constants begin  
  20. // section -84-16-6-101-32d97df8:117d1aeef8e:-8000:0000000000000846-constants end  
  21.   
  22. /** 
  23. * Esta clase representa los artículos que se escriben para el blog. 
  24. * 
  25. * @access public 
  26. * @author firstname and lastname of author, author@example.org 
  27. */  
  28. class Articulo  
  29. {  
  30. // — ATTRIBUTES —  
  31.   
  32. /** 
  33. * Identificador único 
  34. * 
  35. * @access private 
  36. * @var Integer 
  37. */  
  38. private $idarticulo = null;  
  39.   
  40. /** 
  41. * Título del artículo 
  42. * 
  43. * @access private 
  44. * @var String 
  45. */  
  46. private $titulo = null;  
  47.   
  48. /** 
  49. * Texto del artículo 
  50. * 
  51. * @access private 
  52. * @var String 
  53. */  
  54. private $cuerpo = null;  
  55.   
  56. /** 
  57. * Fecha de creación 
  58. * 
  59. * @access private 
  60. * @var Integer 
  61. */  
  62. private $fecha_creacion = null;  
  63.   
  64. // — OPERATIONS —  
  65.   
  66. /** 
  67. * En realidad esta función debería insertar un nuevo 
  68. * artículo en la BD pero de momento sólo tiene código de prueba 
  69. * 
  70. * @access public 
  71. * @author firstname and lastname of author, author@example.org 
  72. * @param  String titulo 
  73. * @param  String cuerpo 
  74. * @return Boolean 
  75. */  
  76. public function nuevoArticulo( String $titulo,  String $cuerpo)  
  77. {  
  78. $returnValue = null;  
  79.   
  80. // section -84-16-6-100–4073085f:118d2dc4603:-8000:000000000000086C begin  
  81. $returnValue=true;  
  82. // section -84-16-6-100–4073085f:118d2dc4603:-8000:000000000000086C end  
  83.   
  84. return $returnValue;  
  85. }  
  86.   
  87. /** 
  88. * Esta función debería borrar el artículo identificado mediante id. 
  89. * 
  90. * @access public 
  91. * @author firstname and lastname of author, author@example.org 
  92. * @param  Integer id 
  93. * @return mixed 
  94. */  
  95. public function borraArticulo( Integer $id)  
  96. {  
  97. // section -84-16-6-100–4073085f:118d2dc4603:-8000:000000000000088C begin  
  98. // section -84-16-6-100–4073085f:118d2dc4603:-8000:000000000000088C end  
  99. }  
  100.   
  101. } /* end of class Articulo */  
  102.   
  103. ?>  

¡Nuestro código sigue ahí!

Por último pasamos el proyecto por PHPDocumentor y obtenemos la documentación correspondiente.

Y eso es básicamente todo, si trabajáis en Web con PHP, os gusta modelar y tenéis tiempo para ello, ArgoUML es una gran elección.

Fuente: http://deuteria.blogspot.com/2008/03/modelando-con-argouml-aplicaciones-en.html

This entry was posted on Sunday, March 22nd, 2009 at 11:47 pm and is filed under Uncategorized. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.

Leave a Reply