java - traducir - traductor de frases en ingles a español gratis
Manera limpia de combinar varias jarras? Preferiblemente usando Ant (11)
¿Has considerado usar Maven u otro sistema que gestiona tus dependencias automáticamente? Entonces no necesitaría especificar dónde se encuentra cada biblioteca, cuáles son sus nombres y qué dependencias transitivas tienen sus dependencias directas. Simplemente indicaría en un solo lugar cuál es la dependencia y su versión, y el sistema se encargaría de descargar las bibliotecas, configurar el classpath y construir el proyecto.
Tengo dependencias de tiempo de ejecución en algunos archivos jar externos que me gustaría "volver a unir" en un único contenedor. Estas dependencias externas se almacenan en un directorio external_jars, y me gustaría poder no tener que enumerarlas todas (es decir, no necesitar cambiar mis scripts de compilación si mis dependencias cambian). ¿Alguna idea?
Google me dio una buena respuesta sobre cómo hacer esto, si no te importa enumerar cada contenedor como una dependencia:
http://markmail.org/message/zijbwm46maxzzoo5
A grandes rasgos, quiero algo similar a lo siguiente, que combinaría todos los archivos jar en el directorio lib en out.jar (con algunas reglas de sobrescritura).
jar -combine -out out.jar -in lib/*.jar
Bueno, no estoy tan metido en la programación, pero algo más simple me funcionó ... si la pregunta significaba: combinar archivos jar en uno. Por supuesto, esta es una solución manual y sucia. Acabo de destrabar todos los tars ... y luego ... creé un nuevo archivo tar, agregando todos los directorios formados anulando el tar al nuevo archivo tar. funcionó.
Esta es mi solución:
<target name="-post-jar">
<echo>Packaging ${application.title} into a single JAR</echo>
<jar destfile="${basedir}${file.separator}${dist.dir}${file.separator}_${ant.project.name}_.jar">
<zipgroupfileset dir="${basedir}${file.separator}${dist.dir}" includes="${ant.project.name}.jar"/>
<zipgroupfileset dir="${basedir}${file.separator}${dist.dir}${file.separator}lib" includes="*.jar"/>
<manifest>
<attribute name="Main-Class" value="${main.class}"/>
</manifest>
</jar>
</target>
Intente extraer sus JAR a un directorio de clasificación primero:
<target name="combine-jars">
<mkdir dir="${marshall.dir}"/>
<unzip dest="${marshall.dir}">
<fileset dir="${external.jar.dir}">
<include name="**/*.jar"/>
</fileset>
</unzip>
<jar destfile="${combined.jar}" basedir="${marshall.dir"}>
<delete dir="${marshall.dir}"/>
</target>
Donde ${marshall.dir} es un directorio temporal, ${external.jar.dir} es donde guarda los JAR, y ${combined.jar} es el JAR objetivo.
La pregunta está bien respondida. Quería mencionar una herramienta que considero útil: One-Jar . One-Jar maneja los recursos de forma más limpia (manteniéndolos a todos). Esto es más útil si el código necesita procesar archivos MANIFEST.
Ejemplo de XML copiado del sitio web.
<import file="one-jar-ant-task.xml"/>
<target name="hello" depends="init">
<!-- Build lib.jar -->
<javac destdir="${classes.dir}/lib">
<src path="${lib.dir}" />
</javac>
<jar destfile="${build.dir}/lib.jar" >
<fileset dir="${classes.dir}/lib"/>
</jar>
<!-- Build classes for main.jar -->
<javac destdir="${classes.dir}/src">
<src path="${src.dir}" />
<classpath path="${build.dir}/lib.jar"/>
</javac>
<!-- Construct the One-JAR file -->
<one-jar destfile="hello.jar" manifest="hello.mf">
<main>
<!-- Construct main.jar from classes and source code -->
<fileset dir="${classes.dir}/src"/>
</main>
<lib>
<fileset file="${build.dir}/lib.jar" />
</lib>
</one-jar>
<echo>
Now you can run the Hello One-JAR example using
$ java -jar hello.jar
</echo>
</target>
La respuesta de Vladimir es correcta, pero creo que lo que sugiere implica reenvasar todas las jarras en un gran out.jar, que luego se alimenta a la tarea Ant Jar como un solo <zipfileset> o algo así. Este enfoque de dos pasos es innecesario. No estoy seguro de si esto está relacionado con la versión Ant, pero tengo Ant 1.7.1, y su tarea <jar> comprende <zipgroupfileset> , que permite alimentar todo el contenido de los <zipgroupfileset> de terceros directamente.
<jar destfile="MyApplication.jar">
<zipgroupfileset dir="lib" includes="*.jar" />
<!-- other options -->
<manifest>
<attribute name="Main-Class" value="Main.MainClass" />
</manifest>
</jar>
Maven u otras herramientas de compilación no pueden "administrar" la resolución de múltiples versiones de archivos de clase. De hecho, Maven causa estos problemas en primer lugar, a través de la inclusión transitiva de todos los archivos jar descendentes que no son explícitamente requeridos por un proyecto.
Supongamos que en algún lugar del cierre transitivo de un proyecto (todas las bibliotecas y módulos requeridos por el proyecto, y todos sus proyectos dependientes, recursivamente) hay dos versiones de un archivo de clase. ¿Cómo podría Maven saber cuál es el "correcto"? ¿Cuál fue diseñado por el programador?
No puede porque esta información se perdió cuando las dependencias explícitas fueron descartadas a favor de las transitorias (para guardar la tipificación XML).
Puedes echar un vistazo a jarjar:
Si está construyendo con una hormiga (estoy usando una hormiga de eclipse), puede agregar los archivos jar adicionales al agregarlos para agregarlos ... No necesariamente el mejor método si tiene un proyecto mantenido por varias personas, pero funciona para un proyecto de una persona y es fácil.
por ejemplo, mi objetivo que estaba construyendo el archivo .jar era:
<jar destfile="${plugin.jar}" basedir="${plugin.build.dir}">
<manifest>
<attribute name="Author" value="ntg"/>
................................
<attribute name="Plugin-Version" value="${version.entry.commit.revision}"/>
</manifest>
</jar>
Acabo de agregar una línea para hacerlo:
<jar ....">
<zipgroupfileset dir="${external-lib-dir}" includes="*.jar"/>
<manifest>
................................
</manifest>
</jar>
dónde
<property name="external-lib-dir" value="C:/.../eclipseWorkspace/Filter/external/.../lib" />
era el directorio con los frascos externos. Y eso es todo ... También puedes agregar varias etiquetas zipgroupfileset.
Si usas maven, ¿por qué no? :) Simplemente usa el plugin maven-shade, ¡funciona como un encanto!
<project>
...
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>1.5</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>com.YOUR_COMPANY.YOUR_MAIN_CLASS</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
...
</project>