Estándares de programación en JAVA

Versión 0.9.3

Lima, 2014
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

1. TABLA DE CONTENIDO

1. TABLA DE CONTENIDO 2

2. LISTA DE FIGURAS 4

3. INTRODUCCIÓN 5

4. OBJETIVO 6

5. ALCANCES 6
 Estándares de nomenclatura 6
 Estándares de codificación 6
 Convenciones de formato del código fuente 6
 Plantillas de desarrollo 7
 Prácticas de desarrollo 7

6. ESTÁNDARES DE PROGRAMACIÓN 8
6.1. ORGANIZACIÓN DEL PROYECTO 8
6.2. ESTÁNDARES DE NOMENCLATURA 10
 Nomenclatura de Paquetes 10
 Nomenclatura general de clases 11
 Nomenclatura general de interfaces 12
 Nomenclatura de JavaBeans 13
 Nomenclatura de Servlets 14
 Nomenclatura de Clases DAO o despachadoras 15
 Nomenclatura de las Clases de Negocio 16
 Nomenclatura de las Clases Action 17
 Nomenclatura de las Clases Lista 18
 Nomenclatura de los archivos JSP y HTML 19
 Nomenclatura de los documentos XML, XSL, XSD, XSLT, WML, WSDL 20
 Nomenclatura de archivos JavaScript 21
 Nomenclatura de archivos de páginas de estilos (CSS) 22
 Nomenclatura de archivos de recursos (Imágenes, PDF, jpg) 23
 Nomenclatura de objetos de Interfaz de Usuario: Controles HTML 24
 Notación de clases 25
 Notación de interfaces 27
6.3. ESTÁNDARES DE CODIFICACIÓN 29
 Accesibilidad 29
 Notación de Sentencias 29
 Manejo de errores 32
6.4. CONVENCIONES DE FORMATO DE CÓDIGO FUENTE 33
 Comentarios de código fuente 33
 Documentación de Clases e Interfaces 36
 Documentación de páginas HTML, JSP, XML, scriptlets, CSS y JS 38
 Documentación de Constructores 41
 Documentación de variables o campos miembro 41
 Documentación de Métodos 43
 Identación 44
 Tamaño de línea 44
6.5. PLANTILLAS DE DESARROLLO 45
 Plantilla de clase Java 45
 Plantilla de página JSP 46

Página 2
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Plantilla de HTML 47

7. PRÁCTICAS DE DESARROLLO 48
a) ARQUITECTURA MVC 54
 Definición de las partes 54
b) FRAMEWORKS 56
 JAKARTA STRUTS 57
 JAVASERVER FACES (JSF) 58
 HIBERNATE 59
 IBATIS 60
c) PATRONES DE DISEÑO 62
d) COMPONENTES ADICIONALES 63
 JFREECHART 63
 IREPORT 63
 JAVAMAIL 64
 POI 64
e) RECOMENDACIONES DE OPTIMIZACIÓN 64
 JDBC 65
 Excepciones 65
 Servlet y JSP 65

8. GLOSARIO 66

9. Historia de Modificación del Documento 71

10. Historia de las Revisiones 71

Página 3
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

2. LISTA DE FIGURAS

Figura 1: Ejemplo de Distribución de carpetas en el proyecto Web .................................................. 9

Figura 2: Distribución de módulos en el paquete bn.com.pe ........................................................... 10
Figura 3: Programa con 1 y con 2 threads o hilos ........................................................................... 48
Figura 4: Ciclo de vida de un Thread ............................................................................................... 50
Figura 5: Esquema del patrón MVC ................................................................................................. 55
Figura 6: Interacciones en el patrón MVC ........................................................................................ 56
Figura 7: Frameworks MVC ............................................................................................................. 56
Figura 8: Arquitectura Struts ............................................................................................................ 57
Figura 9: Diagrama de funcionamiento de JSF................................................................................ 58
Figura 10: Jerarquía de Hibernate ................................................................................................... 60
Figura 11: Diagrama de flujo de iBatis ............................................................................................. 61

Página 4
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

3. INTRODUCCIÓN
En su afán por la mejora continua en el desarrollo y mantenimiento de sistemas de
información, se ha establecido una serie de estándares y buenas prácticas a aplicar en
las tareas de desarrollo y mantenimiento de sus sistemas, en este caso específicamente
los sistemas en entorno Java.

Los estándares de programación son reglas específicas a un lenguaje que reducen

perceptiblemente el riesgo de que los desarrolladores introduzcan errores. Los
estándares permiten uniformar el código generado por los programadores involucrados
en el proyecto, a fin, de que sea fácilmente entendible para todos ellos y también para
futuros involucrados en ampliaciones o mantenimiento.

Para la redacción de esta guía, se han tenido en cuenta los siguientes principios:

 Uniformizar el método de desarrollo para facilitar el intercambio del conocimiento

de los sistemas entre los desarrolladores.
 Ayudar a los desarrolladores, independientemente de su experiencia, a producir un
código de alta calidad, reducir su tiempo de desarrollo, esfuerzo y por ende el costo
del proyecto.
 Simplificar el mantenimiento del software en todo su tiempo de vida, que se
expande hasta después de sus autores originales.
 Utilizar el concepto de reusabilidad, generando librerías de objetos y
procedimientos almacenados con código probado, eficiente y mantenible.

Este documento está dirigido a analistas, diseñadores, administradores de base de datos,

analistas programadores y programadores, con el fin de homogeneizar el desarrollo de
los sistemas en la Institución.

Página 5
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

4. OBJETIVO

Los estándares que se presentan a continuación han sido elaborados con la finalidad de
establecer una guía que permita identificar en forma clara el código de las aplicaciones
desarrolladas bajo el entorno Java, los cuales se basan en una arquitectura distribuida
(Modelo MVC) que permita en primer lugar tener una codificación clara, que permita el re-
uso de clases y con facilidad para el mantenimiento.

5. ALCANCES

Los alcances del presente documento son los siguientes:

 Estándares de nomenclatura
En esta sección se detallan los estándares para la definición de los nombres físicos
que se usan en los diferentes componentes Java durante el desarrollo del sistema.
Estas notaciones se basan en las recomendaciones de los creadores de Java y se
aplican sobre los siguientes componentes:
 Paquetes
 Clases
 Interfaces
 Archivos

 Estándares de codificación
Se definen los estándares a utilizar para la declaración de variables, constantes, y
métodos, así como la notación de sentencias (condicionales y de bucle) y el manejo
de errores.
El seguimiento de los estándares y convenciones definidos facilitarán las labores de
mantenimiento y actualización de las aplicaciones desarrolladas.

 Convenciones de formato del código fuente

Se definen las convenciones estructurales: definición de comentarios y
documentación, identación, tamaño de línea y cortes de línea en base a los
estándares de codificación ya definidos para Java.

Página 6
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Plantillas de desarrollo
Se establecen las plantillas para los principales documentos Java que se emplearán
en el desarrollo del sistema:
 Páginas JSP
 Clases Java
 Páginas HTML
 Páginas XML

 Prácticas de desarrollo
Se exponen un conjunto de buenas prácticas para el desarrollo de aplicaciones Web
basadas en el uso de la arquitectura MVC, frameworks, patrones de diseño,
recomendaciones de optimización y componentes (API) adicionales. El objetivo de
esta sección es presentar algunas herramientas, mas no limitar al equipo de
desarrollo en su uso, el cual es libre de utilizar además aquellas que considere
óptimas en base a su experiencia.

Notas sobre el idioma:

El idioma oficial del proyecto es el español, por lo tanto para la documentación, y la
creación de nombres en el transcurso del proyecto deben ser consistentes con las reglas
de la gramática y ortografía del idioma español.

El idioma utilizado es el castellano, sin embargo no se utilizan tildes ni la letra ñ. Si se

presentase el caso de colocar en algunos nombres la letra ‘ñ’, se debe reemplazar por
‘ni’. Ejemplo año será reemplazado por anio. Esta regla debe extenderse a todos los
nombres de paquetes, clases, variables, constantes, y en general a todo lo relacionado
con programación. En esto se incluyen los nombres de directorios y carpetas en donde se
pueda guardar los códigos fuente, etc.

Observación:
Los estándares de diseño establecidos pueden consultarse en el documento titulado
“Estándares de Diseño para aplicaciones Web”. En este documento se define el
diseño de interfaz gráfica de usuario que se empleará para el desarrollo de las pantallas
que conformarán los sistemas.

Página 7
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

6. ESTÁNDARES DE PROGRAMACIÓN

6.1. ORGANIZACIÓN DEL PROYECTO

Los proyectos Web deben presentar 2 directorios base que contendrán todos los
componentes de la aplicación:
 JavaSource: Contiene todos los fuentes sin compilar (archivos .java)
 WebContent: Almacena los archivos del proyecto en ejecución (archivos .class,
.jar, y demás recursos)

Dentro del directorio WebContent se almacena la carpeta WEB-INF donde se encuentra

el archivo web.xml que contiene la configuración del proyecto donde se registran y
mapean los Servlets, el tiempo de sesión de usuario, registro de la página de arranque
del sistema, registro de bibliotecas a usarse en el sistema y otras variables más de
acuerdo a los requerimientos del proyecto. Adicionalmente, dentro de la carpeta WEB-
INF tenemos la carpeta classes (donde van todos los archivos .class distribuidos según
la conveniencia del proyecto) y la carpeta lib (para las bibliotecas adicionales (jar)).

En el nivel del directorio WebContent debemos tener una carpeta recursos que
contenga la carpeta images para las imágenes que se usan en el proyecto y la carpeta
script donde se asignen todos los archivos en javascript (.js). Los archivos .jsp y .class
se distribuirán en carpetas con nombres específicos según su funcionalidad y con letras
minúsculas (excepto la carpeta WEB-INF), como se muestra en la figura 1:

Página 8
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Figura 1: Ejemplo de Distribución de carpetas en el proyecto Web

Página 9
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

6.2. ESTÁNDARES DE NOMENCLATURA

 Nomenclatura de Paquetes

Basándose en el estándar ISO 3166 (1981), los prefijos de un nombre de paquete

único siempre se escriben en letras ASCII minúsculas. De esta manera, se tomará
como paquete base pe.AA.com dentro del cual se encontrarán los subpaquetes
detallando el área, el módulo y el tipo de clase que contiene.

Sintaxis:
pe.AA.com.[wwww].[xxxx].[yyyy]
Donde:
pe.AA.com. : estructura base de toda aplicación
[wwww][xxxx][yyyy] : nombre de paquetes

Ejemplos:
pe.AA.com.serviciosbancarios
pe.AA.com.serviciosbancarios.beans
pe.AA.com.serviciosbancarios.servlets

Figura 2: Distribución de módulos en el paquete AA.com.pe

Página 10
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura general de clases

Los nombres de clases deben ser mezclas de mayúsculas y minúsculas, con la
primera letra de cada palabra en mayúsculas (notación Camel).

Se debe:
 mantener los nombres de clases simples y descriptivos;
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura sea muy conocida como URL o HTML).
 considerar 10 palabras como máximo para el nombre de las clases.

No se debe:
 Incluir preposiciones en el nombre de la clase.

Sintaxis:
[Wwww][Xxxx][Yyyy].java
Donde:
[Wwww][Xxxx][Yyyy] : palabras conformadas por la clase

Ejemplos:
NotaAbono.java
GeneraReporteMoraReclamoCredito.java

Página 11
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura general de interfaces

Los nombres de las interfaces deben empezar con la letra “I” (i mayúscula) seguida
de una segunda letra mayúscula y luego minúsculas, con la primera letra de cada
palabra en mayúsculas (notación Camel).

Se debe:
 mantener los nombres de interfaces simples y descriptivos;
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 10 palabras como máximo para el nombre de las interfaces.

No se debe:
 Incluir preposiciones en el nombre de la interfaz.

Sintaxis:
I[Wwww][Xxxx][Yyyy].java
Donde:
I : denota a las clases interfaz
[Wwww][Xxxx][Yyyy] : palabras del nombre de la interfaz

Ejemplos:
IDocumentoBase.java
ISolicitudApertura.java

Página 12
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de JavaBeans
Los Java Beans, son las clases que representan alguna identidad, tabla o vista de
base de datos y estas deben contener los atributos correspondientes a los datos con
el modificador private y los métodos setters y getters (públicos) para acceder a
dichos atributos.

En cuanto al nombre de las clases este debe ser iniciado con el prefijo del
identificador del tipo de clase en mayúsculas:"B" y por ultimo se añadirá la identidad a
la que representa con la primera letra en mayúsculas.

Se debe:
 mantener los nombres de clases simples y descriptivos;
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 10 palabras como máximo para el nombre de las clases.

No se debe:
 Incluir preposiciones en el nombre de la clase.

Sintaxis:
B[Wwww][Xxxx][Yyyy].java
Donde:
B : denota a las clases JavaBean o Bean
[Wwww][Xxxx][Yyyy] : identidad a la que representa

Ejemplos:
BCuenta.java
BGarantiaHipotecaria.java

Página 13
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de Servlets
Los servlets desempeñan el papel de controladores en el sistema. Los nombres de
los Servlets deben tener como prefijo de la letra que especifica el tipo de componente
(S) seguido de la funcionalidad que controlan. Con la primera letra en mayúsculas v el
resto del nombre con la notación Camel.

Se debe:
 mantener los nombres de clases simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 10 palabras como máximo para el nombre de las clases.

No se debe:
 Incluir preposiciones en el nombre de la clase.

Sintaxis:
S[Wwww][Xxxx][Yyyy].java
Donde:
S : denota a las clases Servlet
[Wwww][Xxxx][Yyyy] : funcionalidad del Servlet

Ejemplos:
SAperAhorros.java
SCerrarSesion.java

Página 14
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de Clases DAO o despachadoras

Las clases despachadoras son las encargadas de realizar operaciones de base de
datos. Los nombres de estas deben comenzar con el prefijo de la letra que identifica
al tipo de clase (D), seguida por el nombre de la funcionalidad a la que está
relacionada. Con la primera letra en mayúsculas y el resto del nombre con la notación
Camel.

Se debe:
 mantener los nombres de clases simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 10 palabras como máximo para el nombre de las clases.

No se debe:
 Incluir preposiciones en el nombre de la clase.

Sintaxis:
D[Wwww][Xxxx][Yyyy].java
Donde:
D : denota a las clases despachador o DAO
[Wwww][Xxxx][Yyyy] : funcionalidad del despachador

Ejemplos:
DAperAhorros.java
DHojaLiquidacionDevolucion.java

Página 15
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de las Clases de Negocio

Las clases de negocio son las clases encargadas del encapsulamiento de algunas
reglas de negocio. Los nombres de estas clases comienzan con la letra que identifica
a este tipo de clases (N), luego del prefijo se coloca el nombre más representativo
para la regla de negocio que encapsula. Con la primera letra en mayúsculas v el resto
del nombre con la notación Camel.

Se debe:
 mantener los nombres de clases simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 10 palabras como máximo para el nombre de las clases.

No se debe:
 Incluir preposiciones en el nombre de la clase.

Sintaxis:
N[Wwww][Xxxx][Yyyy].java
Donde:
N : denota a las clases de negocio
[Wwww][Xxxx][Yyyy] : palabras que definen la clase de negocio

Ejemplos:
NSaldoAhorros.java (valida el saldo de la cuenta de ahorros)
NDeudaPrestamo.java

Página 16
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de las Clases Action

Una clase Action tiene por objetivo procesar una petición como elemento controlador,
mediante su método execute, devolviendo un objeto ActionForward que indica el flujo
de ejecución de la aplicación. Una clase Action es protagonista controlador en una
arquitectura Model View Controller.
Los nombres de estas clases deben comenzar con el prefijo la letra que identifica el
tipo de clase (A), luego se le debe añadir el verbo en infinitivo de la acción que realiza
y un sustantivo, con la primera letra en mayúsculas v el resto del nombre con la
notación Camel.

Se debe:
 mantener los nombres de clases simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 10 palabras como máximo para el nombre de las clases.

No se debe:
 Incluir preposiciones en el nombre de la clase.

Sintaxis:
A[Wwww][Xxxx][Yyyy].java
Donde:
A : denota a las clases Controlador
[Wwww][Xxxx][Yyyy] : palabras conformadas por la clase

Ejemplos:
ACalculaImporte.java
AGeneraEnvioNotificacion.java

Página 17
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de las Clases Lista

Las clases Lista son clases que tienen como padre una clase del tipo collection
(Vector) y que servirán para guardar una lista de objetos bean y que además tengan
métodos especiales como: ordenamiento, validaciones, etc.
Los nombres de estas clases deben comenzar con el prefijo la letra que identifica el
tipo de clase (L), luego se le debe añadir el identificador del bean que contiene, con la
primera letra en mayúsculas y el resto del nombre con la notación Camel.

Se debe:
 mantener los nombres de clases simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 10 palabras como máximo para el nombre de las clases.

No se debe:
 Incluir preposiciones en el nombre de la clase.

Sintaxis:
L[Wwww][Xxxx][Yyyy].java
Donde:
L : denota a las clases listas
[Wwww][Xxxx][Yyyy] : nombre del Bean que contiene

Ejemplos:
LApoderado.java (lista de objetos apoderado)
LAval.java

Página 18
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de los archivos JSP y HTML

Para los archivos JSP y HTML se colocará el prefijo de la opción principal a la que
pertenece (3 letras) seguido de la descripción de la acción que realiza. Los prefijos
deben ser las 3 primeras letras de la opción principal en minúsculas, por ejemplo:

Opción Prefijo
Administración adm
Ahorros aho
Solicitudes sol
Reportes rep

Nota: Los jsp que son de uso general no llevarán tal prefijo. Ejemplo: login.jsp,
index.html, errorMensaje.jsp.

Se debe:
 mantener los nombres de estos archivos simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente)
 considerar 5 palabras como máximo para el nombre de estos archivos.
 la primera letra de cada palabra posterior al prefijo y al “_” debe ser en
mayúsculas

No se debe:
 Incluir preposiciones en el nombre del archivo.

Sintaxis:
[pre]_[Wwww][Xxxx][Yyyy].[extension]
Donde:
[pre] : denota el prefijo de la opción
[Wwww][Xxxx][Yyyy] : nombre del archivo JSP ó HTML
.[extension] : extensión del archivo (.html o .jsp)

Ejemplos:
adm_RegistrarCliente.jsp
aho_BusquedaCtaAhorros.jsp
rep_MostrarListadoCtaAhorros.html

Página 19
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de los documentos XML, XSL, XSD, XSLT, WML, WSDL

Los documentos XML, XSL, XSD, XSLT, WML, WSDL contienen información de
configuración, datos y alias del sistema. Estos documentos deben empezar con
minúscula. Si está conformado por varias palabras, entonces a partir de la segunda
palabra se usará carácter en mayúscula.

Se debe:
 mantener los nombres de los documentos simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente)
 considerar 5 palabras como máximo para el nombre del documento

No se debe:
 incluir preposiciones en el nombre del documento

Sintaxis:
[wwww][Xxxx][Yyyy].[extension]
Donde:
[wwww][Xxxx][Yyyy] : nombre del documento

.[extension] : extensión XML, XSL, XSD, XSLT,

WML o WSDL

Ejemplos:
web.xml
application.xml
plantillaInicio.xsl
esquemaFactura.xsd
documentoInscripcion.xslt
mensajeSaludo.wml
interfazServicios.wsdl

Página 20
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de archivos JavaScript

Los archivos JavaScript contienen funciones y código que nos ayudarán en la
validación y presentación de los datos en los documentos Web. Estos documentos
deben empezar con minúscula. Si está conformado por varias palabras, entonces a
partir de la segunda palabra se usará carácter en mayúscula.

Se debe:
 mantener los nombres de los archivos simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 5 palabras como máximo para el nombre de estos archivos.

No se debe:
 Incluir preposiciones en el nombre del archivo.

Sintaxis:
[wwww][Xxxx][Yyyy].js
Donde:
[wwww][Xxxx][Yyyy].js : nombre del archivo

Ejemplos:
funcionesValidacion.js
utilidadesFecha.js

Página 21
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de archivos de páginas de estilos (CSS)

CSS se utiliza para dar estilo a documentos HTML y XML, separando el contenido de
la presentación. Los estilos definen la forma de mostrar los elementos HTML y XML.
Permite controlar el estilo y el formato de múltiples páginas Web al mismo tiempo.
Sus nombres deben empezar con minúscula. Si está conformado por varias palabras,
entonces a partir de la segunda palabra se usará carácter en mayúscula. Además, su
nombre debe ser representativo a su contenido.

Se debe:
 mantener los nombres de los archivos simples y descriptivos.
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 5 palabras como máximo para el nombre del archivo.

No se debe:
 Incluir preposiciones en el nombre del archivo.

Sintaxis:
[wwww][Xxxx][Yyyy].css

Donde:
[wwww][Xxxx][Yyyy].css : nombre del archivo

Ejemplos:
estilosPortal.css
estilosCabecera.css

Página 22
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de archivos de recursos (Imágenes, PDF, jpg)

Los archivos de recursos son complementarios al proyecto. Sus nombres deben
empezar con minúscula. Si está conformado por varias palabras, entonces a partir de
la segunda palabra se usará carácter en mayúscula. Además, su nombre debe ser
representativo a su contenido.

Se debe:
 mantener los nombres de los archivos simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 5 palabras como máximo para el nombre del archivo

No se debe:
 Incluir preposiciones en el nombre de estos archivos.

Sintaxis:
[wwww][Xxxx][Yyyy].[extension]
Donde:
[wwww][Xxxx][Yyyy].[extension] : nombre del archivo
[extension] : extensión del archivo (pdf, jpg, etc.)

Ejemplos:
logoAA.jpg
tarifarioCTS.pdf

3.1.1.1

Página 23
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Nomenclatura de objetos de Interfaz de Usuario: Controles HTML

Los controles HTML son objetos que definen la presentación gráfica del documento
Web con el que el cliente interactuará para el ingreso o selección de datos que serán
enviados al servidor Web. En este caso sus nombres deben empezar con minúscula.
Si está conformado por varias palabras, entonces se utilizarán los prefijos listados en
la tabla y a partir de la segunda palabra se usará carácter en mayúscula.

Objeto Prefijo
Button btn<ButtonName>
Label lbl<LabelName>
List lst<ListName>
CheckBox chk<CheckName>
Text txt<TextName>
TextArea tar<TextAreaName>
Radio rad<RadioName>
Form frm<FormName>
Hidden hdd<HiddenName>

Se debe:
 mantener los nombres de los archivos simples y descriptivos
 usar palabras completas y evitar acrónimos y abreviaturas
(a menos que la abreviatura se use muy ampliamente).
 considerar 5 palabras como máximo para el nombre de estos objetos.

No se debe:
 Incluir preposiciones en el nombre del objeto.

Ejemplos:
txtNumeroCuenta
lstPaginacion
frmDatosPrestamo

Página 24
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Notación de clases
El siguiente gráfico y tabla describen las partes de la declaración de una clase así
como el orden en el que deberían aparecer:

Parte de Declaración de
Orden
Class/Interfaz Notas

(public) (static) Class

1 Declaración de clase
<NombredeClase>
Primero las variables o
propiedades públicas de
2 (ámbito)(static) (tipo) variables la clase, luego las
protegidas y al final las
privadas.
Primero las públicas,
3 Instanciar variables protegidas y luego las
privadas.
Definición de los
4 Constructores
constructores de clase.
Los métodos deben ser
agrupados por
funcionalidad
preferentemente que por
alcance o accesibilidad.
5 Métodos Por ejemplo un método
privado puede estar entre
dos métodos públicos. El
objetivo es hacer legible y
entendible el código
fácilmente.

Página 25
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Por ejemplo:

/**
*Resumen.
*Clase de regla de Negocio
*@author
*@versión 1.00, 17/01/2007
*
*/

package pe.gob.onp.operaciones.recaudacion;

public class <NombreDeClase> {

// declaración de variables miembro de clase

/**
* Descripción del Método.
*@param campo El parámetro campo para …
* @return int
*/
public MetodoClase() {

// declaración de variables

} //Fin MetodoClase

} //Fin Clase

Página 26
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Notación de interfaces
El siguiente gráfico y tabla describe las partes de una declaración de una Interfaz, en
el orden que deberían aparecer:

Parte de Declaración de
Orden
Class/Interfaz Notas

(public) (static) Class

1 Declaración de interfaz.
<NombredeInterfaz>
Primero las variables o
propiedades públicas de la
2 (ámbito)(static) variables
clase, luego las protegidas y
al final las privadas.
Primero las públicas,
3 Instanciar variables protegidas y luego las
privadas.
Los métodos deben ser
agrupados por funcionalidad
preferentemente que por
alcance o accesibilidad. Por
4 Métodos ejemplo un método privado
puede estar entre dos
métodos públicos. El objetivo
es hacer legible y entendible
el código fácilmente.

Página 27
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Por ejemplo:

/**
*Resumen.
*Clase de regla de Negocio
*@author
*@versión 1.00, 17/01/2007
*
*/

package pe.gob.onp.operaciones.recaudacion.interfaces;

public interfaz <NombreDeInterfaz> {

// declaración de variables miembro

/**
* Descripción del Método.
* @param campo El parámetro campo para …
* @return int
*/
public MetodoClase() {

// declaración de variables

} //Fin MetodoClase

} //Fin Interfaz

Página 28
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

6.3. ESTÁNDARES DE CODIFICACIÓN

 Accesibilidad

Uno de los pilares de la programación orientada a objetos es la encapsulación, que

consiste básicamente en ocultar la información que no es conveniente o necesaria
para realizar una determinada tarea.

En Java, para acceder a las variables y métodos miembro de un objeto, se debe tener
en cuenta desde donde lo hacemos. La tabla siguiente resume los aspectos a
considerar en la accesibilidad de paquetes:

Situación del elemento private por defecto protected public

En la misma clase Sí Sí Sí Sí

En una clase en el mismo

No Sí Sí Sí
paquete

En una clase hija en otro

No No Sí Sí
paquete

En una clase no hija en otro

No No No Sí
paquete

 Notación de Sentencias
SENTENCIAS SIMPLES
Cada línea debería contener una sola expresión.

Ejemplo:
Argv++; // Correcto
Argc--; // Correcto
argv++ ; argc--; //incorrecto

SENTENCIAS COMPLEJAS O COMPUESTAS

Estas contienen sentencias simples encerradas entre llaves. Tomar referencia las
siguientes indicaciones:

Página 29
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Las sentencias incluidas deben estar identadas un nivel más que la sentencia
compuesta.

 La llave de apertura debe colocarse al final de la línea en que comienza la

sentencia compuesta; la llave de cierre debe ir al comienzo de una línea e
identarla al mismo nivel de la sentencia compuesta.

 Deben usarse llaves para todas estas sentencias cuando forman parte de una
estructura de control, como una sentencia if-else o for. Esto hace más fácil
incorporar sentencias sin que se introduzcan errores debido a llaves olvidadas.

SENTENCIAS DE RETORNO
Una expresión de retorno con un valor, no debería usar paréntesis a menos que
ayuden a visualizar mejor lo que se devuelve.

Ejemplo:
return;
return myDisk.size();
return (size ? size : defaultSize);

SENTENCIAS IF, IF-ELSE, IF ELSE-IF ELSE

Dichas expresiones deberían tener el siguiente formato:

FORMA 1
if (condition) {
statements;
}

FORMA 2
if (condition) {
statements;
} else {
statements;
}

FORMA 3
if (condition) {
statements;
} else if (condition) {
statements;
} else {
statements;
}

Página 30
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

SENTENCIAS FOR
Una expresión “for” debe de tener necesariamente la siguiente forma:

for (initialization; condition; update) {

statements;
}
Una sentencia for vacía, aquella en la que todo su trabajo está definido en las
cláusulas de inicialización, condición e incremento, debería tener la siguiente forma:

for (initializacion; condicion; incremento);

Cuando se utilice el operador coma en las cláusulas de inicialización o incremento en

la sentencia for, evitar la complejidad no utilizando más de tres variables. Si es
necesario, utilizar sentencias separadas antes del bucle for (para la cláusula de
inicialización), o al final del bucle (para la cláusula de incremento).

SENTENCIAS WHILE
Una expresión “while” debería tener el siguiente formato:

while (condition) {
statements;
}
En el caso de una sentencia while vacía, debería tener esta forma:
while (condicion);

SENTENCIAS DO-WHILE
Un “do-while” expresión debería tener le siguiente formato:
do {
statements;
} while (condition);

Página 31
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

SENTENCIAS SWITCH
Una Expresión “switch” debe de tener el siguiente formato:
switch (condicion) {
case ABC:
statements;
/* sigue la ejecución */

case DEF:
statements;
break;

case XYZ:
statements;
break;

default:
statements;
break;
}
Cada vez que una cláusula case deba seguir la ejecución en la siguiente cláusula
case, es decir, no incluya la sentencia break; es imprescindible incluir un comentario
en el lugar que ocuparía la sentencia break, tal como se muestra en el ejemplo con el
comentario /* sigue la ejecución */.

Cada sentencia switch debería incluir el caso default. Aquí la sentencia break es
redundante, pero debería incluirse siempre para evitar errores en caso de que se
añada una sentencia case posterior y se ejecute si deber hacerlo.

 Manejo de errores
El manejo de errores o excepciones en Java se hace con la instrucción “try-catch” que
debe tener el siguiente formato:
try {
statements;
} catch (ExceptionClass e) {
statements;
} finally {
statements;
}

Página 32
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

6.4. CONVENCIONES DE FORMATO DE CÓDIGO FUENTE

 Comentarios de código fuente

 DEFINICIÓN DE COMENTARIOS
Los comentarios explican la razón de la existencia de código de programación y
son muy importantes para el mantenimiento y documentación.

Java tiene tres tipos de comentarios:

 comentarios de documentación (/.** ..*/)
 comentarios de estilo-C (/* */).
 comentarios de línea única (//)

Los comentarios de documentación (conocido como "doc comments") están

delimitados por /** ... */. Los “doc comments” pueden ser extraídos a un archivo
HTML usando la herramienta javadoc. Los otros dos tipos son para dar a entender
lo que se ha programado, poniéndolo fuera del código; o para comentar acerca de
una particular implementación

 BLOQUE DE DOCUMENTACIÓN
Usados para que los comentarios persistan en el programa compilado (generación
del javadoc ó documentos HTML de ayuda). Generalmente la documentación en
estos comentarios es la descripción de la clase y la definición de cada uno de los
miembros de clase.
Deben:
 Estar precedidos por una línea en blanco.
Ejemplo:

/**
* Clase Calendario de Pagos (Definición de atributos y métodos)
*/

Página 33
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 BLOQUE DE COMENTARIOS
Usados para describir archivos, métodos, estructura de datos y algoritmos en
varias líneas.
Deben:
 Identarse conjuntamente con las líneas de código escritas.
 Estar precedidos por una línea en blanco.
Ejemplo:

/*
* Cálculo para determinar la mora de un cliente
*/

 COMENTARIOS DE UNA LÍNEA

Los comentarios cortos pueden aparecer como una sola línea identada al nivel del
código que la sigue.
Deben:
 Estar precedidos por una línea en blanco.
No deben:
 Ser utilizados para comentarios de más de 1 línea. En ese caso se debe
utilizar el formato de los bloques de comentario.
Ejemplo:
int contador = 0

/*Manejando la condición*/
if (condición){
…
}

Página 34
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 COMENTARIOS FINALES
El delimitador de comentario // puede comentar una línea completa o una línea
parcial.
Deben:
 Estar precedidos por una línea en blanco.
No deben:
 Usarse en líneas consecutivas para comentar texto; sin embargo, si puede
usarse en líneas consecutivas para comentar secciones de código.
Ejemplo:
if (condición){
…
}else{
return false; //no es un cliente
}

Página 35
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Documentación de Clases e Interfaces

Los comentarios de documentación inicial de una clase debe incluir la fecha de
creación y nombre de la empresa, luego viene su respectivo package, para que
finalmente se incluya la descripción de la clase o interfaz, la versión y su autor.

 VERSIÓN INICIAL
/**
*Resumen.
* <DESCRIPCION >
*
*@author < AUTOR>
*@versión <VERSION>, <FECHA >
*@PR [opcional]
*/
package pe.bn.com.operaciones;

public class <Nombre de Clase> {

// Código de la clase
}

 VERSIÓN MODIFICADA (garantiza control de cambios)

/**
*Resumen.
* <DESCRIPCION >
*
*@author < AUTOR>
*@versión <VERSION>, <FECHA >
*@PR [opcional]
*
* PR Modificación : PR<NUMERO PR>
* Descripción : <DESCRIPCION DEL PR>
*
* Fecha modificación : <FECHA MODIFICACION PR>
* Usuario modificación : <DESARROLLADOR DEL PR>
* <Descripción del cambio y métodos cambiados por cada PR>
*/

package pe.bn.com.operaciones;

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Inicio */

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Fin */

public MiClase {

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Inicio */

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Fin */

Página 36
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Donde:
<DESCRIPCION > Descripción de la Clase / Interfaz
< AUTOR> Apellidos y Nombre
<VERSION> Control de Versión
<FECHA > Fecha de Creación
<NUMERO PR> Número Correlativo del PR
<NUMERO ITEM> El número del Ítem del Requerimiento de Cambio.
<DESCRIPCION DEL PR> Descripción del PR
<FECHA MODIFICACION PR> Fecha en la cual se hizo la modificación del objeto con el PR
<DESARROLLADOR DEL PR> Apellidos y Nombres del Desarrollador del objeto con el PR

Ejemplo:
/**
*Resumen.
*Servlet usado para la apertura de una cuenta de Plazo Fijo
*@author Marco Márquez
*@versión 1.00, 16/05/2007
*
*
* PR Modificación : PR021
* Descripción : Considerar personas jurídicas
* Fecha modificación : 18/09/2007
* Usuario modificación : Juan Pérez.
* <Métodos modificados>
*/

package pe.bn.pe.operaciones;

public class MiClase {

// Código de la clase

Página 37
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Documentación de páginas HTML, JSP, XML, scriptlets, CSS y JS

Los documentos HTML y XML tendrán como comentario:
<!—comentario -->
Los scripts podrán usar bloques de comentarios, precedidos por una línea en
blanco y comentarios finales.

 VERSIÓN INICIAL

Para HTML, XML:

<!—
Resumen
Objeto : <NOMBRE DEL OBJETO>
Descripción : <descripción>
Fecha de creación : <fecha de creación>
PR de Creación : (Opcional, si se creo con un PR)
Autor : <Autor>
-----------------------------------------------------------------------------
Modificaciones
Motivo Fecha Nombre Descripción
----------------------------------------------------------------------------
PR00A 15/07/2007 Marco Márquez Valida envio de formulario.
PR00B 08/11/2007 Juan Pérez Cambio de Fecha.
-->

Para JSP / SCRIPTLETS:

Comentario para la cabecera del Documento.

<%--
* Resumen
* Objeto : <nombre del objeto>
* Descripción : <descripción>
* Fecha de creación : <fecha de creación>
* PR de Creación : (Opcional, si se creo con un PR)
* Autor : <Autor>
* ----------------------------------------------------------------------------------------
* Modificaciones
* Motivo Fecha Nombre Descripción
* -------------------------------------------------------------------------------------
* PR00A 15/07/2007 Marco Márquez Valida envio de formulario.
* PR00B 08/11/2007 Juan Pérez Cambio de Fecha.
--%>

Comentario para un segmento del Documento.

<%--
Comentario para un bloque del JSP / Scriptlets --%>

Página 38
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Para CSS:

/*
Resumen
Objeto : <nombre del objeto>
Descripción : <descripción>
Fecha de creación : <fecha de creación>
PR de Creación : (Opcional, si se creo con un PR)
Autor : <Autor>
-----------------------------------------------------------------------------
Modificaciones
Motivo Fecha Nombre Descripción
----------------------------------------------------------------------------
PR00A 15/07/2007 Marco Márquez Valida envio de formulario.
PR00B 08/11/2007 Juan Pérez Cambio de Fecha.
*/

Para JS:

/*
Resumen
Objeto : <nombre del objeto>
Descripción : <descripción>
Fecha de creación : <fecha de creación>
PR de Creación : (Opcional, si se creo con un PR)
Autor : <Autor>
-----------------------------------------------------------------------------
Modificaciones
Motivo Fecha Nombre Descripción
----------------------------------------------------------------------------
PR00A 15/07/2007 Marco Márquez Valida envio de formulario.
PR00B 08/11/2007 Juan Pérez Cambio de Fecha.
*/

 VERSIÓN MODIFICADA (control de cambios)

Para HTML, XML:

Dentro de las líneas de código se debe indicar algún cambio con lo siguiente.

<!— PR<NUMERO PR> - Item <NUMERO ITEM> - Inicio -->

<!— PR<NUMERO PR> - Item <NUMERO ITEM> - Fin -->

Para JSP:

Dentro de las líneas de código se debe indicar algún cambio con lo siguiente.

<%--
PR<NUMERO PR> - Item <NUMERO ITEM> - Inicio --%>

<%--
PR<NUMERO PR> - Item <NUMERO ITEM> - Fin --%>

Página 39
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Para CSS:

Dentro de las líneas de código se debe indicar algún cambio con lo siguiente.

/*
PR<NUMERO PR> - Item <NUMERO ITEM> - Inicio */
/*
PR<NUMERO PR> - Item <NUMERO ITEM> - Fin */

Para JS:

Dentro de las líneas de código se debe indicar algún cambio con lo siguiente.

/*
PR<NUMERO PR> - Item <NUMERO ITEM> - Inicio */
/*
PR<NUMERO PR> - Item <NUMERO ITEM> - Fin */

Donde:
<DESCRIPCION > Descripción del Documento HTML/JSP/XML/CSS/JS
< AUTOR> Apellidos y Nombre
<VERSION> Versión
<FECHA > Fecha de Creación
<NUMERO PR> Número Correlativo del PR
<NUMERO ITEM> El número del Ítem del Requerimiento de Cambio.
<DESCRIPCION DEL PR> Descripción del PR
<FECHA MODIFICACION PR> Fecha en la cual se hizo la modificación del PR

Ejemplo:
<!—
*Resumen.
*Documento XML de esquema de datos de empleados
*@author Marco Márquez
*@versión 1.00, 26/04/2007
*
* PR Modificación : PR021
* Descripción : Adición de propiedades al esquema
* Fecha modificación : 18/05/2007
* Usuario modificación : Juan Pérez.
-->

Página 40
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Documentación de Constructores
Utilizar el siguiente bloque de comentario como plantilla para cada constructor
declarado:

 VERSIÓN INICIAL
/**
* Resumen.
* <DESCRIPCION >
* @param nombre explicación y tipo de parámetro
* @param nombre explicación y tipo de parámetro

*
*thows nombre de excepción y explicación
*/

 POR CADA MODIFICACIÓN

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Inicio */

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Fin */

Donde:
<DESCRIPCION > Descripción del Constructor
<NUMERO PR> Numero de PR
<NUMERO ITEM> El número del Ítem del Requerimiento de Cambio

 Documentación de variables o campos miembro

Se hará con comentarios finales.

 VERSIÓN INICIAL
<AMBITO> <TIPO> <NOMBRE >; // <DESCRIPCION >

 POR CADA MODIFICACIÓN

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Inicio */

<AMBITO> <TIPO> <NOMBRE >; // <DESCRIPCION DE VARIABLE>

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Fin */

<DESCRIPCION > Descripción de la Variable

<AMBITO> Ámbito de la Variable Global / Local / Protegido
<TIPO> Tipo de Dato de la Variable
<NOMBRE > Nombre de la Variable

Página 41
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

<NUMERO PR> Numero de PR

<NUMERO ITEM> El número del Ítem del Requerimiento de Cambio.
Ejemplo:

var sueldo; // Sueldo bruto que percibe un empleado

/* PR021 - Item 1 - Inicio */

var sueldoNeto; // Sueldo neto que percibe un empleado

/* PR021 - Item 1 - Fin */

Página 42
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Documentación de Métodos
Los comentarios de documentación de un método deberán incluir la descripción
del método, los tipos de argumentos que recibe y el tipo de retorno

 VERSIÓN INICIAL
/**
* <DESCRIPCION>
*@param nombre explicación y tipo de parámetro 1
*@param nombre explicación y tipo de parámetro 2
..
*@param nombre explicación y tipo de parámetro N
* @ return Explicación del valor de retorno del método
* thows nombre de excepción y explicación
*/

<AMBITO> <TIPO> <NOMBRE MÉTODO > (<PARAMETROS>) {

return campo;

} // Fin <NOMBRE MÉTODO>

 POR CADA CAMBIO

/**
* <DESCRIPCION>
*@param campo El parámetro campo para …
* @return int
*/
<AMBITO> <TIPO> <NOMBRE MÉTODO > (<PARAMETROS>) {

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Inicio */

var sueldo; // Sueldo bruto que percibe un empleado

/* PR<NUMERO PR> - Item <NUMERO ITEM> - Fin */

} // Fin <NOMBRE MÉTODO>

<DESCRIPCION > Descripción del Método

<AMBITO> Ámbito del Método Global / Local / Protegido
<TIPO> Tipo de Dato de retorno del Método
<NOMBRE MÉTODO > Nombre del Método
<PARAMETROS> Lista de parámetros del Método
<NUMERO PR> Número de PR
El número del Ítem del Requerimiento de
<NUMERO ITEM>
Cambio.

Página 43
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Ejemplo:

/**
* Descripción del Método.
* @param campo El parámetro campo para …
* @return int
*/
public int getCampo (int campo) {

return campo;
}

 Identación
La unidad de identación son cuatro (4) espacios. De esta forma, se puede
identificar rápidamente los bloques de código, y los bloques comprendidos dentro
de ellos.

Ejemplo:
public final class Sql {
// 1 tab
static public String ejecuta(String sql) {
// 2 tabs
String mensaje= null;

try {
// 3 tabs
ConectaDB db= new ConectaDB();
Connection cn= db.getConnection();
Statement st= cn.createStatement();
st.execute(sql);
st.close();
cn.close(); …
} catch(SQLException e) {
mensaje= e.getMessage();
} catch(Exception e) {
mensaje= e.getMessage();
}

 Tamaño de línea
Las líneas de código deben tener una longitud máxima de 80 caracteres, tamaño
adecuado para el caso de impresiones de código.

Página 44
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

6.5. PLANTILLAS DE DESARROLLO

 Plantilla de clase Java

/**
*Resumen.
* <DESCRIPCION >
*
*@author < AUTOR>
*@versión <VERSION>, <FECHA >
*@PR [opcional]
*/
package pe.bn.com.operaciones.<ruta de paquetes>;

import java.<ruta de paquetes>;

import pe.bn.com.operaciones.<ruta de paquetes>;

public class <Nombre de Clase> {

/** Declaración de constantes */

/** Declaración de miembros públicos */

/** Declaración de miembros protegidos */

/** Declaración de miembros privados */

/**
* Descripción de constructor y lista de parámetros.
* @param <Nombre de parámetro 1> : <tipo y descripción de parámetro 1>
* @param <Nombre de parámetro 2> : <tipo y descripción de parámetro 2>
* @param <Nombre de parámetro N> : <tipo y descripción de parámetro N>
* */
public <NombreConstructor>(<tipo> <parámetro 1>, <tipo> <parámetro 2>, <tipo>
<parámetro N>) {

/** Cuerpo de constructor */

/**
* Descripción de método y lista de parámetros.
* @param <Nombre de parámetro 1> : <tipo y descripción de parámetro 1>
* @param <Nombre de parámetro 2> : <tipo y descripción de parámetro 2>
* @param <Nombre de parámetro N> : <tipo y descripción de parámetro N>
* @return <tipo y descripción de retorno>.
* */
<ámbito> <tipo> <nombreMetodo>(<tipo> <parámetro 1>, <tipo> <parámetro 2>, <tipo>
<parámetro N>) {

/** Cuerpo del método */

return <valor de retorno>;
}
}

Página 45
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Plantilla de página JSP

%--
* Resumen
* Objeto : <nombre del objeto>
* Descripción : <descripción>
* Fecha de creación : <fecha de creación>
* PR de Creación : (Opcional, si se creo con un PR)
* Autor : <Autor>
* ----------------------------------------------------------------------------------------
* Modificaciones
* Motivo Fecha Nombre Descripción
* -------------------------------------------------------------------------------------

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>

<%--
Lista de taglib usadas en la página JSP como la que sigue:
--%>
<%--
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
--%>

<%@ page import="pe.gob.onp.operaciones.<ruta de paquetes>" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<title>Título del JSP</title>
</head>
<body>

<%--
Código del JSP
--%>

</body>
</html>

Página 46
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Plantilla de HTML
<!—
Resumen
Objeto : <NOMBRE DEL OBJETO>
Descripción : <descripción>
Fecha de creación : <fecha de creación>
PR de Creación : (Opcional, si se creo con un PR)
Autor : <Autor>
-----------------------------------------------------------------------------
Modificaciones
Motivo Fecha Nombre Descripción
----------------------------------------------------------------------------

<! DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>
<head>
<title>Título de Documento</title>
</head>
<body>

<!-- contenido del documento HTML -->

</body>
</html>

Página 47
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

7. THREADS: PROGRAMAS MULTITAREA

Los procesadores y los Sistemas Operativos Modernos permiten la multitarea, es

decir, la realización simultánea de dos o más actividades (es lo que se aparenta). En
la realidad, un ordenador con un solo CPU no puede realizar dos actividades a la vez.
Sin embargo los sistemas operativos actuales son capaces de ejecutar varios
programas “simultáneamente” aunque sólo se disponga de un CPU: reparten el
tiempo entre dos o más actividades, o bien utilizan los tiempos muertos de una
actividad (por ejm, operaciones de lectura de datos desde el teclado) para trabajar en
la otra. En ordenadores con dos o más procesadores, la multitarea es real, ya que
cada procesador puede ejecutar un hilo o thread diferente.

Figura 3: Programa con 1 y con 2 threads o hilos

Un proceso es un programa ejecutándose de forma independiente y con un espacio

propio de memoria. Un Sistema Operativo multitarea es capaz de ejecutar más de un
proceso simultáneamente. Un thread o hilo es un flujo secuencial simple dentro de un
proceso. Un único proceso puede tener varios hilos ejecutándose. Por ejemplo el
programa Internet Explorer sería un proceso, mientras que cada una de las ventanas
que se pueden tener abiertas simultáneamente trayendo páginas HTML estaría
formada por al menos un hilo.
Un sistema multitarea da realmente la impresión de estar haciendo varias cosas a la
vez y eso es una gran ventaja para el usuario. Sin el uso de threads hay tareas que
son prácticamente imposibles de ejecutar, particularmente las que tienen tiempos de
espera importantes entre etapas.
Los threads o hilos de ejecución permiten organizar los recursos del ordenador de
forma que pueda haber varios programas actuando en paralelo. Un hilo de ejecución
puede realizar cualquier tarea que puede realizar un programa normal y corriente.
Bastará con indicar lo que tiene que hacer en el método run(), que es el que define la
actividad principal de las threads.
Los threads pueden ser daemon o no daemon. Son daemon aquellos hilos que

Página 48
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

realizan en background (en un segundo plano) servicio generales, esto es, tareas que
no forman parte de la esencia del programa y que se están ejecutando mientras no
finalice la aplicación. Un thread daemon podría ser por ejemplo aquél que está
comprobando permanentemente si el usuario pulsa un botón. Un programa de Java
finaliza cuando sólo quedan corriendo threads de tipo daemon. Por defecto, y si no se
indica lo contrario, los threads son del tipo no daemon.
7.1 Creación de THREADS
En Java hay dos formas de crear nuevos threads. La primera de ellas consiste
en crear una nueva clase que herede de la clase java.lang.thread y sobrecargar
el método run() de dicha clase. El segundo método consiste en declarar una
clase que implemente las interface java.lang.Runnable, la cual declarará el
método run(); posteriormente se crea un objeto de tipo Thread pasándole como
argumento al constructor el objeto creado de la nueva clase (la que implementa
la interface Runnable). Como ya se ha apuntado, tanto la clase Thread como la
interface Runnable pertenecen al package java.lang, por lo que no es necesario
importarlas.
A continuación se presentan dos ejemplos de creación de threads con cada uno
de los dos métodos citados.
7.1.1 Creación de threads derivando de la clase Thread
7.1.2 Creación de threads implementando la interface Runnable
7.2 Ciclo de vida de un THREAD
En el apartado anterior se ha visto cómo crear nuevos objetos que permiten
incorporar en un programa la posibilidad de realizar varias tareas
simultáneamente. En la figura (tomada del tutorial Sun) se muestran los distintos
estados por los que puede pasar un thread a lo largo de su vida. Un thread
puede presentar cuatro estados distintos:
1) Nuevo (New): El thread ha sido creado pero no inicializado, es decir, no
se ha ejecutado todavía el método Start(). Se producirá un mensaje de
error (IllegalThreadStateException) si se intenta ejecutar cualquier
método de la clase Thread distinto de Start().
2) Ejecutable (Runnable): en thread puede estar ejecutándose, siempre y
cuando se le haya asignado un determinado tiempo de CPU. En la
práctica puede no estar siendo ejecutado en un instante determinado en
beneficio de otro thread.
3) Bloqueado (Blocked o Not Runnable): El thread podría estar
ejecutándose, pero hay alguna actividad interna suya que impide, como

Página 49
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

por ejemplo una espera producida por una operación de escritura o

lectura de datos del teclado (E/S). Si un thread está en este estado, no se
le asigna tiempo de CPU.
4) Muerto (Dead): La forma habitual de que un thread muera es finalizando
el método run(). También puede llamarse al método stop() de la clase
thread, aunque dicho método es considerado “peligroso” y no se debe
utilizar.

Figura 4: Ciclo de vida de un Thread

A continuación se explicarán con mayor detenimiento los puntos anteriores.

7.2.1 Ejecución de un nuevo thread
La creación de un nuevo thread no implica necesariamente que se
empiece a ejecutar algo. Hace falta iniciarlo con el método Start(), ya que
de otro modo, cuando se intenta ejecutar cualquier método del thread;
distinto del método Stara(), se obtiene en tiempo de ejecución el error
IllegalThreadStateException.
El método Start() se encarga de llamar al método run() de la clase Thread.
Si el nuevo thread se ha creado heredando de la clase Thread la nueva
clase deberá redefinir el método run() de la clase Thread se ocupa de
llamar al método run() de la nueva clase.
Una vez que el método Start() ha sido llamado, se puede decir ya que el
thread está “corriendo” (running), lo cual no quiere decir que se esté
ejecutando en todo momento, pues ese thread tiene que compartir el
tiempo de la CPU con los demás threads que también estén running. Por
eso más bien se dice que dicha thread es runnable.

Página 50
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

7.2.2 Detener un Thread temporalmente: Runnable – Not Runnable

El sistema operative se ocupa de asignar tiempos de CPU a los distintos
threads que se estén ejecutando simultáneamente. Aún en el caso de
disponer de un ordenador con más de un procesador, el número de
threads simultáneos suele siempre superar el número de CPUs, por lo que
se debe repartir el tiempo de forma que parezca que todos los procesos
corren a la vez (quizás mas lentamente), aun cuando sólo unos pocos
pueden estar ejecutándose en un instante de tiempo.
Los tiempos de CPU que el sistema continuamente asigna a los distintos
threads en estado runnable se utilizan en ejecutar el método run() de cada
thread. Por diversos motivos, un thread puede en un determinado
momento renunciar “voluntariamente” a su tiempo de CPU y otorgárselo al
sistema para que se lo asigne a otro thread. Esta “renuncia” se realiza
mediante el método yield(). Es importante que este método sea utilizado
por las actividades que tienden a “monopolizar” la CPU.
El método yield() viene a indicar que en ese momento no es muy
importante para ese thread el ejecutarse continuamente y por lo tanto tener
ocupada la CPU. En caso de que ningún thread este requiriendo la CPU
para una actividad muy intensa, el sistema volverá casi de inmediato a
asignar nuevo tiempo al thread que fue “generoso” con los demás.
Si lo que desea es parar o bloquear temporalmente u thread (pasar al
estado Not Runnable), existen varias formas de hacerlo:
1) Ejecutando el método sleep() de la clase Thread. Esto detiene el
thread un tiempo pre-establecido. De ordinario el método sleep() se
llama desde el método run().
2) Ejecutando el método wait() heredado de la clase Object, a la
espera de que suceda algo que es necesario para poder continuar.
El thread volverá nuevamente a la situación de runnable mediante
los métodos notify() o notifyAll(), que se deberán ejecutar cuando
cesa la condición que tiene detenido al thread.
3) Cuando el thread está esperando para realizar operaciones de
Entrada/Salida o Input/Output (E/S ó I/O).
4) Cuando un thread está tratando de llamar a un método
synchronized de un objeto, y dicho objeto está bloqueado por otro
thread.

Página 51
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Un thread pasa automáticamente del estado Not Runnable a Runnable

cuando cesa alguna de las condiciones anteriores o cuando se llama a
notifiy() o notifyalll().
La clase Thread dispone también de un método stop(), pero no se debe
utilizar ya que puede provocar bloqueos del programa (deadlock). Hay una
última posibilidad para detener un thread, que consiste en ejecutar el
método suspend(). El thread volverá a ser ejecutable de nuevo ejecutando
el método resume(). Esta última forma también se desaconseja, por
razones similares a la utilización de método stop().
El método sleep() de la clase Thread recibe como argumento el tiempo en
milisegundos que ha de permanecer detenido. Adicionalmente, se puede
incluir un número entero con un tiempo adicional en nanosegundos. Las
declaraciones de estos métodos son las siguientes:

Public static void sleep (long millis) throws InterruptedException

Public static void sleep (long millis, int nanosecons) throws InterruptedException

Considérese el siguiente ejemplo:

System.out.println (“Contador de segundos”);

Int count=0;
Public void run (){
try{
sleep(1000);
system.out.println(count++);
}match (InterruptedException e) {}
}

Se observa que el método sleep() puede lanzar una InterruptedException

que ha de ser capturada. Así se ha hecho en este ejemplo, aunque luego
no se gestiona la excepción.
La forma preferible de detener temporalemente un thread es la utilización
conjunta de los métodos wait y notifyAll(). La principal ventaja del método
wait() frente a los métodos anteriormente descritos es que libera el
bloqueo del objeto, por lo que el resto de threads que se encuentran
esperando para actuar sobre dicho objeto pueden llamar a sus métodos.
Hay dos formas de llamar a wait():
1) Indicando el tiempo máximo que debe estar parado (en
milisegundos y con la opción de indicar también nanosegundos), de
forma análoga a sleep(). A diferencia del método sleep(), que
simplemente detiene el thread el tiempo indicado, el método wait()

Página 52
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

establece el tiempo máximo que debe estar parado. Si en ese

plazo se ejecutan los métodos notify() o notifyAll() que indican la
liberación de los objetos bloqueados, el thread continuará sin
esperar a concluir el tiempo indicado. Las dos declaraciones del
método wait() son como siguen:

Public final void wait (long timeout) throws InterruptedException

Public final void wait (long timeout, int nanos) throws InterruptedException

2) Sin argumentos, en cuyo caso el thread permanece parado hasta

que sea reinicializado explícitamente mediante los métodos notify()
o notifyAll().
Public final void wait () throws InterruptedException

Los métodos wait() y notify() han de estar incluidas en un método

synchronized, ya que de otra forma se obtendrá una excepción del tipo
IllegalMonitorStateException en tiempo de ejecución. El uso típico de wait()
es el de esperar a que se cumpla alguna determinada condición, ajena al
propio thread. Cuando ésta se cumpla, se utilizará el método notifyAll()
para avisar a los distintos threads que pueden utilizar el objeto.
7.2.3 Finalizar un thread
Un thread finaliza cuando el método run() devuelve el control, por haber
terminado lo que tenía que hacer (por ejemplo, un bucle for que se ejecuta
un número determinado de veces) o por haberse dejado de cumplir una
condición (por ejemplo, por un bucle while en el método run()). Es habitual
poner las siguientes sentencias en el caso de Applets Runnables:

public class MyApplet extends Applet implements Runnable {

// se crea una referencia tipo thread
private Thread AppletThread;
...
// método start( ) del Applet
public void Start ( ) {
If (AppletThread == null ) { // si no tiene un objeto Thread asociado
AppletThread = new Thread (this, “El propio Applet”);
AppletThread.start (); // se arranca el thread y llama a run ( )
}
}
// método stop ( ) del Applet
public void stop ( ) {
AppletThread = null; //iguala la referencia a null
}
// método run ( ) por implementer Runnable
public void run ( ) {

Página 53
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

thread myThread = Thread.currentThread();

while(mythread == AppletThread){ //hasta que se ejecute stop() de Thread
... // código a ejecutar
}
}
} // fin de la clase MyApplet

8. PRÁCTICAS DE DESARROLLO

a) ARQUITECTURA MVC

El patrón de arquitectura MVC (Model-View-Controller) es un patrón de

arquitectura de software que define la organización independiente de una
aplicación en el Modelo (Objetos de Negocio), la Vista (interfaz con el usuario u
otro sistema) y el Controlador (controlador del workflow de la aplicación). Este
modelo es ideal para aplicaciones Web debido a que define una clara separación
entre los componentes de un programa, lo cual nos permite implementarlos por
separado. Además, se cuenta con un API bien definido; de forma que se puede
reemplazar el Modelo, la Vista o el Controlador sin dificultad.

Al incorporar el modelo de arquitectura MVC a un diseño, las piezas de un

programa se pueden construir por separado y luego unirlas en tiempo de
ejecución. Si uno de los componentes, posteriormente, no funciona
adecuadamente, puede reemplazarse sin que las otras piezas se vean afectadas.
Este escenario contrasta con la aproximación monolítica típica de muchos
programas Java.

 Definición de las partes

Modelo:
Contiene los objetos que representan los datos del programa (dominio de la
aplicación).
Encapsula el estado de la aplicación.
No tiene conocimiento / Es independiente del Controlador y la Vista.
El propio sistema es el encargado de mantener enlaces entre el Modelo y sus
Vistas, y notificar a las Vistas cuando cambia el Modelo.

Página 54
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Vista:

Es el objeto que maneja la presntación visual de los datos del Modelo.

Puede acceder al Modelo pero nunca cambiar su estado.
Puede ser notificada cuando hay un cambio de estado en el Modelo.
Interactúa con el Modelo a través de una referencia al propio Modelo.
Controlador:

Reacciona a la petición del Cliente, ejecutando la acción adecuada y creando el

modelo pertinente, i.e. proporciona significado a las órdenes del usuario, actuando
sobre los datos representados por el Modelo. Cuando se realiza algún cambio,
entra en acción, bien sea por cambios en la información del Modelo o por
alteraciones de la Vista. Interactúa con el Modelo a través de una referencia al
propio Modelo.
Especificación de esquema MVC, en un esquema básico de programa, tenemos
una entrada o parámetros que llegan (INPUT), se procesan y se muestra el
resultado (OUTPUT), y se podría representar por la siguiente imagen:

El diagrama de la figura describe el procesamiento básico que se lleva a cabo

entre los tres componentes de un patrón MVC. El controlador recibe una orden y
decide quien la lleva a cabo en el modelo. Una vez que el modelo (la lógica de
negocio) termina sus operaciones, el flujo vuelve al controlador y este envía el
resultado a la vista (capa de presentación).

Figura 5: Esquema del patrón MVC

Página 55
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

INPUT
PROCESO

OUTPUT

INPUT CONTROLLER

MODEL

OUTPUT VIEW

Figura 6: Interacciones en el patrón MVC

Lenguaje Licencia Nombre

Java / J2ee Apache Grails
Java / J2ee Apache Struts
Java / J2ee Apache Beehive
Java / J2ee Apache Spring
Java / J2ee Apache Tapestry
Java / J2ee Apache Aurora
Java / J2ee Apache JavaServerFaces

Figura 7: Frameworks MVC

b) FRAMEWORKS

Un framework es la extensión de un lenguaje mediante una o más jerarquías de

clases que implementan una funcionalidad y que proveen una estructura y una
metodología de trabajo en la cual otro proyecto de software puede ser organizado
y desarrollado.

Página 56
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 JAKARTA STRUTS
Es el framework que implementa el patrón de arquitectura MVC en Java orientado
a aplicaciones Web más difundido. Su naturaleza de software libre y su
compatibilidad con todas las plataformas J2EE lo convierte en una herramienta
altamente disponible que permite reducir el tiempo de desarrollo.

El framework Struts provee su propio controlador (ActionServlet), y se integra con

otras tecnologías para proveer el modelo y la vista. La navegación se configura en
ficheros XML externos a modo de AFD con eventos. Struts organiza la lógica y
responsabilidades siguiendo la distribución del MVC.

Los principales protagonistas en Struts son los Action y los ActionForms que
mediante pantallas creadas con su biblioteca de tag, permiten mantenimientos de
datos, con navegación definida en archivos XML.

La siguiente figura muestra su arquitectura:

Figura 8: Arquitectura Struts

Más información: http://struts.apache.org/

Página 57
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 JAVASERVER FACES (JSF)

JavaServer Faces es un framework posterior a Struts, y también implementa el
patrón de arquitectura MVC (Model-View-Controller). Sin embargo, JavaServer
Faces se centra en la creación de interfaces para convertir y validar datos
ingresados por el usuario Web, muy similar a los WebForms de Microsoft en su
tecnología .NET

El uso de JSF facilita el desarrollo de aplicaciones Web por lo siguiente:

 Permite crear interfaces de usuario desde un conjunto de componentes
estándares y reutilizables por el lado del servidor.
 Proporciona un conjunto de tags para JSP (Java Server Pages) a fin de
acceder a sus componentes.
 Transparencia en la información de estados de datos ingresados y
formularios re-poblados cuando estos son mostrados para solicitar dichos
datos.
 Proporciona un framework para implementar componentes personalizados.
 Encapsula la manipulación de eventos y presentación de componentes
para que usted pueda usar las clases estándares de JSF o las clases
creadas por usted, que soportan lenguajes de marcas, como el HTML.
La tecnología JSF es un componente de interfaz de usuario en un entorno de
trabajo del lado del servidor para aplicaciones Web basadas en tecnología java.
Como se muestra en la figura, la interfaz de usuario creada con la tecnología JSF
(representada en el gráfico como miIG) corre en el servidor y se renderiza de
vuelta en el cliente.

Figura 9: Diagrama de funcionamiento de JSF

Página 58
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

La página JSP miform.jsp, es una página JSF, la cual es una página JSP que
incluye etiquetas JSF. Expresa los componentes de la interfaz de usuario
empleando unas etiquetas personalizadas definidas por la tecnología JSF. La
interfaz gráfica para la aplicación Web (representada por miIG en la figura) maneja
los objetos referencias por la página JSP. Estos objetos incluyen:

 Los componentes objetos de la interfaz de usuario que mapean las

etiquetas en la página JSP.
 Los manejadores de eventos, validadores y conversores que están
registrados en los componentes.
 Los objetos que encapsulan los datos y la funcionalidad específica de los
componentes.

Más información: http://java.sun.com/javaee/javaserverfaces/

 HIBERNATE
Hibernate es un framework que proporciona mecanismos de mapeo
objeto/relacional para definir cómo se almacenan, eliminan, actualizan y
recuperan los objetos Java, mediante archivos declarativos (XML) que permiten
establecer estas relaciones.
Además, Hibernate ofrece servicios de consulta y recuperación que pueden
optimizar los esfuerzos de desarrollo dentro de entornos SQL y JDBC.

La característica principal de Hibernate es el mapeo de clases en Java a tablas de

una base de datos (y de tipos de datos de Java hacia tipos de datos de SQL),
ofreciendo también consulta de datos y facilidades de recuperación. Hibernate
genera las sentencias SQL y libera al desarrollador del manejo manual de los
datos que resultan de la ejecución de dichas sentencias, manteniendo la
portabilidad entre todas las bases de datos con un ligero incremento en el tiempo
de ejecución.

Entre sus ventajas tenemos:

 Muy buena documentación
 Comunidad activa con muchos usuarios
 Transacciones, caché, asociaciones, poliformismo, herencia, persistencia
transitiva.

Página 59
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Potente lenguaje de Consulta (HQL) subqueries, outer joins, ordering,

proyección (report query),paginación)
 Fácil testeo

La siguiente figura muestra la jerarquía de Hibernate:

Figura 10: Jerarquía de Hibernate

Más información: http://www.hibernate.org/

 IBATIS
Apache iBatis está constituido por dos frameworks independientes que
generalmente se usan juntos: DAO y sqlMaps. El primero simplifica la
implementación del patrón de diseño Direct Access Objects (DAO) y el segundo
simplifica la persistencia de objetos en bases de datos relacionales.

A diferencia de Hibernate, iBatis NO es un ORM (Object Relational Mapper), por

lo que se pueden utilizar modelos de datos existentes o poco normalizados y,
finalmente, no es completamente transparente (el programador programa el SQL).

Página 60
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 El patrón DAO nos ayuda a organizar las tareas de persistencia (guardado,

búsqueda, recuperación, borrado, etc.) de los objetos y nos permite definir
múltiples implementaciones para un mismo objeto mediante la definición
de una interfaz. Por ejemplo, la interfaz UsuarioDao tiene los métodos
guardarUsuario(Usuario usuario), obtenerUsuario(String loginId), etc y dos
implementaciones: UsuarioMySqlDao y UsuarioLdapDao donde
implementamos las operaciones para MySql y Ldap respectivamente. Con
iBatis DAO podremos configurar cuándo usar una u otra implementación
sin necesidad de modificar código. Además, agregar un UsuarioOracleDao
será muy fácil y no implicará modificar código del resto de la aplicación.

 Cuando hacemos un análisis y diseño orientado a objetos obtenemos

nuestro modelo de clases y también diseñamos el modelo de datos donde
se almacena la información. Y siempre nos queda la tarea de conectarnos
con una base de datos, crear statements, construir selects/updates/etc,
recorrer resultsets y setear atributos de objetos, etc. para guardar, buscar,
recuperar, etc. los valores de los atributos de un objeto. iBatis sqlMap
simplifica esta tarea resumiéndola a la configuración de ficheros XML, con
SQL ANSI o propietario y funciona con prácticamente cualquier base de
datos con driver JDBC.
En la siguiente imagen podemos ver el diagrama de flujo de iBatis:

Figura 11: Diagrama de flujo de iBatis

Más información: http://ibatis.apache.org/

Página 61
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

c) PATRONES DE DISEÑO

Un patrón de diseño es una abstracción de una solución en un nivel alto. Los

patrones solucionan problemas que existen en muchos niveles de abstracción.
Hay patrones que abarcan las distintas etapas del desarrollo; desde el análisis
hasta el diseño y desde la arquitectura hasta la implementación.

Los diseñadores de software extendieron la idea de patrones de diseño al proceso

de desarrollo de software. Debido a las características que proporcionaron los
lenguajes orientados a objetos (como herencia, abstracción y encapsulamiento) les
permitieron relacionar entidades de los lenguajes de programación a entidades del
mundo real fácilmente, los diseñadores empezaron a aplicar esas características
para crear soluciones comunes y reutilizables para problemas frecuentes que
exhibían patrones similares.
Los patrones se clasifican en 3 grandes categorías basadas en su propósito:
creacionales, estructurales y de comportamiento.
 Creacionales: Patrones creacionales tratan con las formas de crear
instancias de objetos. El objetivo de estos patrones es de abstraer el proceso
de instanciación y ocultar los detalles de cómo los objetos son creados o
inicializados. Tipos de patrones creacionales:
o Creacional de la Clase
Los patrones creacionales de Clases usan la herencia como un
mecanismo para lograr la instanciación de la Clase.
o Creacional del objeto
Los patrones creacionales de objetos son más escalables y dinámicos
comparados de los patrones creacionales de Clases.
 Estructurales: Los patrones estructurales describen como las clases y
objetos pueden ser combinados para formar grandes estructuras y
proporcionar nuevas funcionalidades. Estos objetos adicionados pueden ser
incluso objetos simples u objetos compuestos. Tipos de patrones
estructurales:
o Estructural de la Clase
Los patrones estructurales de Clases usan la herencia para
proporcionar interfaces más útiles combinando la funcionalidad de
múltiples Clases.
o Estructural de Objetos
Los patrones estructurales de objetos crean objetos complejos

Página 62
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

agregando objetos individuales para construir grandes estructuras. La

composición de l patrón estructural del objeto puede ser cambiado en
tiempo de ejecución, el cual nos da flexibilidad adicional sobre los
patrones estructurales de Clases.

 Comportamiento: Los patrones de comportamiento nos ayudan a definir la

comunicación e iteración entre los objetos de un sistema. El propósito de este
patrón es reducir el acoplamiento entre los objetos. Tipos de patrones de
comportamiento:
o Comportamiento de Clase
Los patrones de comportamiento de Clases usan la herencia para
distribuir el comportamiento entre Clases.
o Comportamiento de Objeto
Los patrones de comportamiento de objetos nos permite analizar los
patrones de comunicación entre objetos interconectados, como objetos
incluidos en un objeto complejo.

d) COMPONENTES ADICIONALES

 JFREECHART
Presenta todo un conjunto de bibliotecas Java para el desarrollo de gráficos
estadísticos. La versión a usar para ONP es la 1.06, que se descarga en el
archivo jfreechart-1.0.6.zip donde se encuentran ejemplos de su uso y los
archivos .JAR que son las bibliotecas a enlazar en el proyecto.

Estás bibliotecas están disponibles en http://www.jfree.org/jfreechart/

 IREPORT
En muchos proyectos Web siempre se presentan la necesidad de imprimir
reportes, documentos impresos que sustenten el cumplimiento de un proceso, o
que ayuden a recoger información para el usuario, por lo tanto, es necesario
generar reportes en Java:

iReport, es para el diseño visual de plantillas de los reportes que se desea

construir, que finalmente serán archivos XML. La versión de iReport a usar en
ONP será 2.0.0, que se puede descargar de: http://ireport.sourceforge.net

Página 63
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Asimismo, Jasperreport, es para poder usar los reportes generados con iReport
a través de nuestras aplicaciones Java con bibliotecas (archivos JAR) que leen los
XML. La versión de Jasperreport a usar en ONP será 1.3.4, que se puede
descargar de: http://jasperreports.sourceforge.net/index.html

 JAVAMAIL
El API JavaMail es un paquete de clases para leer, componer, y enviar mensajes
vía correo electrónico. Está diseñado para proporcionar acceso independiente del
protocolo, para enviar y recibir mensajes agrupándose en dos partes: La primera
parte del API es el cómo enviar y recibir mensajes independientemente del
proveedor/protocolo. La segunda parte habla de lenguajes específicos del
protocolo como SMTP, POP, IMAP, y NNTP
Los archivos necesarios para la generación de aplicaciones que envíen emails
son:
mail.jar de la siguiente dirección http://java.sun.com/products/javamail/index.jsp
Versión para BN JavaMail 1.4
activation.jar de la siguiente dirección http://java.sun.com/products/javabeans/jaf/
Versión para BN JAF 1.1

 POI
El proyecto POI consiste en APIs para manipular varios formatos de ficheros
basados en el formato de Documento Compuesto OLE 2 de Microsoft, utilizando
Java puro. En concreto, se pueden leer y escribir ficheros MS Excel utilizando
Java.. Para más información del proyecto POI nave-gar a:
http://jakarta.apache.org/poi/index.html Versión para BN 3.0.1

Para desarrollar proyectos con POI necesitamos la biblioteca poi-2.5.1-final-

20040804.jar que puede ser descargada del URL de POI (ver párrafo anterior),
que es enlazada a nuestro proyecto como cualquier otra biblioteca.

e) RECOMENDACIONES DE OPTIMIZACIÓN

 Se recomienda usar el patrón singleton (solo una instancia para toda la

aplicación) para clases utilitarias comunes (Es una buena opción para
disminuir el número de variables de contexto).
 Minimizar el uso de System.out,println ya que involucran procesos de l/O.
 Usar StringBuffer para concatenaciones grandes.

Página 64
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 JDBC
 La estructura a emplearse en el caso se realicen las conexiones a Base de
Datos será siempre la siguiente:
Connection conn = null;
PreparedStatement pst = null;
Resultset rs = null;
Try
{
//Uso JDBC
}
catch (Exception ex)
{
//Manejar Exception y hacer rollback
}
finally
{
//cerrar conexiones clase utilitaria
}

 Usar los conceptos de Datasource por JNDI y Pool de Conexiones.

 Como regla se deben liberar o cerrar siempre las conexiones u objetos de
JDBC, para esto se utilizará una clase utilitaria dedicada al cierre de
conexiones y a la liberación de las conexiones para la administración del Pool
de Conexiones, Statements, Preparedstatements y Resultset etc.

 Excepciones
 Toda excepción debe ser controlada inclusive si se advierten excepciones del
tipo Runtime.
 Las excepciones se deben manejar generalmente en las clases de control
(Ejemplo Servlets), ya que estas son las clases que manejan el flujo de la
aplicación
 Se debe enviar a consola un mensaje de la excepción además de controlar
siempre que el flujo de la aplicación continúe (redirección a páginas de error).
 No se debe usar la impresión del Stack Trace (solo para tareas de depuración)
 Toda página JSP debe tener a una página de error.

 Servlet y JSP
 Usar el método process() en los Servlets para resolver requerimientos de los
métodos POST o GET.
 Usar nombres estándar para objetos frecuentemente usados en servlets y JSP
(session, request, response).

Página 65
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

 Minimizar el uso de objetos de sesión (si se usan, deberá removerlos al final

de la operación).
 Usar paginas de error (se debe contar con al menos una pagina de error por
funcionalidad).
 Usar Tags personalizados para tareas comunes y repetitivas (ejemplo para
mostrar listas).

9. GLOSARIO

American Standard Code for Information Interchange (ASCII).- Sistema de codificación

que convierte caracteres a números en el rango de 0 a 127. Es una parte del código ANSI
que se amplía hasta los 257 caracteres.
Aplicación.- Programa informático, que se ejecuta sin necesidad de otro programa

Applet.- Programa informático que se ejecuta necesitando de otro programa,

normalmente un navegador.

Application Programming Interfaz (API).- Conjunto de paquetes y clases Java, incluidos

en el JDK que utilizan los programadores Java para realizar sus aplicaciones.

Archivador de Java (JAR).- Formato de archivo comprimido para almacenar todos los
recursos necesarios para instalar y ejecutar un programa de Java em um archivo
individual.

Array.- Vector.

Beans Developer Kit (BDK).- Conjunto de herramientas para desarrollar JavaBeans.

Bit.- Unidad mínima de información digital que puede tomar los valores lógicos de 0 o de
1.

BDK.- Kit de Desarrollo de Beans

Kit de Desarrollo de Beans.- es un conjunto de herramientas para desarrollar JavaBeans.

Se trata de un kit no incorporado en los distintos JDK de Java.

Bloque.- Código localizado entre corchetes.

Boolean.- Tipo de datos bi-estado, que puede tomar valor de cierto (true) o falso (false).

Byte.- Secuencia de 8 bits.

Cadena.- Secuencia de caracteres.

Carácter.- Símbolo que representa información, o la codificación en una computadora.

Normalmente letras de alfabeto, números o signos ASCII.

CGI.- Common Gateway Interfaz.

Clase.- Unidad fundamental de programación en Java, que sirve como plantilla para la
creación de objetos. Una clase define datos y métodos y es la unidad de organización
básica de un programa Java.

Página 66
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Common Gateway Interfaz (CGI).- Es un lenguaje de programación que permite dotar a

las páginas Web de interactividad, construyendo una página Web correspondiente a un
enlace de hipertexto en el mismo momento en que se hace "clic" sobre el enlace. Los
script cgi pueden estar escritos en cualquier lenguaje de programación.

Common Object Requeset Broker Architecture (CORBA).- Estándar para la conexión

entre objetos distribuidos, aunque esté codificados en distintos lenguajes.

Compilador.- Programa de software que traduce código fuente en un lenguaje de

programación legible por una persona a código máquina interpretable por un ordenador.

Constante.- Valor utilizado en un programa de computadoras con la garantía de no

cambiar en tiempo de ejecución. La garantía es a menudo reforzada por el compilador.
En Java las constantes se declaran como static final.

Constructor.- Método que tiene el mismo nombre que la clase que inicia. Toma cero o
más parámetros y proporciona unos datos u operaciones iniciales dentro de una clase,
que no se pueden expresar como una simple asignación.

Conversión de tipos de datos.- Modificación de una expresión de un tipo de datos a otro.

CORBA.- Common Object Requeset Broker Architecture.

Data Access Object (DAO).- es un componente de software que suministra una interfaz
común entre la aplicación y uno o más dispositivos de almacenamiento de datos, tales
como una Base de datos o un archivo

Entero.- Un número entero, sin parte decimal, positivo o negativo.

Estructura de datos.- Una construcción de software (en memoria o en disco duro) que
contiene datos y las relaciones lógicas entre ellos.

Evento.- Un mensaje que significa n incidente importante, normalmente desde fuera del
entorno de software.

Excepción.- Un evento que ocurre durante la ejecución de un programa que interrumpe el

flujo normal de las instrucciones.

Graphical User Inteface (GUI).- Interfaz gráfica de usuario.

HTML (HyperText Markup Languaje).- Lenguaje que se utiliza para crear páginas Web.
Los programas de navegación de la Web muestran estas páginas de acuerdo con un
esquema de representación definido por el programa de navegación.

IDE.- Integral Development Environment.

Instancia.- Objeto de software construido desde una clase. Por ejemplo, puede tener una
clase avión, pero una flota de quince instancias de avión.

Integral Development Enviroment (IDE).- Una herramienta de desarrollo visual en la que

un

Interfaz Definition Language (IDL).- Herramienta mediante la cual los objetos pueden
invocar métodos de otros objetos que se encuentren en máquinas remotas, mediante
CORBA.

Página 67
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Interfaz gráfica de usuario (GUI).- Una interfaz entre la máquina y el hombre como el
Windows de Microsoft, el Mac OS, o el Sistema X Windows, que depende de pantallas de
alta resolución, un recurso gráfico de puntero como un ratón y una colección de controles
en pantalla (denominados Widgets) que el usuario puede manejar directamente.

Interfaz.- Mecanismo Java para decirle al compilador que un conjunto de métodos serán
definidos en futuras clases. (Esas clases estarán definidas para implementar la interfaz).

JAR.- Archivador de Java

Java DataBase Connectivity (JDBC).- Lenguaje estándar de Java para interactuar con
bases de datos, similar al SQL. Es independiente no sólo de la plataforma sino también
de la base de datos con que interactúe. Desde la versión 1.2 del JDK se permite
interactuar con ODBC.

Java Developer Connection (JDC).- Conexión de desarrollo en la que se publican las

versiones beta de las biliotecas de Java que se están desarrollando.

Java Foundation Classes (JFC).- Conjunto de componentes y características para

construir programas con interfaces gráficas.

Java Media Framework (JMF).- Protocolo de transmisión de datos para la reproducción

multimedia (vídeo y sonido).

Java Native Invocation (JNI).- Capacidad de Java para ejecutar código nativo, es decir,
código compilado al lenguaje máquina de un determinado ordenador. Permite a la
Máquina Virtual Java (JVM) interactuar con programas o bibliotecas escritos en otros
lenguajes (C/C++, ensamblador...). No se puede utilizar en applets, pues viola las
directrices de seguridad.

Java Runtime Environment (JRE).- Software suministrado por Sun que permite a los
programas de Java ejecutarse en una máquina de usuario. El JRE incluye la Máquina
Virtual Java (JVM).

JRE.- Java Runtime Environment.

JSP.- Java Server Page

Java Server Page.- Tecnología de script de servidor que permite que el codigo Java se
incorpore dinámicamente dentro de las paginas web (archivo HTML) y se ejecute al
utilizar las pagina, para devolver contenido dinámico a un cliente. Las JSP tienen uma
extensión de archivo .jps

JVM.- Java Virtual Machine.

Java Virtual Machine (JVM).- El intérprete de Java que ejecuta los códigos de byte en una
plataforma particular.

JavaBeans.- Paquete que permite escribir componentes software Java, que se puedan
incorporar gráficamente a otros componentes.

J2EE.- Java 2 Plataforma, Enterprise Edition

Java 2 Plataforma, Enterprise Edition.- Es una plataforma de Sun Microsystem Inc. Para
crear aplicaciones de empresa basadas en web. Los componenetes centrales de J”EE
son Eterprise JavaBeans, JavaServer Page(JSP) y servelet Java, ademas de diversas
interfaces para enlazar con recursos de información de empresas.

Página 68
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

JDK.- Java Development Kit

Java Development Kit.- Es el conjunto de herramientas proporcionadas por sun, que

permite compilar y ejecutar código java.

Método.- Conjunto de sentencias que operan sobre los datos de la clase para manipular
su estado.

Modelo.- En diseño orientado a objetos, una representación del mundo real en unas
abstracciones de software denominadas clases y la relación entre ellas.

Moldeado.- Suplantación del tipo de un objeto o variable por otro nuevo tipo.

Navegador Web.- Software que permite al usuario conectarse a un servidor de Web

utilizando Hypertext Transfer Protocol (HTTP). Microsoft Internet Explorer, Netscape
Navigator, HotJava de Sun, son populares navegadores de Web.

Navegador.- Navegador Web.

null.- Valor de Java que significa vacío.

Object DataBase Conectivity (ODBC). Lenguaje estándar de Microsoft; que utiliza un

driver del fabricante de una base de datos, para interactuar con ella, más orientado a
C/C++ que a Java.

Paquete.- Nombre de Java para una biblioteca de clases.

Parámetros formales.- Nombres utilizados dentro de una subrutina por sus parámetros.

Parámetros.- Valores u objetos pasados entre una subrutina y la rutina de llamada.

Plug-in.- Un programa de una plataforma específica diseñado para ser llamado por un
navegador Web. Utilizado con frecuencia para mostrar información que el mismo
navegador no puede mostrar.

Poliforfismo.- En diseño orientado a objetos, la habilidad de utilizar una clase derivada en

lugar de su clase base. Por ejemplo, un programador puede escribir un método
expresarse() para la clase Mamífero. Un Perro, una Vaca y un Gato se derivan de
Mamífero, y todos pueden expresarse(), aunque sus voces sean bastantes diferentes.

Proceso.- Instancia de un programa ejecutable. Por ejemplo, si inicia dos copias de un

intérprete de Java, tiene dos procesos de la máquina virtual de Java ejecutándose en su
computadora.

Servlets.- Módulos que permiten sustituir o utilizar el lenguaje Java en lugar de

programas CGI.

SQL.- Structured Query Language.

Estático.- En diseño orientado a objetos, representa la pertenencia a la clase, en vez de a

una instancia. Es un espacio compartido por todas las instancias de una clase.

Stream.- Flujo de datos. Por ejemplo las entradas y salidas de un programa.

String.- Objeto Java estandarizado en el lenguaje, que representa una cadena de

caracteres.

Página 69
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

Structured Query Language (SQL).- Lenguaje para realizar consultas a Bases de Datos
relacionales.

Subclase.- Clase descendiente de otra clase de la que hereda métodos y variables.

Superclase.- Clase de la cual heredan sus métodos y variables otras clases denominadas
subclases.

Swing.- Paquete que permite incorporar elementos gráficos en las aplicaciones, de una
manera más potente que con el AWT. Aparece en la versión 1.2 del JDK. Es no de los
componentes que están incluidos en las Java Fundation Classes, o JFC.

Thread.- Un "proceso ligero" que puede ser arrancado y utilizado más rápidamente que
por un fork o spawn. Véase también: fork, spawn y Proceso.

Unicode.- Conjunto de caracteres de 16 bits, en lugar de los 8 que soportaba ASCII. Así
se pueden representar la mayor parte de los lenguajes del mundo.

URL.- Uniform resource identifier

Uniform resource identifier.- Una secuencia de caracteres que representa recursos de

información en un sistema o en una red como, por ejemplo, Internet. Esta secuencia de
caracrteres incluye:

 El nombre abreviado del protocolo utilizado para acceder al recurso de

información.

 La información utilizada por el protocolo para ubicar el recurso de la

información.
Verificador de código de byte.- Rutinas en la máquina virtual de Java, que aseguran que las instrucciones en
el archivo de clase no violan ciertas restricciones de seguridad.

Página 70
 Versión: 0.9.3
Manual de Instalación Fecha: 15/04/2010

10. Historia de Modificación del Documento

Fecha Versión Descripción Autor

Elaboración preliminar de los
06/01/2006 0.8.1
estándares de Java
11/07/2007 0.9 Elaboración de los estándares de Java
- Adición de secciones: Convenciones
de formato de código fuente, Plantillas
de desarrollo
- Eliminación de secciones:
Generalidades sobre el lenguaje,
16/01/2008 0.9.2 estándares de diseño
- Modificación de secciones:
Introducción, Alcances, Estándares de
programación, Prácticas de Desarrollo
- Cambio en el formato general del
documento
- Modificación de secciones: Prácticas
de desarrollo, Arquitectura MVC,
Frameworks MVC
- Adición de secciónes: Threads
15/04/2010 0.9.3
Programas Multitarea, Creación de
Threads, Ciclo de vida de un Thread
- Cambio en el formato general del
documento

11. Historia de las Revisiones

Fecha Versión Descripción Autor

<dd/mmm/yy> <x.x> <detalles> <nombre>

Página 71