整理一个ANT在J2EE项目中的应用，含预编译JSP和打包WAR/EAR文件！

首先，假设我们的项目的结构如下，相同的目录大家可以自行扩展！

${project.root}
|
+-- build/ <-- WAR/EAR档的目录
+-- classes/ <-- 编译的输出目录，与JBuilder兼容
+-- src/ <-- Java源文件目录
+-- web/ <-- WEB Content 目录
| |
| +--pages/ <-- JSP 文件目录
| +--WEB-INF/ <-- web.xml 等配置文件
+-- ejb <-- EJB Content 目录
| |
| +--META-INF/ <-- EJB 配置文件
+-- ear <-- EAR Content 目录
| |
| +--META-INF/ <-- EAR 配置文件
|-- lib <-- 项目所要用到的library

接下来第一步，就是要先定义好一些全局的参数，以便以后更改起来方便，风格
大家自己选择好了，我用的是如下的方式：

(1) 给出项目的目录：

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->  <!--// project directories //-->
<property name="dir.project" value="D:/Code/MyProject"/>
<property name="dir.project.lib" value="${dir.project}/lib"/>
<property name="dir.project.src" value="${dir.project}/src"/>
<property name="dir.project.web_module" value="${dir.project}/web"/>
<property name="dir.project.ejb_module" value="${dir.project}/ejb"/>
<property name="dir.project.ear_module" value="${dir.project}/ear"/>

<!--// compile, build and deploy directories //-->
<property name="dir.project.compile" value="${dir.project}/classes"/>
<property name="dir.project.compile.jspcache" value="${dir.project.compile}/jspcache"/>
<property name="dir.project.build" value="${dir.project}/build"/>

<!--// J2EE Container //-->
<property name="dir.appserver.tomcat.home" value="D:/J2EE_HOME/AppServer/Tomcat"/>
<property name="dir.appserver.oc4j.j2ee.home" value="D:/J2EE_HOME/AppServer/OC4J/j2ee/home"/>

(2) 定义Java Source的编译选项

 
  <!--// Java compiler options //--> 
<property name="opt.compile.source" value="1.4"/>
<property name="opt.compile.target" value="1.4"/>
<property name="opt.compile.encoding" value="UTF-8"/>
<property name="opt.compile.deprecation" value="on"/>
<property name="opt.compile.debug" value="on"/>
<property name="opt.compile.optimize" value="off"/>

(3) 如果需要 import EJB library 的话，给出下面的定义，后面会用到

  
<!--// EJB imported resource //-->
<property name="import.ejb.report.server" value="${dir.project.lib}/AppFramework.jar"/>

(4) 给出部署WAR/EAR文件的名称：

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
  <!--// Deployment //-->
<property name="deploy.file.ejb_module" value="MyApp_EJB.jar" />
<property name="deploy.file.web_module" value="MyApp_WEB.war" />
<property name="deploy.file.ear_module" value="MyApp.ear" />

(5) 给出CLASSPATH的定义，引入相关的Library和项目编译生成的Java Classes

  <path id="CLASSPATH">
<!--// Tomcat Libraries //-->
<fileset dir="${dir.appserver.tomcat.home}/bin"> 
<include name="*.jar"/>
</fileset> 
<fileset dir="${dir.appserver.tomcat.home}/server/lib"> 
<include name="*.jar"/> 
</fileset> 
<fileset dir="${dir.appserver.tomcat.home}/common/lib"> 
<include name="*.jar"/> 
</fileset> 
<!--// OC4J Libraries
    <fileset dir="${dir.appserver.oc4j.j2ee.home}"> 
      <include name="*.jar"/>
    </fileset> 
    <fileset dir="${dir.appserver.oc4j.j2ee.home}/lib"> 
      <include name="*.jar"/> 
    </fileset> 
    //-->
<!--// Depended Libraries //-->
<pathelement location="${dir.project.lib}/abc.jar"/>
<pathelement location="${dir.project.lib}/AppServer.jar"/>
<pathelement location="${dir.project.lib}/AppServiceClient.jar"/>
<pathelement location="${dir.project.lib}/AppUtil.jar"/>
<pathelement location="${dir.project.lib}/xport.jar"/>
<pathelement location="${dir.project.lib}/jaxen-full.jar"/>
<pathelement location="${dir.project.lib}/jstl.jar"/>
<pathelement location="${dir.project.lib}/log4j-1.2.13.jar"/>
<pathelement location="${dir.project.lib}/ojdbc14.jar"/>
<pathelement location="${dir.project.lib}/saxpath.jar"/>
<pathelement location="${dir.project.lib}/standard.jar"/>
<pathelement location="${dir.project.lib}/taglibs-log.jar"/>
<!--// Project classes //-->
<pathelement location="${dir.project.compile}"/>
</path>

(6) 基本的clean和init的task

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
  <target name="clean">
<delete dir="${dir.project.build}"/>
<delete dir="${dir.project.compile.jspcache}"/>
<delete dir="${dir.project.compile}"/>
<delete dir="${dir.project.web_module}/WEB-INF/classes"/>
<delete dir="${dir.project.web_module}/WEB-INF/lib"/>
</target>

<target name="init">
<mkdir dir="${dir.project.compile}"/>
<mkdir dir="${dir.project.compile.jspcache}"/>
<mkdir dir="${dir.project.web_module}/WEB-INF/classes"/>
<mkdir dir="${dir.project.web_module}/WEB-INF/lib"/>
<mkdir dir="${dir.project.build}"/>
</target>

(7) 编译Java Source

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->  <target name="src_compile" depends="init">
<!--// compile the Java source //-->
<javac srcdir="${dir.project.src}" 
           destdir="${dir.project.compile}" 
           encoding="${opt.compile.encoding}" 
           source="${opt.compile.source}" 
           target="${opt.compile.target}" 
           deprecation="${opt.compile.deprecation}"
           debug="${opt.compile.debug}" 
           optimize="{opt.compile.optimize}" >
<classpath refid="CLASSPATH"/>
<include name="**/*.java"/>
</javac>
<!--// copy the classpath resources //-->
<copy todir="${dir.project.compile}">
<fileset dir="${dir.project.src}">
<exclude name="**/*.java"/>
</fileset>
</copy> 
</target>

(8) 预编译JSP文件，可选择基于Tomcat或是Oracle Application Server

  <!--// for Tomcat //--> 
<target name="jsp_src_generate" depends="src_compile">
<taskdef classname="org.apache.jasper.JspC" name="jasper2">
<classpath refid="CLASSPATH"/>  
</taskdef>
<jasper2 validateXml="false" 
             verbose="9"
             uriroot="${dir.project.web_module}" 
             outputDir="${dir.project.compile.jspcache}" 
             webXmlFragment="${dir.project.compile.jspcache}/generated-web.xml" /> 
</target>

<!--// for OC4J 9.0.4
    <target name="jsp_src_generate" depends="src_compile">
      <java classname="oracle.jsp.tools.Jspc" fork="yes" failonerror="true">
        <classpath refid="CLASSPATH"/>
        <arg line="-extend com.orionserver.http.OrionHttpJspPage"/>
        <arg line="-srcdir ${dir.project.compile.jspcache}"/>
        <arg line="-appRoot ${dir.project.web_module}"/>
        <arg line="-noCompile"/>
        <arg line="-debug"/>
        <arg line="-verbose"/>
        <arg line="${dir.project.web}/*.jsp"/>
      </java>
    </target>
  //-->

<target name="jsp_src_compile">
<javac srcdir="${dir.project.compile.jspcache}" 
           destdir="${dir.project.compile.jspcache}" 
           encoding="${opt.compile.encoding}" 
           source="${opt.compile.source}" 
           target="${opt.compile.target}" 
           deprecation="${opt.compile.deprecation}"
           debug="${opt.compile.debug}" 
           optimize="{opt.compile.optimize}" >
<classpath refid="CLASSPATH"/>
<include name="**"/>
</javac>
</target>

<target name="jsp_precompile" depends="src_compile, jsp_src_generate, jsp_src_compile" />

(9) 开始进行compile，make 和 build，并生成部署档案

  <target name="compile" depends="src_compile, jsp_precompile" />

<!--// Build WAR file //-->
<target name="make.web_module" depends="compile">
<war destfile="${dir.project.build}/${deploy.file.web_module}" webxml="${dir.project.web_module}/WEB-INF/web.xml">
<fileset dir="${dir.project.web_module}" >
<include name="**"/>
<exclude name="WEB-INF/classes/**"/>
<exclude name="WEB-INF/lib/**"/>
</fileset>
<classes dir="${dir.project.compile}">
<include name="**"/>
<exclude name="project/package/trx/**"/>
<exclude name="jspcache/**"/>
</classes>
<lib dir="${dir.project.lib}">
<include name="AppUtil.jar"/>
<include name="AppClient.jar"/>
</lib>
</war>
</target>

<!--// Build EJB Jar file //-->
<target name="make.ejb_module" depends="src_compile">
<jar destfile="${dir.project.build}/${deploy.file.ejb_module}">
<zipgroupfileset dir="${dir.project.lib}">
<include name="AppServer.jar"/>
</zipgroupfileset>
<fileset dir="${dir.project.ejb_module}">
<include name="**"/>
</fileset>
<fileset dir="${dir.project.compile}">
<include name="**"/>
<exclude name="project/package/controller/**"/>
<exclude name="jspcache/**"/>
</fileset>
</jar>
</target>

<!--// Build EAR file //-->
<target name="make.ear_module" depends="compile, make.web_module, make.ejb_module">
<ear destfile="${dir.project.build}/${deploy.file.ear_module}" appxml="${dir.project.ear_module}/META-INF/application.xml">
<fileset dir="${dir.project.build}">
<include name="${deploy.file.web_module}"/>
<include name="${deploy.file.ejb_module}"/>
</fileset>
</ear>
</target>

<target name="make" depends="init, compile, make.web_module, make.ejb_module, make.ear_module" />

<target color: rgb(255, 0, 0); font-family: 

  


  

    
    
分享到：
      
      
    
  

  

    

      英语标准答案
      |
      CC2e：《代码大全（第2版）》集萃
    
  
  

    

      
2006-02-13 22:43
      
浏览 471
      
评论(0)
      
      
            
      
查看更多
    
    
  
    
  

  
  
  



  

    
相关推荐
    
    

        
        

          

            
            

              
                
                
                

                  

                    
                      JSP预编译和打包成jar
                    
                  
                  
**JSP预编译与打包成JAR**是Web应用开发中的一个重要环节，尤其是在大型项目中，为了提高应用性能和管理便捷性，开发者通常会采用这样的步骤。JSP（JavaServer Pages）是一种动态网页技术，它允许在服务器端生成HTML...
                
                
              
                
                
                

                  

                    
                      使用ANT打包J2EE程序
                    
                  
                  
本文将详细介绍如何使用Ant来构建一个简单的J2EE项目，并将其打包为WAR文件，以便后续部署到应用服务器上。  #### 示例项目结构  为了清晰地展示整个构建过程，我们首先定义一个简单的J2EE项目结构：  ``` example |...
                
                
              
                
                
                

                  

                    
                      把jsp编译打包成jar
                    
                  
                  
总的来说，将JSP编译打包成jar是一个将静态的JSP文件转换为可执行的Servlet代码，并利用构建工具Ant完成打包的过程，这样可以方便地在不支持JSP的环境中运行和部署。这个过程涉及到JSP、Servlet、Ant构建工具以及web...
                
                
              
                
                
                

                  

                    
                      使用Ant编译打包
                    
                  
                  
例如，你可以创建一个`compile`目标用于编译源代码，一个`jar`目标用于打包成JAR，以及一个`war`目标用于打包成WAR文件，适用于Web应用程序。  ```xml   &lt;property name="src.dir" value="src"/&gt;  ...
                
                
              
                
                
                

                  

                    
                      用ant进行war打包
                    
                  
                  
在Java开发领域，Ant是一个非常...总之，Ant作为Java开发中的构建工具，其`&lt;war&gt;`任务能方便地帮助开发者将Web应用打包成WAR文件，便于分发和部署。理解并熟练掌握Ant的使用，对于提高开发效率和项目管理具有重要意义。
                
                
              
                
                
                

                  

                    
                      ant打war包
                    
                  
                  
在压缩包中的文件名列表"ant打war包"可能是整个构建过程的示例项目，包含了一个使用Ant构建WAR包的实际项目结构，用户可以参考这个示例来理解和学习如何在自己的项目中应用Ant和SVN。  总之，"ant打war包"涉及了Ant...
                
                
              
                
                
                

                  

                    
                      ant打ear包的详细步骤
                    
                  
                  
Ant 打包 EAR 文件的详细步骤是指使用 Apache Ant 工具将 Java 企业级应用程序（Enterprise JavaBean，EJB）项目打包成 EAR 文件的过程。本文将通过一个简单的 EJB 3.0 示例，记录 Ant 打包 EAR 文件的详细步骤。  ...
                
                
              
                
                
                

                  

                    
                      ant打包编译全套资料
                    
                  
                  
Ant是Apache软件基金会下的一个项目，它是一款Java语言编写的构建工具，被广泛应用于Java项目的构建、测试和部署过程。Ant以其灵活性和可扩展性，通过XML格式的构建文件（build.xml）来定义任务，使得开发者能够自动...
                
                
              
                
                
                

                  

                    
                      ant编译1.9版本
                    
                  
                  
在Java Web开发中，"打war包"是将所有的源代码、库文件、配置文件等整合到一个单一的WAR（Web ARchive）文件中，便于部署到Web服务器上。Ant提供了方便的`war`任务，允许开发者自定义打包过程，包括指定Web应用的根...
                
                
              
                
                
                

                  

                    
                      怎样制作ear,war文件
                    
                  
                  
- **WAR 文件**：主要用于打包Web应用程序，它是一个包含Web应用程序所有组件的ZIP文件，包括HTML页面、Java Servlets、JSP文件、图像等静态资源，以及Web应用程序的配置文件（如web.xml）。  #### 二、制作WAR 文件...
                
                
              
                
                
                

                  

                    
                      ant自动打包编译android custom_rules和ant.properties文件
                    
                  
                  
`Ant.properties`是Ant构建过程中的一个关键配置文件，它用于存储项目特定的属性值。这些属性可以在整个构建过程中被引用，提供了一种灵活的方式来管理项目的配置信息。例如，你可以定义版本号、编译时的SDK版本、...
                
                
              
                
                
                

                  

                    
                      Ant打包编译部署工具学习笔记2(附件中含有测试项目)
                    
                  
                  
在IT行业中，构建自动化工具是不可或缺的一部分，它们帮助开发者高效地进行代码的编译、打包和部署。Apache Ant是一款广泛使用的Java项目管理工具，它基于XML来定义项目任务，简化了构建过程。本文将深入探讨Ant工具...
                
                
              
                
                
                

                  

                    
                      J2EE中应用Ant包压缩导出的Excel文件并提供下载
                    
                  
                  
在J2EE应用程序开发中，Ant是一个非常重要的构建工具，它允许开发者自动化构建过程，包括编译、测试、打包和部署等任务。本知识点主要围绕如何在J2EE环境中使用Ant来生成Excel文件并提供下载服务进行讲解。  首先，...
                
                
              
                
                
                

                  

                    
                      用Ant实现Java项目的自动构建和部署
                    
                  
                  
Ant是一个基于XML的构建工具，它的配置文件（build.xml）定义了构建过程中的各种任务，如编译、打包、测试和部署等。XML结构使得构建过程可读性强，易于维护。  对于J2ME项目，Ant可以完成以下步骤： 1. **编译源...
                
                
              
                
                
                

                  

                    
                      ant编译java工程
                    
                  
                  
在Java开发中，Ant常用于自动化编译、测试、打包和部署等任务。  首先，Ant的核心是构建文件`build.xml`，它包含了构建过程的所有指令。这个文件定义了目标（target）和任务（task），每个目标都是一个具体的构建...
                
                
              
                
                
                

                  

                    
                      使用ant编译打包应用程序
                    
                  
                  
这个示例展示了如何使用Apache Ant工具来编译、打包和运行一个简单的Java应用程序。Ant是一个基于XML的构建工具，它允许开发者定义任务来自动化构建过程，如编译源代码、创建JAR文件、运行测试等。  首先，我们来看...
                
                
              
                
                
                

                  

                    
                      ant编译的文件要在eclipse中编译需要的jar文件
                    
                  
                  
Ant以其XML为基础的构建文件（通常命名为build.xml）为开发者提供了跨平台的构建脚本，可以用于编译、打包、测试和部署应用程序。Eclipse是一款流行的Java集成开发环境（IDE），虽然它自带了内置的构建系统，但在...
                
                
              
                
                
                

                  

                    
                      Ant 打 war 包过程
                    
                  
                  
在Java Web开发中，"Ant打war包过程"是一个关键步骤，它涉及到使用Apache Ant工具将项目打包成一个可部署的WAR（Web Application Archive）文件。Ant是一个基于XML的构建工具，广泛用于自动化Java项目的构建、编译和...
                
                
              
            
          
        
    
  


  
    
  












      
            
    
    
    

      
      

        

          
          
          
        
      
    
  
  



   Global site tag (gtag.js) - Google Analytics