[ Foro de Java ]

Persistence Java

Estimados muy buenas. Ruego por favor me ayuden con lo siguiente. He credo el siguiente código para añadir, editar o eliminar datos de una base de datos. La cuestión es que no está funcionando como debería y no sé por qué. Quizás me puede ayudar.

Uso java mediante netbeans. Me conecto correctamente a la base de datos. Desde netbeans puedo abrirla y revisarlo y demás pero al correr el programa no hace lo que debería. Me explico:

Esta es la clase creada en entidad:

/*
package Entidad;
import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
/**
*
* @author cuera
*/
@Entity
@Table(name = "asignatura")
@NamedQueries({
   @NamedQuery(name = "Asignatura.findAll", query = "SELECT a FROM Asignatura a"),
   @NamedQuery(name = "Asignatura.findByIdAsignatura", query = "SELECT a FROM Asignatura a WHERE a.idAsignatura = :idAsignatura"),
   @NamedQuery(name = "Asignatura.findBySemestreAsignatura", query = "SELECT a FROM Asignatura a WHERE a.semestreAsignatura = :semestreAsignatura"),
   @NamedQuery(name = "Asignatura.findByHorasAsignatura", query = "SELECT a FROM Asignatura a WHERE a.horasAsignatura = :horasAsignatura"),
   @NamedQuery(name = "Asignatura.findByCreditosAsignatura", query = "SELECT a FROM Asignatura a WHERE a.creditosAsignatura = :creditosAsignatura")})
public class Asignatura implements Serializable {

   private static final long serialVersionUID = 1L;
   @Id
   @Basic(optional = false)
   @Column(name = "id_asignatura")
   private Integer idAsignatura;
   @Lob
   @Column(name = "codigo_asignatura")
   private String codigoAsignatura;
   @Lob
   @Column(name = "nombre_asignatura")
   private String nombreAsignatura;
   @Column(name = "semestre_asignatura")
   private Integer semestreAsignatura;
   @Column(name = "horas_asignatura")
   private Integer horasAsignatura;
   @Column(name = "creditos_asignatura")
   private Integer creditosAsignatura;
   @Lob
   @Column(name = "dependencia_asignatura")
   private String dependenciaAsignatura;
   @JoinColumn(name = "id_carrera", referencedColumnName = "id_carrera")
   @ManyToOne
   private Carrera idCarrera;

   public Asignatura() {
   }

   public Asignatura(Integer idAsignatura) {
       this.idAsignatura = idAsignatura;
   }

   public Integer getIdAsignatura() {
       return idAsignatura;
   }

   public void setIdAsignatura(Integer idAsignatura) {
       this.idAsignatura = idAsignatura;
   }

   public String getCodigoAsignatura() {
       return codigoAsignatura;
   }

   public void setCodigoAsignatura(String codigoAsignatura) {
       this.codigoAsignatura = codigoAsignatura;
   }

   public String getNombreAsignatura() {
       return nombreAsignatura;
   }

   public void setNombreAsignatura(String nombreAsignatura) {
       this.nombreAsignatura = nombreAsignatura;
   }

   public Integer getSemestreAsignatura() {
       return semestreAsignatura;
   }

   public void setSemestreAsignatura(Integer semestreAsignatura) {
       this.semestreAsignatura = semestreAsignatura;
   }

   public Integer getHorasAsignatura() {
       return horasAsignatura;
   }

   public void setHorasAsignatura(Integer horasAsignatura) {
       this.horasAsignatura = horasAsignatura;
   }

   public Integer getCreditosAsignatura() {
       return creditosAsignatura;
   }

   public void setCreditosAsignatura(Integer creditosAsignatura) {
       this.creditosAsignatura = creditosAsignatura;
   }

   public String getDependenciaAsignatura() {
       return dependenciaAsignatura;
   }

   public void setDependenciaAsignatura(String dependenciaAsignatura) {
       this.dependenciaAsignatura = dependenciaAsignatura;
   }

   public Carrera getIdCarrera() {
       return idCarrera;
   }

   public void setIdCarrera(Carrera idCarrera) {
       this.idCarrera = idCarrera;
   }

   @Override
   public int hashCode() {
       int hash = 0;
       hash += (idAsignatura != null ? idAsignatura.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 Asignatura)) {
           return false;
       }
       Asignatura other = (Asignatura) object;
       if ((this.idAsignatura == null && other.idAsignatura != null) || (this.idAsignatura != null && !this.idAsignatura.equals(other.idAsignatura))) {
           return false;
       }
       return true;
   }

   @Override
   public String toString() {
       return "Entidad.Asignatura[ idAsignatura=" + idAsignatura + " ]";
   }

}

Esta es la clase creada en el controlador:


/*
package Controlador;
import Controlador.exceptions.NonexistentEntityException;
import Controlador.exceptions.PreexistingEntityException;
import Entidad.Asignatura;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import Entidad.Carrera;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
/**
*
* @author cuera
*/
public class AsignaturaJpaController implements Serializable {

   public AsignaturaJpaController(EntityManagerFactory emf) {
       this.emf = emf;
   }
   private EntityManagerFactory emf = null;

   public AsignaturaJpaController() {
       throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
   }

   public EntityManager getEntityManager() {
       return emf.createEntityManager();
   }

   public void create(Asignatura asignatura) throws PreexistingEntityException, Exception {
       EntityManager em = null;
       try {
           em = getEntityManager();
           em.getTransaction().begin();
           Carrera idCarrera = asignatura.getIdCarrera();
           if (idCarrera != null) {
               idCarrera = em.getReference(idCarrera.getClass(), idCarrera.getIdCarrera());
               asignatura.setIdCarrera(idCarrera);
           }
           em.persist(asignatura);
           if (idCarrera != null) {
               idCarrera.getAsignaturaCollection().add(asignatura);
               idCarrera = em.merge(idCarrera);
           }
           em.getTransaction().commit();
       } catch (Exception ex) {
           if (findAsignatura(asignatura.getIdAsignatura()) != null) {
               throw new PreexistingEntityException("Asignatura " + asignatura + " already exists.", ex);
           }
           throw ex;
       } finally {
           if (em != null) {
               em.close();
           }
       }
   }

   public void edit(Asignatura asignatura) throws NonexistentEntityException, Exception {
       EntityManager em = null;
       try {
           em = getEntityManager();
           em.getTransaction().begin();
           Asignatura persistentAsignatura = em.find(Asignatura.class, asignatura.getIdAsignatura());
           Carrera idCarreraOld = persistentAsignatura.getIdCarrera();
           Carrera idCarreraNew = asignatura.getIdCarrera();
           if (idCarreraNew != null) {
               idCarreraNew = em.getReference(idCarreraNew.getClass(), idCarreraNew.getIdCarrera());
               asignatura.setIdCarrera(idCarreraNew);
           }
           asignatura = em.merge(asignatura);
           if (idCarreraOld != null && !idCarreraOld.equals(idCarreraNew)) {
               idCarreraOld.getAsignaturaCollection().remove(asignatura);
               idCarreraOld = em.merge(idCarreraOld);
           }
           if (idCarreraNew != null && !idCarreraNew.equals(idCarreraOld)) {
               idCarreraNew.getAsignaturaCollection().add(asignatura);
               idCarreraNew = em.merge(idCarreraNew);
           }
           em.getTransaction().commit();
       } catch (Exception ex) {
           String msg = ex.getLocalizedMessage();
           if (msg == null || msg.length() == 0) {
               Integer id = asignatura.getIdAsignatura();
               if (findAsignatura(id) == null) {
                   throw new NonexistentEntityException("The asignatura with id " + id + " no longer exists.");
               }
           }
           throw ex;
       } finally {
           if (em != null) {
               em.close();
           }
       }
   }

   public void destroy(Integer id) throws NonexistentEntityException {
       EntityManager em = null;
       try {
           em = getEntityManager();
           em.getTransaction().begin();
           Asignatura asignatura;
           try {
               asignatura = em.getReference(Asignatura.class, id);
               asignatura.getIdAsignatura();
           } catch (EntityNotFoundException enfe) {
               throw new NonexistentEntityException("The asignatura with id " + id + " no longer exists.", enfe);
           }
           Carrera idCarrera = asignatura.getIdCarrera();
           if (idCarrera != null) {
               idCarrera.getAsignaturaCollection().remove(asignatura);
               idCarrera = em.merge(idCarrera);
           }
           em.remove(asignatura);
           em.getTransaction().commit();
       } finally {
           if (em != null) {
               em.close();
           }
       }
   }

   public List<Asignatura> findAsignaturaEntities() {
       return findAsignaturaEntities(true, -1, -1);
   }

   public List<Asignatura> findAsignaturaEntities(int maxResults, int firstResult) {
       return findAsignaturaEntities(false, maxResults, firstResult);
   }

   private List<Asignatura> findAsignaturaEntities(boolean all, int maxResults, int firstResult) {
       EntityManager em = getEntityManager();
       try {
           CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
           cq.select(cq.from(Asignatura.class));
           Query q = em.createQuery(cq);
           if (!all) {
               q.setMaxResults(maxResults);
               q.setFirstResult(firstResult);
           }
           return q.getResultList();
       } finally {
           em.close();
       }
   }

   public Asignatura findAsignatura(Integer id) {
       EntityManager em = getEntityManager();
       try {
           return em.find(Asignatura.class, id);
       } finally {
           em.close();
       }
   }

   public int getAsignaturaCount() {
       EntityManager em = getEntityManager();
       try {
           CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
           Root<Asignatura> rt = cq.from(Asignatura.class);
           cq.select(em.getCriteriaBuilder().count(rt));
           Query q = em.createQuery(cq);
           return ((Long) q.getSingleResult()).intValue();
       } finally {
           em.close();
       }
   }

}

Este es el persistence.xml (en la línea 8 añadí esto ?useSSL=false para que no salgan WARNINGS pero nada):

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
 <persistence-unit name="SistemaLaPU" transaction-type="RESOURCE_LOCAL">
   <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
   <class>Entidad.Asignatura</class>
   <class>Entidad.Carrera</class>
   <properties>
     <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/ladb?useSSL=false"/>
     <property name="javax.persistence.jdbc.user" value="dferazo"/>
     <property name="javax.persistence.jdbc.driver" value="org.gjt.mm.mysql.Driver"/>
     <property name="javax.persistence.jdbc.password" value="Chanfaina7*"/>
     <property name="javax.persistence.schema-generation.database.action" value="create"/>

   </properties>
 </persistence-unit>
</persistence>

Y este la clase que ejecuta las operaciones:

/*
package Gestion;
import Controlador.AsignaturaJpaController;
import Entidad.Asignatura;
public class gestionAsignatura {
   private AsignaturaJpaController gestAsignatura = new AsignaturaJpaController();
   private Asignatura asignatura = new Asignatura();
   private String mensaje = "";
   public String insertarAsignatura(int id, String nombre, String codigo) {
       try {
           asignatura.setIdAsignatura(id);
           asignatura.setNombreAsignatura(nombre);
           asignatura.setCodigoAsignatura(codigo);
           gestAsignatura.create(asignatura);
           mensaje = "Se guardó.";
       } catch (Exception e) {
           System.out.println("Mensaje insertar: " + e.getMessage());
           mensaje = "No se guardó.";
       }
       return mensaje;
   }
   public String actualizarAsignatura(int id, String nombre, String codigo) {
       try {
           asignatura.setIdAsignatura(id);
           asignatura.setNombreAsignatura(nombre);
           asignatura.setCodigoAsignatura(codigo);
           gestAsignatura.edit(asignatura);
           mensaje = "Se actualizó.";
       } catch (Exception e) {
           System.out.println("Mensaje insertar: " + e.getMessage());
           mensaje = "No se actualizó.";
       }
       return mensaje;
   }
   public String eliminarAsignatura(int id) {
       try {
           gestAsignatura.destroy(id);
           mensaje = "Se eliminó";
       } catch (Exception e) {
           System.out.println("Mensaje eliminar: " + e.getMessage());
           mensaje = "No se eliminó";
       }
       return mensaje;
   }
}

Con esto ejecuto:

/*
public class test {
   public static void main(String [] args){
       gestionAsignatura test = new gestionAsignatura();
       //System.out.println(test.insertarAsignatura(113, "ComunityManager", "CA607"));
       //System.out.println(test.actualizarAsignatura(113, "SocialMedia", "CA615"));
       System.out.println(test.eliminarAsignatura(113));
   }
}

La cuestión es que se ejecuta (con unas alertas) pero siempre se ejecuta la parte del catch, es decir: no añade, no edita o no elimina no entra al try....... Y no se por qué?????????// Por favor ayúdenme si les es posible. Estos son los errores o advertencias que me salen:

ant -f C:\\Users\\cuera\\Documents\\NetBeansProjects\\SistemaLa -Dnb.internal.action.name=run.single -Djavac.includes=Gestion/test.java -Drun.class=Gestion.test run-single
init:
Deleting: C:\Users\cuera\Documents\NetBeansProjects\SistemaLa\build\built-jar.properties
deps-jar:
Updating property file: C:\Users\cuera\Documents\NetBeansProjects\SistemaLa\build\built-jar.properties
Compiling 1 source file to C:\Users\cuera\Documents\NetBeansProjects\SistemaLa\build\classes



warning: Supported source version 'RELEASE_6' from annotation processor 'org.eclipse.persistence.internal.jpa.modelgen.CanonicalModelProcessor' less than -source '14'
warning: The following options were not recognized by any processor: '[eclipselink.canonicalmodel.use_static_factory]'
2 warnings
compile-single:
run-single:
[EL Info]: 2020-12-14 16:45:12.204--ServerSession(2008966511)--EclipseLink, version: Eclipse Persistence Services - 2.5.2.v20140319-9ad6abd
Mon Dec 14 16:45:12 ECT 2020 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
[EL Info]: connection: 2020-12-14 16:45:12.577--ServerSession(2008966511)--file:/C:/Users/cuera/Documents/NetBeansProjects/SistemaLa/build/classes/_SistemaLaPU login successful
Mon Dec 14 16:45:12 ECT 2020 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
[EL Warning]: metamodel: 2020-12-14 16:45:12.593--The collection of metamodel types is empty. Model classes may not have been found during entity search for Java SE and some Java EE container managed persistence units. Please verify that your entity classes are referenced in persistence.xml using either <class> elements or a global <exclude-unlisted-classes>false</exclude-unlisted-classes> element
Mensaje eliminar: Unknown entity bean class: class Entidad.Asignatura, please verify that this class has been marked with the @Entity annotation.
No se eliminó
BUILD SUCCESSFUL (total time: 2 seconds)


Muchas gracias de antemano. Salu2.