2. Autor: PCYTA / Centro de Excelencia de Software Libre de Castilla-La Mancha
Versión: 1.0
Fecha: Revisado 13-02-2008 23:56
Licencia: CC-by-sa 2.5
0 Licencia
Usted es libre de:
Copiar, distribuir y comunicar públicamente la obra
Hacer obras derivadas
Bajo las condiciones siguientes:
Reconocimiento. Debe reconocer los créditos de la obra de la manera especificada por el
autor o el licenciador (pero no de una manera que sugiera que tiene su apoyo o apoyan el uso
que hace de su obra).
Compartir bajo la misma licencia. Si altera o transforma esta obra, o genera una obra
derivada, sólo puede distribuir la obra generada bajo una licencia idéntica a ésta.
• Al reutilizar o distribuir la obra, tiene que dejar bien claro los términos de la licencia
de esta obra.
• Alguna de estas condiciones puede no aplicarse si se obtiene el permiso del titular de
los derechos de autor
• Nada en esta licencia menoscaba o restringe los derechos morales del autor.
Para ver la licencia visite:
http://creativecommons.org/licenses/by-sa/2.5/es/legalcode.es
6 de febrero de 2008 Tema 3 2
3. UNIDAD II. Introducción a J2EE
0 Licencia............................................................................................................................................ 2
1 Estado actual del desarrollo de aplicaciones.................................................................................... 5
1.1 Modelo 3 Capas ........................................................................................................................5
1.2 Pros y Contras del Modelo 3 Capas ......................................................................................... 6
1.3 Otros aspectos importantes del Modelo 3 Capas ..................................................................... 7
1.4 Características del Contenedor .................................................................................................7
2 ¿Qué es J2EE?.................................................................................................................................. 9
2.1 ¿Qué es J2EE?...........................................................................................................................9
2.2 Trasladémoslo a nuestro ejemplo .............................................................................................9
2.3 API de J2EE y tecnologías empleadas ...................................................................................10
3 Arquitectura J2EE...........................................................................................................................12
3.1 Arquitectura J2EE .................................................................................................................. 12
3.2 Reflexiones sobre la Arquitectura ......................................................................................... 13
4 Servidores de aplicaciones J2EE.................................................................................................... 15
4.1 Servidores de aplicaciones J2EE ...........................................................................................15
4.2 Instalación, Estrutura y Configuración de JBOSS.................................................................. 16
5 Herramientas de desarrollo............................................................................................................. 18
5.1 Herramientas de desarrollo (Eclipse) .................................................................................... 18
5.2 Instalación de Eclipse .............................................................................................................18
5.3 Introducción a Eclipse ........................................................................................................... 20
6 de febrero de 2008 Tema 3 3
4. INTRODUCCIÓN
Hasta el momento hemos repasado los conocimientos previos necesarios para poder entender la
plataforma J2EE. En este tema vamos a ver los conceptos fundamentales que explican la razón por
la que J2EE es tan ampliamente utilizado para el desarrollo de aplicaciones.
En primer lugar se va a explicar cómo se estructuran actualmente las aplicaciones, prestando
especial atención a las aplicaciones Web. Posteriormente, explicaremos a grandes rasgos (en los
temas siguientes entraremos en detalle) cómo es la plataforma J2EE y qué beneficios
proporciona a la hora de crear las aplicaciones. Después comentaremos algunos de los servidores
más utilizados para hacer funcionar aplicaciones J2EE y finalizaremos el tema presentado algunos
de los IDEs más empleados para el desarrollo con esta plataforma.
Para seguir este tema desde un punto de vista más práctico, iremos relacionando los conceptos con
una aplicación "imaginaria" y muy simple.
Imaginémonos y tengamos en mente durante el resto del tema esta aplicación consistente en una
tienda virtual, la cual tiene como misiones presentar un catálogo de productos, un registro simple
de usuarios, la selección de productos, la compra, la inserción del pedido en una base de datos, el
envío de mails a los compradores (usuarios registrados) confirmando el pedido, etc.
6 de febrero de 2008 Tema 3 4
5. 1 Estado actual del desarrollo de aplicaciones
1.1 Modelo 3 Capas
Actualmente, los desarrolladores, a la hora de crear una aplicación de cierta envergadura (como
nuestra tienda virtual), recurren a arquitecturas de varias capas.
Uno de los modelos (patrones) más utilizados es el modelo de 3 capas. Según este modelo, las tres
capas son las siguientes:
- Capa de presentación: capa en la que se programan todos los aspectos referentes a la
presentación de los datos de la aplicación. En nuestra tienda virtual se referiría a las páginas Web
con el formato, estilos, etc. necesarios para mostrar los productos, para que los usuarios
introduzcan sus datos, para formalizar el pago, etc.
- Capa de lógica de negocio: en esta capa se introducirían los aspectos referentes a la definición
de los procesos de negocio de la aplicación. En nuestro ejemplo, se programaría la lógica
necesaria para obtener los artículos que cumplan con los criterios de búsqueda, se haría lo
necesario para validar y crear los usuarios, se situaría el código para gestionar los pagos, para
mandar el correo al comprador, para insertar los datos de los pedidos, artículos y usuarios en base
de datos, etc.
- Capa de datos: en ésta se incluiría la definición de los datos en la base de datos
(principalmente las tablas que contendrían los datos). Esto, en nuestra tienda virtual, se
traduciría en la definición de las tablas necesarias para guardar los datos referentes a usuarios,
artículos, pedidos, etc.
A continuación vemos un diagrama que muestra estas capas en las que se divide una aplicación
de forma gráfica:
6 de febrero de 2008 Tema 3 5
6. En la imagen se pueden ver las tres capas en que se divide una aplicación, la de presentación
normalmente en los clientes (aunque también hay parte alojada en el servidor), la capa de negocio
en lo que se corresponde con el Web Server, y la de datos en la base de datos. También vemos en
este dibujo que las capas se comunican mediante HTTP entre cliente y servidor, y mediante SQL
entre servidor y base de datos. Pero tengamos en cuenta que esto no es siempre así, ya que,
aunque es bastante habitual, no siempre la presentación es HTML y no siempre la capa de
datos es una base de datos relacional.
NOTA: Es importante tener en cuenta que aunque este modelo es muy
habitual y sencillo, cuando la complejidad de las aplicaciones crece,
también lo hace la complejidad del desarrollo y frecuentemente implica
que hay que desglosar en más capas el desarrollo.
1.2 Pros y Contras del Modelo 3 Capas
La forma de estructurar una aplicación en 3 capas tiene una serie de ventajas como, entre otras, las
siguientes:
- Independencia de la presentación de datos respecto a la lógica de negocio: consiguiendo poder
definir diferentes interfaces para los distintos dispositivos (navegadores, pdas, etc) y reutilizando
siempre el resto del código.
-Clientes ligeros, teniendo todo el procesamiento centralizado en servidor y base de datos y
consiguiendo que el cliente del usuario solo tenga que mostrar, recoger y enviar los datos.
En el aspecto negativo se encuentra principalmente que toda la complejidad se traslada a la capa
6 de febrero de 2008 Tema 3 6
7. intermedia (la de lógica de negocio).
1.3 Otros aspectos importantes del Modelo 3 Capas
Como decíamos en el punto anterior, emplear esta estructura al desarrollar una aplicación, haciendo
que prácticamente todo el procesamiento se realice en el servidor aumenta mucho la complejidad
de este procesamiento. Esta complejidad se debe, además del procesamiento necesario por la lógica
de negocio, a que nos hace tener en cuenta los siguientes asuntos:
- Escalabilidad, para el caso de que un único servidor no sea capaz de atender todas las peticiones.
- Concurrencia, ya que puede haber varios usuarios usando simultáneamente la aplicación.
- Disponibilidad, necesitando que el servidor esté las 24 horas funcionando.
- Transaccionalidad, ya que las operaciones se deben realizar de forma atómica.
- Seguridad, debido, entre otras cosas, a la existencia de usuarios.
- Otras, que no detallamos aquí por salir de los objetivos del curso.
Evidentemente, estos aspectos tan comunes en todas las aplicaciones también han sido pensados y
solucionados mediante desarrollos estándar (no reinventemos la rueda, reutilicemos siempre que
podamos). Una de las formas más habituales de solventar este problema es introducir nuestro
desarrollo en un "contenedor"y delegar en él todos los aspectos antes mencionados (para
nosotros, en este curso, nos resulta transparente el funcionamiento de este contenedor aunque
siempre debemos tener presente que existe).
En el siguiente apartado veremos de forma resumida las características de los contenedores en los
cuales desplegaremos nuestros desarrollos (componentes).
1.4 Características del Contenedor
Como hemos comentado anteriormente, un contenedor nos proporciona soluciones a muchos de
los problemas que actualmente se presentan a la hora de realizar un desarrollo.
Las principales características que nos proporcionan los contenedores son las siguientes:
- Gestión del ciclo de vida de los componentes: El contenedor se encarga de gestionar la creación,
6 de febrero de 2008 Tema 3 7
8. utilización y eliminación de los componentes que desplegamos en él. Por ejemplo, nosotros
creamos una clase (componente) que atiende a las peticiones de nuestra aplicación y delegamos en
el contenedor que decida cuando cargarla, cuantas copias cargar, cuando liberar la memoria que
utilizan, etc.
- Gestión de la sesión: El contenedor será el que nos gestione todos los asuntos necesarios
cuando un proceso requiere uso de sesión. Por ejemplo, en nuestra aplicación deberemos guardar
datos introducidos por el usuario durante todo el proceso de compra (los típicos datos de la compra
a realizar) en la sesión. Esta sesión se la pediremos al contenedor sin tener que preocuparnos de su
creación, mantenimiento y eliminación.
- Soporte de Clustering - Balanceo de Carga: El contenedor se encarga de la comunicación y
gestión de nuestros componentes si el servidor tiene un funcionamiento en cluster. Esto nos
será muy útil cuando un único servidor no sea capaz de atender las peticiones y montemos un
cluster. En ese caso, el contenedor se encargará de gestionar todo lo necesario para que nosotros no
tengamos que pensar en que arquitectura se va a desplegar nuestra aplicación.
- Alta disponibilidad: El contenedor se encargará, en una arquitectura de alta disponibilidad, de
hacer que nuestros componentes estén desplegados en algún servidor disponible. También se
encargará de que las peticiones a ellos siempre sean atendidas por algún servidor que no esté caído.
- Seguridad: El contenedor se encargará de gestionar los asuntos de autenticación y autorización
de usuarios en nuestra aplicación. De esta forma, simplifica en gran medida nuestra labor de
desarrollo a la hora de implementar la gestión de usuarios en nuestra aplicación.
Como podemos ver comparando con el apartado anterior, los contenedores nos proporcionan la
solución a esos aspectos que necesitábamos tener en cuenta a la hora de desarrollar nuestra
aplicación, y estos contenedores nos los ofrece la arquitectura J2EE.
6 de febrero de 2008 Tema 3 8
9. 2 ¿Qué es J2EE?
2.1 ¿Qué es J2EE?
En el apartado anterior hemos visto "cómo" se organizan hoy en día las aplicaciones a la hora de
realizar el desarrollo, pero no hemos visto "con qué" se implementa esta organización en capas.
Una de las plataformas más empleadas (probablemente la más) para implementar estas
aplicaciones divididas en capas es J2EE.
J2EE es una plataforma basada en estándares creada para el desarrollo, despliegue y gestión de
aplicaciones multicapa.
La plataforma está basada en la idea componente-contenedor. Los componentes son las
aplicaciones, servicios, etc. Estos componentes se despliegan en contenedores. Estos
contenedores se ocuparán de los aspectos que mencionábamos en el apartado anterior
(escalabilidad, transaccionalidad, concurrencia, seguridad, etc.).
J2EE también proporciona la portabilidad de código, pudiendo desplegar nuestra aplicación en
cualquier servidor, sobre cualquier plataforma, siempre y cuando ambos servidores implemente la
misma versión de J2EE.
J2EE es una especificación de estándares a emplear para esa versión de
la plataforma y cada organización (SUN, IBM, etc.) implementa la
funcionalidad respetando esa especificación.
Otra ventaja más es que existen innumerables recursos para desarrollos sobre J2EE desde
cursos, libros, artículos, etc. hasta librerías muy completas que nos reducen en gran medida el
trabajo y aumentan la calidad de nuestras aplicaciones.
2.2 Trasladémoslo a nuestro ejemplo
Volviendo a nuestro ejemplo imaginario, lo que se nos plantearía es lo siguiente:
6 de febrero de 2008 Tema 3 9
10. Nosotros queremos desarrollar nuestra aplicación (nuestra tienda virtual). Vemos que la mejor
arquitectura es una de 3 capas y tenemos presente, además de la estructuración en capas, que hay
que prestar atención a asuntos como la seguridad, la escalabilidad, etc. Con todos estos requisitos,
decidimos buscar una plataforma que nos facilite nuestro desarrollo y encontramos para ello
J2EE.
En el siguiente apartado vamos a explicar brevemente cada una de las características que nos ofrece
J2EE e iremos mencionando como nos podría ayudar en nuestra aplicación.
2.3 API de J2EE y tecnologías empleadas
Como decíamos en el apartado anterior, J2EE nos ofrece, además de lo mencionado antes, una
serie de componentes y servicios que podremos utilizar en nuestras aplicaciones y que nos
resolverán gran parte de los problemas genéricos que se plantean a la hora de desarrollarlas. A
continuación mencionamos algunos de los más importantes con un ejemplo de utilización:
- Servlet. Son objetos JAVA que extienden la funcionalidad de un servidor WEB. Mediante los
Servlets trataremos las peticiones HTTP realizadas desde los navegadores. En el tema siguiente
veremos a fondo los Servlets. Los utilizaríamos en nuestra tienda virtual para hacer las llamadas a
las clases de lógica de negocio.
- JSP. Es una tecnología que nos permite introducir código java dentro del código HTML.
Mediante las JSPs independizaremos la capa de presentación del resto. Al igual que los
Servlets, las estudiaremos a fondo en el siguiente tema. Las JSPs las utilizaríamos en nuestra tienda
virtual para generar el código HTML introduciendo los valores de nuestros objetos de lógica de
negocio.
- EJB. Es una tecnología para desarrollar componentes en la parte servidora. Son muy útiles
debido a que nos pueden proporcionan transaccionalidad, portabilidad, seguridad, etc. a nuestros
desarrollos.
- JMS. Tecnología que nos ofrece, mediante su API, servicios de mensajería típicos (Punto a
punto y publicador-subscriptor) para comunicar aplicaciones, componentes, etc. Mediante JMS
conseguimos comunicaciones asíncronas.
- JNDI. Servicio de nombrado de recursos y objetos. Mediante JNDI podremos localizar
recursos y objetos desplegados en el servidor local, y también en remotos.
6 de febrero de 2008 Tema 3 10
11. - JDBC. Nos proporciona una API estándar para la comunicación con base de datos relacionales.
Cada gestor de base de datos (ORACLE, MYSQL, DB2, etc.) ofrece siempre sus drivers a modo de
librería que cumple con el API de JDBC. En nuestra aplicación sería la que utilizaríamos para
comunicarnos con la base de datos.
- J2SE. Tecnología sobre la que se apoya toda la plataforma. Es la edición estándar de JAVA que
veíamos en el primer tema y es sobre la que se ejecuta la plataforma. Tengamos en cuenta que una
plataforma J2EE no deja de ser un conjunto de clases JAVA.
- JavaMail. Esta API proporciona el interfaz necesario para la gestión del correo electrónico.
Sería la que utilizaríamos, por ejemplo, para mandar emails en nuestra tienda virtual.
Estas son las tecnologías y APIs más significativas, aunque hay que
destacar que existen muchas más tecnologías sobre las que se basa
J2EE de las que no haremos mención por escaparse de los objetivos del
curso.
En el siguiente apartado introduciremos la arquitectura que sigue la especificación J2EE, que es la
arquitectura que siguen todos los servidores de aplicaciones J2EE.
6 de febrero de 2008 Tema 3 11
12. 3 Arquitectura J2EE
3.1 Arquitectura J2EE
Hasta el momento ya hemos mencionado de palabra la arquitectura con sus principales fundamentos
y con las principales tecnologías que se utilizan. En este apartado vamos a entrar un poco más en
detalle de forma gráfica y explicando brevemente las imágenes.
En esta primera imagen (abajo), vemos sobre fondo verde todo lo referente a J2SE, la base sobre la
que se ejecuta la plataforma. Sobre fondo amarillo se ve el contenedor sobre el que se
despliegan los EJBs, JSPs y Servlets y en morado y azul se muestran servicios, APIs y
tecnologías sobre las que se apoya la plataforma.
En esta segunda imagen (abajo), vemos la misma idea desde el punto de vista de una
arquitectura basada en capas. Podemos ver que la capa cliente se comunica con la de lógica de
negocio a través de los Servlets y JSPs, aunque existe la posibilidad de conexión directa a EJBs. Y
la forma de acceder a la capa de datos es mediante EJBs, cosa que no es obligatoria pero si
puede llegar a ser una "buena costumbre". También se presenta que sobre el servidor de
aplicaciones J2EE se despliegan JSPs, Servlets, EJBs y el resto de servicios. Evidentemente las
capas de datos y la capa cliente son independientes del servidor de aplicaciones.
6 de febrero de 2008 Tema 3 12
13. No confundir la capa cliente con la capa de presentación. La capa
intermedia del dibujo se desdobla en capa de presentación (las JSPs) y
capa de lógica de negocio (Servlets y EJBs).
3.2 Reflexiones sobre la Arquitectura
Para finalizar el esbozo de la arquitectura, sería interesante volver a recordar que esta arquitectura
(J2EE) está basada en el modelo componente-contenedor, donde los componentes son JSPs,
Servlets y EJBs, y el contenedor podríamos decir para entenderlo mejor que es el servidor donde
se despliegan los componentes. También recordemos que los componentes se encargan de la
presentación y la lógica de negocio, mientras que los contenedores proporcionan concurrencia,
seguridad, disponibilidad, escalabilidad, persistencia, transaccionalidad, manejo del ciclo de
vida de los componentes, etc.
6 de febrero de 2008 Tema 3 13
14. Aplicando todo lo estudiado hasta ahora a nuestro ejemplo, la situación sería la siguiente:
- Crearíamos la base de datos sobre la que trabajaría nuestra aplicación.
- Crearíamos JSPs donde se desarrollaría la capa de presentación de nuestra tienda virtual.
- Crearíamos los Servlets que se encargarían de atender las peticiones realizadas desde los
navegadores cliente. En este lugar implementaríamos la lógica de negocio.
- Podríamos crear EJBs para aprovechar sus ventajas (más adelante las veremos) para ciertos
aspectos de la lógica de negocio.
- Para la lógica de negocio, tanto si es con Servlets como con EJBs, podríamos usar los recursos
que hemos visto que J2EE nos ofrece.
- Empaquetaríamos los JSPs, Servlets y EJBs y los desplegaríamos en el servidor de
aplicaciones (contenedor).
Siguiendo estos pasos que acabamos de comentar ya tendríamos nuestra aplicación preparada
para usarla (en el resto del curso veremos como realizar estas labores).
6 de febrero de 2008 Tema 3 14
15. 4 Servidores de aplicaciones J2EE
4.1 Servidores de aplicaciones J2EE
Hasta el momento hemos visto de forma general la arquitectura J2EE. Cuando nosotros decidimos
crear una aplicación usando la plataforma J2EE, tenemos que desarrollar los componentes,
empaquetarlos de la forma apropiada y desplegarlos en los contenedores de componentes. Estos
contenedores "se encuentran" en los servidores de aplicaciones. Es decir, nosotros debemos
arrancar un servidor de aplicaciones y desplegar los componentes en él para poder utilizarlos.
Existen muchos servidores de aplicaciones J2EE. No olvidemos que un servidor de aplicaciones
no es más que una implementación de la especificación definida en el estándar J2EE. Los hay
propietarios y open-source.
También los hay que sólo pueden desplegar aplicaciones Web y los que pueden desplegar
aplicaciones Web y EJBs. Recordemos también que existen, en J2EE, dos tipos de contenedores, los
Web Containers (despliegan Servlets y JSPs) y los EJB Containers (despliengan EJBs).
A continuación vemos una tabla donde se muestran algunos de los principales servidores de
aplicaciones indicando sus características.
Servidor Web Container EJB Container Licencia
TOMCAT Si No Open-Source
JBOSS Si Si Open-Source
WebLogic Si Si Propietario
WebSphere Si Si Propietario
Viendo esta lista, nos preguntamos cuál tenemos que usar. La respuesta es que depende de las
características del proyecto. Para aplicaciones donde los requisitos de rendimiento, disponibilidad,
etc. no sean muy altos, TOMCAT y JBOSS, por ejemplo, son bastante apropiados. En cambio, si el
entorno en el que queremos emplear la aplicación requiere ese rendimiento, alta disponibilidad,
balanceo de carga, seguridad, etc. serían más interesantes las versiones propietarias ya que
6 de febrero de 2008 Tema 3 15
16. proporcionan servidores más completos, potentes y probados y también ofrecen un mejor soporte
para el caso de tener problemas en el funcionamiento de nuestra aplicación sobre ese servidor.
4.2 Instalación, Estrutura y Configuración de JBOSS
Una vez hecho un repaso de algunos de los servidores de aplicaciones que podemos emplear para
desplegar nuestras aplicaciones, hemos optado, para este curso, por elegir JBOSS, en concreto en su
versión 4.2.1.GA.
La instalación de este servidor de aplicaciones es bastante sencilla. Únicamente debemos descargar
el fichero (http://puzzle.dl.sourceforge.net/sourceforge/jboss/jboss-4.2.1.GA.zip) y descomprimirlo
en nuestro disco duro (por ejemplo en c:).
La estructura de directorios de JBOSS es la siguiente:
Como podemos ver, el directorio de JBOSS tiene varias subcarpetas:
- bin: donde se encuentran los ejecutables para, entre otras cosas, arrancar y para el servidor.
- client y lib: librerías generales necesarias para el servidor.
6 de febrero de 2008 Tema 3 16
17. - docs: ciertos ficheros útiles para validación de XMLs, ejemplos, etc.
- server: directorio con contendrá las diferentes configuraciones disponibles: completa (all), por
defecto (default) y mínima (minimal). Mención especial merecen los directorios conf y deploy
dentro de cada directorio de configuración (all, default, minimal). En conf meteríamos todos los
ficheros de configuración de esa configuración y en el directorio deploy situaremos nuestras
aplicaciones.
Con este resumen consideramos cubiertos los objetivos del curso. Para un mayor estudio sobre la
instalación, estructura y configuración de JBOSS mirar la web http://www.jboss.org/
6 de febrero de 2008 Tema 3 17
18. 5 Herramientas de desarrollo
5.1 Herramientas de desarrollo (Eclipse)
Hagamos un pequeño repaso de lo dicho hasta el momento. Empezamos planteándonos la
aplicación que queríamos hacer (nuestra tienda virtual). Después vimos todos los requisitos que
debía cumplir y, por ello, decidimos utilizar J2EE como plataforma sobre la que íbamos a
desarrollar. Después vimos las cosas que deberíamos hacer (crear jsps, crear servlets, etc). Para
esta labor utilizamos las herramientas de desarrollo.
Existen muchas herramientas de desarrollo, por ejemplo, Netbeans, Eclipse, IntelliJ Idea, JBuilder,
etc. Una de las más utilizadas es Eclipse.
Eclipse es gratuito y cuenta con infinidad de plugins que facilitan las diferentes labores a la hora
de desarrollar un proyecto. Tiene plugins para soportar aplicaciones J2EE (Lomboz, entre otros),
para manejar conexiones a BBDD, para hacer diagramas UML que luego se plasman en clases, etc.
En este apartado vamos a ver la instalación de Eclipse con una versión que lleva ya integrados una
serie de plugins, que entre otras cosas, nos ayudarán en el desarrollo de aplicaciones J2EE. También
veremos algunas de las características principales de Eclipse que necesitamos saber antes de
desarrollar aplicaciones con él.
Es importante seguir la lección instalando el IDE
(Eclipse) ya que será necesario para el desarrollo del
resto de temas.
5.2 Instalación de Eclipse
La instalación de Eclipse es muy simple. Basta con descargar el fichero con la versión que nos
interesa (para nuestro curso descargalo de aquí) y después descomprimirlo en el directorio que
queramos, por ejemplo c:.
Con esto ya tendríamos instalado Eclipse, para probarlo basta con entrar en el directorio de Eclipse
y ejecutar eclipse.exe. Cuando ejecutemos eclipse nos preguntará que directorio deseamos usar
6 de febrero de 2008 Tema 3 18
19. como Workspace mediante una ventana como esta:
Lo que nos está preguntando Eclipse es sobre qué directorio queremos que trabaje. En este
directorio estarán todos los ficheros referentes a los proyectos con los que trabajaremos en esa
sesión.
Una vez elegido el directorio, tras pulsar ok, se obtendría una pantalla como esta:
6 de febrero de 2008 Tema 3 19
20. En esta pantalla nos muestran enlaces a asuntos de interés referentes a Eclipse. Para entrar
definitivamente en el área de trabajo basta con cerrar esta pestaña. En el siguiente apartado haremos
una introducción al entorno de desarrollo.
5.3 Introducción a Eclipse
Ya tenemos preparado el entorno de desarrollo, que se compone del servidor de aplicaciones
JBOSS y Eclipse con los plugins apropiados para el desarrollo de aplicaciones J2EE que serán
desplegadas en JBOSS. En los siguientes temas veremos como crear aplicaciones Web y
desplegarlas en JBOSS mediante Eclipse. En este apartado solamente veremos algunos aspectos
generales de Eclipse.
Eclipse, en su configuración inicial, tiene un aspecto como este:
6 de febrero de 2008 Tema 3 20
21. La parte central es donde se mostrará el contenido de los ficheros abiertos, y en el resto de partes
de la pantalla, se muestran las distintas vistas posibles (cada pestaña es una vista). En el dibujo se
ven a modo de ejemplo una pequeña explicación de dos vistas, la de "problemas" y la de
"explorador de paquetes".
Otro de los detalles importantes a tener en cuenta a la hora de usar Eclipse son las perspectivas.
Una perspectiva en Eclipse es como una definición de la distribución y vistas de la pantalla.
Por ejemplo, podemos tener una perspectiva para programar, otra para depurar, etc.
La perspectiva que se muestra en el dibujo anterior es la de programación en Java. En el siguiente
dibujo se muestra la perspectiva de depuración:
6 de febrero de 2008 Tema 3 21
22. Como se puede ver en esta imagen, la perspectiva de depuración tiene esta configuración en la que
se muestran las vistas de depuración, de variables, de breakpoints, de consola, etc.
Evidentemente, todas las vistas y perspectivas son configurables por el usuario del entorno.
Entender esta organización de Eclipse es importante para saber sacarle partido al entorno. En
siguientes temas ya veremos la utilización de Eclipse para desarrollar aplicaciones.
6 de febrero de 2008 Tema 3 22
