Foro de elhacker.net

Programación => Java => Mensaje iniciado por: visualfree en 9 Julio 2015, 16:05 pm



Título: JPA Ayuda plz.
Publicado por: visualfree en 9 Julio 2015, 16:05 pm
Estimados Amigos, agradeceria me pueda ayudar , primero detallo:

TENGO LO SIGUIENTE:

Código:
package model.jpa;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
@Entity
public class Usuarios implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id_usuario;
    private String nombre;
    private String estado;
    @ManyToMany(mappedBy="usuarios")
    private List<Cuestionarios> cuestionarios=new ArrayList<Cuestionarios>();
    public List<Cuestionarios> getCuestionarios() {
        return cuestionarios;
    }
    public void setCuestionarios(List<Cuestionarios> cuestionarios) {
        this.cuestionarios = cuestionarios;
    }
    public Integer getId_usuario() {
        return id_usuario;
    }
    public void setId_usuario(Integer id_usuario) {
        this.id_usuario = id_usuario;
    }
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public String getEstado() {
        return estado;
    }
    public void setEstado(String estado) {
        this.estado = estado;
    }
}



Código:
package model.jpa;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
@Entity
public class Cuestionarios implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id_cuestionario;
    private String nombre;
    private String estado;
    @OneToMany(mappedBy="cuestionarios")
    private List<Preguntas> preguntas=new ArrayList<Preguntas>();
    //ASOCIACION DE MUCHOS A MUCHOS ENTRE TABLA USUARIOS Y CUESTIONARIOS
    @ManyToMany
    @JoinTable(name="USUARIOS_CUESTIONARIOS",
            joinColumns=
                    @JoinColumn(name="id_cuestionario"),
            inverseJoinColumns=
                    @JoinColumn(name="id_usuario"))
    private List<Usuarios> usuarios=new ArrayList<Usuarios>();

    public List<Usuarios> getUsuarios() {
        return usuarios;
    }

    public void setUsuarios(List<Usuarios> usuarios) {
        this.usuarios = usuarios;
    }
    public List<Preguntas> getPreguntas() {
        return preguntas;
    }
    public void setPreguntas(List<Preguntas> preguntas) {
        this.preguntas = preguntas;
    }
    public Integer getId_cuestionario() {
        return id_cuestionario;
    }
    public void setId_cuestionario(Integer id_cuestionario) {
        this.id_cuestionario = id_cuestionario;
    }
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public String getEstado() {
        return estado;
    }
    public void setEstado(String estado) {
        this.estado = estado;
    }
}


El resultado de eso , al ejecutar la aplicación es la generación de 3 tablas:

Código:
mysql> describe usuarios;
+------------+--------------+------+-----+---------+-------+
| Field      | Type         | Null | Key | Default | Extra |
+------------+--------------+------+-----+---------+-------+
| ID_USUARIO | int(11)      | NO   | PRI | NULL    |       |
| ESTADO     | varchar(255) | YES  |     | NULL    |       |
| NOMBRE     | varchar(255) | YES  |     | NULL    |       |
+------------+--------------+------+-----+---------+-------+
3 rows in set (0.03 sec)

mysql> describe cuestionarios;
+-----------------+--------------+------+-----+---------+-------+
| Field           | Type         | Null | Key | Default | Extra |
+-----------------+--------------+------+-----+---------+-------+
| ID_CUESTIONARIO | int(11)      | NO   | PRI | NULL    |       |
| ESTADO          | varchar(255) | YES  |     | NULL    |       |
| NOMBRE          | varchar(255) | YES  |     | NULL    |       |
+-----------------+--------------+------+-----+---------+-------+
3 rows in set (0.01 sec)

mysql> describe usuarios_cuestionarios;
+-----------------+---------+------+-----+---------+-------+
| Field           | Type    | Null | Key | Default | Extra |
+-----------------+---------+------+-----+---------+-------+
| id_cuestionario | int(11) | NO   | PRI | NULL    |       |
| id_usuario      | int(11) | NO   | PRI | NULL    |       |
+-----------------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)



Con esto todo bien, agregue los siguientes usuarios:

Código:
mysql> select * from usuarios;
+------------+--------+---------+
| ID_USUARIO | ESTADO | NOMBRE  |
+------------+--------+---------+
|          1 | ACTIVO | RICARDO |
|          2 | ACTIVO | PEDRO   |
|          3 | ACTIVO | ANDRES  |

Los siguientes cuestionarios:

Código:

mysql> select * from CUESTIONARIOS;
+-----------------+--------+--------------------------+
| ID_CUESTIONARIO | ESTADO | NOMBRE                   |
+-----------------+--------+--------------------------+
|               1 | ACTIVO | CUESTIONARIO MATEMATICAS |
|               2 | ACTIVO | CUESTIONARIO CASTELLANO  |
|               3 | ACTIVO | CUESTIONARIO INGLES      |
+-----------------+--------+--------------------------+
3 rows in set (0.00 sec)



Ahora necesito decir que ricardo y pedro hacen el cuestionario de matemáticas e ingles, teóricamente seria:

Código:
Tabla usuarios_cuestionarios
---------------------------------
id_usuario,id_cuestionario
1             ,1
1             ,3
2             ,1
2             ,3



Ahora lo que estoy tratando de hacer desde mi código Java para lograr esto es lo siguiente:

Código:

     EntityManagerFactory emf=Persistence.createEntityManagerFactory("JPA_EJB_FULLPU");
            EntityManager em=emf.createEntityManager();
            Usuarios u=new Usuarios();
            //BUSCO EL ID DEL USUARIO
            u=em.find(Usuarios.class,1);
            Cuestionarios c=new Cuestionarios();
            //BUSCO EL ID DEL CUESTIONARIO
            c=em.find(Cuestionarios.class,1);
            //ASOCIO EL CUESTIONARIO CON EL USUARIO
            c.getUsuarios().add(u);
            //ASOCIO EL USUARIO CON EL CUESTIONARIO
            u.getCuestionarios().add(c);
            em.getTransaction().begin();
            em.persist(u);
            em.persist(c);
            em.getTransaction().commit();
            em.close();



PERO ME DA ERROR!!!!... AGRADECERIA DE SU AYUDA.

Atento a sus comentarios.


Título: Re: JPA Ayuda plz.
Publicado por: crack81 en 9 Julio 2015, 17:50 pm
Bueno ahora no tengo java pero te aconsejo darle una revisada a esta
info http://www.tutorialspoint.com/es/jpa/jpa_introduction.htm (http://www.tutorialspoint.com/es/jpa/jpa_introduction.htm)


Título: Re: JPA Ayuda plz.
Publicado por: Usuario Invitado en 9 Julio 2015, 22:12 pm
Primero debes empezar la transacción:

Código
  1. EntityManager em=emf.createEntityManager();
  2. EntityTransaction tx = em.getTransaction();
  3. tx.begin();
  4. ...
  5. em.persist(u);
  6. em.persist(c);
  7. tx.commit();

Otra cosa, por lógica, si te da el error debes de ponerlo también para que podamos verlo, de otra manera, estamos adivinando.

Saludos.


Título: Re: JPA Ayuda plz.
Publicado por: visualfree en 10 Julio 2015, 05:35 am
Estimado, comento que ya me ha funcionado de la siguiente manera:

Código:
EntityManagerFactory emf=Persistence.createEntityManagerFactory("JPA_EJB_FULLPU");
                    EntityManager em=emf.createEntityManager();
                    EntityTransaction tx=em.getTransaction();
                    Usuarios u=new Usuarios();
                    u=em.find(Usuarios.class,2);
                    Cuestionarios c=new Cuestionarios();
                    //BUSCO EL ID DEL CUESTIONARIO
                    c=em.find(Cuestionarios.class,2);
                    //ASOCIO EL CUESTIONARIO CON EL USUARIO
                    c.getUsuarios().add(u);
                    //ASOCIO EL USUARIO CON EL CUESTIONARIO
                    u.getCuestionarios().add(c);
                    tx.begin();
                    em.persist(u);
                    em.persist(c);
                    tx.commit();
                    em.close();



PERO AHORA NOSE COMO HACER CON JPQL:

QUIERO PASAR LA SIGUIENTE CONSULA JPQL:

Código:
select usuarios.nombre,cuestionarios.nombre from  usuarios,cuestionarios,usuarios_cuestionarios where usuarios_cuestionarios.id_usuario=usuarios.id_usuario and usuarios_cuestionarios.id_cuestionario=cuestionarios.id_cuestionario and cuestionarios.id_cuestionario=2;

Pero nose como hacerlo :(, agradecería de su ayuda.



Título: Re: JPA Ayuda plz.
Publicado por: Usuario Invitado en 10 Julio 2015, 20:37 pm
Intentemos lo siguiente, ejecutemos la query nativa, es decir, SQL no JPQL. Primero, necesitamos envolver los resultados de las dos tablas y nos apoyaremos en @SqlResultSetMapping:

Código
  1. @SqlResultSetMapping(name="UsuarioCuestionarioResults",
  2.    entities={
  3. @EntityResult(entityClass=tu.paquete.Usuario.class)
  4. @EntityResult(entityClass=tu.paquete.Cuestionario.class)
  5.    }
  6. )
  7. public class Usuario implements Serializable {
  8. ...
  9. }

donde, name es el indentificador. El conjunto entities especifica las clases (tablas) que devolverá la consulta nativa, que son 2: usuarios y cuestionarios.

Ahora, procedemos a llamarlo:

Código
  1. String queryStr = "SELECT u.nombre, c.nombre FROM usuarios u, cuestionarios c,
  2. INNER JOIN usuarios_cuestionarios uc ON uc.id_usuario = u.id_usuario,
  3. INNER JOIN uc.id_cuestionario = c.id_cuestionario
  4. WHERE c.id = 2";
  5.  
  6.  
  7. Query q = em.createNativeQuery(queryStr, "UsuarioCuestionarioResults");
  8. List<Object[]> results = (List<Object[]>) q.getResult();
  9.  
  10. for(Object[] record = results) {
  11.    Usuario u = (Usuario) record[0];
  12.    Cuestionario c = (Cuestionario)[1];
  13.  
  14.    // hacer algo
  15. }

Como ves, llamamos al ResultSetMapping por su identificador. Las nativeQueries devuelven arreglos de objetos, éstos, dependen de las clases (tablas) que devuelve la consulta. Por eso, cada ítem de la lista devuelta, tendrá 2 clases ya mapeadas: Usuario y Cuestionario.

Ahora ya podrás mostrar los datos.

PD: Posiblemente hayan errores, pero serán mínimos, en ese caso, sería bueno que busques también por tu cuenta.