|
Inizio con il dedicare quest'articolo a Gabriele Folchi, un amico e collega, che ha avuto la mia stessa idea, ma che per motivi di tempo non ha potuto anticiparmi nella stesura. I propositi che quest'articolo si propone sono duplici, vorrei introdurvi empiricamente al mondo di ant tramite uno script completo dei tag comunemente più utilizzati, ma soprattutto interagire con voi nell'invitarvi a commentare e completare, migliorando o ampliando, le funzionalità dello script finale. Javaportal provvederà al più presto ad integrare questo articolo con i vostri miglioramenti, commentando le nuove funzionalità firmate da voi con la vostra mail ed eventualmente la società di appartenenza.
Scrivete a m.marzocchi@k-tech.it Non è mia intenzione spiegarvi in quest'articolo i fondamenti di ANT perché è un argomento già trattato dal nostro portale e se lo ritene opportuno potete leggere il tutorial dedicatatogli, ma realizzare insieme a voi uno script completo che ha la presunzione di offrirvi anche la possibilità di configurarvi un IDE di rapido startup di ambienti, per ospitare il vostro codice sorgente. Per lo startup di un nuovo progetto abbiamo bisogno di un buon tool di sviluppo, dell'ottima documentazione funzionale, un programma di versionamento del codice, ma anche di una struttura team-standard di organizzazione e disposizione delle nostre risorse, in grado di essere facilmente consultabile ed inoltre che ci dia la possibilità di compilare e packagiare e deployare il nostro codice in maniera sicura e rapida. Abbiamo bisogno quindi di stabilire la cartella principale che ospiterà tutte le risorse "src_folder", con al suo interno una struttura a directory in grado di suddividere in maniera articolata e friendly le varie classi, xml, jsp etc…
Successivamente necessita una cartella che ospiti le nostre classi per la web application "web_java_folder", una che conterrà le nostre jsp "jsp_folder", ed ancora una per le librerie jar - zip da rendere visibili alla nostra webapp "web_lib_folder", una cartella dove andremo a salvare i nostri web file xml "xml_web_folder", se decidiamo di arricchire la nostra applicazione con degli ejb allora dobbiamo avere anche una cartella che ospiti le classi dei nostri ejb "ejb_folder" ed ancora una cartella per gli ejb file xml "xml_ejb_folder". Immaginate di avere, come nella maggior parte dei casi succede, delle classi necessarie sia agli ejb che alla web-app, sarebbe inutile inserire il sorgente in entrambi gli enviroment, quindi meglio avere una unica cartella che le contenga su cui entrambi abbiano visibilità "common_java_folder". Una cartella infine che conterrà gli xml file per il nostro Enterprise Archive (.ear) "xml_ear_folder".
In fase di compilazione del codice potrei voler vedere in console-out i warnings dell'utilizzo dei metodi deprecati nelle classi e quindi decidere se avere "deprecation" on oppure off, e meglio ancora se fare "debug" della compilazione e quindi anche qui on-off.
Adesso non mi resta che decidere che nome dare al mio al file war che otterrò dopo la compilazione "war_name", il nome del mio jar che conterrà gli ejb "jar_name" ed il nome del mio ear "ear_name". Cosa manca….. la cartella dove il nostro application server eseguirà auto deploy "deploy_folder".
Il nostro file build.xml ci darà la possibilità di configurare queste informazioni in maniera interattiva salvandole, persistendole un file esterno.
Cominciamo con l'assegnare un nome al nostro progetto, e una directory root su cui effettuare le operazioni se non espressamente specificata all'interno del task.
Importante definire un target di default che sarà lanciato, se non espressamente richiesto.
<project name="EAR-SPIDER" default="HELP" basedir=".">
<description>Build Ear file</description>
Dichiariamoci alcune proprietà di enviroment che ci serviranno all'interno dello script, come ad esempio il nome della cartella che conterrà i nostri jar,war,ear. Ed il file su cui andare a prelevare le altre variabili d'ambiente.
<property environment="env"/>
<property file="spider.web"/>
<property name="build" location="./build"/>
Andiamo quindi a definirci due classpath distinti assegnandogli dei nomi univoci "web.classpath" ed "ejb.classpath".
<path id="web.classpath">
<pathelement path="${classpath}"/>
<fileset dir="${src_folder}/${web_lib_folder}">
<include name="**/*.jar"/>
</fileset>
</path>
<path id="ejb.classpath">
<fileset dir="${src_folder}/${web_lib_folder}">
<include name="**/*.jar"/>
<include name="**/*.zip"/>
</fileset>
<pathelement path="${classpath}"/>
</path>
Definiamo quindi un primo target "AUTO-CONFIG", che ci permetterà di configurare automaticamente con dei valori predefiniti il nostro ambiente di sviluppo. Questo target sarà considerato eseguito solo se regolarmente svolto senza errori il target preset…..
<target name="AUTO-CONFIG" depends="preset"/> …..ecco quindi il nostro target "preset" che si occuperà di cancellare eventualmente, e creare un file con nome spider.web su cui andremo a scrivere la configurazione di default delle proprietà precedentemente menzionate, ma solo se non viene rilevata gia settata una variabile di nome "spider".
<target name="preset" unless="spider">
<delete file="spider.web"/>
<propertyfile file="spider.web" comment="BUILDING PROPERTIES">
<entry key="spider" value="web"/>
<entry key="src_folder" value="${basedir}/src"/>
<entry key="war_name" value="web_app" />
<entry key="jar_name" value="ejb_app"/>
<entry key="ear_name" value="app_final"/>
<entry key="deploy_folder" value="${basedir}"/>
<entry key="web_java_folder" value="web-java"/>
<entry key="ejb_folder" value="ejb-java"/>
<entry key="common_java_folder" value="common-java"/>
<entry key="jsp_folder" value="jsp"/>
<entry key="xml_ear_folder" value="xml-app"/>
<entry key="xml_web_folder" value="WEB-INF"/>
<entry key="xml_ejb_folder" value="META-INF"/>
<entry key="web_lib_folder" value="web-lib"/>
<entry key="debug" value="off"/>
<entry key="deprecation" value="off"/>
</propertyfile>
</target> Ecco invece il target che ci permetterà di configurare manualmente da console le proprietà di enviroment, facendo attenzione a chiamare precedentemente il target "preset" appena visionato, cosi da configurare con successo spider.web, anche in caso di errore o parziale configurazione delle variabili. E successivamente invocando il target "set" ……
<target name="CONFIG" depends="preset,set"/>
……che provvederà in un primo mometno a reperire le info necessarie e successivamente a salvarle all'interno del file spider.web
<target name="set">
<echo message="Configurazione delle impostazioni di repository delle risorse, di packaging e deploy .....!!"/>
<input message="Indicare il nome della cartella che conterra' i sorgenti (es src)?" addproperty="src_folder" />
<input message="Indicare il nome della cartella che conterra' le classi java per il WEB (es web- java)?" addproperty="web_java_folder" />
<input message="Indicare il nome della cartella che conterra' le classi java comuni al WEB e agli EJB (es common-java)?" addproperty="common_java_folder" />
<input message="Indicare il nome della cartella che conterra' le JSP (es jsp)?" addproperty="jsp_folder" />
<input message="Indicare il nome della cartella che conterra' le classi java EJB (es ejb-java)??" addproperty="ejb_folder" />
<input message="Indicare il nome della cartella che conterra' gli xml per l' EAR come application.xml (es xml- ear)?" addproperty="xml_ear_folder" />
<input message="Indicare il nome della cartella che conterra' gli xml per gli EJB come ejb-jar.xml (es xml-ejb)?"addproperty="xml_ejb_folder" />
<input message="Indicare il nome della cartella che conterra' gli xml per il WEB come web.xml (es xml- web)?" addproperty="xml_web_folder" />
<input message="Indicare il nome della cartella che conterra' i jar e zip per la lib del WEB (es lib- web)?" addproperty="web_lib_folder" />
<input message="Inserire se si vuole ottenere il debug-out durante la compilazione delle classi e JSP?" validargs="on,off" addproperty="debug" />
<input message="Inserire se si vuole ottenere in out i warning dei metodi deprecati durante la compilazione delle classi e JSP?" validargs="on,off" addproperty="deprecation" />
<input message="Indicare il nome del file war che si vuole ottenere (es javaportal)?" addproperty="war_name" />
<input message="Indicare il nome del file jar degli ejb che si vuole ottenere (es k-techEJB)?" addproperty="jar_name" />
<input message="Indicare il nome del file ear che si vuole ottenere (es final)?" addproperty="ear_name" />
<input message="Indicare il path assoluto della cartella di deploy del server (es c:\jboss\server\....)?" addproperty="deploy_folder" />
<propertyfile file="spider.web" comment="BUILDING PROPERTIES">
<entry key="src_folder" value="${basedir}/${src_folder}" />
<entry key="war_name" value="${war_name}" />
<entry key="jar_name" value="${jar_name}" />
<entry key="ear_name" value="${ear_name}" />
<entry key="deploy_folder" value="${deploy_folder}" />
<entry key="web_java_folder" value="${web_java_folder}" />
<entry key="ejb_folder" value="${ejb_folder}" />
<entry key="common_java_folder" value="${common_java_folder}" />
<entry key="jsp_folder" value="${jsp_folder}" />
<entry key="xml_ear_folder" value="${xml_ear_folder}" />
<entry key="xml_web_folder" value="${xml_web_folder}" />
<entry key="xml_ejb_folder" value="${xml_ejb_folder}" />
<entry key="web_lib_folder" value="${web_lib_folder}" />
<entry key="debug" value="${debug}" />
<entry key="deprecation" value="${deprecation}" />
</propertyfile>
<echo message="Configurazione completa!!!! Per cambiare queste configurazioni editare il file spider.web.."/>
</target>
A questo punto dovremmo ricordarci che avevamo definito come target di default di questo progetto il target di nome "HELP", che ci mostrerà semplicemente la lista dei target principali definiti in questo build.xml con un breve abstract descrittivo sulle loro funzionalità
<target name="HELP">
<echo message="###### TASK LIST #####"/>
<echo message="" />
<echo message="" />
<echo message="[ AUTO-CONFIG ] Questo task permette di autoconfigurare i processi con i valori di default!!!" />
<echo message="" />
<echo message="[ CONFIG ] Questo task permette di configurare manualmente i processi con valori assoluti!!!" />
<echo message="" />
<echo message="[ CR-ejb-struct ] Questo task creera' una struttura a directory per contenere i sorgenti di applicazioni EJB " />
<echo message="" />
<echo message="[ CR-web-struct ] Questo task creera' una struttura a directory per contenere i sorgenti di una applicazione WEB" />
<echo message="" />
<echo message="[ CR-structure ] Questo task creera' una struttura a directory per contenere i sorgenti di una applicazione EAR completa" />
<echo message="" />
<echo message="[ EXECUTE ] Questo task permette di compilare packagiare e deployare l'applicazione" />
<echo message="" />
<echo message="" />
<echo message="#########" />
<echo message="ATTENZIONE E' NECESSARIO LANCIARE LA PRIMA VOLTA CHE SI UTILIZZA QUESTO BUILD.XML IL TASK DI CONFIGURAZIONE (AUTO-CONFIG oppure CONFIG)" />
<echo message="#########" />
</target>
Ecco il primo dei tre target che provvederanno a costruire l'ambiente che utilizzeremo per contenere i nostri sorgenti.
Il target "CR-web-struct" si occuperà di creare le cartelle che ci occorrono per costruire un web application, il target avrà esito positivo solo se trova già settate le variabili "src_folder" e "jsp_folder", ovvero il nome delle cartelle che conterranno i nostri sorgenti e quindi le nostre jsp
<target name="CR-web-struct" description="Create WEB Structure">
<condition property="CR-web-struct-ok">
<and>
<isset property="src_folder"/>
<isset property="jsp_folder"/>
</and>
</condition>
<fail message="##### ATTENZIONE QUESTO BUILD.XML NON E' STATO ANCORA CONFIGURATO.....prego lanciare il task CONFIG o AUTO-CONFIG !!...."
unless="CR-web-struct-ok"/>
<mkdir dir="${src_folder}"/>
<mkdir dir="${src_folder}/${web_java_folder}"/>
<mkdir dir="${src_folder}/${xml_ear_folder}"/>
<mkdir dir="${src_folder}/${common_java_folder}"/>
<mkdir dir="${src_folder}/${xml_web_folder}"/>
<mkdir dir="${src_folder}/${web_lib_folder}"/>
<mkdir dir="${src_folder}/${jsp_folder}"/>
</target>
Il target "CR-ejb-struct" si occuperà di creare le cartelle che ci occorrono per realizzare i nostri ejb, il target avrà esito positivo solo se trova già settate le variabili "src_folder" e "ejb_folder", ovvero il nome delle cartelle che conterranno i nostri sorgenti e quindi i nostri ejb
<target name="CR-ejb-struct" description="Create EJB Structure">
<condition property="CR-ejb-struct-ok">
<and>
<isset property="src_folder"/>
<isset property="ejb_folder"/>
</and>
</condition>
<fail message="##### ATTENZIONE QUESTO BUILD.XML NON E' STATO ANCORA CONFIGURATO.....prego lanciare il task CONFIG o AUTO-CONFIG !!...." unless="CR- ejb-struct-ok"/>
<mkdir dir="${src_folder}"/>
<mkdir dir="${src_folder}/${ejb_folder}"/>
<mkdir dir="${src_folder}/${xml_ear_folder}"/>
<mkdir dir="${src_folder}/${common_java_folder}"/>
<mkdir dir="${src_folder}/${xml_ejb_folder}"/>
</target>
Il target "CR-structure" si occuperà di creare tutte le cartelle che ci occorrono per costruire un web application comprensiva di ejb, il target avrà esito positivo solo se trova già settate le variabili "src_folder" "jsp_folder" e "ejb_folder", ovvero il nome delle cartelle che conterranno i nostri sorgenti quindi le nostre jsp e i nostri ejb
<target name="CR-structure" description="Create Complete Application Structure">
<condition property="CR-struct-ok">
<and>
<isset property="src_folder"/>
<isset property="jsp_folder"/>
<isset property="ejb_folder"/>
</and>
</condition>
<fail message="##### ATTENZIONE QUESTO BUILD.XML NON E' STATO ANCORA CONFIGURATO.....prego lanciare il task CONFIG o AUTO-CONFIG !!...." unless="CR-struct-ok"/>
<mkdir dir="${src_folder}"/>
<mkdir dir="${src_folder}/${web_java_folder}"/>
<mkdir dir="${src_folder}/${ejb_folder}"/>
<mkdir dir="${src_folder}/${xml_ear_folder}"/>
<mkdir dir="${src_folder}/${common_java_folder}"/>
<mkdir dir="${src_folder}/${xml_web_folder}"/>
<mkdir dir="${src_folder}/${xml_ejb_folder}"/>
<mkdir dir="${src_folder}/${web_lib_folder}"/>
<mkdir dir="${src_folder}/${jsp_folder}"/>
</target> Arrivati a questo punto siamo pronti ad utilizzare il target principale dello script "EXECUTE". Analizzeremo tutti i suoi target dipendenti secondo una logica procedurale, e quindi iniziamo da "evaluate"
<target name="EXECUTE" depends="evaluate,cleanup,init-web,init-ejb,compile-ejb,create-ejbClient,copy-ejbClient,compile-web,copy-web,compile-jsp,copy-ejb,create-war,create-jar,create-ear,undeploy,deploy"/> Questo target ci da la sicurezza che la struttura a directory non sia cambiata rispetto alla nostra configurazione iniziale che potrebbe risalire a diversi mesi fa, in più setta alcune variabili che ci occorrono per decidere quali target eseguire in funzione delle cartelle presenti.
<target name="evaluate" description="Evaluate war-jar " >
<echo message="--|--|--|> Start Building Application............." />
<condition property="web.ok">
<or>
<available file="${src_folder}/${web_java_folder}" type="dir" property="src.web.present"/>
<available file="${src_folder}/${jsp_folder}" type="dir" property="src.jsp.present"/>
</or>
</condition>
<condition property="ejb.ok">
<available file="${src_folder}/${ejb_folder}" type="dir" property="src.ejb.present"/>
</condition>
<condition property="web.ejb-exist">
<and>
<isset property="ejb.ok"/>
<isset property="web.ok"/>
</and>
</condition>
<condition property="web-or-ejb-exist">
<or>
<isset property="ejb.ok"/>
<isset property="web.ok"/>
</or>
</condition>
<fail message="##### ATTENZIONE LA STRUTTURA A DIRECTORY NON E' CONFORME ALLA CONFIGURAZIONE DEL FILE spider.web....." unless="web-or-ejb-exist"/>
</target>
Un target molto utile che ci azzererà il contenuto e la cartella che conteneva le vecchie classi e jar già compilati in precedenza
<target name="cleanup">
<delete dir="${build}"/>
</target>
Dobbiamo adesso creare una struttura che contenga le nostre jsp precompilate "tmp-jsp" e la struttura standard compattata di una web application "web", questo target verrà eseguito solo se il target "evaluate" ha settato la variabile "web.ok" indicando che esiste una struttura di sorgenti per ospitare una web-app.
<target name="init-web" if="web.ok" >
<parallel>
<mkdir dir="${build}"/>
<mkdir dir="${build}/web"/>
<mkdir dir="${build}/tmp-jsp"/>
<mkdir dir="${build}/web/WEB-INF"/>
<mkdir dir="${build}/web/WEB-INF/lib"/>
<mkdir dir="${build}/web/WEB-INF/classes"/>
</parallel>
</target>
Dobbiamo adesso creare una struttura che contenga i nostri ejb "ejb" con all'interno la cartella standard "META-INF" che conterrà i nostri xml per gli ejb, questo target verrà eseguito solo se il target "evaluate" ha settato la variabile "ejb.ok" indicando che esiste una struttura di sorgenti per ospitare degli ejb.
<target name="init-ejb" if="ejb.ok">
<parallel>
<mkdir dir="${build}"/>
<mkdir dir="${build}/ejb"/>
<mkdir dir="${build}/ejb/META-INF"/>
</parallel>
</target>
Pronti per compilare I nostri ejb insieme alle "common class" andando a salvare i compilati nella cartella "build\ejb", questo target verrà eseguito solo se il precedente task init-ejb ha avuto esito positivo e se viene rilevata settata la variabile "ejb.ok"
<target name="compile-ejb" depends="init-ejb" description="Compile Java-EJB File " if="ejb.ok" >
<javac destdir="${build}/ejb" debug="${debug}" debuglevel="vars,lines,source" deprecation="${deprecation}">
<src path="${src_folder}/${ejb_folder}"/>
<src path="${src_folder}/${common_java_folder}"/>
<classpath refid="ejb.classpath"/>
</javac>
</target>
Se abbiamo un struttura per web application e per ejb "web.ejb-exist", molto probabilmente la nostra web-app avrà necessità di avere nella cartella lib le interfacce degli ejb per effettuare il casting dopo la lookup, quindi creiamo un jar che prenda il nome del jar dei nostri ejb più "_stub"……….
<target name="create-ejbClient" depends="compile-ejb" if="web.ejb-exist" >
<jar destfile="${build}/${jar_name}_stub.jar">
<fileset dir="${build}/ejb" excludes="META-INF/*.*" />
</jar>
</target>
…… e su tutto è andato bene salviamolo all'interno della cartella che conterrà tutti jar e i zip utili alla nostra web application "web_lib_folder"
<target name="copy-ejbClient" depends="create-ejbClient" if="web.ejb-exist" >
<copy file="${build}/${jar_name}_stub.jar" todir="${src_folder}/${web_lib_folder}"/>
</target>
Pronti a questo punto a compilare le nostre risorse web, sempre stando attenti a controllare che i target dipendenti abbiano avuto esito positivo e che la variabile "web.ok", che conferma la presenza di risorse web, sia stata settata. Decidiamo di compilare il tutto passandogli come classpath "web.classpath" l'identificativo che ad inizio file avevamo assegnato ad uno dei due settaggi di classpath. Controlliamo che tipo di compilazione è stata richiesta (debug,deprecation) e salviamo il tutto all'interno della cartella classes che risiede all'interno della struttura scompattata della web-app "build/web"
<target name="compile-web" depends="init-web" description="Compile Java-WEB File " if="web.ok" >
<javac destdir="${build}/web/WEB-INF/classes" debug="${debug}" deprecation="${deprecation}" debuglevel="vars,lines,source">
<src path="${src_folder}/${web_java_folder}"/>
<src path="${src_folder}/${common_java_folder}"/>
<classpath refid="web.classpath"/>
</javac>
</target>
Copiamo tutto il contenuto della cartella jsp, web-lib e web xml all'interno della struttura scompattata della web-app "build/web" escludendo dalla copia tutti i possibili file di backup "bak" i java e i class. Questo target è comunque vincolato alla riuscita del target precedente "compile-web" e alla variabile "web.ok". Potete notare che stiamo utilizzando come macro tag "parallel" che ci permetterà di velocizzare questo target eseguendo più task parallelamente, che non hanno possibilità di conflitto fra loro.
Infine settando la variabile "finish" che ci servirà per confermare l'operazione di deploy.
<target name="copy-web" depends="compile-web" if="web.ok" >
<parallel>
<copy todir="${build}/web">
<fileset dir="${src_folder}/${jsp_folder}" excludes="*.bak"/>
</copy>
<copy todir="${build}/web/WEB-INF">
<fileset dir="${src_folder}/${xml_web_folder}" excludes="*.bak"/>
</copy>
<copy todir="${build}/web/WEB-INF/lib">
<fileset dir="${src_folder}/${web_lib_folder}" excludes="*.bak"/>
</copy>
<copy todir="${build}/web/WEB-INF/classes">
<fileset dir="${src_folder}/${web_java_folder}" excludes="**/*.java,**/*.class"/>
</copy>
<property name="finish" value="ok"/>
</parallel>
</target>
Compiliamo le nostre risorse jsp, sempre ponendo molta attenzione nel controllare che i target dipendenti abbiano avuto esito positivo e che la variabile "web.ok", che conferma la presenza di risorse web, sia stata settata. Controlliamo che tipo di compilazione è stata richiesta (debug,deprecation) e destiniamo tutti i sorgenti delle servlet generate dalla compilazione delle jsp nella dir "tmp-jsp" che risiede all'interno della directory dei compilati "build". Il compilatore jspc che stiamo utilizzando è quello di tomcat jarato all'interno di jasper-compiler.jar e come classi di appoggio per parsare i tld xercesImpl.jari e depositare all'interno della cartella lib di ant.
(per il DownLoad jasper-compiler.jar / xercesImpl.jar/ jasper-runtime.jar)
<target name="compile-jsp" depends="copy-web" description="Compile Java-WEB File " if="web.ok">
<jspc srcdir="${build}/web" destdir="${build}/tmp-jsp" verbose="9" uriroot="/${build}/web">
<include name="**/*.jsp" />
</jspc>
</target>
Possiamo adesso copiare anche tutti I resurce per gli ejb e I loro file xml escludendo quindi tutti I file di backup i class e i java, eseguendo questi task in maniera parallela. Infine settando la variabile "finish" che ci servirà per confermare l'operazione di deploy.
<target name="copy-ejb" depends="compile-ejb" if="ejb.ok" >
<parallel>
<copy todir="${build}/ejb/META-INF">
<fileset dir="${src_folder}/${xml_ejb_folder}" excludes="*.bak"/>
</copy>
<copy todir="${build}/ejb">
<fileset dir="${src_folder}/${ejb_folder}" excludes="**/*.java,**/*.class"/>
</copy>
<property name="finish" value="ok"/>
</parallel>
</target>
Possiamo ora creare il war della nostra web application, valutando sempre i target precedenti e la variabile "web.ok"
<target name="create-war" depends="compile-jsp" if="web.ok" >
<jar jarfile="${build}/${war_name}.war" basedir="${build}/web"/>
</target>
Possiamo ora creare il jar dei nostri ejb, valutando sempre i target precedenti e la variabile "ejb.ok"
<target name="create-jar" depends="copy-ejb" if="ejb.ok" >
<jar jarfile="${build}/${jar_name}.jar" basedir="${build}/ejb"/>
</target> Valutando che almeno una delle due operazioni di compile e packaging abbiano avuto esito positivo "finish", creiamo il nostro ear passandogli il file application.xml per il packaging escludendo comunque le interfacce degli ejb che precedentemente avevamo creato.
<target name="create-ear" if="finish">
<ear destfile="${build}/${ear_name}.ear" appxml="${src_folder}
/${xml_ear_folder}/application.xml">
<fileset dir="${build}" includes="*.jar,*.war">
<exclude name="${jar_name}_stub.jar"/>
</fileset>
</ear>
</target>
Non vogliamo rischiare di cancellare inavvertitamente l'applicazione deployata in precedenza perchè abbiamo sbadatamente lanciato il task di undeploy, questo target sarà quindi eseguito solo se precedentemente è stato svolto con successo il target "create-ear" e la variabile "finish" sia stata settata. <target name="undeploy" depends="create-ear">
<fail message="##### ATTENZIONE ERRORE DI CONFIGURAZIONE INTERNO... controllare il settaggio delle variabili nel file spider.web e dei files jar,war,ear restituiti !!...." unless="finish"/>
<delete file="${deploy_folder}/${ear_name}.ear"/>
</target>
Finalmente siamo pronti a deployare la nostra applicazione!!!!! <target name="deploy" depends="create-ear" if="finish">
<copy file="${build}/${ear_name}.ear" todir="${deploy_folder}"/>
<echo message="--|--|--|> Finish Process! " />
</target>
</project> Facile intuire che ant si rivela uno strumento particolarmente utile da inserire nei nostri progetti, ed altrettanto flessibile il suo utilizzo, è quindi probabile che ci siano diversi modi per arrivare allo stesso risultato che noi abbiamo ottenuto, vi rivolgo quindi nuovamente il mio invito a collaborare per migliorare ed ampliare le funzionalità di questo script, scrivendo i vostri commenti n.guarnacci@k-tech.it e ad inviare il vostro codice a javaportal m.marzocchi@k-tech.it. Potete comunque scaricare e visionare il file built.xml completo.
Spero vivamente che questo nuovo modo di fare tutorial prenda piede quanto prima su javaportal, e questo solo grazie alla vostra collaborazione e all'integrazione con le vostre idee, preferisco quindi ringraziare anticipatamente l'impegno che ci dedicherete. Ciao Nino ….alias spider-web
|
Documentazione
>
jasper-compiler
