La riflessione Java resa semplice

17 settembre 2018

sommario

La riflessione Java resa semplice

GiavaDiriflessionePresentazione di una classe di utilità che consente di utilizzare facilmente l'API.

Cos'è la riflessione?

API di riflessionedenti,"java.lang.reflect” incluso nella confezione,
Si tratta di un'API che recupera informazioni come campi e metodi dalle classi Java.
Vengono utilizzate principalmente le seguenti classi.

java.lang.Class
java.lang.reflect.Constructor
java.lang.reflect.Method
java.lang.reflect.Field

riflessioneUtilizzando , è possibile creare classi o chiamare metodi senza doverli codificare direttamente.
Puoi creare un'istanza di classe da una stringa o eseguire un metodo.

Scrivendo le definizioni dei nomi delle classi e dei metodi in file esterni come XML, è possibile adattare dinamicamente l'applicazione ai cambiamenti nell'ambiente durante il runtime.
È anche un'API molto efficace per creare applicazioni altamente flessibili.

Scopo della riflessione

riflessionenon viene spesso utilizzato direttamente dagli utenti,
È ampiamente utilizzato in applicazioni web come Struts e framework come la mappatura O/R.

Ad esempio, quando si impostano automaticamente i dati di input della schermata Web sulle proprietà JavaBeans,
Viene utilizzato durante l'emissione di SQL che si aggiorna automaticamente in base alle proprietà JavaBeans.

Inoltre, sono disponibili funzioni come il caricamento dinamico e la registrazione dei plug-in che estendono la funzionalità all'avvio dell'applicazione.riflessioneCiò può essere facilmente ottenuto utilizzando .

Esecuzione del campione

Esegui l'esempio e sperimenta la programmazione in stile framework.

Qui usiamo la seguente classeriflessioneDimostra un utilizzo semplice dell'utilità.

Main.java...Classe da eseguire
BeanUtil.java...Classe di utilità di riflessione
FreeSoft.java...Utilizzato come riflessione in una classe che rappresenta il software libero.

●Se eseguito normalmente

System.out.println(“＞＞＞Caso normale”);
FreeSoft freeSoft = nuovo FreeSoft();
freeSoft.setNome(“Chat&Messenger Chat e Messenger!!”);
freeSoft.showNome();
freeSoft.showPrice(0);

●Quando eseguito utilizzando la riflessione

System.out.println(“＞＞＞Quando si utilizza la riflessione”);
//Crea un'istanza della classe FreeSoft
Oggetto invocaObject = BeanUtil.newInstance(“FreeSoft”);
//Imposta il valore nel campo del nome.
BeanUtil.setProperty(invokeObject, "nome" , “Chat&Messenger Chat e Messenger!!”);
// Esegue il metodo showName() di FreeSoft.
BeanUtil.invoke(invokeObject, “mostraNome”, nullo);
// Esegue il metodo showPrice() di FreeSoft.
// Se il metodo ha argomenti, devono essere passati come array di tipo Oggetto.
BeanUtil.invoke(invokeObject, “mostraprezzo”,nuovo Oggetto[]{nuovo Intero(0)});

●Risultati dell'esecuzione

I risultati dell'esecuzione sono gli stessi sia nel caso normale che quando si utilizza la riflessione.

>>> Caso normale

Nome del software: Chat&Messenger Chatta e messenger! !

Prezzo: 0 yen

>>> Quando si utilizza la riflessione

Nome del software: Chat&Messenger Chatta e messenger! !

Prezzo: 0 yen

Dettagli del metodo BeanUtil

nuova istanza

oggetto statico pubblico nuova istanza(String className) genera un'eccezione

Genera e restituisce un'istanza dalla stringa "className".

parametri:: nome della classe – Nome della classe completo
Valore di ritorno:: Una nuova istanza di un nome di classe completo
eccezione:: Eccezione

nuova istanza

oggetto statico pubblico nuova istanza(String className, Object[] argObj) genera un'eccezione

Genera e restituisce un'istanza dalla stringa "className".

parametri:: nome della classe – Nome della classe completo; argObj – Argomenti del costruttore
Valore di ritorno:: Una nuova istanza di un nome di classe completo
eccezione:: Eccezione

nuova istanza

oggetto statico pubblico nuova istanza(Class clazz) lancia un'eccezione

Genera e restituisce un'istanza dalla classe "clazz".

parametri:: clazz - classe
Valore di ritorno:: nuova istanza di clazz
eccezione:: Eccezione

nuova istanza

oggetto statico pubblico nuova istanza(Class clazz, Object[] argObj) genera un'eccezione

Genera e restituisce un'istanza dalla classe "clazz".

parametri:: clazz - classe; argObj – Argomenti del costruttore
Valore di ritorno:: nuova istanza di clazz
eccezione:: Eccezione

setProperty

vuoto pubblico statico setProperty(Object invokeObject, String fieldName, Object value) genera un'eccezione

Chiama il metodo setter del campo "fieldName" dell'oggetto "invokeObject" e memorizza il valore "value".

Se non esiste un metodo setter, il valore verrà impostato direttamente nel campo. Tuttavia, in questo caso, il modificatore di accesso della proprietà di destinazione deve essere pubblico.

parametri:: invocaOggetto – Oggetto da eseguire; campoNome – Nome della proprietà dell'oggetto da eseguire; valore – Valore da impostare
eccezione:: Eccezione – Si verifica la seguente eccezione.; InvocationTargetException – Se il metodo sottostante genera un'eccezione; IllegalAccessException – Questo oggetto Metodo è Java
Quando viene implementato il controllo dell'accesso alla lingua e non è possibile accedere al metodo sottostante; NoSuchMethodException – Se non viene trovato un metodo con il nome specificato

getProperty

oggetto statico pubblico getProperty(Oggetto invokeObject, String fieldName) genera un'eccezione

Chiama il metodo getter del campo fieldName dell'oggetto invokeObject per ottenere il valore.
Se non esiste un metodo getter, il valore verrà recuperato direttamente dal campo. Tuttavia, in questo caso, il modificatore di accesso della proprietà di destinazione deve essere pubblico.

parametri:: invocaOggetto – Oggetto da eseguire; campoNome – Nome della proprietà dell'oggetto da eseguire
Valore di ritorno:: Valore restituito dal metodo getter
eccezione:: Eccezione – Si verifica la seguente eccezione.; InvocationTargetException – Se il metodo sottostante genera un'eccezione; IllegalAccessException – Questo oggetto Metodo è Java
Quando viene implementato il controllo dell'accesso alla lingua e non è possibile accedere al metodo sottostante; NoSuchFieldException – Se non viene trovato un campo con il nome specificato

invocare

oggetto statico pubblico invocare(Oggetto invokeObject, String callMethod, Object[] argObjects) genera InvocationTargetException, IllegalAccessException, NoSuchMethodException

Esegue il metodo "callMethod" dell'oggetto "invokeObject".
Se è presente un valore restituito, può essere ottenuto come oggetto.

parametri:: invocaOggetto – Oggetto da eseguire; metodochiamata – Nome del metodo da eseguire; argObjects – Se sono presenti argomenti, passarli come un array di oggetti. Se non ci sono argomenti, passa null.
Valore di ritorno:: Valore restituito dall'esecuzione di "callMethod"
eccezione:: InvocationTargetException – Se il metodo sottostante genera un'eccezione; IllegalAccessException – Questo oggetto Metodo è Java
Quando viene implementato il controllo dell'accesso alla lingua e non è possibile accedere al metodo sottostante; NoSuchMethodException – Se non viene trovato un metodo con il nome specificato

findMethod

metodo statico pubblico findMethod(Object invokeObject, String callMethod, Object[] argObjects) genera NoSuchMethodException

Cerca il metodo "callMethod" dell'oggetto "invokeObject".

parametri:: invocaOggetto – Oggetto da eseguire; metodochiamata – Nome del metodo dell'oggetto da eseguire; argObjects – Se sono presenti argomenti, passarli come un array di oggetti. Se non ci sono argomenti, passa null.
Valore di ritorno:: Un oggetto Method che corrisponde alle condizioni dell'argomento specificate
eccezione:: NoSuchMethodException – Se non viene trovato alcun metodo corrispondente o se il nome è “” o “”

setField

vuoto pubblico statico setField(Object invokeObject, String fieldName, Object value) genera IllegalAccessException, NoSuchFieldException

Memorizza il valore "value" nel nome del campo "fieldName" dell'oggetto da eseguire "invokeObject".

parametri:: invocaOggetto – Oggetto da eseguire; campoNome – Nome del campo dell'oggetto da eseguire; valore – Valore da impostare
eccezione:: IllegalAccessException – Il campo su cui si basa l'oggetto specificato (o la sua sottoclasse o implementatore)
non è un'istanza della classe o dell'interfaccia che dichiara o se la conversione di unwrapping fallisce; NoSuchFieldException – Se non viene trovato un campo con il nome specificato

getField

oggetto statico pubblico getField(Oggetto invokeObject, stringa fieldName) genera IllegalAccessException, NoSuchFieldException

Ottiene il valore del nome del campo "fieldName" dell'oggetto da eseguire "invokeObject".

parametri:: invocaOggetto – Oggetto da eseguire; campoNome – Nome del campo dell'oggetto da eseguire
Valore di ritorno:: valore di ritorno
eccezione:: IllegalAccessException – Il campo su cui si basa l'oggetto specificato (o la sua sottoclasse o implementatore)
non è un'istanza della classe o dell'interfaccia che dichiara o se la conversione di unwrapping fallisce; NoSuchFieldException – Se non viene trovato un campo con il nome specificato

hasField

booleano statico pubblico hasField(Oggetto oggetto, String fieldName) genera un'eccezione

Controlla se l'oggetto 'oggetto' dichiara il nome del campo 'fieldName'.

parametri:: oggetto – Oggetto da ispezionare; campoNome – Nome del campo da verificare
Valore di ritorno:: vero se dichiarato
eccezione:: Eccezione

getAllFields

java.util.TreeSet pubblico statico getAllFields(Oggetto oggetto) lancia un'eccezione

parametri:: oggetto –
Valore di ritorno:
eccezione:: Eccezione

getShortClassName

stringa statica pubblica getShortClassName(Oggetto Oggetto)

Ottiene il nome della classe non qualificato da un oggetto.

parametri:: oggetto –
Valore di ritorno:

getShortClassName

stringa statica pubblica getShortClassName(Stringa nomeclasse)

Ottiene il nome della classe dal nome completo.

parametri:: nome della classe –
Valore di ritorno:

getNomeCampo

stringa statica pubblica getNomeCampo(nomemetodo stringa)

Modificare il nome del campo dal nome del metodo. Deve essere conforme alle convenzioni JavaBeans.

parametri:: nomemetodo –
Valore di ritorno:

isClassEsist

booleano statico pubblico isClassEsist(Stringa nomeclasse)

Verifica che il nome completo "className" sia un nome di classe esistente.

parametri:: nome della classe –
Valore di ritorno:

getPropertyDescriptors

PropertyDescriptor statico pubblico[] getPropertyDescriptors(Oggetto oggetto) lancia IntrospectionException

Restituisce un PropertyDescriptor che contiene le informazioni sull'oggetto per "oggetto".

parametri:: oggetto –
Valore di ritorno:
eccezione:: java.beans.IntrospectionException

Codice sorgente BeanUtil

import java.beans.BeanInfo; import java.beans.IntrospectionException; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.math.BigDecimal; import java.sql.Timestamp; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.HashMap; import java.util.Map; import java.util.StringTokenizer; import java.util.TreeSet; /** * Classe di utilità che consente di utilizzare facilmente l'API di riflessione di Java */ classe pubblica BeanUtil { /** */ stringa finale statica privata GET = “GET”; /** */ stringa finale statica privata SET = “SET”; // ————————————————————-『newInstance』 /** * Genera e restituisce un'istanza dalla stringa "className". * @param className Nome classe completo * @return nuova istanza del nome classe completo * @genera un'eccezione */ L'oggetto statico pubblico newInstance (String className) genera un'eccezione { Tentativo { return Class.forName(className).newInstance(); } catch (NoClassDefFoundError e) { System.err.println("NoClassDefFoundError: " + className); lancia e; } } /** * Genera e restituisce un'istanza dalla stringa "className". * @param className Nome classe completo * Argomento del costruttore @param argObj * @return nuova istanza del nome classe completo * @genera un'eccezione */ Oggetto statico pubblico newInstance(String className, Object[] argObj) lancia un'eccezione { Classe[] argClass = nuova Classe[argObj.length]; for (int i = 0; i < argObj.lunghezza; i++) { argClass[i] = argObj[i].getClass(); } Costruttore c = Class.forName(className).getConstructor(argClass); return c.nuovaistanza(argObj); } /** * Crea e restituisce un'istanza dalla classe 'clazz'. *Lezione @param clazz * @return nuova istanza di clazz * @genera un'eccezione */ L'oggetto statico pubblico newInstance (Class clazz) genera un'eccezione { return clazz.newInstance(); } /** * Crea e restituisce un'istanza dalla classe 'clazz'. *Lezione @param clazz * Argomento del costruttore @param argObj * @return nuova istanza di clazz * @genera un'eccezione */ Oggetto statico pubblico newInstance(Classe clazz, Oggetto[] argObj) lancia un'eccezione { Classe[] argClass = nuova Classe[argObj.length]; for (int i = 0; i < argObj.lunghezza; i++) { argClass[i] = argObj[i].getClass(); } Costruttore c = clazz.getConstructor(argClass); return c.nuovaistanza(argObj); } // ---------------------"Metodo" /** * Metodo setter del campo “fieldName” dell'oggetto “invokeObject” * Chiama, memorizza il valore 'valore'. * * Se non esiste un metodo setter, impostare il valore direttamente nel campo. * Tuttavia, in questo caso, il modificatore di accesso della proprietà di destinazione deve essere pubblico. * @param invokeObject Oggetto da eseguire * @param fieldName Nome della proprietà dell'oggetto da eseguire * @param valore valore da impostare * @throws Eccezione Si verifica la seguente eccezione. * @throws InvocationTargetException se il metodo sottostante genera un'eccezione * @throws IllegalAccessException Se questo oggetto Method è Java * Quando è implementato il controllo dell'accesso alla lingua e non è possibile accedere al metodo sottostante * @throws NoSuchMethodException se non viene trovato un metodo con il nome specificato */ public static void setProperty(Oggetto invocaObject, String fieldName, Valore oggetto) genera Eccezione { Tentativo { Metodo metodo = searchMethod(invokeObject, fieldName, SET); Class[] paramClasses = metodo.getParameterTypes(); Oggetto[] valueArray = null; if (paramClasses[0].isInstance(valore)) { //Non convertire se l'oggetto da impostare è una sottoclasse della classe argomento. valueArray = nuovo Oggetto[] { valore }; } altro { valueArray = new Object[] { convObject(value, paramClasses[0] .getNome()) }; } metodo.invoke(invokeObject, valueArray); } catch (NoSuchMethodException e) { Tentativo { // Se non esiste un metodo setter, impostalo direttamente sul campo. setField(invokeObject, nomecampo, valore); } catch (NoSuchFieldException fe) { String errorMes = “\nClass” + getShortClassName(invokeObject) + “è” + “per campo “” + nomecampo + “”\n” + "Non esiste un metodo setter accessibile e." + “Campo “” + nomecampo + Anche “” non è pubblico. "+""; lancia una nuova IllegalAccessException(errorMes); } } } /** * Metodo getter del campo fieldName dell'oggetto invokeObject * Ottieni il valore della chiamata. * Se non esiste un metodo getter, il valore verrà ottenuto direttamente dal campo. * Tuttavia, in questo caso, il modificatore di accesso della proprietà di destinazione deve essere pubblico. * @param invokeObject Oggetto da eseguire * @param fieldName Nome della proprietà dell'oggetto da eseguire * @return valore restituito dal metodo getter * @throws Eccezione Si verifica la seguente eccezione. * @throws InvocationTargetException se il metodo sottostante genera un'eccezione * @throws IllegalAccessException Se questo oggetto Method è Java * Quando è implementato il controllo dell'accesso alla lingua e non è possibile accedere al metodo sottostante * @genera NoSuchFieldException se non viene trovato un campo con il nome specificato */ Oggetto statico pubblico getProperty(Oggetto invocaObject, String fieldName) lancia un'eccezione { Tentativo { Metodo metodo = searchMethod(invokeObject, fieldName, GET); return metodo.invoke(invokeObject, null); } catch (NoSuchMethodException e) { return getField(invokeObject, fieldName); } } /** * Esegue il metodo "callMethod" dell'oggetto "invokeObject". * Se è presente un valore restituito, può essere ottenuto come tipo Oggetto. * @param invokeObject Oggetto da eseguire * @param callMethod Nome del metodo da eseguire * @param argObjects Se è presente un argomento, lo passa come un array di oggetti. * Passa null se non ci sono argomenti. * @return Valore restituito dall'esecuzione di "callMethod" * @throws InvocationTargetException se il metodo sottostante genera un'eccezione * @throws IllegalAccessException Se questo oggetto Method è Java * Quando è implementato il controllo dell'accesso alla lingua e non è possibile accedere al metodo sottostante * @throws NoSuchMethodException se non viene trovato un metodo con il nome specificato */ oggetto pubblico statico invocato(oggetto invocatooggetto, stringa callmetodo, Object[] argObjects) lancia InvocationTargetException, IllegalAccessException, NoSuchMethodException { Metodo metodo = findMethod(invokeObject, callMethod, argObjects); return metodo.invoke(invokeObject, argObjects); } /** * Cerca il metodo 'callMethod' dell'oggetto 'invokeObject'. * @param invokeObject Oggetto da eseguire * @param callMethod Nome del metodo dell'oggetto da eseguire * @param argObjects Se è presente un argomento, lo passa come un array di oggetti. * Passa null se non ci sono argomenti. * Oggetto metodo @return che soddisfa le condizioni dell'argomento specificato * @throws NoSuchMethodException Se non viene trovato alcun metodo corrispondente, * Oppure se il nome è “ " O " "in caso di */ Metodo statico pubblico findMethod(Oggetto invokeObject, String callMethod, Object[] argObjects) genera NoSuchMethodException { Classe[] paramClasses = null; Metodo[] metodi = invokeObject.getClass().getMethods(); in alto: for (int i = 0; i < metodi.lunghezza; i++) { if (metodi[i].getName().equals(callMethod)) { if (argObjects == null && metodi[i].getParameterTypes().length == 0) { metodi di restituzione[i]; } if (argObjects == null) { Continua; } paramClasses = metodi[i].getParameterTypes(); if (paramClasses.length == argObjects.length) { // Convalida tutti i tipi di elenchi di parametri e di argomenti for (int j = 0; j < paramClasses.length; j++) { Classe paramClass = paramClasses[j]; Oggetto argObj = argOggetti[j]; // Se il tipo di argomento è primitivo, l'oggetto dell'argomento // non è nullo ed è primitivo //Se è una sottoclasse di Number, va bene. se (argObj == null) { Continua; } if (paramClass.isPrimitive() && (argObj istanza del Numero || argObj .getClass().isPrimitive())) { Continua; } if (!paramClass.isInstance(argObj)) { // Passa al metodo successivo quando i tipi non sono compatibili con la conversione implicita continua in alto; } } metodi di restituzione[i]; } } } String paramLength = (paramClasses != null) ? Intero .toString(paramClasses.length): “”; Stringa errorMes = getShortClassName(invokeObject) + “metodo” + callMethod + “Non esiste.” + “[ paramClasses.length ] = ” + paramLength + “,[ argObjects.length ] = ” + argObjects.length + “”; lancia una nuova NoSuchMethodException(errorMes); } // ----------------------"Campo" /** * Valore per il nome del campo "fieldName" dell'oggetto "invokeObject" da eseguire * Memorizza il "valore". * @param invokeObject Oggetto da eseguire * @param fieldName Nome del campo dell'oggetto da eseguire * @param valore valore da impostare * @throws IllegalAccessException Se l'oggetto specificato lo è * campo (o la sua sottoclasse o implementatore) * Se non è un'istanza di una classe o di un'interfaccia, dichiara * o se la conversione da scartare fallisce * @genera NoSuchFieldException se non viene trovato un campo con il nome specificato */ public static void setField(Oggetto invokeObject, String fieldName, Valore oggetto) genera IllegalAccessException, NoSuchFieldException { Campo campo = searchField(invokeObject, fieldName); String className = field.getType().getName(); Oggetto convObj = null; if (field.getType().isInstance(valore)) { convObj = valore; } altro { convObj = convOggetto(valore, nomeclasse); } field.set(invokeObject, convObj); } /** * Impostare il valore del nome del campo "fieldName" dell'oggetto di esecuzione "invokeObject" su * Ottenere. * @param invokeObject Oggetto da eseguire * @param fieldName Nome del campo dell'oggetto da eseguire * @return valore restituito * @throws IllegalAccessException Se l'oggetto specificato lo è * campo (o la sua sottoclasse o implementatore) * Se non è un'istanza di una classe o di un'interfaccia, dichiara * o se la conversione da scartare fallisce * @genera NoSuchFieldException se non viene trovato un campo con il nome specificato */ Oggetto statico pubblico getField(Oggetto invocaObject, String fieldName) genera IllegalAccessException, NoSuchFieldException { Campo campo = searchField(invokeObject, fieldName); return field.get(invokeObject); } /** * Controlla se l'oggetto "object" dichiara il nome del campo "fieldName" * Confermare. * @param object Oggetto da ispezionare * @param fieldName Nome del campo da controllare * @return true se dichiarato * @genera un'eccezione */ hasField booleano statico pubblico (oggetto oggetto, stringa nomecampo) lancia un'eccezione { PropertyDescriptor[] props = getPropertyDescriptors(oggetto); for (int i = 0; i < props.length; i++) { String _fieldName = props[i].getName(); if (nomecampo.equals(_nomecampo)) { restituisce vero; } } restituire falso; } /** * * Oggetto @param * @ritorno * @genera un'eccezione */ pubblico statico TreeSet getAllFields (oggetto oggetto) genera un'eccezione { Set di alberi fieldSet = nuovo Set di alberi(); // Ottieni il nome della proprietà dal metodo PropertyDescriptor[] props = getPropertyDescriptors(oggetto); for (int i = 0; i < props.length; i++) { String fieldName = props[i].getName(); fieldSet.add(nomecampo); } // Ottieni il nome della proprietà dal campo Field[] campi = object.getClass().getFields(); for (int i = 0; i < campi.lunghezza; i++) { String fieldName = campi[i].getName(); if (!fieldSet.contains(fieldName)) { fieldSet.add(nomecampo); } } campo restituitoImposta; } /** * * @param invokeObject Oggetto da eseguire * @param fieldName Nome del campo dell'oggetto da eseguire * @return Oggetti archiviati che soddisfano le condizioni dell'argomento specificato * @genera NoSuchFieldException se non viene trovato un campo con il nome specificato */ campo statico privato searchField(Oggetto invokeObject, String fieldName) lancia NoSuchFieldException { Tentativo { ritorna invokeObject.getClass().getField(nomecampo); } catch (NoSuchFieldException e) { // Questo ambito è ottenuto dal nome della colonna della tabella nomecampo = checknomecampo(nomecampo); Field[] campi = invokeObject.getClass().getFields(); for (int i = 0; i < campi.lunghezza; i++) { if (fields[i].getName().equalsIgnoreCase(fieldName)) { campi di ritorno[i]; } } lancia una nuova NoSuchFieldException(fieldName); } } // ----------------------" altri " /** * Ottieni il nome della classe non qualificato da un oggetto. * Oggetto @param * @ritorno */ public static String getShortClassName(oggetto oggetto) { se (oggetto == null) { restituire "null"; } Nome stringa = object.getClass().getName(); return getShortClassName(nome); } /** * Ottieni il nome della classe dal nome completo. * @param nomeclasse * @ritorno */ public static String getShortClassName(String className) { int indice = className.lastIndexOf(“.”); return nomeclasse.sottostringa(indice + 1); } /** * Cambia il nome del campo dal nome del metodo. Conforme alle convenzioni JavaBeans * è necessario. * @param nomemetodo * @ritorno */ public static String getFieldName(String metodoName) { String campoNome = null; if (nomemetodo.startsWith("is")) { nomecampo = nomemetodo.substring(2); } altro { nomecampo = nomemetodo.substring(3); } nomecampo = convString(nomecampo, 0, “L”); restituisce nomecampo; } /** * Verificare che il nome completo "className" sia un nome di classe esistente. * @param nomeclasse * @ritorno */ pubblico statico booleano isClassExist(String className) { Tentativo { Classe.perNome(nomeclasse); restituisce vero; } catch (Eccezione e) { restituire falso; } } mappa statica finale privata beanInfoCache = new HashMap(); /** * Restituisce un PropertyDescriptor che contiene le informazioni sull'oggetto per "oggetto". * Oggetto @param * @ritorno * @genera IntrospectionException */ public static PropertyDescriptor[] getPropertyDescriptors(oggetto oggetto) lancia IntrospectionException { BeanInfo beanInfo = (BeanInfo) beanInfoCache.get(object.getClass()); if (beanInfo == null) { beanInfo = Introspector.getBeanInfo(object.getClass()); beanInfoCache.put(object.getClass(), beanInfo); } // BeanInfo beanInfo = Introspector.getBeanInfo(object.getClass()); return beanInfo.getPropertyDescriptors(); } // ————————————————————————– // ———————————————“Metodo privato di seguito” // ————————————————————————– /** * Cerca il metodo di accesso per l'argomento fieldName in base a PropertyDescriptor. * @param invokeObject Oggetto da eseguire * @param fieldName nome del campo * @param type Metodo getter ⇒ GET Metodo getter ⇒ SET * Oggetto metodo @return che soddisfa le condizioni dell'argomento specificato * @throws NoSuchMethodException Se non viene trovato alcun metodo corrispondente, * Oppure se il nome è “ " O " " * in caso di * @genera IntrospectionException */ Metodo statico privato searchMethod(Oggetto invokeObject, String fieldName, tipo String) genera NoSuchMethodException, IntrospectionException { Metodo metodo = null; nomecampo = checknomecampo(nomecampo); PropertyDescriptor[] props = getPropertyDescriptors(invokeObject); for (int i = 0; i < props.length; i++) { Nome stringa = props[i].getName(); if (!nome.equalsIgnoreCase(nomecampo)) { Continua; } if (tipo.equals(GET)) { metodo = props[i].getReadMethod(); } altro { metodo = props[i].getWriteMethod(); } if (metodo == null) { Continua; } metodo di restituzione; } // Se il metodo non esiste. lancia una nuova NoSuchMethodException("La classe non ha metodi." + "(senza distinzione tra maiuscole e minuscole.): " + type.toLowerCase() + convString(nomecampo, 0, “U”) + “()”); } /** * Controlla se l'argomento fieldName è un nome di colonna; se è un nome di colonna, *Convertire indietro. * * INDIRIZZO_MAIL ⇒ INDIRIZZO MAIL ↓ indirizzo_mail = Indirizzomail * @param fieldName Nome del campo o nome della colonna * Nome del campo @return */ private static String checkFieldName(String fieldName) { int indice = nomecampo.indexOf(“_”); mentre (vero) { se (indice == -1) { restituisce nomecampo; } StringBuffer convcloumn = new StringBuffer(fieldName); convcloumn.deleteCharAt(indice); fieldName = convcloumn.toString(); indice = nomecampo.indiceOf(“_”); } } /** * Converte l'oggetto da convertire, object, nel tipo convClassName. * * @param object Oggetto da convertire * @param convClassName stringa di classe del tipo da convertire * @return l'oggetto convertito */ oggetto statico privato convObject(Oggetto oggetto, String convClassName) { se (oggetto == null) { // Restituire null durante la conversione in un tipo primitivo risulterà in un errore. // Crea un wrapper per 0. if (convClassName.equals(“int”)) { restituisce un nuovo intero(0); } else if (convClassName.equals(“long”)) { ritorna nuovo Long(0); } altro { restituire null; } } if (oggetto.getClass().getName().equals(convClassName)) { oggetto restituito; } // —————————————-『istanza dell'oggetto String』 if (istanza oggetto di String) { if (convClassName.equals(“java.lang.String”)) { oggetto restituito; } altrimenti se (convClassName.equals(“java.lang.Long”) || convClassName.equals("lungo")) { String str = (String) oggetto; se (isEsiste(str)) { // Sarebbe un male se non lo convertissi in BigDecimal una volta // 1000.00000 BigDecimal big = nuovo BigDecimal(str); restituisce new Long(big.longValue()); } altro { // Se str è un valore letterale di shell, imposta il valore iniziale su "0" ritorna nuovo Long(0); } } else if (convClassName.equals(“java.sql.Date”)) { return toSqlDate((String) oggetto); } else if (convClassName.equals(“java.sql.Timestamp”)) { Data data = toSqlDate((String) oggetto); restituisce il nuovo Timestamp(date.getTime()); } else if (convClassName.equals(“java.lang.Integer”) || convClassName.equals("int")) { // Se str è un valore letterale di shell, imposta il valore iniziale su "0" String str = (String) oggetto; se (isEsiste(str)) { BigDecimal big = nuovo BigDecimal(str); restituisce nuovo Integer(big.intValue()); } altro { restituisce un nuovo intero(0); } } else if (convClassName.equals(“boolean”)) { return Boolean.valueOf(object.toString()); } else if (convClassName.equals(“java.math.BigDecimal”)) { String temp = (oggetto (String)).trim(); // Se temp.length() == 0, è sicuro impostarlo su null anziché su 0. if (temp.lunghezza() == 0) { restituire null; } altro { restituisce new BigDecimal(temp); } } ThrowNoSupprt(oggetto, convClassName); } // ———————————“ oggetto istanza di java.sql.Date ” else if (istanza oggetto di java.sql.Date) { if (convClassName.equals(“java.lang.String”)) { return toStringDate((java.sql.Date) oggetto, “aaaa/MM/gg”); } else if (convClassName.equals(“java.sql.Date”)) { oggetto restituito; } else if (convClassName.equals(“java.sql.Timestamp”)) { restituisce il nuovo Timestamp((oggetto (Data)).getTime()); } ThrowNoSupprt(oggetto, convClassName); } // ————————————-『istanza dell'oggetto Timestamp』 else if (istanza oggetto di Timestamp) { molto tempo = (oggetto (Timestamp)).getTime(); if (convClassName.equals(“java.lang.String”)) { return toStringDate(time, “aaaa/MM/gg HH:mm:ss”); } else if (convClassName.equals(“java.sql.Date”)) { restituisce new java.sql.Date(time); } else if (convClassName.equals(“java.sql.Timestamp”)) { oggetto restituito; } ThrowNoSupprt(oggetto, convClassName); } // ——————————————-『istanza dell'oggetto Integer』 else if (istanza oggetto di Integer) { if (convClassName.equals(“java.lang.Integer”) || convClassName.equals("int")) { oggetto restituito; } else if (convClassName.equals(“java.lang.String”)) { restituire oggetto.toString(); } altrimenti se (convClassName.equals(“java.lang.Long”) || convClassName.equals("lungo")) { restituisce il nuovo Long((oggetto (intero)).longValue()); } else if (convClassName.equals(“java.math.BigDecimal”)) { restituisce il nuovo BigDecimal((oggetto (intero)).intValue()); } ThrowNoSupprt(oggetto, convClassName); } // ——————————————『istanza dell'oggetto Long』 else if (oggetto istanza di Long) { if (convClassName.equals(“java.lang.Long”) || convClassName.equals("lungo")) { oggetto restituito; } else if (convClassName.equals(“java.lang.String”)) { restituire oggetto.toString(); } else if (convClassName.equals(“java.lang.Integer”) || convClassName.equals("int")) { restituisce nuovo Integer((oggetto (Long)).intValue()); } else if (convClassName.equals(“java.math.BigDecimal”)) { restituisce il nuovo BigDecimal((oggetto (Long)).longValue()); } ThrowNoSupprt(oggetto, convClassName); } // —————————————-『istanza dell'oggetto Double』 else if (istanza dell'oggetto Double) { if (convClassName.equals(“java.lang.String”)) { // NUMERO COLONNA(8,0) // windows oracle > BigDecimal // Oracolo UNIX > Doppio BigDecimal big = nuovo BigDecimal((oggetto (Double)).doubleValue()); int scala = big.scale(); se (scala == 0) { ritorna big.toString(); } altro { // Non supportato se è richiesto l'arrotondamento. ThrowNoSupprt(oggetto, convClassName); } } if (convClassName.equals(“java.lang.Integer”) || convClassName.equals("int")) { restituisce nuovo Integer((oggetto (Double)).intValue()); } altrimenti se (convClassName.equals(“java.lang.Long”) || convClassName.equals("lungo")) { restituisce il nuovo Long(((Double) oggetto).longValue()); } else if (convClassName.equals(“java.math.BigDecimal”)) { restituisce il nuovo BigDecimal(((Double) oggetto).doubleValue()); } ThrowNoSupprt(oggetto, convClassName); } // ————————————“ istanza dell'oggetto BigDecimal ” else if (istanza oggetto di BigDecimal) { if (convClassName.equals(“java.lang.String”)) { restituire oggetto.toString(); } altrimenti se (convClassName.equals(“java.lang.Long”) || convClassName.equals("lungo")) { restituisce il nuovo Long(((oggettoBigDecimal)).longValue()); } else if (convClassName.equals(“java.lang.Integer”) || convClassName.equals("int")) { restituisce il nuovo Integer(((oggettoBigDecimal)).intValue()); } ThrowNoSupprt(oggetto, convClassName); } // —————————————-『oggetto istanza di byte[]』 else if (oggetto istanza di byte[]) { if (convClassName.equals("java.sql.Blob")) { oggetto restituito; } ThrowNoSupprt(oggetto, convClassName); } // —————————————————“ l'oggetto è booleano” else if (istanza dell'oggetto Booleano) { if (convClassName.equals(“booleano”)) { oggetto restituito; } ThrowNoSupprt(oggetto, convClassName); } // ————————————————-『l'oggetto è booleano[]』 else if (oggetto istanza di boolean[]) { if (convClassName.equals(“java.lang.String”)) { booleano[] bs = (booleano[]) oggetto; Buff StringBuffer = new StringBuffer(“[“); for (int i = 0; i < bs.lunghezza; i++) { buff.append(bs[i] + “,”); } buff.deleteCharAt(buff.length() – 1); buff.append(“]”); ritorna buff.toString(); } ThrowNoSupprt(oggetto, convClassName); } ThrowNoSupprt(oggetto, convClassName); restituire null; } /** *Genera se la conversione non è supportata. * * @param object Oggetto da convertire * @param convClassName Tipo da convertire */ private static void ThrowNoSupprt(Oggetto oggetto, String convClassName) { String className = (oggetto!= null) ? object.getClass().getName() : "nullo"; String errorMess = "\nL'elaborazione della conversione del tipo per questo oggetto non è ancora supportata.\n" + ” [ Oggetto ] = ” + oggetto + “,[ Tipo oggetto ] = ” + nomeclasse + “,[ convertClass ] = ” + convClassName + “”; lancia una nuova UnsupportedOperationException(errorMess); } /** * Converte il carattere nella posizione [indice] della stringa [str] in maiuscolo o minuscolo. * * @param str Stringa da valutare * @param indice Posizione specificata * @param toCase Converti in maiuscolo ⇒ U | u Converti in minuscolo ⇒ L | l * @return Stringa dopo la conversione */ private static String convString(String str, int indice, String toCase) { if (str == null || str.trim().length() == 0) { ritorna str; } altro { String temp = str.substring(indice, indice + 1); if (toCase.equalsIgnoreCase("u")) { temp = temp.toUpperCase(); } altro { temp = temp.toLowerCase(); } StringBuffer tempBuffer = new StringBuffer(str); tempBuffer.replace(indice, indice + 1, temp); return tempBuffer.toString(); } } /** * Verificare se [valore] è un valore valido. * * @param value Stringa da valutare * @return [true]: Se non null e non “” */ booleano statico privato isExist(valore stringa) { if (valore!= null && valore.lunghezza() != 0) { restituisce vero; } restituire falso; } /** * Classe java.util.Date o la sua sottoclasse nel formato specificato * Converti in stringa. * @param date classe java.util.Date da convertire * Formato specificato dal pattern @param * @return stringa di data formattata */ private static String toStringDate(Data data, modello stringa) { SimpleDateFormat sdFormat = new SimpleDateFormat(modello); return sdFormat.format(data); } privato statico java.sql.Date toSqlDate(String strDate) { Calendario cal = toCalendar(strDate); ritorna aSqlDate(cal); } private static java.sql.Date toSqlDate(Calendar cal) { lungo l = cal.getTime().getTime(); restituisce nuovo java.sql.Date(l); } /** * Converte un valore di lunga durata in una stringa nel formato specificato. * @param time Un valore lungo che rappresenta i millisecondi dell'ora corrente. * Formato specificato dal pattern @param * @return stringa di data formattata */ private static String toStringDate(molto tempo, modello di stringa) { return toStringDate(nuova data(ora), modello); } /** * Stringa ⇒ java.sql.Date * * Converti la seguente stringa di data in java.sql.Date * aaaa/MM/gg HH:mm:ss.SSS aaaa-MM-gg HH:mm:ss.SSS * * “20030407” “2003/04/07” “2003-04-07” “2003/04/07 15:20:16” “2003-04-07 * 15:20:16” * @param strDate * @ritorno */ Calendario statico privato toCalendar(String strDate) { strData = formato(strData); Calendario cal = Calendar.getInstance(); int aaaa = Integer.parseInt(strDate.substring(0, 4)); int MM = Integer.parseInt(strDate.substring(5, 7)); int dd = Integer.parseInt(strDate.substring(8, 10)); int HH = cal.get(Calendar.HOUR_OF_DAY); int mm = cal.get(Calendario.MINUTO); int ss = cal.get(Calendar.SECOND); int SSS = cal.get(Calendar.MILLISECOND); cal.clear(); cal.set(aaaa, MM – 1, gg); int len = strDate.length(); interruttore (lente) { caso 10: rottura; caso 16: // aaaa/MM/gg HH:mm HH = Integer.parseInt(strDate.substring(11, 13)); mm = Integer.parseInt(strDate.substring(14, 16)); cal.set(Calendar.HOUR_OF_DAY, HH); cal.set(Calendario.MINUTO, mm); rottura; caso 19: // aaaa/MM/gg HH:mm:ss HH = Integer.parseInt(strDate.substring(11, 13)); mm = Integer.parseInt(strDate.substring(14, 16)); ss = Integer.parseInt(strDate.substring(17, 19)); cal.set(Calendar.HOUR_OF_DAY, HH); cal.set(Calendario.MINUTO, mm); cal.set(Calendario.SECOND, ss); rottura; case 23: // aaaa/MM/gg HH:mm:ss.SSS HH = Integer.parseInt(strDate.substring(11, 13)); mm = Integer.parseInt(strDate.substring(14, 16)); ss = Integer.parseInt(strDate.substring(17, 19)); SSS = Integer.parseInt(strDate.substring(20, 23)); cal.set(Calendar.HOUR_OF_DAY, HH); cal.set(Calendario.MINUTO, mm); cal.set(Calendario.SECOND, ss); cal.set(Calendar.MILLISECONDI, SSS); rottura; predefinito: lancia una nuova IllegalStateException( "Questa stringa String non può essere convertita in una stringa di data: " +strData); } restituire cal; } /** * Qualsiasi stringa di data come “aaaa/MM/gg” o “aaaa/MM/gg HH:mm:ss” * Tenta di convertire in formato. * Esempio: 01/03/3 ⇒ 03/01/2003 * @param strDate * @ritorno */ formato stringa statica privata (String strDate) { strData = strData.trim(); Stringa aaaa = null; Stringa MM = nullo; Stringa gg = null; Stringa HH = nullo; Stringa mm = nullo; Stringa ss = nullo; Stringa SSS = nullo; // Se manca "-" o "/". if (strDate.indexOf(“/”) == -1 && strDate.indexOf(“-“) == -1) { if (strData.lunghezza() == 8) { aaaa = strData.substring(0, 4); MM = strData.substring(4, 6); gg = strData.substring(6, 8); return aaaa + “/” + MM + “/” + gg; } altro { aaaa = strData.substring(0, 4); MM = strData.substring(4, 6); gg = strData.substring(6, 8); HH = strData.substring(9, 11); mm = strData.substring(12, 14); ss = strData.substring(15, 17); return aaaa + "/" + MM + "/" + gg + " " + HH + ":" + mm + ":" +ss; } } Token StringTokenizer = new StringTokenizer(strDate, “_/-:. “); Risultato StringBuffer = new StringBuffer(); for (int i = 0; token.hasMoreTokens(); i++) { Stringa temp = token.nextToken(); interruttore (i) { caso 0:// anno parte aaaa = fillString(strData, temp, “f”, “20”, 4); risultato.append(aaaa); rottura; caso 1:// mese parte MM = fillString(strData, temp, “f”, “0”, 2); risultato.append(“/” + MM); rottura; caso 2://giorno parte gg = fillString(strData, temp, “f”, “0”, 2); risultato.append(“/” + gg); rottura; caso 3://parte temporale HH = fillString(strData, temp, “f”, “0”, 2); risultato.append(” ” + HH); rottura; caso 4://minuta parte mm = fillString(strData, temp, “f”, “0”, 2); risultato.append(“:” + mm); rottura; caso 5://seconda parte ss = fillString(strData, temp, “f”, “0”, 2); risultato.append(“:” + ss); rottura; caso 6:// millisecondo parte SSS = fillString(strData, temp, “b”, “0”, 3); risultato.append(“.” + SSS); rottura; } } restituisce risultato.toString(); } private static String fillString(String strDate, String str, Posizione della stringa, String addStr, int len) { if (str.lunghezza() > len) { String mes = strDate + “Questa stringa String non può essere convertita in una stringa di data”; lancia una nuova IllegalStateException(mes); } return fillString(str, posizione, addStr, len); } /** * Aggiungere la stringa [addStr] da aggiungere alla stringa [str] in [position] in [len] * Inserire fino al riempimento. * * Esempio: String ss = StringUtil.fillString(“aaa”,”b”,”0″,7); ss ⇒ “aaa0000” * * *fillString() inserisce finché len non viene riempito, ma addString() inserisce len. * * @param str stringa di destinazione * @param position Inserisci prima ⇒ F/f Inserisci dopo ⇒ B/b * @param addStr Stringa da inserire * @param len Numero di cifre da ricostituire * @return La stringa dopo la conversione. [str] è un valore letterale nullo o vuoto, [addStr] è impostato su [len] * Restituisce i risultati inseriti finché non è soddisfatto. */ private static String fillString(String str, Posizione stringa, String addStr, int len) { StringBuffer tempBuffer = null; if (!isEsiste(str)) { tempBuffer = new StringBuffer(); for (int i = 0; i < len; i++) { tempBuffer.append(addStr); } return tempBuffer.toString(); } altrimenti se (str.length() != len) { tempBuffer = new StringBuffer(str); while (len > tempBuffer.length()) { if (position.equalsIgnoreCase(“f”)) { tempBuffer.insert(0, addStr); } altro { tempBuffer.append(addStr); } } return tempBuffer.toString(); } ritorna str; } }

URLをコピーしました!