EJB´s y Orion

0
36647

Creación y Despliegue de un EJB básico en Orión

He estado probando el servidor de aplicaciones Orion y la verdad es que es
muy sencillito.

Una de las principales ventajas de las que me han hablado, es que si te lo
montas en local y respetas la estructura de ficheros que te propone, puedes
crear servlets y EJBs y probarlos sin necesidad de desplegarlos.


Lo que he hecho ha sido seguir la guía para la creación de un EJB básico y
me he quedado francamente impresionado porque, y es una de las pocas veces en mi
vida, que siguiendo las instrucciones y sin trucos y dar por hecho que sabes
ademas 150 millones de cosas más, he conseguido poner el sistema en marcha en
menos de una hora

Vamos a ir pasito a pasito:

Primero nos lo descargamos y lo instalamos. Al instalarlo tenemos que
ejecutar un comando para introducir la password

 

 
Instalar el
JSDK de JAVA

Asegurarse de tener la variable de entorno JAVA_HOME apuntando al directorio de instalación de Java
Descargarse ORION de www.orionserver.com
Descomprimir el fichero en un directorio
Ejecutar el comando (añadir password)     
Java –jar orion.jar –install
Arrancar el servidor con     
Java –jar orion.jar


Para probar instalación, desde una navegador, atacar al servidor.

El puerto por defecto es el 80, si se desea cambia, ir al fichero 
\orion\config\default-web-site.xml

y cambiar el parámetro
<web-site host=»[ALL]» port=»8090″
display-name=»Default Orion WebSite»>


La estructura de ficheros que vamos a construir es:

 

Creamos el interfaz de nuestro EJB (ejemplorc.java)

 

package ejemplorc.ejb;
import
java.rmi.*;
import
javax.ejb.*;
public
interface ejemplorc extends EJBObject
{
  
public String muestraMensaje() throws RemoteException;
}

Creeamos el Bean (ejemplorcBean.java)

package ejemplorc.ejb;

import java.rmi.*;
import javax.ejb.*;

public class ejemplorcBean extends Object implements SessionBean {

public String muestraMensaje() {
return «<h1>Este es el mensaje de Roberto</h1>»;
}

public void ejbCreate()
throws EJBException, RemoteException {
}

public void ejbActivate()
throws EJBException, RemoteException {
}

public void ejbPassivate()
throws EJBException, RemoteException {
}

public void ejbRemove()
throws EJBException, RemoteException {
}

public void setSessionContext(SessionContext context)
throws EJBException, RemoteException {
}

}

Creamos el Interfaz Home (ejemplorcHome.java)

package ejemplorc.ejb;

import java.rmi.*;
import javax.ejb.*;

public interface ejemplorcHome extends EJBHome 

{
public ejemplorc create() throws CreateException, RemoteException;
}

 

Creamos el descriptor del EJB (ejb-jar.xml) 

<?xml version=»1.0″?>
<!DOCTYPE ejb-jar PUBLIC «-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 1.1//EN» «http://java.sun.com/j2ee/dtds/ejb-jar_1_1.dtd»>

<ejb-jar>
<description></description>
<enterprise-beans>
<session>
<display-name>El ejemplorc.ejb.ejemplorc Bean de Sesion</display-name>
<ejb-name>ejemplorc.ejb.ejemplorc</ejb-name>
<home>ejemplorc.ejb.ejemplorcHome</home>
<remote>ejemplorc.ejb.ejemplorc</remote>
<ejb-class>ejemplorc.ejb.ejemplorcBean</ejb-class>
<session-type>Stateless</session-type>
</session>
</enterprise-beans>

<assembly-descriptor>
<security-role>
<description>Users</description>
<role-name>users</role-name>
</security-role>
</assembly-descriptor>

</ejb-jar>

Creamos el Servlet que atacará
al EJB
(aunque ya veremos en otra ocasión que no es el modo más
adecuado). Advertencia: Usad este código para
probar que funciona …. para nada más …. porque no es muy adecuado
el modo en que se crea el objeto (compraos un libro de EJB´s)

(ejemplorcServlet.java)

package ejemplorc.web;

import java.io.IOException;
import java.util.Date;
import java.util.Properties;
import javax.naming.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.rmi.PortableRemoteObject;

import ejemplorc.ejb.*;

public class ejemplorcServlet extends HttpServlet 
{

// constructor
public ejemplorcServlet() 
{
super();
trace(«<init>»);
}

// A reference to the remote `Hello’ object
protected ejemplorc ejemplo;

// Initializes this servlet
public void init(ServletConfig config) throws ServletException 
{
super.init(config);
trace(«init»);

// Get the initial JNDI context using our settings
Context context;
try 
{
context = new InitialContext();
}
catch (Throwable exception) 
{
throw new ServletException(«Unable to get initial JNDI context: » + exception.toString());
}

// Get a reference to the Hello home interface
ejemplorcHome miHome;

try 
{
Object boundObject = context.lookup(«java:comp/env/ejb/ejemplorcHome«);
miHome = (ejemplorcHome)PortableRemoteObject.narrow(boundObject,ejemplorcHome.class);
}
catch (Throwable exception) 
{
throw new ServletException(«Unable to get home interface: » + exception.toString());
}

// Get a reference to a Hello instance
try 
{
ejemplo = miHome.create();
}
catch (Throwable exception) 
{
throw new ServletException(«Unable to create Hello instance: » + exception.toString());
}

// Insanity check: Make sure we have a valid reference
if (ejemplo == null) {
throw new ServletException( «Unable to create Hello instance, create() returned null»);
}
}

// Handles the HTTP GET request
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
trace(«doGet»);

ServletOutputStream out = response.getOutputStream();

response.setContentType(«text/html»);

// Get the answer from the bean
String answer;
try {
answer = ejemplo.muestraMensaje();
}
catch (Throwable exception) {
out.println(«<HTML><BODY bgcolor=\»#FFFFFF\»>»);
out.println(«Time stamp: » + new Date().toString());
out.println(«<BR>Hello type: » + ejemplo.getClass().getName());
out.println(«Error calling the ejemplorc bean»);
out.println(exception.toString());
out.println(«</BODY>»);
out.println(«</HTML>»);
return;
}

out.println(«<HTML><BODY bgcolor=\»#FFFFFF\»>»);
out.println(«Time stamp: » + new Date().toString());
out.println(«<BR>Hello type: » + ejemplo.getClass().getName());
out.println(«<BR>Answer: » + answer);
out.println(«</BODY>»);
out.println(«</HTML>»);
}

// Displays a trace message to System.out
private void trace(String methodName) {
System.out.print(methodName);
System.out.println(«() called»);
}

}

Ahora definimos la Web App (web.xml)

<?xml version=»1.0″?>
<!DOCTYPE application PUBLIC «-//Sun Microsystems, Inc.//DTD J2EE Application 1.2//EN» «http://java.sun.com/j2ee/dtds/application_1_2.dtd»>

<application>

<!– The display-name element specifies the human-readable name of this
application. It is not used to identify the application. –>

<display-name>ejemplorc</display-name>

<!– The EJB module. All that needs to be specified is the location of the
EJB JAR file. –>

<module>
<ejb>ejemplorc-ejb.jar</ejb>
</module>

<!– The web module. The context-root specifies how the web-application can
be reached from a browser. The web-uri element specifies the location
of the WAR file that contains the web application. –>

<module>
<web>
<web-uri>ejemplorc-web.war</web-uri>
<context-root>/ejemplorc</context-root>
</web>
</module>

</application>

Definimos con el Build para Ant
(que obviamente debemos tener instalado y la variable ANT_HOME apuntando
al directorio de Instalación) (build.xml)

<?xml version=»1.0″?>

<!–

Build file for ‘ejemplorc’, a sample J2EE application which is part of the
Orion Primer. See http://www.jollem.com/orion-primer/ for this Orion tutorial.

Version: $Revision: 4.12 $ $Date: 2001/06/27 10:36:29 $
Author: Ernst de Haan

–>

<project name=»ejemplorc» default=»ear» basedir=».»>

<!– ================================================================== –>
<!– Initialization of all property settings –>
<!– ================================================================== –>

<target name=»init»>
<property name=»name» value=»ejemplorc» />
<property name=»src.dir» value=»src» />
<property name=»etc.dir» value=»etc» />
<property name=»lib.dir» value=»lib» />
<property name=»build.dir» value=»build» />
<property name=»orion.dir» value=»c:/orion/orion» />
<property name=»build.compiler» value=»classic» />

<property name=»ejb.jar» value=»${orion.dir}/ejb.jar» />
<property name=»jndi.jar» value=»${orion.dir}/jndi.jar» />
<property name=»orion.jar» value=»${orion.dir}/orion.jar» />

<property name=»ejb-classes.dest» value=»${lib.dir}/ejb» />
<property name=»web-classes.dest» value=»${lib.dir}/web/WEB-INF/classes» />

<property name=»ejb.classpath» value=»${ejb.jar}» />
<property name=»web.classpath» value=»${ejb-classes.dest}:${ejb.jar}:${jndi.jar}:${orion.jar}» />

<property name=»pkg-dist.name» value=»${name}-pkg» />

<property name=»deploy.ormi» value=»»/>
<property name=»deploy.username» value=»»/>
<property name=»deploy.password» value=»»/>
</target>

<!– ================================================================== –>
<!– Removes all created files and directories –>
<!– ================================================================== –>

<target name=»clean» depends=»init»>
<delete dir=»${lib.dir}» />
<delete dir=»${build.dir}» />
</target>

<!– ================================================================== –>
<!– Makes sure the needed directory structure is in place –>
<!– ================================================================== –>

<target name=»prepare» depends=»init»>
<mkdir dir=»${lib.dir}» />
<mkdir dir=»${lib.dir}/ejb» />
<mkdir dir=»${lib.dir}/ejb/META-INF» />
<mkdir dir=»${lib.dir}/web» />
<mkdir dir=»${lib.dir}/web/WEB-INF» />
<mkdir dir=»${lib.dir}/web/WEB-INF/classes» />
<mkdir dir=»${lib.dir}/j2ee» />
<mkdir dir=»${lib.dir}/META-INF» />
<mkdir dir=»${build.dir}» />
</target>

<!– ================================================================== –>
<!– Compilation of the EJB part of the application –>
<!– ================================================================== –>

<target name=»ejb-classes» depends=»prepare»>
<javac srcdir=»${src.dir}»
destdir=»${ejb-classes.dest}»
includes=»java/ejemplorc/ejb/**»
classpath=»${ejb.classpath}» />
</target>

<target name=»ejb-meta-inf» depends=»prepare»>
<copy file=»${etc.dir}/ejb-jar.xml»
tofile=»${lib.dir}/ejb/META-INF/ejb-jar.xml» />
</target>

<target name=»ejb-jar» depends=»ejb-classes,ejb-meta-inf»>
<jar jarfile=»${build.dir}/${name}-ejb.jar»
basedir=»${lib.dir}/ejb» />
</target>

<!– ================================================================== –>
<!– Compilation of the web part of the application –>
<!– ================================================================== –>

<target name=»web-classes» depends=»prepare»>
<javac srcdir=»${src.dir}»
destdir=»${lib.dir}/web/WEB-INF/classes»
includes=»java/ejemplorc/web/**»
classpath=»${web.classpath}» />
</target>

<target name=»web-web-inf» depends=»prepare»>
<copy file=»${etc.dir}/web.xml»
tofile=»${lib.dir}/web/WEB-INF/web.xml» />
</target>

<target name=»war» depends=»web-classes,web-web-inf»>
<jar jarfile=»${build.dir}/${name}-web.war»
basedir=»${lib.dir}/web» />
</target>

<!– ================================================================== –>
<!– Compilation of the complete J2EE application (both web and EJB) –>
<!– ================================================================== –>

<target name=»j2ee-meta-inf» depends=»prepare»>
<copy file=»${etc.dir}/application.xml»
tofile=»${lib.dir}/j2ee/META-INF/application.xml» />
</target>

<target name=»ear» depends=»ejb-jar,war,j2ee-meta-inf»>
<copy file=»${build.dir}/${name}-ejb.jar»
tofile=»${lib.dir}/j2ee/${name}-ejb.jar» />
<copy file=»${build.dir}/${name}-web.war»
tofile=»${lib.dir}/j2ee/${name}-web.war» />
<jar jarfile=»${build.dir}/${name}.ear»
basedir=»${lib.dir}/j2ee» />
</target>

<!– ================================================================== –>
<!– Generates a GZip’ed tar source distribution –>
<!– ================================================================== –>

<target name=»pkg-dist» depends=»prepare»>

<mkdir dir=»${build.dir}/${name}» />

<copy todir=»${build.dir}/${name}»>
<fileset dir=».» includes=»${src.dir}/java/**» />
<fileset dir=».» includes=»${etc.dir}/**» />
<fileset dir=».» includes=»build.xml» />
</copy>

<tar tarfile=»${build.dir}/${pkg-dist.name}.tar»
basedir=»${build.dir}»
includes=»${name}/**» />

<gzip src=»/wp-content/uploads/tutorial-data/${build.dir}/${pkg-dist.name}.tar»
zipfile=»${build.dir}/${pkg-dist.name}.tar.gz» />

<delete file=»${build.dir}/${pkg-dist.name}.tar» />

<zip zipfile=»${build.dir}/${pkg-dist.name}.zip»
basedir=»${build.dir}»
includes=»${name}/**» />

<delete dir=»${build.dir}/${name}» />
</target>

<!– ================================================================== –>
<!– Generate as many files as you can! 😉 –>
<!– ================================================================== –>

<target name=»all» depends=»ear,pkg-dist» />

<!– ================================================================== –>
<!– Deploy the application –>
<!– ================================================================== –>

<target name=»deploy» depends=»all»>
<java classname=»com.evermind.client.orion.OrionConsoleAdmin» fork=»yes»>
<arg value=»${deploy.ormi}» />
<arg value=»${deploy.username}» />
<arg value=»${deploy.password}» />
<arg value=»-deploy» />
<arg value=»-file» />
<arg value=»${build.dir}/${name}.ear» />
<arg value=»-deploymentName» />
<arg value=»${name}» />
<classpath>
<pathelement location=»${orion.jar}» />
<pathelement location=»${ejb.jar}» />
<pathelement location=»${jndi.jar}» />
</classpath>
</java>
</target>

</project>

Ir al directorio donde esta el Build.xml y ejecutar
Ant.exe
Ahora damos de alta la Web App en (orion/config/default-web-site.xml)

<?xml version=»1.0″?>
<!DOCTYPE application-server PUBLIC «Orion Application Server Config» «http://www.orionserver.com/dtds/application-server.dtd»>

<application-server
application-directory=»../applications»
deployment-directory=»../application-deployments»
>
<rmi-config path=»./rmi.xml» />
<!– JMS-server config link, uncomment to activate the JMS service –>
<!– <jms-config path=»./jms.xml» /> –>
<log>
<file path=»../log/server.log» />
</log>

<global-application name=»default» path=»application.xml» />

<global-web-app-config path=»global-web-application.xml» />
<web-site path=»./default-web-site.xml» />

<!– Compiler, activate this to specify an alternative compiler such
as jikes for EJB/JSP compiling. –>
<!– <compiler executable=»jikes» classpath=»/myjdkdir/jre/lib/rt.jar» /> –>

<application name=»ejemplorc» path=»C:\orion\ejemplorc\build\ejemplorc.ear» />

</application-server>


 
Nos generará la estructura de ficheros auxiliar y el EAR
destino

 

Y decimos en el server.xml donde esta el ear


Y ya podemos comprobar el resultado

 

Orion también dispone de una consola gráfica para
administrar sus ficheros de configuración. Te advierte que esta en
alpha, aunque a mi no me ha roto nada.

java -jar orion.jar -console

 


 

Sobre el Autor ..

Dejar respuesta

Please enter your comment!
Please enter your name here