java - proyecto - crear instalador en netbeans
¿Cuál es la mejor forma de compartir JAR en múltiples proyectos? (7)
Cuando tiene múltiples proyectos que usan el mismo conjunto de bibliotecas JAR, es tedioso incluir los mismos JAR una y otra vez con cada proyecto. Si estoy trabajando en 20 proyectos diferentes, prefiero no tener 20 del mismo conjunto exacto de archivos JAR por ahí. ¿Cuál es la mejor manera de hacer que todos esos proyectos (y también los nuevos proyectos) hagan referencia al mismo conjunto de JAR?
Tengo algunas ideas, pero cada una de ellas tiene algunas desventajas:
- Coloque todos los JAR en una carpeta y haga que cada proyecto se vea en esa carpeta.
- Usando Eclipse, cree una "Biblioteca de usuario" y haga que cada proyecto haga referencia a esa biblioteca de usuario.
- Cree un proyecto de "Biblioteca" que haga referencia a cada JAR y haga que cada proyecto haga referencia a ese proyecto de biblioteca.
Créalo o no, su enfoque ''tedioso'' es probablemente el enfoque más simple, más limpio y menos lento que existe.
Antes de subirte al carro del maven, deberías considerar lo que está realmente mal haciendo las cosas de la manera en que las estás haciendo actualmente. Mencionaste que es tedioso y que tienes muchos archivos jar por ahí. Creé el proceso de compilación en un gran proyecto de varios módulos usando Maven y pasé los siguientes 18 meses batallando constantemente con él. Créanme que fue tedioso y que había muchos archivos jar por ahí.
Desde que volvimos a Ant y nos comprometimos con el control de la fuente junto con los proyectos que los utilizan, ha sido un viaje mucho más fluido.
Guardo un montón de archivos jar en un único directorio en mi máquina y luego, cuando creo un nuevo proyecto o necesito agregar un nuevo jar a un proyecto existente, solo toma unos 30 segundos:
- Copie el jar de JAR_REPO a project lib dir.
- Agregar jar a build.properties
- Agregar jar a classpath en build.xml
- Agregue jar para compilar la ruta en Eclipse.
En el transcurso de un proyecto, esos 30 segundos son insignificantes, pero significa que tengo un proyecto que se puede retirar del control de fuente y simplemente funciona sin requerir ninguna configuración personalizada de Eclipse o instalaciones de Maven o configuración específica del usuario.
Este enfoque nos ha ahorrado a mí y a mi equipo de proyecto una gran cantidad de tiempo, principalmente porque es simple, confiable y fácil de entender.
Actualización : aclaración provocada por los comentarios
@Robert Munteanu: Gracias por los comentarios y comentarios actualizados. Esto puede sonar un poco argumentativo, pero me temo que no puedo estar de acuerdo con usted en que Maven es más simple y claro, o que le ahorrará tiempo en el largo plazo.
De su publicación:
"Creo firmemente que es más simple y más claro declarar dependencias en lugar de incluirlas manualmente. Hay un pequeño costo de una sola vez asociado con esto, más pequeño para Ivy que para Maven, pero a largo plazo da sus frutos".
Puede ser más fácil hacer que Maven descargue un archivo jar para usted que tener que descargarlo usted mismo, pero esa es la única ventaja. De lo contrario, Maven no es más simple, no es más claro y sus complejidades y limitaciones le costarán a largo plazo.
Claridad
Las dos declaraciones de dependencia a continuación hacen lo mismo. Encuentro a la hormiga mucho más clara que la de Maven.
Estilo Ant:
<path id="compile.classpath">
<pathelement location="${log4j.jar}" />
<pathelement location="${spring.jar}" />
</path>
Estilo Maven:
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>${spring.version}</version>
<scope>compile</scope>
</dependency>
Sencillez
Con la versión Ant puede desplazarse sobre la propiedad $ {log4j.jar} y le mostrará la ruta absoluta al archivo jar. Puede buscar el uso de compile.classpath. No hay mucho más que necesites saber.
No hay duda de que Maven es más complejo que el enfoque que estoy sugiriendo. Cuando comienzas con Maven estas son solo algunas de las preguntas que deben ser respondidas.
- ¿Qué significa groupId?
- ¿Qué significa artefacto?
- ¿De dónde viene el tarro?
- ¿Dónde está el frasco ahora?
- ¿Qué se proporciona el alcance? ¿Quién lo está proporcionando?
- ¿Cómo terminó ese archivo jar en mi archivo WAR?
- ¿Por qué esta dependencia no tiene un elemento de versión?
- No entiendo este mensaje de error ¿Qué diablos significa?
- ¿De dónde vino ese archivo jar? Yo no lo declare.
- ¿Por qué tengo 2 versiones del mismo archivo jar en mi classpath?
- ¿Por qué el proyecto no se construye más? Nada ha cambiado desde la última vez que lo construí.
- ¿Cómo agrego un contenedor de terceros que no está en el repositorio de Maven?
- Dime de nuevo de dónde obtengo ese plugin de Eclipse.
Dependencias transitivas
"Otro beneficio más pequeño es el manejo de dependencias transitivas y conflictivas".
En mi experiencia, las dependencias transitivas son más problemáticas de lo que valen. Terminas con varias versiones del mismo archivo jar y terminas con archivos jar opcionales que no deseas. Terminé declarando casi todo con el alcance proporcionado para evitar la molestia.
El rendimiento a largo plazo
"Enfócate en la programación, no en la construcción".
Estoy de acuerdo. Desde que volví a Ant y puse mis archivos jar en control de fuente, he podido pasar mucho menos tiempo lidiando con problemas de compilación.
Estas son las cosas que paso menos tiempo haciendo:
- Leyendo documentación pobre de Maven.
- Lectura aún más pobre de la documentación de Codehaus Mojo.
- Configuración de repositorios internos compartidos.
- Educar a los miembros del equipo.
- Escribir complementos Maven para llenar los huecos.
- Tratando de solucionar los complementos defectuosos (liberación, ensamblaje).
- Instalar plugins de Eclipse para Maven.
- Esperando que el complemento me devuelva el control de Eclipse.
De todos modos, perdón por la publicación larga. Tal vez ahora que lo saqué de mi pecho puedo cerrar mi larga y dolorosa experiencia de Maven. :)
Depende de tus necesidades, pero hay varias opciones viables. Mi trabajo utiliza una carpeta externa y todos los proyectos hacen referencia a esa carpeta, lo que hace que sea más fácil ejecutar compilaciones fuera de eclipse. Una biblioteca de usuarios es una forma un poco más agradable de hacer las cosas, siempre y cuando no te importe la ligera dependencia del eclipse. No veo mucho beneficio para un proyecto de biblioteca por sí mismo, pero si tiene algún tipo de proyecto de tipo ''util'' universal que todos los demás proyectos ya carguen, podría simplemente poner todos los archivos jar externos en ese proyecto.
Hemos optado por un método más tedioso pero que nos permite tener todo en nuestra empresa, pero probablemente solo funcionará bien para un pequeño grupo de desarrolladores.
Cada conjunto de archivos jar se configura como un proyecto Eclipse con el nombre apropiado después del conjunto de jar, agregado a la ruta de compilación, jar de origen y javadoc jars establecidos correctamente en cada jar en la ruta de compilación, y cada proyecto incluye aquellos proyectos de biblioteca necesarios para ese proyecto. El espacio de trabajo multiproyecto resultante se exporta luego como un archivo ProjectSet.psf que luego se puede leer en un Eclipse sin procesar, trayendo nuevamente todo el espacio de trabajo. Luego tenemos todos los proyectos anteriores en CVS, incluidos los archivos jar.
Esto ha funcionado muy bien o nosotros.
Si se encuentra en una organización más grande, el manejo de la dependencia en Maven puede funcionar bien para usted. Definitivamente debe tener un caché local de artefactos para que todo el mundo no se detenga si se pierde su conexión a Internet.
También tenga en cuenta que el nuevo Eclipse 3.5 que saldrá de este sommer tendrá un "Create Runnable Jar" que puede dar salida a los jar necesarios junto al jar ejecutable generado y configurar correctamente la línea Class-PAth en el Manifiesto. Espero que sea un gran ahorro de tiempo, compruébalo.
Puede editar los "JRE instalados" para incluir su archivo JAR ("Agregar JAR externos"), agregar el archivo al directorio jdk / jre / lib / ext / o especificar una variable de entorno CLASSPATH que contenga la ruta de acceso a él.
Un enfoque es poner todos sus archivos jar en una ubicación en su máquina, en su eclipse ide, definir una variable de entorno, digamos LIB_LOCATION que apunte a ese directorio y hacer que sus proyectos usen los jars relativos a esa variable. De esta manera, obtendrá la facilidad de uso, no múltiples tarros, portátiles en todas las máquinas, siempre que tenga la variable definida correctamente. He intentado maven para un grupo de proyectos de tamaño decente y parece que tengo que luchar al menos tanto como solía hacerlo. Errores y comportamientos cableados en los complementos, m2eclipse y q4eclipse.
Usa Maven o Ivy para manejar estos archivos jar compartidos. Si tiene dudas de cambiar sus proyectos demasiado, simplemente puede usar Ivy para administrar el classpath adicional para usted.
Ambos tienen buenos plugins de Eclipse:
m2eclipse
Contenedor de ruta de clase Maven http://img229.imageshack.us/img229/4848/mavendependencies.png
IvyDE
Contenedor classpath IvyDE http://img76.imageshack.us/img76/3180/cpnode.jpg
que he usado con buenos resultados.
Observará que ambos hacen referencia a jarras fuera del espacio de trabajo, por lo que se elimina la duplicación.
Actualización (provocada por los comentarios):
Mi razón para recomendar este enfoque es que creo firmemente que es más simple y más claro declarar dependencias en lugar de incluirlas manualmente. Hay un pequeño costo de una sola vez asociado con esto, más pequeño para Ivy que para Maven, pero a la larga da sus frutos.
Otro beneficio más pequeño es el manejo de dependencias transitivas y conflictivas. Es fácil olvidar por qué necesita ese commons-logging-1.1.jar en el classpath y si necesita actualizar a 1.1.1. Y tampoco es divertido obtener todas las dependencias requeridas, por ejemplo, un combo Hibernate + Anotación + Primavera. Enfócate en la programación, no en la construcción.
Yo recomendaría el enfoque de proyecto de "biblioteca".
Pero aún mejor, un proyecto de lib por jar externo, esto le permite rastrear deps entre jar de terceros y saber qué necesita cambiar cuando está actualizando una dependencia.
Asegúrese de verificar estos proyectos para que todos los usuarios estén usando las mismas versiones de libs de terceros y para que pueda regenerar fácilmente una versión de software (use etiquetas / etiquetas en su control de versión para agrupar qué versiones de qué proyectos van juntas)