Newsgroup: it.comp.java
Titolo: Importare valore da JavaBean.....

Salve ragazzi,
ho un problema da porvi.
Realizzando un'applicazione JSF ho avuto un problema.
Se in un javabean ho un metodo voglio lanciare per recuperare un
outcome di tipo stringa per la navigazione lo lancio semplicemente
dalla mia pagina JSP ed ho risolto il problema.
Se però questo metodo lo devo lanciare ,ma mi interessa il valore di
una variabile in particolare dopo l'esecuzione di questo metodo come la
importo?
Cioè ammettiamo che questa sia la parte interessata della mia pagina
JSP MyResult.jsp
codice:
<h:outputText value="File Name:"/>
        <h:outputText value="#{
myBean.myFile.name
}"/>
        <h:outputText value="File Size:"/>
        <h:outputText value="#{myBean.myFile.size}"/>
        <h:outputText value="Col Size:"/>
        <h:outputText value="#{myBean.col}"/>
        <h:outputText value="File Size:"/>
        <h:outputText value="#{myBean.row}"/>
Supponiamo che mi interessi tirare fuori e visualizzare il numero di
righe e di colonne del file calcolato con il seguente javabean
codice:package com.devsphere.articles.jsfupload;
import org.apache.myfaces.custom.fileupload.UploadedFile;
import java.io.IOException;
import java.util.Map;
import java.util.StringTokenizer;
import java.io.*;
public class MyBean {
    private UploadedFile myFile;
    private int row=0;
    private int col=0;
    private int numberOfNumericColumns =0;
    public UploadedFile getMyFile() {
        return myFile;
    }
    public void setMyFile(UploadedFile myFile) {
        this.myFile = myFile;
    }
    public String processMyFile() throws IOException {
        BufferedReader br = new BufferedReader(new
InputStreamReader(myFile.getInputStream()));
        String line = br.readLine();
        StringTokenizer st = new StringTokenizer(line);
        col=st.countTokens();
        while (line != null) {
         row++;
         line = br.readLine();
        }
        return "success";
    }
}
type Exception report
message
description The server encountered an internal error () that prevented
it from fulfilling this request.
exception
javax.servlet.ServletException: #{myBean.processMyfile}:
javax.faces.el.MethodNotFoundException: processMyfile:
com.devsphere.articles.jsfupload.MyBean.processMyfile()
javax.faces.webapp.FacesServlet.service(FacesServlet.java:209)
org.apache.myfaces.webapp.filter.ExtensionsFilter.doFilter(ExtensionsFilter.java:144)
root cause
javax.faces.FacesException: #{myBean.processMyfile}:
javax.faces.el.MethodNotFoundException: processMyfile:
com.devsphere.articles.jsfupload.MyBean.processMyfile()
com.sun.faces.application.ActionListenerImpl.processAction(ActionListenerImpl.java:74)
javax.faces.component.UICommand.broadcast(UICommand.java:312)
javax.faces.component.UIViewRoot.broadcastEvents(UIViewRoot.java:267)
javax.faces.component.UIViewRoot.processApplication(UIViewRoot.java:381)
com.sun.faces.lifecycle.InvokeApplicationPhase.execute(InvokeApplicationPhase.java:75)
com.sun.faces.lifecycle.LifecycleImpl.phase(LifecycleImpl.java:200)
com.sun.faces.lifecycle.LifecycleImpl.execute(LifecycleImpl.java:90)
javax.faces.webapp.FacesServlet.service(FacesServlet.java:197)
org.apache.myfaces.webapp.filter.ExtensionsFilter.doFilter(ExtensionsFilter.java:144)
Vi ringrazio anticipatamente

importo?
Eh?
Descrivi meglio cosa vuoi fare...
e quel codice sinceramente non vedo cosa c'entri. Poi alla fine mostri anche 
un eccezione..prima pero' hai fatto una domanda generica...
Se vuoi fare un esempio cerca di ripulirlo dalle cose che non hanno a che 
fare con la domanda. 

Scusate la mia scarsa dimestichezza nello spiegarvi il problema,ma sono
alle prime armi.
Devo realizzare una applicazione JSF che mi permetta di fare l'upload
di un file e l'analisi del file per determinarne numero di righe e di
colonne.
A tal proposito ho realizzato una classe java che dovrebbe fare
correttamente queste operazioni,cioè carica il file "uploadato" come
inputstream e calcola il numero di righe e di colonne.
package com.devsphere.articles.jsfupload;
import org.apache.myfaces.custom.fileupload.UploadedFile;
import java.io.IOException;
import java.util.Map;
import java.util.StringTokenizer;
import java.security.MessageDigest;
import java.io.*;
public class MyBean {
    private UploadedFile myFile;
    private int row=0;
    private int col=0;
    private int numberOfNumericColumns =0;
    public UploadedFile getMyFile() {
        return myFile;
    }
    public void setMyFile(UploadedFile myFile) {
        this.myFile = myFile;
    }
    public String processMyFile() throws IOException {
    	BufferedReader br = new BufferedReader(new
InputStreamReader(myFile.getInputStream()));
    	String line = br.readLine();
        StringTokenizer st = new StringTokenizer(line);
        col=st.countTokens();
        while (line != null) {
         row++;
         line = br.readLine();
        }
        return "success";
    }
}
La pagina in cui faccio l'upload è
Myform.jsp
<%@ taglib uri="
http://java.sun.com/jsf/core
" prefix="f"%>
<%@ taglib uri="
http://java.sun.com/jsf/html
" prefix="h"%>
<%@ taglib uri="
http://myfaces.apache.org/tomahawk
" prefix="t"%>
<f:view>
<h:form id="MyForm" enctype="multipart/form-data" >
    <h:messages globalOnly="true" styleClass="message"/>
    <h:panelGrid columns="3" border="0" cellspacing="5">
        <h:outputLabel for="myFileId" value="File: "/>
        <t:inputFileUpload id="myFileId"
            value="#{myBean.myFile}"
            storage="file"
            required="true"/>
        <h:message for="myFileId"/>
        <h:outputText value=" "/>
        <h:commandButton value="Submit"
            action="#{myBean.processMyfile}"/>
        <h:outputText value=" "/>
    </h:panelGrid>
</h:form>
</f:view>
Quello che adesso voglio fare è creare una pagina JSP che mi mostri le
informazioni sul file,cioè nome e dimensione(intrinseche e calcolabili
facilmente tramite i metodi dell'interfaccia importata) e numero di
colonne e di righe(col e row) prese dal javaBean.
La pagina che ho scritto è:
Myresult.jsp
<%@ taglib uri="
http://java.sun.com/jsf/core
" prefix="f"%>
<%@ taglib uri="
http://java.sun.com/jsf/html
" prefix="h"%>
<f:view>
    <h:panelGrid columns="2" border="0" cellspacing="5">
        <h:outputText value="File Name:"/>
        <h:outputText value="#{
myBean.myFile.name
}"/>
        <h:outputText value="File Size:"/>
        <h:outputText value="#{myBean.myFile.size}"/>
        <h:outputText value="Col Size:"/>
        <h:outputText value="#{myBean.col}"/>
        <h:outputText value="Rowe Size:"/>
        <h:outputText value="#{myBean.row}"/>
    </h:panelGrid>
</f:view>
Ma lanciando l'applicazione questa non parte.
Sono sicuro di aver sbagliato la"gestione del javaBean",perchè se
faccio visualizzare solo nome e dimensione del file(non legate al
javabean) tutto funziona a meraviglia.
Potete aiutarmi?
Grazie.
Vi posto per comodità anche il web.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC
    "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "
http://java.sun.com/dtd/web-app_2_3.dtd
">
<web-app>
    <context-param>
        <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
        <param-value>client</param-value>
    </context-param>
	<filter>
        <filter-name>ExtensionsFilter</filter-name>
        <filter-class>
            org.apache.myfaces.component.html.util.ExtensionsFilter
        </filter-class>
        <init-param>
            <param-name>uploadMaxFileSize</param-name>
            <param-value>100m</param-value>
        </init-param>
        <init-param>
            <param-name>uploadThresholdSize</param-name>
            <param-value>100k</param-value>
        </init-param>
   	</filter>
    <filter-mapping>
        <filter-name>ExtensionsFilter</filter-name>
        <servlet-name>FacesServlet</servlet-name>
    </filter-mapping>
    <servlet>
        <servlet-name>FacesServlet</servlet-name>
        <servlet-class>
            javax.faces.webapp.FacesServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>FacesServlet</servlet-name>
        <url-pattern>/faces/*</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>FacesServlet</servlet-name>
        <url-pattern>*.faces</url-pattern>
    </servlet-mapping>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>
e il faces-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD
JavaServer Faces Config 1.1//EN"
"
http://java.sun.com/dtd/web-facesconfig_1_1.dtd
">
<faces-config>
 <managed-bean>
  <managed-bean-name>myBean</managed-bean-name>
<managed-bean-class>com.devsphere.articles.jsfupload.MyBean</managed-bean-class>
  <managed-bean-scope>request</managed-bean-scope>
 </managed-bean>
 <navigation-rule>
  <from-view-id>/pages/MyForm.jsp</from-view-id>
  <navigation-case>
   <from-outcome>success</from-outcome>
   <to-view-id>/pages/MyResult.jsp</to-view-id>
  </navigation-case>
 </navigation-rule>
</faces-config>
Sperando di essere stato più chiaro,vi ringrazio in anticipo.


Mi sembrerebbe strano se jsf, a differenza di tutti gli altri framework
lavorasse con gli attributi di un bean (per di più private !!),
anzichè che con i metodi.
In soldoni, devi creare i metodi getter di col e row

        <h:outputText value=" "/>
Oltre a quanto detto da pioneer, c'e' anche il problema che il metodo 
processMyfile non esiste.
Semmai esiste processMyFile (notare le maiuscole).

pio...@inwind.it
 ha scritto:

Grazie dell'aiuto,
ma ho modificato il MyBean.java,ma ho sempre lo stesso errore.Cosa
sbaglio ancora?
Scusami ma è la prima volta che faccio quest'operazione..
package com.devsphere.articles.jsfupload;
import org.apache.myfaces.custom.fileupload.UploadedFile;
import java.io.IOException;
import java.util.Map;
import java.util.StringTokenizer;
/*import java.util.HashMap;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;*/
import java.security.MessageDigest;
//import java.security.NoSuchAlgorithmException;
import java.io.*;
public class MyBean {
    private UploadedFile myFile;
    //private Map <String, double[]>dataMap=null;
    private int row=0;
    private int col=0;
    private int numberOfNumericColumns =0;
    public UploadedFile getMyFile() {
        return myFile;
    }
    public void setMyFile(UploadedFile myFile) {
        this.myFile = myFile;
    }
    public String processMyFile() throws IOException {
    	BufferedReader br = new BufferedReader(new
InputStreamReader(myFile.getInputStream()));
    	String line = br.readLine();
        StringTokenizer st = new StringTokenizer(line);
        col=st.countTokens();
        while (line != null) {
         row++;
         line = br.readLine();
        }
        return "success";
    }
    public  int getrow(){
    	return row;
    }
    public  int getcol(){
    	return col;
    }
    public void setcol(int col) {
        this.col = col;
    }
    public void setrow(int row) {
        this.row = row;
    }
}
Il resto devo lasciarlo inalterato?
Cioè col e row devo richiamarli sempre come fatto nelle pagine che ti
ho postato prima?
Ti prego aiutami..

 Ti prego aiutami..
L'iniziale dell'attributo nel nome del metodo deve essere maiuscola
(getRow ecc...)
Il resto va bene

cicap ha scritto:

Grazie ragazzi,
ho risolto e funziona tutto egregiamente....
non so come ringraziarvi,spero di imparare presto da questi errori

In realtà avrei una curiosità e un consiglio ancora da chiedervi.
Sempre nella stessa applicazione JSF ho aggiunto delle righe di codice
al mio MyBean che di seguito vi riporto per cominciare a gestire la
fase di archiviazione del file che ho dato in upload.
In realtà quello che devo fare è questo:
dovrei memorizzare in un array di byte questo file per poi inserirlo
così com'è in un campo blob di una tabella.
La cosa importante è che però,dovendo eseguire in un secondo momento
una query su questo campo blob devo essere in grado di "ricostruire" il
file per effettuarne la query.
Avrei bisogno quindi di convertire il file in un array di byte ma
secondo un formato interno mio,che mi consenta l'operazione inversa.Per
fare ciò penso siano utili il numero di righe e di colonne calcolate
precedentemente.
Come mi consigliate di agire?
Sono molto inesperto,quindi non ho ancora le idee chiare.
Avevo pensato,come vedrete nel bean che vi posto,di memorizzare il file
in una HashMap,ma poi?
Come la converto in un array di byte ricostruibile in fase di query?
Sto trovando molti problemi a livello di strategia,se qualcuno può
aiutarmi vi ringrazio in anticipo.
Ecco il bean che ho modificato:
codice:
package com.devsphere.articles.jsfupload;
import org.apache.myfaces.custom.fileupload.UploadedFile;
import java.io.IOException;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.HashMap;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import java.io.*;
public class MyBean {
    private UploadedFile myFile;
    private Map <String, double[]>dataMap=null;
    private int row=0;
    private int col=0;
    private int numberOfNumericColumns =0;
    public UploadedFile getMyFile() {
        return myFile;
    }
    public void setMyFile(UploadedFile myFile) {
        this.myFile = myFile;
    }
    public String processMyFile() throws IOException {
    	BufferedReader br = new BufferedReader(new
InputStreamReader(myFile.getInputStream()));
    	this.dataMap = new HashMap<String, double[]>();
        System.out.println("Caricamento dell'array di double in
corso.....");
        // Store each line of the input file as a separate key and
entry in  the Map.
        String line = null;
        while ((line = br.readLine()) != null) {
            line = line.replace (',', '.');
            row++;
            // Create a tokenizer for the line.
            StringTokenizer st = new StringTokenizer(line);
            // Assuming that the first column of every row is a String
and
            //the remaining columns  are numbers, count the number of
numeric columns.
            numberOfNumericColumns = (st.countTokens()-1);
            col=(numberOfNumericColumns+1);
            // Get the first token from the line. It will be a String
and
            //its value will be a  unique key for the rest of the row.
            String key = st.nextToken().trim();
            // Create the array for the numbers which make up the rest
of the line.
            double[] array = new double[numberOfNumericColumns];
            // Populate the array by parsing the rest of the line.
            for (int column = 0; column < numberOfNumericColumns;
column++){
                array[column] =
Double.parseDouble(st.nextToken().trim());
            }
            // Store the first column as the key and the array as the
entry.
            this.dataMap.put(key, array); //Associates the specified
value with
            //the specified key in this map.
        }
 
        return "success";
    } 
 
}