Uso eficaz de la reflexión de Java: ¿se trata de un truco, o es esta práctica estándar?

Question

Hola, oyente por primera vez oyente por primera vez, y estoy haciendo una pregunta relacionada con la reflexión de Java, y qué fácil se presta a una codificación aparentemente desagradable. El siguiente método intenta tomar dos objetos similares (un objeto que tiene todos los campos del otro objeto, y algunos) y compararlos para la igualdad. Será (supuestamente) devuelto verdadero si los captadores que los objetos comparten son iguales, y devolverá falso si no son iguales.

public boolean validateArchive(Object record, Object arcRecord) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException 
{ 
    log.debug(record.getClass().toString()); 

    Object methodValue; 
    Object arcMethodValue; 

    for (Method method : record.getClass().getMethods()) 
    { 
     if (method.getTypeParameters().length == 0 && method.getName().startsWith("get") && !method.getName().startsWith("getClass")) 
     { 
      methodValue = method.invoke(record); 
      arcMethodValue = arcRecord.getClass().getMethod(method.getName()).invoke(arcRecord); 

      log.debug("Method name: " + method.getName()); 
      log.debug("Archive value: " + arcMethodValue); 
      log.debug("Object value: " + methodValue); 

      if (arcMethodValue != null && methodValue != null && !arcMethodValue.equals(methodValue)) 
      { 
       return false; 
      } 
      else 
      { 
       if (arcMethodValue == null && methodValue != null || methodValue == null && arcMethodValue != null) 
       { 
        return false; 
       } 
      } 
     } 
    } 

    return true; 
} 

Este método hace lo que se espera que haga en las pruebas de unidad, pero se ve feo, y se siente mal (yo particularmente no soy un fan de la anidada 'si'). Solo esperaba algunos consejos sobre cómo hacer esto de manera más efectiva/eficiente. Si he roto algún tipo de regla de publicación, no dude en corregirme, estoy ansioso por aprender, etc.

Answer 1

Para esta tarea en particular, recomendaría implementar el método equals en las clases que se compararán, a menos que no tiene esa opción (por ejemplo, si no tiene el código fuente para la clase original). Los IDE's como IntelliJ proporcionan soporte para la creación de métodos "iguales" y "código hash" (en IntelliJ, usted proporciona los campos que se compararán y los campos que pueden ser nulos o no). Para este caso particular, diría que vaya con estas herramientas.

Hay un caso en el que creo que sería útil una implementación usando Reflection: en una prueba unitaria, si desea lanzar un error de aserción si la igualdad no es verdadera, puede lanzar una afirmación para el campo exacto que está fallando, y no solo un error de aserción genérico de "objeto no es lo mismo" - incluso en este caso, realizaría un igual a después de mi validación original solo para asegurarme de que los objetos son los mismos, o al menos eso el método equals está implementado y funciona correctamente.

PD: Si quiere deshacerse de todo este código, consulte la biblioteca Beans Common; PD 2: La reflexión no está mal, y se usa en todas partes donde no tiene una llamada de código explícita - Archivos de configuración de Spring, por ejemplo. Simplemente no lo abuse.

Answer 2

Como usted está buscando sólo para "propiedades" que podrían usar commons beanutils y más precisamente this class ...

(supongo que no se puede poner en práctica .equals porque sus objetos no comparten el mismo tipo ...)

Answer 3

creo que está probando para los casos innecesarios en sus declaraciones if, y puede reducirlas a esto:

if (arcMethodValue == null) { 
    if (methodValue != null) { 
     return false; 
    } 
} else if (!arcMethodValue.equals(methodValue)) { 
    return false; 
} 

también, que está llamando method.getName() 4 veces, puede crear una variable y luego usarlo.

Answer 4

Su código de retorno es innecesariamente complicado. El lenguaje estándar para la comparación de los tipos de referencia es la siguiente:

(field1 == null) ? (field2 == null) : field1.equals(field2); 

Esto es mucho más claro y es bastante estándar (Java eficaz segunda edición, página 43).

---

Actualización:

Hubo una confusión, ya que anteriormente había escrito return [idiom]. Sí, en este caso, un return no sería lo que desea el póster original.Él querría en su lugar. Mi punto es que el [idiom] funciona, y es mucho mejor.