Makefile para Java

gnu make ¿Cuántos de ustedes han tenido los programadores de Java problemas al compilar programas? bibliotecas a $ CLASSPATH, parámetros kilométrico a pasar al compilador de Java. Incluso la utilización de entornos de desarrollo para Java, la situación no mejora mucho. Pasamos mucho tiempo Parámetro y establecer cada vez que inicia el llenado falta algo!

Usted puede evitar todos estos problemas simplemente mediante la organización de la fuente de Java y el uso de un escrito Makefile para tal fin.

¿Qué es un Makefile

Un Makefile es un archivo que describe los pasos para llegar a efftuare archivos que tenemos el árbol y todas sus dependencias. Se utiliza en plataformas basadas en Unix y pueden ser utilizados para elaborar cada tipo de programa. La utilidad make interpreta el makefile y compilar el código fuente de programas ejecutables y bibliotecas.

Ventajas de usar que

Muchos de ustedes son escépticos de la utilización de un makefile para cada proyecto Java por la sencilla razón de que el makefile tiene que especificar las dependencias entre archivos, lo que sin duda varía de un proyecto a otro. Por lo tanto, debe escribir un makefile para nuestro proyecto entre sí. Este límite puede ser superado por escrito un generador de Makefile es capaz de calcular todos las dependencias para que el proyecto sea completado para utilizar el mismo guión para todos los proyectos sin que nada moficare en el makefile.

Por supuesto que no despreciable ventaja es la capacidad de hacer lo suficiente para llenar. Por favor, evitar hacer lo que ya está terminado y no se ha modificado con un ahorro sustancial de tiempo.

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

Cómo usarlo

El makefile que escribí para construir proyectos de Java puede ser utilizado sin modificaciones para proyectos que tienen una estructura de directorios determinados. La fuente de Java debe tener un directorio para. Java, uno de los archivos. Class, y un frasco para las bibliotecas.
Por ejemplo: 

  | - Src
 | `- Principal
 | | - Java
 | | `- Com
 | | `- Ejemplo
 | | | - ExampleA.java
 | | | - ExampleB.java
 | | `- ExampleC.java
 | `- Recursos
 | `- Res.java
 | - Clases
 | - Librerias
 | | - General
 | | | - Base de datos
 | | | | - DB1.jar
 | | | `- DB2.jar
 | `- Registro
 | `- Log.jar
 | - Tarros

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 es el especificado en el archivo (para las clases. Clase, por src. libs a de jar java) y el lanzamiento de comandos make
eso es todo. Si queremos un frasco que contiene el proyecto en su conjunto sólo ejecute 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) \/ \? //' ) Subdirectoios: = $ (shell encontrar $ (SOURCE_DIR) - name "*. java" -% h printf \ n | sort | uniq | sed 's / $ (SOURCE_DIR) \ / \? / /')

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

 Campo # compilador
 JDEBUGFLAGS = #-g-desaprobación
 JDEBUGFLAGS = #-O-dependen-nowarn
 ) / javac CCM = $ (JAVA_HOME) / javac

 clean classes compile jar . Falso: compilación limpia clases jar

 a:
	 SUBDIRS ) ; do \ @ @ Para p en $ (subdirectorios); hacer \
		 p ; \ echo 'compilar' $ $ p; \
		 $$ p ; \ Exportación SubD = $ $ p; \
		 print - directory compile ; \ hacer - sin letra - - compilación de directorios, \
	 hecho

 Limpieza:
	 f * ~ *. class *. bak $ ( foreach dir ,$ ( SUBDIRS ) ,$ ( CLASS_DIR ) /$ ( dir ) /*. class ) - RM - f * ~ *. bak *. class $ (dir foreach, $ (subdirectorios) $ (CLASS_DIR) / $ (dir) / *. class)


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

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

 compilar: clases

 Crear dir # clase objetivo si no está presente.
 ) : $ (LOCAL_CLASS_DIR):
	 LOCAL_CLASS_DIR ) mkdir - p $ (LOCAL_CLASS_DIR)


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


 # Que le dice a make comando mágico para encontrar archivos de clase en otro dir
 class $ ( LOCAL_CLASS_DIR ) Vpath%. $ Class (LOCAL_CLASS_DIR)
 java $ ( LOCAL_SOURCE_DIR ) Vpath%. Java (LOCAL_SOURCE_DIR)

 # Ruta de clases, pulg todos los / las jarras y. / Libs
 ) :$ ( SOURCE_DIR ) :$ ( subst . jar ,. jar :,$ ( wildcard libs /*. jar libs /*/*. jar libs /*/*/*. jar jars /*. jar ) ) LIBCLASSPATH: = $ (CLASS_DIR): $ (SOURCE_DIR): $ (Sust. Jar. Jar: $ (comodín libs / libs *. jar libs /*/*/*. /*/*. frascos de Jar Jar / * . jar))

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

 # Descubra el objetivo de los archivos
 $ ( 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:. java clase =.)

Buena compilación.

Una respuesta a "Makefile para Java"

  1. thegamer - 28 de agosto 2009

    Me gusta mucho más hormiga!
    Deberías probarlo ...

Deja una respuesta