Newsgroup: it.comp.java
Titolo: Help!!!!! getDeclaredMethod - invoke

Ho il seguente problema:
Siccome ho un oggetto che uso spesso in diversi progetti e che adatto di
volta in volta, vorrei poterlo generalizzare.
Il problema è che gli adattamenti che faccio, sono le chiamate a dei metodi
di una classe (un Model) che cambia di volta in volta e che contiene le
chiamate alle Stored Procedure.
Volevo creare una serie di metodi che permettono di specificare classe
(Model), metodo e parametri da chiamare per poi lavorarci.
Ho usato il metodo "getDeclaredMethod" della classe Class, per prendermi il
Metodo della classe che mi interessa, ma già qui il primo problema, se la
classe vuole come parametri elementari come gli int o i long, come li
trasformo in una classe da passare all'array di classi necessario per il
suddetto metodo?
Una volta ottenuto il metodo, come uso invoke?
Vuole un'array di oggetti che indicano i parametri del metodo.
In sostanza io vorrei poter fare una cosa simile:
ClasseGenerica myClass = new ClasseGenerica();
myClass.lanciaStored("agendaM","LeggiDatiCliente", parametri[]) -> accetto
consigli su come passare i parametri
Devo passare un'array che può contenere
qualunque tipo. Pensavo ad un Vetor o ad un
HaschTable
Allego il mio codice di esempio (studio), scusate se è un po' criptico, ma
sto cercando di capire come funzionano questi elementi.
        provami p = new provami();
        Object obj = (Object) p;
        Class c = obj.getClass();
        int argomenti = 3;
        Class arg[] = new Class[argomenti];
        try
        {
            arg[0] = Class.forName("java.lang.String");
            arg[1] = Class.forName("java.lang.String");
            arg[2] = Class.forName("java.lang.Object");
            Method m = c.getDeclaredMethod("pippo", arg);
            m.invoke(obj,(Object[])arg);
        }catch(ClassNotFoundException e){
            System.out.println(e);}
        catch(NoSuchMethodException e){
            System.out.println(e);}
        catch(SecurityException e){
            System.out.println(e);}
        catch(IllegalAccessException e){
            System.out.println(e);}
        catch(IllegalArgumentException e){
            System.out.println(e);}
        catch(InvocationTargetException e){
            System.out.println(e);}
        catch(NullPointerException e){
            System.out.println(e);}
--
Danilo Cividin
E-Mail 
dciv...@tiscalinet.it

Dimenticavo di ringraziare tutti e in particolar modo chi avrà anche solo la
pazienza di leggere tutto il post.
Ciao e grazie
AIUTATEMI !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Non serve più, ho risolto da solo.

Non serve più, ho risolto da solo.
Ci dici come? :-)
-- 
Ciao
	Fabrizio C.

Come dissi qualche thread fa, avevo necessità di sviluppare un metodo al
quale si passavano: nome di una classe generica, metodo della classe
generica, parametri del metodo; e questo lanciava suddetto metodo.
Io ho risolto da solo il mio problema, ma qualcuno mi ha chiesto come ho
fatto.
Allego la risposta data a Fabrizio per E-Mail, spero che possa essere di
aiuto ad altri.
Se c'è qualche esperto che sa come migliorare o potenziare il tutto, mi
farebbe piacere avere dei consigli.
// ------------------------------------------------------------------ //
Ciao Fabrizio, io ho risolto così :
Ti allego il codice di prova, ovviamente non è stato ottimizzato per tutte
le possibilità.
Purtroppo che come hanno visto le potenzialità di una struttura così
dinamica i miei BOSS hanno pensato bene di bocciarla.
Allora, questo metodo da inserire dove ti fa più comodo, permette di
lanciare il metodo di una classe generica.
Ovvio che non è possibile in fase di compilazione capire se il numero
l'ordine e i tipi di parametri di passaggio del metodo che vuoi eseguire
sono corretti, così come non puoi sapere sempre in fase di compilazione se
la classe e il suo metodo esistono.
Ma possiamo controllare in fase di RUN, grazie ai mitici Try e Catch (tipo
Starky ed Atch, mo non me ricordo come se scrivono)
private void pippo(String nomeClasse,String nomeMetodo, Vector argomenti)
    // il tipo di ritorno sceglilo tu.
    // Io ho usato un Vector per passare i paramtri di passaggio del metodo.
    // Ricordati che se devi passare un numero int, float etc. devi passare
al Vector una classe Integer etc.
{
    int numEl = argomenti.size();
    Class  argomentiC[] = new Class[numEl];  // Questo array serve per
ricavare il metodo dalla classe
    Object args[] = new Object[numEl];         //  Questo viene utilizzato
per lanciare il metodo
    Object tmp = null;
// Ora mi estraggo tutti i tipi
// Per ora a me servivano solo stringhe quindi non ho gestito il caso dei
numeri
// ricordati però che per passare la classe di un int per esempio, all'array
di classi devi fare così
// es. argomentiC[i]  = int.class;
// quindi devi vedere se quello che torna dal Vector è un oggetto Integer
(per esempio) e fare come sopra.
// Sicuramente c'è una strada più semplice, ma non sono così esperto da
giurartelo.
    for(int i=0; i<numEl; i++)
    {
        tmp = argomenti.elementAt(i);
        argomentiC[i] = argomenti.elementAt(i).getClass();  // Carico le
classi nell'array quindi i TIPI
        args[i] = argomenti.elementAt(i);                             //
Carico i VALORI nell'array
    }
    try
    {
        Class useClass = Class.forName(nomeClasse);         // Carico la
classe che contiene il metodo
        Method m = useClass.getDeclaredMethod(nomeMetodo, argomentiC); // Mi
ricavo il metodo (se esiste)
        m.invoke(useClass,args);     // Lo lancio
    }catch(ClassNotFoundException e){
        System.out.println(e);}
    catch(NoSuchMethodException e){
        System.out.println(e);}
    catch(SecurityException e){
        System.out.println(e);}
    catch(IllegalAccessException e){
        System.out.println(e);}
    catch(IllegalArgumentException e){
        System.out.println(e);}
    catch(InvocationTargetException e){
        System.out.println(e);}
    catch(NullPointerException e){
        System.out.println(e);}
}
Spero che il codice sia chiaro, sicuramente le mie spiegazioni no........
Ciao