Makefile para Java

Publicado el 26 de mayo de 2009 por la pluma

0 votado votar

¿Cuántos de ustedes los programadores de Java han tenido problemas al compilar programas? las bibliotecas de los $ CLASSPATH parámetros de kilometraje, para pasar al compilador de Java. Incluso el uso de las herramientas de desarrollo para Java, la situación no mejora mucho. Pasamos un montón de tiempo para establecer paramteri y cada vez que inicie la compilación siempre falta algo!

Usted puede evitar todos estos problemas simplemente por la organización de la fuente de Java y el uso de un Makefile escrita ad hoc.

¿Qué es un Makefile

Un creador de archivos es un archivo que describe los pasos para efftuare para llegar a los archivos que obtendríamos el árbol y todas sus dependencias. Se utiliza ampliamente en plataformas basadas en UNIX y puede ser usado para construir cualquier tipo de programa. La utilidad make interpreta el makefile y compilar el código fuente de los programas ejecutables y bibliotecas.

Ventajas en el uso de hacer

Muchos de ustedes serán escépticos de la utilización de un makefile para cada proyecto de Java por la sencilla razón de que el makefile tiene que especificar las dependencias entre los archivos, seguramente va a cambiar de proyecto a proyecto. Por lo tanto, debe escribir un makefile diferente para cada proyecto. Esta limitación puede ser superada por escribir un makefile genéricos y se pueden calcular todas las dependencias para que el proyecto se completará con el fin de utilizar el mismo guión para todos los proyectos sin que nada moficare en el makefile.

Una ventaja ciertamente no despreciable es la capacidad de hacer para llenar solamente la necesaria. Así se evita compiare de lo que ya está terminado y no ha sido modificado con un ahorro considerable de tiempo.

Con sólo un makefile puede compilar todas las fuentes del proyecto.

Cómo utilizar

El makefile que escribí para compilar los proyectos de Java puede ser utilizado sin modificaciones para los proyectos que tienen una estructura de directorios determinado. El código fuente de Java debe tener un directorio para. Java, uno de los archivos. Clase, y un frasco para las bibliotecas.
Tal como:

  | - Src
 | `- Principal
 | | - Java
 | | `- Com
 | | `- Ejemplo
 | | | - ExampleA.java
 | | | - ExampleB.java
 | | `- ExampleC.java
 | `- Recursos
 | `- Res.java
 | - Clases
 | - Libs
 | | - General
 | | | - Base de datos
 | | | | - DB1.jar
 | | | `- DB2.jar
 | `- Inicio de sesión
 | `- Log.jar
 | - Tarros

Para usarlo, y sólo resta escribir el código de abajo en el Makefile en el directorio raíz del proyecto, compruebe que el nombre del directorio que se especifica en el archivo (para las clases de la clase;.. Src en las librerías de java y jar) y lanzar el mandar make
eso es todo. Si queremos un frasco que contiene la totalidad del proyecto basta con ejecutar make && make jar

Makefile

  #
 # Makefile
 # Autor: Danilo Abbasciano
 #

 # Establezca aquí los directorios de las clases y las fuentes
 = CLASS_DIR clases
 Src = SOURCE_DIR
 JARS_DIR = frascos

 find $ ( SOURCE_DIR ) - name "*.java" - printf % h\\n | sort | uniq | sed 's/$(SOURCE_DIR) \/ \? //' ) SUBDIRS: = $ (shell encontrar $ (SOURCE_DIR) - nombre de "Java *." -% Printf h \ \ n | sort | uniq | sed 's / $ (SOURCE_DIR) \ / \ / /?)

 local / java / bin JAVA_HOME = / usr / local / java / bin

 # Compilador de campo
 # JDEBUGFLAGS =-g-desaprobación
 # JDEBUGFLAGS =-O-dependen-nowarn
 ) / javac CCM = $ (JAVA_HOME) / javac

 clean classes compile jar El falso.: Limpia las clases de compilación jar

 a:
	 SUBDIRS ) ; do \ @ @ Para p en $ (SUBDIRS); hacer \
		 echo 'compilación'       $</span>p<span style="color: #004400;">;</span> \ <span style="color: #666622; font-weight: bold;">export</span> SUBDIR<span style="color: #004400;">=</span><span style="color: #000088; font-weight: bold;">$   p, \
		 print - directory compile ; \ que - no - impresión - directorio de compilación, \
	 hecho

 limpiar:
	 f * ~ *. class *. bak $ ( foreach dir ,$ ( SUBDIRS ) ,$ ( CLASS_DIR ) /$ ( dir ) /*. class ) - RM - f * ~ * Clase Bak $ (foreach dir, $ (SUBDIRS) $ (CLASS_DIR) / $ (dir) / * Clase.)..


 ) /$ ( SUBDIR ) LOCAL_CLASS_DIR = $ (CLASS_DIR) / $ (subdirectorio)
 ) /$ ( SUBDIR ) LOCAL_SOURCE_DIR = $ (SOURCE_DIR) / $ (subdirectorio)

 jar:
	 ) ; jar - cf ../$ ( JARS_DIR ) / project . jar * cd $ (CLASS_DIR) jar - ver .. / $ (JARS_DIR) / proyecto jar *.

 compilación: clases

 # Crear clases directorio de destino si no está presente.
 ) : $ (LOCAL_CLASS_DIR):
	 LOCAL_CLASS_DIR ) mkdir - p $ (LOCAL_CLASS_DIR)


 # Nueva regla para Java
 Sufijos:.
 java . class Sufijos:... Java Class


 # Este comando mágico le dice que para encontrar los archivos de clase en otro directorio
 class $ ( LOCAL_CLASS_DIR ) VPATH%. clase $ (LOCAL_CLASS_DIR)
 java $ ( LOCAL_SOURCE_DIR ) VPATH%. java $ (LOCAL_SOURCE_DIR)

 # Rutas de clases, todos los frascos y pulgadas / libs /.
 ) :$ ( SOURCE_DIR ) :$ ( subst . jar ,. jar :,$ ( wildcard libs /*. jar libs /*/*. jar libs /*/*/*. jar jars /*. jar ) ) LIBCLASSPATH: = $ (CLASS_DIR): $ (SOURCE_DIR): $ (subst. Jar Jar., $ (LIBS comodín / * libs Jar / libs * / * Jar / * / * / * / * Jar tarros... . jar))

 # Comando compil
 class : .. Java Class:
	 ) $ ( JCC ) - nowarn - d $ ( CLASS_DIR ) $ ( JDEBUGFLAGS ) $< CLASSPATH = $ (LIBCLASSPATH) $ (CCM) - nowarn - d $ (CLASS_DIR) $ (JDEBUGFLAGS) $ <

 # Averigüe los archivos de destino
 $ ( LOCAL_SOURCE_DIR ) /*. java ) PATHFILES = $ ($ comodín (LOCAL_SOURCE_DIR) / Java *.)
 $ ( LOCAL_SOURCE_DIR ) /,,$ ( PATHFILES ) ) ARCHIVOS = $ ($ subst (LOCAL_SOURCE_DIR) /, $ (PATHFILES))
 java =. class ) clases: $ (ARCHIVOS:.. = clase java)