Has realizado cambios en tu código Java, compilaste todo correctamente, generaste el archivo JAR… pero al ejecutarlo, el programa sigue comportándose igual que antes. Si te preguntas por qué tu archivo JAR no se actualiza, no estás solo. Este es un problema muy común tanto en desarrolladores principiantes como en profesionales que trabajan con proyectos grandes o automatizados.
El error suele deberse a una mezcla de factores: compilaciones incompletas, versiones antiguas en caché, rutas equivocadas o incluso configuraciones erróneas en el archivo MANIFEST.MF. En este artículo aprenderás por qué sucede, cómo solucionarlo paso a paso y cómo prevenirlo en el futuro.
¿Por qué mi archivo JAR no se actualiza?
Antes de intentar resolver el problema, es importante entender qué es realmente un archivo JAR. Un JAR (Java ARchive) es un paquete comprimido que contiene archivos .class compilados, recursos como imágenes o configuraciones, y metadatos sobre cómo ejecutar la aplicación. Es, esencialmente, el equivalente a un archivo ZIP para programas Java.
Qué contiene un archivo JAR
Dentro de un archivo JAR encontrarás carpetas con clases compiladas (extensión .class), recursos del proyecto y un archivo especial llamado MANIFEST.MF, ubicado en la carpeta META-INF. Este manifiesto indica qué clase debe ejecutarse y define información sobre el proyecto y las dependencias.
Si este manifiesto no se actualiza correctamente o apunta a una clase antigua, el programa podría ejecutar una versión anterior del código, incluso si las clases fueron recompiladas.
Cómo se genera un JAR
Puedes generar un JAR de varias formas: desde la línea de comandos con jar cf, o mediante herramientas de automatización como Maven (mvn package) o Gradle (gradle build).
En entornos integrados (IDEs) como Eclipse, IntelliJ o NetBeans, el proceso suele ser automático, pero puede fallar si la configuración del build no se limpia correctamente.
Por eso, es fundamental saber cómo y desde dónde se genera el JAR, ya que un error en esta etapa es una de las causas más comunes del problema.
Causas por las que un archivo JAR no se actualiza
El problema puede tener distintos orígenes, desde simples descuidos hasta errores complejos en la estructura del proyecto. Vamos a revisar los más frecuentes.
El IDE no recompila correctamente
A veces, aunque parezca que compilaste el proyecto, el entorno no recompila todas las clases. En Eclipse, por ejemplo, si la opción Build Automatically está desactivada, el IDE no genera nuevas versiones de las clases modificadas.
Esto significa que el JAR empaquetará los archivos antiguos, dando la impresión de que el programa “no se actualiza”.
Solución: asegúrate de activar la compilación automática o realiza un Clean and Build manual. En IntelliJ puedes usar Build → Rebuild Project para forzar una compilación completa.
Cambios no guardados o no compilados
Un error simple pero común es olvidar guardar los archivos antes de generar el JAR. Si el IDE no detecta cambios, compilará versiones anteriores del código.
También puede ocurrir que se compile solo una parte del proyecto, dejando archivos desactualizados en otras carpetas.
Consejo: antes de empaquetar, guarda todos los cambios (Ctrl + S o Cmd + S), y verifica que los archivos .class tengan fecha y hora actualizada.
Cache o versiones previas del JAR
Java, algunos servidores de aplicaciones y hasta el sistema operativo pueden mantener versiones en caché del archivo JAR. Esto es muy común si usas el mismo nombre de archivo (por ejemplo, app.jar) para diferentes versiones.
Solución: elimina versiones anteriores del JAR y reinicia cualquier proceso que lo esté usando. Si trabajas con Tomcat, GlassFish o Spring Boot, borra la carpeta temporal del servidor antes de desplegar la nueva versión.
MANIFEST.MF mal configurado
El archivo MANIFEST.MF define cuál es la clase principal (Main-Class) y puede contener rutas relativas a dependencias.
Si este archivo no se actualiza o mantiene referencias a clases antiguas, el JAR seguirá ejecutando código viejo, aunque hayas recompilado.
Solución: abre el archivo META-INF/MANIFEST.MF dentro del JAR (puedes usar WinRAR o el comando jar xf) y verifica que la clase principal corresponda a la actual. Si no, genera el JAR nuevamente con el manifiesto correcto.
Error al copiar o reemplazar el archivo
Puede parecer obvio, pero en muchos casos el problema está en copiar el nuevo JAR en el lugar equivocado o no reemplazar correctamente el archivo viejo.
Por ejemplo, si usas scripts de despliegue, es posible que estén copiando el JAR desde una carpeta antigua o temporal.
Consejo: verifica la ruta exacta de ejecución. Ejecuta java -jar nombre.jar desde el directorio donde está la última versión, y confirma con la fecha de modificación que sea la actual.
Soluciones prácticas para actualizar correctamente un archivo JAR
Una vez identificada la causa, hay varias formas de asegurarte de que tu JAR se actualice correctamente y refleje los cambios más recientes.
Limpia y recompila el proyecto
El primer paso siempre debe ser una limpieza total. Esto elimina archivos .class antiguos y genera nuevas versiones desde el código fuente.
En Maven, usa:
mvn clean package
En Gradle:
gradle clean build
Y en IDEs como Eclipse o IntelliJ, utiliza la opción Clean and Build o Rebuild Project.
Esto garantiza que todo el contenido del JAR sea completamente nuevo.
Revisa la ruta del archivo JAR
Si trabajas con varias copias del proyecto, es común ejecutar un archivo viejo por accidente.
Abre el explorador de archivos o usa el comando:
ls -lh nombre.jar
para confirmar la fecha y hora de creación. Así sabrás si estás ejecutando la última versión.
Verifica el contenido interno del JAR
Para comprobar si tu JAR contiene las clases actualizadas, puedes inspeccionarlo con:
jar tf nombre.jar
Esto muestra todas las rutas internas. Luego puedes descomprimirlo con:
jar xf nombre.jar
y abrir los archivos .class o MANIFEST.MF para verificar que reflejen los cambios recientes.
Revisa el MANIFEST.MF
Si el problema persiste, revisa el archivo MANIFEST.MF y asegúrate de que la línea Main-Class: apunte a la clase correcta.
Por ejemplo:
Main-Class: com.miempresa.app.Main
También verifica que las rutas de librerías externas (si las tienes en el classpath) estén bien configuradas. Si usas Maven o Gradle, deja que ellos generen el manifiesto automáticamente.
Limpia la caché de ejecución o servidor
Si tu aplicación Java corre dentro de un servidor, limpia su caché antes de desplegar.
En Tomcat, por ejemplo, borra la carpeta work/ y reinicia el servicio.
En entornos locales, reinicia la consola o el IDE para eliminar cualquier referencia antigua.
Prevención: buenas prácticas para mantener tus JAR siempre actualizados
Prevenir el problema es mucho más sencillo que solucionarlo cada vez. Con estas prácticas, tus builds serán más limpios y confiables.
Usa versionado en los artefactos
No uses siempre el mismo nombre de archivo. En lugar de app.jar, usa app-v1.1.jar o incluye un número de build.
Esto evita confusiones y te permite identificar fácilmente qué versión está en ejecución.
Automatiza el proceso de build
Usa pipelines de integración continua (CI/CD) como Jenkins, GitHub Actions o GitLab CI para automatizar la compilación y el empaquetado.
De este modo, cada commit genera un JAR limpio, sin depender de compilaciones manuales o desactualizadas.
Documenta y controla dependencias
Mantén actualizado tu pom.xml (en Maven) o build.gradle.
Si una dependencia antigua se mantiene en el proyecto, podría estar cargando código desactualizado. Usa comandos como:
mvn dependency:tree
para detectar versiones obsoletas.
Conclusión: un JAR actualizado es un proyecto estable
Entender por qué tu archivo JAR no se actualiza te ahorrará horas de frustración y errores innecesarios.
La mayoría de los casos se solucionan con una limpieza completa, revisión del manifiesto y control del entorno de ejecución.
Si adoptas buenas prácticas de versionado y automatización, tus builds serán consistentes, tus despliegues más seguros y tus aplicaciones más confiables.
Recuerda: un JAR actualizado significa un proyecto estable, profesional y fácil de mantener.