@Remote public interface SesionEjemploRemote { String getSaludo(String msg); }

Luego realizo la implementación en el módulo EJB.

@Stateless public class SesionEjemplo implements SesionEjemploRemote { @Override public String getSaludo(String msg) { return "Hola: "+msg; } }

Realizo el deploy en mi glassfish y procedo a realizar un cliente standalone.

Para realizar el cliente es necesario importar el jar gf-client.jar que se encuentra en la carpeta lib de la instalación de glassfish 3.0.

Ahora procedo a crear mi solución.

import org.dani.ejb.SesionEjemploRemote; public class EJBAction { private SesionEjemploRemote sesionEjemplo; public SesionEjemploRemote getSesionEjemplo() { return sesionEjemplo; } public void setSesionEjemplo(SesionEjemploRemote sesionEjemplo) { this.sesionEjemplo = sesionEjemplo; } }

Creo los archivos de configuración de spring.

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="ctx" class="org.springframework.context.support.ClassPathXmlApplicationContext"> <constructor-arg> <list> <value>applicationContext.xml</value> </list> </constructor-arg> </bean> </beans>

applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd"> <jee:jndi-lookup id="sesionEjemplo" jndi-name="org.dani.ejb.SesionEjemploRemote"> <jee:environment> java.naming.factory.initial=com.sun.enterprise.naming.SerialInitContextFactory java.naming.factory.url.pkgs=com.sun.enterprise.naming org.omg.CORBA.ORBInitialHost=localhost org.omg.CORBA.ORBInitialPort=3700 </jee:environment> </jee:jndi-lookup> <bean id="ejbAction" class="org.dani.ejemplo.ejb.client.EJBAction"> <property name="sesionEjemplo" ref="sesionEjemplo"/> </bean> </beans>

Por último creo mi clase main.

public class Main { public static void main(String[] args) throws NamingException { Main start=new Main(); EJBAction action=(EJBAction) start.getBean("ejbAction"); SesionEjemploRemote sesion=action.getSesionEjemplo(); System.out.println(sesion.getSaludo("dani")); } private BeanFactory factory; public Main() { BeanFactoryLocator beanFactoryLocator = SingletonBeanFactoryLocator.getInstance(); BeanFactoryReference beanFactoryReference = beanFactoryLocator.useBeanFactory("ctx"); factory = beanFactoryReference.getFactory(); } public Object getBean(String id) { return factory.getBean(id); } }

Adjunto codigo fuente para efectos de estudio.

Comentarios (2)

Cuando hablamos de EJB (Enterprise JavaBeans) indudablemente tenemos que hablar sobre JPA.

Siempre me ha parecido algo rigido el hecho de tener que usar consultas JPQL para generar mis Entity Class, aunque estar este tipo de consultar resulta beneficioso a la hora de cambiar de base de datos completamente ya que para la base de datos es transparente el JPQL. y aporta mucho a a la portabilidad del código con respecto a la base de datos.

Pero en ocasiones necesitamos hacer uso de caracteristicas propias de la base datos para crear consultas mas complejas y nos vemos limitados por el JPQL entonces vemos la necesidad de utilizar consultas SQL nativas y a la vez son mucho más rapidas que las JPQL.

¿Como se utilizan?

Se podría decir que la sintaxis es la siguiente:

Query createNativeQuery(String sql, Class entityClass)

Donde:

Parametro uno: String sql
Es la consulta SQL nativa en el cual deben de ir los campos que conformaran nuestra Entity Class.

Parametro dos: Class entityClass
Es la Entity Class resultante de la consulta nativa SQL.

Ahora como siempre recalco, es tipico de este blog desarrollar un pequeño ejemplito de uso.

Asumiendo, ya tenemos generadas nuestra Entity Class llamada Persona procedremos a generar una lista de "personas".

EntityManagerFactory emf=Persistence.createEntityManagerFactory("nombreUnidadPersistencia");

EntityManager em=em.createEntityManager();
String consulta="select * from persona";
Query q=em.createNativeQuery(consulta,com.paquete.modelo.Persona.class);
Persona[] personas=(Persona[])q.getResultList().toArray(new Persona[0]);

for(Persona p:personas)
System.out.println(p.getPropiedad());

A veces no queremos tener un array de Entity Class sino que queremos obtener un valor escalar proveniente de una función sum, avg, max, etc...

EntityManagerFactory emf=Persistence.createEntityManagerFactory("nombreUnidadPersistencia");

EntityManager em=em.createEntityManager();
String consulta="select sum(campo) from tabla";
Query q=em.createNativeQuery(consulta);
double total=((BigDecimal)((List)q.getSingleResult()).get(0)).doubleValue();

De esta forma podemos trabajar con consultas SQL nativas y poder hacer uso de las capacidades de nuestra base de datos.

Comentarios (5)