Anécdotas de las Curvas del Seno: spring

Mostrando entradas con la etiqueta spring. Mostrar todas las entradas

Glassfish 3.0: Cliente Remoto EJB 3.0

Posted in Etiquetas: cliente, ejb, glassfish, java, jndi, remoto, spring | lunes, noviembre 07, 2011

Hace poco me he visto en la necesidad de crear un cliente sobre unos session beans de EJB 3.0 en un servidor Glassfish 3.0 remoto para un proyecto que estoy realizando sobre Eclipse RAP.

Esta vez realizare un pequeño ejemplo sobre como llevar a cabo la tarea apoyandome, como siempre, de Spring 3.0 he invocare un servicio a través de JNDI.

Primeramente creare un módulo EJB el cual creare una interfaz remota (es necesario que sea remota si se va a acceder al servicio fuera del contenedor). Si bien en J2EE 6 ya no es necesario utilizar interfaces a mi me gusta mas de esa manera para que no quede al descubierto la implementación de la solución y que a su vez al modulo que invocara el servicio, una interfaz le resulta mas simple usar.

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

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.

Creo los archivos de configuración de spring.

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.

Adjunto codigo fuente para efectos de estudio.

Comentarios (2)

JSF 2.0: Error Handling

Posted in Etiquetas: error handling, jsf 2.0, primefaces, spring | viernes, octubre 07, 2011

Ya había realizado un post sobre como manejar las excepciones en JSF apoyandome en richfaces, pero lo hicen pensando que aún seguia utilizando JSF 1.2, esta vez lo haré casi de forma similar pero esta vez para la versión 2.0 de JSF y apoyandome con primefaces y usando un poco de spring para poder enviar los errores al contexto de la aplicación.

Este post será muy similar a como se manejan los errores como en swing, que será implementando dos clases que capturan las excepciones en tiempo de ejecucion.

public class ExceptionWrapper extends ExceptionHandlerWrapper{

private ExceptionHandler wrapper;
    private IManagedBean bean;

public ExceptionWrapper(ExceptionHandler wrapper) {
        this.wrapper=wrapper;
        bean=(IManagedBean) FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance()).getBean("managedBean");
    }

@Override
    public ExceptionHandler getWrapped() {
        return wrapper;
    }

@Override
    public void handle() throws FacesException {
        Iterator<ExceptionQueuedEvent> i=getUnhandledExceptionQueuedEvents().iterator();
        while(i.hasNext()) {
            ExceptionQueuedEvent evt=i.next();
            ExceptionQueuedEventContext context = (ExceptionQueuedEventContext) evt.getSource();

Throwable t=context.getException();
            try{                
                String msgDetail=t.getMessage();
                String msgSummary=t.getCause().getMessage();
                bean.addError(msgDetail, msgSummary);
            }
            finally {
                i.remove();
            }            
        }
        getWrapped().handle();
    }

}

Luego el factory

Ahora hay que registrar el exception factory en el faces-config.xml

Mi bean que implementa la funcionalidad para enviar los mensajes al contexto de la aplicacion sera asi:

No explicare como configurar el bean anterior con spring ya que para ello ya he abordado el tema bastante.
Mi managed bean quedara de la siguiente manera

La plantilla la defino de la siguiente manera
Y la pagina implementando la plantilla

El resultado seria así

Adjunto codigo fuente para efectos de estudio.

Comentarios (0)

Inyectar objetos JSF 2.0 en Custom Converters

Posted in Etiquetas: converter, jsf 2.0, spring | viernes, octubre 07, 2011

Ya en una entrada previa había explicado que son los convertidores en JSF y como implementarlos, esta vez lo haré con JSF 2.0 e inyectare el acceso a datos a través de Spring.

La clave de esto es utilizar el FacesContextUtils.

De esta forma ya no es necesario registrar el converter en el archivo faces-config.xml y puede utilizarse para cualquier tipo de componente.

Comentarios (0)

Integracion de Liquibase con Spring y JPA

Posted in Etiquetas: base de datos, java, jpa, liquibase, postgresql, software, spring, versionamiento | miércoles, octubre 05, 2011

¿Qué es Liquibase?

Liquibase, es una libreria opensource para gestionar los cambios en base de datos. En la etapa de desarrollo de un sistema casi como norma debe versionarse el código fuente, pero no había un mecanismo para llevar un control de los cambios en la estructura de la base de datos y de esta necesidad nace liquibase.

En un equipo de desarrollo es habitual que cada miembro realice procedimientos almacenados, vistas o cambios en las estructuras de las tablas en función de las funciones que este desarrollando y al momento de integrar todo se vuelve un quilombo. Con liquibase los cambios se realizan a través de un archivo de cambios el cual se sincroniza con los demás miembros del equipo, de esta forma los cambios no se hacen directamente a la base de datos sino desde la aplicación al momento de su ejecución.

Desarrollare un pequeño ejemplo de como implementar esta libreria con Spring y JPA, del lado de la base de datos utilizare PostgreSQL. Supondremos que ya tenemos creado nuestro acceso a datos y procedemos a configurar el contexto de spring.

<tx:annotation-driven transaction-manager="transactionManager"/>
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory"/>
    <property name="dataSource" ref="dataSource"/>
</bean>

Ahora se debe configurar el archivo donde se declaran los cambios en la base de datos.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog/1.9" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog/1.9 http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-1.9.xsd">
    <preConditions>
        <dbms type="postgresql" />
    </preConditions>

<createTable tableName="project">
            <column name="id" type="int" autoIncrement="true">
                <constraints nullable="false" primaryKey="true" />
            </column>
            <column name="description" type="varchar" />
            <column name="start_date" type="datetime" />
            <column name="end_date" type="datetime" />
            <column name="fk_responsible" type="int">
                <constraints foreignKeyName="project-responsible" references="responsible"/>
            </column>
        </createTable>
        <sql>insert into responsible(name) values('dani');</sql>
    </changeSet>

Cuando ejecutemos la aplicación liquibase intentara primeramente hacer efectivos los cambios configurados en db-changelog.xml

En el caso de JPA, es de tener en cuenta que siempre hay que actualizar manualmente los Entity class, ya que no es parte de las funciones de liquibase.

Adjunto código fuente para efectos de estudio.

Comentarios (1)opiniones, ¿cual es la tuya?

Lazy Loading en ice:dataTable con ICEfaces

Posted in Etiquetas: 2.0, icefaces, java, jsf, lazy loading, spring | viernes, septiembre 30, 2011

¿Que és lazy loading? pues traduciendolo a mi manera en español podria referirse a carga ociosa, es decir carga ociosa de datos. ¿para que se utiliza? sucede que cuando se utiliza un dataTable con JSF siempre se le envia la lista completa de registros que se obtienen de una busqueda en la base de datos y los carga todos de una vez en la tabla para usarlos con un paginador, ¿pero que sucede si tenemos una busqueda de miles de registros? no podemos carga toda esa lista en el dataTable, entonces surge la necesidad de solo traer que necesitamos ver en el paginador por bloques.

Algunos diran que ya existe un articulo en la documentación oficial de ICEfaces para realizar un lazy loading, pero el punto es que es muy dificil de entender ya que agregan otras funcionalidades que estan demas y mi objetivo es simplificar el entendimiento de la técnica.

En esta ocasión utilizare netbeans, tomcat y spring para el acceso a datos.

Utilizare tambien la tabla "Manufacturer" de la base de datos derby "Sample" embebida en netbeans, ya que es la unica que tiene algunos cuantos registros para efectos de prueba.

No entrare en detalle de como configurar un proyecto JSF con ICEfaces ni de como integrarlo con Spring para el acceso a datos, supondre que se ha leido las entradas respectivas.

Suponiendo que ya se ha generado el entity de la tabla Manufacturer creo mi acceso a datos.

Luego la implementación

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.dani.ejemplo.dao;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import org.springframework.orm.jpa.JpaCallback;
import org.springframework.orm.jpa.support.JpaDaoSupport;

/**
 *
 * @author dherrera
 */
public class DerbyImpl extends JpaDaoSupport implements DerbyDAO{

public int getTotalManufacturers() {
        Long count=(Long) getJpaTemplate().find("Select count(m) From Manufacturer m").get(0);
        return count.intValue();
    }

public List<Manufacturer> getFindManufacturers(final int firstRow, final int max) {
        return getJpaTemplate().execute(new JpaCallback<List<Manufacturer>>() {

public List<Manufacturer> doInJpa(EntityManager em) throws PersistenceException {
                return em.createQuery("Select m From Manufacturer m").setFirstResult(firstRow).
                        setMaxResults(max).
                        getResultList();
            }
        });
    }

}

Luego creo mi configuracion en spring

<tx:annotation-driven transaction-manager="transactionManager"/>
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="dataSource" ref="dataSource"/>
    <property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

<jee:jndi-lookup id="dataSource" jndi-name="jdbc/derby"/>

</beans>

Ahora la parte fundamental es crear un custom DataModel

package org.dani.ejemplo.web.model;

import java.util.List;
import javax.faces.model.DataModel;

/**
 *
 * @author dherrera
 */
public class LazyModel<T> extends DataModel{

List<T> list;
    private int pageSize;
    private int totalRows;
    private int rowIndex = -1;

public LazyModel(int totalRows,int pageSize, List<T> list) {
        super();
        this.pageSize=pageSize;
        this.totalRows=totalRows;
        this.list=list;
    }

@Override
    public boolean isRowAvailable() {
        if(list == null)
            return false;

int index = getRowIndex();
        return (index >=0 && index < list.size());
    }

@Override
    public int getRowCount() {
        return totalRows;
    }

@Override
    public Object getRowData() {
        if(list == null)
            return null;
        else if(!isRowAvailable())
            throw new IllegalArgumentException();
        else {
            int dataIndex = getRowIndex();
            return list.get(dataIndex);
        }
    }

@Override
    public int getRowIndex() {
        return (rowIndex % pageSize);
    }

@Override
    public void setRowIndex(int i) {
        rowIndex=i;
    }

@Override
    public Object getWrappedData() {
        return list;
    }

@Override
    public void setWrappedData(Object o) {
        this.list=(List<T>) o;
    }

}

Ahora me dedico a crear los managed beans.

package org.dani.ejemplo.web;

import com.icesoft.faces.component.datapaginator.DataPaginator;
import java.io.Serializable;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;
import javax.faces.event.ActionEvent;
import org.dani.ejemplo.dao.DerbyDAO;
import org.dani.ejemplo.dao.Manufacturer;
import org.dani.ejemplo.web.model.LazyModel;

/**
 *
 * @author dherrera
 */
@ManagedBean
@ViewScoped
public class ViewBean extends AbstractManagedBean implements Serializable{

@ManagedProperty("#{dao}")
    private DerbyDAO dao;
    private int firstRow;
    private int pageSize;

@PostConstruct
    public void init() {
        firstRow=1;
        pageSize=Integer.valueOf(getBundleValue("paginator.page_size"));
    }

public LazyModel<Manufacturer> getModel() {
        int totalRows=dao.getTotalManufacturers();
        
        List<Manufacturer> list=dao.getFindManufacturers(firstRow, pageSize);
        return new LazyModel<Manufacturer>(totalRows, pageSize, list);
    }

public void pageListener(ActionEvent evt) {
        DataPaginator paginator=(DataPaginator) evt.getSource();
        this.firstRow=paginator.getFirstRow();
    }

public void setDao(DerbyDAO dao) {
        this.dao = dao;
    }
}

Por ultimo el diseño de la página xhtml

<?xml version='1.0' encoding='UTF-8' ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:ui="http://java.sun.com/jsf/facelets"
	xmlns:f="http://java.sun.com/jsf/core"
	xmlns:h="http://java.sun.com/jsf/html"
        xmlns:icecore="http://www.icefaces.org/icefaces/core"
        xmlns:ace="http://www.icefaces.org/icefaces/components"
        xmlns:ice="http://www.icesoft.com/icefaces/component"
       >
    <h:head>
        <title>ICEfaces 2</title>
        <link rel="stylesheet" type="text/css" href="./xmlhttp/css/rime/rime.css"/>
    </h:head>
    <h:body styleClass="ice-skin-rime">
      <h:form id="form">
          <ice:outputConnectionStatus/>
          <ice:dataPaginator for="tabla"
                             actionListener="#{viewBean.pageListener}"
                             paginator="true" fastStep="#{setting['paginator.page_size']}" paginatorMaxPages="#{setting['paginator.max_pages']}">
            <f:facet name="first">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-first.gif"/>
                </f:facet>
                <f:facet name="last">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-last.gif"/>
                </f:facet>
                <f:facet name="previous">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-previous.gif"/>
                </f:facet>
                <f:facet name="next">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-next.gif"/>
                </f:facet>
                <f:facet name="fastforward">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-ff.gif"/>
                </f:facet>
                <f:facet name="fastrewind">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-fr.gif"/>
                </f:facet>
          </ice:dataPaginator>

<ice:dataTable id="tabla" value="#{viewBean.model}" var="m"
                         rows="#{setting['paginator.page_size']}">
              <ice:column>
                  <f:facet name="header"><ice:outputText value="#{setting['customer.name']}"/></f:facet>
                  <ice:outputText value="#{m.name}"/>
              </ice:column>
              <ice:column>
                  <f:facet name="header"><ice:outputText value="#{setting['customer.email']}"/></f:facet>
                  <ice:outputText value="#{m.email}"/>
              </ice:column>
          </ice:dataTable>
      </h:form>
    </h:body>
    <h:outputStylesheet library="org.icefaces.component.skins" name="rime.css" />
</html>

El resultado sera el siguiente

A través del trace se puede observar que por cada vez que se cambia de pagina se obtiene el bloque de registros que interesa.

Adjunto el codigo fuente para efectos de estudio.

Comentarios (2)

Spring 3.0 y JSF 2.0

Posted in Etiquetas: 2.0, 3.0, hibernate, java, jpa, jsf, spring | lunes, septiembre 26, 2011

Hace poco me había planteado la necesidad de utilizar una capa de servicios potente como EJB 3.0 pero sin utilizar un servidor de aplicaciones sino un simple tomcat, ya que este no es un contenedor de EJB. Así que me decidi por la combinación Spring 3.0 y JSF 2.0, la reseta de implementación JPA 2.0 para Spring utilizare Hibernate. Aca desarrollare un ejemplo de como utilizar las dos tecnologías antes mencionadas. Antes que nada es necesario configurar un datasource el cual accederemos desde spring vía jndi, para el ejemplo accederemos a la base de datos derby que esta embebida con netbeans. En el archivo contex.xml del tomcat creamos el datasource.

Ahora procedemos con la capa de acceso a datos generando los entities de las tablas "customer" y "discount_code". Modificamos el archivo persistence.xml que debera quedar de la siguiente manera:
Creare la interfaz con la con la cual las transacciones de spring funcionaran

Luego creo la implementación

El siguiente paso es configurar el archivo de spring applicationContex.xml en la ubicación WEB-INF

<?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:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
          http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
          http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
">

<bean id="dao" class="org.dani.ejemplo.dao.DerbyDAOImpl">
    <property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

<jee:jndi-lookup id="dataSource" jndi-name="jdbc/derby"/>

<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="persistenceUnitName" value="SpringWebPU"/>
    <property name="jpaDialect">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
    </property>
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
    </property>
    <property name="loadTimeWeaver">
        <bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/>
    </property>
</bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="dataSource" ref="dataSource"/>
    <property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

</beans>

Ahora vamos con la parte de la vista. Se debe configurar el proyecto web para que JSF pueda interactuar con Spring. Se agregan las siguientes líneas en el archivo web.xml:

Luego se debe configurar el archivo faces-config.xml para que spring pueda realizar inyección de dependencias a través de el lenguaje de extextareasiones de JSF, se debe crear sino existe.
Luego creo el managed bean

Por ultimo desplegamos la java.util.Lista "customers" del managed bean en nuestra página xhtml

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core">
    <h:head>
        <title>#{msg['jsf.titulo']}</title>
    </h:head>
    <h:body>
        <h:form>
            <h2>#{msg['jsf.titulo']}</h2>

<h:dataTable value="#{beanManager.customers}" var="c" border="1">
                <h:column>
                    <f:facet name="header">
                        <h:outputText value="#{msg['customer.label.name']}"/>
                    </f:facet>
                    <h:outputText value="#{c.name}"/>
                </h:column>
                <h:column>
                    <f:facet name="header">
                        <h:outputText value="#{msg['customer.label.email']}"/>
                    </f:facet>
                    <h:outputText value="#{c.email}"/>
                </h:column>
                <h:column>
                    <f:facet name="header">
                        <h:outputText value="#{msg['customer.label.state']}"/>
                    </f:facet>
                    <h:outputText value="#{c.state}"/>
                </h:column>
                <h:column>
                    <f:facet name="header">
                        <h:outputText value="#{msg['discountcode.label.code']}"/>
                    </f:facet>
                    <h:outputText value="#{c.discountCode.discountCode}"/>
                </h:column>
            </h:dataTable>
        </h:form>
    </h:body>
</html>

El resultado sera el siguiente

Adjunto el código fuente para efectos de estudio.

Comentarios (1)opiniones, ¿cual es la tuya?

Spring 3.0 e Hibernate JPA 2.0

Posted in Etiquetas: hibernate, jpa, spring | lunes, septiembre 19, 2011

Hace unos días me decici a integrar Spring con la implementacion JPA 2.0 de Hibernate. En esta ocasión la versión de spring que usare es la 3.0 de Hibernate 3.6.7 y la base de datos de ejemplo (derby - sample) que se encuentra embebida en Netbeans.

Los jars necesarios para utilizar la implementación JPA de Hibernate, en donde {hibernate-path} es la ruta donde esta descomprimido la distribución final de Hibernate 3.6.7:

{hibernate-path}\lib\jpa\hibernate-jpa-2.0-api-1.0.1.Final.jar
{hibernate-path}\lib\required\antlr-2.7.6.jar
{hibernate-path}\lib\required\commons-collections-3.1.jar
{hibernate-path}\lib\required\dom4j-1.6.1.jar
{hibernate-path}\lib\required\javassist-3.12.0.GA.jar
{hibernate-path}\lib\required\jta-1.1.jar
{hibernate-path}\lib\required\slf4j-api-1.6.1.jar
{hibernate-path}\hibernate3.jar

Como nota aclaratoria es tambien necesario agregar el jar aopalliance.jar para poder utilizar la anotación @Transactional, en este ejemplo no realizaremos un CRUD por esa razón no se incluye.

Y la versión 3.0 de Spring que viene con Netbeans.

Las tablas que utilizare son "Product", "Manufacturer" y "Product_Code", al mapear las tablas con el asistente de Netbeans obtengo sus clases

La unidad de persistencia debera quedar de la siguiente forma:




  
    org.hibernate.ejb.HibernatePersistence
    org.dani.ejemplo.jpa.dao.ProductCode
    org.dani.ejemplo.jpa.dao.Product
    org.dani.ejemplo.jpa.dao.Manufacturer

Creo el acceso a datos para las tablas.

package org.dani.ejemplo.jpa.dao;
import org.springframework.orm.jpa.support.JpaDaoSupport;
import java.util.*;
/**
 *
 * @author dherrera
 */
public class DerbySampleDAO extends JpaDaoSupport{

    public List getAllProducts() {
        return getJpaTemplate().find("Select p From Product p");
    }
}

Luego procedo a configurar el archivo de configuración de spring

Y la forma de uso sera de la siguiente forma:

package org.dani.ejemplo.jpa;

import java.util.List;
import org.dani.ejemplo.jpa.dao.DerbySampleDAO;
import org.dani.ejemplo.jpa.dao.Product;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 *
 * @author dherrera
 */
public class Init {

    public static void main(String[] args) {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("/org/dani/ejemplo/jpa/applicationContext.xml");
        DerbySampleDAO dao=(DerbySampleDAO) ctx.getBean("dao");
        List list=dao.getAllProducts();
        for(Product product:list)
            System.out.println(product.getDescription());
    }
}

Adjunto el código fuente de ejemplo aca.

Comentarios (0)

Glassfish 3.0: Cliente Remoto EJB 3.0

JSF 2.0: Error Handling

Inyectar objetos JSF 2.0 en Custom Converters

Integracion de Liquibase con Spring y JPA

Lazy Loading en ice:dataTable con ICEfaces

Spring 3.0 y JSF 2.0

Spring 3.0 e Hibernate JPA 2.0

Acerca de mi

Busca en el blog

Seguidores

Archivo de blog