An Indracompany

Java Object Orieted Proramming

From technical to professional

Manual teórico
Enero, 2020

Opsait
Academic
 Opsait
Academic

Atribución-NoComercial-CompartirIgual

Compilación por Juan Adán López López

Java Object Orieted Proramming, From technical to profesional

2020, Juan Adán López López

Usted es libre de:

 Compartir — copiar y redistribuir el material en cualquier medio o formato

 Adaptar — remezclar, transformar y construir a partir del material

 Este es un resumen legible por humanos (y no un sustituto) de la licencia. Advertencia.

 Self-published [email protected]

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

2
 Opsait
Academic

Índice

1. Objetivo del Curso..................................................................................................................................... 9

2. Las necesidades....................................................................................................................................... 9
3. Características.......................................................................................................................................... 9
3.1 Desarrollo de Capacidades y Habilidades........................................................................................ 9
3.2 Escenarios de aplicación del conocimiento adquirido.....................................................................10
4. Conocimientos Teóricos.......................................................................................................................... 11
4.1 Conocimientos base....................................................................................................................... 11
4.2 Contenido del curso impartido........................................................................................................ 11
4.2.1 Java, una introducción al lenguaje.............................................................................................. 11
4.2.1.1 ¿Qué es POO?................................................................................................................ 11
4.2.1.2 ¿Qué es Java?................................................................................................................. 13
4.2.1.3 Java Core......................................................................................................................... 13
4.2.1.3.1 Componentes de Java................................................................................................ 13
4.2.1.3.2 Conceptos básicos de Java........................................................................................ 15
4.2.1.3.3 Tipos de dato primitivos.............................................................................................. 18
4.2.1.3.4 Literales....................................................................................................................... 20
4.2.1.3.5 Operadores................................................................................................................. 19
4.2.1.3.6 Controles de flujo........................................................................................................ 21
4.2.2 Herramientas y tecnologías adicionales.....................................................................................25
4.2.2.1 IDE (Integrated Development Environment).....................................................................25
4.2.2.2 Framework....................................................................................................................... 26
4.2.3 Patrones de Diseño.................................................................................................................... 27
4.2.3.1 MVC*................................................................................................................................ 27
4.2.3.2 (Data Transfer Object)...................................................................................................... 28
4.2.3.3 DAO (Data Access Object)............................................................................................... 29
4.2.3.4 Singleton.......................................................................................................................... 29
4.2.4 Inversión de control e Inyección de Dependencias.....................................................................30
4.2.4.1 Inversión de control.......................................................................................................... 30
4.2.4.2 Inyección de dependencias.............................................................................................. 30
4.2.5 Spring Framework....................................................................................................................... 30
4.2.5.1 AOP (Aspects Oriented Programming)............................................................................31
4.2.5.2 Módulos............................................................................................................................ 31
4.2.5.2.1 Core Container.................................................................................................................... 31
4.2.5.3 Anotaciones Spring.......................................................................................................... 32
4.2.5.3.1 Spring Stereotypes...................................................................................................... 32
4.2.5.3.2 Persistence................................................................................................................. 33
4.2.5.3.3 Web............................................................................................................................. 33

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

3
 Opsait
Academic

4.2.5.3.4 Anotaciones................................................................................................................ 34
4.2.5.3.4.1 Bean Annotations................................................................................................... 34
4.2.5.3.4.1.1 Spring Stereotypes.............................................................................................. 34
4.2.5.3.4.1.2 Bean.................................................................................................................... 35
4.2.5.3.4.2 Autowired............................................................................................................... 36
4.2.5.3.4.2.1 Autowired en propiedades...................................................................................36
4.2.5.3.4.2.2 Autowired en setters............................................................................................ 36
4.2.5.3.4.2.3 Autowired en constructores.................................................................................37
4.2.5.3.4.3 Scope..................................................................................................................... 38
4.2.5.3.4.3.1 Singleton.............................................................................................................. 38
4.2.5.3.4.3.2 Prototype............................................................................................................. 38
4.2.5.3.4.3.3 Request............................................................................................................... 38
4.2.5.3.4.3.4 Session................................................................................................................ 39
4.2.5.3.4.3.5 Application........................................................................................................... 39
4.2.5.4 Configuración................................................................................................................... 40
4.2.5.4.1 applicationContext.xml................................................................................................ 40
4.2.6 Java Server Faces (JSF)............................................................................................................ 41
4.2.6.1 Características de JSF..................................................................................................... 41
4.2.6.2 Lenguaje de definición de vistas de JSF..........................................................................42
4.2.6.3 Managed Beans............................................................................................................... 43
5. Prime Faces............................................................................................................................................ 45
5.1 Introducción.................................................................................................................................... 45
5.2 Añadiendo el soporte para Primefaces........................................................................................... 45
5.3 Creando una página de prueba...................................................................................................... 48
5.4 Añadir el soporte de un ManagedBean........................................................................................... 48
5.5 Comparativas con otras librerías.................................................................................................... 50
5.6 Conclusiones.................................................................................................................................. 51
6. Spring Boot.............................................................................................................................................. 51
6.1 ¿Qué es Spring Boot?.................................................................................................................... 51
6.2 Objetivo........................................................................................................................................... 53
6.3 Crear proyecto Spring Boot............................................................................................................ 53
6.4 Algunas explicaciones sobre Sprint Boot........................................................................................ 58
6.5 Ejecución del Proyecto Spring Boot................................................................................................ 59
6.6 ¿Cómo funciona Spring Boot?........................................................................................................ 61
6.7 Apéndice: Servidor de configuración.............................................................................................. 62
7. Maven...................................................................................................................................................... 64
7.1 Dependencias, directas y transitivas............................................................................................... 64
7.2 Verifique su Eclipse para ver si instala Maven o no........................................................................66
7.3 Instalar Maven en Eclipse como programa incrustado...................................................................67
7.4 Instalar independientemente Maven fuera de Eclipse....................................................................70

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

4
 Opsait
Academic

7.5 Cree un proyecto de aplicación web vacio de Maven en Eclipse....................................................80

7.6 Proyecto simple en Maven.............................................................................................................. 84
7.7 Crear un proyecto simple................................................................................................................ 85
7.8 Construyendo un proyecto simple................................................................................................... 87
7.9 Modelo de objeto de proyecto simple............................................................................................. 88
7.10 Conceptos básicos.......................................................................................................................... 89
7.11 Complementos y objetivos de Maven............................................................................................. 89
7.12 Ciclo de vida de Meaven................................................................................................................. 90
7.13 Coordenadas de Maven.................................................................................................................. 93
7.14 Repositorios Maven........................................................................................................................ 95
7.15 Gestión de dependencias de Maven............................................................................................... 96
7.16 Generación de sitios e informes...................................................................................................... 97
7.17 Resumen........................................................................................................................................ 97
8. Trabajando con bases de datos | 14h..................................................................................................... 98
8.1 ¿Qué es SQL?................................................................................................................................ 98
8.1.1 Creación y evolución de SQL...................................................................................................... 98
8.1.2 Fundamentos de SQL................................................................................................................. 99
8.1.3 DDL, DML y DCL........................................................................................................................ 99
8.1.3.1 Lenguaje de Definición de Datos.....................................................................................99
8.1.3.2 Lenguaje de Manipulación de Datos (DML)...................................................................100
8.1.3.3 Lenguaje de Control de Datos (DCL).............................................................................100
8.1.4 Sistemas de gestión de bases de datos más conocidos...........................................................100
8.1.5 Comandos y sintaxis de SQL.................................................................................................... 102
8.1.5.1 CREATE......................................................................................................................... 102
8.1.5.2 ALTER............................................................................................................................ 102
8.1.5.3 DROP............................................................................................................................. 102
8.1.5.4 TRUNCATE.................................................................................................................... 103
8.1.5.5 INSERT.......................................................................................................................... 103
8.1.5.6 UPDATE......................................................................................................................... 103
8.1.5.7 DELETE......................................................................................................................... 103
8.2 Oracle | 5h.................................................................................................................................... 104
8.2.1 Que es una base de datos........................................................................................................ 104
8.2.2 Características de la base de datos Oracle..............................................................................105
8.2.3 Ediciones de base de datos Oracle.......................................................................................... 106
8.2.4 Conceptos básicos de Oracle................................................................................................... 106
8.2.4.1 Consulta de datos:......................................................................................................... 106
8.2.4.2 Ordenar datos:............................................................................................................... 108
8.2.4.3 Filtrar datos:................................................................................................................... 108
8.2.4.4 Unir tablas...................................................................................................................... 108
8.2.4.5 Agrupar datos................................................................................................................. 108

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

5
 Opsait
Academic

8.2.4.6 Subconsulta................................................................................................................... 108

8.2.4.7 Operadores.................................................................................................................... 108
8.2.4.8 Modificar datos............................................................................................................... 110
8.2.4.9 Definición de datos......................................................................................................... 110
8.2.4.10 Tipos de datos................................................................................................................ 110
8.2.4.11 Restricciones.................................................................................................................. 111
8.2.5 Vistas de Oracle........................................................................................................................ 111
8.2.5.1 Simplificando la recuperación de datos..........................................................................111
8.2.6 PL/SQL..................................................................................................................................... 113
8.3 MySQL |4h.................................................................................................................................... 114
8.3.1 Características de MySQL........................................................................................................ 114
8.3.2 Ventajas de usar MySQL.......................................................................................................... 115
8.3.3 Historia y versiones de MySQL................................................................................................. 115
8.3.4 Principales sentencias de MySQL............................................................................................ 117
8.3.4.1 Ejemplo con Distinct....................................................................................................... 117
8.3.4.2 Ejemplo con WHERE..................................................................................................... 118
8.3.4.3 Ejemplo con AND y OR.................................................................................................. 118
8.3.4.4 Ejemplo con ORDER BY................................................................................................ 119
8.3.4.5 Ejemplo con INSERT..................................................................................................... 119
8.3.4.6 Ejemplo con UPDATE.................................................................................................... 119
8.3.4.7 Ejemplo con DELETE..................................................................................................... 120
8.3.5 Algunas operaciones básicas con MySQL................................................................................120
8.3.6 Trabajar con parámetros........................................................................................................... 122
8.3.7 Trabajando con Stored Procedures.......................................................................................... 123
8.4 Hibernate y JPA | 5h..................................................................................................................... 125
8.4.1 Funcionalidades compatibles con el marco de Hibernate.........................................................126
8.4.2 Arquitectura Hibernate.............................................................................................................. 126
8.4.2.1 Configuración................................................................................................................. 127
8.4.2.2 SessionFactory.............................................................................................................. 127
8.4.2.3 Session.......................................................................................................................... 127
8.4.2.4 Transaction.................................................................................................................... 127
8.4.2.5 Query............................................................................................................................. 128
8.4.2.6 Criterios.......................................................................................................................... 128
8.4.3 Flujo de trabajo durante la operación en Hibernate Framework:..............................................128
8.4.4 JPA Usando Hibernate............................................................................................................. 129
8.4.4.1 Paso 1............................................................................................................................ 129
8.4.4.2 Paso 2............................................................................................................................ 130
8.4.4.3 Paso 3............................................................................................................................ 130
8.4.4.3.1 Paso 3.1 Con Maven................................................................................................. 130
8.4.4.3.1.1 Paso 3.2............................................................................................................... 131

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

6
 Opsait
Academic

8.4.4.3.1.2 Paso 3.3............................................................................................................... 131

8.4.4.3.2 Paso 3.1 Sin Maven.................................................................................................. 133
8.4.4.3.2.1 Paso 3.2............................................................................................................... 133
8.4.4.3.2.2 Paso 3.3............................................................................................................... 133
8.4.4.3.2.3 Paso 3.4............................................................................................................... 133
8.4.4.4 Paso 4............................................................................................................................ 134
8.4.4.5 Paso 5............................................................................................................................ 134
8.4.4.6 Paso 6............................................................................................................................ 135
8.4.4.7 Paso 7............................................................................................................................ 135
8.4.4.8 Paso 8............................................................................................................................ 136
8.4.4.9 Paso 9............................................................................................................................ 136
8.4.4.10 Paso 10.......................................................................................................................... 136
8.4.4.11 Paso 11.......................................................................................................................... 139
9. Buenas prácticas y Estándares............................................................................................................. 140
9.1 Nombre y extensiones de los archivos......................................................................................... 140
9.1.1 Volumen de los archivos........................................................................................................... 140
9.1.2 Archivos fuente en JAVA.......................................................................................................... 140
9.1.2.1 Comentarios de inicio..................................................................................................... 140
9.1.2.2 Sentencias package e import......................................................................................... 141
9.1.2.3 Declaraciones de clases e interfaces.............................................................................141
9.1.2.4 Codificación estándar básica......................................................................................... 141
9.1.2.5 Sangría (Indentación)..................................................................................................... 141
9.1.2.6 Longitud de la línea........................................................................................................ 141
9.1.2.7 Dividiendo líneas............................................................................................................ 142
9.1.2.8 Comentarios................................................................................................................... 143
9.1.2.9 Formatos de los comentarios de implementación..........................................................143
9.1.2.10 Comentarios de bloque.................................................................................................. 143
9.1.2.11 Comentarios de una línea.............................................................................................. 144
9.1.2.12 Sentencias simples........................................................................................................ 144
9.1.2.13 Comentarios de documentación y uso de javadoc.........................................................145
9.1.3 Tags a utilizar............................................................................................................................ 145
9.1.3.1 Ejemplo de uso de los tags............................................................................................ 146
9.2 Inicialización................................................................................................................................. 147
9.2.1 Declaraciones de class e interfaces.......................................................................................... 147
9.2.2 Sentencias compuestas............................................................................................................ 148
9.2.3 Sentencias de retorno............................................................................................................... 148
9.2.4 Sentencias if............................................................................................................................. 148
9.2.5 Sentencias for........................................................................................................................... 149
9.2.6 Sentencias while....................................................................................................................... 149
9.2.7 Sentencias do-while.................................................................................................................. 149

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

7
 Opsait
Academic

9.2.8 Sentencias switch..................................................................................................................... 149

9.2.9 Sentencias try-catch................................................................................................................. 150
9.3 Convenciones de nombres........................................................................................................... 150
10. Bibliografía........................................................................................................................................ 153

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

8
 Opsait
Academic

1. Objetivo del Curso

El objetivo de este Seminario consiste en brindarle al interesado un conocimiento general de los temas
relacionados con <Temas que se verán en el curso>. Por medio de un proceso de aprendizaje basado en un
programa de estudio mixto, implementando la inducción de la teoría en la que se basa el curso y reforzando
los conocimientos adquiridos por medio de un taller práctico que permita al interesado poner en práctica
dichos conocimientos.

El objetivo de este Taller consiste en brindarle al interesado un conocimiento de nivel intermedio de los
temas relacionados con <Temas que se verán en el curso>. Por medio de un proceso de aprendizaje
basado en un programa de estudio mixto, implementando la inducción de la teoría en la que se basa el
curso y reforzando los conocimientos adquiridos por medio de un taller práctico que permita al interesado
poner en práctica dichos conocimientos. Así mismo se le brindará al interesado las herramientas y
conocimientos para integrar diferentes tecnologías y herramientas para resolver un problema común.

El objetivo de este Diplomado consiste en brindarle al interesado un conocimiento de nivel avanzado de los
temas relacionados con <Temas que se verán en el curso>. Por medio de un proceso de aprendizaje
basado en un programa de estudio mixto, implementando la inducción de la teoría en la que se basa el
curso y reforzando los conocimientos adquiridos por medio de un taller práctico que permita al interesado
poner en práctica dichos conocimientos. Así mismo se le brindará al interesado las herramientas y
conocimientos para integrar diferentes tecnologías y herramientas para resolver un problema complejo o en
su proporcionar propuestas de mejora que puedan impulsar el área a la que pertenece.

2. Las necesidades
Por medio del presente curso se busca satisfacer las necesidades de los proyectos en los que participará el
interesado durante su desarrollo como un miembro de valor dentro de la empresa. Entre las principales
necesidades que este curso pretende satisfacer se encentran las siguientes:

 Necesidad 2: Descripción de la necesidad y como se solventará por medio de este Curso.

 Necesidad 3: Descripción de la necesidad y como se solventará por medio de este Curso.
 Necesidad 4: Descripción de la necesidad y como se solventará por medio de este Curso.
 Necesidad N: Descripción de la necesidad y como se solventará por medio de este Curso.

3. Características

3.1 Desarrollo de Capacidades y Habilidades

Tras el desarrollo del curso el participante contará con las habilidades y capacidades necesarias para
afrontar los retos que se le presenten durante las ejecuciones de las actividades que le sean asignadas.

Entre las capacidades que este curso pretende desarrollar en el Participante se encuentran principalmente
las siguientes:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

9
 Opsait
Academic

Ilustración 1

3.2 Escenarios de aplicación del conocimiento adquirido.

Tras completar el presente curso el participante será capaz de desarrollar capacidades que le permitirán
lidiar con los retos que se le presenten durante la ejecución de las actividades a las que será asignado.
Entre los que se destacan los siguientes:

Ilustración 2

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

10
 Opsait
Academic

 Escenario 1: Descripción del escenario.

 Escenario 2: Descripción del escenario.
 Escenario 3: Descripción del escenario.
 Escenario 4: Descripción del escenario.
 Escenario N: Descripción del escenario.

4. Conocimientos Teóricos

4.1 Conocimientos base

Con el objetivo de desarrollar de forma correcta y ágil el presente curso será indispensable que los
interesados cuentes por lo menos con los siguientes conocimientos base, mismos que les permitirán
entender mejor el objetivo del curso así como su contenido.

 Conocimiento 1: Descripción del Conocimiento.

 Conocimiento 2: Descripción del Conocimiento.
 Conocimiento 3: Descripción del Conocimiento.
 Conocimiento 4: Descripción del Conocimiento.
 Conocimiento N: Descripción del Conocimiento.

4.2 Contenido del curso impartido

4.2.1 Java, una introducción al lenguaje

4.2.1.1 ¿Qué es POO?
La Programación Orientada a Objetos es un paradigma de programación que nos permite trasladar y/o
visualizar el código como lo tenemos en el mundo real, es decir, no es necesario pensar como máquina para
que podamos “traducir” un problema, necesidad, escenario a código, este tipo de programación nos permite
visualizar, crear y manipular entidades dentro del código como si se tratara de las reales.

Dentro de este paradigma tenemos diferentes conceptos que a continuación se explican.

Clase

Es el elemento con el que definimos las características y comportamiento de una entidad que va a existir en
nuestro programa, es decir, si en nuestro programa va a haber una entidad que refleje a una persona, en
nuestra clase se específica que va a tener un nombre, apellidos, una fecha de nacimiento, entre otros datos
que le caractericen, así como del comportamiento que una persona tendría dentro del sistema, es decir, las
acciones que va a ejecutar.

Propiedad

Como su nombre lo indica, se refiere a cada una de las propiedades o características que le darán forma al
objeto, como se mencionó anteriormente, nombre, apellidos, fecha de nacimiento, lugar de origen, pueden
ser algunas de las propiedades que definan una clase que darán pie a la creación de un objeto de tipo
persona.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

11
 Opsait
Academic

Objeto

Básicamente el elemento que da origen a este paradigma, un objeto es un elemento creado a partir de lo
definido en una clase, en resumen, podríamos definir a la clase como un molde para gelatinas, dónde se
define el tamaño de la gelatina y la forma que va a tener, y cada gelatina creada con el molde, sería un
objeto como tal, cada una tendría la misma base, pero cada gelatina tendría ya sus características propias,
como el sabor, sin embargo sigue teniendo la forma de la gelatina que fue definida en un inicio.

Encapsulamiento

Se trata de una característica propia de cada objeto creado, quiere decir que cada uno será un objeto
independiente de los demás, no compartirá información con otros objetos de manera directa y solo lo hará
por medio de métodos de acceso que son los que accederán de manera directa a la información del objeto.

Dentro de esta característica podemos encontrar una característica a la que se le denomina “modificadores
de acceso”, que básicamente consiste en el grado de accesibilidad a estos objetos por parte de otros, pero
esto lo explicaremos más adelante.

Herencia

Es una característica en la cual una clase hereda las características/propiedades de otra, añadiendo
después las suyas propias, esto quiere decir que un objeto creado tomando como base la clase hija, tendrá
las características tanto de la clase padre como de la clase hija.

Abstracción

Se trata de un proceso en cuál identificamos lo más genérico de las entidades con las que pretendemos
trabajar en nuestro sistema, siguiendo el ejemplo de persona, podemos identificar muchas entidades que
pueden ser una persona, el punto de la abstracción es identificar las características que todas éstas tienen,
es decir, ir a lo general.

Concreción/Especialización

Es el proceso contrario a la abstracción, una vez que hemos identificado las características generales,
podemos ahora a lo concreto, por ejemplo, de una clase abstracta de Persona, podemos identificar
especializaciones como Empleado, Cliente, Proveedor, todas éstas comparten las características de una
persona, y a su vez, cada una tiene las suyas propias que la definen como lo que son; cabe recalcar que no
existe un límite de abstracción o especialización, todo dependerá de cada necesidad, puede haber tantos
niveles como se requieran.

Hasta aquí no hemos creado nada de software, simplemente es un proceso previo al diseño del desarrollo,
es visualizar lo que se desarrollará, identificar el problema, beneficio, el proceso de la solución y cómo la
implementaremos, es un proceso importante dentro de cualquier desarrollo.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

12
 Opsait
Academic

4.2.1.2 ¿Qué es Java?

Cuando escuchamos de Java, generalmente pensamos en el lenguaje de programación, en ése que es tan
popular y que nos permite crear muchas soluciones tecnológicas, pensamos en errores por falta de puntos y
comas, programación Web y muchas cosas más, pero Java es más que solo un lenguaje de programación
más, Java es toda una plataforma, y aquí la vamos a conocer.

Java es generalmente conocido como un lenguaje de programación, y lo es, pero va más allá de eso, Java
es una plataforma que está conformada por diferentes elementos que trabajan en conjunto para permitir
brindar soluciones tecnológicas robustas, útiles y fáciles de usar, sin importar el sistema operativo dónde
serán ejecutadas las aplicaciones.

4.2.1.3 Java Core

Como se mencionó anteriormente, Java es una tecnología que está compuesta por diversos elementos que
ayudan crear soluciones tecnológicas, cuando se habla de Java Core, estamos hablando de un conjunto de
herramientas e implementaciones, otras tecnologías de las cuales podemos disponer para crear productos
finales, estas tecnologías están diseñadas y desarrolladas dependiendo el objetivo que pretenden atender.

4.2.1.3.1 Componentes de Java

El lenguaje Java

Se trata de un lenguaje de programación que sigue el paradigma de Programación Orientada a Objetos,

está basado en C, razón por la cual mantiene una sintaxis parecida que permite que la curva de aprendizaje
para quienes vienen de C sea menos costosa.

Las aplicaciones escritas en Java manejan una estructura de paquetes, estos son los directorios dónde se
localizan las clases, que son archivos de texto plano dónde se escriben las instrucciones que serán
finalmente compiladas, interpretadas y ejecutadas por un intérprete llamado Java Virtual Machine (JVM).

Los archivos java, como ya se mencionó, son archivos de texto plano, tienen la extensión .java.

Compilador

El compilador es un software que sirve como traductor, ya que del archivo .java genera otro archivo con
extensión .class, este último es el archivo compilado y que será interpretado por la JVM para que las
instrucciones programadas sean ejecutadas.

Java Virtual Machine (JVM)

La JVM es un software que funge como una máquina virtual, dicha máquina virtual interpreta los archivos
compilados para traducir las instrucciones programadas al lenguaje de la máquina, es la Java Virtual
Machine la que hace posible que las aplicaciones codificadas con este lenguaje de programación, sean
ejecutadas en cualquier sistema operativo, puesto que existe una JVM para cada SO, así que no importar el
SO dónde haya sido el programa, mientras esté instalado la JVM correspondiente, el programa será
ejecutado, es por esto que se define a Java como una tecnología portable.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

13
 Opsait
Academic

API de Java (JDK)

La API de Java es básicamente el conjunto de clases previamente desarrolladas en el mismo lenguaje y que
podemos utilizar para nuestro propio desarrollo, como ejemplo tenemos la mismísima clase String, que
comúnmente utilizamos para definir tipos de dato para manejar cadenas, aunque en realidad se trata de una
clase con propiedades y métodos como cualquier otra desarrollada en Java, dicha clase viene ya dentro de
una estructura de paquetes junto con muchas otras clases que podemos usar para nuestro propio
desarrollo, otros ejemplos pueden ser:

 List
 Integer
 StringBuilder
 ArrayList

Hasta aquí hablaremos sobre Java Core, estos son los componentes más generales con los que
trabajaremos, claro está que el Java Core es una plataforma muy amplia y extensa, así que sus
componentes los iremos conociendo conforme vayamos avanzando, en la ilustración 3 podemos ver un
plano de todos los componentes que forman parte de Java Core.

Ilustración 3

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

14
 Opsait
Academic

4.2.1.3.2 Conceptos básicos de Java

Ya adentrados en el tema del lenguaje de programación, también encontramos diversos conceptos básicos,
en esencia estos siguen los de la POO, naturalmente, los veremos ya más a nivel del lenguaje más otros
propios del lenguaje.

Palabras reservadas

Son palabras que se utilizan para el funcionamiento propio del lenguaje, como especificar tipos de datos,
una clase, interface o definir el nivel de accesibilidad que tendrá una variable, esto quiere decir que no
podemos utilizar estas palabras para nombrar clases, variables, métodos, y demás elementos de autoría
propia, a continuación, podemos conocer las palabras reservadas:

abastract continue for new switch

assert default goto package synchronized
boolean do if private this
break double implements protected throw
byte else import public thows
case enum instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp volatile
const float native super while

Paquete

Como ya se mencionó anteriormente, un paquete es un conjunto de directorios en los cuales se localizan las
clases de nuestro programa, un directorio puede tener N niveles y dentro de cada paquete pueden existir N
clases.

Clase

Es un archivo de texto plano con extensión .java en el cual se escriben las instrucciones a ejecutar en el
programa, es básicamente una plantilla.

La estructura básica de una clase java es la siguiente:

Sección de documentación: parte de una buena práctica de desarrollo es escribir documentación acerca de
la clase, dónde se describa el objetivo de ésta, la documentación tiene que ser clara, concisa y corta, si bien
esta sección no es indispensable para el funcionamiento de la clase, es altamente recomendable para que
sea más fácil entender el objetivo.

Declaración de paquete (package statement): Es la sección dónde se especifica el paquete dónde se

localiza la clase, recordando que un paquete es prácticamente una estructura de directorio de N niveles
dónde se pueden encontrar N clases; la manera en cómo se define esta sección es con la siguiente sintaxis:
package nombre_paquete.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

15
 Opsait
Academic

Declaración de importaciones (import statement): Es la sección dónde damos la instrucción de otras clases
que vamos a necesitar dentro de nuestra clase para su funcionamiento, dado que necesitamos funciones
que ya están desarrolladas y podemos consumirlas haciendo referencia a las clases importadas; la manera
en cómo se define esta instrucción es la siguiente: import nombre_paquete.nombre_clase; Si la clase
está dentro de una estructura de varios paquetes, cada uno se especifica con un punto dentro de la
declaración, como se especifica a continuación: import paque_padre.paquete_hijo.nombre_clase.

Definición/declaración de clase (class definition): es la sección dónde se podría decir que oficialmente inicia
la clase, aquí se define el nombre que ésta tendrá y dentro de la definición de clase finalmente comienzan a
escribirse los atributos y métodos que le darán un estado y comportamiento.

Atributos: en esta sección se definen los atributos que representan las características que tendrá la clase,
es en esta sección dónde se almacena la información que le dará identidad a un objeto creado a partir de
esta clase.

Métodos: son las funciones que finalmente ejecutan instrucciones específicas, como asignar valores, hacer
operaciones matemáticas, entre muchas otras cosas.

A continuación, en la ilustración 4 podemos ver un ejemplo de una clase sencilla:

Ilustración 4

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

16
 Opsait
Academic

Variable

Es un espacio en memoria dónde se guarda un determinado valor, para declarar una variable se especifica
el tipo de información que va a almacenar y el nombre que va a llevar dicha variable, en el siguiente ejemplo
se declara una variable para almacenar un número entero:

 int edad;

Tipado

El tipado en el lenguaje de programación Java, se refiere a que es necesario especificar el tipo de

información que va a almacenar una variable, si es que va a manipular una cadena, o bien, un número
entero.

Añadiendo a esto, las clases las podemos usar también para definir tipos de dato. (Ver apartado de Objeto).

Atributos

Como ya se mencionó en el apartado de Clase, los atributos son para definir las características de la clase,
así como una persona tiene un nombre, tiene apellidos, tiene una fecha de nacimiento, o bien, un animal
tiene un color, pertenece a una especie, posiblemente tenga un nombre también, para esto sirven los
atributos, dan una identidad a nuestra clase, estos están definidos por medio de un tipo de dato, es decir,
que tipo de información es la que van a contener, puede ser una cadena de texto, un número entero, un
número decimal, una fecha, a continuación un ejemplo de un atributo dónde se pretende “almacenar” el
valor del nombre de la clase persona:

 String nombre;

Como se puede observar, es básicamente lo mismo que definir en variable, ya que técnicamente hablando
se trata de una variable, para que se considere atributo debe cumplir con ciertas características que lo
diferenciarán de cualquier variable, como el ser una variable global, es decir, una variable que se declara a
nivel de clase, así como cumplir con el concepto de cohesión, pero esto lo veremos más adelante.

Métodos

Los métodos son rutinas que describen las acciones que se ejecutan, en estos se escribe el código
necesario para realizar operaciones matemáticas, asignar y/o cambiar valores a los atributos de la clase,
hacer cálculos complejos, etc., es básicamente dónde se existe el código necesario para que se ejecuten
instrucciones específicas de acciones.

El método está conformado de dos elementos principales:

Firma: especifica el nombre del método y los parámetros que va a recibir

Cuerpo: especifica como tal las instrucciones que se van a ejecutar.

Los métodos pueden o no regresar un valor o no.

Objeto (Instancia)

Un objeto, coloquialmente conocido también y más comúnmente como instancia, es una unidad creada en
base a una clase, tiene un estado, que es el valor de cada uno de los atributos y un comportamiento, que
corresponde a los métodos.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

17
 Opsait
Academic

La manera de crear una instancia es con la palabra reservada new.

Persona personaUno = new Persona ();

Como se observa en el ejemplo anterior, la creación de una instancia u objeto, requiere de la

implementación de 2 características mencionadas anteriormente, la creación de una variable, y definir su
tipo, en este caso, estamos creando una variable llamada personaUno de tipo Persona, a dicha variable le
estamos asignando un valor con la instrucción new Persona(), con la palabra reservada new estamos dando
la indicación de la creación de un nuevo objeto de tipo Persona, es entonces cuando tenemos un objeto o
instancia.

Constructores

Los constructores son el mecanismo con el que se crean nuevas instancias de una clase, su mecanismo se
puede comparar con el de un método, pues tienen firma, pueden recibir parámetros e incluso puede ejecutar
tareas como lo hace un método, se difieren de un método porque primeramente debe ser nombrado
exactamente igual que la clase anfitrión, en segunda, los constructores solo son ejecutados al momento de
la creación del objeto, pues como ya se mencionó anteriormente, son precisamente el mecanismo que
crean los objetos.

La manera en cómo se invocan los constructores ya se mostró anteriormente, utilizando la palabra

reservada new y la invocación de la firma del constructor, como a continuación se muestra.

Persona personaUno = new Persona ();

En el ejemplo anterior, mediante new se está invocando un constructor sin parámetros llamado Persona(),
esto quiere decir que no estamos enviando ningún valor desde dónde se está haciendo la invocación, esta
instrucción da como resultado una nueva instancia la cual se “almacena” en la variable personaUno,
básicamente se puede entender que la instancia generada es el valor asignado a la variable, en caso de
que no se asignara dicho valor a la variable, la instancia quedaría en el “limbo” ocupando un espacio en
memoria, hasta que llegue el “garbage collector” y elimine el objeto.

Hay que tomar en cuenta que cada que se invoca un constructor se genera un objeto nuevo, por lo que es
importante tener cuidado de no ejecutar demasiadas veces esta instrucción puesto que se generarían
demasiados objetos consumiendo recursos de más.

Interface

Las interfaces son técnicamente clases que fungen como un contrato dónde se especifica el
comportamiento general que va a tener una clase, en una interface se describen los métodos que DEBEN
ser implementados.

La estructura de una interface es básicamente la misma que la de una clase, con la diferencia de que los
métodos no están implementados, es decir, no tienen cuerpo, solo la firma.

4.2.1.3.3 Tipos de dato primitivos y Tipo Objeto

Como se mencionó anteriormente, Java se define como un lenguaje de tipado estático, es decir, que es
necesario definir el tipo de dato que van a almacenar las variables y el tipo de valor que van a regresar los
métodos, en caso de que así sea.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

18
 Opsait
Academic

Java contempla 8 tipos de dato primitivos a los cuales se les denomina tipos primitivos, es decir, son ya por
default y se llaman y clasifican de la siguiente manera.

Tipo Descripción Default Tamaño Ejemplos

boolean true o false false 1 bit true, false
entero
byte complemento de 0 8 bits 100, -50
dos
‘a’, ‘\u0041’, ‘\101’,
char carácter unicode \u0000 16 bits
‘\\’
entero
short complemento de 0 16 bits 10000,-20000
dos
entero
100000,-2,-
int complemento de 0 32 bits
1,0,1,2,-200000
dos
entero
long complemento de 0 64 bits -2L,-1L,0L,1L,2L
dos
coma flotante 1.23e100f, -1.23e-
float 0.0 32 bits
IEEE 754 100f, .3ef, 3.14f
1.2345e300d,
coma flotante
double 0.0 64 bits -1.2345e-300f,
IEEE 754
1e1d

Los tipo Objeto son muy parecidos a los primitivos a diferencia de que puedes ser nulos (null) ya que estos
son objetos o clases. Los tipos de datos son los siguiente:

Tipo Descripción Default Tamaño Ejemplos

String define y admite cadenas de null 16 bits “Programando Hola
caracteres Mundo”

Boolean puede almacenar unicamente dos null 2 bits true, false

valores: verdadero o falso.

Integer es un puntero que hace referencia null 32 bits 2,147,483,647

a una clase que contiene un
entero

Double se usan para guardar números en null 64 bits -1.79769313486231578 ,

memoria que tienen parte entera y 1.7976931348623157
parte decimal.

Long se refiere a un tipo de dato de null 64 bits 9,223,372,036,854,775,807L

punto (o coma) flotante que suele
ser más preciso que un double

Byte es un tipo de datos para un solo null 8 bit 0, 255

objeto grande que almacena
cualquier dato en una secuencia
de bytes no diferenciados.

Short Use el tipo de datos Short para null 16 bits 32,767, -32,768
contener valores enteros que no

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

19
 Opsait
Academic

requieren el ancho de datos

completo de Integer.

Float se usan para guardar números en null 32 bits 1.23e100f,-1.23e-100f, .

memoria que tienen parte entera y 3ef, 3.14f
parte decimal

Character es un solo carácter encerrado null 2 bits “a”, “b”, “z”

entre comillas simples.

Los primitivos deben ser inicializados por su respectivo valor lo de tipo objeto como se habia comentado
con anterioridad no. Ejemplo:

 Numéricos enteros: Son los tipos byte, short, int y long. Los 4 representan números enteros con
signo.
 Carácter: El tipo char representa un carácter codificado en el sistema Unicode.
 Numérico decimal: Los tipos float y double representan números decimales en coma flotante.
 Lógicos: El tipo boolean es el tipo de dato lógico; los dos únicos posibles valores que puede
representar un dato lógico son true y false. True y false son palabras reservadas de Java.

4.2.1.3.4 Literales
Las literales son específicamente el valor que se asigna de manera directa a las variables de tipo primitivo,
no se requiere la palabra reservada new, simplemente se inicializa la variable con un valor directo.

 Int edad = 10;

 boolean vigente = true;
 char sexo = ‘F’;

4.2.1.3.5 Operadores
Los operadores son elementos que permiten generar operaciones sobre variables y valores.

En Java se dividen los operadores en 4 grupos:

 Aritméticos
 Asignación
 Comparación
 Lógicos

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

20
 Opsait
Academic

Operadores Aritméticos

Son utilizados para ejecutar operaciones matemáticas comunes.

Considerando que:

 int a = 10;
 int b = 1

Operador Nombre Descripción Ejemplo Resultado

+ Adición Suma 2 valores a-b 11
- Substracción Resta 2 valores a-b 9
* Multiplicación Multiplica 2 valores a*b 10
/ División Divide 1 valor entre 2 a/c 10
++ Incremento Incrementa el valor de una variable de 1 en 1 a++ 11
-- Decremento Decremente el valor de una variable de 1 en 1 b++ 9
% Módulo Devuelve el residuo de una división a/c 1

Operadores de Asignación

Los operadores de asignación se utilizan para asignar valores a las variables.

Considerando que:

 int x = 2;

Operador Descripción Ejemplo Valor Final De La Variable

= Asigna un valor a la variable x=1 1
+= Suma y asigna resultado a la vez a la variable x+= 5 7
-= Resta y asigna resultado a la vez a la variable x-=1 1
*= Multiplica y asigna resultado a la vez a la variable x*=2 4
/= Divide y asigna resultado a la vez a la variable x/=2 1
%= Decremente el valor de una variable de 1 en 1 x%=2 0

Operadores de comparación

Los operadores nos permiten comparar 2 variables, el resultado siempre será un valor booleano, indicando
si pasó o no la comparación.

Considerando que:

 int x = 2;
 int y = 3;
 int z = 7;

Operador Nombre Ejemplo Ejemplo

== Igual que x == y false
!= Diferente de x != y true
> Mayor que x>y false
< Menor que x<y true
>= Mayor o igual que z >= y true
<= Menor o igual que x <= y true

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

21
 Opsait
Academic

Operadores lógicos

Los operadores lógicos se utilizan para evaluar 2 o más evaluaciones de comparación, es decir, se evalúan
2 o más valores booleanos.

 int a = 10;
 int b = 3;
 int x = 8;
 int y = 11;

Operador Nombre Descripción Ejemplo Ejemplo

a > b && y < x
Ambas comparaciones tienen que ser
&& AND verdaderas para que la evaluación completa “a” es igual a “b” y false
sea verdadera “y” es menor que
“x”
a > b || y < x
Es suficiente con que una de las evaluaciones
|| OR sea verdadera para que la validación completa “a” es igual a “b” o true
sea verdadera “y” es menor que
“x”
! NOT Niega el resultado de una evaluación, es decir !a>b false

4.2.1.3.6 Controles de flujo

Las sentencias dentro del código fuente, generalmente son ejecutas de arriba abajo conforme van
apareciendo, los controles de flujo permiten romper el flujo para tomar decisiones y ejecutar otras
instrucciones como ciclos, ejecutar otros bloques de código, etc.

En esencia, los controles de flujo son sentencias que realizan evaluaciones, en base al resultado obtenido
se ejecutan las instrucciones especificadas.

A continuación, los diferentes controles de flujo.

IF-ELSE

1. IF: valida si una o más condiciones se cumplen, en caso de que así sea, se ejecuta el código dentro
del cloque IF
2. ELSE: es una sentencia para dar una alternativa de ejecución en caso de que la sentencia “IF no se
cumpla, no es obligatorio que se especifique esta sentencia y se pueden especificar tantas
alternativas como se necesiten.
3. ELSE IF: si no se cumple la sentencia “IF”, se pueden evaluar otras opciones como alternativas de
evaluación, al igual que con “ELSE”, no es obligatoria y puede haber tantas como sean necesarias,
la única condición es que esta sentencia debe estar declarada después del “IF” y antes de “ELSE”

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

22
 Opsait
Academic

Ejemplo:

SWITCH-CASE

Se trata de una sentencia que evalúa un parámetro de entrada y si se da alguno de diversos casos, en caso
de que ningún caso se cumpla, se puede especificar un caso por default.

Como buena práctica se puede especificar un caso final, esto en escenarios en los que es necesario cerrar
recursos, por ejemplo, una consulta a base de datos.

Hasta la versión 6 de Java, solo se podían evaluar valores de tipo: byte, short, int, char, desde la versión 7
de Java, se pueden evaluar también valores de tipo String.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

23
 Opsait
Academic

FOR

Esta sentencia se utilizar para ejecutar un ciclo (bucle, loop) mientras cierta condición se cumpla, éste se
repetirá hasta que la condición cambie.

Está conformado por los siguientes elementos:

 Inicialización: es la expresión que inicializa el ciclo, es ejecuta una sola vez, al inicio del ciclo.
 Terminación: indica la condición con la que se finalizará el ciclo.
 Incremento: Incrementa (o decrementa) el valor de la variable especificada en la Inicialización.

for (initialization; termination; increment) {

//instrucciones a ejecutar dentro del ciclo

El resultado del ejemplo anterior, sería la siguiente impresión a consola:

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10

FOR EACH

Se trata de una variante de FOR, está enfocado a ejecutar un bloque de código mientras se recuperen
valores dentro de una colección.

for (tipo de dato a obtener de la colección: variable de iteración dónde se guarda objeto de iteración;
colección a recorrer) {

//instrucciones a ejecutar dentro del ciclo

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

24
 Opsait
Academic

El resultado del ejemplo anterior, sería la siguiente impresión a consola:

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10

WHILE

Es una sentencia que se ejecuta continuamente mientras se cumple una condición.

while (expresion) {

Bloque de código a ejecutar

Es importante tener cuidado con este tipo de ciclos, ya que pueden presentarse “loops infinitos”

DO-WHILE

Es una variante de la sentencia WHILE, con la diferencia de que en DO-WHILE el código se ejecutará al
menos una vez al inicio, posteriormente se realizará la validación para la ejecución del ciclo.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

25
 Opsait
Academic

BREAK

Es una sentencia que rompe la ejecución de un bloque de código dentro de un ciclo como for, for-each,
while, do-while, o bien, dentro de una sentencia switch.

CONTINUE

Se trata de una sentencia que brinca la actual iteración a la siguiente dentro de un ciclo, no rompe el ciclo
como tal, sino que solo continúa de manera directa a la siguiente.

4.2.2 Herramientas y tecnologías adicionales

En el desarrollo de software actual, se utilizan tecnologías adicionales que nos permiten complementar y
agilizar el desarrollo, podemos encontrar muchas enfocadas a diferentes objetivos, sin embargo en este
apartado nos centraremos en dos específicamente: IDEs y Frameworks.

4.2.2.1 IDE (Integrated Development Environment)

Se traduce directamente como Entorno de Desarrollo Integrado, se trata básicamente de un editor de texto
enfocado para escribir el código necesario para una aplicación así como para integrar todas aquellas
tecnologías que formarán parte de ésta, lo que lo diferencia de un editor de texto común es que los IDEs
disponen de complementos para facilitar las tareas de construcción, entre las tareas que podemos ejecutar
mediante un IDE están:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

26
 Opsait
Academic

 Escribir y depurar código

 Integrar frameworks y bibliotecas
 Ejecutar la aplicación
 Ejecutar pruebas
 Compilar

Hay diferentes tipos de IDE con soporte a diferentes lenguajes de programación y diferentes frameworks,
esto permite a estas herramientas identificar la sintaxis del lenguaje dándonos información general sobre el
estatus de nuestro código, por ejemplo, evitar la falta del famoso punto y coma en Java.

Algunos de los IDEs más utilizados son:

 Eclipse
 Spring Tool Suite
 IntellIJ
 Visual Studio
 Aptana

NetBeans

 Android Studio
 Sublime

Algunos IDEs de open source y otros requerirán de comprar una licencia para ser utilizados.
Es importante destacar que el uso de un IDE no es imprescindible para el desarrollo de una aplicación, es
decir, el IDE no es la herramienta que construye, si no que facilita la construcción, muchos líderes,
desarrolladores e incluso empresas completas se casan con IDEs específicos olvidándose de que estos son
solo facilitadores, lo verdaderamente importante es conocer el lenguaje y las tecnologías que se integrarán
en la aplicación, cada desarrollador utilizará el IDE con el que mejor se acomode, incluso hay
desarrolladores tan avanzados que prefieren trabajar su código con editores sencillos como Bloc de Notas,
vim, entre otros.

4.2.2.2 Framework
En términos de desarrollo de software, un framework es una tecnología integrada por una serie de
componentes previamente desarrollados y que atienden problemas y/o necesidades comunes y específicas
y que podemos integrar a nuestra aplicación para consumir, es como si estuviéramos preparando un platillo
al cuál agregamos diferentes ingredientes que ya han sido pre-cocinados y que solo añadimos a nuestra
receta para completarla y mejorarla.

Existen diferentes tipos de framework dependiendo el tipo de necesidad y/o problema, existen frameworks
para ofrecer soluciones en los diferentes capas de una aplicación, así como opciones específicas para cada
lenguaje de programación, así como de la plataforma en la que se pretende se ejecute la aplicación.

A menudo a los frameworks también se les denomina “bibliotecas”, o más comúnmente mal llamadas
“librerías”, la bibliotecas son también un conjunto de componentes previamente desarrollados que se
pueden implementar dentro de la aplicación, la diferencia entre un framework y una biblioteca es el nivel de
implementación, el framework forma parte de la arquitectura general de la aplicación, mientras que una
biblioteca atiende solo una necesidad en específico, no afecta a la arquitectura.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

27
 Opsait
Academic

Algunos de los frameworks más utilizados en el mercado:

 Angular
 AngularJS
 React
 JSF
 Spring Framework
 Spring Boot,
 Spring Security
 Symfony
 Grails

Los siguientes están originalmente catalogados como ORM (Object Relational Mapping), sin embargo
mantienen la naturaleza de Framework.

 Hibernate
 GORM
 Doctrine

Consideraciones
La implementación de frameworks nos da la ventaja de disminuir tiempos desarrollo, así como de brindar
mejores características a nuestra aplicación, disminuir problemas como el acoplamiento, aumentar la
mantenibilidad y escalabilidad, aunque hay que tener cuidado con su implementación, ésta no es una tarea
que se deba tomar a la ligera, puede requerir de tiempo adicional de configuración, además si la
implementación no se hace correctamente puede generar problemas a futuro, sobre todo cuando se
integran varios frameworks en una misma aplicación, es necesario contemplar qué frameworks serán
utilizados y bajo qué condiciones, se deben tomar en cuenta factores como rendimiento, soporte, seguridad,
compatibilidad, si alguno de estos factores falla, se pueden generar más problemas que beneficios.

4.2.3 Patrones de Diseño

Los patrones de diseño son técnicas de diseño de software para establecer las características que deben
tener los componentes de un programa, estos patrones se definen en base al objetivo que persiguen los
diferentes componentes de la aplicación, en esencia, los patrones de diseño están enfocados a resolver
necesidades en específico.

Los patrones de diseño son parte de la definición de arquitectura de una aplicación.

Existen diversos patrones de diseño, a continuación, veremos los más comunes y utilizados.

4.2.3.1 MVC*
El patrón de diseño de modelo-vista-controlador (MVC) especifica que una aplicación consta de un modelo
de datos, presentación de información y de control de información. El patrón requiere que cada uno de estos
elementos esté separado en distintas capas y elementos por cada una de éstas.

El modelo (por ejemplo, la información de datos) contiene únicamente los datos puros de aplicación; no
contiene lógica que describe cómo pueden presentarse los datos a un usuario.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

28
 Opsait
Academic

Esta capa mantiene las operaciones relacionadas con la manipulación y comunicación de información con
origines de datos, como pueden ser bases de datos, ficheros, o hasta web services, todo depende de la
estructura del proyecto en turno.

La vista (presentación) presenta al usuario los datos del modelo. La vista sabe cómo acceder a los datos del
modelo, pero no sabe el significado de estos datos ni lo que el usuario puede hacer para manipularlos.

Por último, el controlador (por ejemplo, la información de control) está entre la vista y el modelo. Escucha los
sucesos desencadenados por la vista (u otro origen externo) y ejecuta la reacción apropiada a estos
sucesos. En la mayoría de los casos, la reacción es llamar a un método del modelo. Puesto que la vista y el
modelo están conectados a través de un mecanismo de notificación, el resultado de esta acción se reflejará
automáticamente en la vista.

La mayoría de las aplicaciones hoy en día siguen este patrón, muchas con ligeras variaciones. Por ejemplo,
algunas aplicaciones combinan la vista y el controlador en una clase porque ya están estrechamente unidos.
Todas las variaciones recomiendan enérgicamente la separación de los datos de su presentación. Esto no
sólo simplifica la estructura de una aplicación, sino que también permite reutilizar el código.

4.2.3.2 (Data Transfer Object)

Se trata de un patrón de diseño de clases que encapsulan información en un solo objeto, no tienen un
comportamiento específico, es decir, no manejan regla de negocio, solo mantienen estado, su única función
es encapsular la información para manipularla en un solo objeto dentro de todas las capas de la aplicación.

Es un patrón con el que hay que tener mucho cuidado y mesura en su implementación, ya que es propenso
a generar código repetitivo y redundante.

En el siguiente ejemplo se presenta una clase DTO que contiene los datos básicos de una persona, la
finalidad de esta clase es que se generen objetos de ésta y que contengan solo esta información, no pueden
existir métodos que desarrollen regla de negocio, solo métodos utilitarios para el manejo de la información
dentro del mismo DTO.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

29
 Opsait
Academic

Es importante recalcar que se pueden crear múltiples instancias de un DTO, y cada una sería diferente

4.2.3.3 DAO (Data Access Object)

Como su nombre lo indica, es un patrón de diseño con el cual se diseñan clases que tienen la finalidad de
proporcionar métodos de acceso a datos, el uso más frecuente es el de proveer métodos de guardado,
edición, consulta y eliminación de registros en base de datos, entre otras operaciones relacionadas con
ésta, sin embargo, las operaciones con bases de datos no son las únicas, sino que también el acceso a
Web Services y ficheros también pueden considerarse acceso a datos, por lo cual se recomienda la
implementación de este patrón para dichas operaciones.

Al igual que el patrón DTO, en las clases diseñadas con DAO, no se debe desarrollar código que
implemente lógica de negocio, únicamente aquellas operaciones que sean necesarias para la operación de
comunicación con base de datos, Web Services y ficheros.

4.2.3.4 Singleton
Es un patrón de diseño que consiste en limitar la creación de objetos para que sea solo uno el que se crea y
esté disponible para todos los demás objetos dentro de la aplicación, será una instancia única, por lo cual
este tipo de patrón se recomienda para clases con métodos genéricos, clases de utilerías, etc.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

30
 Opsait
Academic

4.2.4 Inversión de control e Inyección de Dependencias.

La inversión de control e inyección de dependencias son dos principios/patrones de diseño enfocados a la
manera en cómo se deben de generar y consumir los objetos en una aplicación, trabajan de la mano con
finalidad de disminuir el acoplamiento en los componentes facilitando su desarrollo, lectura y mantenimiento,
generando un entorno de desarrollo más enfocado a una mayor productividad.

4.2.4.1 Inversión de control

Es un principio o patrón que tienen como objetivo delegar la responsabilidad del control de objetos a un
tercero como un contenedor o un framework, en contraste con el desarrollo tradicional en el cual el código
es el que se encarga de manipular otros componentes para su propio desempeño.

¿Qué ventajas tiene?

 Componentes desacoplados
 Mayor flexibilidad en cambio de implementaciones
 Mayor modularidad
 Facilidad de implementación de pruebas unitarias

4.2.4.2 Inyección de dependencias

La inyección de dependencias es un patrón de diseño que funciona a través de la inversión de control, ya
que una vez que se ha delegado la responsabilidad del control de objetos al framework, éste se encargará
de “inyectar” estos objetos dentro de otros para sean consumidos, en otras palabras, es el framework el
encargados de gestionar la creación y asignación de objetos.

4.2.5 Spring Framework

Se trata de uno de los frameworks más populares y robustos que actualmente existen, comenzó como un
contenedor de Inyección de dependencias, poco a poco fue creciendo hasta ofrecer un catálogo muy amplio
de diversos componentes para diferentes necesidades, en los próximos temas nos adentraremos a algunos
detalles para comprender de manera general cómo opera esta tecnología.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

31
 Opsait
Academic

4.2.5.1 AOP (Aspects Oriented Programming)

La Programación Orientada a Aspectos es un paradigma de programación en el cuál los componentes se
desarrollan sobre funcionalidades genéricas, es decir, funcionalidades que intervienen en la operación de
toda la aplicación.

Bajo este paradigma está diseñado e implementado Spring, dotando de componentes genéricos que dan
solución a necesidades globales y que incluso determinan la arquitectura del sistema dónde se está
implementando el framework.

4.2.5.2 Módulos
Cómo ya se mencionó con anterioridad, Spring Framework está formado por diferentes módulos que
ofrecen diferentes componentes para diferentes necesidades.

La arquitectura (ecosistema) de Spring Framework está seccionada en diferentes niveles dependiendo la

capa a la que se pretende dotar de funcionalidad adicional para facilitar el trabajo de desarrollo y dar una
estructura específica.

4.2.5.2.1 Core Container

Los módulos de Core Container son los que dieron origen al framework, como su nombre lo indica, se trata
del núcleo de framework y son los módulos encargados de llevar toda la funcionalidad relacionada con la
inversión de control e inyección de dependencias.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

32
 Opsait
Academic

spring-core-X.X.X: Este módulo es el encargado de implementar el código de inversión de control de

Spring permitiendo inyectar beans, etc.
En escencia, es este módulo el encargado de realizar las tareas que corresponden de tomar el cotrol de los
beans para posteriormente “inyectarlos” en los componentes dónde se requieran.
spring-beans-X.X.X: Este módulo es el encargado de añadir las típicas Factorías como BeanFactory,
encargada de instanciar los distintos beans registrados en el framework.
Básicamente se encarga de realizar la creación de cada uno de los objetos que el core inyectará.
spring-context-X.X.X: Este módulo es el encargado de añadir un contexto al framework y se encarga por
ejemplo de simplificar la carga de los distintos recursos. Eneste módulo se realizan las configuraciones
necesarias para que los módulos del core funcionen correctamente y acorde a las necesidades el proyecto.
spring-context-support-X.X.X: Este módulo es el encargado de añadir las clases que gestionan servicios
complementarios como Cache, Mail, Quartz etc.
spring-expression-X.X.X: Este módulo es el encargado de añadir a Spring su Expresion Language para
poder usarlo en los ficheros xml o anotaciones.
4.2.5.3 Anotaciones Spring
Antes de explicar cuáles son las anotaciones más comunes en la implementación de Spring es necesario
entender qué son.

Las anotaciones son un mecanismo para agregar metadatos para añadir información o características
adicionales al código que se está desarrollando, es decir, que son una referencia a otras funcionalidades
que ayudan a complementar nuestro código para que éste esté más completo.

Dada esta información, podemos entender que las anotaciones de Spring son utilizadas para brindar a
nuestro código funcionalidad adicional o bien, para que Spring pueda trabajar sobre estas clases, a
continuación repasaremos las más comunes, cabe destacar que para información más detallada es
aconsejable consultar el sitio oficial del framework.

4.2.5.3.1 Spring Stereotypes

Son anotaciones que forman parte del core de Spring, permiten establecer que clases gestionará Spring
para la creación de objetos y la respectiva inyección de dependencias, existen 4 diferentes estereotipos
para 4 diferentes tipos de objeto.

1. @Component: Es el estereotipo general y permite anotar un bean para que Spring lo considere uno
de sus objetos.
2. @Repository: Es el estereotipo que se encarga de dar de alta un bean para que implemente el
patrón repositorio que es el encargado de almacenar datos en una base de datos o repositorio de
información que se necesite. Al marcar el bean con esta anotación Spring aporta servicios
transversales como conversión de tipos de excepciones.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

33
 Opsait
Academic

3. @Service: Este estereotipo se encarga de gestionar las operaciones de negocio más importantes a
nivel de la aplicación y aglutina llamadas a varios repositorios de forma simultánea. Su tarea
fundamental es la de agregador.
4. @Controller: El último de los estereotipos que es el que realiza las tareas de controlador y gestión
de la comunicación entre el usuario y el aplicativo. Para ello se apoya habitualmente en algún motor
de plantillas o librería de etiquetas que facilitan la creación de páginas.

4.2.5.3.2 Persistence
Los módulos de Persistence son todos aquellos que están enfocados a brindar soporte y funcionalidad a la
capa que trabaja con la capa de persistencia, después del Core Container, son los módulos más utilizados
dentro del ecosistema de Spring.

1 spring-jdbc-X.X.X: Este módulo es el encargado de implementar el sistema de plantillas JDBC para

simplificar al máximo el código de acceso a datos que utiliza este API.
2 spring-orm-X.X.X: Este módulo es el encargado de integrar JPA e Hibernate dentro de Spring
Framework.
3 spring-messaging-X.X.X: Este módulo es el encargado de integrar en el framework la funcionalidad
de JMS.
4 spring-oxm-X.X.X: Este módulo es el encargado de integrar tecnologías XML como por ejemplo JAXB
dentro del framework.

4.2.5.3.3 Web
Los módulos orientados a Web brindan componentes para brindar soluciones para programación Web, es
decir, para aquellas aplicaciones que son expuestas a ambientes Web.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

34
 Opsait
Academic

1. spring-web-X.X.X: Este módulo es el encargado de integrar las aplicaciones web con Spring
framework. Es el caso de JSF o antiguamente Struts.
2. spring-webmvc-X.X.X: Este módulo hace referencia a Spring MVC el framework web propio de
Spring para desarrollo de aplicaciones web basadas en el modelo MVC.
3. spring-portlets-X.X.X: Este módulo es el encargado de integrar Spring con los sistemas de portales
a través del desarrollo de tus propios Portlets.
4. spring-websockets-X.X.X: Este módulo es de reciente creación y se encarga de aportar a Spring
framework las capacidades de WebSocket a nivel de servidor algo cada día más crítico en HTML5.

4.2.5.3.4 Anotaciones
Para entender el uso de anotaciones dentro de Spring es necesario primero entender qué son las
anotaciones.

Las anotaciones son un mecanismo para agregar metadatos a las clases, métodos y variables para agregar
funcionalidad adicional y dar más características, de igual manera funcionan para proporcionar información
a los frameworks sobre cómo tratar los elementos.

Dependiendo de la anotación, algunas son solo informativas y no generan ninguna diferencia más allá de
brindar información al desarrollador, tal como la anotación @Override que es parte de la misma API de
Java, esta anotación es solo informativa, indicando que un método está siendo sobre-escrito, el que se use
o no esta anotación, no genera ningún impacto en la compilación, funcionalidad ni comportamiento de la
aplicación.

Como ya se mencionó con anterioridad, el uso de anotaciones es variado, algunas sirven solo para dar
información a los desarrolladores, otras sí generan un impacto directo en el comportamiento de la
aplicación, dependiendo de la anotación que se esté implementando, algunas pueden ayudar en el
tratamiento de parámetros que se estén recibiendo desde una capa superior, o bien, para establecer la
relación de una clase con otras, incluso para dar soporte en la comunicación de la aplicación con la base de
datos, a continuación repasaremos algunas de las anotaciones más utilizadas dentro del ecosistema de
Spring, para mayor detalle se aconseja consultar directamente en la documentación del Framework.

4.2.5.3.4.1 Bean Annotations

Spring proporciona una serie de anotaciones para identificar a las clases de cuales Spring tomará el control
y administrar la creación de objetos

4.2.5.3.4.1.1 Spring Stereotypes

Las anotaciones de estereotipos de Spring brindan información al framework sobre cómo deben ser tratadas
las clases para la creación de los objetos y cómo es que será la relación entre tales clases, así como de
brindar soporte específico dependiendo el estereotipo.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

35
 Opsait
Academic

1 @Component: Es el estereotipo general y permite anotar un bean (objeto) para que Spring lo
considere uno de sus objetos.
1 @Repository: Es el estereotipo que se encarga de dar de alta un bean para que implemente el patrón
repositorio que es el encargado de almacenar datos en una base de datos o repositorio de información
que se necesite. Al marcar el bean con esta anotación Spring aporta servicios transversales como
conversión de tipos de excepciones.

2 @Service: Este estereotipo se encarga de gestionar las operaciones de negocio más importantes a
nivel de la aplicación y aglutina llamadas a varios repositorios de forma simultánea. Su tarea
fundamental es la de agregador.

3 @Controller: El último de los estereotipos que es el que realiza las tareas de controlador y gestión de
la comunicación entre el usuario y el aplicativo. Para ello se apoya habitualmente en algún motor de
plantillas o librería de etiquetas que facilitan la creación de páginas.

Como se observa, los estereotipos están pensados para implementarse en una aplicación dividida en las
capas de MVC, distribuyendo la carga de trabajo entre cada capa, para cada uno de los estereotipos Spring
brinda diversas características dependiendo la capa en la que se encuentre la clase.

Cabe destacar que Component es un estereotipo genérico, por lo que cualquier clase que implemente
dicha anotación será reconocida por Spring para la generación beans, al utilizar cualquiera de los otros 3
estereotipos, que son una implementación de Component, además de que indicamos a Spring que será
una clase para ser administrada por el framework, le dará el tratamiento correspondiente.

Con estas anotaciones estamos indicando a Spring qué clases tomará como base para crear los diferentes
objetos dentro de la aplicación para posteriormente inyectarlos.

4.2.5.3.4.1.2 Bean
Bean es una anotación que tiene un comportamiento similar al de los estereotipos, sin embargo, ésta es
utilizada únicamente para la manipulación de un objeto sencillo.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

36
 Opsait
Academic

La anotación:

4.2.5.3.4.2 Autowired
Autowired es una anotación que se utiliza para la inyección de dependencias, es decir, permitirá al
framework asignar el valor del objeto generado a una variable específica.

Lo que tenemos con el uso de esta anotación, es una asociación entre los objetos creados.

Existen 3 formas de utilizar la anotación Autowired para inyectar dependencias.

4.2.5.3.4.2.1 Autowired en propiedades

La anotación puede utilizarse directamente en las propiedades de la clase, esto permite eliminar la
implementación de getters y setters.

Como se puede observar, se está utilizando la variable personaService sin haber creado explícitamente una
instancia, Spring reconoce la clase PersonaServiceImpl que previamente fue marcada con la anotación
@Component y de esa clase crea una instancia, la cual después es inyectada directamente sobre la
propiedad personaService que tendrá la referencia al objeto creado.
4.2.5.3.4.2.2 Autowired en setters
La anotación puede ser usada directamente en el setter, recordando que son los métodos para asignar
valores a las propiedades.

Cuando la anotación es usada sobre estos métodos, estos son llamados por el framework al momento de
crear la clase en la cuál será inyectado el objeto.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

37
 Opsait
Academic

4.2.5.3.4.2.3 Autowired en constructores

La anotación puede usarse también en el constructor de la clase.

Como se puede observar, en los 3 escenarios Spring realiza la inyección del objeto creado a partir de
PersonaService dentro de la clase PersonaController; de esta manera estamos visualizando los conceptos
de Inversión de Control e Inyección de Dependencias.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

38
 Opsait
Academic

4.2.5.3.4.3 Scope
Los scopes definen el ciclo de vida de los objetos dentro de la aplicación, es decir, cuanto vivirán.

Spring nos permite definir el scope que se requiere para los objetos, lo más comunes y utilizados son los
siguientes:

 singleton
 prototype
 request
 session
 application

Los últimos 4 scopes (request, sesión, application, websocket) pueden ser implementados solo en
aplicaciones web.

4.2.5.3.4.3.1 Singleton
Anteriormente ya revisado dentro de los patrones de diseño, siguiendo dicho patrón, es un scope que define
un objeto como único,

4.2.5.3.4.3.2 Prototype
Este scope devuelve un nuevo objeto cada vez que se hace un llamado al contener de Spring, es el scope
contrario a singleton que devuelve siempre la misma instancia, en este caso será siempre un objeto distinto.

4.2.5.3.4.3.3 Request
Se trata de un scope en el que se especifica que el objeto va a vivir durante el ciclo de una petición Web.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

39
 Opsait
Academic

4.2.5.3.4.3.4 Session
De igual manera es un Scope que define el ciclo de vida de un objeto mientras la sesión Web exista, se
consume y define de la misma manera, solo cambia el ciclo de vida.

4.2.5.3.4.3.5 Application
De igual manera es un Scope que define el ciclo de vida de un objeto mientras la instancia de la aplicación
Web exista, se consume y define de la misma manera, solo cambia el ciclo de vida.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

40
 Opsait
Academic

4.2.5.4 Configuración
Para que Spring Framework funcione, es necesario hacer algunas configuraciones, en este manual nos
centraremos en las más básicas, como ya se mencionó anteriormente, es necesario verificar la
documentación de Spring para conocer el detalle de cada una de las configuraciones que es posible hacer,
ya que hay configuraciones para necesidades específicas.

Desde la versión 3.0 de Spring, tenemos 2 formas de hacer las configuraciones: xml o clase de
configuración.

4.2.5.4.1 applicationContext.xml
Es el archivo de configuración de Spring por medio de etiquetas XML, la configuración más básica es la
siguiente:

Se inicia con la etiqueta beans en la cual agregamos los name-spaces, por medio de los cuales
importaremos los componentes necesarios para nuestra configuración.

Dentro de la etiqueta observamos la etiqueta context:component-scan para indicar a Spring el paquete base
dónde se encuentran las clases manipulará.

Ésta es la configuración más básica posible, desde este punto se pueden agregar varias configuraciones
más, pero estás se irán agregando conforme la aplicación vaya creciendo.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

41
 Opsait
Academic

4.2.6 Java Server Faces (JSF)

Java Server Faces es un framework dedicado para la capa de vista en aplicaciones Web, dentro de las
denominadas RIA (Rich Internet Applications), es un conjunto de APIs que ofrecen componentes para
generar vistas enriquecidas y reducir el esfuerzo en desarrollo en la comunicación cliente-servidor.

Es importante destacar que JSF si bien está enfocado a brindar soluciones a la capa de vista, su
funcionamiento está basado en el servidor, ya que los archivos generados son compilados del lado del
servidor y el cliente (navegador) consume el producto del servidor.

En la imagen anterior se observa cual es la estructura y funcionamiento de un proyecto JSF, a continuación,

se describen los pasos:

I. El navegador Web realiza una petición al servidor para la carga del sitio.
II. El motor de JSF en el servidor procesa la solicitud y carga los archivos JSF y clases Java para
administrar las páginas.
III. El motor de JSF genera las páginas HTML y los componentes de administración (managed Beans).
IV. El navegador recibe la respuesta del servidor y muestra la página.

4.2.6.1 Características de JSF

JSF es un framework MVC (Modelo-Vista-Controlador) basado en el API de Servlets que proporciona un
conjunto de componentes en forma de etiquetas definidas en páginas XHTML mediante el framework
Facelets. Facelets se define en la especificación 2 de JSF como un elemento fundamental de JSF que
proporciona características de plantillas y de creación de componentes compuestos. Antes de la
especificación actual se utilizaba JSP para componer las páginas JSF.

En la siguiente sesión explicaremos con más profundidad las características MVC de JSF. Por ahora basta
con adelantar que JSF utiliza las páginas Facelets como vista, objetos Javabean como modelos y métodos
de esos objetos como controladores. El servlet FacesServlet realiza toda la tediosa tarea de procesar las
peticiones HTTP, obtener los datos de entrada, validarlos y convertirlos, colocarlos en los objetos del
modelo, invocar las acciones del controlador y renderizar la respuesta utilizando el árbol de componentes.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

42
 Opsait
Academic

Entrando un poco más en detalle, JSF proporciona las siguientes características destacables:

 Definición de las interfaces de usuario mediante vistas que agrupan componentes gráficos.
 Conexión de los componentes gráficos con los datos de la aplicación mediante los denominados
beans gestionados.
 Conversión de datos y validación automática de la entrada del usuario.
 Navegación entre vistas.
 Internacionalización
 A partir de la especificación 2.0 un modelo estándar de comunicación Ajax entre la vista y el
servidor.

4.2.6.2 Lenguaje de definición de vistas de JSF

Al igual que JSP, las vistas JSF se construyen mediante etiquetas específicas que declaran elementos y
componentes. Un ejemplo de página JSF es el siguiente:

En las especificaciones anteriores a JSF 2.0, las páginas de JSF se construían utilizando páginas JSP con
etiquetas específicas de JSF. Pronto se comprobó que el enfoque no era el correcto. La tecnología JSP no
tenía la potencia sufiente para las funcionalidades que se intentaban implementar en JSF. Además, ambos
conjuntos de etiquetas tenían incompatibilidades y era complicado combinarlas de forma sencilla.

La especificación 2 soluciona el problema utilizando XHTML como el lenguaje en el que se definen las
páginas. Repasemos rápidamente qué es el XHTML y cuáles son sus ventajas frente al HTML tradicional.

El lenguaje XHTML es una normalización del HTML orientada a hacerlo compatible con el formato XML.
Expresándolo en pocas palabras, un documento XHTML es un documento HTML formateado en forma de
documento XML. Por ejemplo, en los documentos XML toda etiqueta debe empezar y terminar. En HTML,
no sucede siempre así. El ejemplo más común es la etiqueta de fin de línea <br>. En HTML es una etiqueta
correcta. Sin embargo, en XHTML se transforma añadiéndole la terminación (<br/>) para cumplir el estándar
XML.

Debido a que están escritos en XML, los documentos XHTML son más fáciles de validar y de procesar. Se
pueden editar con herramientas genéricas orientadas a XML. Y se pueden transformar utilizando hojas de
estilo y otras características de XML.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

43
 Opsait
Academic

Una de las características del XHTML es la posibilidad de utilizar en un mismo documento distintos
lenguajes de etiquetas utilizando espacios de nombres. Por ejemplo, un documento XHTML puede contener
dibujos definidos en SVG o ecuaciones definidas en MathML. Cada lenguaje tiene su propio espacio de
nombres definido con un prefijo distinto. Es la forma de evitar conflictos entre etiquetas iguales de distintos
lenguajes. Esta característica es la que usa la especificación JSF para permitir que en las páginas XHTML
coexistan distintos tipos de etiquetas.

Los espacios de nombres se especifican al comienzo del documento XHTML definiendo el prefijo que
utilizan las etiquetas de cada uno de los lenguajes. Utilizando distintos prefijos para distintos lenguajes se
elimina el problema de la posible ambigüedad a la hora de procesar el documento.

La siguiente tabla muestra las distintas librerías de etiquetas que se utilizan en las páginas JSF.

Librería de etiquetas Descripción Ejemplo

<c:forEach>
JSTL Core Etiquetas estándar JSP
<c:catch>
<fn:toUpperCase>
JSTL Functions Funciones estándar JSTL
<fn:toLowerCase>
<ui:component>
Facelets Lenguaje de plantillas
<ui:insert>
Componentes estándar JSF basados en <h:body>
JSF HTML
HTML <h:inputText>
<f:actionListener>
JSF Core Componentes específicos de JSF
<f:attribute>

Cada librería se declara con un prefijo distinto. La siguiente tabla muestra los distintos prefijos y URIs.

Librería de etiquetas Prefijo URI

JSTL Core c: http://java.sun.com/jsp/jstl/core
JSTL Functions fn: http://java.sun.com/jsp/jstl/functions
JSF Facelets ui: http://java.sun.com/jsf/facelets
JSF HTML h: http://java.sun.com/jsf/htm
JSF Core f: http://java.sun.com/jsf/core

4.2.6.3 Managed Beans

Las páginas JSF son gestionadas desde el servidor por objetos llamadas Managed Beans, los cuales con
especificados y gestionados por medio de anotaciones como se muestra a continuación:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

44
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

45
 Opsait
Academic

5. Prime Faces

5.1 Introducción

PrimeFaces es una librería de componentes visuales open source desarrollada y mantenida por Prime
Technology, una compañía Turca de IT especializada en consultoría ágil, JSF, Java EE y Outsourcing. El
proyecto es liderado por Çağatay Çivici, un miembro del «JSF Expert Group».

Las principales características de Primefaces son:

 soporte nativo de Ajax, incluyendo Push/Comet.

 kit para crear aplicaciones web para móviles.
 es compatible con otras librerías de componentes, como JBoss RichFaces.
 uso de javascript no intrusivo (no aparece en línea dentro de los elementos, sino dentro de un
bloque <script>).
 es un proyecto open source, activo y bastante estable entre versiones.

Algunos inconvenientes podrían ser:

 Para utilizar el soporte de Ajax tenemos que indicarlo explícitamente, por medio de atributos
específicos de cada componente.
 No podemos utilizar el soporte de Ajax de JSF 2 (mediante <f:ajax>) con los componentes de
Primefaces.

Este tutorial no pretende hacer un análisis exahustivo de todos los componentes de Primefaces (más de 90
en el momento de escribir este tutorial), sino servir de introducción y mostrar lo necesario para poder utilizar
la librería en nuestras aplicaciones web.

5.2 Añadiendo el soporte para Primefaces

Configuración del pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.autentia.tutorial</groupId>
<artifactId>primefacesAppDemo</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>primefacesAppDemo Maven Webapp</name>

<build>
<finalName>primefacesAppDemo</finalName>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
</plugins>
</build>

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

46
 Opsait
Academic

<repositories>
<!-- Repositorio de Maven de JBoss -->
<repository>
<id>maven2-repository.jboss.com</id>
<name>Jboss Repository for Maven</name>
<url>http://repository.jboss.com/maven2</url>
</repository>
<!-- Repositorio con el API y la implementación de JSF 2 -->
<repository>
<id>maven2-repository.dev.java.net</id>
<name>Java.net Repository for Maven</name>
<url>http://download.java.net/maven/2</url>
</repository>
<!-- Repositorio de Primefaces -->
<repository>
<id>prime-repo</id>
<name>Prime Technology Maven Repository</name>
<url>http://repository.prime.com.tr/</url>
<layout>default</layout>
</repository>
</repositories>

<dependencies>
<!-- API e implementación de JSF 2. Del repo dev.java.net -->
<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-api</artifactId>
<version>2.0.2-b10</version>
</dependency>
<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-impl</artifactId>
<version>2.0.2-b10</version>
</dependency>

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>

<!-- Librerías de Primefaces -->

<dependency>
<groupId>org.primefaces</groupId>
<artifactId>primefaces</artifactId>
<version>2.0.2</version>
</dependency>
</dependencies>
</project>

Descriptor de despliegue de la aplicación web:

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">

<display-name>Introducción a Primefaces</display-name>

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

47
 Opsait
Academic

<!-- Configuración de JSF -->

<context-param>
<description>
Define the value returned by Application.getProjectStage(). Allowed
values: Production, Development,
UnitTest, SystemTest, Extension. Default value is Production.
</description>
<param-name>javax.faces.PROJECT_STAGE</param-name>
<param-value>Development</param-value>
</context-param>
<context-param>
<description>Do not render comments in facelets (xhtml) pages. Default is
false.</description>
<param-name>javax.faces.FACELETS_SKIP_COMMENTS</param-name>
<param-value>true</param-value>
</context-param>
<context-param>
<param-name>javax.faces.CONFIG_FILES</param-name>
<param-value>/WEB-INF/faces-config.xml</param-value>
</context-param>

<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.xhtml</url-pattern>
</servlet-mapping>

<!-- Servlet de recursos de Primefaces -->

<servlet>
<servlet-name>Resource Servlet</servlet-name>
<servlet-class>org.primefaces.resource.ResourceServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Resource Servlet</servlet-name>
<url-pattern>/primefaces_resource/*</url-pattern>
</servlet-mapping>

<welcome-file-list>
<welcome-file>index.xhtml</welcome-file>
</welcome-file-list>
</web-app>

Por último, y lo mejor, el fichero de configuración de JSF. Con el uso de anotaciones en nuestros bean
manejados y el soporte nativo de Facelets, este fichero puede ser tan simple como esto:

<?xml version='1.0' encoding='UTF-8'?>

<faces-config xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd"
version="2.0">

</faces-config>

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

48
 Opsait
Academic

5.3 Creando una página de prueba

Para probar si funcina nuestra configuración, vamos a crear la página index.xhtml, con el siguiente
contenido:

Hemos especificado el espacio de nombres «xmlns:p» para poder utilizar la librería de componentes de
Primefaces y, como no, hemos añadido un componente calendario dentro de un panel, aunque podríamos
haber elegido cualquiera de los que hay en la librería de componentes de Primefaces.

Si abrimos la página con un navegador, veremos el resultado:

5.4 Añadir el soporte de un ManagedBean

Vamos a añadir un controlador para nuestra vista que guarde en una variable la fecha seleccionada en el
calendario. Además, cuando se seleccione la fecha, se realizará una llamada por Ajax al método
«cambioFecha» del controlador, que añadirá un mensaje de Faces que se mostrará en la página.

El fichero PruebaView.java es el siguiente:

package com.autentia.tutorial.view;
 
import java.io.Serializable;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
 
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
 
import org.primefaces.event.DateSelectEvent;
 
 
@ManagedBean
@ViewScoped
public class PruebaView implements Serializable {
 
private static final long serialVersionUID = 8995118759276351827L;
 
private Date date;

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

49
 Opsait
Academic

public void cambioFecha(DateSelectEvent event) {

DateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");

FacesContext.getCurrentInstance().addMessage(null,
new FacesMessage("Fecha seleccionada: " +
formatter.format(event.getDate())));
}

public Date getDate() {

return date;
}
 
public void setDate(Date date) {
this.date = date;
}
}

Debemos modificar el código de nuestra vista para enlazar el valor de la fecha del calendario con la variable
«date» del controlador. Además habrá que llamar al método «cambioFecha» cuando cambie la selección y
añadir el componente que mostrará los mensajes. Se ha utilizado el componente «growl» de Primefaces,
que

Mostrará los mensajes dentro de unos «pop-ups» que desaparecerán transcurridos unos segundos.

<h:form>
<p:growl id="growl" />
<p:panel header="Prueba con Primefaces">
<h:panelGrid columns="2">
<h:outputLabel value="#{pruebaView.date}" />
<p:calendar pattern="dd/MM/yyyy"
selectListener="#{pruebaView.cambioFecha}"
onSelectUpdate="growl" />
</h:panelGrid>
</p:panel>
</h:form>

Ahora, cuando cambiemos la fecha del calendario, veremos que aparece el siguiente mensaje:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

50
 Opsait
Academic

5.5 Comparativas con otras librerías

Para terminar, vamos a ver un resumen de las carácteristicas de Primefaces con otras dos librerías:
ICEfaces y RichFaces.

Característica ICEfaces RichFaces Primefaces

Tenemos que hacer
uso de Ajax4JSF, que
no es tan transparente Es transparente para el
Es transparente para el
para el desarrollador, desarrollador,
desarrollador, lo
puesto que, además aunque para activarlo deben
implementa de forma
de introducir los utilizarse atributos específicos
Soporte de Ajax nativa en todos los
componentes para
componentes mediante
de RichFaces, lanzar un método del servidor y
la propiedad
tenemos que añadir para indicar los componentes a
partialSubmit
componentes no actualizar.
visuales de la librería
Ajax4JSF.
Usa el soporte de
Usa el soporte de
prototypejs, aunque la
prototypejs y Utiliza el soporte de jQuery y
Librerías en las parte de Ajax la han
script.aculo.us, aunque jQuery UI para los efectos
que se basan rescrito y para los
soporta también visuales.
efectos visuales
jquery.
utilizan script.aculo.us.
Incorpora el concepto
de skins y distribuye Incorpora el concepto de skins,
Personalización Incorpora el concepto
12 temas, aunque utilizando ThemeRoller, y
de la interfaz de de skins y distribuye 3
se pueden encontrar dispone de 26 temas
usuario temas.
más en el repositorio prediseñados.
de SNAPSHOTS.
Tiene 79 componentes Tiene 212
en la versión componentes entre los
básica, a los que hay propios de RichFaces
que sumar 32 de la y
versión empresarial, los de Ajax4JSF. Con
esta última es de pago. RichFaces todos los Tiene más de 90 componentes
La componentes son OpenSource, algunos muy
Número de percepción es que OpenSource y avanzados como el
componentes estan inviertiendo podemos usar un Pick HTMLEditor. Además dispone
esfuerzos en mejorar la List sin contratar nada, de un kit para crear interfaces
versión sin embargo, con web para teléfonos móviles.
empresarial y, como es ICEfaces sin queremos
lógico, esperan obtener un Dual List o
beneficio económico pagamos o lo
por implementamos
ello. nosotros.
MPL 1.1, que cubre la
LGPL V 2.1. Si bien
LGPL V 2.1. en su Apache
Licencia disponen de una
totalidad. License V2
versión empresarial
con licencia comercial.
Relevancia Ha sustituido a Es la librería de Ha
Woodstock como componentes visuales sido una de las primeras
librería de de Jboss, se integra, librerías capaces de integrarse

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

51
 Opsait
Academic

Característica ICEfaces RichFaces Primefaces

componentes de con JSF 2 y
referencia de Sun para por defecto con Jboss viene pisando fuerte debido a la
el desarrollo de Seam, aunque éste diversidad y calidad de sus
aplicaciones RIA. Se también soporta componentes. Puede utilizarse
distribuye, por defecto, ICEfaces. junto a Richfaces, pero no es
con NetBeans. compatible con ICEfaces.

5.6 Conclusiones

Existen actualmente bastantes librerías de componentes para JSF. El elegir utilizar una u otra dependerá en
gran medida del número y la calidad de componentes que nos ofrezca, la estabilidad en los cambios de
versión, el disponer de una buena documentación y la utilización e integración con otros estándares. Se
puede decir que Primefaces cumple sobradamente con todas esas características, por lo que puede ser una
buena elección. Además hay que tener en cuenta que no estamos limitados a utilizar una única librería,
aunque en ese caso habría que investigar un poco más para estar seguros de que no se produzcan
incompatibilidades entre ellas, que podrían darnos muchos quebraderos de cabeza.

6. Spring Boot

6.1 ¿Qué es Spring Boot?

Spring Boot es una de las tecnologías dentro del mundo de Spring de las que más se está hablando
últimamente. ¿Qué es y cómo funciona Spring Boot? Para entender el concepto primero debemos
reflexionar sobre cómo construimos aplicaciones con Spring Framework.

1) Seleccionar jars con Maven

2) Crear la aplicación
3) Desplegar servidor

Fundamentalmente existen tres pasos a realizar. El primero es crear un proyecto Maven/Gradle y descargar
las dependencias necesarias. En segundo lugar, desarrollamos la aplicación y en tercer lugar la
desplegamos en un servidor. Si nos ponemos a pensar un poco a detalle en el tema, únicamente el paso
dos es una tarea de desarrollo. Los otros pasos están más orientados a infraestructura.

SpringBoot nace con la intención de simplificar los pasos 1 y 3 y que nos podamos centrar en el desarrollo
de nuestra aplicación.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

52
 Opsait
Academic

En resumen, Spring Boot es un framework que está basado en Spring Framework, con la diferencia de que
está enfocado en reducir la configuración para centrarse en la codificación, por lo cual la estructura de un
proyecto Sprig Boot es prácticamente igual a la de Spring Framework, con la diferencia de que nos da
algunas características adicionales que son las que ayudan a reducir la configuración:

 Autoconfigurable: las configuraciones que se necesitan son mínimas, disponemos de un servidor de

aplicaciones, por lo cual no es necesario descarga e instalar uno, así como de la integración de
paquetes de Spring.
 Stand-alone: permite generar aplicaciones independientes, se reduce la dependencia de otros
sistemas, solo corremos la aplicación por separado, cabe recalcar que esto dependerá en gran
medida de que se haga un buen diseño, esto permite adentrarnos al mundo de los microservicios.
 Dogmático: tiene la capacidad de “decidir” por sí mismo como hacer e implementar las cosas.

Dadas tales características, se obtienes beneficios muy interesantes, tales como:

 Spring Boot no requiere desplegar archivos WAR

 Permite crear aplicaciones stand-alone
 Contiene servidor de aplicaciones embebido como Tomcat, Jetty o Untertow
 No requiere configuración XML
 Disminuye líneas de código
 Ofrece características listas para producción
 Fácil de implementar
 Fácil personalización y gestión

A estos beneficios podemos agregar los ya existentes de las características de Spring Framework como la
inversión de control e inyección de dependencias, así como la integración de otros módulos que puedan
llegar a ser requeridos dentro del proyecto.

Spring Boot es el siguiente paso de Spring para hacer que Spring sea más fácil de configurar y desarrollar
aplicaciones. Para Spring Boot, la configuración de Spring se minimiza. Spring Boot admite contenedores
integrados para permitir que las aplicaciones web puedan ejecutarse de forma independiente sin
implementarse en el servidor web.

Puede usar el sprint boot para crear una aplicación web en Java que se ejecute a través de la línea de
comando 'java -jar' o exportar a un archivo war para implementar en el servidor web como de costumbre.
Spring Boot le proporciona una "Herramienta CLI" para ejecutar scripts de Spring.

Spring Boot puede explicarse simplemente por la siguiente ilustración:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

53
 Opsait
Academic

Beneficios de Spring Boot

 Es muy fácil desarrollar aplicaciones basadas en Spring con Java o Groovy.

 Reduce mucho tiempo de desarrollo y aumenta la productividad.
 Evita escribir código repetitivo, anotaciones y configuración XML.
Es muy fácil integrar la aplicación Spring Boot con su ecosistema Spring como Spring JDBC,
Spring ORM, Spring Data, Spring Security, etc.
 Sigue el enfoque de "Configuración predeterminada de opinión" para reducir el esfuerzo del
desarrollador
Proporciona servidores HTTP integrados como Tomcat, Jetty, etc. para desarrollar y probar las
aplicaciones web con mucha facilidad.
 Proporciona la herramienta CLI (interfaz de línea de comandos) para desarrollar y probar
aplicaciones Spring Boot (Java o Groovy) desde el símbolo del sistema de manera muy fácil y
rápida.
 Proporciona muchos complementos para desarrollar y probar aplicaciones Spring Boot muy
fácilmente usando herramientas de desarrollo como Maven y Gradle
 Proporciona muchos complementos para trabajar con bases de datos integradas y en memoria
muy fácilmente

6.2 Objetivo

Crear una aplicación Hello Spring Boot, es una aplicación web simple que usa Spring Boot, y ejecutar esta
aplicación de forma independiente sin implementarla en el servidor web.

6.3 Crear proyecto Spring Boot

En Eclipse, crear un proyecto utilizando Spring Tool Suite (STS):

Archivo / Nuevo / Otro…

 Nombre: HelloSpringBoot
 Grupo: org.o7planning
 Artefacto: HelloSpringBoot
 Paquete: org.o7planning.hellospringboot

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

54
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

55
 Opsait
Academic

El proyecto ya se ha creado, a continuación se muestra la estructura predeterminada del Proyecto.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

56
 Opsait
Academic

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>org.o7planning</groupId>
<artifactId>HelloSpringBoot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>HelloSpringBoot</name>
<description>Hello Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.0.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

</project>

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

57
 Opsait
Academic

6.4 Algunas explicaciones sobre Sprint Boot

En el paso anterior, acaba de crear un proyectro Spring Boot, veamos el contenido de pom.xml:

pom.xml

Hay 3 puntos clave en pom.xml (1), (2), (3) como se muestra a continuación, Spring Boot lo ayuda a
simplificar la declaración de las bibliotecas de Spring.

spring-boot-starter-parent

spring-boot-starter-parent es un proyecto disponible en Spring Boot. Las bibliotecas dependientes se

declaran en spring-boot-starter-parent, el proyecto solo lo hereda. Solo necesita declarar <parent> en el
archivo pom.xml de su proyecto

** spring-boot-starter-parent **

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-
parent -->

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.0.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

58
 Opsait
Academic

spring-boot-starter-web

Otros "Iniciadores" simplemente proporcionan dependencias que probablemente necesitará al desarrollar un

tipo específico de aplicación. Como estamos desarrollando una aplicación web, agregaremos una
dependencia web spring-boot-starter-web

<dependencies>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

</dependencies>

spring-boot-maven-plugin

Spring-boot-maven-plugin es el complemento que proporciona las bibliotecas necesarias que ayudan a que
su proyecto se pueda ejecutar directamente sin implementarlo en un servidor web. Ayuda a crear un archivo
jar que pueda ser ejecutable.

<plugins>

<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

<!-- ... -->

</plugins>

6.5 Ejecución del Proyecto Spring Boot

En el paso anterior, se ha creado el proyecto HelloSpringBoot de Eclipse & Spring Tool Suite y no hay
cambios. Todas las cosas se crean por defecto. Ahora necesita algunos pasos para ejecutar la aplicación.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

59
 Opsait
Academic

Si su aplicación HelloSpringBoot se está ejecutando, puede probar este enlace:

http://localhost:8080/

Aparecerá un mensaje de error "404 No encontrado" cuando ejecute este enlace, pero no hay problemas
serios porque su proyecto aún no tiene ninguna página.

Creando el archivo style.css en la carpeta estática:

style.css

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

60
 Opsait
Academic

h1 {
    color: red;
}

Y vuelva a ejecutar la aplicación con el enlace:

http://localhost:8080/style.css

6.6 ¿Cómo funciona Spring Boot?

Cuando crea una “aplicación web Spring Boot”, la herramienta genera 1 clase: Hola Spring Boot Application.

Su aplicación se inicia ejecutrando la clase HelloSpringBootAplication. La clase está anotada por

@SpringBootApplication.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

61
 Opsait
Academic

HelloSpringBootApplication.java

package org.o7planning.hellospringboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloSpringBootApplication {

public static void main(String[] args) {

SpringApplication.run(HelloSpringBootApplication.class, args);
}
}

La anotación @SpringBootApplication es equivalente a usar @Configuration, @EnableAutoConfiguration y

@ComponentScan con sus atributos predeterminados:

Por lo tanto, @SpringBootApplication te ayuda a configurar Spring automáticamente y a escanear

automáticamente todo el proyecto para descubrir los componentes de Spring (Controller, Bean, Service, ...)

6.7 Apéndice: Servidor de configuración

Está ejecutando la aplicación Spring Boot anterior, puede cambiar las configuraciones del servidor como
Port, contextPath .....

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

62
 Opsait
Academic

Cambio del puerto HTTP del servidor:

Puede cambiar otras propiedades si lo desea, Eclipse le sugerirá las propiedades cambiables y su
significado.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

63
 Opsait
Academic

7. Maven
Es una herramienta para automatización de construcción de proyectos Java, ayuda a construir, compilar y
paquetizar un proyecto, descargar e integrar las dependencias (bibliotecas) así como de los recursos
necesarios para la implementación de un framework, lo cual nos facilita la tarea de estar descargando
manualmente los jar de Internet y posteriormente integrarlos.

Los beneficios de implementar Maven son los siguientes:

 Permite estandarizas aplicaciones

 Reutilización
 Gestión de dependencias
 Escalabilidad
 Permite crear herencia de proyectos

La configuración de un proyecto creado con Maven se realiza mediante un archivo XML llamado POM
(Project Object Model), este archivo contiene la información necesaria para la construcción del proyecto, así
como de las dependencias que se van a necesitar.

7.1 Dependencias, directas y transitivas.

Las dependencias directas son aquellas que se definen de manera directa en el XML para que sean
descargadas e integradas al proyecto.

Las dependencias transitivas, son aquellas que las dependencias directas necesitan para su
funcionamiento, son descargas e integradas de forma automática en el proyecto.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

64
 Opsait
Academic

modelVersion: indica la versión de modelo de objeto que el POM está usando, básicamente indica a Maven
qué elementos deben ser especificados, cuales son obligatorios, cómo interpretarlos, etc., dependiendo de
la versión de Maven que se esté implementando es la versión de modelo de objeto.

Coordenadas Maven

Las coordenadas de Maven son datos obligatorios que definen la identidad del proyecto, consta de 3 datos
específicos.

groupId: es un ID generalmente único dentro de una organización o un proyecto, dentro de una

organización que lleve varios proyectos, generalmente van a llevar el mismo ID de grupo, por ejemplo, todos
los proyectos que se realicen durante el presente curso tendrían el groupId mx.indra.es. Es importante
destacar que este ID no necesariamente debe seguir la misma notación por punto.

Este dato es independiente a la estructura de paquetes del sistema.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

65
 Opsait
Academic

artifacId: este dato generalmente indica el nombre del proyecto por el cual va a ser identificado, se puede
considerar que junto con el groupId completa el identificador del proyecto, todos los integrantes de la
organización identificarán al proyecto en cuestión con este dato.

versión: como su nombre lo dice, define la versión del proyecto, cuando el código cambia, el versionado
debe cambiar, esto ayuda a mantener un historial sobre los cambios realizados sobre el proyecto.

properties: dentro de esta etiqueta se pueden establecer diferentes parámetros en los que se pueden
especificar las versiones de las tecnologías involucradas en el proyecto.

dependencies: en este tag se indica la sección del listado de dependencias, dentro de esta sección se
listan una por una las dependencias.

dependency: se especifica una dependencia como tal, por medio de datos como groupId y artifactId para
descargarla de los repositorios de Maven; se puede especificar la versión también, en caso de que no sea
así, por default descargará la última versión disponible.

scope: define el nivel de transitividad que tendrá la dependencia que pretende integrarse al proyecto.

exclusions: sección para indicar a Maven que dependencias transitivas no queremos que sean integradas
al proyecto.

7.2 Verifique su Eclipse para ver si instala Maven o no

En primer lugar verifique se Eclipse para ver si instala Meave o no.

Archivo / Nuevo / Otro

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

66
 Opsait
Academic

Si existe Maven Wizard, significa que su Eclipse se ha instalado con Maven Plugin y está listo para
funcionar. Sin embargo, aún puede reinstalar su última versión si lo desea.

7.3 Instalar Maven en Eclipse como programa incrustado

Introducir:
Nombre: m2e
Ubicación: http://download.eclipse.org/technology/m2e/releases

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

67
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

68
 Opsait
Academic

Ha instalado con éxito Maven en Eclipse, reinicie Eclipse.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

69
 Opsait
Academic

7.4 Instalar independientemente Maven fuera de Eclipse

Descargar Maven
http://maven.apache.org/

http://maven.apache.org/download.cgi

Este documento se basa en la última versión 3.6.3 de Maven, por lo que vamos a descargar y utilizar esta
versión.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

70
 Opsait
Academic

Después de descargar Maven por completo, puede extraer y guardar el archivo zip en una carpeta
específica
Del disco duro:

Puede ver un ejemplo a continuación:

D: /DevPrograms/apache-maven.3.6.3

Este es un resultado de extracción en el disco duro

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

71
 Opsait
Academic

Configurar variables de entorno

El siguiente paso es declarar una variable ambiental para maven. Estas imágenes que se muestran a
continuación se basan en Windows 10 y los otros sistemas operativos de Windows son similares.

Se incluyen la variable ambiental y se declaran una ruta:

JAVA_HOME=C:\DevPrograms\Java\jdk1.8.0_40
M2_HOME=D:\DevPrograms\apache-maven-3.3.3

M2=%M2_HOME%\bin
Path=;%M2%;%JAVA_HOME%\bin

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

72
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

73
 Opsait
Academic

Compruebe para asegurarse de que no esta declarada la variable de entorno JAVA_HOME, luego
agréguela.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

74
 Opsait
Academic

Del mismo modo, puede declarar a otras dos variables ambientales.

Finalmente, agregue el valor de la variable ambiental Path como se muestra a continuación:

% M2%;% JAVA_HOME% \ bin

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

75
 Opsait
Academic

Luego, verifique sus declaraciones ambientales. Será mejor que reinicie o "cierre sesión" en su
computadora.

Abra una ventana de comando y escriba el comando:

mvn --versión

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

76
 Opsait
Academic

Declarar la ubicación de configuración Maven en Eclipse

Abrir una carpeta D: \ DevPrograms \ apache-maven-3.3.3 \ conf

Abra el archivo settings.xml para cambiar algunos parámetros.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

77
 Opsait
Academic

Luego añade:
<localRepository> D: \ apache-maven-3.6.3 \ repository </localRepository>

Abre Window / Preferences en Eclipse

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

78
 Opsait
Academic

Haga clic en "Agregar" para agregar un nuevo perfil

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

79
 Opsait
Academic

A continuación, declare la posición del archivo de configuración de Maven que se modificó la última vez.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

80
 Opsait
Academic

La instalación de Maven en Eclipse se ha completado.

https://o7planning.org/en/11253/create-an-empty-maven-web-app-project-in-eclipse

7.5 Cree un proyecto de aplicación web vacio de Maven en Eclipse

Objetivo

Hay muchas instrucciones sobre la necesidad de o7planning.org para crear un proyecto de aplicación web
Maven con Eclipse. En este documento, se mostrarán los pasos para crear un proyecto vacío como ese.
  
Este documento se base en:
Eclipse 4.6 (NEON).

Crear proyecto de aplicación web Maven

Seleccione: en Eclipse
Archivo / Nuevo / Otro ..

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

81
 Opsait
Academic

Para crear una aplicación web maven, debe seleccionar el arquetipo que es maven-archetype-webapp.

Ingrese el nombre de su proyecto, aquí lo llamo, “YourProjectName”.

Id. De grupo: org.o7planning

Id. De artefacto:
Paquete: org.o7planning.yourprojectname

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

82
 Opsait
Academic

Tu proyecto está creado.

No se preocupe por el mensaje de error cuando se haya creado el Proyecto. La razón es que no se declaró
la biblioteca Servlet.

Si el proyecto se crea con la falta de la carpeta que contiene el código fuente de Java, se debe crear esta
carpeta.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

83
 Opsait
Academic

Usando UFT8

Propiedades del proyecto:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

84
 Opsait
Academic

Establecer Versión de Java

Se recomienda se use Java >=6

7.6 Proyecto simple en Maven

Introducción

En este capítulo, presentamos un proyecto simple creado desde cero utilizando el complemento Maven
Archetype. Esta aplicación elemental proporciona la oportunidad de discutir algunos conceptos básicos de
Maven mientras sigue con el desarrollo del proyecto.

Antes de que pueda comenzar a usar Maven para compilaciones complejas de varios módulos, debemos
comenzar con lo básico. Si ha usado Maven anteriormente, notará que hace un buen trabajo al cuidar los
detalles. Sus compilaciones tienden a "simplemente funcionar", y realmente solo necesita sumergirse en los
detalles de Maven cuando desea personalizar el comportamiento predeterminado o escribir un complemento
personalizado. Sin embargo, cuando necesite profundizar en los detalles, es esencial una comprensión
profunda de los conceptos básicos. El objetivo de este capítulo es presentarle los proyectos de Maven más
simples posibles y luego presentar algunos de los conceptos básicos que hacen que Maven sea una
plataforma de compilación sólida. Después de leerlo, comprenderá fundamentalmente el ciclo de vida de la
compilación, los repositorios de Maven, la administración de dependencias y el Modelo de objetos de
proyecto (POM).

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

85
 Opsait
Academic

Descargando el ejemplo de este capítulo

Este capítulo desarrolla un ejemplo muy simple que se utilizará para explorar los conceptos centrales de
Maven. Si sigue los pasos descritos en este capítulo, no debería necesitar descargar los ejemplos para
recrear el código producido por Maven. Utilizaremos el complemento Arquetipo de Maven para crear este
proyecto simple y este capítulo no modifica el proyecto de ninguna manera. Si prefiere leer este capítulo con
el código fuente de ejemplo final, el proyecto de ejemplo de este capítulo se puede descargar con el código
de ejemplo del libro en:

http://www.sonatype.com/books/mvnex-book/mvnex-examples.zip

Descomprima este archivo en cualquier directorio y luego vaya al directorio ch-simple /. Allí verá un
directorio llamado simple que contiene el código fuente de este capítulo.

7.7 Crear un proyecto simple

Para comenzar un nuevo proyecto Maven, use el complemento arquetipo de Maven desde la línea de
comandos. Ejecute el Archetype: generate objetivo, seleccione el arquetipo predeterminado sugerido
presionando "Enter". Esto usará el arquetipo org.apache.maven.archetypes: maven-archetype-quickstart.
Presione "Enter" nuevamente para confirmar la última versión del arquetipo y luego "Enter" para confirmar
los parámetros suministrados.

Advertencia

Al momento de la publicación, el maven-archetype-quickstart predeterminado era el ítem # 312 en una lista

de 860 arquetipos disponibles. A medida que más y más proyectos liberen los arquetipos de Maven, esta
lista cambiará y el número del arquetipo predeterminado puede cambiar. Cuando ejecuta Archetype:
generate como se muestra a continuación, se seleccionará por defecto el maven-archetype-quickstart
predeterminado.

$ mvn archetype:generate -DgroupId=org.sonatype.mavenbook \

-DartifactId=simple \
-Dpackage=org.sonatype.mavenbook \
-Dversion=1.0-SNAPSHOT
[INFO]
[INFO] ----------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ----------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.2:generate (default-cli) @ standalone- ←
pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.2:generate (default-cli) @ standalone- ←
pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.2:generate (default-cli) @ standalone- ←
pom --
[INFO] Generating project in Interactive mode
[INFO] No archetype defined. Using maven-archetype-quickstart (org.apache. ←
maven.archetypes:maven-archetype-quickstart:1.0) Choose archetype:
...
312: remote -> org.apache.maven.archetypes:maven-archetype-quickstart (An ←
archetype which contains a sample Maven project.)
Choose a number or apply filter (format: [groupId:]artifactId, case ←
sensitive contains): 312:
Choose org.apache.maven.archetypes:maven-archetype-quickstart version:
1: 1.0-alpha-1
2: 1.0-alpha-2
3: 1.0-alpha-3
4: 1.0-alpha-4

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

86
 Opsait
Academic

5: 1.0
6: 1.1
Choose a number: 6:
[INFO] Using property: groupId = org.sonatype.mavenbook
[INFO] Using property: artifactId = simple
[INFO] Using property: version = 1.0-SNAPSHOT
[INFO] Using property: package = org.sonatype.mavenbook
Confirm properties configuration:
groupId: org.sonatype.mavenbook
artifactId: simple
version: 1.0-SNAPSHOT
package: org.sonatype.mavenbook
Y: :
[INFO] --------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) ←
Archetype: maven-archetype-quickstart:1.1
[INFO] --------------------------------------------------------
[INFO] Parameter: groupId, Value: org.sonatype.mavenbook
[INFO] Parameter: packageName, Value: org.sonatype.mavenbook
[INFO] Parameter: package, Value: org.sonatype.mavenbook
[INFO] Parameter: artifactId, Value: simple
[INFO] Parameter: basedir, Value: /Volumes/mac-data/dev/github/sonatype
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: /Volumes/mac-data/ ←
dev/github/sonatype/simple
[INFO] BUILD SUCCESS
...

Mvn es el comando Maven. archetype: generate es un objetivo Maven. Un arquetipo se define como "un
modelo original o tipo después del cual se modelan otras cosas similares; un prototipo ”. En Maven hay
disponibles varios arquetipos para cualquier cosa, desde una aplicación simple hasta una aplicación web
compleja, y el archetype: generate ofrece una lista de arquetipos para elegir. En este capítulo, vamos a
utilizar el arquetipo más básico para crear el esqueleto de un proyecto básico . El complemento es el prefijo
archetype, y el objetivo es generate.

Una vez que hayamos generado un proyecto, eche un vistazo a la estructura de directorios que Maven creó
en el directorio simple:

simple/v 1
simple/pom.xmlv 2
/src/
/src/main/v 3
/main/java
/src/test/v 4
/test/java

Este directorio generado se adhiere al diseño de directorio estándar de Maven. Entraremos en más detalles
más adelante en este capítulo, pero por ahora, intentemos comprender estos pocos directorios básicos:

El complemento Maven Archetype crea un directorio simple que coincide con el artifactId. Esto se conoce
como el directorio base del proyecto.

Cada proyecto Maven tiene lo que se conoce como un Modelo de Objeto de Proyecto (POM) en un archivo
llamado pom. xml. Este archivo describe el proyecto, configura complementos y declara dependencias.

El código fuente y los recursos de nuestro proyecto se colocan en src / main. En el caso de nuestro proyecto
Java simple, este consistirá en unas pocas clases de Java y un archivo de propiedades. En otro proyecto,
esto podría ser la raíz documental de una aplicación web o archivos de configuración para un servidor de
aplicaciones. En un proyecto de Java, las clases de Java se colocan en src / main / java y los recursos de
classpath se colocan en src / main / resources.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

87
 Opsait
Academic

Los casos de nuestro proyecto se ubican en src / test. Bajo este directorio, las calses de Java tales como
JUnit o TestNG se colocan en src / test / java, y los recursos de classpath para las pruebas se encuentran
en src/test/resources.

El complemento Maven Archetype generó una clase única org.sonatype.mavenbook.App, que es una clase
Java de 13 líneas con una función principal estática que imprime un mensaje:

package org.sonatype.mavenbook;
/** *
Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
System.out.println( "Hello World!" );
}
}

El arquetipo de Maven más simple genera el programa más simple posible: un programa que imprime "¡Hola
Mundo!" a la salida estándar.

7.8 Construyendo un proyecto simple

El directorio creado simple contiene el pom.xml y puede construir fácilmente el proyecto:

$ cd simple
$ mvn install
[INFO] Scanning for projects...
[INFO] ----------------------------------------
[INFO] Building simple
[INFO]task-segment: [install]
[INFO] ----------------------------------------
[INFO] [resources:resources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:compile]
[INFO] Compiling 1 source file to /simple/target/classes
[INFO] [resources:testResources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:testCompile]
[INFO] Compiling 1 source file to /simple/target/test-classes
[INFO] [surefire:test]
[INFO] Surefire report directory: /simple/target/surefire-reports

Pruebas
Running org.sonatype.mavenbook.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.105 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] [jar:jar]
[INFO] Building jar: /simple/target/simple-1.0-SNAPSHOT.jar
[INFO] [install:install]
[INFO] Installing /simple/target/simple-1.0-SNAPSHOT.jar to \
~/.m2/repository/com/sonatype/maven/simple/simple/1.0-SNAPSHOT/ \
simple-1.0-SNAPSHOT.jar

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

88
 Opsait
Academic

Acaba de crear, compilar, probar, empaquetar e instalar el proyecto Maven más simple posible. Para
demostrarte a ti mismo que este programa funciona, ejecútalo desde la línea de comandos.

$ java -cp target/simple-1.0-SNAPSHOT.jar org.sonatype.mavenbook.App

Hello World!

7.9 Modelo de objeto de proyecto simple

Archivo Simple Project’spom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.sonatype.mavenbook.simple</groupId>
<artifactId>simple</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>simple</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Este archivo pom.xml es el POM más básico con el que se enfrentará para un proyecto Maven, por lo
general, un archivo POM es considerablemente más complejo: definir múltiples dependencias y personalizar
el comportamiento del complemento. Los primeros elementos (groupId, artifactId, packaging, version) son
los que se conocen como las coordinadas de Maven que identifican un proyecto de manera única. name y
url son elementos descriptivos del POM que proporcionan un nombre legible por humanos y asocian el
proyecto con un sitio web. El elemento de dependencias define un único, alcance de pruebas en un marco
de prueba de unidad llamado JUnit. Estos temas se presentarán más adelante, todo lo que necesita saber,
en este punto, es que pom.xml es el archivo que hace que Maven funcione.

Maven siempre se ejecuta contra un POM efectivo, una combinación de configuraciones del pom.xml de
este proyecto, todos los padres del POMs, un super-POM definido dentro de Maven, configuraciones
definidas por el usuario y perfiles activos. Todos los proyectos finalmente extienden el super-POM, que
define un conjunto de configuraciones predeterminadas sensibles. Si bien su proyecto puede tener un
pom.xml relativamente mínimo, el contenido del POM de su proyecto se interpola con el contenido de todos
los POM principales, la configuración del usuario y cualquier perfil activo. Para ver este POM "efectivo",
ejecute el siguiente comando en el directorio base del proyecto simple.

$ mvn help:effective-pom

Cuando suceda esto, debería ver un POM más grande que exponga los ajustes predeterminados de Maven.
Este objetivo puede ser útil si está tratando de depurar una compilación y quiere ver cómo todos los POMs
ancestrales del proyecto actual están contribuyendo a la POM efectiva.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

89
 Opsait
Academic

7.10 Conceptos básicos

Después de haber ejecutado Maven para la primera vez, es un buen momento para presentar un poco de
los conceptos básicos de Maven. En el ejemplo anterior, generó un proyecto que consistía en un POM y un
código ensamblado en el diseño de directorio estándar de Maven. Luego ejecutó Maven con una fase de
ciclo de vida como argumento, lo que llevó a Maven a ejecutar una serie de objetivos de complementos. Por
último, instaló un artefacto Maven en su repositorio local. ¿Espere? ¿Qué es un "ciclo de vida"? ¿Qué es un
"repositorio local"? La siguiente sección define algunos de los conceptos centrales de Maven.

7.11 Complementos y objetivos de Maven

Para ejecutar un solo objetivo de complemento Maven, utilizamos la sintaxis mvn archetype: generate,
donde archetype es el identificador de un complemento y generate es el identificador de un objetivo. Cuando
Maven ejecuta un objetivo de complemento, imprime el identificador de complemento y el identificador de
objetivo en la salida estándar:

$ mvn archetype:generate -DgroupId=org.sonatype.mavenbook.simple

...
[INFO] [archetype:generate]
...

Un complemento de Maven es una colección de uno o más objetivos. Ejemplos de complementos de Maven
pueden ser complementos básicos simples como el complemento Jar, que contiene objetivos para crear
archivos JAR, el complemento Compilador, que contiene objetivos para compilar código fuente y pruebas
unitarias, o el complemento Surefire, que contiene objetivos para ejecutar pruebas unitarias y generar
informes. otros complementos más especializados de Maven incluyen complementos como el complemento
Hibernate3 para la integración con la popular biblioteca de persistencia Hibernate, el complemento de JRuby
que te permite ejecutar ruby como parte de una compilación Maven o escribir complementos de Maven en
Ruby. Maven también proporciona la capacidad de definir complementos personalizados. Un complemento
personalizado puede escribirse en Java, o un complemento puede escribirse en cualquier número de
lenguajes, incluidos Ant, Groovy, beanshell y, como se mencionó anteriormente, Ruby.

Un goal es una tarea específica que puede ejecutarse como un objetivo independiente o junto con otros
objetivos como parte de una construcción más grande. Un goal es una "unidad de trabajo" en Maven. Los
ejemplos de goal incluyen el compile goal en el complemento compilador, que compila todo el código fuente
de un proyecto, o el test goal del complemento Surefire, que puede ejecutar pruebas unitarias. Los goal se
configuran mediante propiedades de configuración que se pueden utilizar para personalizar el
comportamiento. Por ejemplo, el compile goal del complemento Compilador define un conjunto de
parámetros de configuración. Al ejecutar el archetype: generate goal, pasamos el parámetro del paquete al
goal de generar como org.sonatype.mavenbook. Si hubiéramos omitido el parámetro del paquete, el nombre
del paquete habría sido predeterminado en org.sonatype. mavenbook.simple.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

90
 Opsait
Academic

Nota

Cuando se refiere a un plugin goal, con frecuencia usamos la abreviatura: pluginId: goalId. Por ejemplo,
cuando nos referimos a generate goal en el complemento Arquetipo, escribimos archetype: generate.

Los goals definen parámetros que pueden definir valores predeterminados sensibles. En el ejemplo
archetype: generate, no especificamos qué tipo de arquetipo era el objetivo crear en nuestra línea de
comando; simplemente pasamos un groupId y un artifactId. Al no pasar el tipo de artefacto que queríamos
crear, el objetivo de generación nos solicitó la entrada, el objetivo de generación se detuvo y nos pidió que
eligiéramos un arquetipo de una lista. Si hubiera ejecutado el archetype:create goal en su lugar, Maven
habría asumido que quería generar un nuevo proyecto utilizando el arquetipo predeterminado de maven-
archetype-quickstart. Este es nuestro primer acercamiento con la convención sobre la configuración. La
convención, o predeterminada, para el créate goal es crear un proyecto simple llamado Inicio rápido
(Quickstart). El créate goal define una propiedad de configuración archetypeArtifactId que tiene un valor
predeterminado de maven-archetype-quickstart. El arquetipo de Inicio rápido genera un shell de proyecto
mínimo que contiene un POM y una sola clase. El arquetipo complemento es mucho más poderoso de lo
que sugiere este primer ejemplo, pero es una excelente manera de comenzar nuevos proyectos
rápidamente. Más adelante en este libro, le mostraremos cómo se puede utilizar el complemento Arquetipo
para generar proyectos más complejos, como aplicaciones web, y cómo puede usar el complemento
Arquetipo para definir su propio conjunto de proyectos.

El núcleo de Maven tiene poco que ver con las tareas específicas involucradas en la construcción de su
proyecto. Por sí mismo, Maven no sabe cómo compilar su código ni siquiera cómo hacer un archivo JAR.
Delega todo este trabajo a los complementos de Maven, como el complemento Compilador y el
complemento Jar, que se descargan según sea necesario y se actualizan periódicamente desde el
repositorio central de Maven. Cuando descargue Maven, está obteniendo el núcleo de Maven, que consiste
en un shell muy básico que solo sabe cómo analizar la línea de comando, administrar un classpath, analizar
un archivo POM y descargar complementos de Maven según sea necesario. Al mantener el complemento
del compilador separado del núcleo de Maven y proporcionar un mecanismo de actualización, Maven facilita
a los usuarios el acceso a las últimas opciones en el compilador. De esta manera, los complementos de
Maven permiten la reutilización universal de la lógica de compilación común. No está definiendo la tarea de
compilación en un archivo de compilación; está utilizando un complemento de compilador que es compartido
por todos los usuarios de Maven. Si hay una mejora en el complemento del compilador, cada proyecto que
use Maven puede beneficiarse inmediatamente de este cambio. (Y, si no le gusta el complemento
Compilador, puede anularlo con su propia implementación).

7.12 Ciclo de vida de Meaven

El segundo comando que ejecutamos en la sección anterior incluía una ejecución del ciclo de vida de
Maven. Comienza con una fase para validar la integridad básica del proyecto y termina con una fase que
implica implementar un proyecto en producción. Las fases del ciclo de vida son intencionalmente vagas,
definidas únicamente como validación, prueba o implementación, y pueden significar diferentes cosas para
diferentes proyectos. Por ejemplo, en un proyecto que produce un archivo Java, la fase del paquete produce
un JAR; En un proyecto que produce una aplicación web, la fase del paquete produce un WAR.

Los objetivos del complemento se pueden adjuntar a una fase del ciclo de vida. A medida que Maven
avanza por las fases de un ciclo de vida, ejecutará los objetivos asociados a cada fase en particular. Cada
fase puede tener cero o más objetivos vinculados a ella. En la sección anterior, cuando ejecutas ub mvn
install, es posible que haya notado que se ejecutó más de un objetivo. Examine el resultado después de
ejecutar mvn install y tome nota de los diversos objetivos que se ejecutan. Cuando este simple ejemplo
alcanzó la fase de paquete, ejecuta el jar goal en el complemento Jar. Dado que nuestro proyecto de inicio
rápido simple tiene (por defecto) un tipo de empaque de jar, el objetivo jar: jar está vinculado a la fase de
paquete.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

91
 Opsait
Academic

Sabemos que la fase de paquete creará un archivo JAR para un proyecto con empaquetado jar. Pero, ¿qué
pasa con los objetivos que lo preceden, como compiler: compiler y surefire:test? Estos objetivos se ejecutan
como pasos de Maven en las fases que preceden el paquete en el ciclo de vida de Maven.

Resources:resources

El complemento de recursos está vinculado a la fase de process-resources. Este objetivo copia todos los
recursos de src / main / resources y cualquier otro directorio de recursos configurado en el directorio de
salida.

compiler: compile

Está vinculada a la fase compile. Este objetivo compila todo el código fuente de src / main / java o cualquier
otro directorio fuente configurado en el directorio de salida.

resources: testResources

Complementos esta vinculado a la fase process-test-resources. Este objetivo copia todos los recursos de
src / test / resources y cualquier otro directorio de recursos de prueba configurado a un directorio de salida
de prueba.

compiler: tesfCompile

el complemento está vinculado a la fase test-compile. Este objetivo compila casos de prueba de src / test /
jav y cualquier otro directorio de origen de prueba configurado en un directorio de salida de prueba.

surefire: test

vinculada a la fase de prueba (test). Este objetivo ejecuta todas las pruebas y crea archivos de salida que
capturan resultados detallados. Por defecto, este objetivo terminará una compilación si hay una falla en la
prueba.

jar: jar

A la fase de paquete (package). Este objetivo empaqueta el directorio de salida en un archivo JAR.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

92
 Opsait
Academic

Para resumir, cuando ejecutamos mvn install, Maven ejecuta todas las fases hasta la fase de instalación, y
en el proceso de pasar por las fases del ciclo de vida, ejecuta todos los objetivos vinculados a cada fase. En
lugar de ejecutar una meta de ciclo de vida de Maven, usted puede lograr los mismos resultados
especificando una secuencia de objetivos de complemento de la siguiente manera:

mvn resources:resources \
compiler:compile \
resources:testResources \
compiler:testCompile \
surefire:test \
jar:jar \
install:install

Es mucho más fácil ejecutar las fases del ciclo de vida que especificar objetivos explícitos en la línea de
comando, y el ciclo de vida común permite que cada proyecto que utiliza Maven se adhiera a un conjunto de
estándares bien definidos. El ciclo de vida es lo que permite a un desarrollador saltar de un proyecto Maven
a otro sin tener que saber mucho sobre los detalles de la construcción de cada proyecto en particular. Si
puede construir un proyecto Maven, puede construirlos todos.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

93
 Opsait
Academic

7.13 Coordenadas de Maven

El complemento Archetype creó un proyecto con un archivo llamado pom.xml. Este es el Modelo de objetos
del proyecto (POM), una descripción declarativa de un proyecto. Cuando Maven ejecuta un objetivo, cada
objetivo tiene acceso a la información definida en el POM de un proyecto. Cuando el jar: jar goal necesita
crear un archivo JAR, mira al POM para descubrir cuál es el nombre del archivo JAR. Cuando el compiler:
compile goal compila el código fuente de Java en bytecode, mira al POM para ver si hay algún parámetro
para el objetivo de compilación. Los objetivos se ejecutan en el contexto de un POM. Los goals son
acciones que deseamos realizar en un proyecto, y un proyecto está definido por un POM. El POM nombra el
proyecto, proporciona un conjunto de identificadores únicos (coordenadas) para un proyecto y define las
relaciones entre este proyecto y otros a través de dependencias, padres y requisitos previos. Un POM
también puede personalizar el comportamiento del complemento y proporcionar información sobre la
comunidad y los desarrolladores involucrados en un proyecto.

Las coordenadas de Maven definen un conjunto de identificadores que se pueden utilizar para identificar de
forma exclusiva un proyecto, una dependencia o un complemento en un POM de Maven. Echa un vistazo a
la siguiente POM.

Hemos resaltado las coordenadas de Maven para este proyecto: groupId, artifactId, version y packaging.
Estos identificadores combinados forman las coordenadas de un proyecto. Hay una quinta coordenada, rara
vez utilizada, llamada clasificador (classifier) que presentaremos más adelante. Puede sentirse libre de
ignorar a los clasificadores ahora. Al igual que cualquier otro sistema de coordinación, un conjunto de
secuencias de coordinación de Maven se dirige a un espacio específico. Maven señala que un proyecto se
coordina cuando un proyecto se relaciona con otro, ya sea como una dependencia, un complemento o una
referencia de proyecto principal. Las coordenadas de Maven a menudo se escriben utilizando dos puntos
como delimitador en el siguiente formato: groupId: artifactId: packaging: version. En el archivo pom.xml
anterior para nuestro proyecto actual, sus coordenadas se representan como mavenbook: myapp: jar: 1.0-
SNAPSHOT.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

94
 Opsait
Academic

groupId

El grupo, empresa, equipo, organización, proyecto u otro grupo. La convención para los identificadores de
grupo es que comienzan con el nombre de dominio inverso de la organización que crea el proyecto. Los
proyectos de Sonatype tendrían un groupId que comience con com.sonatype, y los proyectos de Apache
Software Foundation tendrían un groupId que comenzaría con org.apache.

artifactId

Un identificador único bajo groupId que representa un solo proyecto.

version

Una versión específica de un proyecto. Los proyectos que se han lanzado tienen un identificador de versión
fijo que se refiere a una conversión específica del proyecto. Los proyectos en desarrollo activo en curso
pueden usar un identificador especial que marca una versión como SNAPSHOT.

El formato de empaquetado de un proyecto también es un componente importante en las coordenadas de

Maven, pero no forma parte del identificador único de un proyecto. groupId: artifactId: version hace que ese
proyecto sea único; puede tener un proyecto con los mismos tres identidicadroes groupId, artifactId y
versión.

packaging

El tipo de proyecto, por defecto en jar, que describe el resultado empaquetado producido por un proyecto.
Un proyecto con paquetes jar produce un archivo JAR; un proyecto con paquetes war produce una
aplicación web.

Estos cuatro elementos se convierten en la clave de ubicación y uso de un proyecto en particular en el

espacio más amplio de otros proyectos "Mavenized". Los repositorios de Maven (públicos, privados y
locales) se organizan de acuerdo con estos identificadores. Cuando este proyecto se instala en el
repositorio local de Maven, queda inmediatamente disponible localmente para cualquier otro proyecto que
desee utilizarlo. Todo lo que debe hacer es agregarlo como una dependencia de otro proyecto utilizando las
coordenadas únicas de Maven para un artefacto específico.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

95
 Opsait
Academic

7.14 Repositorios Maven

Cuando ejecute Maven por primera vez, notará que Maven descarga varios archivos desde un repositorio
remoto de Maven. Si el proyecto simple se ejecuta por primera vez en Maven, lo primero que hará será
descargar la última versión del complemento Recursos cuando active los resources: resources objetivos. En
Maven, los artefactos y complementos se recuperan de un repositorio remoto cuando se necesitan. Una de
las razones por las que la descarga inicial de Maven es tan pequeña (1.5 MiB) se debe al hecho de que
Maven no se envía con muchos complementos. Maven se envía con el mínimo necesario y se obtiene de un
repositorio remoto cuando es necesario. Mavenshipswithadefaultremoterepositorylocation
(http://repo1.maven.org/maven2) que utiliza para descargar los complementos y dependencias principales
de Maven.

A menudo escribirá un proyecto que depende de bibliotecas que no son gratuitas ni se distribuyen
públicamente. En este caso, deberá configurar un repositorio personalizado dentro de la red de su
organización o descargar e instalar las dependencias manualmente. Los repositorios remotos
predeterminados se pueden reemplazar o aumentar con referencias a repositorios Maven personalizados
mantenidos por su organización. Existen múltiples productos disponibles para permitir a las organizaciones
administrar y mantener espejos de los repositorios públicos de Maven.

¿Qué hace un repositorio de Maven un repositorio de Maven? Un repositorio es una colección de artefactos
de proyecto almacenados en una estructura de directorio que coincide estrechamente con las coordenadas
Maven de un proyecto. Puede ver esta estructura abriendo un navegador web y explorando los datos del
repositorio central de Maven en http: //repo1.maven.org/maven2/. Verá que un artefacto con las
coordenadas org.apache.commons: commons-email: 1.1 está disponible en el directorio
/org/apache/commons/commons-email-1.1/ en un archivo llamado commons-email-1.1.jar. El estándar para
un repositorio Maven es almacenar un artefacto en el siguiente directorio relativo a la raíz del repositorio:

/<groupId>/<artifactId>/<version>/<artifactId>-<version>.<packaging>

Maven descarga artefactos y complementos desde un repositorio remoto a su máquina local y almacena
estos artefactos en su repositorio local de Maven. Una vez que Maven haya descargado un artefacto desde
el repositorio remoto de Maven, nunca tendrá que volver a descargar ese artefacto, ya que Maven siempre
buscará el artefacto en el repositorio local antes de buscar en otro lado. En Windows XP, es probable que
su repositorio local esté en C: \ Documents and Settings \ USERNAME \ .m2 \ repository, y en Windows
Vista, su repositorio local está en C: \ Users \ USERNAME \ .m2 \ repository. En los sistemas Unix, su
repositorio local de Maven está disponible en ~ / .m2 / repository. Cuando crea un proyecto como el
proyecto simple que creó en la sección anterior, la fase de instalación ejecuta una meta que instala los
artefactos de su proyecto en su repositorio local de Maven.

En su repositorio local, debería poder ver el artefacto creado por nuestro proyecto simple. Si ejecuta el
comando mvn install, Maven instalará el artefacto de nuestro proyecto en su repositorio local. Intentalo.

$ mvn install
...
[INFO] [install:install]
[INFO] Installing .../simple-1.0-SNAPSHOT.jar to \
~/.m2/repository/com/sonatype/maven/simple/1.0-SNAPSHOT/ \
simple-1.0-SNAPSHOT.jar
...

Como puede ver en el resultado de este comando, Maven instaló el archivo JAR de nuestro proyecto en
nuestro repositorio local de Maven. Maven usa el repositorio local para compartir dependencias entre
proyectos locales. Si desarrolla dos proyectos, el proyecto A y el proyecto B, con el proyecto B dependiendo
del artefacto producido por el proyecto A, Maven recuperará el artefacto del proyecto A de su repositorio
local cuando esté construyendo el proyecto B. Los repositorios de Maven son un caché local de artefactos
descargado desde un repositorio remoto y un mecanismo para permitir que sus proyectos dependan unos
de otros.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

96
 Opsait
Academic

7.15 Gestión de dependencias de Maven

En el ejemplo simple de este capítulo, Maven resolvió las coordenadas de la dependencia de JUnit junit:
junit: 3.8.1 toapathinaMavenrepository /junit/junit/3.8.1/junit-3.8.1.jar. La capacidad de ubicar un artefacto en
un repositorio basado en las coordenadas de Maven nos da la capacidad de definir dependencias en el
archivo POM del proyecto. Si examina el archivo pom.xml del proyecto simple, verá que hay una sección
que se ocupa de las dependencias y que esta sección contiene una sola dependencia: JUnit.

Un proyecto más complejo contendría más de una dependencia, o podría contener dependencias que
dependen de otros artefactos. El soporte para dependencias transitivas es una de las características más
poderosas de Maven. Supongamos que su proyecto depende de una biblioteca que, a su vez, depende de
otras 5 o 10 bibliotecas (Spring o Hibernate, por ejemplo). En lugar de tener que rastrear todas estas
dependencias y enumerarlas explícitamente en su pom.xml, simplemente puede depender de la biblioteca
que le interesa y Maven agregará las dependencias de esta biblioteca a las dependencias de su proyecto
implícitamente. Maven también se encargará de resolver conflictos entre dependencias y le brinda la
posibilidad de personalizar el comportamiento predeterminado y excluir ciertas dependencias transitivas.

Echemos un vistazo a una dependencia que se descargó a su repositorio local cuando ejecutó el ejemplo
anterior. Busque en su ruta de repositorio local en ~ / .m2 / repository / junit / junit / 3.8.1 /. Si ha seguido los
ejemplos de este capítulo, habrá un archivo llamado junit-3.8. 1.jar y un archivo junit-3.8.1.pom además de
algunos archivos de suma de comprobación que Maven utiliza para verificar la autenticidad de un artefacto
descargado. Tenga en cuenta que Maven no solo descarga el archivo JUnit JAR, sino que también
descarga un archivo POM para la dependencia JUnit. El hecho de que Maven descargue archivos POM
además de artefactos es fundamental para el soporte de Maven para las dependencias transitivas.

Cuando instale el artefacto de su proyecto en el repositorio local, también notará que Maven publica una
versión ligeramente modificada del archivo pom.xml del proyecto en el mismo directorio que el archivo JAR.
El almacenamiento de un archivo POM en el repositorio proporciona a otros proyectos información sobre
este proyecto, lo que es más importante, qué dependencias tiene. Si el Proyecto B depende del Proyecto A,
también depende de las dependencias del Proyecto A. Cuando Maven resuelve un artefacto de
dependencia a partir de un conjunto de coordenadas de Maven, también recupera el POM y consulta el
POM de dependencias para encontrar cualquier dependencia transitiva. Estas dependencias transitivas se
agregan como dependencias del proyecto actual.

Una dependencia en Maven no es solo un archivo JAR; es un archivo POM que, a su vez, puede declarar
dependencias de otros artefactos. Estas dependencias de dependencias se denominan dependencias
transitivas, y son posibles por el hecho de que el repositorio de Maven almacena más que un código de
bytes; almacena metadatos sobre artefactos.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

97
 Opsait
Academic

En la figura anterior, el proyecto A depende de los proyectos B y C. El proyecto B depende del proyecto D y
el proyecto C depende del proyecto E. El conjunto completo de dependencias directas y transitivas para el
proyecto A serían los proyectos B, C, D y E, pero todo lo que el proyecto A tuvo que hacer fue definir una
dependencia de B y C. Las dependencias transitivas pueden ser útiles cuando su proyecto depende de
otros proyectos con varias dependencias pequeñas (como Hibernate, Apache Struts o Spring Framework).
Maven también le brinda la capacidad de excluir las dependencias transitivas de ser incluidas en el
classpath de un proyecto.

Maven también proporciona diferentes ámbitos de dependencia. El pom.xml del proyecto simple contiene
una sola dependencia: junit: junit: jar: 3.8.1, withascopeoftest. Cuando la dependencia tiene un alcance de
prueba, no estará disponible para el objetivo de compilación del complemento Compilador. Se agregará al
classpath solo para el compiler: testCompile y surefire: test goals.

Cuando crea un JAR para un proyecto, las dependencias no se agrupan con el artefacto generado; solo se
usan para compilar. Cuando utiliza Maven para crear un archivo WAR o EAR, puede configurar las
dependencias del paquete Mavento con el artefacto generado, y también puede configurarlo para excluir
ciertas dependencias del archivo WAR utilizando el alcance proporcionado. El alcance proporcionado le dice
a Maven que se necesita una dependencia para la compilación, pero que no se debe agrupar con la salida
de una compilación. Este alcance viene cuando usted está desarrollando una aplicación web. Tendrá que
compilar nuestra empresa contra la especificación de Servlet, pero no desea incluir el JAR API de Servlet en
el directorio WEBINF / lib de su aplicación web.

7.16 Generación de sitios e informes

Otra característica importante de Maven es su capacidad para generar documentación e informes. En el

directorio de su proyecto simple, ejecute el siguiente comando:

$ mvn site

Esto ejecutará la fase del ciclo de vida del sitio. A diferencia del ciclo de vida de compilación predeterminado
que gestiona la generación de código, la manipulación de recursos, la compilación, el empaquetado, etc.,
este ciclo de vida se ocupa únicamente del procesamiento del contenido del sitio bajo los directorios src /
site y la generación de informes. Después de que se ejecute este comando, debería ver un sitio web del
proyecto en el directorio de target / site. Cargue target / site / index.html y debería ver un shell básico de un
sitio de proyecto. Este shell contiene algunos informes en "Informes del proyecto" en el menú de navegación
de la izquierda, y también contiene información sobre el proyecto, las dependencias y los desarrolladores
asociados en "Información del proyecto". El sitio web del proyecto simple está en su mayoría vacío, ya que
el POM contiene muy poca información sobre sí mismo más allá de sus coordenadas Maven, un nombre,
una URL y una única dependencia de prueba.

En este sitio, notará que hay algunos informes predeterminados disponibles. Un informe de prueba de
unidad comunica el éxito y el fracaso de todas las pruebas de unidad en el proyecto. Otro informe genera
Javadoc para la API del proyecto. Maven proporciona una gama completa de informes configurables, como
el informe Clover que examina la cobertura de las pruebas unitarias, el informe JXR que genera listados de
código fuente HTML con referencias cruzadas útiles para revisiones de código, el informe PMD que analiza
el código fuente para varios problemas de codificación, y el informe JDepend que analiza las dependencias
entre paquetes en una base de código. Puede personalizar los informes del sitio configurando qué informes
se incluyen en una compilación a través del archivo pom.xml.

7.17 Resumen

En este capítulo, creamos un proyecto simple, empaquetamos el proyecto en un archivo JAR, instalamos
ese JAR en el repositorio de Maven para que lo utilicen otros proyectos y generamos un sitio con
documentación. Logramos esto sin escribir una sola línea de código o tocar un solo archivo de
configuración. También nos tomamos un tiempo para desarrollar definiciones para algunos de los conceptos
centrales de Maven.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

98
 Opsait
Academic

8. Trabajando con bases de datos | 14h

8.1 ¿Qué es SQL?

En la actualidad es difícil pensar en el desarrollo de aplicaciones sin una manera fiable de almacenar datos.
Cualquier programa que imaginemos genera una ingente cantidad de datos. Ya sean simples registros
internos o datos generados por los propios usuarios.

Imaginemos por ejemplo un sistema de gestión hotelera. Tenemos los datos de cada cliente, empleado,
proveedor, sus reservas, datos de registro y facturación, sus modificaciones, etc. Si todavía crees que esto
se puede gestionar con un simple libro de registro mejor no sigas leyendo.

Si te dedicas al desarrollo de software sabes lo importante que es mantener los datos ordenados y
almacenados para poder ser usados de manera eficiente. Las bases de datos son la solución. Grandes
almacenes de datos que una vez estructuradas almacenan todo lo que podamos precisar en nuestro
desarrollo. Pero, ¿qué es una base de datos?

Desde un punto de vista técnico podemos definir una base de datos como una aplicación independiente a
nuestro programa que almacena una colección de datos. Esta colección de datos es organizada mediante
campos, registros, índices y archivos de manera que mediante una simple consulta sea posible seleccionar
fragmentos de datos mostrando el resultado con rapidez.

Aunque existen muchos tipos de bases de datos y métodos para manejar la información en este artículo
hablaremos de SQL (Structured Query Language). Se trata de un lenguaje declarativo estándar que permite
su integración en diferentes lenguajes de programación, por ejemplo PHP o Java y en combinación con
cualquier base de datos específica. MariaDB, MySQL o SQL Server, por citar algunos ejemplos, trabajan de
diferente manera pero todos comparten un modo común de manipulación y consulta de datos a través del
lenguaje SQL.

8.1.1 Creación y evolución de SQL

En ingeniería de software toda buena historia comienza con la necesidad de resolver un problema. En los
años 70 las bases de datos comenzaban a ser el quebradero de cabeza de muchos desarrollos. La falta de
un estándar claro y que cada empresa competía por imponer su solución de software hacía muy difícil, sino
casi imposible, la coexistencia entre sí.

En 1974, basándose en el modelo correlacional establecido por Edgard Codd, IBM comienza a trabajar en
las bases de lo que sería su base de datos SEQUEL. La idea de fondo era resolver los problemas anteriores
ofreciendo una solución estandarizada a los problemas de la época.

El éxito de su propuesta fue inminente entre sus clientes y entre los años 1974 a 1977 aparecieron
diferentes versiones que popularizaron su integración en diferentes sistemas. Posteriormente por causas
legales IBM se vió obligada a rebautizar el nombre de su proyecto a SQL

Pronto las empresas de todo el mundo comenzaron a demandar soluciones de software que hicieran uso de
las bondades del sistema SQL. Esto hizo que pronto aparecieran alternativas procedentes de otras
compañias. Oracle, Sybase fueron las primeras compañías en comercializar sus productos basados en SQL
lo cual contribuyó a reforzar las bases del ecosistema que estaría por crearse.

SQL ya era por 1981 considerado un estándar pero no fue hasta 1986 cuando el ANSI adoptó SQL como
estándar de facto para los lenguajes relacionales. Esto hizo que un año después se publicase el conjunto de
normas que lo convertirán en un estándar ISO (SQL/86) dando lugar a diferentes revisiones hasta la fecha.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

99
 Opsait
Academic

8.1.2 Fundamentos de SQL

Con SQL podemos realizar diferentes operaciones para consultar o manipular datos. A estas operaciones
solemos referirnos como operaciones CRUD (de Create, Read, Update y Delete). Para ello hacemos uso de
cuatro instrucciones para realizar estas tareas:

 INSERT: Inserta filas en una tabla. Se corresponde con la “C” de CRUD.

 SELECT: Muestra información sobre los datos almacenados en la base de datos. Dicha información
puede pertenecer a una o varias tablas. Es la “R”.
 UPDATE: Actualiza información de una tabla. Es, obviamente, la “U”.
 DELETE: Borra filas de una tabla. Se corresponde con la “D”.

Por ejemplo y para mostrar cómo funciona su sintaxis lo mejor es ver un ejemplo con SELECT. Es sin duda el
comando más versátil del lenguaje SQL.

SELECT *
FROM Nombre_Tabla_Vista
WHERE Condiciones
ORDER BY ListaColumnas [ ASC / DESC ]

Por ejemplo:

nombre apellido1 apellido2

JUAN PEREZ MENDEZ
MARIA GARCIA BENITO
LUIS GARCIA PEREZ

8.1.3 DDL, DML y DCL

Cuando pensamos en una base de datos tenemos solemos verla como un conjunto de datos ordenados en
tablas, registros e índices pero en realidad el primer paso es definir sus estructuras de datos. El lenguaje
SQL permite a programadores realizar esta tarea de manera eficiente a través de un gestor de bases de
datos como MySQL o PostgreSQL. Para ello SQL como estándar se estructura a su vez en 3 lenguajes
independientes con las siglas DDL, DML y DCL.

8.1.3.1 Lenguaje de Definición de Datos

DDL (Data Definition Language) es el conjunto de instrucciones agrupadas en un lenguaje que nos permite
definir estas estructuras que almacenarán los datos así como los procedimientos y funciones que permitirán
consultarlos.

Para definir las estructura disponemos de tres sentencias:

 CREATE, se usa para crear una base de datos, tabla, vistas, etc.
 ALTER, se utiliza para modificar la estructura, por ejemplo añadir o borrar columnas de una tabla.
 DROP, con esta sentencia, podemos eliminar los objetos de la estructura, por ejemplo un índice o
una secuencia.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

100
 Opsait
Academic

8.1.3.2 Lenguaje de Manipulación de Datos (DML)

Data Manipulation Language (DML) se resume en el conjunto de instrucciones SQL que permite a los
usuarios introducir datos para posteriormente realizar tareas de consultas o modificación de los datos que
contienen las Bases de Datos.

Los elementos que se utilizan para manipular los datos, son los siguientes:

 SELECT, esta sentencia se utiliza para realizar consultas sobre los datos.
 INSERT, con esta instrucción podemos insertar los valores en una base de datos.
 UPDATE, sirve para modificar los valores de uno o varios registros.
 DELETE, se utiliza para eliminar las finas de una tabla.

8.1.3.3 Lenguaje de Control de Datos (DCL)

Hasta aquí hemos visto las sentencias usadas para crear y manipular datos pero también es necesario su
control y administración. De esto se encarga el lenguaje DLC (Data Control Languaje) mediante el conjunto
de comandos que permiten a un administrador del sistema de bases de datos controlar el acceso a usuarios
mediante la asignación de permisos o roles para realizar determinadas tareas.

Los comandos para controlar los permisos son los siguientes:

 GRANT, permite otorgar permisos.

 REVOKE, elimina los permisos que previamente se han concedido.

8.1.4 Sistemas de gestión de bases de datos más conocidos

Desde la aparición de los primeros modelos de bases de datos relacionales a comienzos de la década de
los 70 hasta nuestros días la industria del software a visto nacer y morir múltiples propuestas. En una
evolución constante en la actualidad podemos decir que los principales sistemas gestores de bases de
datos relacionales en la actualidad son:

MySQL: Es el sistema gestor de bases de datos relacional por excelencia y utilizado en la gran parte de las
aplicaciones web actuales. Se ofrece bajo licencia GNU/GPL y aunque es posible adquirir una versión
licenciada por Oracle (actualmente la empresa responsable de su desarrollo).

Las principales ventajas son:

 Base de datos multihilo y multiusuario

 Facilidad de uso y gran rendimiento
 Facilidad para instalar y configurar
 Soporte multiplataforma
 Soporte SSL

MariaDB: Este sistema de gestión de bases de datos fue en origen un fork o derivación de MySQL debido a
los modelos de licencia que Oracle lleva imponiendo a su desarrollo desde la adquisición de Sun
Microsystems. Esto hizo que la comunidad moviera sus esfuerzos en la creación de un desarrollo
independiente.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

101
 Opsait
Academic

Entre sus principales características se encuentran:

 Aumento de motores de almacenamiento

 Gran escalabilidad
 Seguridad y rapidez en transacciones
 Extensiones y nuevas características relacionadas con su aplicación para Bases de datos NoSQL.

SQLite: Utilizada por multitud de aplicaciones en la actualidad se trata de una librería escrita en C que
implementa la gestión de un sistema de base de datos sin necesidad de un servidor ni configuraciones. Esto
lo hace muy versátil para el desarrollo de pequeñas aplicaciones de software reduciendo significativamente
sus requerimientos de hardware.

Las principales características de SQLite son:

 El tamaño, al tratarse de una biblioteca, es mucho menor que otros sistemas de gestión de bases
de datos.
 Reúne los cuatro criterios ACID (Atomicidad, Consistencia, Aislamiento y Durabilidad) logrando gran
estabilidad
 Gran portabilidad y rendimiento

PostgreSQL: Bajo licencia BSD este sistema de base de datos relacional está orientado a objetos. Esto
ofrece a desarrolladores la posibilidad de poder trabajar de un modelo más robusto de gestión de grandes
volúmenes de datos.

Sus principales características son:

 Control de Concurrencias multiversión (MVCC)

 Flexibilidad en cuanto a lenguajes de programación que soporta
 Es multiplataforma y opera bajo una licencia libre
 Robustez, Eficiencia y Estabilidad

Microsoft SQL Server: Es un sistema propietario licenciado por Microsoft y se basa en el lenguaje Transact-
SQL, capaz de poner a disposición de muchos usuarios grandes cantidades de datos de manera
simultánea.

Sus principales características son:

 Soporte exclusivo por parte de Microsoft.

 Escalabilidad, estabilidad y seguridad.
 Posibilidad de cancelar consultas.
 Potente entorno gráfico de administración que permite utilizar comandos DDL y DML.
 Puede utilizarse en otras plataformas como Linux o Docker.

Oracle: Además de MySQL Oracle ofrece su propia gestión de bases de datos para el mundo empresarial.
En la actualidad se considera como el más robusto y completo y es utilizado habitualmente en soluciones de
banca o en grandes empresas.

Sus principales características:

 Soporte de transacciones.
 Estabilidad.
 Escalabilidad.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

102
 Opsait
Academic

 Multiplataforma.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

103
 Opsait
Academic

9. Comandos y sintaxis de SQL

9.1.1.1 CREATE
Este comando crea un objeto dentro del gestor de base de datos. Puede ser una base de datos, tabla,
índice, procedimiento almacenado o vista.

Ejemplo (crear una tabla):

# CREATE TABLE Empleado

(
id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
Nombre VARCHAR(50),
Apellido VARCHAR(50),
Direccion VARCHAR(255),
Ciudad VARCHAR(60),
Telefono VARCHAR(15),
Peso VARCHAR (5),
Edad (2),
Actividad Específica (100),
idCargo INT
)

9.1.1.2 ALTER
Con este comando podemos modificar la estructura de un objeto. Se pueden agregar/quitar campos a una
tabla, modificar el tipo de un campo, agregar/quitar índices a una tabla, modificar un trigger, etc.

Ejemplo (agregar columna a una tabla):

# ALTER TABLE ' NOMBRE_TABLA' ADD NUEVO_CAMPO INT;

# ALTER TABLE 'NOMBRE_TABLA' DROP COLUMN NOMBRE_COLUMNA;

9.1.1.3 DROP
Este comando elimina un objeto de la base de datos. Puede ser una tabla, vista, índice, trigger, función,
procedimiento o cualquier otro objeto que el motor de la base de datos soporte. Se puede combinar con la
sentencia ALTER.

Ejemplo:

# DROP TABLE 'NOMBRE_TABLA';

# DROP SCHEMA 'ESQUEMA;'
# DROP DATABASE 'BASEDATOS';

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

104
 Opsait
Academic

9.1.1.4 TRUNCATE
Este comando trunca todo el contenido de una tabla. Frente a Drop su principal ventaja es que si se quiere
borrar todo el contenido de la tabla, es mucho más rápido, especialmente si la tabla es muy grande.

Ejemplo:

# TRUNCATE TABLE 'NOMBRE_TABLA';

9.1.1.5 INSERT
Una sentencia INSERT de SQL agrega uno o más registros a una (y sólo una) tabla en una base de datos
relacional.

Forma básica:

# INSERT INTO ''tabla'' (''columna1'', [''columna2,... '']) VALUES (''valor1'', [''valor2,...''])

Ejemplo:

# INSERT INTO agenda_telefonica VALUES (Pedro Aguilar, 881412339);

9.1.1.6 UPDATE
Utilizada para modificar los valores de un conjunto de registros existentes en una tabla.

Ejemplo:

# UPDATE mi_tabla SET campo1 = 'nuevo valor campo1' WHERE campo2 = 'N';

9.1.1.7 DELETE
Borra uno o más registros existentes en una tabla.

Forma básica:

# DELETE FROM 'tabla' WHERE 'columna1' = 'valor1'

Ejemplo:

# DELETE FROM My_table WHERE field2 = 'N';

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

105
 Opsait
Academic

9.2 Oracle | 5h

9.2.1 Que es una base de datos

Una base de datos es una colección organizada de datos estructurados almacenados electrónicamente en
un sistema informático.

Cuando se inventó la computadora, se usó principalmente para investigaciones científicas para realizar
cálculos rápidamente.

Dado que la computadora se adoptó cada vez más, los requisitos también se incrementaron para requerir
que la computadora almacene un meayor volumen de datos para una recuperación rápida.

Antes de que se inventara el sistema de base de datos, la estructura de archivos planos se usaba
comúnmente para almacenar datos. Por ejemplo, aquí está el archivo de valores separados por comas
(CSV) que almacena la información del empleado:

El archivo CSV tiene tres columnas que se conocen como campos y filas que se conocen como registros.
Cuando aumenta el número de filas en el archivo plano, por ejemplo, millones de filas, se vuelve
inmanejable.

En la década de 1970, el Dr. Ted Codd, un científico informático, inventó el modelo relacional para la gestión
de bases de datos. El modelo relacional trata muchos problemas causados por el modelo de archivo plano.
Según su modelo, los datos se organizan en entidades y atributos, en lugar de combinar todo en una sola
estructura.

Una entidad es una persona, lugar o cosa y los atributos describen la persona. Por ejemplo, puede usar el
modelo relacional para organizar la información del empleado en una entidad del empleado con los
atributos: nombre, apellido y teléfono:

Cada empleado puede tener uno o más contactos, puede crear una entidad de contacto y relacionar la
entidad del empleado con la entidad de contactos a través de una relación llamada uno a muchos.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

106
 Opsait
Academic

Por cierto, a menudo nos referimos a las entidades como tablas, registros como filas y campos como
columnas.

El modelo relacional es mejor que el modelo de archivo plano porque elimina los datos duplicados, por
ejemplo, si coloca información de empleados y contactos en el mismo archivo. El empleado, que tiene más
de un contacto, aparecerá en varias filas.

El Sistema de gestión de bases de datos relacionales, o RDBMS en resumen, gestiona datos relacionales.
Oracle Database es un RDBMS con la mayor cuota de mercado.

Además de Oracle Database, hay otros productos RDBMS disponibles. Aquí hay algunos notables:

 Db2 de IBM.
 SQL Server de Microsoft.
 MySQL: la base de datos de código abierto más popular, también de Oracle.
 PostgreSQL: la base de datos de código abierto más avanzada.

9.2.2 Características de la base de datos Oracle

Oracle Database le permite almacenar y recuperar datos de forma rápida y segura. Estos son los beneficios
de integración de la base de datos Oracle:

 Oracle Database es multiplataforma. Puede ejecutarse en varios hardware a través de sistemas

operativos, incluidos Windows Server, Unix y varias distribuciones de GNU / Linux.
 Oracle Database tiene su pila de redes que permite que la aplicación desde una plataforma
diferente se comunique con Oracle Database sin problemas. Por ejemplo, las aplicaciones que se
ejecutan en Windows pueden conectarse a la base de datos Oracle que se ejecuta en Unix.
 Compatible con ACID: Oracle es una base de datos compatible con ACID que ayuda a mantener la
integridad y confiabilidad de los datos.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

107
 Opsait
Academic

 Compromiso con las tecnologías abiertas: Oracle es una de las primeras bases de datos que
admitió GNU / Linux a fines de la década de 1990 antes de que GNU / Linux se convirtiera en un
producto comercial. Ha estado apoyando esta plataforma abierta desde entonces.

Oracle Database tiene varias características estructurales que lo hacen popular:

 Estructura de datos lógica: Oracle utiliza la estructura de datos lógica para almacenar datos para
que pueda interactuar con la base de datos sin saber dónde se almacenan físicamente los datos.
 Particionamiento: es una característica de alto rendimiento que le permite dividir una mesa grande
en diferentes piezas y almacenar cada pieza en dispositivos de almacenamiento.
 Almacenamiento en memoria caché: la arquitectura de almacenamiento en memoria caché le
permite escalar una base de datos muy grande que aún puede funcionar a alta velocidad.
 Data Dictionary: es un conjunto de tablas y vistas internas que admiten la administración de Oracle
Database de manera más efectiva.
 Copia de seguridad y recuperación: garantiza la integridad de los datos en caso de falla del sistema.
Oracle incluye una poderosa herramienta llamada Recovery Manager (RMAN): permite que DBA
realice copias de seguridad de bases de datos frías, calientes e incrementales y recuperaciones de
puntos en el tiempo.
 Clustering: Oracle Real Application Clusters (RAC): Oracle permite una alta disponibilidad que
permite que el sistema esté en funcionamiento sin interrupción de los servicios en caso de que uno
o más servidores en un clúster falle.

9.2.3 Ediciones de base de datos Oracle

Oracle proporciona tres ediciones principales de bases de datos Oracle de la siguiente manera:

1) Enterprise Edition (EE) es la edición común y costosa de la base de datos Oracle. Tiene las siguientes
características:

 Sin número máximo de CPU

 Sin límites en la memoria o el tamaño de la base de datos.
 Incluye características Premium que no están disponibles en otras ediciones.

2) Standard Edition (SE) es una edición limitada de Enterprise Edition que tiene las siguientes
características:

 Limitado a cuatro o menos CPU

 Sin límite de memoria o tamaño de la base de datos.
 Incluye muchas funciones, pero no tantas como EE

3) Expression Edition (XE) es una versión gratuita de la base de datos Oracle que está disponible en
plataformas Windows y GNU / Linux. Estas son las características de Oracle Database XE 18c:

 Limitado a 2 CPU
 Puede usar el máximo de 2 GB de RAM y tiene 12 GB de datos de usuario.
 Características muy limitadas

9.2.4 Conceptos básicos de Oracle

9.2.4.1 Consulta de datos:
SELECT: muestra cómo consultar datos de una sola tabla.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

108
 Opsait
Academic

9.2.4.2 Ordenar datos:

ORDER BY: ordena el conjunto de resultados de una consulta en orden ascendente o descendente.

9.2.4.3 Filtrar datos:

DISTINCT : elimina filas duplicadas del resultado de una consulta.
WHERE: especifica una condición para las filas en el conjunto de resultados devuelto por una consulta.
AND: combina dos o más expresiones booleanas y devuelva verdadero si todas las expresiones son
verdaderas.
OR : combina dos o más expresiones booleanas y devuelva verdadero si una de las expresiones es
verdadera.
FETCH : muestra cómo limitar las filas devueltas por una consulta utilizando la cláusula de limitación de
filas.
IN: determina si un valor coincide con algún valor en una lista o subconsulta.
BETWEEN: filtra los datos en función de un rango de valores.
LIKE: realiza una coincidencia basada en patrones específicos.
IS NULL y IS NOT NULL: compruebe si una expresión o valores en una columna son NULL o no.

9.2.4.4 Unir tablas

INNER JOIN: consulta filas de una tabla que tienen filas coincidentes de otra tabla.
LEFT JOIN: selecciona filas de la tabla izquierda que tienen o no las filas coincidentes en la tabla derecha.
RIGHT JOIN: consulta de la tabla derecha que tienen o no las filas coincidentes en la tabla izquierda.
FULL OUTER JOIN: consulta datos de dos tablas.
CROSS JOIN: producto cartesiano a partir de varias tablas.
Self-join: consulta datos jerárquicos o compara filas dentro de la misma tabla.
9.2.4.5 Agrupar datos
GROUP BY : agrupa filas en subgrupos y aplica una función agregada para cada grupo
HAVING: devuelve filas donde los valores agregados cumplen las condiciones especificadas.
9.2.4.6 Subconsulta
Subquery: se utiliza para devolver datos que se utilizarán en la consulta principal como condición para
restringir aún más los datos que se recuperarán.
Subquery correlacionado: es una subconsulta que depende de los valores devueltos por la consulta
externa.
EXISTS y NOT EXISTS: verifica existencia de filas devueltas por una subconsulta.
ANY, SOME, y ALL: compara un valor con una lista o subconsulta.
9.2.4.7 Operadores
UNION: combina los resultados de dos consultas en un único resultado.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

109
 Opsait
Academic

INTERSECT: compara el resultado de dos consultas y devuelve las distintas filas que generan ambas

consultas..
MINUS: resta un conjunto de resultados de otro.
9.2.4.8 Modificar datos
INSERT: inserta una fila en una tabla.
INSERT INTO SELECT:inserta datos en una tabla a partir del resultado de una consulta.
INSERT ALL: inserta varias filas en una tabla o varias tablas.
UPDATE: cambia los valores existentes de una tabla.
DELETE: elimina una o más filas de una tabla.
MERGE: realiza una combinación de inserción, actualización y eliminación utilizando una sola instrucción.
9.2.4.9 Definición de datos
CREATE TABLE: crear nuevas tablas en la base de datos.
ALTER TABLE: cambia la estructura de las tablas existentes.
ALTER TABLE ADD: agrega una o más columnas a una tabla existente.
ALTER TABLE MODIFY column: cambia la definición de las columnas existentes en una tabla.
DROP TABLE: elimina tablas de la base de datos.
TRUNCATE TABLE: elimina todos los datos de una tabla de forma más rápida y eficiente.
RENAME table: cambia el nombre de una tabla.
9.2.4.10 Tipos de datos
Tipo de Dato
VARCHAR2(size [BYTE | CHAR])
NVARCHAR2(size)
NUMBER[(precision [, scale]])
LONG
DATE
BINARY_FLOAT
BINARY_DOUBLE
RAW(size)
LONG RAW
ROWID
CHAR [(size [BYTE | CHAR])]
NCHAR[(size)]
CLOB
NCLOB
BLOB
BFILE
TIMESTAMP [(fractional_seconds)]
TIMESTAMP [(fractional_seconds)] WITH TIME ZONE
INTERVAL YEAR [(year_precision)] TO MONTH
INTERVAL DAY [(day_precision)] TO SECOND[(fractional_seconds)]
UROWID [(size)]

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

110
 Opsait
Academic

Tipo de Dato
TIMESTAMP [(fractional_seconds)] WITH LOCAL TIMEZONE
10. Restricciones
Primary key: es una columna o una combinación de columnas en una tabla que identifica de forma
exclusiva una fila.
Foreign key: es una columna o varias columnas, que sirven para señalar cual es la clave primaria de otra
tabla.
NOT NULL constraint: asegura de que una columna no acepte valores nulos.
UNIQUE constraint: garantiza que los datos almacenados en una columna o en un grupo de columnas
sean únicos entre las filas de toda la tabla.
CHECK constraint: permite imponer la integridad del dominio al limitar los valores aceptados por una o más
columnas.
10.1.1 Vistas de Oracle
Puede usar vistas en muchos casos para diferentes propósitos. Los usos más comunes de las vistas son los
siguientes:

 Simplificando la recuperación de datos.

 Mantener la independencia lógica de los datos.
 Implementación de seguridad de datos.

10.1.1.1 Simplificando la recuperación de datos

Las vistas ayudan a simplificar la recuperación de datos de manera significativa. Primero, crea una consulta
compleja. Luego, puede acceder a los datos de las tablas subyacentes a través de la vista en lugar de
reescribir toda la consulta una y otra vez.

La siguiente consulta devuelve el importe de ventas por cliente por año:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

111
 Opsait
Academic

Esta consulta es bastante compleja. Escribirlo una y otra vez lleva mucho tiempo y potencialmente puede
causar un error. Para simplificarlo, puede crear una vista basada en esta consulta:

Ahora, puede recuperar fácilmente las ventas del cliente en 2017 con una consulta más simple:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

112
 Opsait
Academic

10.1.2PL/SQL
PL / SQL significa "Extensiones de lenguaje de procedimiento para el lenguaje de consulta estructurado".
SQL es un lenguaje popular para consultar y actualizar datos en los sistemas de gestión de bases de datos
relacionales (RDBMS). PL / SQL agrega muchas construcciones de procedimiento al lenguaje SQL para
superar algunas limitaciones de SQL. Además, PL / SQL proporciona una solución de lenguaje de
programación más completa para crear aplicaciones de misión crítica en bases de datos Oracle.

PL / SQL es un lenguaje altamente estructurado y legible. Sus construcciones expresan claramente la

intención del código. Además, PL / SQL es un lenguaje sencillo de aprender.

PL / SQL es un lenguaje estándar y portátil para el desarrollo de Oracle Database. Si desarrolla un

programa que se ejecuta en una base de datos Oracle, puede moverlo rápidamente a otra base de datos
Oracle compatible sin ningún cambio.

PL / SQL es un lenguaje incrustado. PL / SQL solo puede ejecutarse en una base de datos Oracle. No fue
diseñado para usarse como un lenguaje independiente como Java, C # y C ++. En otras palabras, no puede
desarrollar un programa PL / SQL que se ejecute en un sistema que no tenga una base de datos Oracle.

PL / SQL es un lenguaje de base de datos de alto rendimiento y altamente integrado. Además de PL / SQL,
puede usar otros lenguajes de programación como Java, C # y C ++. Sin embargo, es más fácil escribir
código eficiente en PL / SQL que otros lenguajes de programación cuando se trata de interactuar con la
base de datos Oracle. En particular, puede usar construcciones específicas de PL / SQL como la
FORALLdeclaración que ayuda a mejorar el rendimiento de la base de datos.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

113
 Opsait
Academic

10.2 MySQL |4h

En programación es prácticamente inevitable trabajar con algún tipo de sistema de gestión de bases de
datos. Cualquier programa que imaginemos tarde o temprano necesitará almacenar datos en algún lugar,
como mínimo para poder almacenar la lista de usuarios autorizados, sus permisos y propiedades.

MySQL es el sistema de gestión de bases de datos relacional más extendido en la actualidad al estar
basada en código abierto. Desarrollado originalmente por MySQL AB, fue adquirida por Sun MicroSystems
en 2008 y esta su vez comprada por Oracle Corporation en 2010, la cual ya era dueña de un motor propio
InnoDB para MySQL.

MySQL es un sistema de gestión de bases de datos que cuenta con una doble licencia. Por una parte es de
código abierto, pero por otra, cuenta con una versión comercial gestionada por la compañía Oracle.

Las versiones Enterprise, diseñadas para aquellas empresas que quieran incorporarlo en productos
privativos, incluyen productos o servicios adicionales tales como herramientas de monitorización y
asistencia técnica oficial.

10.2.1Características de MySQL
MySQL presenta algunas ventajas que lo hacen muy interesante para los desarrolladores. La más evidente
es que trabaja con bases de datos relacionales, es decir, utiliza tablas múltiples que se interconectan entre
sí para almacenar la información y organizarla correctamente.

Al ser basada en código abierto es fácilmente accesible y la inmensa mayoría de programadores que
trabajan en desarrollo web han pasado usar MySQL en alguno de sus proyectos porque al estar
ampliamente extendido cuenta además con una ingente comunidad que ofrece soporte a otros usuarios.
Pero estas no son las únicas características como veremos a continuación:

1. Arquitectura Cliente y Servidor: MySQL basa su funcionamiento en un modelo cliente y servidor.

Es decir, clientes y servidores se comunican entre sí de manera diferenciada para un mejor
rendimiento. Cada cliente puede hacer consultas a través del sistema de registro para obtener
datos, modificarlos, guardar estos cambios o establecer nuevas tablas de registros, por ejemplo.
2. Compatibilidad con SQL: SQL es un lenguaje generalizado dentro de la industria. Al ser un
estándar MySQL ofrece plena compatibilidad por lo que si has trabajado en otro motor de bases de
datos no tendrás problemas en migrar a MySQL.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

114
 Opsait
Academic

3. Vistas: Desde la versión 5.0 de MySQL se ofrece compatibilidad para poder configurar vistas
personalizadas del mismo modo que podemos hacerlo en otras bases de datos SQL. En bases de
datos de gran tamaño las vistas se hacen un recurso imprescindible.
4. Procedimientos almacenados: MySQL posee la característica de no procesar las tablas
directamente sino que a través de procedimientos almacenados es posible incrementar la eficacia
de nuestra implementación.
5. Desencadenantes: MySQL permite además poder automatizar ciertas tareas dentro de nuestra
base de datos. En el momento que se produce un evento otro es lanzado para actualizar registros o
optimizar su funcionalidad.
6. Transacciones: Una transacción representa la actuación de diversas operaciones en la base de
datos como un dispositivo. El sistema de base de registros avala que todos los procedimientos se
establezcan correctamente o ninguna de ellas. En caso por ejemplo de una falla de energía, cuando
el monitor falla u ocurre algún otro inconveniente, el sistema opta por preservar la integridad de la
base de datos resguardando la información.

10.2.2 Ventajas de usar MySQL

Descritas las principales características de MySQL es fácil ver sus ventajas. MySQL es una opción
razonable para ser usado en ámbito empresarial. Al estar basado en código abierto permite a pequeñas
empresas y desarrolladores disponer de una solución fiable y estandarizada para sus aplicaciones. Por
ejemplo, si se cuenta con un listado de clientes, una tienda online con un catálogo de productos o incluso
una gran selección de contenidos multimedia disponible, MySQL ayuda a gestionarlo todo debida y
ordenadamente.

10.2.3 Historia y versiones de MySQL

La historia de MySQL comienza cuando Michael Widenius, un programador de software, buscaba una
solución sencilla que permitiera dar salida a sus proyectos sin recurrir a soluciones de terceros. Al comienzo
MySQL carecía de elementos considerados esenciales como la integridad referencial y transacciones pero a
pesar de ello atrajo rápidamente a desarrolladores web.

Esto dió lugar a la fundación de la empresa MySQL AB (empresa fundada por David Axmark, Allan Larsson
y Michael Widenius) para dar continuidad al proyecto. Posteriormente la empresa fue adquirida por Sun
MicroSystems en 2008 quien vió en MySQL una solución para competir con su competidor Oracle quien,
curiosamente, acabó por hacerse con la compañía en 2010.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

115
 Opsait
Academic

Desde 1995, momento en el que la compañía de software de MySQL AB creó la versión original hasta hoy
MySQL ha ido evolucionando incorporando nuevas funciones. En 1999, se lanzó la versión 3.23.0, la
primera versión en importancia a la que luego siguieron otras como las versiones 5.0.0, liberada en 2005, y
la 5.5.x que fue lanzada en diciembre de 2009.

10.2.4 Principales sentencias de MySQL

MySQL comparte las sentencias del lenguaje SQL. Lo que en la práctica se traduce en una plena
compatibilidad. Al ser un elemento muy ligado al backend de cualquier aplicación web, normalmente
desarrollada sobre algún lenguaje como PHP, puede ser un poco difícil de ejemplificar pues sería necesario
abarcar todo un artículo pero se puede realizar la siguiente relación de sentencias básicas:

 SELECT  Es usada para consultar datos.

 DISTINCT  Sirve para eliminar los duplicados de las consultas de datos.
 WHERE  Es usada incluir las condiciones de los datos que queremos consultar.
 AND y OR  Es usada para incluir 2 o más condiciones a una consulta.
 ORDER BY  Es usada para ordenar los resultados de una consulta.
 INSERT  Es usada para insertar datos.
 UPDATE  Es usada actualizar o modificar datos ya existentes.
 DELETE  Es usada borrar datos.

Por ejemplo y para mostrar cómo funciona su sintaxis lo mejor es ver un ejemplo con SELECT. Es sin duda
el comando más versátil del lenguaje SQL.

SELECT *
FROM Nombre_Tabla_Vista
WHERE Condiciones
ORDER BY ListaColumnas [ ASC / DESC ]

Por ejemplo:

SELECT nombre, apellido1, apellido2 FROM personas

nombre apellido1 apellido2
JUAN MATEOS MENDEZ
MARIA GARCIA BENITO
LUIS GARCIA MATEOS

10.2.4.1 Ejemplo con Distinct

Al realizar una consulta puede ocurrir que existan valores repetidos para algunas columnas. Por ejemplo

SELECT nombre FROM personas

NOMBRE
EVA
LUIS
EVA

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

116
 Opsait
Academic

Esto no es un problema, pero a veces queremos que no se repitan, por ejemplo, si queremos saber los
nombre diferentes que hay en la tabla personas”, entonces utilizaremos DISTINCT.

SELECT DISTINCT nombre FROM personas

nombre
EVA
LUIS

10.2.4.2 Ejemplo con WHERE

La cláusula WHERE es usada para hacer filtros en las consultas, es decir, seleccionar solamente algunas
filas de la tabla que cumplan una determinada condición.

El valor de la condición debe ir entre comillas simples”. Por ejemplo:

Seleccionar las personas cuyo nombre sea EVA

SELECT * FROM personas WHERE nombre = EVA

nombre apellido1 apellido2
EVA MATEOS GUTIERREZ
EVA BENITO BENITO

10.2.4.3 Ejemplo con AND y OR

Los operadores AND y OR son usados para filtrar resultados con 2 condiciones. Así, el operador AND
mostrará los resultados si se cumplan las 2 condiciones.

Condición1 AND condición2

Mientras que el operador OR mostrará los resultados cuando se cumpla alguna de las 2 condiciones.

Condicion1 OR condicion2

Por ejemplo en la tabla personas:

nombre apellido1 apellido2

EVA MATEOS GUTIERREZ
EVA BENITO BENITO
LUIS LOPEZ MATEOS
La siguiente sentencia (ejemplo AND) dará el siguiente resultado:

SELECT * FROM personas WHERE nombre = ‘EVA’ AND apellido1 = ‘GARCIA’

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

117
 Opsait
Academic

nombre apellido1 apellido2

EVA GARCIA BENITO

10.2.4.4 Ejemplo con ORDER BY

ORDER BY es usada para ordenar los resultados de una consulta, según el valor de la columna
especificada. Por ejemplo:

SELECT nombre, apellido1 FROM personas ORDER BY apellido1 ASC

nombre apellido1
LUIS LOPEZ
EVA GARCÍA
EVA MATEOS

SELECT nombre, apellido1 FROM personas ORDER BY apellido1 DESC

nombre apellido1
EVA MATEOS
EVA GARCIA
LUIS LOPEZ

10.2.4.5 Ejemplo con INSERT

La sentencia INSERT INTO es usada para insertar nuevas filas en una tabla. Si queremos insertar una
nueva fila en la tabla personas, lo podemos hacer con cualquiera de las dos sentencias siguientes:

INSERT INTO personas VALUES (‘PEDRO’, ‘RUIZ’, ‘GONZALEZ’)

INSERT INTO personas (nombre, apellido1, apellido2) VALUES (‘PEDRO’, ‘RUIZ’, ‘GONZALEZ’)

10.2.4.6 Ejemplo con UPDATE

La sentencia UPDATE es usada para modificar valores en una tabla.

Ejemplo del uso de SQL UPDATE

UPDATE personas SET apellido2 = ‘RODRIGUEZ’ WHERE nombre = ‘ANTONIO’ AND apellido1 = ‘GARCIA’
AND apellido2 = ‘BENITO’

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

118
 Opsait
Academic

10.2.4.7 Ejemplo con DELETE

La sentencia DELETE es usada para BORRAR valores en una tabla. Por ejemplo:

DELETE FROM personas WHERE nombre = ‘LUIS’ AND apellido1 = ‘LOPEZ’ AND apellido2 = ‘MATEOS’

Por supuesto podríamos ofrecer más ejemplos pero las posibilidades son infinitas. En este tipo de casos la
máxima debería ser “la práctica hace al maestro” y estoy seguro que a poco que comiences a trabajar con
bases de datos o a desarrollar tus primeras aplicaciones en PHP, Java o Javascript comenzarás a
familiarizarte con los conceptos básicos y avanzados del tratamiento de datos en MySQL.

10.2.5 Algunas operaciones básicas con MySQL

Mostrando bases de datos existentes. Usando la instrucción SHOW DATABASES:

Creando una nueva base de datos. Usando la instrucción CREATE DATABASE:

Compronado si la base de datos ha sido creada:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

119
 Opsait
Academic

Creando una tabla dentro de una base de datos. Primero, elija la base de datos en la que desea crear la
tabla con una instrucción USE :

La instrucción USE le dice a MySQL que la use como la base de datos predeterminada para declaraciones
posteriores. A continuación, cree una tabla con una instrucción CREATE TABLE :

Agregar registros a la tabla. Utilice, por ejemplo, una instrucción INSERT ... VALUES :

Recuperando registros de la tabla.  Usando la  instrucción SELECT y " * " para hacer coincidir todas las

columnas:

Para seleccionar columnas y filas específicas por una determinada condición utilizando la clausula WHERE:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

120
 Opsait
Academic

Eliminar un registro de una tabla. Usamos la instrucción DELETE para eliminar un registro de una tabla,
especificando el criterio para la eliminación con la cláusula WHERE:

Agregar o eliminar una columna de una tabla. Usamos la instrucción ALTER TABLE ... ADD para agregar
una columna. Puede usar, por ejemplo, una AFTER cláusula para especificar la ubicación de la nueva
columna:

Usamos la instrución ALTER TABLE ... DROP para eliminar una columna:

10.2.6 Trabajar con parámetros

Aunque es posible construir cadenas de consulta SQL directamente desde la entrada del usuario, esto no es
aconsejable ya que no evita que se ingrese información errónea o maliciosa. Es más seguro usar
parámetros, ya que se procesarán solo como datos de campo. Por ejemplo, imagine que la siguiente
consulta se construyó a partir de la entrada del usuario:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

121
 Opsait
Academic

Si la cadena user_continent provenía de un control de TextBox, potencialmente no habría control sobre la

cadena ingresada por el usuario. El usuario podría ingresar una cadena que genere un error de tiempo de
ejecución o, en el peor de los casos, dañar el sistema. Cuando se utilizan parámetros, no es posible hacerlo
porque un parámetro solo se trata como un parámetro de campo, en lugar de una pieza arbitraria de código
SQL.

La misma consulta escrita usando un parámetro para la entrada del usuario es:

Además de marcar la posición del parámetro en la cadena de consulta, es necesario agregar un parámetro
al objeto Command. Esto se ilustra con el siguiente fragmento de código:

En este ejemplo, la cadena "North America" se suministra como el valor del parámetro de forma estática,
pero en un ejemplo más práctico provendría de un control de entrada del usuario.

Otro ejemplo ilustra el proceso completo:

10.2.7 Trabajando con Stored Procedures

Poner operaciones intensivas en bases de datos en procedimientos almacenados le permite definir una API
para su aplicación de base de datos. Puede reutilizar esta API en múltiples aplicaciones y múltiples
lenguajes de programación. Esta técnica evita duplicar el código de la base de datos, ahorrando tiempo y
esfuerzo cuando realiza actualizaciones debido a cambios en el esquema, ajusta el rendimiento de las
consultas o agrega nuevas operaciones de base de datos para el registro, la seguridad, etc.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

122
 Opsait
Academic

Ejemplo:

Pruebe que el procedimiento almacenado funciona como se esperaba escribiendo lo siguiente en el

intérprete de comandos mysql:

Llamar a un procedimiento almacenado desde su aplicación Connector / NET. Un MySqlCommand crea un

objeto, pero en lugar de tomar una consulta SQL como parámetro, toma el nombre del procedimiento
almacenado para llamarlo. Establezca el MySqlCommand objeto en el tipo de procedimiento almacenado,
como se muestra en el siguiente fragmento de código:

En este caso, el procedimiento almacenado requiere que pase un parámetro, como se muestra en el
siguiente fragmento de código:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

123
 Opsait
Academic

El siguiente código muestra el ejemplo completo del procedimiento almacenado.

10.3 Hibernate y JPA | 5h

Hibernate es un marco que proporciona una cierta capa de abstracción , lo que significa que el programador
no tiene que preocuparse de las implementaciones, Hibernate hace las implementaciones para que
internamente como establecer una conexión con la base de datos, escribiendo consulta para realizar las
operaciones CRUD etc .

Es un marco de Java que se utiliza para desarrollar la lógica de persistencia. La lógica de persistencia
significa almacenar y procesar los datos para un uso prolongado. Más precisamente, Hibernate es un marco
java ORM (Object-relational mapping) de código abierto, no invasivo y ligero para desarrollar objetos que
son independientes del software de la base de datos y hacen una lógica de persistencia independiente en
todo JAVA, JEE.

Framework significa que es un software especial que se puede instalar que proporciona una capa de
abstracción en una o más tecnologías como JDBC, Servlet, etc. para simplificar o reducir la complejidad del
proceso de desarrollo.

Código abierto significa:

 El marco de Hibernate está disponible para todos sin costo alguno.

 El código fuente de Hibernate también está disponible en Internet y también podemos modificar el
código.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

124
 Opsait
Academic

Peso ligero significa:

 Hibernate es de menor tamaño, lo que significa que el paquete de instalación no es grande.

 Hibernate no requiere ningún contenedor pesado para su ejecución.
 No requiere programación de modelos POJO y POJI.
 Hibernate se puede usar solo o podemos usar Hibernate con otra tecnología y marco de Java.

Medios no invasivos:

 Las clases de desarrollo de aplicaciones de Hibernate son clases poco acopladas con respecto a la
API de Hibernate, es decir, la clase de Hibernate no necesita implementar interfaces de API de
hibernate y no necesita extenderse desde las clases de API de Hibernate.

10.3.1Funcionalidades compatibles con el marco de Hibernate

El marco de Hibernate admite operaciones DDL automáticas . En JDBC manualmente, tenemos que crear
una tabla y declarar el tipo de datos para cada columna. Pero Hibernate puede realizar operaciones DDL
por usted internamente, como la creación de una tabla, soltar una tabla, alterar una tabla, etc.

Hibernate admite la generación automática de claves primarias . Significa que en JDBC tenemos que
establecer manualmente una clave primaria para una tabla. Pero Hibernate puede hacer esta tarea por
usted.

El marco de Hibernate es independiente de la base de datos porque es compatible con HQL (Hibernate
Query Language) que no es específico de ninguna base de datos, mientras que JDBC depende de la base
de datos.

En Hibernate, el manejo de excepciones no es obligatorio , mientras que en JDBC el manejo de

excepciones es obligatorio.

Hibernate admite memoria caché, mientras que JDBC no admite memoria caché.

Hibernate es una herramienta ORM, lo que significa que admite el mapeo relacional de objetos. Mientras
que JDBC no está orientado a objetos, además, estamos tratando con valores que significan datos
primitivos. En hibernación, cada registro se representa como un Objeto, pero en JDBC cada registro no es
más que un dato que no es más que valores primitivos.

10.3.2 Arquitectura Hibernate

Hibernate: Hibernate es un marco que se utiliza para desarrollar lógica de persistencia que es
independiente del software de base de datos. En JDBC para desarrollar la lógica de persistencia, tratamos
con tipos primitivos. Mientras que el marco de Hibernate usamos objetos para desarrollar una lógica de
persistencia que es independiente del software de la base de datos.

Arquitectura Hibernate:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

125
 Opsait
Academic

10.3.2.1 Configuración
La configuración es una clase que está presente en el paquete org.hibernate.cfg. Activa el marco de
Hibernate. Lee tanto el archivo de configuración como los archivos de mapeo.

Comprueba si el archivo de configuración es sintácticamente correcto o no.

Si el archivo de configuración no es válido, arrojará una excepción. Si es válido, crea metadatos en la

memoria y devuelve los metadatos al objeto para representar el archivo de configuración.

10.3.2.2 SessionFactory
SessionFactory es una interfaz que está presente en el paquete org.hibernate y se utiliza para crear objetos
de sesión.

10.3.2.3 Session
Session es una interfaz que está presente en el paquete org.hibernate. El objeto de sesión se crea en
función del objeto SessionFactory, es decir, de fábrica.

Abre la Connection/Session con el software de base de datos a través de Hibernate Framework.

Es un objeto liviano y no es seguro para los hilos.

El objeto de sesión se utiliza para realizar operaciones CRUD.

10.3.2.4 Transaction
El objeto de transacción se usa cuando realizamos cualquier operación y, en función de esa operación, hay
algún cambio en la base de datos.

El objeto de transacción se usa para dar instrucciones a la base de datos para realizar los cambios que
ocurren debido a la operación como permanente mediante el uso del método commit ().

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

126
 Opsait
Academic

10.3.2.5 Query
Query es una interfaz que se presenta dentro del paquete org.hibernate.

Una instancia de Query se obtiene llamando a Session.createQuery ().

Esta interfaz expone algunas funciones adicionales más allá de las proporcionadas por Session.iterate () y
Session.find ():

Se puede seleccionar una página particular del conjunto de resultados llamando a setMaxResults (),
setFirstResult ().

Se pueden usar parámetros de consulta con nombre.

10.3.2.6 Criterios
Criterios es una API simplificada para recuperar entidades componiendo objetos Criterion.

La sesión es una fábrica de criterios. Las instancias de criterio generalmente se obtienen a través de los
métodos de fábrica en Restricciones.

10.3.3 Flujo de trabajo durante la operación en Hibernate Framework:

Supongamos que queremos insertar un objeto en la base de datos. Aquí Object no es más que lógica de
persistencia que escribimos en el programa java y creamos un objeto de ese programa. Si queremos
insertar ese objeto en la base de datos o si queremos recuperar el objeto de la base de datos. Ahora la
pregunta es cómo hibernate guarda el Objeto en la base de datos o recupera el objeto de la base de
datos. Hay varias capas a través de las cuales el marco de Hibernate va para lograr la tarea
anterior. Comprendamos las capas / flujo del marco de Hibernate durante la realización de operaciones:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

127
 Opsait
Academic

Etapa I: En la primera etapa, escribiremos la lógica de persistencia para realizar algunas operaciones
específicas en la base de datos con la ayuda del archivo de configuración de Hibernate y el archivo de
mapeo de Hibernate. Y después de eso creamos un objeto de la clase particular en la que escribimos la
lógica de persistencia.

Etapa II: En la segunda etapa, nuestra clase que contiene la lógica de persistencia interactuará con el
marco de Hibernate, donde el marco de Hibernate ofrece cierta abstracción. Ahora aquí ha terminado la
imagen de la clase de Java. Ahora Hibernate es responsable de realizar la lógica de persistencia con la
ayuda de capas que están debajo del marco de Hibernate o podemos decir que las capas que son la
implementación interna de Hibernate.

Etapa III: En la tercera etapa, nuestro marco de Hibernate interactúa con JDBC, JNDI, JTA, etc. para ir a la
base de datos para realizar esa lógica de persistencia.

Etapa IV y V: En la cuarta y quinta etapa, Hibernate interactua con la base de datos con la ayuda del
controlador JDBC. Ahora aquí Hibernate realiza esa lógica de persistencia que no es más que la operación
CRUD . Si nuestra lógica de persistencia es recuperar un registro, en el orden inverso se mostrará en la
consola de nuestro programa Java en términos de Objeto.

10.3.4 JPA Usando Hibernate

Java Persistence API (JPA) es una especificación de interfaz de programación de aplicaciones Java que
describe la gestión de datos relacionales en aplicaciones que utilizan Java Platform, Standard Edition y Java
Platform, Enterprise Edition. Varios marcos como Hibernate , EclipseLink y Apache OpenJPA  proporcionan
mapeo relacional de objetos de acuerdo con los estándares JPA.

Nota: Necesita Eclipse para desarrolladores Java EE y el servidor MySQL en su sistema para poder probar
los siguientes pasos.

10.3.4.1 Paso 1
Crear una base de datos " javahelps " y una tabla " student " en MySQL.

CREATE DATABASE IF NOT EXISTS javahelps;

CREATE TABLE javahelps. student(

student_id INT NOT NULL ,
student_name VARCHAR(45) NOT NULL ,
student_age INT NOT NULL ,
PRIMARY KEY (student_id) );

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

128
 Opsait
Academic

10.3.4.2 Paso 2
Crear un nuevo proyecto Java " JPAHelloWorld " en Eclipse.

10.3.4.3 Paso 3
Este paso tiene dos opciones. Puede convertir este proyecto en un proyecto Maven o continuar como un
proyecto Java ordinario.

10.3.4.3.1 Paso 3.1 Con Maven

Convierta el proyecto en proyecto Maven haciendo clic derecho en el proyecto y seleccionando Configurar
→ Convertir en proyecto Maven.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

129
 Opsait
Academic

10.3.4.3.1.1 Paso 3.2

Ingrese la identificación del grupo: “ com.javahelps ” y la identificación del artefacto: “ JPAHelloWorld ” en el
cuadro de diálogo que aparece y finalice el proceso.

10.3.4.3.1.2 Paso 3.3

Agregue las siguientes dependencias a pom.xml.

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>4.3.10.Final</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>4.3.10.Final</version>
</dependency>

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.12</version>
</dependency>

<dependency>
    <groupId>org.javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.20.0-GA</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.36</version>
</dependency>

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

130
 Opsait
Academic

Después de la modificación, pom.xml debería verse así:

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.javahelps</groupId>
    <artifactId>JPAHelloWorld</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <build>
        <sourceDirectory>src</sourceDirectory>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.3.10.Final</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.10.Final</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>

        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.20.0-GA</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.36</version>
        </dependency>
    </dependencies>
</project>

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

131
 Opsait
Academic

10.3.4.3.2 Paso 3.1 Sin Maven

Descargue y extraiga las bibliotecas de Hibernate, desde este enlace: Hibernate ORM.
Descargue y extraiga el conector MySQL JDBC, desde este enlace: Descargar Connector / J.
10.3.4.3.2.1 Paso 3.2
Cree una nueva carpeta "lib" en el proyecto.

10.3.4.3.2.2 Paso 3.3

Copie todos los archivos * .jar de la carpeta " hibernate-release-xxx / lib / required " y péguelos en la carpeta
"lib".
Además, copie el archivo mysql-connector-java-xxx-bin.jar a la carpeta " lib " de su proyecto.
10.3.4.3.2.3 Paso 3.4
Seleccione todas las bibliotecas; haga clic derecho sobre ellos y seleccione Crear ruta → Agregar a la ruta
de construcción. Después de agregar a la Ruta de compilación, las bibliotecas se deben enumerar en
Bibliotecas referenciadas como se muestra a continuación:

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

132
 Opsait
Academic

10.3.4.4 Paso 4
Cree un nuevo paquete "com.javahelps.jpa".
10.3.4.5 Paso 5
Cree una nueva clase student dentro del paquete como se muestra a continuación.

package com.javahelps.jpa;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "student")
public class Student implements Serializable {
@Id
@Column(name = "student_id", unique = true)
private int id;

@Column(name = "student_name", nullable = false)

private String name;

@Column(name = "student_age", nullable = false)

private int age;

public int getId() {

return id;
}

public void setId(int id) {

this.id = id;
}

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}

public int getAge() {

return age;
}

public void setAge(int age) {

this.age = age;
}

@Override
public String toString() {
return id + "\t" + name + "\t" + age;
}
}

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

133
 Opsait
Academic

10.3.4.6 Paso 6
Haga clic derecho en el proyecto y seleccione Nuevo → Carpeta de origen.
Indique el nombre de la carpeta como "resources" y haga clic en el botón "Finalizar" en el cuadro de diálogo
que aparece. Dentro de la carpeta de resources, cree una nueva carpeta llamada META-INF.

10.3.4.7 Paso 7
Cree un nuevo archivo persistence.xml , en la carpeta META-INF y modifique el contenido como se muestra
a continuación.

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="2.0"
xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
<persistence-unit name="JavaHelps" transaction-type="RESOURCE_LOCAL">
<!-- Persistence provider -->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<!-- Entity classes -->
<class>com.javahelps.jpa.Student</class>
<properties>
<!-- The JDBC driver of your database -->
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver" />
<!-- The JDBC URL to the database instance -->
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/javahelps" />
<!-- The database username -->
<property name="javax.persistence.jdbc.user" value="root" />
<!-- The database password -->
<property name="javax.persistence.jdbc.password" value="root" />
</properties>
</persistence-unit>
</persistence>

En este archivo de configuración, cambie el nombre de usuario y la contraseña de la base de datos de

acuerdo con su base de datos.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

134
 Opsait
Academic

10.3.4.8 Paso 8
Cree una nueva clase Java Main.java con el método principal.

10.3.4.9 Paso 9
Cree una EntityManagerFactory e inicialícela como se muestra a continuación. El nombre de la unidad de
persistencia utilizado para crear EntityManagerFactory debe coincidir con el nombre definido en el archivo
persistence.xml.

package com.javahelps.jpa;

import java.util.List;

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class Main {

// Create an EntityManagerFactory when you start the application.
private static final EntityManagerFactory ENTITY_MANAGER_FACTORY = Persistence
.createEntityManagerFactory("JavaHelps");
}

10.3.4.10 Paso 10
Agregue los métodos CRUD a la clase Main y acceda a ellos desde el método main como se muestra a
continuación:

package com.javahelps.jpa;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class Main {

// Create an EntityManagerFactory when you start the application.
private static final EntityManagerFactory ENTITY_MANAGER_FACTORY = Persistence
.createEntityManagerFactory("JavaHelps");

public static void main(String[] args) {

// Create two Students

create(1, "Alice", 22); // Alice will get an id 1
create(2, "Bob", 20); // Bob will get an id 2
create(3, "Charlie", 25); // Charlie will get an id 3

// Update the age of Bob using the id

upate(2, "Bob", 25);

// Delete the Alice from database

delete(1);

// Print all the Students

List students = readAll();
if (students != null) {
for (Student stu : students) {
System.out.println(stu);
}
}

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

135
 Opsait
Academic

// NEVER FORGET TO CLOSE THE ENTITY_MANAGER_FACTORY

ENTITY_MANAGER_FACTORY.close();
}

/**
* Create a new Student.
*
* @param name
* @param age
*/
public static void create(int id, String name, int age) {
// Create an EntityManager
EntityManager manager = ENTITY_MANAGER_FACTORY.createEntityManager();
EntityTransaction transaction = null;

try {
// Get a transaction
transaction = manager.getTransaction();
// Begin the transaction
transaction.begin();

// Create a new Student object

Student stu = new Student();
stu.setId(id);
stu.setName(name);
stu.setAge(age);

// Save the student object

manager.persist(stu);

// Commit the transaction

transaction.commit();
} catch (Exception ex) {
// If there are any exceptions, roll back the changes
if (transaction != null) {
transaction.rollback();
}
// Print the Exception
ex.printStackTrace();
} finally {
// Close the EntityManager
manager.close();
}
}

/**
* Read all the Students.
*
* @return a List of Students
*/
public static List readAll() {

List students = null;

// Create an EntityManager
EntityManager manager = ENTITY_MANAGER_FACTORY.createEntityManager();
EntityTransaction transaction = null;

try {
// Get a transaction
transaction = manager.getTransaction();
// Begin the transaction
transaction.begin();

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

136
 Opsait
Academic

// Get a List of Students

students = manager.createQuery("SELECT s FROM Student s",
Student.class).getResultList();

// Commit the transaction

transaction.commit();
} catch (Exception ex) {
// If there are any exceptions, roll back the changes
if (transaction != null) {
transaction.rollback();
}
// Print the Exception
ex.printStackTrace();
} finally {
// Close the EntityManager
manager.close();
}
return students;
}

/**
* Delete the existing Student.
*
* @param id
*/
public static void delete(int id) {
// Create an EntityManager
EntityManager manager = ENTITY_MANAGER_FACTORY.createEntityManager();
EntityTransaction transaction = null;

try {
// Get a transaction
transaction = manager.getTransaction();
// Begin the transaction
transaction.begin();

// Get the Student object

Student stu = manager.find(Student.class, id);

// Delete the student

manager.remove(stu);

// Commit the transaction

transaction.commit();
} catch (Exception ex) {
// If there are any exceptions, roll back the changes
if (transaction != null) {
transaction.rollback();
}
// Print the Exception
ex.printStackTrace();
} finally {
// Close the EntityManager
manager.close();
}
}

/**
* Update the existing Student.
*
* @param id
* @param name
* @param age
*/
public static void upate(int id, String name, int age) {

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

137
 Opsait
Academic

// Create an EntityManager
EntityManager manager = ENTITY_MANAGER_FACTORY.createEntityManager();
EntityTransaction transaction = null;

try {
// Get a transaction
transaction = manager.getTransaction();
// Begin the transaction
transaction.begin();

// Get the Student object

Student stu = manager.find(Student.class, id);

// Change the values

stu.setName(name);
stu.setAge(age);

// Update the student

manager.persist(stu);

// Commit the transaction

transaction.commit();
} catch (Exception ex) {
// If there are any exceptions, roll back the changes
if (transaction != null) {
transaction.rollback();
}
// Print the Exception
ex.printStackTrace();
} finally {
// Close the EntityManager
manager.close();
}
}
}

10.3.4.11 Paso 11
Ejecute el proyecto y verifique el resultado.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

138
 Opsait
Academic

11. Buenas prácticas y Estándares

11.1 Nombre y extensiones de los archivos

El lenguaje Java usa las siguientes extensiones para sus archivos:

 Archivo Fuente Java terminan con extensión .java

 Bytecode(código byte) de Java terminan con extensión .class

11.1.1 Volumen de los archivos

Cualquier archivo del proyecto deberá tener un volumen menor a 2000 líneas, si se llegara a sobre pasar, se
DEBE dividir en clase abstracta o interfaz y las clases especializadas necesarias.

11.1.2 Archivos fuente en JAVA

Cada archivo fuente Java contiene una única clase o interface pública. Cuando algunas clases o interfaces
privadas están asociadas a una clase pública, pueden ponerse en el mismo archivo que la clase pública,
cuando se haga uso de una inner class (clase anidada), en los demás casos se DEBE utilizar un archivo por
clase. La clase o interfaz pública debe ser la primera declarada en el archivo.

Los archivos fuentes Java tienen la siguiente ordenación:

1. Comentarios de inicio
2. package(paquete)
3. import (importar)
4. Declaraciones de clases e interfaces

A continuación, se detalla cada una de estas partes de los archivos.

11.1.2.1 Comentarios de inicio

Todos los ficheros fuente deben comenzar con un comentario en el que se lista el nombre de la clase,
información de la versión, fecha, a que se dedica el archivo, dónde está localizado, y copyright:

/*
* Nombre de la clase
*
* Versión
*
* Descripción de la versión
*
* Autor
*
* Fecha en formato dd/mm/aaaa
*/

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

139
 Opsait
Academic

11.1.2.2 Sentencias package e import

La primera línea no-comentario de los archivos fuente de Java DEBE ser la sentencia package. Después de
esta, pueden seguir varias sentencias import, Por ejemplo:

package mx.org.ift.java.awt;

import java.awt.peer.CanvasPeer;

El primer componente del nombre de un paquete único (package) se escribe siempre en minúsculas con
caracteres ASCII imprimible y debe ser uno de los nombres de dominio de último nivel, actualmente com,
edu, gov, mil, net, org, o uno de los códigos ingleses de dos letras que especifican el país como se define en
el ISO Standard 3166, 1981.

11.1.2.3 Declaraciones de clases e interfaces

La siguiente tabla describe las partes de la declaración de una clase o interface, en el orden en que
deberían aparecer:

1. Sentencia class o interface

2. Variables de clase static
3. En el siguiente orden de aparición las variables de clase public, las protected, las de nivel de
paquete (sin modificador de acceso), y las private.
4. Variables de instancia
5. En el siguiente orden de aparición las public, las protected, las de nivel de paquete (sin
modificador de acceso), y las private.
6. Constructores
7. Métodos

Estos métodos se deben agrupar por funcionalidad más que por visión o accesibilidad. Por ejemplo, un
método de clase privado puede estar entre dos métodos públicos de instancia. El objetivo es hacer el código
más legible y comprensible.

11.1.2.4 Codificación estándar básica

Esta sección comprende lo que debe considerarse al momento de la codificación de los elementos que se
requieren para garantizar un alto nivel técnico de interoperabilidad del código JAVA.

11.1.2.5 Sangría (Indentación)

Se deben emplear cuatro espacios en blanco como unidad de indentación.

11.1.2.6 Longitud de la línea

Las líneas deben de tener a lo más de 80 caracteres.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

140
 Opsait
Academic

11.1.2.7 Dividiendo líneas

Cuando una expresión no entre en una línea, esta debe ser dividida de acuerdo con estos principios:

1. Dividir después de una coma.

2. Dividir antes de un operador.
3. Se da preferencia a las divisiones de línea de alto nivel (más a la derecha que el "padre") que de
bajo nivel (más a la izquierda que el "padre").
4. Las nuevas líneas deben estar alineadas con el comienzo de la expresión al mismo nivel de la línea
anterior.
5. Si las reglas anteriores llevan a código confuso o a código que se aglutina en el margen derecho,
indentar justo 4 espacios en su lugar.
Ejemplos de cómo romper la llamada a un método:

unMetodo(expresionLarga1, expresionLarga2, expresionLarga3, expresionLarga4,

expresionLarga5);

Ahora dos ejemplos de ruptura de líneas en expresiones aritméticas. Se DEBE usar el primero, ya que el
salto de línea ocurre fuera de la expresión que encierra los paréntesis.

nombreLargo1 = nombreLargo2 * (nombreLargo3 + nombreLargo4 - nombreLargo5).+ 4 *

nombreLargo6; // PREFERIDA

nombreLargo1 = nombreLargo2 * (nombreLargo3 + nombreLargo4

- nombreLargo5) + 4 * nombreLargo6; // EVITAR

Ruptura en sentencias if deberá seguir el uso de dos bloques de cuatro espacios.

//NO USAR
if((condicion1 && condicion2)
|| (condicion3 && condicion4)
||!(condicion5 && condicion6)) { //MALOS SALTOS
hacerAlgo(); //HACEN ESTA LINEA FACIL DE OLVIDAR
}

// USAR
if((condicion1 && condicion2)
|| (condicion3 && condicion4)
||!(condicion5 && condicion6)) {
hacerAlgo();
}

//USAR
if((condicion1 && condicion2) || (condicion3 && condicion4)
||!(condicion5 && condicion6)) {
hacerAlgo();
}

Las expresiones ternarias se deben expresar con el siguiente formato o en una sola línea si no se rebasan
los 80 caracteres

alpha = (unaLargaExpresionBooleana)
? beta
: gamma;

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

141
 Opsait
Academic

11.1.2.8 Comentarios
Los programas JAVA pueden tener dos tipos de comentarios:

1. Los comentarios de implementación son para comentar nuestro código o para comentarios acerca
de una implementación particular y se encuentran, delimitados por /*...*/, y //. (Es preferible
que use un javadoc ya que es un plugin para exportar documentación sobre el funcionamiento del
código, lo comentarios normales se utilizan para especificar lineas de código importantes o si hay
una necesidad de que dejarle cierta información a los programadores)
2. Los comentarios de documentación (conocidos como "doc comments") se limitan por /**...*/, se
DEBEN exportar a ficheros HTML con la herramienta javadoc, y sirven para describir la
especificación del código, libre de una perspectiva de implementación, y para ser leídos por
desarrolladores que pueden no tener el código fuente a mano.
Se DEBEN usar los comentarios para dar descripciones de código y facilitar información adicional que no es
legible en el código mismo.

DEBEN contener sólo información que es relevante para la lectura y entendimiento del programa.

La información sobre cómo se construye el paquete correspondiente o en que directorio reside DEBE ser
incluida como comentario.

Se DEBE evitar duplicar información que está presente (de forma clara) en el código evitando así
comentarios redundantes.

SE DEBE evitar cualquier comentario que pueda quedar desfasado a medida que el código evoluciona. La
frecuencia de comentarios a veces refleja una pobre calidad del código. Cuando se sienta obligado a
escribir un comentario considere reescribir el código para hacerlo más claro.

Los comentarios NO DEBEN encerrarse en grandes cuadrados dibujados con asteriscos u otros caracteres.

11.1.2.9 Formatos de los comentarios de implementación

Los programas PUEDEN tener alguno de los siguientes tres estilos de comentarios de implementación:

11.1.2.10 Comentarios de bloque

1. Se usan para dar descripciones de ficheros, métodos, estructuras de datos y algoritmos.
2. Se podrán usar al comienzo de cada archivo o antes de cada método. También se pueden usar en
otros lugares, tales como el interior de los métodos.
3. Deben ser indentados al mismo nivel que el código que describen. Un comentario de bloque debe ir
precedido por una línea en blanco que lo separe del resto del código.
/*
* Aquí hay un comentario de bloque.
*/
Los comentarios de bloque también PUEDEN comenzar con /*-, que es reconocido como el comienzo de un
comentario de bloque que no debe ser re formateado.

/*-
* Aquí tenemos un comentario de bloque con cierto formato que no
* debe ser modificado.
*
* uno
* dos
* tres
*/

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

142
 Opsait
Academic

11.1.2.11 Comentarios de una línea

1. Son comentarios cortos de una única línea al nivel del código.
2. Si un comentario no se puede escribir en una línea, debe seguir el formato de los comentarios de
bloque.
3. Debe ir precedido de una línea en blanco.
4. El delimitador de comentario es “//” puede convertir en comentario una línea completa o una parte
de una línea.
5. NO DEBE ser usado para hacer comentarios de varias líneas consecutivas

Aquí un ejemplo de comentario de una sola línea en código Java:

if(condicion){

//Código de la condición.
...
}

if(foo > 1){

// Hacer algo.
...

}else{

return false; // Explicar aquí por qué se hace.

}

11.1.2.12 Sentencias simples

Se DEBE hacer una declaración por línea, ya que facilita los comentarios, ejemplo:

int nivel; // nivel de indentación (esto es un comentario)

int tam; // tamaño de la tabla (esto es un comentario)

NO DEBE declarar múltiples variables en la misma línea, aunque sean del mismo tipo, ejemplo:

int level, size;

NO DEBE poner diferentes tipos en la misma línea, por ejemplo:

int foo, fooarray[]; //ERROR!

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

143
 Opsait
Academic

11.1.2.13 Comentarios de documentación y uso de javadoc

Se DEBE documentar cada proyecto Java dentro de la DGTIC del instituto lo cual nos traerá las siguientes
ventajas:

1. Facilita el mantenimiento del proyecto, ya que al generar documentación lo suficientemente

detallada otros programadores serán capaces de usarla para consultar clases específicas o todo el
proyecto.
2. No debe existir necesidad de leer o estudiar su implementación, lo mismo que nosotros para usar
una clase del API Java no leemos ni estudiamos su código fuente.
3. Javadoc es una utilidad de Oracle para la generación de documentación de APIs en formato HTML
a partir de código fuente Java y es el estándar para documentar clases de Java.
Reglas para la generación automática de documentación:

1. La documentación para javadoc DEBE de incluirse entre símbolos de comentario que han de
empezar con una barra y doble asterisco, y terminar con un asterisco y barra simple.
/**
* Esto es un comentario para javadoc
*/
2. La ubicación define el tipo de comentario:
a. Si está antes de la declaración de clase se considerará tipo clase.
b. Si está justo antes de un constructor o método tipo constructor o método.
3. Las palabras reservadas (tags) precedidas por el carácter "@", dentro de los símbolos de
comentario, alimentan a la herramienta para detectar los hitos para la documentación de la clase.
11.1.3 Tags a utilizar
Se DEBEN incluir al menos los siguientes tags:

1. @author
2. @since. Indica el número de versión desde la que existe el método.
3. @throws. Descripción de la excepción que puede propagar. Habrá una etiqueta throws por cada tipo
de excepción.
4. @see. Referencia a otra clase, ya sea del API, del mismo proyecto o de otro. Por ejemplo:
@see cadena @see paquete.clase#miembro @see enlace
5. @deprecated. Indica que el método o clase es obsoleto (propio de versiones anteriores) y que no se
recomienda su uso.
6. @param. Definición de un parámetro de un método, es requerido para todos los parámetros del
método.
7. @return. Informa de lo que devuelve el método, no se aplica en constructores o métodos "void".
8. @version. Versión del método o clase.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

144
 Opsait
Academic

11.1.3.1 Ejemplo de uso de los tags

/**
* Esta clase define objetos que contienen tantos enteros aleatorios entre 0 y
* 1000 como * se le definen al crear un objeto
*
* @author: Emmanuel Oropeza
* @version: 1.0
* @see <a href = "http://www.oracle.com" /> Sitio oficial de Oracle </a>
*/

package mx.org.ift.ejemplos;

import java.util.ArrayList;
import java.util.Random;

public class SerieDeAleatoriosD {

// Campos de la clase
private ArrayList<Integer> serieAleatoria;

/**
* Constructor para la serie de números aleatorios
*
* @param numeroItems
* El parámetro numeroItems define el número de elementos que va
* a tener la serie aleatoria
*/
public SerieDeAleatoriosD(int numeroItems){

serieAleatoria = new ArrayList<Integer>();

for(int i = 0; i < numeroItems; i++){

serieAleatoria.add(0);
}
System.out.println("Serie inicializada. El número de elementos en la serie .
es: " + getNumeroItems());
} // Cierre del constructor

/**
* Método que devuelve el número de ítems (números aleatorios) existentes en
* la serie
*
* @return El número de ítems (números aleatorios) de que consta la serie
*/
public int getNumeroItems(){
return serieAleatoria.size();
}

/**
* Método que genera la serie de números aleatorios
*/
public void generarSerieDeAleatorios(){

Random numAleatorio;
numAleatorio = new Random();

for(int i = 0; i < serieAleatoria.size(); i++){

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

145
 Opsait
Academic

serieAleatoria.set(i, numAleatorio.nextInt(1000));
}

System.out.print("Serie generada! ");

} // Cierre del método

} // Cierre de la clase y del ejemplo

11.2 Inicialización

Se DEBE inicializar las variables locales donde se declaran. La única razón para no inicializar una variable
donde se declara es si el valor inicial depende de algunos cálculos.

11.2.1 Declaraciones de class e interfaces

Al codificar clases e interfaces de Java, se DEBEN seguir las siguientes reglas de formato:

Ningún espacio en blanco entre el nombre de un método y el paréntesis "(" que abre su lista de parámetros.

La llave de apertura "{" aparece al final de la misma línea de la sentencia declaración.

La llave de cierre "}" empieza una nueva línea indentada para ajustarse a su sentencia de apertura
correspondiente, excepto cuando no existen sentencias entre ambas, que debe aparecer inmediatamente
después de la de apertura "{".

class Ejemplo extends Object{

int ivar1;
int ivar2;

Ejemplo(int i, int j){

ivar1 = i;
ivar2 = j;
}

int metodoVacio(){

...
}
}

Los métodos se separan con una línea en blanco.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

146
 Opsait
Academic

11.2.2Sentencias compuestas
Las sentencias compuestas como su nombre lo indica están formadas de otras sentencias encerradas entre
llaves de la siguiente forma “{sentencias}".

Al tener una sentencia compuesta DEBEN seguirse las siguientes reglas:

 Las sentencias encerradas deben indentarse un nivel más que la sentencia compuesta.
 La llave de apertura se debe poner al final de la línea que comienza la sentencia compuesta.
 La llave de cierre debe empezar una nueva línea y ser indentada al mismo nivel que el principio de
la sentencia compuesta.

Las llaves se usan en todas las sentencias, incluso las simples, cuando forman parte de una estructura de
control, como en las sentencias if-else o for. Esto hace más sencillo añadir sentencias sin incluir bugs
accidentalmente por olvidar las llaves, como se muestra en el ejemplo:

if(condicion){
sentencias;

if(condición){
sentencias;
}

}else{
sentencias;
}

11.2.3Sentencias de retorno
Una sentencia return con un valor NO DEBE usar paréntesis a menos que hagan el valor de retorno más
obvio de alguna manera. Ejemplo:

return;
return miDiscoDuro.size();
return (tamanio ? tamanio : tamanioPorDefecto);

11.2.4Sentencias if
La clase de sentencias if-else debe tener la siguiente forma:

if(condición){
sentencias;
}

if(condicion){
sentencias;
}else{
sentencias;
}

if(condicion){
sentencia;
}else if(condicion){
sentencia;
}else{
sentencia;
}

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

147
 Opsait
Academic

Las sentencias if DEBEN declararse siempre con el uso de llaves {}. Evitar la siguiente forma, propensa a
errores:

//Aquí no se hace uso de las llaves,

//esto tiende a generar errores
if(condicion)
sentencia;

11.2.5 Sentencias for

Una sentencia for DEBE tener la siguiente forma:

for(inicializacion; condicion; actualizacion){

sentencias;
}

Una sentencia for vacía debe tener la siguiente forma:

for(inicializacion; condicion; actualizacion);

Al usar el operador coma en la cláusula de inicialización o actualización de una sentencia for, evitar la
complejidad de usar más de tres variables. Si se necesita, usar sentencias separadas antes de bucle for
(para la cláusula de inicialización) o al final del bucle (para la cláusula de actualización).

11.2.6Sentencias while
Una sentencia while debe tener la siguiente forma:

while(condicion){
sentencias;
}

Una sentencia while vacía debe tener la siguiente forma:

while (condicion);

11.2.7 Sentencias do-while

Una sentencia do-while debe tener la siguiente forma:

do{
sentencias;
}while(condicion);

11.2.8Sentencias switch
Cada vez que un caso se propaga (no incluye la sentencia break), añadir un comentario donde la sentencia
break se encontraría normalmente.

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

148
 Opsait
Academic

Esto se muestra en el ejemplo anterior con el comentario /* este caso se propaga */.

switch(condicion){
case ABC:
sentencias;
/* este caso se propaga */
case DEF:
sentencias;
break;
case XYZ:
sentencias;
break;
default:
sentencias;
break;
}

Cada sentencia switch debe incluir un caso por defecto. El break en el caso por defecto es redundante,
pero prevé que se propague por error si luego se añade otro caso.

11.2.9Sentencias try-catch
Una sentencia try-catch DEBE tener la siguiente forma:

try{
sentencias;
}catch(ExceptionClass e){
sentencias;
}

Una sentencia try-catch puede ir seguida de un finally, cuya ejecución se hará independientemente de
que el bloque try se haya completado con éxito o no.

try{
sentencias;
}catch(ExceptionClass e){
sentencias;
}finally{
sentencias;
}

11.3 Convenciones de nombres

Las convenciones de nombres hacen los programas más entendibles haciéndolos más fácil de leer.
También pueden dar información sobre la función de un identificador, por ejemplo, cuando es una
constante, un paquete, o una clase, que puede ser útil para entender el código.

1. Paquetes
 Deben ser escritos todo en minúscula
 Van después de la palabra reservada package
 Si se van a usar paquetes dentro de otros paquetes, se unen mediante un punto (.)
 Finalizan con ;
 El prefijo del nombre de un paquete se escribe siempre con letras ASCII en minúsculas:
mx.org.ift

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

149
 Opsait
Academic

2. Clases
 La primera letra debe ser mayúscula
 Utiliza nomenclatura CamelCase
 Para las clases, los nombres deben de ser sustantivos (Sujeto) y van después de la palabra
reservada class
 Intentar mantener los nombres de las clases simples y descriptivas. Usar palabras completas,
evitar acrónimos y abreviaturas (a no ser que la abreviatura sea mucho más conocida que el
nombre completo, como URL or HTML): class Cliente;

3. Interfaces
 Los nombres de las interfaces siguen la misma regla que las clases más las siguientes.
 Para las interfaces, los nombres deben de ser adjetivos (Califica el sustantivo) y van después
de la palabra reservada interface: Interface ObjetoPersistente;

4. Métodos
 La primera letra debe ser minúscula
 Utiliza nomenclatura CamelCase
 Los nombres deben conformarse por el par verbo + sustantivo
 El nombre va después del tipo de método (void, int, double, String)
 Al finalizar el nombre del método debe indicarse mediante paréntesis con o sin argumentos ():
ejecutarRapido();

5. Variables
 La primera letra debe ser minúscula
 Utiliza nomenclatura camelCase
 El nombre va después del tipo de dato (int, String, double, boolean)
 Es recomendable utilizar nombres con un significado explícito, y en lo posible, cortos
 Los nombres de variables NO DEBEN empezar con los caracteres subguión "_" o signo del
dolar "$", aunque ambos están permitidos por el lenguaje.
 Los nombres de las variables deben ser cortos, pero con significado. La elección del nombre de
una variable debe ser un mnemónico, designado para indicar a un observador casual su
función. Los nombres de variables de un solo carácter se deben evitar, excepto para variables
índices temporales. Nombres comunes para variables temporales son i, j, k, m, y n para
enteros; c, d, y he para caracteres: String direccionResidencia = calle 20;

6. Constantes
 Todas las letras de cada palabra deben estar en mayúsculas
 Separa cada palabra con un _
 Se declaran similar a las variables, con la diferencia de que el tipo de dato va después de la
palabra reservada final: final double PI

El siguiente ejemplo muestra un archivo de JAVA con la utilización de los elementos antes mencionados:

/*
* @ (#)NombreDeClase.java 09/02/2017
*
* Copyright (c) 2017 Instituto Federal de Telecomunicaciones (IFT).
* Insurgentes sur #838, Colonia Del Valle, Delegación Benito Juárez,
* C.P. 03100, CDMX, MÉXICO
* Derechos reservados.
*
* la información contenida en el presente documento, y por ende prohíbe
* expresamente la reproducción total o parcial de la misma.
*
*/

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

150
 Opsait
Academic

package mx.org.ift.java.bla;

import java.bla.blabla.BlaBla;

/**
* La descripción de la clase viene aqui.
*
* @versiondatos de la versión (número y fecha)
* @author Nombre Apellido
*/

public class Bla extends OtraClase {

/*
* Un comentario de implemantación de la clase viene aquí.
*/

/** El comentario de documentación de claseVar1 */

public static int claseVar1;

/** Comentario de documentación de instanciaVar1 */

public Object instanciaVar1;

/**
* Comentario de documentación del constructor Bla
*/
public Bla() {
// aquí viene la implementación
}

/**
* Comentario de documentación del método hacerAlgo
*/
public void hacerAlgo() {
// aquí viene la implementación
}

/**
* Comentario de documentación de hacerOtraCosa
*
* @param unParametro
* descripción
*/
public void hacerOtraCosa(Object unParametro) {
// aquí viene la implementación
}
}

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

151
 Opsait
Academic

12. Bibliografía
 https://www.ibm.com/developerworks/ssa/java/tutorials/j-introtojava1/index.html
 https://www.java.com/es/download/faq/whatis_java.xml
 https://www.java.com/es/about/whatis_java.jsp?bucket_value=desktop-chrome77-
osx10150&in_query=no
 https://docs.oracle.com/javase/7/docs/api/
 https://www.oracle.com/technetwork/es/java/javase/tech/index.html
 https://www.ibm.com/support/knowledgecenter/es/ssw_ibm_i_71/rzaha/clpckdir.htm
 https://docs.oracle.com/javase/tutorial/java/concepts/index.html
 https://www.w3schools.in/java-tutorial/program-structure/
 https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
 https://docs.oracle.com/javase/tutorial/java/nutsandbolts/branch.html
 https://www.ibm.com/support/knowledgecenter/es/SSZLC2_8.0.0/com.ibm.commerce.developer.doc
/concepts/csdmvcdespat.htm
 https://dzone.com/articles/singleton
 https://www.baeldung.com/inversion-control-and-dependency-injection-in-spring
 https://www.arquitecturajava.com/para-que-sirven-los-spring-modules/
 https://www.baeldung.com/spring-autowire
 https://www.baeldung.com/spring-bean-scopes
 https://www.arquitecturajava.com/spring-configuration/
 http://www.jtech.ua.es/j2ee/publico/jsf-2012-13/sesion01-apuntes.html
 https://developer.mozilla.org/es/docs/HTML/HTML5
 https://www.arquitecturajava.com/que-es-spring-boot/
 https://devcode.la/blog/que-es-sql/
 https://study.com/academy/lesson/what-are-sql-functions-use-examples.html
 https://docs.oracle.com/cd/F49540_01/DOC/java.815/a64686/01_intr3.htm
 https://sg.com.mx/revista/29/trabajando-stored-procedures-sql-server
 https://support.microsoft.com/es-mx/help/283878/description-of-the-database-normalization-basics
 https://www.w3schools.com/sql/sql_view.asp
 https://www.mkyong.com/hibernate/why-i-choose-hibernate-for-my-project/
 https://openwebinars.net/blog/que-es-sql/
 https://www.oracletutorial.com/getting-started/what-is-oracle-database/
 https://www.oracletutorial.com/oracle-basics/
 https://www.oracletutorial.com/oracle-view/
 https://www.oracletutorial.com/plsql-tutorial/
 https://openwebinars.net/blog/que-es-mysql/
 https://dev.mysql.com/doc/mysql-getting-started/en/#mysql-getting-started-basic-ops
 https://dev.mysql.com/doc/connector-net/en/connector-net-tutorials-parameters.html
 https://dev.mysql.com/doc/connector-net/en/connector-net-tutorials-stored-procedures.html
 https://www.geeksforgeeks.org/introduction-to-hibernate-framework/
 https://www.geeksforgeeks.org/hibernate-architecture/
 https://www.javahelps.com/2015/08/jpa-hello-world-using-hibernate.html
 https://www.adictosaltrabajo.com/2010/06/30/introduccion-primefaces/

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

152
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

153
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

154
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

155
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

156
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

157
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

158
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

159
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

160
 Opsait
Academic

Manual teórico. Java Object Oriented Programming – Versión 1.0

An Indracompany

161
An Indracompany