当前页面位置: » 丰搜网 » 文档中心 » 详细内容
使用ant进行web开发，第二部分
使用ant进行web开发，第二部分作者：steve holzner译者：ginger547e-mail： ginger547@hotmail.com版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
原文地址:
http://www.on
java.com/pub/a/on
java/excerpt/
anttdg_chap8/index1.
html中文地址:
http://www.matrix.org.cn/resource/article/43/43742_
ant_
web.
html关键词：
ant web编辑语：本文是the definitive
guide, 2nd edition的摘录的第二部分，在第一部分中作者steve holzner介绍了如何为
web应用程序打包，包括war,cab,ear和
jspc。本周他介绍
web 应用程序的部署，包括get, serverdeploy和 scp。
使用
ant进行
web开发，第一部分:
http://www.matrix.org.cn/resource/article/43/43596_
ant_
web.
html建立简单的web部署既然已经有了war文件(或 cab文件), 是时候转向
web应用程序开发的部署了。如果你工作的机器本身就是一台
web服务器，部署将简单到只是把.war文件拷贝到
服务器的相应应用程序目录。例 8-2说明了这一点; 这个创建文件建立和拷贝了一个 .war文件到
tomcat的
webapps 目录.当你(重)启动
tomcat,这个.war文件就会被自动释放到一个同名的文件夹下(省去了.war扩展名),同时这个
web应用程序也就准备好了,在这个例子中,其url是http://localhost:8080/app (如果你正在部署一个
servlet, url将会反映出
servlet的包结构，例如http://localhost:8080/org/
antbook/ch08/app说明serlet类的结构org.
antbook.ch08.app.)。
例 8-2.
tomcat部署的创建文件 (ch08/simple/build.
xml)
<?xml version="1.0" encoding = "utf-8"?>
<project default="main" basedir=".">
<property name="src" location="source" />
<property name="wardir" location=
"c:/tomcat/jakarta-tomcat-5.0.19/webapps"/>
<property name="warfile" location="${wardir}/app.war"/>
<target name="main" depends="war">
<echo message="deploying the web app...."/>
</target>
<target name="war" >
<war destfile="${warfile}" webxml="${src}/app.xml" basedir="${bin}" />
</target>
</project>
你可以使用
ant的 ftp 任务(查看第4章)来远程地部署到一个
web服务器的基础目录下。
使用scp来部署另一种从
ant 1.6开始的有效部署方式是scp，它把一个文件或者fileset从一个运行ssh (译者注：指ssh daemon。daemon- [计] inte
.net中用于邮件收发的后台程序) 的远程主机上拷贝 (或者拷贝到远程主机上)。这种方式是一种可选的方式，而且你需要把
jsch.jar 放到
ant的lib目录下来使用 (你可以从以下地址得到
jsch.jar： http://www.jcraft.com/
jsch/index.
html)。
用这种方式部署起来很方便。例如,下面是一个怎样把一个单独的文件部署到一台远程主机的例子 (任何的主机，除非你明确地设置trust的属性为yes或者true，否则它一定要在你的已知主机 (knownhosts) 列表中):
<scp file="project.jar"
todir="user:password@antmegacorp.com:/home/steven/cgi-bin"/>
你可以明确的使用password属性来设置密码:
<scp file="project.jar"
todir="user@antmegacorp.com:/home/steven/cgi-bin""
password="password"/>
如何拷贝一个远程文件到本地机器:
<scp file="user:password@antmegacorp.com:/home/steven/cgi-bin/project.jar"
todir="${archive}"/>
如何利用fileset来拷贝一组文件:
<scp todir="user:password@antmegacorp.com:
/home/steven/source">
<fileset dir="${src}">
<include name="**/*.java"/>
</fileset>
</scp>
例8-3给出了一个完整的利用scp方式来部署的构造文件。(它使用了远程主机的ip地址来代替了命名远程
服务器。)
例 8-3. 利用scp (ch08/scp/build.
xml)
<?xml version="1.0" ?>
<project default="main">
<property name="message" value="deploying the .jar file." />
<property name="src" location="source" />
<property name="output" location="bin" />
<target name="main" depends="init, compile, compress, deploy">
<echo>
${message}
</echo>
</target>
<target name="init">
<mkdir dir="${output}" />
</target>
<target name="compile">
<javac srcdir="${src}" destdir="${output}" />
</target>
<target name="compress">
<jar destfile="${output}/project.jar" basedir="${output}">
<include name="*.class"/>
<include name="*.txt"/>
</jar>
</target>
<target name="deploy">
<scp trust="true" file="${output}/project.jar"
todir="user:password@000.000.000.000:cgi-bin"/>
</target>
</project>
这是刚才的构造文件在windows机器上运行时候的样子:
%ant
buildfile: build.xml
init:
[mkdir] created dir: c:\ant\ch08\scp\bin
compile:
[javac] compiling 1 source file to c:\ant\ch08\scp\bin
compress:
[jar] building jar: c:\ant\ch08\scp\bin\project.jar
deploy:
[scp] connecting to 000.000.000.000
[scp] sending: project.jar : 664
[scp] file transfer time: 1.32 average rate: 9502.27 b/s
[scp] done.
main:
[echo]
[echo] deploying the .jar file.
[echo]
build successful
total time: 12 seconds小技巧: 正如在第4章的时候说过的一样，在一个构造文件中对密码和/或用户名的显式编码 (hardcoding-也有人称硬编码) 是一种不好的选择。使用属性会是一种较好的办法，象下面这样:
<scp todir="${username}:${password}@antmegacorp.com:
/home/steven/source" ...>象下面这样把用户名和密码传递给
ant:
ant -dusername=steven -dpassword=opensesame在文件被scp 方式所拷贝的时候，它的
unix文件许可并没有被保留(实际上它们得到的是umask许可)。如果你想保留
unix许可,用
unix下的scp 命令来代替(例如, <execexecutable="scp" ... >).
表 8-3. scp任务属性
你可以使用fileset 元素来选择一组文件来拷贝;如果你使用了fileset,你就必须为todir属性指定一个值. (fileset 元素只在你拷贝本地文件到远程主机时可用)
部署到tomcat作为
servlet和
jsp的参考
web服务器，
tomcat (可从http://jakarta.apache.org/
tomcat/得到)，自从它包含了自定义的
ant部署方式，就变得更吸引
ant开发者。
从你的
tomcat5复制文件server/lib/catalina-
ant.jar到
ant的lib目录来使用那些任务。
tomcat部署任务包括部署， 重新加载，反部署 (卸载); 要使用他们，增加这些taskdef元素(在第11章讨论了) 到你的建造文件:
<taskdef name="deploy" classname="org.apache.catalina.ant.deploytask"/>
<taskdef name="reload" classname="org.apache.catalina.ant.reloadtask"/>
<taskdef name="undeploy" classname="org.apache.catalina.ant.undeploytask"/>
想使用这些任务， 你需要
tomcat管理员权限; 象下面这样编辑conf/
tomcat-users.
xml为一个用户名增加管理员权限(这里是admin)和口令:
<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
<role rolename="manager"/>
<role rolename="role1"/>
<role rolename="tomcat"/>
<user username="admin" password="password" roles="manager"/>
<user username="role1" password="tomcat" roles="role1"/>
<user username="tomcat" password="tomcat" roles="tomcat"/>
<user username="both" password="tomcat"
roles="tomcat,role1"/>
</tomcat-users>
你能像下面这样使用部署任务在
ant中部署一个
web应用程序到
tomcat:
<target name="install">
<deploy url="${manager.url}"
username="${manager.username}"
password="${manager.password}" path="${app.path}"
localwar="file://${build}"/>
</target>
在这里manager.url是
tomcat管理器的
servlet的url。
这
servlet的缺省值名字是“manager”，因此看起来象http://localhost:8080/manager。
app.path属性表示的是这个应用程序应该被部署的上下文路径(通常是“/”加上你想要在url中联机访问的应用程序的的名字)。
build属性表示的是在你要在什么位置来建立
web应用程序，比喻说是
tomcat的
webapps目录。
如果你已经安装一个应用程序并且想要
tomcat认出你最新的
java类，使用reload(重新加载任务)代替:
<target name="reload">
<reload url="${manager.url}"
username="${manager.username}"
password="${manager.password}"
path="${app.path}"/>
</target>
删掉一个
web应用程序， 使用undeploy任务:
<target name="remove">
<undeploy url="${manager.url}"
username="${manager.username}"
password="${manager.password}"
path="${app.path}"/>
</target>
部署到tomcat更平常的情况是，你将不会在你想部署到的
服务器上进行你的应用程序的开发。 你可以通过浏览器中的url访问到
tomcat管理器的
servlet进而达到在一台运行了
tomcat的远程主机上部署的目的。
在
ant中实现这一点你需要get任务，当你把一个url传递给它时它得到一份文件。如果你正在使用
java 1.4或更新版本，这个任务支持任何url schema， 包括http:, ftp:, jar:,和 https:。如果你想要下载联机的内容，那么这个任务是较大的，或，如在本例中， 通过urls向联机的代码发布命令。
在开始部署前，这个例子使用get命令修改
ant主页并保存成
ant.
html:
<get src="http://ant.apache.org/" dest="ant.html"/>
你能通过传递一个要上传的
web应用程序的本地位置给管理器的
servlet来实现为
tomcat上传
web应用程序的目的。
例如，从windows的c:/
ant/ch08/app上传一个
web应用程序，你将使用这个位置:
file:////c:\ant\ch08\app/上传一个.war文件， 你在位置的最后加一个！来说明你上传的是一个文件而不是目录的内容，在
unix中象下面这样：
jar:file://///ant/ch08/app.war!/例子8-3展示的是在实践的如何工作。
在这个例子中， 构造文件从c: \
ant\deploy\app(org.
antbook.ch08.deploy)部署一个
web应用程序到
tomcat，它包含一个显示"project deployment"的
servlet。
这是你要传递给的get任务的url来告诉
tomcat管理器
servlet你想要干什么:
http://localhost:8080/manager/deploy?path=/deployment&
war=file:////c:\ant\deploy\app/在例子8-4你能看到如何工作。
例子8-4 部署与get(ch08/get/build.
xml)
<?xml version="1.0" encoding="utf-8" ?>
<project default="main" basedir=".">
<property name="tomcat.port" value="8080" />
<property name="tomcat.username" value="admin" />
<property name="tomcat.password" value="password" />
<target name="main" >
<get src="http://localhost:8080/manager/deploy?path=/deployment&
war=file:////c:\ant\deploy\app/"
dest="deploy.txt"
username="${tomcat.username}"
password="${tomcat.password}" />
</target>
</project>
下面是构造文件在实际中运行时候的样子:
%ant
buildfile: build.xml
main:
[get] getting: http://localhost:8080/manager/deploy?
path=/deployment&war=file:////c:\ant\ch08\get\app/
build successful
total time: 1 second这是
tomcat输出到deploy.txt中的文件内容:
ok - deployed application at context path /deployment在部署以后， 通过http://localhost:8080/deployment/org.
antbook.ch08.deploy显示出部署的
servlet，如图8-1。
图 8-1. 部署到
tomcat 小技巧: 想要得到
tomcat管理
servlet上的更多的信息，查看
tomcat的manager/
html-manager-howto.
html。
get任务的属性在表8-4列出.
表 8-4. get任务属性
小技巧: 当verbose 被设置为true的时候,任务会每接受100k显示一个点(.)。
编译jsps当部署到
服务器时，
jspc任务是很有用的。 这个任务运行
javaserver pages编译器并且把
jsp页变成
java源代码，也可以在
javac任务中实现。 编译
jsp页支持
jsp网页的快速调用， 在没有完全的jdk
服务器上的部署， 或让你不用部署就可以检查他们网页的语法。 缺省情况下，这个任务使用由
tomcat自带的j
asper
jsp编译器。 拷贝
tomcat的j
asper-compiler.jar和j
asper-runtime.jar文件进
ant的lib目录来使用这个任务。 你将需要在
ant lib目录下放置由
tomcat带来的
servlet.jar。
例如， 你有这
jsp页面， greeting.
jsp:
<html>
<head>
<title>creating a greeting</title>
</head>
<body>
<h1>creating a greeting</h1>
<%
out.println("hello from jsp!"); //display the greeting
%>
</body>
</html>
例子8-5显示出怎么编译这
jsp成greeting.
java。
例子8-5 编译
jsp页(ch08/
jspc/build.
xml)
<?xml version="1.0" ?>
<project default="main">
<property name="message" value="compiling the jsp...." />
<property name="src" location="source" />
<property name="output" location="bin" />
<target name="main" depends="init, compile">
<echo>
${message}
</echo>
</target>
<target name="init">
<mkdir dir="${output}" />
</target>
<target name="compile">
<jspc
srcdir="${src}"
destdir="${output}"
package="org.antbook.jsp"
verbose="9">
<include name="**/*.jsp" />
</jspc>
</target>
</project>
下面是你在运行构造文件时候所要看到的:
%ant
buildfile: build.xml
init:
compile:
[jspc] compiling 1 source file to
/home/steven/ant/ch08/jspc/bin/org/antbook/jsp
[jasperc] 2004-06-30 02:20:09 - class name is:
greeting
[jasperc] 2004-06-30 02:20:09 - java filename is:
/home/steven/ant/ch08/jspc/bin/org/antbook/jsp/greeting.java
[jasperc] 2004-06-30 02:20:09 - accepted
org.apache.jasper.compiler.parser$scriptlet at /greeting.jsp(7,4)
[jasperc] 2004-06-30 02:20:09 - compiling with: -encoding utf8
main:
[echo]
[echo] compiling the jsp....
[echo]
build successful
total time: 3 seconds下面是
java代码结果greeting.
java看起来的样子:
package org.antbook.jsp.;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import org.apache.jasper.runtime.*;
public class greeting extends httpjspbase {
static {
}
public greeting( ) {
}
private static boolean _jspx_inited = false;
public final void _jspx_init( )
throws org.apache.jasper.runtime.jspexception {
}
public void _jspservice(httpservletrequest request, httpservletresponse
response)
throws java.io.ioexception, servletexception {
jspfactory _jspxfactory = null;
pagecontext pagecontext = null;
httpsession session = null;
.
.
.
out.println("hello from jsp!"); //display the greeting
.
.
.
}
}
下面是另一个例子，它编译
jsp页，检查相关性， 并且使用
javac任务为这
jsp创建实际的bytecode:
<jspc
destdir="temp"
srcdir="${src}"
package="org.antbook.ch08">
<include name="**/*.jsp" />
</jspc>
<depend
srcdir="temp"
destdir="${bin}"
classpath="lib/app.jar"/>
<javac
srcdir="temp"
destdir="${bin}"
classpath="lib/app.jar" />
在表8-5你能看见
jspc任务的属性。
表 8-5.
jspc任务的属性
jspc任务是一个基于目录的任务，因此被编的
jsp文件用
javac任务定位一样的方法定位文件， 它意味着你能使用嵌套元素，例如includes 和 excludes。你能使用嵌套的classpath和classpathref元素， 象嵌套的
webapp元素一样。唯一出现在
jspc任务中的
webapp元素， 指示
jsp编译器创建一个全部
web应用程序程序。一个
webapp元素的属性是basedir属性， 它设置应用程序的根目录。在它下级子目录必须有一个
web-inf子目录。如果你使用这元素， 这个任务使用编译器检查所有的相关性。
下面是一个使用
webapp的例子:
<jspc
package="org.antbook.ch08">
<include name="**/*.jsp" />
<webapp basedir="${ch08}" />
</jspc>
部署至ejb 容器基本上，部署
javabean到企业(
ejb)
应用服务器相似于你已经看见的另外的
ant部署工程。你能使用这任务来打包并且部署
ejb应用。 例如，在例子8-6你会看到一个为
jboss服务器开发的构造文件; 构造文件首先创造一个.war文件然后把它打包进一个用来部署的.ear文件。
例8-6 一个
jboss ejb构造文件(ch08/
ejb/build.
xml)
<?xml version="1.0" ?>
<project default="main" basedir=".">
<target name="main" depends="init,
compile, war, ear"/>
<target name="init">
<property name="src" value="${basedir}/src"/>
<property name="bin" value="${basedir}/output"/>
<property name="web" value="${basedir}/web"/>
<property name="descriptors"
value="${basedir}/output/deploymentdescriptors"/>
<property name="eardir" value="${basedir}/output/ear"/>
<property name="wardir"
value="${basedir}/output/war"/>
<property name="warfile" value="app.war"/>
<property name="earfile" value="app.ear"/>
<mkdir dir="${wardir}/web-inf"/>
<mkdir dir="${wardir}/web-inf/classes"/>
<mkdir dir="${eardir}/meta-inf"/>
</target>
<target name="compile">
<javac destdir="${bin}" srcdir="${src}" includes="**/*.java" />
</target>
<target name="war">
<copy todir="${wardir}">
<fileset dir="${web}" includes="**/*.*" /> </copy>
<copy file="${descriptors}/web.xml" todir="${wardir}/web-inf" />
<copy todir="${wardir}/web-inf/classes">
<fileset dir="${bin}" includes="**/*.class" /> </copy>
<jar jarfile="${eardir}/${warfile}" basedir="${wardir}" />
</target>
<target name="ear">
<copy file="${descriptors}/application.xml"
todir="${eardir}/meta-inf" />
<jar jarfile="${basedir}/${earfile}" basedir="${eardir}" />
</target>
</project>
这就是全部。尽管这构造文件使用标准的
ant任务工作，被构造了进
ant的任务使以ear任务开始的
ejb应用程序工作更容易。
创建ear文件创造ear任务是容易的.ear文件并且为在大多数ear需要的application.
xml文件做特殊的预备。
它没有强制使用这个任务创造一个.ear文件，但是它能使生活更容易。
在表8-6你能看见这个任务的属性。
小技巧: ear任务是一个有为application.
xml的特殊的待遇的对jar任务的扩展。
你可以进行一样的操作，在一个zip或者jar任务中使用prefix(前缀)和fullpath属性。
表8-6 ear任务的属性
从zip任务的扩充的支持属性 prefix， fullpath，和src的zipfileset元素， 在ear任务也同样可以办到。 嵌套的metainf元素规定一个fileset; fileset包括的所有的文件在.ear文件的meta-inf目录的结束。
这个任务允许你使用app
xml属性设定从什么地方得到application.
xml。 下面是一个创建.ear文件的例子:
<ear destfile="${output}/app.ear" appxml="${src}/application.xml">
<fileset dir="${wardir}" includes="*.war"/>
</ear>支持热部署serverdeploy任务被设计成支持热部署 (在部署前你不必关闭
服务器) 到
ejb- aware的
服务器。 你设置action属性为你做见过的属性，像为
tomcat 管理器
servlet设置使用了的那些: "deploy", "delete", 和 "undeploy"。
小技巧: 你可能需要vendor-specific来完成这个工作。
ant提供build-end， 但是你的
服务器需要提供
ant能连结与并且交往的一套部署工具。
在写这篇文章时， 这个任务仅仅支持
weblogic服务器和jonas 2.4开放源代码
ejb服务器， 但是对另外的
ejb容器的支持应该快被增加。
这个任务有仅仅2属性，在表8-7被列出， 并且要求一些嵌套元素。
表8-7 serverdeploy任务的属性
generic元素如果你从
服务器生产商得到
java类的部署代码，这是一个用于基于
java的部署的通用元素。如果有一个厂家特定的元素给serverdeploy使用，那当然使用它；但如果没有，那请使用通generic元素。
在表8-8此元素的属性被列出。
表8-8 generic元素的属性
generic元素支持嵌套的arg和jvmarg元素。下面是一个假定目标
web服务器是org.steven.
j2ee.config.deploy时，使用generic元素的部署文件的例子:
<serverdeploy action="deploy" source="${eardir}/app.ear">
<generic classname="org.steven.j2ee.config.deploy"
classpath="${classpath}"
username="${user.name}"
password="${user.password}">
<arg value="-install"/>
<jvmarg value="-mx512m"/>
</generic>
</serverdeploy>weblogic元素weblogic元素用于运行
weblogic.deploy部署工具; 此工具的合法的actions包括：deploy, undeploy, list, update, 和 delete.。
在表8-9这些元素的属性被列出。
表8-9
weblogic元素的属性
下面是一个使用这个serverdeploy元素内部的元素来部署
weblogic服务器的例子:
<serverdeploy action="deploy" source="${eardir}/app.ear">
<weblogic application="app"
server="ff19://server:7001"
classpath="${weblogic.home}/lib/weblogic.jar"
username="${user.name}"
password="${user.password}"
component="appserver,productionserver" />
</serverdeploy>jonas元素jonas单元支持部署到jonas (
java open application server,
java开放
应用服务器)
服务器。 jonas部署工具 (org.object
web.jonas.adm.jonasadmin) 的有效actions有
deploy, undeploy, list 和 update.
在表8-10这元素的这些属性别列出。
表8-10。 jonas元素的属性
小技巧: 如果你准备根据从
服务器回应的延期时间来编译一个延期任务，使用
ant waitfor任务。 你可以使用sleep任务来实现这个目的。
jonas单元支持嵌套的classpath， arg，和jvmarg单元。 下面是一个使用serverdeploy部署到一个jonas
服务器的例子:
<serverdeploy action="deploy" source="${eardir}/app.jar">
<jonas server="jonas5" jonasroot="${jonas.root}">
<classpath>
<pathelement path="${jonas.root}/lib/rmi_jonas.jar"/>
</classpath>
</jonas>
</serverdeploy>steve holzner是o'reilly出版的 upcoming
eclipse: a
java developer's
guide的作者。
