Java Jersey RestFul，错误为500，无日志_Java_Jpa_Jersey

Java Jersey RestFul，错误为500，无日志

java jpa jersey

Java Jersey RestFul，错误为500，无日志,java,jpa,jersey,Java,Jpa,Jersey,我正在尝试编写一个restful程序。为此，我创建了一个通用映射器（Mapper.class）。当我在类user.class上使用它时，一切都正常，但当我将类更改为planning.class时，我有一个错误 User.class @Entity @XmlRootElement public class Utilisateur implements Serializable{ @Id @GeneratedValue(strategy= GenerationType.AUT

我正在尝试编写一个restful程序。为此，我创建了一个通用映射器（Mapper.class）。当我在类user.class上使用它时，一切都正常，但当我将类更改为planning.class时，我有一个错误

User.class

    @Entity
@XmlRootElement
public class Utilisateur implements Serializable{
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    @Column(name = "UTILISATEUR_ID")
    private int Id;

    @NotNull
    private String Login;

    @NotNull
    private String MotDePasse;

    @NotNull
    private String Prenom;

    @NotNull
    private String Nom;

    @NotNull
    private EnumTypeUtilisateur TypeUtilisateur;

    @ManyToMany(mappedBy="Moniteurs", cascade=CascadeType.ALL) 
    private Collection<Planning> Plannings;

    @ManyToMany(mappedBy="Moniteurs", cascade=CascadeType.ALL) 
    private Collection<Disponibilite> Disponibilites;

    public Utilisateur(){
    }
    public Utilisateur(String Login, String MotDepasse, String Prenom, String Nom, EnumTypeUtilisateur TypeUtilisateur){
        this.Login=Login;
        this.MotDePasse=MotDePasse;
        this.Prenom=Prenom;
        this.Nom=Nom;
        this.TypeUtilisateur=TypeUtilisateur;
    }

    public int getId() {
        return Id;
    }

    public void setId(int Id) {
        this.Id = Id;
    }
    public String getLogin() {
        return Login;
    }

    public void setLogin(String Login) {
        this.Login = Login;
    }

    public String getMotDePasse() {
        return MotDePasse;
    }

    public void setMotDePasse(String MotDePasse) {
        this.MotDePasse = MotDePasse;
    }

    public String getPrenom() {
        return Prenom;
    }

    public void setPrenom(String Prenom) {
        this.Prenom = Prenom;
    }

    public String getNom() {
        return Nom;
    }

    public void setNom(String Nom) {
        this.Nom = Nom;
    }

    public Collection<Planning> getPlanning() {
        return Plannings;
    }

    public void setPlanningCollection(Collection<Planning>  PlanningCollection) {
        this.Plannings = PlanningCollection;
    }

    public Collection<Disponibilite> getDisponibilite() {
        return Disponibilites;
    }

    public void setDisponibiliteCollection(Collection<Disponibilite> DisponibiliteCollection) {
        this.Disponibilites = DisponibiliteCollection;
    }

    public EnumTypeUtilisateur getTypeUtilisateur() {
        return TypeUtilisateur;
    }

    public void setTypeUtilisateur(EnumTypeUtilisateur TypeUtilisateur) {
        this.TypeUtilisateur = TypeUtilisateur;
    }

}

    @Entity
@XmlRootElement
public class Planning implements Serializable {
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    @Column(name = "PLANNING_ID")
    private int Id;

    @Column(name="DATE_EVENEMENT")
    @Temporal(TemporalType.TIMESTAMP)
    private Date dateEvenement;

    @NotNull
    private EnumTypePlanning Type; 

    @ManyToMany
    @JoinTable(name="ActivitePlanning", 
            joinColumns=@JoinColumn(name="PLANNING_ID", referencedColumnName="PLANNING_ID"),
            inverseJoinColumns=@JoinColumn(name="ACTIVITE_ID", referencedColumnName="ACTIVITE_ID"))
    private Collection<Activite> Activites;

    @ManyToOne
    @JoinColumn(name="GROUPE_ID",insertable = false, updatable = false)
    private Groupe Groupe;

    @ManyToMany
    @JoinTable(name="UtilisateurPlanning", 
            joinColumns=@JoinColumn(name="PLANNING_ID", referencedColumnName="PLANNING_ID"),
            inverseJoinColumns=@JoinColumn(name="UTILISATEUR_ID", referencedColumnName="UTILISATEUR_ID"))
    private Collection<Utilisateur> Moniteurs;

    public Planning(){

    }

    public Planning(Date dateEvenement, EnumTypePlanning Type, Collection<Activite> Activite, Groupe Groupe){
        this.dateEvenement = dateEvenement;
        this.Type=Type;
        this.Activites=Activite;
        this.Groupe=Groupe;

    }

    public int getId() {
        return Id;
    }

    public void setId(int Id) {
        this.Id = Id;
    }

    public Date getDateEvenement() {
        return dateEvenement;
    }

    public void setDateEvenement(Date dateEvenement) {
        this.dateEvenement = dateEvenement;
    }

    public EnumTypePlanning getType() {
        return Type;
    }

    public void setType(EnumTypePlanning Type) {
        this.Type = Type;
    }

    public Collection<Activite> getActivites() {
        return Activites;
    }

    public void setActivites(Collection<Activite> Activites) {
        this.Activites = Activites;
    }


    public Groupe getGroupe(){
        return Groupe;
    }

    public void setGroupe(Groupe Groupe) {
        this.Groupe = Groupe;
    }

    public Collection<Utilisateur> getMoniteur() {
        return Moniteurs;
    }

    public void setMoniteurCollection(Collection<Utilisateur> MoniteurCollection) {
        this.Moniteurs = MoniteurCollection;
    }

}

public class Mapper<T> extends AbstractFacade implements IMapper<T> {
    @PersistenceContext(unitName = "EJPlanningRestPU")
    private EntityManager em;

    private List<T> list;

    public Mapper(Class T){
    super(T);
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("EJPlanningRestPU");
        em = emf.createEntityManager();
    }

    @Override
    protected EntityManager getEntityManager() {
        return em;
    }

    @Override
    public void add(T itemA) {
    ParameterIsNotNull(itemA);  
    super.<T>create(itemA);    
    }

    @Override
    public void update(T itemA) {
    ParameterIsNotNull(itemA); 
    super.<T>edit(itemA);
    }

    @Override
    public void delete(T itemA) {
    ParameterIsNotNull(itemA);   
    super.<T>remove(itemA);    
    }

    @Override
    public T getById(int id) {
    ParameterIsNotNull(id);   
    T item = (T)super.find(id);
    return item;
    }

    @Override
    public List getAll() {  
        list = super.findAll();
        return list;
    }

    @Override
    public void ParameterIsNotNull(Object param){
        if(param == null){
        throw new IllegalStateMessage(param.toString()+" a généré une erreur ! ");
        }
    }

    public abstract class AbstractFacade<T> {

    private Class<T> entityClass;
            private List<T> list;


    public AbstractFacade(Class<T> entityClass) {
        this.entityClass = entityClass;
    }

    protected abstract EntityManager getEntityManager();

    public T create(T entity) {
        try {
            getEntityManager().getTransaction().begin();
            getEntityManager().persist(entity);
            getEntityManager().getTransaction().commit();
            return entity;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return null;
    }

    public void edit(T entity) {
        try {
            getEntityManager().getTransaction().begin();
            getEntityManager().merge(entity);
            getEntityManager().getTransaction().commit();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

    }

    public void remove(T entity) {
        try {
            getEntityManager().getTransaction().begin();
            getEntityManager().remove(getEntityManager().merge(entity));
            getEntityManager().getTransaction().commit();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    public T find(Object id) {
        try {
            return getEntityManager().find(entityClass, id);
        } catch (Exception e) {
            return null;
        }
    }

    public List<T> findAll() {
        try {
            javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
            cq.select(cq.from(entityClass));
            return getEntityManager().createQuery(cq).getResultList();
        } catch (Exception e) {
            return null;
        }
    }

    public List<T> findRange(int[] range) {
        try {
            javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
            cq.select(cq.from(entityClass));
            javax.persistence.Query q = getEntityManager().createQuery(cq);
            q.setMaxResults(range[1] - range[0] + 1);
            q.setFirstResult(range[0]);

            return q.getResultList();
        } catch (Exception e) {
            return null;
        }
    }
    public List<T>findByOneParameter(String Table, Object param){
    CriteriaBuilder criteriabuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> q = criteriabuilder.createQuery(entityClass);
    Root<T> c = q.from(entityClass);
    ParameterExpression<Object> p = criteriabuilder.parameter(Object.class, Table);
    q.select(c).where(criteriabuilder.equal(c.get(Table), p));
    TypedQuery<T> query = getEntityManager().createQuery(q);
    query.setParameter(p, param);
    return list = query.getResultList();

    }

     public List<T>findBytwoParameter(String Table,String Table2, Object param, Object param2){
    CriteriaBuilder criteriabuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> q = criteriabuilder.createQuery(entityClass);
    Root<T> c = q.from(entityClass);
    ParameterExpression<Object> p = criteriabuilder.parameter(Object.class, Table);
    ParameterExpression<Object> p2 = criteriabuilder.parameter(Object.class, Table2);

    q.select(c).where(criteriabuilder.equal(c.get(Table2), p2), 
                      criteriabuilder.equal(c.get(Table), p));

    TypedQuery<T> query = getEntityManager().createQuery(q);
    query.setParameter(p, param);
    query.setParameter(p2, param2);
    return list = query.getResultList();

    }
     public List<T>findBythreeParameter(String Table,String Table2,String Table3, Object param, Object param2, Object param3){ 
    CriteriaBuilder criteriabuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> q = criteriabuilder.createQuery(entityClass);
    Root<T> c = q.from(entityClass);
    ParameterExpression<Object> p = criteriabuilder.parameter(Object.class, Table);
    ParameterExpression<Object> p2 = criteriabuilder.parameter(Object.class, Table2);
    ParameterExpression<Object> p3 = criteriabuilder.parameter(Object.class, Table3);

    q.select(c).where(criteriabuilder.equal(c.get(Table2), p2), 
                      criteriabuilder.equal(c.get(Table), p),
                      criteriabuilder.equal(c.get(Table3), p3));

    TypedQuery<T> query = getEntityManager().createQuery(q);
    query.setParameter(p, param);
    query.setParameter(p2, param2);
    query.setParameter(p3, param3);
    return list = query.getResultList();

    }

    public int count() {
        try {
            javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
            javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
            cq.select(getEntityManager().getCriteriaBuilder().count(rt));
            javax.persistence.Query q = getEntityManager().createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } catch (Exception e) {       
            return 0;


}
    }
}

    public class PlanningMapper extends AbstractFacade  implements IPlanningMapper{


    @PersistenceContext(unitName = "EJPlanningRestPU")
    private EntityManager em;
    private List<Planning> list;

    public PlanningMapper() {
        super(Planning.class);
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("EJPlanningRestPU");
        em = emf.createEntityManager();       }

    @Override
    protected EntityManager getEntityManager() {
        return em;
    }

    @Override
    public Planning getByDateAndGroupe(String Date, String Groupe) {
        Planning user = new Planning();
        try{
        list =super.findBytwoParameter("dateEvenement","Groupe",Date,Groupe);
        user = list.get(0);
        }catch(Exception e){
        return null;
        }
        return user;  
    }

}

@实体
@XmlRootElement
公共类利用器实现可序列化{
@身份证
@GeneratedValue（策略=GenerationType.AUTO）
@列（name=“usilisateur\u ID”）
私有int-Id；
@NotNull
私有字符串登录；
@NotNull
私有字符串MotDePasse；
@NotNull
私有字符串Prenom；
@NotNull
私有字符串名称；
@NotNull
私人EnumTypeUserateur TypeUserateur；
@ManyToMany（mappedBy=“Moniteurs”，cascade=CascadeType.ALL）
私人收藏计划；
@ManyToMany（mappedBy=“Moniteurs”，cascade=CascadeType.ALL）
私人收藏争议；
公共用途{
}
公共用户（字符串登录、字符串MotDepasse、字符串Prenom、字符串Nom、枚举类型用户类型用户）{
this.Login=Login；
这个.motdepase=motdepase；
这个。Prenom=Prenom；
这个.Nom=Nom；
这个.typeutisateur=typeutisateur；
}
公共int getId（）{
返回Id；
}
公共无效集合Id（内部Id）{
这个.Id=Id；
}
公共字符串getLogin（）{
返回登录；
}
公共void setLogin（字符串登录）{
this.Login=Login；
}
公共字符串getMotDePasse（）{
返回莫德帕斯；
}
公共void setMotDePasse（字符串MotDePasse）{
this.motdepase=motdepase；
}
公共字符串getPrenom（）{
返回Prenom；
}
公共void setPrenom（字符串Prenom）{
这个。Prenom=Prenom；
}
公共字符串getNom（）{
返回名称；
}
公共无效集合名（字符串名）{
这个.Nom=Nom；
}
公共收藏策划{
回归规划；
}
公共作废集合计划集合（集合计划集合）{
这个.Plannings=PlanningCollection；
}
公共集合getDisponibilite（）{
返回争议；
}
public void setDisponibiliteCollection（集合DisponibiliteCollection）{
this.disponibiletes=disponibiletecollection；
}
公共EnumTypeUserateur GetTypeUserateur（）{
返回类型利用者；
}
公共无效设置类型使用权（枚举类型使用权类型使用权）{
this.typeutisateur=typeutisateur；
}
}

计划课程

    @Entity
@XmlRootElement
public class Utilisateur implements Serializable{
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    @Column(name = "UTILISATEUR_ID")
    private int Id;

    @NotNull
    private String Login;

    @NotNull
    private String MotDePasse;

    @NotNull
    private String Prenom;

    @NotNull
    private String Nom;

    @NotNull
    private EnumTypeUtilisateur TypeUtilisateur;

    @ManyToMany(mappedBy="Moniteurs", cascade=CascadeType.ALL) 
    private Collection<Planning> Plannings;

    @ManyToMany(mappedBy="Moniteurs", cascade=CascadeType.ALL) 
    private Collection<Disponibilite> Disponibilites;

    public Utilisateur(){
    }
    public Utilisateur(String Login, String MotDepasse, String Prenom, String Nom, EnumTypeUtilisateur TypeUtilisateur){
        this.Login=Login;
        this.MotDePasse=MotDePasse;
        this.Prenom=Prenom;
        this.Nom=Nom;
        this.TypeUtilisateur=TypeUtilisateur;
    }

    public int getId() {
        return Id;
    }

    public void setId(int Id) {
        this.Id = Id;
    }
    public String getLogin() {
        return Login;
    }

    public void setLogin(String Login) {
        this.Login = Login;
    }

    public String getMotDePasse() {
        return MotDePasse;
    }

    public void setMotDePasse(String MotDePasse) {
        this.MotDePasse = MotDePasse;
    }

    public String getPrenom() {
        return Prenom;
    }

    public void setPrenom(String Prenom) {
        this.Prenom = Prenom;
    }

    public String getNom() {
        return Nom;
    }

    public void setNom(String Nom) {
        this.Nom = Nom;
    }

    public Collection<Planning> getPlanning() {
        return Plannings;
    }

    public void setPlanningCollection(Collection<Planning>  PlanningCollection) {
        this.Plannings = PlanningCollection;
    }

    public Collection<Disponibilite> getDisponibilite() {
        return Disponibilites;
    }

    public void setDisponibiliteCollection(Collection<Disponibilite> DisponibiliteCollection) {
        this.Disponibilites = DisponibiliteCollection;
    }

    public EnumTypeUtilisateur getTypeUtilisateur() {
        return TypeUtilisateur;
    }

    public void setTypeUtilisateur(EnumTypeUtilisateur TypeUtilisateur) {
        this.TypeUtilisateur = TypeUtilisateur;
    }

}

    @Entity
@XmlRootElement
public class Planning implements Serializable {
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    @Column(name = "PLANNING_ID")
    private int Id;

    @Column(name="DATE_EVENEMENT")
    @Temporal(TemporalType.TIMESTAMP)
    private Date dateEvenement;

    @NotNull
    private EnumTypePlanning Type; 

    @ManyToMany
    @JoinTable(name="ActivitePlanning", 
            joinColumns=@JoinColumn(name="PLANNING_ID", referencedColumnName="PLANNING_ID"),
            inverseJoinColumns=@JoinColumn(name="ACTIVITE_ID", referencedColumnName="ACTIVITE_ID"))
    private Collection<Activite> Activites;

    @ManyToOne
    @JoinColumn(name="GROUPE_ID",insertable = false, updatable = false)
    private Groupe Groupe;

    @ManyToMany
    @JoinTable(name="UtilisateurPlanning", 
            joinColumns=@JoinColumn(name="PLANNING_ID", referencedColumnName="PLANNING_ID"),
            inverseJoinColumns=@JoinColumn(name="UTILISATEUR_ID", referencedColumnName="UTILISATEUR_ID"))
    private Collection<Utilisateur> Moniteurs;

    public Planning(){

    }

    public Planning(Date dateEvenement, EnumTypePlanning Type, Collection<Activite> Activite, Groupe Groupe){
        this.dateEvenement = dateEvenement;
        this.Type=Type;
        this.Activites=Activite;
        this.Groupe=Groupe;

    }

    public int getId() {
        return Id;
    }

    public void setId(int Id) {
        this.Id = Id;
    }

    public Date getDateEvenement() {
        return dateEvenement;
    }

    public void setDateEvenement(Date dateEvenement) {
        this.dateEvenement = dateEvenement;
    }

    public EnumTypePlanning getType() {
        return Type;
    }

    public void setType(EnumTypePlanning Type) {
        this.Type = Type;
    }

    public Collection<Activite> getActivites() {
        return Activites;
    }

    public void setActivites(Collection<Activite> Activites) {
        this.Activites = Activites;
    }


    public Groupe getGroupe(){
        return Groupe;
    }

    public void setGroupe(Groupe Groupe) {
        this.Groupe = Groupe;
    }

    public Collection<Utilisateur> getMoniteur() {
        return Moniteurs;
    }

    public void setMoniteurCollection(Collection<Utilisateur> MoniteurCollection) {
        this.Moniteurs = MoniteurCollection;
    }

}

public class Mapper<T> extends AbstractFacade implements IMapper<T> {
    @PersistenceContext(unitName = "EJPlanningRestPU")
    private EntityManager em;

    private List<T> list;

    public Mapper(Class T){
    super(T);
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("EJPlanningRestPU");
        em = emf.createEntityManager();
    }

    @Override
    protected EntityManager getEntityManager() {
        return em;
    }

    @Override
    public void add(T itemA) {
    ParameterIsNotNull(itemA);  
    super.<T>create(itemA);    
    }

    @Override
    public void update(T itemA) {
    ParameterIsNotNull(itemA); 
    super.<T>edit(itemA);
    }

    @Override
    public void delete(T itemA) {
    ParameterIsNotNull(itemA);   
    super.<T>remove(itemA);    
    }

    @Override
    public T getById(int id) {
    ParameterIsNotNull(id);   
    T item = (T)super.find(id);
    return item;
    }

    @Override
    public List getAll() {  
        list = super.findAll();
        return list;
    }

    @Override
    public void ParameterIsNotNull(Object param){
        if(param == null){
        throw new IllegalStateMessage(param.toString()+" a généré une erreur ! ");
        }
    }

    public abstract class AbstractFacade<T> {

    private Class<T> entityClass;
            private List<T> list;


    public AbstractFacade(Class<T> entityClass) {
        this.entityClass = entityClass;
    }

    protected abstract EntityManager getEntityManager();

    public T create(T entity) {
        try {
            getEntityManager().getTransaction().begin();
            getEntityManager().persist(entity);
            getEntityManager().getTransaction().commit();
            return entity;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return null;
    }

    public void edit(T entity) {
        try {
            getEntityManager().getTransaction().begin();
            getEntityManager().merge(entity);
            getEntityManager().getTransaction().commit();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

    }

    public void remove(T entity) {
        try {
            getEntityManager().getTransaction().begin();
            getEntityManager().remove(getEntityManager().merge(entity));
            getEntityManager().getTransaction().commit();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    public T find(Object id) {
        try {
            return getEntityManager().find(entityClass, id);
        } catch (Exception e) {
            return null;
        }
    }

    public List<T> findAll() {
        try {
            javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
            cq.select(cq.from(entityClass));
            return getEntityManager().createQuery(cq).getResultList();
        } catch (Exception e) {
            return null;
        }
    }

    public List<T> findRange(int[] range) {
        try {
            javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
            cq.select(cq.from(entityClass));
            javax.persistence.Query q = getEntityManager().createQuery(cq);
            q.setMaxResults(range[1] - range[0] + 1);
            q.setFirstResult(range[0]);

            return q.getResultList();
        } catch (Exception e) {
            return null;
        }
    }
    public List<T>findByOneParameter(String Table, Object param){
    CriteriaBuilder criteriabuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> q = criteriabuilder.createQuery(entityClass);
    Root<T> c = q.from(entityClass);
    ParameterExpression<Object> p = criteriabuilder.parameter(Object.class, Table);
    q.select(c).where(criteriabuilder.equal(c.get(Table), p));
    TypedQuery<T> query = getEntityManager().createQuery(q);
    query.setParameter(p, param);
    return list = query.getResultList();

    }

     public List<T>findBytwoParameter(String Table,String Table2, Object param, Object param2){
    CriteriaBuilder criteriabuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> q = criteriabuilder.createQuery(entityClass);
    Root<T> c = q.from(entityClass);
    ParameterExpression<Object> p = criteriabuilder.parameter(Object.class, Table);
    ParameterExpression<Object> p2 = criteriabuilder.parameter(Object.class, Table2);

    q.select(c).where(criteriabuilder.equal(c.get(Table2), p2), 
                      criteriabuilder.equal(c.get(Table), p));

    TypedQuery<T> query = getEntityManager().createQuery(q);
    query.setParameter(p, param);
    query.setParameter(p2, param2);
    return list = query.getResultList();

    }
     public List<T>findBythreeParameter(String Table,String Table2,String Table3, Object param, Object param2, Object param3){ 
    CriteriaBuilder criteriabuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> q = criteriabuilder.createQuery(entityClass);
    Root<T> c = q.from(entityClass);
    ParameterExpression<Object> p = criteriabuilder.parameter(Object.class, Table);
    ParameterExpression<Object> p2 = criteriabuilder.parameter(Object.class, Table2);
    ParameterExpression<Object> p3 = criteriabuilder.parameter(Object.class, Table3);

    q.select(c).where(criteriabuilder.equal(c.get(Table2), p2), 
                      criteriabuilder.equal(c.get(Table), p),
                      criteriabuilder.equal(c.get(Table3), p3));

    TypedQuery<T> query = getEntityManager().createQuery(q);
    query.setParameter(p, param);
    query.setParameter(p2, param2);
    query.setParameter(p3, param3);
    return list = query.getResultList();

    }

    public int count() {
        try {
            javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
            javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
            cq.select(getEntityManager().getCriteriaBuilder().count(rt));
            javax.persistence.Query q = getEntityManager().createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } catch (Exception e) {       
            return 0;


}
    }
}

    public class PlanningMapper extends AbstractFacade  implements IPlanningMapper{


    @PersistenceContext(unitName = "EJPlanningRestPU")
    private EntityManager em;
    private List<Planning> list;

    public PlanningMapper() {
        super(Planning.class);
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("EJPlanningRestPU");
        em = emf.createEntityManager();       }

    @Override
    protected EntityManager getEntityManager() {
        return em;
    }

    @Override
    public Planning getByDateAndGroupe(String Date, String Groupe) {
        Planning user = new Planning();
        try{
        list =super.findBytwoParameter("dateEvenement","Groupe",Date,Groupe);
        user = list.get(0);
        }catch(Exception e){
        return null;
        }
        return user;  
    }

}

@实体
@XmlRootElement
公共类规划实现了可序列化{
@身份证
@GeneratedValue（策略=GenerationType.AUTO）
@列（name=“PLANNING\u ID”）
私有int-Id；
@列（name=“DATE\u evement”）
@时态（TemporalType.TIMESTAMP）
私人约会；
@NotNull
私人计划型；
@许多
@JoinTable（name=“ActivitePlanning”，
joinColumns=@JoinColumn（name=“PLANNING\u ID”，referencedColumnName=“PLANNING\u ID”），
inverseJoinColumns=@JoinColumn（name=“ACTIVITE\u ID”，referencedColumnName=“ACTIVITE\u ID”））
私人收藏活动；
@许多酮
@JoinColumn（name=“GROUPE\u ID”，insertable=false，updateable=false）
私人集团；
@许多
@JoinTable（name=“UsilisaturPlanning”，
joinColumns=@JoinColumn（name=“PLANNING\u ID”，referencedColumnName=“PLANNING\u ID”），
inverseJoinColumns=@JoinColumn（name=“usiliateur\u ID”，referencedColumnName=“usiliateur\u ID”））
私人收藏监督员；
公共规划（）{
}
公共计划（日期-日期-活动、枚举类型计划类型、收集活动、分组）{
this.DateEvenment=DateEvenment；
this.Type=Type；
this.Activites=Activite；
this.Groupe=Groupe；
}
公共int getId（）{
返回Id；
}
公共无效集合Id（内部Id）{
这个.Id=Id；
}
公共日期getDateEvenment（）{
返回日期晚上；
}
公共作废设置日期晚上（日期晚上）{
this.DateEvenment=DateEvenment；
}
公共枚举类型规划getType（）{
返回类型；
}
公共void集合类型（EnumTypePlanning类型）{
this.Type=Type；
}
公共集合getActivites（）{
返回活动；
}
公共无效集合活动（集合活动）{
this.Activites=Activites；
}
公共组getGroupe（）{
返回组；
}
公共void setGroupe（Groupe-Groupe）{
this.Groupe=Groupe；
}
公共集合getMoniteur（）{
返回监视器；
}
公共作废集合监控集合（集合监控集合）{
this.Moniteurs=MoniteurCollection；
}
}

Mapper.class

    @Entity
@XmlRootElement
public class Utilisateur implements Serializable{
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    @Column(name = "UTILISATEUR_ID")
    private int Id;

    @NotNull
    private String Login;

    @NotNull
    private String MotDePasse;

    @NotNull
    private String Prenom;

    @NotNull
    private String Nom;

    @NotNull
    private EnumTypeUtilisateur TypeUtilisateur;

    @ManyToMany(mappedBy="Moniteurs", cascade=CascadeType.ALL) 
    private Collection<Planning> Plannings;

    @ManyToMany(mappedBy="Moniteurs", cascade=CascadeType.ALL) 
    private Collection<Disponibilite> Disponibilites;

    public Utilisateur(){
    }
    public Utilisateur(String Login, String MotDepasse, String Prenom, String Nom, EnumTypeUtilisateur TypeUtilisateur){
        this.Login=Login;
        this.MotDePasse=MotDePasse;
        this.Prenom=Prenom;
        this.Nom=Nom;
        this.TypeUtilisateur=TypeUtilisateur;
    }

    public int getId() {
        return Id;
    }

    public void setId(int Id) {
        this.Id = Id;
    }
    public String getLogin() {
        return Login;
    }

    public void setLogin(String Login) {
        this.Login = Login;
    }

    public String getMotDePasse() {
        return MotDePasse;
    }

    public void setMotDePasse(String MotDePasse) {
        this.MotDePasse = MotDePasse;
    }

    public String getPrenom() {
        return Prenom;
    }

    public void setPrenom(String Prenom) {
        this.Prenom = Prenom;
    }

    public String getNom() {
        return Nom;
    }

    public void setNom(String Nom) {
        this.Nom = Nom;
    }

    public Collection<Planning> getPlanning() {
        return Plannings;
    }

    public void setPlanningCollection(Collection<Planning>  PlanningCollection) {
        this.Plannings = PlanningCollection;
    }

    public Collection<Disponibilite> getDisponibilite() {
        return Disponibilites;
    }

    public void setDisponibiliteCollection(Collection<Disponibilite> DisponibiliteCollection) {
        this.Disponibilites = DisponibiliteCollection;
    }

    public EnumTypeUtilisateur getTypeUtilisateur() {
        return TypeUtilisateur;
    }

    public void setTypeUtilisateur(EnumTypeUtilisateur TypeUtilisateur) {
        this.TypeUtilisateur = TypeUtilisateur;
    }

}

    @Entity
@XmlRootElement
public class Planning implements Serializable {
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    @Column(name = "PLANNING_ID")
    private int Id;

    @Column(name="DATE_EVENEMENT")
    @Temporal(TemporalType.TIMESTAMP)
    private Date dateEvenement;

    @NotNull
    private EnumTypePlanning Type; 

    @ManyToMany
    @JoinTable(name="ActivitePlanning", 
            joinColumns=@JoinColumn(name="PLANNING_ID", referencedColumnName="PLANNING_ID"),
            inverseJoinColumns=@JoinColumn(name="ACTIVITE_ID", referencedColumnName="ACTIVITE_ID"))
    private Collection<Activite> Activites;

    @ManyToOne
    @JoinColumn(name="GROUPE_ID",insertable = false, updatable = false)
    private Groupe Groupe;

    @ManyToMany
    @JoinTable(name="UtilisateurPlanning", 
            joinColumns=@JoinColumn(name="PLANNING_ID", referencedColumnName="PLANNING_ID"),
            inverseJoinColumns=@JoinColumn(name="UTILISATEUR_ID", referencedColumnName="UTILISATEUR_ID"))
    private Collection<Utilisateur> Moniteurs;

    public Planning(){

    }

    public Planning(Date dateEvenement, EnumTypePlanning Type, Collection<Activite> Activite, Groupe Groupe){
        this.dateEvenement = dateEvenement;
        this.Type=Type;
        this.Activites=Activite;
        this.Groupe=Groupe;

    }

    public int getId() {
        return Id;
    }

    public void setId(int Id) {
        this.Id = Id;
    }

    public Date getDateEvenement() {
        return dateEvenement;
    }

    public void setDateEvenement(Date dateEvenement) {
        this.dateEvenement = dateEvenement;
    }

    public EnumTypePlanning getType() {
        return Type;
    }

    public void setType(EnumTypePlanning Type) {
        this.Type = Type;
    }

    public Collection<Activite> getActivites() {
        return Activites;
    }

    public void setActivites(Collection<Activite> Activites) {
        this.Activites = Activites;
    }


    public Groupe getGroupe(){
        return Groupe;
    }

    public void setGroupe(Groupe Groupe) {
        this.Groupe = Groupe;
    }

    public Collection<Utilisateur> getMoniteur() {
        return Moniteurs;
    }

    public void setMoniteurCollection(Collection<Utilisateur> MoniteurCollection) {
        this.Moniteurs = MoniteurCollection;
    }

}

public class Mapper<T> extends AbstractFacade implements IMapper<T> {
    @PersistenceContext(unitName = "EJPlanningRestPU")
    private EntityManager em;

    private List<T> list;

    public Mapper(Class T){
    super(T);
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("EJPlanningRestPU");
        em = emf.createEntityManager();
    }

    @Override
    protected EntityManager getEntityManager() {
        return em;
    }

    @Override
    public void add(T itemA) {
    ParameterIsNotNull(itemA);  
    super.<T>create(itemA);    
    }

    @Override
    public void update(T itemA) {
    ParameterIsNotNull(itemA); 
    super.<T>edit(itemA);
    }

    @Override
    public void delete(T itemA) {
    ParameterIsNotNull(itemA);   
    super.<T>remove(itemA);    
    }

    @Override
    public T getById(int id) {
    ParameterIsNotNull(id);   
    T item = (T)super.find(id);
    return item;
    }

    @Override
    public List getAll() {  
        list = super.findAll();
        return list;
    }

    @Override
    public void ParameterIsNotNull(Object param){
        if(param == null){
        throw new IllegalStateMessage(param.toString()+" a généré une erreur ! ");
        }
    }

    public abstract class AbstractFacade<T> {

    private Class<T> entityClass;
            private List<T> list;


    public AbstractFacade(Class<T> entityClass) {
        this.entityClass = entityClass;
    }

    protected abstract EntityManager getEntityManager();

    public T create(T entity) {
        try {
            getEntityManager().getTransaction().begin();
            getEntityManager().persist(entity);
            getEntityManager().getTransaction().commit();
            return entity;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return null;
    }

    public void edit(T entity) {
        try {
            getEntityManager().getTransaction().begin();
            getEntityManager().merge(entity);
            getEntityManager().getTransaction().commit();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

    }

    public void remove(T entity) {
        try {
            getEntityManager().getTransaction().begin();
            getEntityManager().remove(getEntityManager().merge(entity));
            getEntityManager().getTransaction().commit();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    public T find(Object id) {
        try {
            return getEntityManager().find(entityClass, id);
        } catch (Exception e) {
            return null;
        }
    }

    public List<T> findAll() {
        try {
            javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
            cq.select(cq.from(entityClass));
            return getEntityManager().createQuery(cq).getResultList();
        } catch (Exception e) {
            return null;
        }
    }

    public List<T> findRange(int[] range) {
        try {
            javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
            cq.select(cq.from(entityClass));
            javax.persistence.Query q = getEntityManager().createQuery(cq);
            q.setMaxResults(range[1] - range[0] + 1);
            q.setFirstResult(range[0]);

            return q.getResultList();
        } catch (Exception e) {
            return null;
        }
    }
    public List<T>findByOneParameter(String Table, Object param){
    CriteriaBuilder criteriabuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> q = criteriabuilder.createQuery(entityClass);
    Root<T> c = q.from(entityClass);
    ParameterExpression<Object> p = criteriabuilder.parameter(Object.class, Table);
    q.select(c).where(criteriabuilder.equal(c.get(Table), p));
    TypedQuery<T> query = getEntityManager().createQuery(q);
    query.setParameter(p, param);
    return list = query.getResultList();

    }

     public List<T>findBytwoParameter(String Table,String Table2, Object param, Object param2){
    CriteriaBuilder criteriabuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> q = criteriabuilder.createQuery(entityClass);
    Root<T> c = q.from(entityClass);
    ParameterExpression<Object> p = criteriabuilder.parameter(Object.class, Table);
    ParameterExpression<Object> p2 = criteriabuilder.parameter(Object.class, Table2);

    q.select(c).where(criteriabuilder.equal(c.get(Table2), p2), 
                      criteriabuilder.equal(c.get(Table), p));

    TypedQuery<T> query = getEntityManager().createQuery(q);
    query.setParameter(p, param);
    query.setParameter(p2, param2);
    return list = query.getResultList();

    }
     public List<T>findBythreeParameter(String Table,String Table2,String Table3, Object param, Object param2, Object param3){ 
    CriteriaBuilder criteriabuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<T> q = criteriabuilder.createQuery(entityClass);
    Root<T> c = q.from(entityClass);
    ParameterExpression<Object> p = criteriabuilder.parameter(Object.class, Table);
    ParameterExpression<Object> p2 = criteriabuilder.parameter(Object.class, Table2);
    ParameterExpression<Object> p3 = criteriabuilder.parameter(Object.class, Table3);

    q.select(c).where(criteriabuilder.equal(c.get(Table2), p2), 
                      criteriabuilder.equal(c.get(Table), p),
                      criteriabuilder.equal(c.get(Table3), p3));

    TypedQuery<T> query = getEntityManager().createQuery(q);
    query.setParameter(p, param);
    query.setParameter(p2, param2);
    query.setParameter(p3, param3);
    return list = query.getResultList();

    }

    public int count() {
        try {
            javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
            javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
            cq.select(getEntityManager().getCriteriaBuilder().count(rt));
            javax.persistence.Query q = getEntityManager().createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } catch (Exception e) {       
            return 0;


}
    }
}

    public class PlanningMapper extends AbstractFacade  implements IPlanningMapper{


    @PersistenceContext(unitName = "EJPlanningRestPU")
    private EntityManager em;
    private List<Planning> list;

    public PlanningMapper() {
        super(Planning.class);
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("EJPlanningRestPU");
        em = emf.createEntityManager();       }

    @Override
    protected EntityManager getEntityManager() {
        return em;
    }

    @Override
    public Planning getByDateAndGroupe(String Date, String Groupe) {
        Planning user = new Planning();
        try{
        list =super.findBytwoParameter("dateEvenement","Groupe",Date,Groupe);
        user = list.get(0);
        }catch(Exception e){
        return null;
        }
        return user;  
    }

}

公共类映射器扩展AbstractFacade实现IMapper{
@PersistenceContext（unitName=“EJPlanningRestPU”）
私人实体管理者；
私人名单；
公共制图器（T类）{
超级（T）；
EntityManagerFactory emf=Persistence.createEntityManagerFactory（“EJPlanningRestPU”）；
em=emf.createEntityManager（）；
}
@凌驾
受保护的EntityManager getEntityManager（）{
返回em；
}
@凌驾
公共无效添加（T项A）{
参数完整（项目A）；
super.create（itemA）；
}
@凌驾
公共作废更新（T项A）{
参数完整（项目A）；
超级编辑（itemA）；
}
@凌驾
公共作废删除（T项A）{
参数完整（项目A）；
超级。删除（第a项）；
}
@凌驾
公共T getById（int-id）{
参数完整（id）；
T item=（T）super.find（id）；
退货项目；
}
@凌驾
公共列表getAll（）{
list=super.findAll（）；
退货清单；
}
@凌驾
公共void参数null（对象参数）{
if（param==null）{
投掷ne