Cách tạo tệp chiến tranh

Thực tiễn tốt nhất để tạo tệp chiến tranh (sử dụng eclipse) để chạy trên tomcat là gì? hướng dẫn, liên kết, ví dụ được đánh giá cao.

Bạn có thể sử dụng Ant để thiết lập, biên dịch, WAR và triển khai giải pháp của mình.

<target name="default" depends="setup,compile,buildwar,deploy"></target>

Sau đó, bạn có thể thực hiện một cú nhấp chuột trong Eclipse để chạy mục tiêu Ant đó. Dưới đây là ví dụ về từng bước:

Điều kiện tiên quyết

Chúng tôi sẽ giả định rằng bạn có mã của mình được tổ chức như sau:

• ${basedir}/src: Tệp Java, thuộc tính, tệp cấu hình XML
• ${basedir}/web: Các tệp JSP của bạn
• ${basedir}/web/lib: Bất kỳ JAR nào được yêu cầu trong thời gian chạy
• ${basedir}/web/META-INF: Tệp kê khai của bạn
• ${basedir}/web/WEB-INF: Tệp web.xml của bạn

Thiết lập

Xác định setuptác vụ tạo thư mục phân phối và sao chép bất kỳ tạo tác nào cần được WARred trực tiếp:

<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>

Biên dịch

Xây dựng các tệp Java của bạn thành các lớp và sao chép lên bất kỳ tạo tác không phải Java nào nằm trong đó srcnhưng cần có sẵn trong thời gian chạy (ví dụ: thuộc tính, tệp XML, v.v.):

<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>

Xây dựng CHIẾN TRANH

Tự tạo CHIẾN TRANH:

<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>

Triển khai

Cuối cùng, bạn có thể thiết lập một nhiệm vụ để triển khai WAR trực tiếp vào vị trí triển khai Tomcat của mình:

<target name="deploy">
    <copy file="My.war" todir="${tomcat.deploydir}" />
</target>

Nhấp và đi!

Khi tất cả điều này được thiết lập, chỉ cần khởi chạy defaultmục tiêu từ Eclipse sẽ biên dịch, WAR và triển khai giải pháp của bạn.

Ưu điểm của cách tiếp cận này là nó sẽ hoạt động bên ngoài Eclipse cũng như bên trong Eclipse và có thể được sử dụng để dễ dàng chia sẻ chiến lược triển khai của bạn (ví dụ: thông qua kiểm soát nguồn) với các nhà phát triển khác cũng đang làm việc trong dự án của bạn.

Tôi luôn chọn Xuất từ ​​Eclipse. Nó xây dựng tệp chiến tranh và bao gồm tất cả các tệp cần thiết. Cung cấp cho bạn việc tạo dự án dưới dạng một dự án web, đó là tất cả những gì bạn cần làm. Eclipse làm cho nó rất đơn giản để làm.

Chúng tôi sử dụng Maven (anh trai của Ant) cho tất cả các dự án java của mình và nó có một plugin WAR rất tiện lợi. Hướng dẫn và cách sử dụng có thể được tìm thấy ở đó.

Nó dễ dàng hơn Ant rất nhiều, hoàn toàn tương thích với Eclipse (sử dụng maven eclipse: eclipse để tạo các dự án Eclipse) và dễ cấu hình.

Trang chủ của Maven

Plugin Maven WAR

Cấu hình mẫu:

<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>

Tập tin chiến tranh chỉ đơn giản là một tập tin jar có phần mở rộng chiến tranh, nhưng điều khiến nó hoạt động là cách nội dung thực sự được cấu trúc.

Hướng dẫn J2EE / Java EE có thể là một khởi đầu:

http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/WebComponents3.html

Và đặc tả Servlet chứa các chi tiết đẫm máu:

http://java.sun.com/products/servlet/download.html

Nếu bạn tạo một dự án web mới trong Eclipse (tôi đang đề cập đến phiên bản Java EE), cấu trúc được tạo cho bạn và bạn cũng có thể cho nó biết nơi cài đặt Appserver của bạn và nó sẽ triển khai và khởi động ứng dụng cho bạn.

Sử dụng tùy chọn "Export-> WAR file" sẽ cho phép bạn lưu tệp chiến tranh.

Nếu bạn không biết phải làm gì và bắt đầu lại từ đầu thì Maven có thể giúp bạn bắt đầu.

Bằng cách làm theo các bước dưới đây, bạn có thể thiết lập dự án chiến tranh mới một cách hoàn hảo trong nhật thực.

1. Tải xuống và cài đặt Maven
2. Chạy dòng lệnh: mvn archetype:generate
3. Làm theo các bước được nhắc - chọn dự án web java đơn giản (18) và tên phù hợp.
4. Khi nó chạy xong: mvn eclipse:eclipse
5. Khởi động Eclipse. Chọn Tệp -> Nhập -> Dự án hiện có. Chọn thư mục mà bạn đã chạy các mục tiêu mvn.
6. Vậy là xong, bây giờ bạn sẽ có một khởi đầu rất tốt cho một dự án chiến tranh trong nhật thực
7. Bạn có thể tự tạo cuộc chiến bằng cách chạy mvn packagehoặc triển khai nó bằng cách thiết lập một máy chủ trong eclipse và chỉ cần thêm dự án vào máy chủ.

Như một số người khác đã nói nhược điểm của việc sử dụng maven là bạn phải sử dụng các quy ước của maven. Nhưng tôi nghĩ nếu bạn chỉ mới bắt đầu, tìm hiểu các quy ước là một ý kiến ​​hay trước khi bạn bắt đầu tự làm. Không có gì ngăn cản bạn thay đổi / cấu trúc lại phương pháp ưa thích của riêng bạn sau này.

Hi vọng điêu nay co ich.

Sử dụng nhiệm vụ Ant war

Sử dụng mã xây dựng kiến ​​Tôi sử dụng mã này cho SMS dự án của mình

<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>

Một tùy chọn khác là xây dựng nó tự động bằng Eclipse. Tất nhiên nếu bạn có môi trường tích hợp liên tục Ant hoặc Maven được khuyến khích. Thay thế xuất không thuận tiện lắm vì bạn phải định cấu hình mỗi khi xuất các thuộc tính.

CÁC BƯỚC:

1. Bật hỗ trợ "Lưu trữ dự án"; điều này có thể phụ thuộc vào dự án của bạn (tôi đã sử dụng nó trên Java EE / dự án Web). Nhấp chuột phải vào thư mục gốc của dự án; Định cấu hình -> Thêm Hỗ trợ Lưu trữ Dự án.

2. Đi và tạo một kho lưu trữ mới trong dir hàng đầu "Kho lưu trữ Dự án". Bạn chỉ có tùy chọn jar, nhưng đặt tên cho kho lưu trữ * .war.

3. Định cấu hình Fileset-s, tức là những tệp nào sẽ được đưa vào. Điển hình là cấu hình hai tập tin tương tự như cách cấu hình Web Deployment Assembly (thuộc tính dự án).

   • copy / WebContent vào /
   • sao chép / xây dựng / các lớp vào WEB-INF / các lớp (tạo bộ tệp này sau khi bạn xác định thư mục WEB-INF / lớp trong kho lưu trữ)

4. Bạn có thể cần phải chỉnh sửa thuộc tính loại trừ tập tin tùy thuộc vào nơi bạn đặt một số tập tin cấu hình hoặc bạn có thể cần nhiều tập tin hơn, nhưng ý tưởng là một khi bạn đã định cấu hình thì bạn không cần phải thay đổi nó.

5. Xây dựng kho lưu trữ theo cách thủ công hoặc xuất bản trực tiếp lên máy chủ; nhưng cũng được Eclipse tự động xây dựng cho bạn

Một lựa chọn phổ biến khác là gradle.

http://www.gradle.org/docs/current/userguide/application_plugin.html

Để xây dựng tệp chiến tranh của bạn trong một ứng dụng web:

Trong build.gradle, hãy thêm:

apply plugin: 'war'

Sau đó:

./gradlew war

Sử dụng bố cục từ câu trả lời được chấp nhận ở trên.

Sử dụng lệnh sau bên ngoài thư mục WEB-INF. Điều này sẽ tạo ra tệp chiến tranh của bạn và là phương pháp nhanh nhất mà tôi biết.

(Bạn sẽ cần cài đặt JDK 1.7+ và các biến môi trường trỏ đến thư mục bin của JDK của bạn.)

jar -cvf projectname.war *

liên kết tham khảo

Giải pháp đơn giản hơn cũng làm mới không gian làm việc 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>

Mã Shell đơn giản để tạo tệp WAR từ Dự án Web động Eclipse tiêu chuẩn. Sử dụng hệ thống Tệp RAM (/ dev / shm) trên nền tảng 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

** Tạo tệp War trong dự án web Eclips Gaynemed of grails **

1. dự án nhập khẩu:

2. thay đổi tệp datasource.groovy

Như thế này: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"

2.chuyển đổi AppConfig.xml

3.kill Java từ Trình quản lý tác vụ:

4. chạy sạch sẽ comand trong nhật thực

5. chạy 'cuộc chiến thần đồng' theo tên dự án.

6. Kiểm tra tệp nhật ký và tìm tệp .war tương tự trong thư mục của bàn làm việc có cùng ngày.