Problème remplir un DataTable à partir de mysql

**tarask** · 09/02/2011, 15h00

Bonjour cela fait 2 jours que je cherche a trouver une solutions partout mais en vaint je n'ai pas reussi j'espere que quelqu'un pourra m'aider , j'utilise jsf 2.0 et donc j'aimerai remplir un DataTable a partir d'une table dans mysql , j'arrive a remplir mon tableau quandje rentre des informations en dur et j'arrive aussi a enregistrer toutes les données, que je veux recupérer ,dans une ArrayList tout cela marche mais je ne sais pour quel raison juste au moment où je rentre dans le tableau (regarder en faisant du debuggage pas a pas ) ma ArrayList en vider et donc je me retrouve avec un tableau vide
voici le code:

ma pagewelcomeJSF.jsp

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
   <%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="html" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="core" %>
 
<%@ page import="java.sql.*"%>
<%@ page import="java.io.*" %>
<%@ page import="java.util.*"%>
<%@ page import="java.sql.Connection"%>
<%@ page import="java.sql.DriverManager"%>
 
<%@ page import="beanPackage.*" %>
 
 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
 
<%--
    This file is an entry point for JavaServer Faces application.
--%>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title> Configuration fichier Automatique </title>
    </head>
    <body>
 
<%--Connection to BDD --%>
<%
 
    String test;
    Integer compteur; 
    List<Rpt> testlist ;
    DataTableRptBean DataTableRptBean = new DataTableRptBean();
 
try {
 
// Load JBBC driver "com.mysql.jdbc.Driver"
Class.forName("com.mysql.jdbc.Driver").newInstance();
 
/* Create a connection by using getConnection() method that takes parameters of
string type connection url, user name and password to connect to database. */
Connection connection =DriverManager.getConnection ("jdbc:mysql://localhost/wrs?characterEncoding=UTF-8","wrs", "17janvier");
 
Statement requete = connection.createStatement();
ResultSet resultat = requete.executeQuery("SELECT rpt_file,rpt_dbname,rpt_dbuser,rpt_theme_id from wrs_rpt where rpt_id<9 ");
if(resultat.next())
     {
 
    do
        {
 DataTableRptBean.setRpt(resultat.getString(1),resultat.getString(2),resultat.getString(3),resultat.getString(4));
 test=DataTableRptBean.testRpt();
compteur=DataTableRptBean.testCompteurRpt();
 out.println(test);
 out.println("compteur :"+compteur);
   //   out.println(resultat.getString(1)+"\t"+resultat.getObject(2)+"\t"+resultat.getObject(3)+"\t"+resultat.getString(4));
    %>
    <br>  
    <%
    }
    while(resultat.next());
    testlist=DataTableRptBean.getRpt();
    out.println("ATTENTION :"+testlist.get(0).getRptName());
}
testlist=DataTableRptBean.getRpt();
//out.println("Connexion avec succes " + "MySQL serveur utilisé TCP/IP...");
 
connection.close();
}
catch(Exception e){
 
out.println("impossible de se connecter a la base de donnees test");
out.println(e);
}
testlist=DataTableRptBean.getRpt();
%>
 
        <core:view>
          <html:form >
              <html:dataTable value="#{tablerpt.rpt}" var="rpt" border="1" cellspacing="4" width="80%">
                  <html:column>
                      <core:facet name="header">
                          <html:outputText value="Nom du fichier :"/>
                      </core:facet>
                      <html:outputText value="#{rpt.rptName}"/>
                  </html:column>
                  <html:column>
                      <core:facet name="header">
                          <html:outputText value="Société :"/>
                      </core:facet>
                      <html:outputText value="#{rpt.rptDbName}"/>
                  </html:column>
                  <html:column>
                      <core:facet name="header">
                          <html:outputText value="Nom du créateur :"/>
                      </core:facet>
                      <html:outputText value="#{rpt.rptDbUser}"/>
                  </html:column>
                  <html:column>
                      <core:facet name="header">
                          <html:outputText value="thème :"/>
                      </core:facet>
                      <html:outputText value="#{rpt.rptThemeId}"/>
                  </html:column>
              </html:dataTable>
         <br>
              <html:outputText value="Nom du fichier:  "/>
              <html:inputText id="runrpt_name" value="#{formulaire.runrpt_name}"/>
         <br>
              <html:outputText value="Liste déroulante des rapports:  "/>
         <br>
              <html:outputText value="Nom du fichier que le Subsriber apercevra:  "/>
              <html:inputText id="runrpt_pfx"value="#{formulaire.runrpt_pfx}"/>
         <br>
         <h4> <html:outputText value="Format du fichier à envoyer :  "/>
              <html:selectOneMenu value="#{formulaire.format}">
              <core:selectItems value="#{formulaire.formatValue}"></core:selectItems>
              </html:selectOneMenu>
         </h4>
        <br>
              <html:commandButton value="Valider" action="validation.jsp" />
	<br>
           </html:form>
        </core:view>
 
<%
testlist=DataTableRptBean.getRpt();
out.println("ATTENTION :"+testlist.get(0).getRptName());
%>
 
 
</body>
</html>

mon bean datatableaurptbean.java:

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
 
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
@ManagedBean(name="tablerpt")
@SessionScoped
/**
 *
 * @author stag
 */
public class DataTableRptBean implements Serializable {
    public List<Rpt> refRpt;
    public List<Rpt> TestRpt;
    private String test;
    private int compteurRpt;
    private String testName,testDbName,testDbUser,testThemeId;
 
    public DataTableRptBean()
    {
       if(refRpt==null)
        {
        refRpt = new ArrayList<Rpt>();
       }
        test="";
        compteurRpt=0;
    }
 
    public void setRpt(String pRptName,String pRptDbName,String pRptDbUser,String pRptThemeId)
    {
 
            refRpt.add(new Rpt(pRptName,pRptDbName,pRptDbUser,pRptThemeId));
 
            testName= refRpt.get(compteurRpt).getRptName();
            testDbName= refRpt.get(compteurRpt).getRptDbName();
            testDbUser= refRpt.get(compteurRpt).getRptDbUser();
            testThemeId= refRpt.get(compteurRpt).getRptThemeId();
            test=testName+"/"+testDbName+"/"+testDbUser+"/"+testThemeId;
            //test=pRptName+"/"+pRptDbName+"/"+pRptDbUser+"/"+pRptThemeId;
 
    }
    public String testRpt()
    {
        return test;
    }
    public int testCompteurRpt()
    {
        compteurRpt=compteurRpt+1;
        return compteurRpt;
    }
    public List<Rpt> getRpt()
     {
      if(refRpt==null)
             {
 
                 TestRpt = new ArrayList<Rpt>();
                 TestRpt.add(new Rpt("Votre","BaseDonné","est","vide"));
 
 
                  return TestRpt;
              }
 
         return ((List)refRpt);
        }
 
 
}

et ma page rpt.java

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
 
package beanPackage;
import java.io.Serializable;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
@ManagedBean(name="rpt")
@RequestScoped
/**
 *
 * @author stag
 */
public class Rpt implements Serializable {
    private String rptName;
    private String rptDbName;
    private String rptDbUser;
    private String rptThemeId;
    public  Rpt()
    {
        rptName="";
        rptDbName="";
        rptDbUser="";
        rptThemeId="";
    }
    public Rpt(String pRptName,String pRptDbName,String pRptDbUser,String pRptThemeId)
    {
        rptName=pRptName;
        rptDbName=pRptDbName;
        rptDbUser=pRptDbUser;
        rptThemeId=pRptThemeId;
    }
 
    public String getRptName()
    {
        return rptName;
    }
    public void setRptName(String pRptName)
    {
        rptName=pRptName;
    }
    public String getRptDbName()
    {
        return rptDbName;
    }
    public void setRptDbName(String pRptDbName)
    {
        rptDbName=pRptDbName;
    }
    public String getRptDbUser()
    {
        return rptDbUser;
    }
    public void setRptDbUser(String pRptDbUser)
    {
        rptDbUser=pRptDbUser;
    }
    public String getRptThemeId()
    {
        return rptThemeId;
    }
    public void setRptThemeId(String pRptThemeId)
    {
        rptThemeId=pRptThemeId;
    }
}

je remercie a la personne qui maiderai parceque je suis vraiment a bout

**kimausoleil** · 09/02/2011, 20h39

Salut !

Pour commencer, je trouve que tu t'y prends pas très bien (quand je vois ta page jsp et ton managed-bean...) !

Après je te conseille tout simplement d'utiliser la couche de persistence avec JPA pour te connecter à à ta base et lier tes entités !

Perso, j'utilise NetBeans 6.9.1 et tout se fait très simplement : tu installes glassfish (c'est avec NetBeans), tu crées un projet Web en choisissant ton framework JSF.

Puis tu choisis de créer tes entités à partir de ta base de données : la connexion à ta base, et ton unité de persistence se créent tout seul !

Exemple avec, dans ma base, une table de clients telle que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
-------------------------
 t_client
-------------------------
 + cid : int(10)
 + cnom : varchar(30)
 + cprenom : varchar (30)
--------------------------

Je génère mon entité (classe objet Client) :

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
 
@Entity
@Table(name = "t_client")
public class Client implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "cid")
    private Integer id;
 
    @Basic(optional = false)
    @Column(name = "cnom")
    private String nom;
 
    @Basic(optional = false)
    @Column(name = "cprenom")
    private String prenom;
 
    public Client() {
    }
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getNom() {
        return nom;
    }
 
    public void setNom(String nom) {
        this.nom = nom;
    }
 
    public String getPrenom() {
        return prenom;
    }
 
    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }
 
    @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 Client)) {
            return false;
        }
        Client other = (Client) 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 "Client[cid=" + id + "]";
    }
 
}

et mon fichier persistence.xml qui s'est créé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  <persistence-unit name="TestPU" transaction-type="JTA">
    <jta-data-source>jdbc/mabasededonnees</jta-data-source>
    <properties/>
  </persistence-unit>
</persistence>

Puis tu génères ton session-bean qui est le conteneur qui assurera la persistence de ton entité :

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
 
@Stateless
public class ClientFacade extends AbstractFacade<Client> implements ClientFacadeLocal, ClientFacadeRemote {
 
    @PersistenceContext(unitName = "TestPU")
    private EntityManager em;
 
    @Override
    protected EntityManager getEntityManager() {
        return em;
    }
 
    public ClientFacade() {
        super(Client.class);
    }
}

accompagné de ta classe abstraite AbstractFacade et de l'interface ClientFacadeLocal créées automatiquement :

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
 
public abstract class AbstractFacade<T> {
    private Class<T> entityClass;
 
    public AbstractFacade(Class<T> entityClass) {
        this.entityClass = entityClass;
    }
 
    protected abstract EntityManager getEntityManager();
 
    public void create(T entity) {
        getEntityManager().persist(entity);
    }
 
    public void edit(T entity) {
        getEntityManager().merge(entity);
    }
 
    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();
    }
 
}

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
 
@Local
public interface ClientFacadeLocal {
 
    Client authenticate(String login, String password);
 
    void create(Client client);
 
    void edit(Client client);
 
    Client find(Object id);
 
    List<Client> findAll();
 
    List<Client> findRange(int[] range);
 
    int count();
}

Donc jusque là, il n'y a rien eu à faire, tout a été généré automatiquement par NetBeans !

Tu crées alors ton managed-bean :

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
 
@ManagedBean
@RequestScoped
public class ClientBean {
 
    @EJB
    private ClientFacadeLocal ejb;
    private List<Client> clientList;
 
    /** Creates a new instance of ClientBean */
    public ClientBean() {
    }
 
    @PostConstruct
    private void load() {
        clientList = ejb.findAll();
    }
 
    public List<Client> getClientList() {
        return clientList;
    }
 
}

Là pas trop de code à faire, mais pour charger ta liste de ta base de données, il faut utiliser une méthode annotée avec @PostConstruct...

Et dans ta page xhtml (plus préférable avec JSF2 qu'une pas jsp), tout simplement :

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
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:h="http://java.sun.com/jsf/html">
    <f:view contentType="text/html">
        <h:head>
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
            <title>Exemple</title>
        </h:head>
        <h:body>
            <p>
                Affichage de la liste des clients :
            </p>
            <h:dataTable var="client" value="#{clientBean.clientList}">
                <h:column>
                    <f:facet name="header">ID</f:facet>
                    <h:outputText value="#{client.id}" />
                </h:column>
                <h:column>
                    <f:facet name="header">NOM</f:facet>
                    <h:outputText value="#{client.nom}" />
                </h:column>
                <h:column>
                    <f:facet name="header">PRENOM</f:facet>
                    <h:outputText value="#{client.prenom}" />
                </h:column>
            </h:dataTable>
        </h:body>
    </f:view>
</html>

Et voilà, ta liste est chargée à partir de ta base de données !

Donc finalement, très peu de code écrit (managed-bean + page xhtml) pour un affichage d'une liste liée à ta base de données !

Avec un exemple concret, j'espère t'avoir montrer qu'en utilisant un EDI comme NetBeans (ou Eclipse), tu te simplifies extrêment la tâche !

**tarask** · 10/02/2011, 08h59

Merci beaucoup pour ta réponse j'utilise en effet netbeans 6.9.1 mais j'utilise TomCat.Mais j'aimerai bien savoir mon erreur parceque tu viens de me dire marcher très ma liste est bien complèter a partir de ma base de données mais il y a un moment où quelque chose fais quel est effacé et j'aimerai bien savoir pourquoi ? peu etes un probleme au niveau du cycle de vie ?

et existe t'il une palette graphique complete de composant JSF 2.O sous netbeans 6.9.1

je suis debutant dans ce framework et j'avou avoir du mal sur certaines choses

**kimausoleil** · 10/02/2011, 11h41

Je pense que tu persistes dans la mauvaise méthode !
Surtout si tu utilises NetBeans 6.9.1, essaie donc de faire comme mon exemple !

**romaintaz** · 10/02/2011, 11h51

De toutes façons, ta page JSP est en partie à oublier car en JSF 2.0, il te faut faire du XHTML (c'est presque comme le JSP, mais en XML si tu veux), et surtout les scriplets (les trucs entre <% %>), ça devrait être interdit tellement ça fait du mauvais code !

**tarask** · 10/02/2011, 11h52

le probleme c'est que je suis obligé d'utilisé tomcat comme conteneur, je suis en stage dans une entreprise et c'est celui la qu'il utilise .et ton exemple j'ai forcement besoin de glassfish ?

**romaintaz** · 10/02/2011, 13h48

Tu peux tout à fait utiliser Tomcat.

Problème remplir un DataTable à partir de mysql

JSF Java

Vue hybride

Discussions similaires

Partager

Partager