bonjour,

j'aimerais utiliser des générique pour éviter de toujours ecrire le meme code mais j'ai quelque souci :

voici ce que j'ai penser a crée :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public abstract class AbstractCore<E,F> {
     private Class<E> entityClass;
     private Class<F> facade;
 
   protected abstract F getEntityManager();
 
    public void Cree(E entity)  {
        facade.create(entity);
    }
 
     public List<E> allObject(){
 
        return facade.findAll();
    }
 
    public Civilite ObjectbyID(Object id){
       return facade.find(id);
    }
    public void Modifier(E entity){
        facade.update(entity);
    }
}

car pour le moment j'ai les méthodes suivante :


Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
public class CiviliteCore implements CiviliteInterface   {
 
    private CiviliteFacade civiliteFacade = new CiviliteFacade();
 
    public CiviliteCore() {
    }
 
    public void Cree(Civilite civilite)  {
 
       civiliteFacade.create(civilite);
    }
 
    public List<Civilite> allObject(){
 
        return civiliteFacade.findAll();
    }
 
    public Civilite ObjectbyID(Civilite civilite){
       return civiliteFacade.find(civilite.getKeyCivilite());
    }
    public void Modifier(Civilite civilite){
        civiliteFacade.update(civilite);
    }
 
}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public class TypeContactCore implements TypeContactInterface {
 
    private  TypeContactFacade typeContactFacade = new TypeContactFacade();
    @Override
    public void Cree(TypeContact typeContact) {
        typeContactFacade.create(typeContact);
    }
 
    @Override
    public List<TypeContact> allObject() {
       return typeContactFacade.findAll();
    }
 
    @Override
    public TypeContact ObjectbyID(TypeContact typeContact) {
      return  typeContactFacade.find(typeContact.getKeyTypeContact());
    }
 
    @Override
    public void Modifier(TypeContact typeContact) {
        typeContactFacade.update(typeContact);
    }
 
}

facade extends tous

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
package fr.ietevents.serviceweb.Facades;
 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
 
/**
 *
 * @author Coshom
 */
public abstract class AbstractFacade<T> {
 
    private Class<T> entityClass;
    final String urlDB = "fr.ietevents_ServiceWeb_war_1.0-SNAPSHOTPU";
 
    public AbstractFacade(Class<T> entityClass) {
        this.entityClass = entityClass;
    }
 
    protected abstract EntityManager getEntityManager();
 
    public void create(T entity) {
        EntityManager em = getEntityManager();
        EntityTransaction tx = em.getTransaction();
        //System.out.println( "Début de la transaction");
        tx.begin();
        try {
            //  System.out.println( "Ajout du client dans la base en cours..." );
            em.persist(entity);
            em.flush();
            em.refresh(entity);
            tx.commit();
            //  System.out.println( "Transaction validée");
        } catch (Exception e) {
            System.out.println("Erreur :" + e.getMessage());
            tx.rollback();
 
        } finally {
 
            em.close();
 
        }
 
    }
 
    public void update(T entity) {
        EntityManager em = getEntityManager();
        EntityTransaction tx = em.getTransaction();
 
        tx.begin();
        try {
 
            em.merge(entity);
            em.flush();
            tx.commit();
        } catch (Exception e) {
            System.out.println("Erreur :" + e.getMessage());
            tx.rollback();
 
        } finally {
            em.close();
 
        }
 
    }
 
    public void remove(T entity) {
        getEntityManager().remove(getEntityManager().merge(entity));
    }
 
    public T find(Object id) {
        return getEntityManager().find(entityClass, id);
    }
 
    public List<T> findAll() {
        javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
        cq.select(cq.from(entityClass));
        return getEntityManager().createQuery(cq).getResultList();
    }
 
    public List<T> findRange(int[] range) {
        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]);
        q.setFirstResult(range[0]);
        return q.getResultList();
    }
 
    public int count() {
        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();
    }
 
}