Appunti di applicazione della riflessione Java nella pratica

Di recente, ho incontrato un problema del genere:

Creare uno strumento di test per tutti gli interfacce di un progetto, utilizzando la tecnologia java Swing. Il progetto ha diverse versioni e non tutte le interfacce sono le stesse in tutte le versioni. Lo strumento che ho creato deve essere compatibile con tutte le versioni.

Questo ha portato a un problema:

Alcuni interfacce potrebbero non esistere in alcune versioni, quindi quando si esegue questa operazione attraverso l'interfaccia, viene generato un errore. Pertanto, per garantire la compatibilità con tutte le versioni, è necessario considerare l'esistenza del metodo prima della chiamata del metodo, e per evitare di generare eccezioni alla compilazione, durante la chiamata del metodo:

Anche per il richiamo tramite reflection, l'implementazione è la seguente:

Primo punto: uso della reflection per determinare l'esistenza del metodo

/**
   * Giudicare l'esistenza del metodo
   *
   * @param obj istanza di JObjectService
   * @param methodName nome del metodo
   * @param paraTypes array di tipi di parametri formali del metodo
   * @return
   */
  public static boolean judgeMethodIsExist(Object obj, String methodName, Class[] paraTypes) {
    boolean result = true;
    try {
      if (null != obj) {
        Method method = obj.getClass().getMethod(methodName, paraTypes);
      }
    } catch (NoSuchMethodException ex) {
      showWarnInfo(ex.toString());
      log.error("L'eccezione si è verificata in: " + MainJFrame.hostName + "; Dettagli: " + ex.getMessage());
      result = false;
    }
    return result;
  }

Introduzione ai parametri:

(1) obj: l'oggetto che rappresenta l'invocazione di un metodo

(2) methodName: il nome del metodo da chiamare

(3) paraTypes: il tipo di parametro richiesto dal metodo (in caso di più di uno, è un array)

Con questo metodo, puoi determinare se il metodo methodName (parametro di tipo) chiamato tramite l'oggetto obj esiste; se non esiste, verrà lanciata un'eccezione NoSuchMethodException

Secondo, chiamare il metodo tramite reflection per evitare eccezioni durante la compilazione

sysUser = MainJFrame.getSysUser();
    Class[] paramObj = {String.class, long.class, String.class, String.class, int.class}; // verifica dell'esistenza del metodo
    boolean isExist = CommonUtil.judgeMethodIsExist(sysUser, "createBucket", paramObj);
    if (isExist) {
      try { // chiamata del metodo tramite reflection
        Class clazz = sysUser.getClass(); // nome del metodo -- tipo dei parametri del metodo (per ordine dei parametri)
        Method createBucket = clazz.getDeclaredMethod("createBucket", String.class, long.class, String.class, String.class, int.class);
        int create = (int) createBucket.invoke(sysUser, bucketName, Long.parseLong(bucketSize), bucketLoc, bucketAcl, Integer.parseInt(StringUtil.emptyToZero(bucketCycle)));
        if (create == 1) {
          CommonUtil.showInfo("Bucket creazione riuscita");
          log.info("Bucket creazione riuscita");
        } else {
          CommonUtil.showWarnInfo("Bucket creazione fallita, errore interno del server!");
          log.info("Bucket creazione fallita, errore interno del server");
        }
      catch (Exception ex) {
        CommonUtil.showWarnInfo(ex.getMessage());
        log.error("L'eccezione si è verificata in: " + MainJFrame.hostName + "; Dettagli: " + ex.getMessage());
      }
    }

Nella seguente codice:

Riga prima: l'oggetto che chiama il metodo createBucket è sysUser

Riga seconda: l'array dei tipi dei parametri nel metodo viene utilizzato per determinare se il metodo esiste

Riga terza: determina se il metodo esiste tramite l'oggetto, il nome del metodo e l'array dei tipi dei parametri

Tramite queste tre righe, se il metodo esiste, eseguirà le seguenti operazioni, se non esiste, verrà visualizzato un messaggio di eccezione

Riga sesta: ottieni la Class dell'oggetto

Riga settima: ottieni l'oggetto Method per il metodo, i parametri sono il nome del metodo e il tipo dei parametri corrispondenti

Riga ottava: chiamata al metodo createBucket tramite l'oggetto Method, i parametri sono l'oggetto sysUser e i parametri (valori) necessari

Tramite i metodi sopra descritti, non si verificheranno eccezioni di compilazione anche se un'interfaccia non esiste nell'oggetto.

Onestamente, è la prima volta che mi sono imbattuto in problemi di riflessione Java nel mio progetto, è necessario annotarlo!

Sommario

Questo è tutto il contenuto del presente articolo sui punti di applicazione della riflessione Java in pratica, speriamo che sia utile a tutti. Gli amici interessati possono continuare a consultare il nostro sito:

Tutorial semplice di riflessione Java

Cose che devi sapere sul meccanismo di riflessione Java

Se c'è qualcosa di insufficiente, ti preghiamo di lasciare un commento. Grazie per il supporto dei nostri amici!

Dichiarazione: il contenuto di questo articolo è stato raccolto da Internet, il copyright è di proprietà del rispettivo proprietario, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene il diritto di proprietà, non è stato editato manualmente e non assume alcuna responsabilità legale. Se trovi contenuti sospetti di copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare, fornendo prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente il contenuto sospetto di violazione del copyright.