JPA TopLink

[AlexCollado]

Hola a todos,

estoy realizando una aplicacion web (una inmobiliaria) usando JPA y me he encntrado con un problema.

Tengo inmuebles ya insertados por la aplicacion y se pueden realizar busquedas en las que aparece el listado de los mismos. Pues bien, si se botrra un inmueble, y se realiza una busqueda nueva, efectivamente ya no se ve el inmueble borrado, si se inserta un nuevo inmueble y se hace la bsqueda, se ve el nuevo inmueble PEEEERO si se modifica un inmueble (inmueble.update) luego se va a hacer la busqueda y los datos son los de la busqueda anterior, es decir, sin modificar. En la BBDD los cambios si que se ven reflejados.... es por esto por lo que estoy mas "rallado".

Alguna sugerencia?

Muchas graciasde antemano.

[vdpazmino]

talvez lo puedas solucionar usando el metodo refresh del entitymanager al momento de realizar la busqueda.

salu2

[AlexCollado]

Hola,

No conocía ese metodo del entityManager, pero.... me pide un objeto como parámetro, por lo tanto intuyo que no es lo que busco... supongo q actualizará una entidad JPA en relacion a lo que encuentre en la BBDD no? pero.... ya digo, que no creo q sea lo que busco, ya que yo no busco actualizar una entidad.... es una lista la que obtengo al hacer la busqueda y me gustaría que en la búsqueda ya estuvieran los objetos actuializados, claro.

De todos modos he probado a hacer el em.refresh(listaResultado) despues de hacer la busqueda y me da un error: can not refresh not managed object y me salen todos los inmuebles de la lista obtenida como errores.

No se muy bien que es lo que estará pasando, pero no logro entenderlo....

A ver si se puede solucionar...

Muchas gracias.

[AlexCollado]

Voy a intentar ser algo más concreto en mis explicaciones para ver si así alguien se siente más familiariazado con el tema o lo conoce algo mas...

Estoy haciendo un proyecto para una inmobiliaria. Se necesita:

Una aplicacion Cliente, que es la que va a ver todo el mundo q se meta en la web y que basicamente lo unico que realiza con busquedas en la BBDD (mySql 5) a través del lenguaje EJB QL que usa TopLink en su implementación para JPA.

Otra aplicacion Administración, que es donde los gestores de la inmobiliaria mantendrán la BBDD actualizada, y desde donde se realizarán las insercciones de nuevos inmuebles, borrados y modificaciones de lo que se quiera.

Esto se traduce en 2 aplicaciones, con distinto contexto (necesito q lo tengan para que no se pueda acceder a la una desde la otra y viceversa) cada una con un persistence.xml y unas entidades y unos services, aunque las entidades y los services son los mismos, ya que ambas tocan la misma base de datos (la de cliente solo lee y la de administración escribe y lee).

Yo pensé que como ambas trabajaban sobre una sola BBDD, pues que al hacer las lecturas no habría problemas, ya que una actualizaba y la otra ya leia sobre una BBDD actualizada (y así es, xq al modificar los datos de un inmueble desde la aplicacion de Administracion la BBDD queda bien actualizada). Pero debe ser un problema con JPA o algo relacionado... ya que como digo, la BBDD está actualizada, pero a la aplicacion cliente le da =... el hace la busqueda (q funciona correctamente, sacando los inmuebles que debe) pero los datos no están actualizados conn respecto a la BBDD.

Puede venir el problema por tener 2 unidades de persistencia distintas y que la actualizacion en una unidad no la vea la otra? si es así, hay forma de que 2 aplicaciones con el mismo contexto compartan unidad de persistencia? Lo unico que se me hace raro es que xq al hacer una isnerccion en la BBDD o un borrado no existe ningun problema?? no se....

A ver si alguien puede ayudarme.

Muchas gracias.

[vdpazmino]

Código PHP:

  import javax.persistence.EntityManager; 
import javax.persistence.EntityManagerFactory; 
import javax.persistence.EntityTransaction; 
import javax.persistence.Persistence; 
 
import com.exes.itecel.exception.PersistenceException; 
 
public class PersistenceUtil { 
 
    private static ThreadLocal<EntityManager> threadLocal = new ThreadLocal<EntityManager>(); 
    private static ThreadLocal<EntityTransaction> threadTx = new ThreadLocal<EntityTransaction>(); 
    private static EntityManagerFactory emf = null; 
     
    public static EntityManager getEntityManager() throws PersistenceException{ 
        try { 
            EntityManager em = threadLocal.get(); 
 
            if (em == null || !em.isOpen()) { 
                if (emf == null) { 
                    rebuildEntityManagerFactory(); 
                } 
                em = (emf != null) ? emf.createEntityManager() 
                        : null; 
                threadLocal.set(em); 
            } 
 
            return em; 
        } catch (RuntimeException e) { 
            throw new PersistenceException(e.getMessage(), e); 
        } 
    } 
     
    public static void rebuildEntityManagerFactory() throws PersistenceException{ 
        try { 
            emf = Persistence.createEntityManagerFactory("Itecel"); 
        } catch (RuntimeException e) { 
            throw new PersistenceException(e.getMessage(), e); 
        } 
    } 
     
    public static void closeEntityManager() throws PersistenceException{ 
        try { 
            EntityManager em = threadLocal.get(); 
            threadLocal.remove(); 
 
            if (em != null) { 
                em.close(); 
            } 
        } catch (RuntimeException e) { 
            throw new PersistenceException(e.getMessage(), e); 
        } 
    } 
     
    public static void beginTransaction() throws PersistenceException{ 
        EntityTransaction tx = threadTx.get(); 
        if (tx == null)  
        { 
            tx = getEntityManager().getTransaction(); 
            threadTx.set(tx); 
             
        } 
        tx.begin(); 
    } 
     
    public static void commitTransaction() throws PersistenceException{ 
        try { 
            EntityTransaction tx = threadTx.get(); 
            if ( tx != null && tx.isActive()) 
            {                 
                tx.commit(); 
            }                 
            threadTx.remove(); 
        } catch (RuntimeException e) { 
            throw new PersistenceException(e.getMessage(), e); 
        }             
    } 
     
    public static void rollbackTransaction() throws PersistenceException{ 
        try { 
            EntityTransaction tx = threadTx.get(); 
            threadTx.remove(); 
            if ( tx != null && tx.isActive() ) { 
                tx.rollback(); 
            } 
        } catch (RuntimeException e) { 
            throw new PersistenceException(e.getMessage(), e); 
        } 
    } 
}  
   

yo uso esa clase que se encarga de obtener un entity manager, lo que permite esta clase es que si dos threads se conectan a tu aplicacion esta clase le asigan un entitymanager a cada thread y los almacena para eso uso la clase ThreadLocal, con esto controlo que la aplicacion pueda tener varios usuarios, talvez te pueda ser util

salu2