smells - Cómo encontrar código no utilizado/muerto en proyectos java
feature envy code smell (21)
¿Qué herramientas utiliza para encontrar código no utilizado / muerto en grandes proyectos de Java? Nuestro producto ha estado en desarrollo durante algunos años y es muy difícil detectar manualmente el código que ya no está en uso. Sin embargo, intentamos eliminar tanto código no utilizado como sea posible.
También se aprecian sugerencias para estrategias / técnicas generales (que no sean herramientas específicas).
Edición: Tenga en cuenta que ya utilizamos herramientas de cobertura de código (Clover, IntelliJ), pero son de poca ayuda. El código muerto todavía tiene pruebas unitarias y aparece como cubierto. Supongo que una herramienta ideal identificaría grupos de código que tienen muy poco otro código dependiendo de él, lo que permite la inspección manual de documentos.
DCD no es un complemento para algunos IDE, pero puede ejecutarse desde ant o de forma independiente. Parece una herramienta estática y puede hacer lo que PMD y FindBugs no pueden . Voy a probarlo.
PS Como se menciona en un comentario a continuación, el Proyecto vive ahora en GitHub .
Eclipse puede mostrar / resaltar código que no se puede alcanzar. JUnit puede mostrarle la cobertura del código, pero necesitará algunas pruebas y tendrá que decidir si falta la prueba relevante o si el código realmente no se usa.
En teoría, no se puede encontrar de manera determinista el código no utilizado. Hay una prueba matemática de esto (bueno, este es un caso especial de un teorema más general). Si tienes curiosidad, busca el problema de la detención.
Esto puede manifestarse en el código Java de muchas maneras:
- Clases de carga basadas en la entrada del usuario, archivos de configuración, entradas de la base de datos, etc .;
- Cargando código externo;
- Pasar árboles de objetos a bibliotecas de terceros;
- etc.
Dicho esto, uso IDEA IntelliJ como mi IDE de elección y tiene amplias herramientas de análisis para encontrar dependencias entre módulos, métodos no utilizados, miembros no utilizados, clases no utilizadas, etc. También es bastante inteligente como un método privado que no se llama etiquetado no utilizado pero un método público requiere un análisis más extenso.
Encontré la herramienta de cobertura de Clover que instruye el código y resalta el código que se usa y que no se usa. A diferencia de Google CodePro Analytics, también funciona para aplicaciones Web (según mi experiencia y puedo ser incorrecto sobre Google CodePro).
El único inconveniente que noté es que no tiene en cuenta las interfaces de Java.
Estoy sorprendido de que ProGuard no haya sido mencionado aquí. Es uno de los productos más maduros que existen.
ProGuard es un reductor, optimizador, ofuscador y preverificador de archivos de clase Java. Detecta y elimina clases, campos, métodos y atributos no utilizados. Optimiza el bytecode y elimina las instrucciones no utilizadas. Renombra las clases, campos y métodos restantes utilizando nombres cortos sin significado. Finalmente, verifica previamente el código procesado para Java 6 o para Java Micro Edition.
Algunos usos de ProGuard son:
- Creación de código más compacto, para archivos de código más pequeños, transferencia más rápida a través de redes, carga más rápida y huellas de memoria más pequeñas.
- Hacer que los programas y las bibliotecas sean más difíciles de aplicar ingeniería inversa.
- Listado de código muerto, por lo que puede ser eliminado del código fuente.
- Redirigir y preverificar los archivos de clase existentes para Java 6 o superior, para aprovechar al máximo su carga de clases más rápida.
Hay herramientas que perfilan el código y proporcionan datos de cobertura del código. Esto le permite ver (a medida que se ejecuta el código) cuánto se está llamando. Puede obtener cualquiera de estas herramientas para averiguar cuánto código huérfano tiene.
Hay un proyecto Java - Detector de código muerto (DCD). Para el código fuente no parece funcionar bien, pero para el archivo .jar es realmente bueno. Además puedes filtrar por clase y por método.
Hemos empezado a usar Find Bugs para ayudar a identificar algunos de los funk en el entorno rico en objetivos de nuestro código base para refactorizaciones. También consideraría la Estructura 101 para identificar puntos en la arquitectura de su base de código que son demasiado complicados, para que sepa dónde están los pantanos reales.
Herramientas de cobertura del usuario, como EMMA. Pero no es una herramienta estática (es decir, requiere ejecutar realmente la aplicación a través de pruebas de regresión y a través de todos los posibles casos de error, lo cual es, bueno, imposible :))
Aún así, EMMA es muy útil.
Instalaría el sistema en ejecución para mantener registros del uso del código y luego comenzar a inspeccionar el código que no se usa durante meses o años.
Por ejemplo, si está interesado en clases no utilizadas, todas las clases podrían instrumentarse para registrarse cuando se crean instancias. Y luego, un pequeño script podría comparar estos registros con la lista completa de clases para encontrar clases no utilizadas.
Por supuesto, si vas al nivel de método debes tener en cuenta el rendimiento. Por ejemplo, los métodos solo pueden registrar su primer uso. No sé cómo hacerlo mejor en Java. Lo hemos hecho en Smalltalk, que es un lenguaje dinámico y por lo tanto permite la modificación del código en tiempo de ejecución. Instrumentamos todos los métodos con una llamada de registro y desinstalamos el código de registro después de que un método se haya registrado por primera vez, por lo tanto, después de algún tiempo, no se producen más penalizaciones de rendimiento. Tal vez se pueda hacer algo similar en Java con banderas booleanas estáticas ...
IntelliJ tiene herramientas de análisis de código para detectar código que no se utiliza. Debería intentar hacer tantos campos / métodos / clases como no públicos como sea posible y se mostrarán más métodos / campos / clases no utilizados
También intentaría ubicar el código duplicado como una forma de reducir el volumen de código.
Mi última sugerencia es tratar de encontrar un código fuente abierto que, de ser utilizado, haría su código más simple.
La perspectiva de la sección Estructura101 proporcionará una lista (y un gráfico de dependencia) de cualquier "huérfano" o " groups huérfano" de clases o paquetes que no tengan dependencias hacia o desde el grupo "principal".
Las herramientas de cobertura de código, como Emma, Cobertura y Clover, instrumentarán su código y registrarán qué partes se invocan al ejecutar un conjunto de pruebas. Esto es muy útil y debería ser una parte integral de su proceso de desarrollo. Le ayudará a identificar qué tan bien su conjunto de pruebas cubre su código.
Sin embargo, esto no es lo mismo que identificar un código muerto real. Solo identifica el código que está cubierto (o no está cubierto) por las pruebas. Esto le puede dar falsos positivos (si sus pruebas no cubren todos los escenarios) así como falsos negativos (si sus pruebas acceden al código que en realidad nunca se usa en un escenario del mundo real).
Imagino que la mejor manera de identificar realmente el código muerto sería instrumentar su código con una herramienta de cobertura en un entorno de ejecución en vivo y analizar la cobertura del código durante un período prolongado de tiempo.
Si está ejecutando en un entorno redundante de carga equilibrada (y si no, ¿por qué no?), Supongo que tendría sentido instrumentar solo una instancia de su aplicación y configurar su equilibrador de carga de manera tal que una parte aleatoria, pero pequeña, de sus usuarios se ejecutan en su instancia instrumentada. Si hace esto durante un período prolongado de tiempo (para asegurarse de haber cubierto todos los escenarios de uso del mundo real, tales variaciones estacionales), debería poder ver exactamente a qué áreas de su código se accede bajo el uso en el mundo real y a qué partes. Realmente nunca se accede y por lo tanto el código muerto.
Nunca lo he visto personalmente y no sé cómo se pueden usar las herramientas antes mencionadas para instrumentar y analizar el código que no se está invocando a través de un conjunto de pruebas, pero estoy seguro de que pueden serlo.
Un complemento de Eclipse que funciona razonablemente bien es el Detector de código no utilizado .
Procesa un proyecto completo o un archivo específico y muestra varios métodos de código muerto / no utilizado, además de sugerir cambios de visibilidad (es decir, un método público que podría estar protegido o en privado).
Una cosa que se sabe que hago en Eclipse, en una sola clase, es cambiar todos sus métodos a privados y luego ver qué quejas recibo. Para los métodos que se utilizan, esto provocará errores, y los devuelvo al nivel de acceso más bajo que puedo. Para los métodos que no se utilizan, esto provocará advertencias sobre los métodos no utilizados, y luego se pueden eliminar. Y como beneficio adicional, a menudo se encuentran algunos métodos públicos que pueden y deben hacerse privados.
Pero es muy manual.
Uso Doxygen para desarrollar un mapa de llamadas a métodos para localizar métodos que nunca se llaman. En la gráfica encontrarás islas de grupos de métodos sin interlocutores. Esto no funciona para las bibliotecas, ya que siempre debe comenzar desde algún punto de entrada principal.
CodePro fue lanzado recientemente por Google con el proyecto Eclipse. Es gratis y altamente efectivo. El complemento tiene una función '' Buscar código muerto '' con uno / varios puntos de entrada. Funciona bastante bien
Netbeans aquí es un complemento para el detector de código muerto de Netbeans.
Sería mejor si pudiera vincular y resaltar el código no utilizado. Puede votar y comentar aquí: Error 181458 - Encuentre clases públicas, métodos, campos no utilizados
- FindBugs es excelente para este tipo de cosas.
- PMD (Project Mess Detector) es otra herramienta que puede usarse.
Sin embargo, ninguno de los dos puede encontrar métodos estáticos públicos que no se utilizan en un área de trabajo. Si alguien sabe de una herramienta así, por favor hágamelo saber.