Wat zijn de beste praktijken van het maken van oorlogsbestanden (met behulp van Eclipse) om op Tomcat te rennen? Tutorials, links, voorbeelden worden zeer op prijs gesteld.
1, Autoriteit 100%
U kunt ant gebruiken om in te stellen, compileren, Oorlog , en implementeer uw oplossing.
<target name="default" depends="setup,compile,buildwar,deploy"></target>
U kunt vervolgens één klik in Eclipse uitvoeren om dat mierdoel uit te voeren. Hier zijn voorbeelden van elk van de stappen:
randvoorwaarden
We nemen aan dat u uw code hebt georganiseerd zoals:
${basedir}/src: JAVA-bestanden, eigenschappen, XML-configuratiebestanden${basedir}/web: Uw JSP-bestanden${basedir}/web/lib: ELKE PUNTEN VEREIST OP Runtime${basedir}/web/META-INF: UW MIFISTE${basedir}/web/WEB-INF: uw web.xml-bestanden
Instellen
Definieer een setupTaak die de distributiemap creëert en alle artefacten kopieert die rechtstreeks moeten worden verkocht:
<target name="setup">
<mkdir dir="dist" />
<echo>Copying web into dist</echo>
<copydir dest="dist/web" src="web" />
<copydir dest="dist/web/WEB-INF/lib" src="${basedir}/../web/WEB-INF/lib" />
</target>
Compileer
Bouw uw Java-bestanden in de klassen en kopieer over eventuele niet-Java-artefacten die zich bevinden onder src, maar moeten beschikbaar zijn op runtime (bijvoorbeeld Eigenschappen, XML-bestanden, enz.):
<target name="compile">
<delete dir="${dist.dir}/web/WEB-INF/classes" />
<mkdir dir="${dist.dir}/web/WEB-INF/classes" />
<javac destdir="${dist.dir}/web/WEB-INF/classes" srcdir="src">
<classpath>
<fileset dir="${basedir}/../web/WEB-INF/lib">
<include name="*" />
</fileset>
</classpath>
</javac>
<copy todir="${dist.dir}/web/WEB-INF/classes">
<fileset dir="src">
<include name="**/*.properties" />
<include name="**/*.xml" />
</fileset>
</copy>
</target>
Oorlog bouwen
Maak de oorlog zelf:
<target name="buildwar">
<war basedir="${basedir}/dist/web" destfile="My.war"
webxml="${basedir}/dist/web/WEB-INF/web.xml">
<exclude name="WEB-INF/**" />
<webinf dir="${basedir}/dist/web/WEB-INF/">
<include name="**/*.jar" />
</webinf>
</war>
</target>
Implementeer
Ten slotte kunt u een taak instellen om de oorlog rechtstreeks in uw Tomcat-locatie te implementeren:
<target name="deploy">
<copy file="My.war" todir="${tomcat.deploydir}" />
</target>
Klik en ga!
Zodra dit alles is ingesteld, stelt u eenvoudig de defaultDoel van Eclipse samenstellen, Oorlog en implementeer uw oplossing.
Het voordeel van deze aanpak is dat het buiten de Eclipse en binnen Eclipse zal werken en kan worden gebruikt om eenvoudig uw implementatiestrategie (bijv. Via bronbesturing) met andere ontwikkelaars die ook aan uw project werken.
2, Autoriteit 38%
Ik heb altijd zojuist export van Eclipse geselecteerd. Het bouwt het War-bestand en bevat alle benodigde bestanden. Als u het project als webproject hebt gemaakt, dat is alles wat u moet doen. Eclipse maakt het heel eenvoudig om te doen.
3, Autoriteit 23%
We gebruiken Maven (Ant’s Big Brother) voor al onze Java-projecten, en het heeft een zeer nifty oorlogs plug-in. Tutorials en gebruik zijn daar te vinden.
Het is een stuk eenvoudiger dan mier, volledig compatibel met Eclipse (gebruik MAVEN ECLIPSE: Eclipse om Eclipse-projecten te maken) en eenvoudig te configureren.
Voorbeeldconfiguratie:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.1-alpha-2</version>
<configuration>
<outputDirectory>${project.build.directory}/tmp/</outputDirectory>
<workDirectory>${project.build.directory}/tmp/war/work</workDirectory>
<webappDirectory>${project.build.webappDirectory}</webappDirectory>
<cacheFile>${project.build.directory}/tmp/war/work/webapp-cache.xml</cacheFile>
<nonFilteredFileExtensions>
<nonFilteredFileExtension>pdf</nonFilteredFileExtension>
<nonFilteredFileExtension>png</nonFilteredFileExtension>
<nonFilteredFileExtension>gif</nonFilteredFileExtension>
<nonFilteredFileExtension>jsp</nonFilteredFileExtension>
</nonFilteredFileExtensions>
<webResources>
<resource>
<directory>src/main/webapp/</directory>
<targetPath>WEB-INF</targetPath>
<filtering>true</filtering>
<includes>
<include>**/*.xml</include>
</includes>
</resource>
</webResources>
<warName>Application</warName>
</configuration>
</plugin>
4, Autoriteit 14%
Een oorlogsbestand is gewoon een jar-bestand met een oorlogsverlenging, maar wat het werkt is hoe de inhoud daadwerkelijk is gestructureerd.
De J2EE / JAVA EE-tutorial kan een start zijn:
http://java.sun.com/j2ee/ TUTORIAL / 1_3-FCS / DOC / WEBCOMPONENTEN3.HTML
en de SERFT-specificatie bevat de GORY-details:
http://java.sun.com/products/servlet/download.html
Als u een nieuw webproject in Eclipse maakt (ik verwijs naar de Java EE-versie), wordt de structuur voor u gemaakt en u kunt het ook vertellen waar uw AppServer is geïnstalleerd en deze wordt ingezet en start u de aanvraag voor u .
Met behulp van de optie “Export- & GT; War File” kunt u het oorlogsbestand opslaan.
5, Autoriteit 12%
Als u niet zeker weet wat u moet doen en vanaf het nul begint, kan MAVEN u helpen bij u op zijn gestart.
Door de onderstaande stappen te volgen, kunt u een nieuwe War Project Setup perfect in Eclipse krijgen.
- Download en installeer Maven
- Go The Command Line Run:
mvn archetype:generate - Volg de gevraagde stappen – het kiezen van het eenvoudige Java-webproject (18) en een geschikte naam.
- Wanneer het is voltooid:
mvn eclipse:eclipse - Start Eclipse. Kies Bestand – & GT; Import – & GT; Bestaand project. Selecteer de map waar u de MVN-doelstellingen hebt uitgevoerd.
- Dat is het dat je nu een heel goed start hebt voor een oorlogsproject in Eclipse
- U kunt de oorlog zelf maken door
mvn packagete gebruiken of in te zetten door een server in Eclipse in te stellen en eenvoudig het toevoegen van het project aan de server toe te voegen.
Zoals sommige anderen hebben gezegd, is het nadeel van het gebruik van Maven dat je de Maven-conventies moet gebruiken. Maar ik denk dat als je net begint, het leren van de conventies een goed idee is voordat je het je hebt gemaakt. Er is niets om te voorkomen dat u op een later punt aan uw eigen voorkeursmethode wordt gewijzigd / refactoring.
Ik hoop dat dit helpt.
Antwoord 6, autoriteit 4%
Gebruik de Ant-oorlogstaak
Antwoord 7, autoriteit 4%
Gebruik de volgende opdracht buiten de map WEB-INF. Dit zou je oorlogsbestand moeten maken en is de snelste methode die ik ken.
(Je moet JDK 1.7+ hebben geïnstalleerd en omgevingsvariabelen die verwijzen naar de bin-directory van je JDK.)
jar -cvf projectname.war *
Antwoord 8, autoriteit 3%
Gebruik ant build-code
Ik gebruik dit voor mijn project SMS
<property name="WEB-INF" value="${basedir}/WebRoot/WEB-INF" />
<property name="OUT" value="${basedir}/out" />
<property name="WAR_FILE_NAME" value="mywebapplication.war" />
<property name="TEMP" value="${basedir}/temp" />
<target name="help">
<echo>
--------------------------------------------------
compile - Compile
archive - Generate WAR file
--------------------------------------------------
</echo>
</target>
<target name="init">
<delete dir="${WEB-INF}/classes" />
<mkdir dir="${WEB-INF}/classes" />
</target>
<target name="compile" depends="init">
<javac srcdir="${basedir}/src"
destdir="${WEB-INF}/classes"
classpathref="libs">
</javac>
</target>
<target name="archive" depends="compile">
<delete dir="${OUT}" />
<mkdir dir="${OUT}" />
<delete dir="${TEMP}" />
<mkdir dir="${TEMP}" />
<copy todir="${TEMP}" >
<fileset dir="${basedir}/WebRoot">
</fileset>
</copy>
<move file="${TEMP}/log4j.properties"
todir="${TEMP}/WEB-INF/classes" />
<war destfile="${OUT}/${WAR_FILE_NAME}"
basedir="${TEMP}"
compress="true"
webxml="${TEMP}/WEB-INF/web.xml" />
<delete dir="${TEMP}" />
</target>
<path id="libs">
<fileset includes="*.jar" dir="${WEB-INF}/lib" />
</path>
Antwoord 9, autoriteit 2%
Een andere veel voorkomende optie is gradle.
http://www.gradle.org/docs/current/userguide /application_plugin.html
Om uw oorlogsbestand op te bouwen in een web-app:
Voeg in build.gradle toe:
apply plugin: 'war'
Dan:
./gradlew war
Gebruik de lay-out van het geaccepteerde antwoord hierboven.
Antwoord 10
Eenvoudigere oplossing die ook de Eclipse-werkruimte vernieuwt:
<?xml version="1.0" encoding="UTF-8"?>
<project name="project" default="default">
<target name="default">
<war destfile="target/MyApplication.war" webxml="web/WEB-INF/web.xml">
<fileset dir="src/main/java" />
<fileset dir="web/WEB-INF/views" />
<lib dir="web/WEB-INF/lib"/>
<classes dir="target/classes" />
</war>
<eclipse.refreshLocal resource="MyApplication/target" depth="infinite"/>
</target>
</project>
Antwoord 11
Simplistische Shell-code voor het maken van WAR-bestanden van een standaard dynamisch Eclipse-webproject. Gebruikt RAM-bestandssysteem (/dev/shm) op een Linux-platform.
#!/bin/sh
UTILITY=$(basename $0)
if [ -z "$1" ] ; then
echo "usage: $UTILITY [-s] <web-app-directory>..."
echo " -s ..... With source"
exit 1
fi
if [ "$1" == "-s" ] ; then
WITH_SOURCE=1
shift
fi
while [ ! -z "$1" ] ; do
WEB_APP_DIR=$1
shift
if [ ! -d $WEB_APP_DIR ] ; then
echo "\"$WEB_APP_DIR\" is not a directory"
continue
fi
if [ ! -d $WEB_APP_DIR/WebContent ] ; then
echo "\"$WEB_APP_DIR\" is not a Web Application directory"
continue
fi
TMP_DIR=/dev/shm/${WEB_APP_DIR}.$$.tmp
WAR_FILE=/dev/shm/${WEB_APP_DIR}.war
mkdir $TMP_DIR
pushd $WEB_APP_DIR > /dev/null
cp -r WebContent/* $TMP_DIR
cp -r build/* $TMP_DIR/WEB-INF
[ ! -z "$WITH_SOURCE" ] && cp -r src/* $TMP_DIR/WEB-INF/classes
cd $TMP_DIR > /dev/null
[ -e $WAR_FILE ] && rm -f $WAR_FILE
jar cf $WAR_FILE .
ls -lsF $WAR_FILE
popd > /dev/null
rm -rf $TMP_DIR
done
Antwoord 12
**War-bestand maken in Eclips Gaynemed of grails-webproject **
1.Importeer project:
2.Wijzig het bestand datasource.groovy
Zoals dit: url=”jdbc:postgresql://18.247.120.101:8432/PGMS”
2.chnge AppConfig.xml
3.Dood de Java vanuit Taakbeheer:
-
voer een schoon commando uit in eclips
-
voer ‘prod war’ uit, gevolgd door de projectnaam.
-
Controleer het logbestand en vind hetzelfde .war-bestand in de directory van de workbench met dezelfde datum.