Guía: 2

Curso: Java Server Faces

Título: Introducción a JPA
Tiempo de Ejecución: 3 horas

I. OBJETIVOS

Que el participante:

Crear Entidades.

Configurar persistence.xml
persistence.xml.

Elabore mapeos de relaciones entre entidades

Consultas sobre datos.

II. DESARROLLO

Parte I Configuración Básica para JPA

1. Cree un nuevo proyecto Java Application y nómbrelo como SateliteModel

1 Grupo Satélite
2. Adicione una Persistence Unit para conectarse a la base de datos satélite, creada
en la guía1

3. En la estrategia de generación utilice None

2 Grupo Satélite
 4. Adicione un paquete al proyecto con el nombres satelite.model

5. Modelado de entidades. En este paso adicione las siguientes entidades y sus

correspondientes tablas en la base de datos. Puede utilizar el asistente de
Netbeans o copiar el código de las entidades que se muestran en la guía.

@Entity
public class TipoCurso implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Basic(optional=false)
private String nombreTipo;

public Long getId() {

return id;

3 Grupo Satélite
 }

public void setId(Long id) {

this.id = id;
}

public String getNombreTipo() {

return nombreTipo;
}

public void setNombreTipo(String nombreTipo) {

this.nombreTipo = nombreTipo;
}
/*Campos sobreescritos para implementar Serializable
codigo generado por netbeans.
*/
@Override
public int hashCode() {
int hash = 0;
hash += (id != null ? id.hashCode() : 0);
return hash;
}

@Override
public boolean equals(Object object) {
// TODO: Warning - this method won't work in the case the id fields are
not set
if (!(object instanceof TipoCurso)) {
return false;
}
TipoCurso other = (TipoCurso) object;
if ((this.id == null && other.id != null) || (this.id != null &&
!this.id.equals(other.id))) {
return false;
}
return true;
}

@Override
public String toString() {
return "satelite.model.TipoCurso[ id=" + id + " ]";
}

@Entity
@Table(name="cur_curso")
public class Curso implements Serializable {

private static final long serialVersionUID = 1L;

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)

4 Grupo Satélite
 @Basic(optional = false)
@NotNull
@Column(name = "idCUR_CURSO")
private Integer id;
@Basic(optional = false)
@NotNull
private String nombre;
@Column(name = "cur_FechaInicio")
@Temporal(TemporalType.DATE)
private Date fechaInicio;
@Column(name = "cur_FechaFin")
@Temporal(TemporalType.DATE)
private Date fechaFin;

/*métodos set y get y métodos de Serialiazable*/

@Entity
public class Alumno implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Basic(optional=false)
private String nombre;
private String telefono;

public Long getId() {

return id;
}

public void setId(Long id) {

this.id = id;
}

public String getNombre() {

return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public String getTelefono() {

return telefono;
}

public void setTelefono(String telefono) {

this.telefono = telefono;
}
/*métodos set y get y métodos de Serialiazable*/

5 Grupo Satélite
Parte II. Manipulando Entidades

1. Utilizando la entidad Curso realice el siguiente test.

public static void test1( ) {

// configuracion del JPA
EntityManagerFactory factory =
Persistence.createEntityManagerFactory("SateliteModelPU");
EntityManager manager = factory.createEntityManager();

/*Crear una entidad */

manager.getTransaction().begin();
Curso a = new Curso();
a.setNombre("Curso de JPA");
manager.persist(a);
manager.getTransaction().commit();

/*Buscar una entidad por Id*/

manager.getTransaction().begin();
Curso encontrado = new Curso();
encontrado = manager.find(Curso.class,a.getId());

System.out.println("id Curso"+ encontrado.getId().toString());

System.out.println("nombre Curso:"+encontrado.getNombre());

/*Modificar entidad*/
encontrado.setNombre("Curso nombre modificado"+encontrado.getId());
manager.getTransaction().commit();

/*Consultando*/
manager.getTransaction().begin();
Curso encontradoModificado = new Curso();
encontradoModificado = manager.find(Curso.class,encontrado.getId());
System.out.println("*********encontrado y modificado");
System.out.println("id Curso"+ encontradoModificado.getId().toString());
System.out.println("nombre Curso:"+encontradoModificado.getNombre());

List<Curso> cursosDisponibles = new ArrayList();

Query query = manager.createQuery("SELECT c FROM Curso c");
cursosDisponibles = query.getResultList();
for (Iterator<Curso> it = cursosDisponibles.iterator(); it.hasNext();) {
Curso curso = it.next();
System.out.println("id Curso"+ curso.getId().toString());
System.out.println("nombre Curso:"+curso.getNombre());
System.out.println("******************");
}

manager.getTransaction().commit();

6 Grupo Satélite
 manager.close();

factory.close();

}
/*método main invoca el test1 */
public static void main(String[] args) {
// configuracion del JPA
SateliteModel.test1();

ParteIII. Mapeo de Entidades

1. Relacione las entidades TipoCurso y Curso. Para este caso la relación es Un Curso
es de un TipoCurso. La relación es de Muchos a Uno. Modifique la entidad Curso y
la base de datos para este propósito. En la entidad curso tendremos una referencia a
TipoCurso por lo cual se debe modificar según el siguiente código.
@ManyToOne
@JoinColumn(name="IdTipoCurso")
private TipoCurso tipo;

2. Realice el siguiente test y ejecútelo desde el método main

public static void test2(){

EntityManagerFactory factory =
Persistence.createEntityManagerFactory("SateliteModelPU");
EntityManager manager = factory.createEntityManager();
manager.getTransaction().begin();
TipoCurso tipoCurso =new TipoCurso();
tipoCurso.setNombreTipo("Programacion");

Curso curso= new Curso();

curso.setNombre("JPA 2+3 ");
curso.setTipo(tipoCurso);

manager.persist(tipoCurso);
manager.persist(curso);

List<Curso> cursosDisponibles = new ArrayList();

Query query = manager.createQuery("SELECT c FROM Curso c");
cursosDisponibles = query.getResultList();
for (Iterator<Curso> it = cursosDisponibles.iterator(); it.hasNext();) {
Curso c = it.next();
System.out.println("id Curso"+ c.getId().toString());
System.out.println("nombre Curso:"+c.getNombre());

7 Grupo Satélite
 System.out.println("nombre Curso:"+c.getTipo().getNombreTipo());
System.out.println("******************");
}

3. Relacione Alumno con Cursos. En esta relación haremos uso de ManytoMany

Edite la entidad Curso para adicionar una lista de alumnos

@ManyToMany
private List<Alumno> ListaAlumnos;

4. Edite la entidad Alumno

@ManyToMany
@JoinTable(name="axc_alumnocur",
joinColumns=@JoinColumn(name="idalumno"),
inverseJoinColumns=@JoinColumn(name="idcurso"))
private List<Curso> CursosInscritos;

5. Con los cambios realizados desarrolle los siguientes ejercicios

• Adicione un alumno e inscríbalo en un curso
• Dado un curso liste los alumnos inscritos
public static void test3() {
EntityManagerFactory factory =
Persistence.createEntityManagerFactory("SateliteModelPU");
EntityManager manager = factory.createEntityManager();
manager.getTransaction().begin();
Alumno a = new Alumno();
a.setNombre("Tu");
a.setTelefono("222");
a.setCursosInscritos(new ArrayList());
String querybuscar = "SELECT c FROM Curso c WHERE c.curNombre =
:curNombre";
Query query = manager.createQuery("SELECT c FROM Curso c");
query.setParameter("curNombre", "JPA 2");
Curso curso = (Curso) query.getSingleResult();
a.getCursosInscritos().add(curso);
manager.persist(a);
manager.getTransaction().commit();
manager.close();

factory.close();

8 Grupo Satélite