Showing posts with label Eclipse. Show all posts
Showing posts with label Eclipse. Show all posts

Friday, 1 May 2009

Creando un Webservice con Eclipse 3.4.2 (J2EE) y JBoss 5.0.1 GA

Continuando con la temática del último post (Creando un Servlet en J2EE mediante Eclipse 3.4.2 y JBoss 5.0.1 GA) y ahora que ya tenemos instalado el JBoss y tenemos todo el entorno configurado, podemos crear un Webservice y probarlo. Para ello, utilizaremos el JBoss Webservice (JAX-WS), y lo iniciaremos mediante un proyecto web con Eclipse. Una vez hecho, iniciaremos nuestro proyecto en el servidor de JBoss y este nos generará un fichero wsdl. Luego desde el mismo JBoss, podremos examinar el contenido de este, y incluso utilizar el Web Service Examinator que tiene el Eclipse para visualizar el contenido y los métodos que hemos puesto en el WebService.


  • Creando el Dynamic Web Project:
Creamos un proyecto Web (File -> New -> Dynamic Web Project), que tenga la siguiente estructura:

Crearé la Clase HiTime.java que tiene unos métodos públicos getDescription y getNumber, estos devuelven String y Integer simples. El getDescription devuelve a partir de un texto un saludo más la hora, y el getNumber solo devuelve un número fijo.

Comprobar que realmente están cargadas todas las librerias del JBoss, sino la aplicación no cargará.

HiTime.java



package com.webservice;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;

/**
* Esto es un WebService
* @author Jordi Coll
*/

/*
* @WebService indica que es una interfície webservice
* el name indica que es un nombre de webservice.
*/
@WebService(name = "HiTime")
/*
* @SOAPBinding indica información vinculate para los mensajes SOAP.
*/
@SOAPBinding(style = SOAPBinding.Style.DOCUMENT,
use = SOAPBinding.Use.LITERAL,
parameterStyle = SOAPBinding.ParameterStyle.WRAPPED)

public class HiTime {
@WebMethod
public String getDescription(@WebParam(name = "name") String name) {
Calendar cal = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat("H:mm:ss:SSS");
return "Hi! " + name + " Time: " + sdf.format(cal.getTime());
}

@WebMethod
public int getNumber() {
return 46;
}
}





web.xml



<?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>Hi Web Service</display-name>
<servlet>
<servlet-name>HiTime</servlet-name>
<servlet-class>com.webservice.HiTime</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>HiTime</servlet-name>
<url-pattern>/HiTime</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>30</session-timeout>
</session-config>
</
web-app>



Una vez hemos creado los diferentes ficheros, arrancamos el proyecto con el server:

Veremos como genera el deploy del fichero .war:

Buildfile: C:\Archivos de programa\dev\eclipseJ2EE\plugins\org.eclipse.jst.server.generic.jboss_1.5.206.v20090115\buildfiles\jboss323.xml deploy.j2ee.web:
[jar] Building jar: D:\workspaceJ2EE\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\TestWebService.war [move] Moving 1 file to C:\jboss-5.0.1.GA\server\default\deploy BUILD SUCCESSFUL Total time: 10 seconds


Ahora si accedemos a la url : http://localhost:8080/TestWebService/HiTime?wsdl, podremos ver como ha creado la SOAP y nos muestra el XML.


Podemos ver en el XML, el nombre del servicio y el puerto. En este caso "HiTimeService" y "HiTimePort", estos hay que tenerlos en cuenta por si queremos conectarlos a la SOAP mediante algún otro programa, por ejemplo un Excel o Delphi:


uses
ComObj;
var
SoapClient: OleVariant;
begin
SoapClient := CreateOleObject('MSSOAP.SoapClient');
SoapClient.mssoapinit('http://127.0.0.1:8080/TestWebService/HiTime?wsdl',
'HiTimeService', 'HiTimePort');
showmessage(IntToStr(SoapClient.getNumber));

Podemos también acceder al WebService del Jboss en la url: http://localhost:8080/jbossws/.

  • Comprobando el WebService desde Eclipse:
Podemos examinar el fichero wsdl mediante el Eclipse Web Service Explorer. Para utilizarlo es muy sencillo, nos dirigimos a la ruta:

C:\jboss-5.0.1.GA\server\default\data\wsdl\TestWebService.war

Dentro de esta, encontraremos los ficheros HiTimeServicexxxxxxx.wsdl. (Cada vez que hacemo sun cambio en nuestro proyecto, automáticamente se genera un nuevo wsdl y se lanza al WebService, por eso puede ser que tengamos un monton de ficheros:


Ahora cogemos el último fichero generado (Por la fecha), y lo copiamos dentro de nuestro proyecto en el Workspace, en mi caso:

Ahora hacemos un refresh en nuestro proyecto (F5), y nos aparecerá el wsdl en nuestro proyecto. Ahora, con el botón derecho -> Web Services -> Test with Web Service Explorer.



Si hacemos doble click sobre el wsdl, también podemos ver la información del servicio:

Ahora que sabemos que funciona correctamente, podemos acceder a este servicio desde cualquier aplicación.

  • Creando un cliente Web Service:
Ahora que ya sabemos crear el Web Service, y podemos ver si funciona correctamente, podemos generar su proyecto cliente y hacer el test mediante páginas en JSP.

Despues de copiar el wsdl dentro de nuestro proyecto, desde la ruta:
C:\jboss-5.0.1.GA\server\default\data\wsdl\TestWebService.war,
hacia : D:\workspaceJ2EE\TestWebService\WebContent.

Nos aparecerá el wsdl dentro de nuestro proyecto. Ahora hacemos un nuevo Web Service Client, vamos a File -> New Other -> Web Service Client

Configuramos el asistente de la siguiente manera:


En Test Client, y luego dentro de Client Project, tenemos que modificar los valores que hay por:


No dejar el mismo nombre de antes, ya que sinó nos eliminará nuestro proyecto. Creamos uno y le indicamos que es un cliente.

Ahora hacemos finish, y empezará a cargar todo el test en el JBoss, y nos generará las página JSP para poder hacer la edición de los métodos de nuestra SOAP.


Si no arranca a la primera, parad el Server y arrancarlo todo otra vez junto. Luego si vamos a las url:
http://127.0.0.1:8080/TestWebService/HiTime?wsdl
http://localhost:8080/TestWebServiceClient/sampleHiTimeProxy/TestClient.jsp

Podremos ver la página con el XML, y la página de test hecha en JSP:


Podemos ver como funciona perfectamente y podemos interaccionar con la SOAP y nos devuelve el texto creado por nuestro método.

  • Enlaces de interés:
http://www.proyectoautodidacta.com/2008/05/14/que-es-un-servicio-web/
http://www.eclipse.org/webtools/jst/components/ws/1.5/tutorials/TopDownWebService/TopDownWebService.html

java.lang.UnsupportedOperationException: setProperty must be overridden by all subclasses of SOAPMessage

Si creando el webservice os encontráis con este error al probar el fichero wsdl, puede ser porque tengáis instalado el jre6, y con el jboss hace falta el jre1.5. La aplicación funcionará correctamente, y generará el WebService pero a la hora de ir a buscar los datos no funcionará ya que está compilado con el jre6.

23:31:50,162 ERROR [[HiTime]] Servlet.service() para servlet HiTime lanzó excepción
java.lang.UnsupportedOperationException: setProperty must be overridden by allsubclasses of SOAPMessage at javax.xml.soap.SOAPMessage.setProperty(Unknown Source)
at org.jboss.ws.core.soap.SOAPMessageImpl.(SOAPMessageImpl.java:82)
at org.jboss.ws.core.soap.MessageFactoryImpl.createMessage(MessageFactoryImpl.java:169)
at org.jboss.ws.core.jaxws.SOAPFaultHelperJAXWS.createSOAPMessage(SOAPFaultHelperJAXWS.java:295)
at org.jboss.ws.core.jaxws.SOAPFaultHelperJAXWS.toSOAPMessage(SOAPFaultHelperJAXWS.java:256)
at org.jboss.ws.core.jaxws.SOAPFaultHelperJAXWS.exceptionToFaultMessage(SOAPFaultHelperJAXWS.java:187)
at org.jboss.ws.core.jaxws.binding.SOAP11BindingJAXWS.createFaultMessageFromException(SOAP11BindingJAXWS.java:102)
at org.jboss.ws.core.CommonSOAPBinding.bindFaultMessage(CommonSOAPBinding.java:671)
at org.jboss.wsf.stack.jbws.RequestHandlerImpl.processRequest(RequestHandlerImpl.java:496)
at org.jboss.wsf.stack.jbws.RequestHandlerImpl.handleRequest(RequestHandlerImpl.java:295)
at org.jboss.wsf.stack.jbws.RequestHandlerImpl.doPost(RequestHandlerImpl.java:205)
at org.jboss.wsf.stack.jbws.RequestHandlerImpl.handleHttpRequest(RequestHandlerImpl.java:131)
at org.jboss.wsf.common.servlet.AbstractEndpointServlet.service(AbstractEndpointServlet.java:85)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:717)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:290)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
at org.jboss.web.tomcat.filters.ReplyHeaderFilter.doFilter(ReplyHeaderFilter.java:96)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:235)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:235)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:191)
at org.jboss.web.tomcat.security.SecurityAssociationValve.invoke(SecurityAssociationValve.java:190)
at org.jboss.web.tomcat.security.JaccContextValve.invoke(JaccContextValve.java:92)
at org.jboss.web.tomcat.security.SecurityContextEstablishmentValve.process(SecurityContextEstablishmentValve.java:126)
at org.jboss.web.tomcat.security.SecurityContextEstablishmentValve.invoke(SecurityContextEstablishmentValve.java:70)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:127)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:102)
at org.jboss.web.tomcat.service.jca.CachedConnectionValve.invoke(CachedConnectionValve.java:158)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:109)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:330)
at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:829)
at org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:601)
at org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:447)
at java.lang.Thread.run(Unknown Source)

Podemos descargar las versiones anteriores del jre desde el siguiente enlace:
http://java.sun.com/javase/downloads/index_jdk5.jsp

Luego en la configuración del Server de JBoss, hay que marcar que vaya con el jre más antiguo:

Creando un Servlet en J2EE mediante Eclipse 3.4.2 y JBoss 5.0.1 GA

Aquí os dejo un pequeño ejemplo/tutorial de como crear un pequeño servlet en J2EE con eclipse 3.4.2 y Jboss 5.0.1. Primero necesitamos el JBoss 5.0.1 que es nuestro servidor de aplicaciones open source y se encargará de ejecutar nuestro servlet. Desde este enlace podemos descargar la versión que queramos: jboss community. Para este ejemplo he utilizado la versión 5.0.1 GA, aquí os dejo también el enlace directo a la versión estable jboss 5.0.1 GA.

Una vez descargado, lo descomprimimos lo dejamos en la C:\ por ejemplo. Siempre en un directorio sin espacios sino queremos que nos pase el error que comenté en un post anterior. No hay que hacer nada más, ya lo configuraremos luego desde Eclipse.

Ahora descargamos el Java EE desde aquí: Java EE 5 SDK Update 7. O podemos seleccionar la versión que queramos desde la página de descargas de sun. Una vez iniciamos la aplicación java_ee_sdk-5_07-windows-nojdk-ml.exe nos aparecerá un asistente de instalación que nos irá indicando los pasos para instalar el J2EE. Una vez lleguemos a la parte de la configuración del administrador, simplemente apuntar un password válido y decir que no pregunte sobre el user. En mi caso he puesto 12345678, los puertos los he conservado.


En las opciones de instalación, marcar "Upgrade from previous version", ya que si tenéis una versión anterior os la actualizará.

Una vez finalizado, podemos arrancar el Server haciendo un test, y luego salir de la instalación.

Ahora descargamos el Eclipse ganymede 3.4.2, (IDE for EE). Aquí os dejo el link de descarga directa: Eclipse 3.4.2.

Una vez tenemos el Eclipse en nuestra máquina, lo descomprimimos donde queramos y lo iniciamos. Una vez iniciado, tenemos que crear un server. Hacemos File -> New Other, y escribimos server.

Ahora lo configuramos:


Una vez tenemos el servidor configurado, creamos una pequeña aplicación que se llamara "HolaServlet", y que tendrá una pequeño ejemplo en HTML que enviará un texto a un Servlet.

Lo configuramos de la siguiente manera, con las librerías indicadas, con las clases indicadas y los ficheros de configuración.


Los ficheros a crear son los siguientes:

indice.html



<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<
head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Ejemplo Servlet JBoss 5.0 Eclipse 3.4.2</title>
</
head>
<body>
<center>
<form action="http://localhost:8080/HolaServlet/NewServlet" method=Post>
Ejemplo Servlet JBoss 5.0 Eclipse 3.4.2<br><br>
Texto a enviar al Servlet: <input type=Text name="texto"><br><br>
<input type="Submit" value="Enviar">
<input type="Reset" value="Reset">
</form>
</center>
</body>
</
html>





NewServlet.java



import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class NewServlet extends HttpServlet {
private static final long serialVersionUID = 1L;

public void init(ServletConfig conf) throws ServletException {
super.init(conf);
}

public void doPost(HttpServletRequest peticion,
HttpServletResponse respuesta) throws ServletException, IOException {
respuesta.setContentType("text/html");
PrintWriter out = respuesta.getWriter();
String nombre = peticion.getParameter("texto");
out.println("<html><body>Hola soy un Servlet y he recibido " +
"el texto: <h1><font color='red'>" + nombre + "" +
"</font></h1></body></html>");
}
}





web.xml



<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<display-name>Welcome to JBoss 5.0</display-name>
<description>Welcome to JBoss 5.0</description>

<servlet>
<servlet-name>NewServlet</servlet-name>
<servlet-class>NewServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>NewServlet</servlet-name>
<url-pattern>/NewServlet</url-pattern>
</servlet-mapping>

</
web-app>




una vez creado el Servlet, lo iniciamos en el server que hemos creado.


Antes, podemos publicar nuestro proyecto, haciendo botón derecho sobre el JBoss v5.0 y hacemos publish. Esto nos muestra como genera el fichero .war y lo publica en el deploy del JBoss:

Buildfile: C:\Archivos de programa\dev\eclipseJ2EE\plugins\org.eclipse.jst.server.generic.jboss_1.5.206.v20090115\buildfiles\jboss323.xml
deploy.j2ee.web:
[jar] Building jar: D:\workspaceJ2EE\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\HolaServlet.war
[move] Moving 1 file to C:\jboss-5.0.1.GA\server\default\deploy
BUILD SUCCESSFUL
Total time: 10 seconds

Si ahora iniciamos el server, podemos consultar la web indice.html en la url : http://localhost:8080/HolaServlet/indice.html, y nos aparecerá la web en HTML que hemos creado:

Si hacemos "enviar", podremos ver lo que recibe en el post el servlet:


Monday, 27 April 2009

Error iniciando JBoss en Eclipse 3.4.2

Si alguna vez os encontráis con el siguiente error:



ERROR [AbstractKernelController] Error installing to Instantiated: name=TransactionManager state=Described java.lang.ExceptionInInitializerError: java.net.MalformedURLException: unknown protocol: c...


El problema puede ser que la carpeta donde está alojado el JBoss tenga algún espacio. En mi caso estaba instalado en C:\Archivos de Programa\dev\jboss-5.0.0.GA, se soluciona el problema moviendo la carpeta directamente en el directorio raíz de C -> C:\jboss-5.0.0.GA

Thursday, 16 April 2009

Desarrollo OSGi con Eclipse Equinox

Como indica la palabra OSGi (Open Services Gateway initiative), es un sistema muy conocido en el entorno Java. Una buena definición la podemos encontrar en la misma web del OSGi Alliance : Sistema de módulos dinámicos para Java. Lo que aporta OSGi Service Platform, es un contenedor sobre el que corren distintos módulos, con sus versiones, sus paquetes exportados (que pueden utilizar otros módulos) y sus dependencias. Existen varias implementaciones del estándar, y la más conocida Equinox de Eclipse, la cuál voy a utilizar para este post.

fuente : Wikipedia

  • Descargando OSGi para Eclipse.
Nos dirigimos a la web de Eclipse, y descargamos la última versión de Equinox, en este caso es la 3.4. Aquí hay un enlace de descarga directa:
eclipse-equinox-3.4.zip

Una vez tenemos el fichero en nuestro PC, lo descomprimimos dentro de la ruta del Eclipse, en mi caso C:\Archivos de Programa\dev\Eclipse, el paquete lleva todos los plugins necesarios para que se ejecute el OSGi.

Sobretodo en el fichero que nos tenemos que fijar es el:
org.eclipse.osgi_3.4.0.v20080605-1900.jar
Que es el que luego ejecutaremos para iniciar el OSGi desde la consola del S.O.

Para comprobar que el OSGi funciona, hacemos una pequeña prueba, iniciamos un interprete de comandos con el comando "cmd" y luego nos dirigimos a la carpeta C:\Archivos de Programa\dev\Eclipse\plugins\ y desde aquí escribimos:

java -jar org.eclipse.osgi_3.4.0.v20080605-1900.jar -console

luego veremos como inicia el OSGi y inicia el servicio:

Ahora desde aquí, podemos instalar los plugins (les llaman Bundles), y a partir de ahí, iniciarlos, pararlos o desinstalarlos. Aquí os dejo un pequeño resumen sobre las acciones que podemos hacer sobre el OSGi:

install [bundle URL] Instala un bundle desde una URL
start [bundle] Inicia un bundle a través de su ID
stop [bundle] Para un bundle a través de su ID
ss [bundle] Muestra el estado de los bundles
diag [bundle] Reporta cualquier problema del bundle a través de su ID

  • Creando nuestro OSGi Bundle.
Ahora que ya sabemos como ejecutar el OSGi, tenemos que crear los plugins desde Eclipse para instalarlos e iniciarlos desde el OSGi. Por lo tanto desde Eclipse, hacemos:

New Project -> Plug-in Project


Luego marcamos que el plugin funcionará con un OSGi framework Equinox:

Continuamos el asistente y mantenemos la configuración actual:

Seleccionamos una template de Hello OSGi Bundle, ya que esta nos generará un código de plantilla con las llamadas para que el framework lo pueda ejecutar.


Luego finalizamos, y nos aparecerá la pantalla de configuración del Plug-in, donde podremos visualizar sus dependencias, propiedades y el fichero MANIFEST.MF, que es el que tiene la conversión de los nombres simbólicos, el ejemplo en nuestro caso es el siguiente:

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: OsgiTest2 Plug-in
Bundle-SymbolicName: OsgiTest2
Bundle-Version: 1.0.0
Bundle-Activator: osgitest2.Activator
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: org.osgi.framework;version="1.3.0"

Si ahora ejecutamos el Framework tal como lo hemos creado, nos tendria que aparecer en la consola del Eclipse, un "Hello World!!" que es el que viene por defecto con la template del Bundle Plug-in.


Antes de iniciar la aplicación, tenemos que ir al fichero MANIFEST.MF, y con el botón derecho hacemos -> Run Configurations:

Solo marcamos nuestro Plug-in, y luego hacemos Run. En la consola tenemos que ver algo parecido a esto:

Configuration location:
file:/D:/workspace/.metadata/.plugins/org.eclipse.pde.core/mboss/
Configuration file:
file:/D:/workspace/.metadata/.plugins/org.eclipse.pde.core/mboss/config.ini loaded
Install location:
file:/D:/workspace/mboss-target-platform/target/
Framework located:

file:/D:/workspace/mboss-target-platform/target org.eclipse.osgi_3.4.2.R34x_v20080826-1230.jar
Framework classpath:

file:/D:/workspace/mboss-target-platform/target/org.eclipse.osgi_3.4.2.R34x_v20080826-1230.jar
Debug options:

file:/D:/workspace/.metadata/.plugins/org.eclipse.pde.core/mboss/.options loaded

Skipping osgi.properties:
osgi.properties

Initialize the framework: 94
Trying to launch framework

osgi>
install from inputstream: i
nitial@reference:file:../../OsgiTest2/, org.eclipse.osgi.framework.internal.core.ReferenceInputStream@4741d6
compact(D:\workspace\.metadata\.plugins\org.eclipse.pde.core\mboss\org.eclipse.osgi\bundles)
Trying to resume bundle
initial@reference:file:../../OsgiTest2/ [1]
Time to load bundles: 16
Trying to resume bundle initial@reference:file:../../OsgiTest2/ [1] Bundle:
Active sl = 4; Bundle 1 sl = 4

Hello World!!
->started initial@reference:file:../../OsgiTest2/ [1]


Podemos ver como aparece el mensaje que tiene programada la clase Activator.java:



  • Exportando el proyecto para su ejecución en el OSGi
Una vez tenemos el proyecto funcionando sin ningún error, podemos exportarlo para que se ejecute en el OSGi desde el intérprete de comandos, para hacer eso, tenemos que hacer los siguiente sobre nuestro proyecto:

Hacemos con el botón derecho sobre nuestro proyecto -> Export -> Deployable plug-ins and fragments.


Luego seleccionamos el proyecto a exportar, en mi caso OsgiTest2:

Una vez finalizada la creación, si nos dirigimos a C:\TEMP\bundles\plugins nos encontraremos con un fichero OsgiTest2_1.0.0.jar que es el bundle que le tenemos que pasar a nuestro OSGi.

Desde nuestro OSGi, instalamos el plug-in:

osgi> install file:W:\bundles\plugins\OsgiTest2_1.0.0.jar Bundle id is 10 osgi> start 10 Hello World!! osgi> stop 10 Goodbye World!!

Podemos ver que instalando el Bundle y iniciandolo, podemos ver el mensaje que hemos programado en Activator.java.

Si quisieramos una activación directa de nuestros bundles, tendriamos que crear un fichero config.ini en la carpeta C:\TEMP\configuration y que dentro de esta tuviese las activaciones de nuestros bundles:

osgi.bundles=OsgiTest2.jar@start
eclipse.ignoreApp=true

Ahora ya podemos hacer cualquier aplicación mediante bundles y ejecutarlos en el OSGi. Si queremos, también podemos interacturar con el OSGi a través de la consola del Eclipse. Una vez arrancamos el plug-in, podemos ejecutar los comandos necesarios en la ventana:

Ahora que ya sabemos como funciona un poco todo esto, ya podemos empezar a crear aplicaciones más modulares, ya que disponemos de un framework que nos permite interactuar con él y ejecutar nuestros bundles.

Enlaces de interés:
http://mikiorbe.wordpress.com/2009/02/23/desarrollo-osgi-en-eclipse/
http://knowledgerush.com/kr/encyclopedia/OSGi/
http://www.ibm.com/developerworks/library/os-ecl-osgi/index.html
http://www.vogella.de/articles/OSGi/article.html
http://www.eclipse.org/equinox/documents/quickstart.php


Wednesday, 15 April 2009

AJDT: AspectJ Development Tools

Siguiendo en la línea del post del día 9 de abril sobre el AOP (Programación orientada a Aspectos), aquí os hago una pequeña demostración y algún ejemplo de como integrar AspectJ en el eclipse. Primero nos descargamos el paquete para nuestra versión de eclipse, en mi caso la 3.4.1 Ganymede (ya lo comenté un día en algún post).
Aquí os dejo en enlace directo para la descarga:

Copiamos el fichero ajdt_1.6.4_for_eclipse_3.4.zip dentro de la carpeta donde tenemos instalado el Eclipse, en mi caso en C:\Archivos de Programa\dev\Eclipse y extraemos el contenido de todo el paquete. Directamente se copiaran dentro de la carpeta plugins y features. Ahora solo falta iniciar el eclipse, y podremos ver que les herramientas del AspectJ están ya integradas en el IDE del eclipse.

Una vez iniciamos el eclipse, podemos ver en la pantalla principal (overview):

  • Un ejemplo práctico y sencillo:
Por la red, podemos encontrar un sinfín de ejemplos basados en AspectJ o en AOP Guice que es como lo hice el otro día, de todas formas, aquí, podemos encontrar un manual que está bastante bien.

Primero creamos un proyecto, en este caso se llamará HelloWorldAspect, y crearemos una pequeña clase que simplemente diga "Hello". Una vez hecha la clase, con el botón derecho del ratón, convertiremos este proyecto a AspectJ Project, una vez hecho, el proyecto aparecerá de la siguiente manera:

El código es el siguiente:




public class HelloWorld {
public void sayHello() {
System.out.println("Hello");
}

public static void main(String[] args) {
new HelloWorld().sayHello();
}
}




Ahora nos ha añadido la librería del AspectJ, y solo falta crear el nuevo aspecto sobre nuestra clase. Por lo tanto, nos dirigiremos hacia el botón de "New Java Class", pero escogeremos "New Aspect":

Vamos a crear un Aspect que se llame World.aj, y que contenga el siguiente código:




public aspect World {
pointcut greeting() :
execution (* HelloWorld.sayHello(..));

before() : greeting() {
System.out.println("Before greeting!");
}

after() : greeting() {
System.out.println("After greeting!");
}

after() returning : greeting() {
System.out.println("After returning greeting!");
}
}




Una vez hemos completado todos los pasos, deberíamos tener algo como esto (mostrando todas las referencias del AspectJ):


El resultado de la ejecución de la aplicación, es el siguiente:

Before greeting!
Hello
After greeting!
After returning greeting!

Por lo tanto, hemos interceptado el mensaje que manda nuestra clase, y hemos ejecutado un código antes y después del mensaje. Es el mismo concepto, de interceptar lo que está diciendo nuestra clase y que mostré en el post del AOP.

El funcionamiento es bastante simple pero potente a su vez. Primero creamos un punto de corte que lo llamaremos Greeting, este punto de corte está asociado a un método de nuestra clase. Luego sobre este punto de corte se vigilan los accesos (before, after, after returning, after throwing, etc) y se muestra el resultado de estos por pantalla. Mediante esta guia, podemos introducirnos mejor en este mundo del AOP.

Podemos ver el aspecto de nuestro proyecto con la vista del AspectJ:

  • Más ejemplos en:
http://www.eclipse.org/ajdt/demos/

Wednesday, 4 March 2009

Instalar una herramienta de workflow para Eclipse



Con la herramienta que nos proporciona Eclipse Java Workflow Tooling (JWT), podemos crear nuestros programas con una herramienta de tipo Workflow. Un ejemplo seria el siguiente:



De esta manera nos podemos ahorrar bastante el trabajo de programación, ya que lo podemos ver como una seqüència de trabajo y ejecutarlo de esa manera.

Para instal·lar la última versión, tenemos que ir a la sección de descarga de JWT : http://wiki.eclipse.org/JWT_Downloads, y descargar los 2 pluggin el Workflow editor i el Viewer Creator. Una vez tenemos los dos ficheros descargados:

Workflow Editor
Viewer Creator

Los copiamos dentro de la carpeta plugins del Eclipse, y luego lo iniciamos. Una vez lo iniciamos nos fijamos que ahora cuando generamos un nuevo proyecto, nos aparece la opción de workflow y si vamos a las vistas también aparece.



Ahora, ya podemos generar nuestros modelos, pero para saber como funciona, aquí dejo unos links con los manuales y la wiki del Eclipse.
Usage Tutorial :
http://www.eclipse.org/jwt/components/we/docs/JWTWorkflowEditorUsageTutorial.pdf
JWT Wiki:
http://wiki.eclipse.org/Java_Workflow_Tooling_Project