Manual Jboss Server,Creación de Proyecto en Eclipse

INFORME DE CONFIGURACION
Y COMPILACION DE
EJERCICIOS EN JBOSS SERVER
STALIN TUSA

1
Tabla de contenido
Herramientas iniciales que debemos tener antes del proceso de instalación.................................................................2
Descarga de Archivos....................................................................................................................................................2
Agregar variables de sistema a nuestro PATH..................................................................................................................3
Instalación de jbossesb-server-4.12..................................................................................................................................7
Compilación de ejemplos de prueba ................................................................................................................................9
Como crear un proyecto propio usando Eclipse Índigo..................................................................................................13
Creación de un proyecto propio en Eclipse Índigo .........................................................................................................18
Creación de los Proveedores(Providers).........................................................................................................................20
Creación de Filtros ..........................................................................................................................................................22
Creación de Servicios (Services)......................................................................................................................................24
Creación de Actions ........................................................................................................................................................27
Creación de un Archivo ESB ............................................................................................................................................32

2
Herramientas iniciales que debemos tener antes del proceso de instalación.
Descarga de Archivos
Iniciamos con la descarga del archivo jbossesb-server, de su sitio oficial http://www.jboss.org/jbossesb/downloads,
en nuestro caso usaremos la versión 4.12
Luego procedemos a descargar el apache-ant-1.9.0 para ejecutar el comando ant en el cmd, ya que si no lo hacemos
no podremos continuar con la compilación de nuestros ejercicios, lo podemos hacer desde si sitio oficial
http://mirror.metrocast.net/apache//ant/binaries/
Ahora si no tenemos instalado un IDE de java como Netbeans, debemos descargar el jdk y el jre para poder usar y
ejecutar nuestro servidor, para lo cual ingresamos a la dirección web https://jdk7.java.net/, en nuestro caso usaremos
la versión 7.
Y el jre desde la siguiente dirección http://www.oracle.com/technetwork/java/javase/downloads/index.html,
usaremos la versión 1.5

3
Agregar variables de sistema a nuestro PATH
Antes de proceder con la instalación debemos asegurarnos que el jdk y el jre están corriendo en nuestro equipo, esto
lo haremos abriendo una ventana de comandos y ejecutamos lo siguiente,
Si es que está funcionando bien debe aparecernos lo siguiente:
Pero en el caso de que no les salga esto, debemos hacer lo siguiente, vamos a añadir los path´s respectivos a las
variables del sistema, esto es de la siguiente manera:
Primero nos ubicamos en la carpeta donde está instalado el jdk de java y en la carpeta bin, asi:
Ahora procedemos a copiar la dirección y nos vamos a Equipo>clic derecho>propiedades>configuración avanzada del
sistema, hasta que lleguemos a esta ventana.

4
Entonces damos clic en configuración avanzada del sistema y tendremos esto:
Ahora nos vamos a variables de entorno y tendremos esto:
En donde dice variables del sistema, buscamos la opción que diga PATH
Le damos clic en editar y nos aparecerá lo siguiente:
Agregamos la dirección del jdk que explicamos anteriormente, asi:
Y damos clic en aceptar.

5
Ahora haremos lo mismo con el apache ant, nos ubicamos en la dirección en donde lo descomprimimos al archivo que
nos descargamos, luego vamos a la carpeta bin, y copiamos la dirección, asi:
Ahora esa misma dirección agregamos al PATH, asi:
Y listo damos clic en aceptar y cerramos todo, ahora nos vamos nuevamente a nuestra consola de Windows, y
ejecutamos nuevamente lo siguiente.
Y si todo sale bien nos saldrá lo siguiente:
Ahora procedemos con el comando siguiente:

6
Y si hicimos todos los path´s nos aparecerá lo siguiente:
Si todavía no les sale, probamos con lo siguiente, volvemos a variables del sistema, y hacemos esto:
Clic en nueva
Aquí escribimos en nombre JAVA_HOME y en valor de variable, la dirección donde está el jdk instalado, pero no en la
carpeta bin, sino solo en la carpeta donde está instalado, es decir esta:
Procedemos a copiarla entonces y pegamos en valor de la variable.

7
Y aceptamos y cerramos todo, abrimos nuevamente nuestra terminal y ejecutamos nuevamente el comando javac –
version, y ahora si ya nos saldrá lo siguiente:
Ahora si procedemos a instalar nuestro servidor jbossesb-server-4.12.
Instalación de jbossesb-server-4.12
Lo primero que debemos hacer una vez comprobado que el jdk y el apache-ant estén añadidos a nuestro path, vamos
a empezar recién con la instalación de nuestro servidor jbossesb-server-4.12.
Abrimos una nueva terminal como administrador:
Ahora vamos a ubicarnos en la carpeta del apache ant, y luego en la carpeta bin y mostramos los directorios, y
tendremos algo como esto:
Aquí ejecutamos el archivo antRun, asi:

8
Presionamos enter y tendremos lo siguiente:
Ahora una vez hecho esto abrimos una nueva terminal y nos ubicamos en la carpeta de nuestro jbossesb-server-4.12,
luego nos vamos a la carpeta bin y ahí ejecutamos el archivo run.bat:
Ahora como es la primera vez que lo iniciamos se va a demorar un poco dependiendo de las características de tu Pc, y
tendremos finalmente esto:
Que nos dice que se ha iniciado correctamente e 43 segundos y 804 mili segundos.
Y ya tenemos nuestro servidor jbossesb-server-4.12, corriendo.

9
Compilación de ejemplos de prueba
Jbossesb-server-4.12 viene por defecto con samples o ejemplos básicos con los cuales podemos probar si de veras
está recibiendo las peticiones de nuestros clientes, entonces vamos a ir con nuestro explorador de Windows a la
carpeta descomprimida de jbossesb-server-4.12.
Aquí nos vamos a samples:
Luego a quikstarts:

10
Como vemos en la figura anterior, tenemos un gran número de ejemplos que vienen junto con jbossesb-server-4.12,
entonces vamos a probar el primero, buscamos el que dice helloworld:
Como vemos en la figura, allí esta, y ese es el que vamos a compilar para probar nuestro servidor.
Como primer paso abrimos una nueva terminal sin cerrar las que hemos abierto anteriormente, igualmente como
administrador.
Luego nos ubicamos en la carpeta de samples en nuestro Jboss y en la carpeta samples, asi:
Ahora nos vamos a quickstarts:
Ahora a la carpeta de nuestro ejemplo que se llama helloworld:

11
Una vez dentro de nuestra carpeta del ejemplo helloworld, ejecutamos el comando siguiente:
Entonces vemos ant deploy nos da creando el buffer o cola para escuchar, y presionamos enter y tendremos lo
siguiente:
Nos dice que se ha compilado satisfactoriamente en 2 segundos.
Ahora vamos a ejecutarlo, lo que debemos hacer es ejecutar el comando ant runtest, asi:

12
Y tendremos lo siguiente:
Nos dice que el test se ha ejecutado correctamente y nos vamos a ir al terminal donde esta corriendo nuestro servidor
y veremos que se imprime el mensaje helloworld al final:
Entonces como podemos ver si nos esta recibiendo las peticiones que hacemos.

13
Como crear un proyecto propio usando Eclipse Índigo
Entonces procedemos a descargar el Eclipse desde el sitio
http://www.eclipse.org/downloads/packages/release/indigo/sr2.
Sin cerrar nuestro servidor que se está ejecutando en el terminal descomprimimos el archivo de Eclipse Índigo, y
procedemos a crear un workspace así:
En mi caso escribo ejemplo, ponemos ok.
Ahora tendremos nuestro workspace listo, y vamos a proceder a descargar los componentes necesarios, en este caso
jbosstools-3.3.2, desde el sitio oficial de jbosstools que es http://www.jboss.org/overview/.
Al abrir eclipse tendremos nuestro espacio de trabajo parecido a este:
Ahora vamos a instalar estos componentes en nuestro eclipse. De la siguiente manera.
Vamos a ir a help>install new software, nos aparecerá esto:

14
Ahora damos clic en add, tendremos esto:
Ahora damos clic en archive:
Y buscamos en donde hemos guardado nuestro archivo descargado jbosstools-3.3.2.Final.aggregate-Update-2013-01-
18_18-03-25-H229.rar, y escogemos dicha carpeta comprimida, asi:
Damos clic en abrir y nos aparecerá esto:
Ahora dejamos sin nombre, damos clic en ok y tendremos esto:

15
Ahora procederemos a escoger los componentes que vamos a necesitar, ya que no vamos a usar todos, empecemos
entonces, nos vamos a Abridged JBoss Tools 3.3, aquí vamos a escoger lo siguiente.
1. Context and Dependency Injection Tools
2. Hibernate Tools
3. JBoss Runtime AS Detector
4. JBossAS Tools
5. JBoss Tools Java Standard Tools
Tendremos una selección parecida a esta:
Ahora damos clic en siguiente esperamos hasta que se cargue totalmente.

16
Ahora vamos a instalar el paquete soatools-3.3.3.Final.aggregate-Update-2013-01-28_17-58-40-H2, que igualmente
lo descargamos desde el sitio oficial de Jboss, luego procedemos a instalar de la misma forma que lo hicimos
anteriormente, asi:
Damos clic en help>install new software.
Damos clic en Add, nos aparecerá lo siguiente.
Ahora clic en Archive.
Damos clic en abrir, y tendremos esto.

17
Damos clic en ok, dejamos sin nombre y tendremos lo siguiente.
Aquí vamos a escoger de la misma manera, solo las características que vamos a usar, que son las siguientes.
En la opción JBoss SOA Development, abrimos y escogemos, JBoss ESB Tools.
Ahora en la opción SOA and Data Services Tooling, y escogemos adicionalmente JBoss Runtime ESB Detector, aparte
del JBOSS ESB Tools.
Y con estos pasos estamos listos para crear nuestro primer ejemplo, nuestro propio Hola mundo, que como vimos
anteriormente solo lo compilamos el que esta creado, ahora lo haremos paso a paso.

18
Creación de un proyecto propio en Eclipse Índigo
Entonces empecemos con creando un nuevo proyecto java, dado clic en file>new, asi:
Ahora nos aparecerá esta ventana:
Aquí escogemos la opción que dice ESB, damos clic en ESB Proyect, asi:
Presionamos siguiente.

19
Ahora nos aparecerá esta ventana en donde pondremos el nombre de nuestro proyecto, en mi caso es Ejemplo1:
Como vemos en el Target runtime, vemos que nos aparece la opción que escogimos al momento de la instalación de
los JbossTools, además en JBoss ESB_version podemos escoger las diferentes versiones que existen, pero en nuestro
caso dejaremos todo por defecto, con la versión 4.12, que fue la que descargamos.
Ahora presionamos next(siguiente), y tendremos la siguiente ventana.
Aquí escogeremos donde guardar todo lo que haremos, y presionamos siguiente.
Aquí nos pide la configuración de nuestro facet, para el contenido de nuestro ESB y la versión, todo esto dejaremos
por defecto, presionamos finalizar.

20
Creación de los Proveedores(Providers).
Ahora vemos que nuestro workspace se ha transformado a esta forma
Ahora nos ubicaremos en la carpeta de Providers, y lo primero que vamos a crear es un nuevo proveedor de la siguiente
manera:
Clic en providers, lego clic en add nos aparecerán múltiples opciones
Escogemos la opción que necesitamos que es un JMS Provider y tendremos la siguiente ventana.

21
En nombre vamos a llamarle JBossMQ, puede ser cualquier nombre, por cuestiones de formato y estándares le pondré
este nombre.
Ahora en connection Factory nos pide que elijamos un tipo de conexión, el cual será en nuestro caso mediante:
Luego presionamos siguiente y nos pedirá el canal del bus por donde vamos a enviar la conexión, y pondremos lo
siguiente, en el id quickstartGwChannel, puede ser cualquier nombre, pero yo lo pondré este.
Presionamos finish(Terminar), y listo tenemos nuestro primer proveedor.
Como vemos al abrirlo, se muestra el canal, que era quickstartGwChannel, con su nombre y con su tipo de conexión,
además de un Filter, en el cual podremos filtrar las conexiones, entonces lo siguiente que procederemos a hacer es
crear un filtro, de la siguiente manera.

22
Creación de Filtros
Nos ubicamos en Filter y tendremos esta interfaz:
Nos solicita llenar el campo del nombre del destino y también escoger el tipo de destino, el tipo lo dejaremos QUEUE,
ya que es el que se usa para este tipo de ejemplo, yo usaré este nombre queue/quickstart_helloworld_Request_gw,
puede ser cualquiera, entonces tendremos algo como esto:
Y listo damos clic en guardar proyecto, y se guardará.
Ahora añadiremos otro id de canal del bus, para hacer esto nos ubicaremos en nuestro proveedor creado que es
JBossMQ, nos aparecerá esto:

23
Y en la lista de canales vemos que esta creado nuestro primer canal, ahora vamos a crear uno nuevo dando clic en
add, el nombre que le pondré en mi caso es quickstartEsbChannel, pero puede ser cualquier nombre, y tendremos
algo como esto:
Y presionamos Finish, y listo, porque dos canales?, ya que facilita la forma de conectarnos a nuestro servidor, ya sea
por el ESB cannel o el JMS cannel, y tendremos esto:
Abrimos nuestro canal y creamos el nuevo filtro que se llamará queue/quickstart_helloworld_Request_esb, insistiré
en decir que puede ser cualquier nombre, guardamos y listo se ha guardado nuestro filtro.
Y con esto finalizamos la creación de los proveedores, ahora empezaremos con la creación de los servicios.

24
Creación de Servicios (Services)
Ahora en nuestro proyecto nos ubicamos en la pestaña de services(Servicios)
Y procedemos a crear un servicio de la misma manera que creamos los proveedores, damos clic en add, y llenamos la
siguiente ventana.
Ahora damos clic en finish, y tendremos esta interfaz.
Ahora abrimos la pestaña SimpleListener(O el nombre que le hayan puesto), y vamos a añadir un nuevo Listener de
esta forma:

25
Hacemos clic en add y nos aparece estas opciones de Listener:
Y el que vamos a usar un JMS listener y tenemos esto y rellenamos con la siguiente información.
Finalizamos y ahora ya está nuestro listener JMS.
Aquí no crearemos un filtro.

26
Ahora en donde nos pide si es gateway o no, le ponemos que si, es decir true:
Ahora crearemos otro Listener, recordando que estamos siguiendo los mismos pasos del archivo jboss-esb.xml, que
está ubicado en la capeta samples/quickstart/helloworld, entonces creamos de la misma manera que el anterior.
Solo que esta vez es un ESB cannel, lo cual lo diferencia del anterior y al ubicarnos en nuestro archivo de proyecto
jboss-esb.xml vemos que esta idéntico al de la carpeta samples.
Como vemos nuestro archivo .xml ya tiene los servicios, los filtros, los providers y los listeners, ahora lo que nos hace
falta es los actions, que es lo siguiente que crearemos.

27
Creación de Actions
Para crear las Actions vamos a proceder de la siguiente manera:
En other buscamos nuestros complementos instalados ESB, y tenemos lo siguiente:
Y damos clic en ESB Action.
Ahora llenamos la información del paquete, en mi caso es el que aparece allí escrito, pueden usarlo si es que están
siguiendo a la par mi ejercicio.
En nombre ponemos cualquier nombre, en mi caso es MyJMSListenerAction.

28
Presionamos finalizar y listo tenemos nuestra primera clase para crear nuestra Action.
Y nos aparecerá una interfaz de la siguiente manera,
Aquí es donde vamos a programar todos los eventos que deseamos se ejecuten al momento de compilar nuestro
proyecto.
Ahora en el método que por defecto nos aparece en el cual es de tipo Message, y recibe un Objeto tipo Message
escribiremos el código siguiente:
Que lo que hace es imprimirnos el mensaje que nosotros vamos a programar que nos imprima en el servidor.
Ahora si vamos a crear nuestra Action, regresamos a nuestro Jboss, nos ubicamos en actions y damos clic en add, y
tendremos lo siguiente.

29
Aquí escogemos la opción que dice Custom Action y le damos clic.
No aparecerá lo siguiente.
En nombre le voy a poner action1, ahora este paso es importante, en donde nos pide la clase, recuerden ustedes que
ya creamos una clase tipo ESBAction que se llamaba MyListenerAction, o el nombre que ustedes le hayan puesto,
entonces damos clic en browse y buscamos nuestra clase creada.
Como vemos basta con escribir las dos primeras letras, nos aparecerá nuestra clase, en el paquete que le hayamos
creado, entonces seleccionamos nuestra clase y damos clic en ok.
Tendremos esto, ahora en process, recordemos que programamos un proceso en nuestra clase ESBAction, que se
llamaba displayMessage, entonces damos clic en browse y debe aparecernos nuestro proceso, asi:

30
Como vemos si nos aparece, lo seleccionamos y damos clic en ok.
Y ya tenemos llenado todo en nuestra Action:
Damos clic en ok, y tendremos lo siguiente.
Esta entonces creada nuestra action, que será la que llame a nuestra clase e imprima nuestro mensaje, es este caso
o imprima lo que se haya programado en el método.
Ahora como estamos usando el ejemplo del helloworld, vamos a ir a la carpeta de este programa y copiamos el
archivo jbm-queue-service.xml, de esta manera.

31
Lo copiamos y lo pegamos en la carpeta esbcontent de nuestro proyecto, de esta forma, que en si es un managed
bean:
Y listo al final de nuestro proyecto nos aparece ya nuestro archivo:
Ahora haremos lo mismo con el archivo deployment.xml y lo pegamos en la carpeta META-INF, de nuestro proyecto,
y tendremos nuestro proyect tree de la siguiente manera

32
Creación de un Archivo ESB
Primero crearemos una carpeta llamada deploy, entonces vamos a File>New>Folder
Ahora estamos casi en la parte final de la creación de nuestro propio hola mundo, para ello vamos a proceder a crear
un archivo ESB en la carpeta deploy que creamos anteriromente, lo haremos de la siguiente forma tal como lo hicimos
para nuestra clase para para crear nuestra primera ACTION, entonces nos vamos a File>New>Other>ESB y aquí
escogemos el ESB File.
Clic en siguiente
Nos aparecerá esto y le ponemos un nombre cualquiera en mi caso es HolaMundoUTN. Y clic en Finish.

33
Ahora vamos a guardar nuestro deployment.xml con nuestro archivo ESB, en la capeta del proyecto creado, esto lo
haremos de la siguiente manera, clic derecho en nuestro archivo deployment.xml:
Nos a parecerá lo siguiente en donde escogeremos la forma como lo vamos a exportar, es decir como un ESB File
Clic en next, luego tendremos que buscar la dirección donde esta nuestro proyecto guardado, es decir en nuestro
workspace que creamos al inicio, así:
En mi caso es esta dirección, aquí abrimos la carpeta con el nombre de nuestro proyecto, en mi caso se llama
Ejemplo1.

34
Una vez en la carpeta de nuestro proyecto abrimos la carpeta deploy que creamos.
Y damos clic en guardar, tendremos esto:
Damos clic en Finish.
Ahora vamos a proceder a copiar nuestro archivo ESB creado o exportado, en mi caso se llama Ejemplo1

35
Lo copiamos y lo pegamos en la carpeta donde esta descomprimidos nuestro Jboss server, en la carpeta deploy asi:
Esta parte es importante que la hagamos para poder correr nuestro ejercicio, ahora si ejecutamos nuestro servidor
en una consola de comandos.
Como vemos esta iniciado, si no les inicia revisar la instalación en la parte inicial del tutorial, ahora vamos a crear una
clase java llamada test, clic en File>New>Class y le pondremos el nombre test, asi:

36
Creamos un paquete en mi caso es ec.edu.utn.ficatest, el nombre es test, clic en finish, luego en la clase creada
copiamos el siguiente código
package ec.edu.utn.ficatest;
import java.util.Properties;
import javax.jms.JMSException;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class Test {
QueueConnection conn;
QueueSession session;
Queue que;
public void setupConnection() throws JMSException, NamingException
{
Properties properties1 = new Properties();
properties1.put(Context.INITIAL_CONTEXT_FACTORY,
"org.jnp.interfaces.NamingContextFactory");
properties1.put(Context.URL_PKG_PREFIXES,
"org.jboss.naming:org.jnp.interfaces");
properties1.put(Context.PROVIDER_URL, "jnp://127.0.0.1:1099");
InitialContext iniCtx = new InitialContext(properties1);
Object tmp = iniCtx.lookup("ConnectionFactory");
QueueConnectionFactory qcf = (QueueConnectionFactory) tmp;
conn = qcf.createQueueConnection();
que = (Queue) iniCtx.lookup("queue/quickstart_helloworld_Request_gw");
session = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
conn.start();
System.out.println("Connection Started");
}
public void stop() throws JMSException

37
{
conn.stop();
session.close();
conn.close();
}
public void sendAMessage(String msg) throws JMSException {
QueueSender send = session.createSender(que);
ObjectMessage tm = session.createObjectMessage(msg);
send.send(tm);
send.close();
}
public static void main(String args[]) throws Exception
{
Test sm = new Test();
sm.setupConnection();
sm.sendAMessage(“Este es mi primer programa”);
sm.stop();
}
}
De modo que nos quede así:

38
Ahora lo que vamos a hacer es enviar la petición a nuestro servidor corriendo el ejercicio, como una aplicación java.
Esto lo hacemos como cliente JMS, entonces no aparecerá:
Y miramos en la consola del servidor y veremos que nos envía el mensaje que escribimos:
Como vemos si está corriendo, ahora en el mismo paquete crearemos el segundo cliente, que lo llamaremos Test2,
creamos una clase java, en nuestro paquete ec.edu.utn.ficatest, entonces nos ubicamos en nuestro paquete clic
derecho>New>Class.

39
Clic en finish y pegamos el siguiente código.
package ec.edu.utn.ficatest;
import org.jboss.soa.esb.message.Message;
import org.jboss.soa.esb.message.format.MessageFactory;
import org.jboss.soa.esb.client.ServiceInvoker;
public class Test2 {
public static void main(String args[]) throws Exception
{
// Setting the ConnectionFactory such that it will use scout
System.setProperty("javax.xml.registry.ConnectionFactoryClass","org.apache.ws.scout.reg
istry.ConnectionFactoryImpl");
if (args.length < 3)
{
System.out.println("Usage SendEsbMessage <category> <name> <text to
send>");
}
Message esbMessage = MessageFactory.getInstance().getMessage();
esbMessage.getBody().add(args[2]);
new ServiceInvoker(args[0], args[1]).deliverAsync(esbMessage);
}
}
Luego ejecutamos como aplicación java y nos mostrará en mensaje, y eso es todo, espero que le sirva este manual,
he tratado de hacerlo sin omitir ningún paso, para que sea de fácil comprensión y les ayude en sus investigaciones,
saludos Stalin Tusa Vitar – Universidad Técnica del Norte – Ibarra – Ecuador ACREDITADA.

Manual Jboss Server,Creación de Proyecto en Eclipse

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (8)

Similaire à Manual Jboss Server,Creación de Proyecto en Eclipse

Similaire à Manual Jboss Server,Creación de Proyecto en Eclipse (20)

Plus de Stalin Eduardo Tusa Vitar

Plus de Stalin Eduardo Tusa Vitar (20)

Dernier

Dernier (15)

Manual Jboss Server,Creación de Proyecto en Eclipse