Jakie są najlepsze praktyki tworzenia plików wojennych (przy użyciu zaćmienia) do uruchamiania na tomcat? tutoriale, linki, przykłady są bardzo cenione.
Jakie są najlepsze praktyki tworzenia plików wojennych (przy użyciu zaćmienia) do uruchamiania na tomcat? tutoriale, linki, przykłady są bardzo cenione.
Odpowiedzi:
Możesz użyć Ant do konfigurowania, kompilowania, WAR i wdrażania rozwiązania.
<target name="default" depends="setup,compile,buildwar,deploy"></target>Następnie możesz wykonać jedno kliknięcie w Eclipse, aby uruchomić ten cel Ant. Oto przykłady każdego z kroków:
Zakładamy, że masz zorganizowany kod w następujący sposób:
${basedir}/src: Pliki Java, właściwości, pliki konfiguracyjne XML${basedir}/web: Twoje pliki JSP${basedir}/web/lib: Wszystkie pliki JAR wymagane w czasie wykonywania${basedir}/web/META-INF: Twój manifest${basedir}/web/WEB-INF: Twoje pliki web.xmlZdefiniuj setupzadanie, które tworzy katalog dystrybucyjny i kopiuje wszystkie artefakty, które mają być bezpośrednio objęte WARred:
<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>Zbuduj pliki Java w klasy i skopiuj wszystkie artefakty inne niż Java, które znajdują się pod nimi, srcale muszą być dostępne w czasie wykonywania (np. Właściwości, pliki XML itp.):
<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>Utwórz samą WOJNĘ:
<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>Na koniec możesz skonfigurować zadanie, aby wdrożyć WAR bezpośrednio w lokalizacji wdrożenia Tomcat:
<target name="deploy">
<copy file="My.war" todir="${tomcat.deploydir}" />
</target>Gdy wszystko zostanie skonfigurowane, po prostu uruchom defaultcel z Eclipse, aby skompilować, WOJNA i wdrożyć rozwiązanie.
Zaletą tego podejścia jest to, że będzie działać poza Eclipse, a także w Eclipse i może być używane do łatwego udostępniania strategii wdrażania (np. Poprzez kontrolę źródła) innym programistom, którzy również pracują nad Twoim projektem.
Zawsze wybierałem Export from Eclipse. Tworzy plik wojenny i zawiera wszystkie niezbędne pliki. Zakładając, że utworzyłeś projekt jako projekt internetowy, to wszystko, co musisz zrobić. Eclipse sprawia, że jest to bardzo proste.
Używamy Mavena (starszego brata Anta) do wszystkich naszych projektów java i ma on bardzo fajną wtyczkę WAR. Można tam znaleźć tutoriale i sposób użycia.
Jest dużo łatwiejszy niż Ant, w pełni kompatybilny z Eclipse (użyj maven eclipse: eclipse do tworzenia projektów Eclipse) i łatwy w konfiguracji.
Przykładowa konfiguracja:
<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>Plik wojenny to po prostu plik jar z rozszerzeniem war, ale to, co sprawia, że działa, to faktyczna struktura zawartości.
Samouczek J2EE / Java EE może być początkiem:
http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/WebComponents3.html
A specyfikacja serwletu zawiera krwawe szczegóły:
http://java.sun.com/products/servlet/download.html
Jeśli utworzysz nowy projekt internetowy w Eclipse (mam na myśli wersję Java EE), struktura zostanie utworzona dla Ciebie i możesz również powiedzieć, gdzie jest zainstalowany Twój Appserver, a on wdroży i uruchomi aplikację za Ciebie.
Użycie opcji „Eksportuj-> plik WAR” pozwoli Ci zapisać plik wojny.
Jeśli nie masz pewności, co robić i zaczynasz od zera, Maven może Ci pomóc.
Postępując zgodnie z poniższymi krokami, możesz idealnie skonfigurować nowy projekt wojenny w czasie zaćmienia.
mvn archetype:generatemvn eclipse:eclipsemvn packagelub wdrażając, konfigurując serwer w eclipse i po prostu dodając projekt do serwera.Jak niektórzy powiedzieli, wadą używania mavena jest to, że musisz używać konwencji mavena. Ale myślę, że jeśli dopiero zaczynasz, nauczenie się konwencji to dobry pomysł, zanim zaczniesz tworzyć własne. Nic nie powstrzyma Cię później przed zmianą / refaktoryzacją do własnej preferowanej metody.
Mam nadzieję że to pomoże.
Użyj kodu kompilacji Ant Używam tego dla mojego projektu 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>Inną opcją byłoby automatyczne zbudowanie go za pomocą Eclipse. Oczywiście jeśli masz środowisko ciągłej integracji polecamy Ant lub Maven. Alternatywa eksportu nie jest zbyt wygodna, ponieważ za każdym razem musisz konfigurować właściwości eksportu.
KROKI:
Włącz obsługę „archiwów projektów”; może to zależeć od twojego projektu (użyłem go w projekcie Java EE / Web). Kliknij prawym przyciskiem myszy katalog główny projektu; Konfiguruj -> Dodaj obsługę archiwów projektu.
Idź i utwórz nowe archiwum w katalogu głównym „Project Archives”. Masz tylko opcję jar, ale nazwa archiwum * .war.
Skonfiguruj zestawy plików, tj. Jakie pliki mają zostać dołączone. Typowa jest konfiguracja dwóch zestawów plików w sposób podobny do konfiguracji Web Deployment Assembly (właściwości projektu).
Może być konieczne zmodyfikowanie właściwości wykluczania zestawu plików w zależności od tego, gdzie umieściłeś niektóre pliki konfiguracyjne lub możesz potrzebować więcej zestawów plików, ale pomysł jest taki, że po skonfigurowaniu nie musisz go zmieniać.
Zbuduj archiwum ręcznie lub opublikuj bezpośrednio na serwerze; ale jest również automatycznie tworzony przez Eclipse
Inną powszechną opcją jest gradle.
http://www.gradle.org/docs/current/userguide/application_plugin.html
Aby zbudować plik wojenny w aplikacji internetowej:
W pliku build.gradle dodaj:
apply plugin: 'war'Następnie:
./gradlew warUżyj układu z zaakceptowanej odpowiedzi powyżej.
Użyj następującego polecenia poza folderem WEB-INF. To powinno stworzyć plik wojenny i jest najszybszą metodą, jaką znam.
(Będziesz potrzebował zainstalowanego JDK 1.7+ i zmiennych środowiskowych wskazujących na katalog bin twojego JDK.)
jar -cvf projectname.war *Prostsze rozwiązanie, które również odświeża przestrzeń roboczą Eclipse:
<?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>Uproszczony kod powłoki do tworzenia plików WAR ze standardowego dynamicznego projektu internetowego Eclipse. Używa systemu plików RAM (/ dev / shm) na platformie Linux.
#!/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** Tworzenie pliku War w projekcie internetowym Eclips Gaynemed of Grails **
1. Importuj projekt:
2. Zmień plik datasource.groovy
Na przykład: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"
2. zmień AppConfig.xml
3. zabić Java z Menedżera zadań:
uruchom czyste polecenie w zaćmieniach
uruchom „wojnę prod” obsługiwaną przez nazwę projektu.
Sprawdź plik dziennika i znajdź ten sam plik .war w katalogu Workbencha z tą samą datą.