精华内容
下载资源
问答
  • ANT执行junit

    2016-04-13 10:48:22
    ANT执行junit可运行
  • java代码调用ant执行

    2021-02-20 02:30:18
    java代码调用ant执行类,供参考java代码调用ant执行类,供参考 java代码调用ant执行类,供参考java代码调用ant执行类,供参考
  • Ant 执行jmeter脚本

    2019-10-08 10:37:49
    1、安装jmeter,配置环境 ... 配置Ant环境变量 新增ANT_HOME: D:\apache-ant-1.10.7 ...添加Path:%ANT_HOME%\bin ...配置完成后,打开cmd窗口,输入:ant -v,如下截图,说明ant...3、Ant执行jmeter脚本,并生成测试报...

    1、安装jmeter,配置环境

    2、下载Ant: http://ant.apache.org/

    配置Ant环境变量

    新增ANT_HOME:   D:\apache-ant-1.10.7

     

    添加Path:%ANT_HOME%\bin 

    配置完成后,打开cmd窗口,输入:ant -v,如下截图,说明ant环境配好:

     

     3、Ant执行jmeter脚本,并生成测试报告

    jmeter目录下新建TestCase,编写接口测试脚本保存至TestCase目录中

     

    修改bin目录下jmeter配置文件jmeter.properties:把jmeter.save.saveservice.output_format=csv修改为jmeter.save.saveservice.output_format=xml
    jmeter执行结果文件默认保存的是csv格式,不是xml格式,csv无法转化成html格式

     

     在jmeter的extras目录下,把ant-jmeter-1.1.1.jar文件复制到ant的lib目录下

    jmeter的lib目录下,把serializer-2.7.2.jar、xalan-2.7.2.jar文件复制到ant的lib目录下

     

     

     在TestCase目录下,创建build.xml文件(ant执行脚本时会使用),内容如下:

    <?xml version="1.0" encoding="UTF-8"?>
    
    <project name="ant-jmeter-test" default="run" basedir=".">
        <tstamp>
            <format property="time" pattern="yyyyMMddhhmm" />
        </tstamp>
    
        <property name="ReportName" value="TestReport" />
        
        <property name="jmeter.home" value="D:/apache-jmeter-4.0" />
        
        <property name="jmeter.result.dir" value="D:/apache-jmeter-4.0/TestCase/report/jtl" />
        <property name="jmeter.result.html.dir" value="D:/apache-jmeter-4.0/TestCase/report/html" />
        <property name="jmeter.result.jtlName" value="${jmeter.result.dir}/${ReportName}.jtl" />
        <property name="jmeter.result.htmlName" value="${jmeter.result.html.dir}/${ReportName}.html" />
        <property name="mail_to" value="458702847@qq.com"/>
        
        <!-- 查找脚本的目录-->
        <property name="githome" value="D:/apache-jmeter-4.0/TestCase" />
        
        <path id="xslt.classpath">
            <fileset dir="${jmeter.home}/lib" includes="xalan*.jar"/>
            <fileset dir="${jmeter.home}/lib" includes="serializer*.jar"/>
        </path>
        
        <target name="run">
            <echo message="start..."/>
            <antcall target="test" />
            <antcall target="report" />
        </target>
        
            
        <target name="test">
            <taskdef name="jmeter" classname="org.programmerplanet.ant.taskdefs.jmeter.JMeterTask" />
            <jmeter jmeterhome="${jmeter.home}" resultlog="${jmeter.result.jtlName}">
                 <!-- 指定执行的文件,可以用*进行模糊匹配-->
                 <testplans dir="D:/apache-jmeter-4.0/TestCase" includes="*.jmx" />
                
                <property name="jmeter.save.saveservice.output_format" value="xml"/>
            </jmeter>
        </target>
        
        <target name="report">
         <tstamp> <format property="report.datestamp" pattern="yyyy/MM/dd HH:mm" /></tstamp>
            <xslt 
                  classpathref="xslt.classpath"
                  force="true"
                  in="${jmeter.result.jtlName}"
                  out="${jmeter.result.htmlName}"
                  style="${jmeter.home}/extras/jmeter.results.shanhe.me.xsl">
                  <param name="dateReport" expression="${report.datestamp}"/>
                  </xslt>
            
            <copy todir="${jmeter.result.dir}">
                <fileset dir="${jmeter.home}/extras">
                    <include name="collapse.png" />
                    <include name="expand.png" />
                </fileset>
            </copy>
        </target>
    </project>

    在TestCase目录下,创建TestCase\report\html   TestCase\report\jtl,用来分别保存html,jtl格式的测试报告:

     

     

     

    TestCase目录下,执行ant命令,自动执行Jmeter测试脚本,如下则运行成功:

     

     

    执行成功可查看对应的html及jtl报告

     

     

     

     

    转载于:https://www.cnblogs.com/zhangfeiyue/p/11531892.html

    展开全文
  • 主要介绍了配置Ant执行Jmeter脚本过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • ant执行命令的详细参数和Ant自带的系统属性
                   

    转载自:http://ldbjakyo.iteye.com/blog/910114

    一:ant执行命令的详细参数 
    -buildfile<file>,-file<file>,-f<file> :要指定执行构件的的位置和名称。 
    -find<file>,-s<file>: 查找构件文件,并执行找到的构件文件。 
    -help,-p:显示ant的命令帮助信息。在命令行中显示ant的命令选项及简短的介绍,-h是简写。 
    -version:显示ant 的版本信息。 
    -diagnostics:显示ant项目的运行环境、依赖库等信息,为错误诊断和报告提供一些有用的帮助信息。 
    -quiet,-q: 隐藏ant执行的提示输出信息。命令行将不会输出具体的target的执行信息。 
    -verbose,-v: 显示ant执行的详细信息,包括操作系统和Java环境等信息。 
    -debug,-d:显示ant执行调试的信息、详细的log信息。 
    -lib<path>:指定一个类库所在的位置(jar文件位置),让ant工具可以使用这些类文件。path类型指定类库文件。 
    -logfile<file>,-l<file>:指定ant执行时日志输出文件,让日志输出到指定文件而不在命令行输出。 
    例如:执行 ant -f test.xml -l c:\testAntLog.log 将会百日志信息输出到c:\testAntLog.log去。 
    -D<property>=<value>:用于设定一些变量,这些变量可以在target中直接引用,或覆盖已设定的属性值。 
    例如:ant -f test.xml -D src=hello 
    二:Ant系统属性(用${}来获取属性值 例如:${os.name}) 
    os.name:       操作系统的名称。 
    basedir: 项目引用的根路径。 
    ant.home:     Ant工具的根目录位置。 
    ant.file: 构件文件的绝对路径。 
    ant.version:   ant的版本信息。 
    ant.java.version: ant检测到的JVM版本。 
    ant.project.name: 当前执行的项目名称及信息。 
    java.version: Java的版本信息。 
    java.home:    Java的根目录位置。 
    java.class.path: Java类库的文件的位置。 
    line.separator:   换行符. 
    user.home:    用户的home目录,在Linux和UNIX中经常甬道。

               
    展开全文
  • eclipse ant 执行build.xml could not find the main class Program will exit
  • Ant执行脚本仅供自己参考Ant执行脚本仅供自己参考Ant执行脚本仅供自己参考
  • 使用Ant执行程序

    千次阅读 2012-01-05 15:34:56
    这意味着应该探索Ant执行外部程序的能力的时候了。这些可外部程序可以是JAVA程序也可以是本地程序。  1. 使用Ant执行外部程序的原因:  由于Ant得益于其内置的任务,所以可以自己完成很多工作而不需要求助于...
    之前我们讲解了一个构建过程来编译和测试JAVA源代码,在测试表明代码是正确的之后,我们就该运行它了。这意味着应该探索Ant执行外部程序的能力的时候了。这些可外部程序可以是JAVA程序也可以是本地程序。 

    1.       使用Ant执行外部程序的原因: 
    由于Ant得益于其内置的任务,所以可以自己完成很多工作而不需要求助于外部代码。但是在大型工程中,很快就会发现它们需要使用外部程序,既可能使用本地程序,又可能使用JAVA应用程序。 
          实际的构建或测试应用程序是最常见的Ant内部运行的程序,这些程序的任务就是在主程序中进行单元测试、系统测试和载入测试。其他常见的外部程序就是“遗留构建步骤”:软件的某些部分需要一个本地编译器、Perl脚本或仅仅是一些用在构建中的本地工具程序。 
          从Ant内部运行程序时,有两个方案: 
    l         编写一个定制的Ant任务来调用程序,适用于需要在很多构建文件中使用同一个外部程序的情况。(适用于长期项目,经常工程编写Ant任务包装器)。 
    l         编写一个新的Ant任务,这个任务只是从构建文件中调用程序。从构建文件中直接调用程序是编写定制任务的基础。 
    Ant可以包装本地应用程序,而JAVA应用程序可以在Ant的JVM中运行,也可以在其外部运行。无论执行什么类型的应用程序,也无论怎样执行它,Ant都会挂起构建本身直至程序结束。程序的所有控制台输出都会加入到Ant的日志工具里,通常显示到屏幕里。被包装的程序无法读取控制台的输出,因此需要用户输入的程序无法运行。 
    2.       运行JAVA程序: 
    启动JAVA程序是Ant的拿手好戏。这种方法最好的一个特性就是可以轻而易举的指定classpath。它比在编写批处理或者是SHELL脚本时手工指定每个类库要容易得多;它可以将classpath中的lib/**/*.jar拥有的 所有文件统统包含近来。 
    Ant执行JAVA程序另一个好处是它可以在当前的JVM中运行程序。即使指定的classpath是由定制的类载入器提供的,也可以做到。在当前的JVM内运行的程序可以减少启动延迟;它只在载入新类时消耗时间,因此有助于构建保持快速。然而,在新的JVM中执行代码也有很多理由,”forking”(建立新进程),它在一些情形下更适用: 
    l         如果不建立新进程,就无法指定一个新的工作路径。 
    l         当你在建立新进程时,如果遇到与类载入器有关的奇怪的错误或者安全冲突,这很可能是因为在两个载入器里载入了同一个类:原先Ant中的类载入器和一个新的类载入器。在父类载入器或子类载入器中建立新进程或者追踪错误的JAR,然后移除它。 
    l         不能在同一个的JVM中执行JAR;而必须建立新的进程。 
    l         需要大量内存或leaky的JAVA程序应当运行在它们自己的JVM里,并给这个JVM分配适当的内存空间。 
    l         建立一个新进程也允许在另一个版本的虚拟机中运行代码。这个版本可以不同于启动ANT的虚拟机版本。 
    a)       首先介绍一下<java>任务: 
    建立一个JAVA类,然后打印入口参数,为了讲解classpath,这里我们引入一个记录日志的软件包,log4j来记录日志: 
    工程目录如下: 


    类代码如下: 
    package com.neusoft.test; 

    import org.apache.log4j.Logger; 

    publicclass TestJava { 
          privatestatic Logger logger = Logger.getLogger(TestJava.class); 

          /** 
           *enterpointmethod 
           * 
           *@paramargs 
           *            enterpoingarguments 
           */ 
          publicstaticvoid main(String[] args) { 
               if (args.length <= 0) { 
                     logger.error("Bad arguments!"); 
                     System.out.println("Usage:\n\tjava TestJava arg1 args2 ..."); 
                     System.exit(-1); 
               } 
               for (int i = 0; i < args.length; i++) { 
                     logger.info("arg" + i + "=" + args[i]); 
                     System.out.println("arg" + i + "=" + args[i]); 
               } 
          } 

    在不输入入口参数的情况下,打印帮助信息,并退出程序,在输入入口参数的情况下,执行程序,并打印参数。 
    其中log4j需要一个配置文件,示例如下: 
    <?xml version="1.0" encoding="UTF-8" ?> 
    <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"> 
    <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"> 
          <appender name="error" class="org.apache.log4j.FileAppender"> 
               <param name="File" value="${user.dir}/logs/error.log" /> 
               <layout class="org.apache.log4j.PatternLayout"> 
                     <param name="ConversionPattern" 
                          value="%d{yyyy/MM/dd HH:mm:ss},%p,%C.%M,%m%n" /> 
               </layout> 
          </appender> 
          <root> 
               <priority value="DEBUG" /> 
               <appender-ref ref="error" /> 
          </root> 
    </log4j:configuration> 
    这里设置了一个文件类型的日志输出器,所有日志输出都将被输出到用户目录的logs/error.log文件中,关于log4j的知识,请参考本blog其他文章。运行完成后的工程目录如下图所示: 

    error.log中将记录日志信息。 

    下面我们来创建构建文件: 
    <target name="run " depends="compile"> 
    <echo>running a search</echo> 
    <java classname="com.neusoft.test.TestJava"> 
    <arg value="The"/> 
    <arg value="current"/> 
    <arg value="dir"/> 
    <arg value="is"/> 
    <arg file="."/> 
    </java> 
    </target> 

    这样设置还不够,还需要指定classpath,否则可能会出现如下错误: 
    Buildfile: C:\eclipse\workspace\Ant_Chapater5\build.xml 
    init: 
        [mkdir] Created dir: C:\eclipse\workspace\Ant_Chapater5\build 
        [mkdir] Created dir: C:\eclipse\workspace\Ant_Chapater5\build\classes 
    compile: 
        [javac] Compiling 1 source file to C:\eclipse\workspace\Ant_Chapater5\build\classes 
    run: 
         [java] Could not find com.neusoft.test.TestJava. Make sure you have it in your classpath 
          …… 
    BUILD SUCCESSFUL 
    Total time: 4 seconds 

    因为我们没有配置classpath。当任何指定的classpath都不存在时,<java>任务就使用Ant自身的classpath:诸如ant.jar以及其他任何位于ANT_HOME/lib目录下的类库,再加上系统CLASSPATH环境变量的内容。就几乎所有<java>任务而言,应该另外指定一个classpath。当这样做的时候,已经存在的所有非java和javax包的classpath中的内容就不再可用了。这种方式与<javac>不同,在<javac>中如果够文件不指定其他值,则自动包含Ant运行时classpath。 

    添加classpath很容易:在<classpath>元素中写路径或者提供classpath属性一个字符串形式的路径。如果想做多个不同的地方使用classpath,最好先设置好classpath,然后再通过classpathref属性引用它。一个常见的惯例是: 
    用第二个包含有新的生成类的classpath来扩展第一个编译时classpath,而不管这个新的生成类是档案文件形式还是.class文件的目录树形式。 
    我们也采用这种办法,一个用于编译,一个用于执行: 
    <path id="compile.classpath"> 
    <pathelement path="src/log4j-1.2.13.jar"/> 
    </path> 
    <path id="run.classpath"> 
    <path refid="compile.classpath"/> 
    <pathelement location="${build.dir}/classes"/> 
    </path> 
    第一个classpath包含编译时所需要的类库,第二个添加我们刚刚编写的代码。易于维护,任何编译时所需要新的类库都会自动传递到运行时classpath。 
          此时可以修改<java>任务如下: 
    <java classname=" com.neusoft.test.TestJava" 
    classpathref="run.classpath"> 
    <arg value="The"/> 
    <arg value="current"/> 
    <arg value="dir"/> 
    <arg value="is"/> 
    <arg file="."/> 
    </java> 

    现在构建文件如下: 
    <?xml version="1.0" encoding="UTF-8" ?> 
    <projectname="run-java-application"default="run"> 

          <propertyname="build.dir"value="build"/> 
          <pathid="compile.classpath"> 
               <pathelementlocation="src/log4j-1.2.13.jar"/> 
          </path> 
          <pathid="run.classpath"> 
               <pathrefid="compile.classpath"/> 
               <pathelementlocation="${build.dir}/classes"/> 
          </path> 
          <targetname="init"> 
               <deletedir="${build.dir}"/> 
               <deletedir="logs"/> 
               <mkdirdir="${build.dir}"/> 
               <mkdirdir="${build.dir}/classes"/> 
          </target> 
          <targetname="compile"depends="init"> 
               <javacsrcdir="src"destdir="${build.dir}/classes"> 
                     <classpathrefid="compile.classpath"/> 
               </javac> 
          </target> 
          <targetname="run"depends="compile"> 
               <javaclassname="com.neusoft.test.TestJava"> 
                     <classpathrefid="run.classpath"/> 
                     <argvalue="The"/> 
                     <argvalue="current"/> 
                     <argvalue="dir"/> 
                     <argvalue="is"/> 
                     <argfile="."/> 
               </java> 
          </target> 
    </project> 

    构建过程运行如下: 
    Buildfile: C:\eclipse\workspace\Ant_Chapater5\build.xml 
    init: 
        [mkdir] Created dir: C:\eclipse\workspace\Ant_Chapater5\build 
        [mkdir] Created dir: C:\eclipse\workspace\Ant_Chapater5\build\classes 
    compile: 
        [javac] Compiling 1 source file to C:\eclipse\workspace\Ant_Chapater5\build\classes 
    run: 
         [java] log4j:WARN No appenders could be found for logger (com.neusoft.test.TestJava). 
         [java] log4j:WARN Please initialize the log4j system properly. 
         [java] arg0=The 
         [java] arg1=current 
         [java] arg2=dir 
         [java] arg3=is 
         [java] arg4=C:\eclipse\workspace\Ant_Chapater5 
    BUILD SUCCESSFUL 
    Total time: 4 seconds 

    执行完成后工程目录如下: 


    但是,可以看到,由于构建过程中不能找到log4j的配置文件,所以有如下警告: 
    [java] log4j:WARN No appenders could be found for logger (com.neusoft.test.TestJava). 
    [java] log4j:WARN Please initialize the log4j system properly. 

    也就没有生成logs/error.log日志文件。这个原因本人也在探索中,试图将log4j.xml添加到classpath中,但是还是出问题。如果有遇到类似问题的朋友,希望帮忙解决。 
    个人初步分析原因是:不能在同一个的JVM中执行JAR;而必须建立新的进程。因为写日志相当于执行了log4j档案文件中的类,所以不能在同一个JVM中运行。 

    3.       参数: 
    在<java>任务中,最重要的可选参数是嵌套参数列表。可以通过一个简单值,一行文本,一个用于参数列表优先级解析的文件,或者一个路径来命名一个参数。可以在任务的<arg>元素里指定它们,<arg>元素支持以下四个属性,Ant按这些参数声明的顺序将它们传递给JAVA程序: 
    value:字符串值。(对XML的特殊记号要进行转义:>变为&gt;   &#x0a;代表换行) 
    file:文件或目录,在使用之前解析为绝对地址。然后再传递。 
    line:传递给程序的整个行 
    path:一个字符串,包含有用冒号或分号隔开的文件或目录。 

    4.       定义系统特性: 
    系统是那些要传给JAVA命令行(如:-Dproperty=value)的参数的定义。嵌套的<sysproperty>元素可以用来定义要传递的特性。 
    <sysproperty key="socksProxyHost" value="socks-server"/> 
    <sysproperty key="socksProxyPort" value="1080"/> 
    有两种可选方法能代替value参数:file和path。就如带参数一样,file属性为文件命名;Ant对相对引用进行解析并传入绝对文件名,并使用本地平台的文件分隔符。path属性与之类似,只是允许列入多个文件: 
    <sysproperty key="configuration.file" file="./config.properties"/> 
    <sysproperty key="searchpath" path="build/classes:lib/j2ee.jar" /> 

    5.       在新的JVM中运行程序 
    <java>任务将运行在当前的JVM中,除非fork属性被设置为true,这将减少程序启动的时间。做为实验,我们可以将TestJava放在一个新的JVM中运行。 
    <target name="run-search-fork" depends="create-jar"> 
    <echo>running a search</echo> 
    <java classname="com.neusoft.test.TestJava" 
    classpathref="run.classpath" 
    fork="true"> 
    <argvalue="The"/> 
                     <argvalue="current"/> 
                     <argvalue="dir"/> 
                     <argvalue="is"/> 
    <argfile="."/> 
    </java> 
    </target> 

    6.       设置环境变量: 
    你可以在一个建立新进程的JVM里使用嵌套元素<env>来设置环境变量。这个元素的语法与<sysproperty>元素是一样的。 

    7.       控制新的JVM 

    可以选择不同于Ant的JAVA运行时环境,只要通过jvm属性设置JVM命令就可以了,这对与从一个旧的JVM中运行程序时是非常有用的,诸如运行在JAVA1.1系统里的测试,或者可能在JAVA的一个未来版本的BETA版。可以给这个JVM指定参数来控制它,最常用的选项就是设置内存数量,属性maxmemory,这个属性具有一些幕后只能 可以区分JAVA 1.1和1.2系统,生成合适的命令。 
    可以通过<java>嵌套的<jvmarg>元素提供通用的 JVM参数。这些参数的确切用法与<arg>元素相同。 
    <target name="run-search-jvmargs" depends="create-jar"> 
    <property name="Search.JVM.extra.args" value="-Xincgc"/> 
    <java classname=" com.neusoft.test.TestJava" 
    classpathref="run.classpath" 
    fork="true" 
    maxmemory="64m"> 
    <jvmarg line="${Search.JVM.extra.args}"/> 
    <argvalue="The"/> 
                     <argvalue="current"/> 
                     <argvalue="dir"/> 
                     <argvalue="is"/> 
    <argfile="."/> 
    </java> 
    </target> 

    当fork=”false”时,所有的JVM选项都不起作用;仅仅显示一行警告信息。 
    8.       使用failonerror处理错误 
    尽管核心的构建步骤(compile和JAR)必须完成后才可以认为整个构建是成功的,但是一些其他的构建过程中的任务,它们的失败并不重要。例如发送进度报告的电子邮件并不因为邮件服务器确实而终止构建,同样配置过程中的很多方面,诸如停止一个WEB服务器等,并不会因失败而终止构建。 
    一些Ant任务有一个共同的属性,failonerror,它可以控制当任务失败时是否终止构建。多数任务的默认值是”true”,意思是任何构建过程中任务的失败都会导致构建失败,并导致ANT的BUILD FAILED信息。 
    <java>任务支持这个属性,但仅在新的JVM中才支持,如果JAVA程序的返回值不等于0,则终止构建。当JVM内部调用System.exit()时,整个构建过程会因为JAVA停止运行而突然停止并且不显示BUILD FAILED信息:这个调用退出了ANT以及程序。 
    例如我们将failonerror设置为true,并且不传递任何参数给程序,将调用System.exit(-1),此时JAVA程序的输出为: 

    <target name="run-search-invalid" depends="compile"> 
    <echo>running a search</echo> 
    <java classname="com.neusoft.test.TestMain" 
    classpathref="run.classpath" 
    failοnerrοr="true" 
    fork="true"> 
    <argvalue="The"/> 
                     <argvalue="current"/> 
                     <argvalue="dir"/> 
                     <argvalue="is"/> 
    <argfile="."/> 
    </java> 
    </target> 
    构建输出如下: 
    run-search-invalid: 
    [echo] running a search 
    [java] Usage: 
    java TestJava arg1 args2 ... 
    BUILD FAILED 
    C:\AntBook\app\tools\build.xml:532: Java returned: -1 

    9.       执行JAR文件: 
    当一个JAR文件由命令行中的java –jar命令启动时,该JAR文件可以在清单(manifest)上列出一个类的名字做为执行入口,ANT也可以类似地运行JAR文件,但只能在建立新进程的JVM中。这是因为执行JAR文件的过程会载入classpath列表中所列的文件,而其他细节则与JAVA的“扩展”有关。通过一个jar属性设置为文件的文职可以运行JAR文件: 
    <target name="run-search-jar" depends="create-jar"> 
    <echo>running a search</echo> 
    <java 
    jar="${jarfile.path}" 
    classpathref="run.classpath" 
    failοnerrοr="true" 
    fork="true"> 
    <arg value="The" /> 
                     <arg value="current" /> 
                     <arg value="dir" /> 
                     <arg value="is" /> 
    <arg file="." /> 
    </java> 
    </target> 

    这个目标并不能实际工作,因为还没有设置清单(manifest),这些内容等到下一章再讲解。 

    10.       调用第三方程序: 
    可以使用任务运行由第三方提供的程序,假设我们部署过程的一个环节中包含了停止WEB SERVER的操作,比如TOMCAT 5.5,这在部署中是个常见的动作;为了从构建中进行部署,必须实现自动化每个步骤。幸运的是多数WEB SERVER都提供了这样或那样的方法来做到这一点:从TOMCAT的启动脚本中提取命令来完成<javac>任务: 
    <property environment="env"/> //获取环境变量 
    <target name="stop-tomcat" 
    description="stop tomcat if it is running"> 
    <java classname="org.apache.tomcat.startup.Tomcat"> 
    <classpath> 
    <fileset dir="${env.TOMCAT_HOME}/lib"> 
    <include name="**/*.jar"/> 
    </fileset> 
    </classpath> 
    <arg value="-stop"/> 
    <sysproperty key="tomcat.home" 
    value="${env.TOMCAT_HOME}"/> //将TOMCAT的HOME目录向下传递 
    </java> 
    </target> 
    执行该目标有以下几种结果: 
    l         TOMCAT存在而且库文件位于预先假设的位置,成功停止TOMCAT 
    l         本地目前没有任何版本的TOMCAT在运行,无法停止TOMCAT 
    l         即使已经设置classpath,但是因为TOMCAT未安装或者环境变量未正确设置,因此造成库目录确实而无法创建classpath 
    这时我们需要预先判断。 

    11.       在调用之前探察JAVA程序: 
    在准备调用一个JAVA类之前,在classpath上查找它是很容易的,这样做使得显示警告信息成为可能。对于TOMCAT问题,可以使用<available>任务,或者采用<condition>任务会更好,后者能够通过检测环境变量组合<available>测试: 
    <target name="validate-tomcat" 
    <condition property="tomcat.available"> 
    <and> 
    <isset property="env.TOMCAT_HOME"/> 
    <available classname="org.apache.tomcat.startup.Tomcat"> 
    <classpath> 
    <fileset dir="${env.TOMCAT_HOME}/lib"> 
    <include name="**/*.jar"/> 
    </fileset> 
    </classpath> 
    </available> 
    </and> 
    </condition> 
    <echo>tomcat.available=${tomcat.available}</echo> 
    </target> 

    这里声明了,当且仅当env.TOMCAT_HOME已经定义,且要调用的类org.apache.tomcat.startup.Tomcat位于TOMCAT目录下的classpath时,特性tomcat.available才会被设置成true。由于<and>的捷径效应,第一个测试失败时不运行第二个,因为第一个失败时,classpath是不合法的。 
          这个测试可以用语带条件的任务,或者当一个程序必须存在时,带条件的<fail>任务将被用于立即终止构建。当找不到TOMCAT时,通过使用将目标依赖于检验目标,且将条件设置为tomcat.available特性而选择了简单的略过测试: 
    <target name="stop-tomcat" 
    if="tomcat.available" 
    depends="validate-tomcat" 
    description="stop tomcat if it is running"> 
    <java classname="org.apache.tomcat.startup.Tomcat"> 
    <classpath> 
    <fileset dir="${env.TOMCAT_HOME}/lib"> 
    <include name="**/*.jar"/> 
    </fileset> 
    </classpath> 
    <arg value="-stop"/> 
    <!— 传递给JAVA命令行的参数的定义 --> 
    <sysproperty key="tomcat.home" 
    value="${env.TOMCAT_HOME}"/> 
    </java> 
    </target> 

    12.       设置超时 
    Ant1.5为<java>任务扩展了timeout属性,允许以毫秒的方式指定一个JAVA应用程序最大的运行时间。只能在建立新进程的JVM中使用这一个特性。 

    第二部分:使用<exec>启动本地程序 
          JAVA执行并不能给予构建文件访问底层操作系统的全部能力,或者访问本地平台的构建步骤,除非JAVA程序调用本地程序。由于本地程序的移植性很差,因此为了实现以跨平台的方式定制任务,应提供可移植性的包装方式。 
          在运行程序之前让构建文件去探测这些程序存在与否(用上一节的知识)。这是个功能强大的技巧,就如同多数与维护相关的编码,通过不懈的努力能满足绝大部分的情形。 
          要在Ant内运行一个外部程序,应该使用<exec>任务,它可以执行以下操作: 
    l         指定程序名称和要传入的参数 
    l         命名运行目录 
    l         使用failonerror标志来控制当应用程序失败时是否终止构建 
    l         指定一个最大程序持续时间,时间超过则终止程序。任务在这时被认为是失败,但是至少构建会终止,而不是挂起,这对于自动构建是很重要的。 
    l         将输出存入一个文件或特性 
    l         指定JAVA调用本地程序时需要预先设定的环境变量 
    有一件事是它所做不到的,那就是使用一个OsFamily标志将操作限制到操作系统家族,诸如Windows或者Unix,否则将是非常方便的。<condition>任务确实拥有一个OsFamily测试可用于具有条理性的操作系统测试,但是这样的话整个目标都变成有条件的。 
    将<exec>与特定的操作系统绑定在一起是不好的做法,除非这个调用直接对应操作系统的底层功能。而检测相应程序,如果存在就调用它则好的多。 
    例子: 
    <exec executable="ln"> 
    <arg value="-s"/> 
    <arg location="execution.xml"/> 
    <arg location="symlink.xml"/> 
    </exec> 
    这个任务的用途是给文件创建符号连接,因为内置JAVA命令没有这个功能。如果可执行程序在当前路径或者在系统path目录中,则无需指定其完整路径。 
    1.       设置环境变量: 
    正如<java>任务支持将系统属性作为嵌套元素一样,<exec>任务允许<env>子元素设置环境变量。它与<sysproperty>元素具有相同的语法,以不同的元素名分隔。<exec>的一个特别的功能,是你可以选择程序是否继承当前的环境。通常情况下继承当前的所有设置是有意义的,诸如PATH和TEMP,但是有时候可能希望通过参数进行绝对控制: 
    <exec executable="preprocess" 
    newenvironment="true" > 
    <env key="PATH" path="${dist.dir}/win32;${env.PATH}"/> 
    <env key="TEMPLATE" file="${src.dir}/include/template.html"/> 
    <env key="USER" value="self"/> 
    </exec> 

    即使通过newenvironment=”false”(默认值)继承已有的环境,任何显示定义的环境变量也将覆盖所传入环境变量的值。 

    2.       处理错误 
    <exec>属于这样一类Ant任务:这类任务默认情况下failοnerrοr=”false”。这是有原因的:最初没有返回值校验,因此当它被实现时,校验将被设为false以避免与已有构建冲突。即使JAVA任务与其他多数任务不同,但它至少和本地执行任务有统一的默认值。 
          声明failonerror为true和false,而忽略其默认值,这样使构建文件可读性好。”什么情况下出错就终止”/”什么情况下出错但不终止”。 
          failonerror并不控制在程序运行时系统对失败如何反映,在Ant 1.5中,<exec>加入了第二个失败检查,failIfExecuteFails,它控制了实际的执行失败是否被忽略。 
    3.       处理超时 
    运行超时杀死任务,以免陷入挂起。<exec>支持一个timeout属性,以毫秒为单位。如果设置了该属性则一个监视计时器就会启动运行。当外部程序占用时间超时后就“杀死”它。当超时发生时,监视器不会明确告诉你超时发生了,但是执行文件的返回代码被设为”1”。如果failonerror被设置,则将会终止构建。如果没有设置,那么它就会悄悄的不被忽略。 
    <target name="sleep-fifteen-seconds" > 
    <echo message="sleeping for 15 seconds" /> 
    <exec executable="sleep" 
    failοnerrοr="true" 
    timeout="2000"> 
    <arg value="15" /> 
    </exec> 
    </target> 
    运行该目标,当遇到超时就会产生一个错误: 
    sleep-fifteen-seconds: 
    [echo] sleeping for 15 seconds 
    [exec] Timeout: killed the sub-process 
    BUILD FAILED 
    execution.xml:18: exec returned: 1 

    如果外部程序设置成将结果传入一个特性,并将failonerror设置为off,那么就没办法将为1的结果和超时区分开。 
    需要在构建中插入一个暂停时,可以使用<sleep>任务,该任务可以工作在所有平台上。 

    4.       运行shell命令 
    使用: 
    <exec executable="cmd" failοnerrοr="true"/> 
    <arg line="/c echo hello &gt; hello.txt"/> 
    </exec> 
    而不是 
    <exec command="/c echo hello &gt; hello.txt" failοnerrοr="true"/> 
    </exec> 

    在shell中也是一样:应该使用 
    <exec command="ps -ef | grep java &gt; processes.txt" 
    failοnerrοr="false"/> 

    而不是 
    <exec executable="sh" failοnerrοr="true"/> 
    <arg line="-c 'ps -ef | grep java &gt; processes.txt'"/> 
    </exec> 

    因为整个一行的内容需要shell来解释。 

    5.       在程序被调用之前进行探测 
    有时候当程序不可用时,可以略过一个构建步骤,或者提供有帮助的错误并终止。如果你知道程序所在的位置,就可以调用<available>任务对其进行测试,但是假如只是要求该程序在指定目录中怎么办呢?<available>任务可以在整个文件路径下搜索指定的文件,因此探测一个程序是否存在就是个简单的事情了,只要沿着环境变量PATH查找程序名字就可以了,当然,在跨平台的方式下,这并不简单:MS-DOC和UNIX系统以不同的方式命名可执行文件,有时甚至连路径变量也不同。将这些纳入考虑之中,对文件的探测就变成了一个多情况的测试,测试必须以带.exe和不带.exe扩展名两种方式来寻找可执行文件,并且MS-DOC/Windows可执行文件必须同时通过环境变量的两个选项进行搜索。Path和PATH: 
    <target name="probe_for_gcc" > 
    <condition property="found.gcc"> 
    <or> 
    <available file="gcc" filepath="${env.PATH}" /> 
    <available file="gcc.exe" filepath="${env.PATH}" /> 
    <available file="gcc.exe" filepath="${env.Path}" /> 
    </or> 
    </condition> 
    </target> 

    可以通过编写依赖的目标,如果程序不存在,要么使用<fail>任务,要么仅仅跳出某个执行步骤: 
    <target name="compile_cpp" depends="verify_gcc" if="found.gcc"> 
    <exec executable="gcc" ... /> 
    </target> 

    第三部分: 使用<apply>进行批量运行 
    将一个文件列表传递给外部可执行文件程序的特性问题,可以使用<apply>任务来解决,这个任务接受一个文件集并将其传递给指定的应用程序,既可以一次传完,也可以逐个传递。 
          <apply>是作为<exec>的一个子类而被实现,所以<exec>任务的所有属性,都可以用于<apply>;除此之外,它还包括一个批处理的附加功能。 
    例如有一个本地程序,可以将XML文件转换为PDF,它有两个参数:XML文件的路径,以及对应的PDF文件的路径: 
    <apply executable="cmd" dest="docs"> 
    <arg line="/c echo"/> 
    <arg value="convert"/> 
    <srcfile/> 
    <targetfile/> 
    <fileset dir ="." includes="*.xml"/> 
    <mapper type="glob" from="*.xml" to="*.pdf"/> 
    </apply> 

    在Windows平台上运行,并使用内置echo命令,必须将可执行文件设置为cmd以便echo可以正常工作,打开/c开关使得命令行shell在echo完成后自动退出。对于同一个目录下数个xml文件的执行,输出如下: 
    [apply] convert C:\AntBook\Sections\Learning\callingotherprograms\apply.xml 
    C:\AntBook\Sections\Learning\callingotherprograms\docs\apply.pdf 
    [apply] convert C:\AntBook\Sections\Learning\callingotherprograms\execution. 
    xml C:\AntBook\Sections\Learning\callingotherprograms\docs\execution.pdf 
    [apply] convert C:\AntBook\Sections\Learning\callingotherprograms\java.xml C 
    :\AntBook\Sections\Learning\callingotherprograms\docs\java.pdf 
    [apply] convert C:\AntBook\Sections\Learning\callingotherprograms\probes.xml 
    C:\AntBook\Sections\Learning\callingotherprograms\docs\probes.pdf 
    [apply] convert C:\AntBook\Sections\Learning\callingotherprograms\shells.xml 
    C:\AntBook\Sections\Learning\callingotherprograms\docs\shells.pdf 

    到目前为止,它所做的全部工作就是显示我们要执行的命令,但是并没有实际执行它。 
    <apply>隐含依赖关系检查。目标文件新于源文件,它就被忽略。 

    一旦对echo的输出结果满意,看到它为每个文件将执行预期的命令行,就可以把属性值由convert修改为executable,去掉/c echo参数,然后再回到正题。 

    该任务的parallel选项的意思是”一次传入全部的文件”,而不是”并行执行该任务多次”。 

    第四部分:处理输出: 
    以上介绍的三个任务:<java>,<exec>和<apply>这三个任务,都允许你使用output参数将输出结果保存到文件中,可以将这个文件传入别的程序,或者一个ant任务,其中的两个任务<exec>和<apply>,还可以将调用的值存入特性,该特性接下来可以被扩展应用为其他任务的参数。例如:可以将构建阶段的结果发email给其他人: 
    <exec executable="unregbean" output="beans.txt" > 
    <arg value="-d"/> 
    </exec> 
    <mail from="build" tolist="operations" 
    subject="list of installed beans for ${user.name}" 
    failοnerrοr="false" 
    files="beans.txt"/> 
    这种将生成的文件和报告用email发出去的办法,在自动化的构建和测试系统中是常见的功能。 
    展开全文
  • Ant执行jmeter

    2020-08-05 10:35:04
    三、 配置系统变量,先添加环境变量ANT_HOME D:\downloads\apache-ant-1.10.8-bin\apache-ant-1.10.8,然后在PATH后面追加;%ANT_HOME%\bin,如图: 四、 打开命令行界面,先输入ant –v 回车,然后输入ant

    Ant是Java的生成工具,是Apache的核心项目;
    Ant类似于Unix中的Make工具,都是用来编译、生成;
    Ant是跨平台的,而Make不能;
    Ant的主要目的就是把你想做的事情自动化,不用你手动一步一步做,因为里面内置了javac、java、创建目录、复制文件等功能,所以可以直接点击Ant文件,即可编译生成你的项目。
    一、 根据系统版本和java版本下载ant(官网https://ant.apache.org/bindownload.cgi),如图:
    在这里插入图片描述

    二、 解压压缩包,放在合适路径,路径需全英文,最好和jmeter同路径如图:
    在这里插入图片描述
    在这里插入图片描述

    三、 配置系统变量,先添加环境变量ANT_HOME D:\downloads\apache-ant-1.10.8-bin\apache-ant-1.10.8,然后在PATH后面追加;%ANT_HOME%\bin,如图:
    在这里插入图片描述
    在这里插入图片描述

    四、 打开命令行界面,先输入ant –v 回车,然后输入ant –version 回车,显示内容如图,即配置成功:
    在这里插入图片描述

    五、 将apache-jmeter-5.3\extras内的ant-jmeter-1.1.1.jar复制到apache-ant-1.10.8-bin\apache-ant-1.10.8\lib下(jmeter版本和ant版本以及路径以具体安装为准),如图:
    在这里插入图片描述
    在这里插入图片描述

    六、 将apache-jmeter-5.3\lib内的serializer-2.7.2.jar和xalan-2.7.2.jar复制到apache-ant-1.10.8-bin\apache-ant-1.10.8\lib下(jmeter版本和ant版本以及路径以具体安装为准),如图:
    在这里插入图片描述
    在这里插入图片描述

    七、 用Notepad++打开apache-jmeter-5.3\bin下的jmeter.properties,将jmeter.save.saveservice.output_format=csv,取消注释状态,并将csv改为xml需小写,(jmeter版本和ant版本以及路径以具体安装为准),如图:
    在这里插入图片描述
    在这里插入图片描述

    八、 在\apache-jmeter-5.3下创建三个文件夹(名称自定),demo文件夹放需要运行的jmx文件和build.xml,jtl放运行jmx生成的原生报告,就是察看结果树,HTML放ant生成的HTML报告,如图:
    在这里插入图片描述

    九、 在demo文件夹下放入build.xml,下载地址在最后,然后用Notepad++打开,按图,将路径修改为实际路径,保存即可,如图:
    在这里插入图片描述
    在这里插入图片描述

    十、 执行,先打开命令行界面,切换到apache-jmeter-5.3\demo文件夹下,输入ant回车即可,如图:
    在这里插入图片描述

    十一、执行完毕后会在jtl(jtl报告可在GUI中打开)和html生成报告,HTML报告效果图如下:
    在这里插入图片描述

    十二、build.xml下载地址,链接:https://share.weiyun.com/WMa14Ypl 密码:nzs355

    展开全文
  • ant学习笔记之(ant执行命令的详细参数和Ant自带的系统属性)
  • ANT 执行SHELL脚本

    千次阅读 2014-07-30 16:47:14
    ANT 执行SHELL脚本  solaris环境  [1]vi test.sh  echo My name is $1  echo My age is $2  [2] chmod a+x test.sh  [3] vi build.xml         deploy clean axis service
  • ant执行java类

    2013-07-12 18:04:54
    每次都打开eclipse来生成文件,是很麻烦的一件事情,还是直接执行ant,更好一些,在执行的同时,还可以舒舒服服喝口茶,岂不快哉.  那么开始吧. ant 执行java其实很简单,下面几句话就可以搞定啦 &lt;target name=...
  • 使用ant执行jmx脚本 将D:\jmeter\apache-jmeter-3.3\extras下的ant-jmeter-1.1.1.jar复制到D:\soft\ant\apache-ant-1.10.5-bin\apache-ant-1.10.5\lib目录下 简历执行目录F:\ant,里面放build.xml文件和...
  • 有如下ant的target,为了执行java代码 上面代码中,classname应该写java类包括包名的名称“ com.shanhy.demo.packers.Test ”,我故意写错只写“ Test ”在eclipse中使用ant 执行该target 的...
  • 转自:... ant学习笔记之(ant执行命令的详细参数和Ant自带的系统属性) 一:ant执行命令的详细参数 -buildfile,-file,-f :要指定执行构件的的位置和名称。 -
  • 使用Ant执行程序

    2011-03-18 09:41:28
    这意味着应该探索Ant执行外部程序的能力的时候了。这些可外部程序可以是JAVA程序也可以是本地程序。 1. 使用Ant执行外部程序的原因: 由于Ant得益于其内置的任务,所以可以自己完成很多工作而不需要求助于外部...
  • ant执行远程linux脚本

    千次阅读 2010-07-29 09:11:00
    ant执行远程linux脚本
  • ant 执行报52错

    2019-02-01 11:04:45
    原因是安装的是ant1.105版本对应的jdk是1-8,而我项目环境是1.7,版本不一致导致的问题
  • ant 执行jmeter

    2019-01-30 11:35:00
    构建-invoke ant -properties jmeter.home=/home/userapp/apps/apache-jmeter-5.0report.title=kyh_register_reportshow-data=ytest=register_task 转载于:https://www.cnblogs.com/xiaodebing/p/10337400.html...
  • Jmeter接口测试脚本运行后生成的是jtl(xml)格式的文件,这些文件不具备可读性,所以我们要把他转化为可以阅读的html格式...用ant执行脚本 1.jmeter下新建两个目录 TestReport文件夹:用于保存html的结果报告;...
  • ant执行sql文件源码

    2010-09-03 19:08:39
    ant执行sql文件源码请查看附件
  • Ant执行Junit测试

    千次阅读 2017-11-29 16:12:26
    Apache Ant简介 ...简单的讲,Ant是一个命令行工具,可以用来编译java文件,执行java程序,生成jar文件,执行测试等。 具体参见http://ant.apache.org/ 1.Ant的配置 (1)下载Ant htt
  • 1、安装ant 2、准备jmeter 及用例...3、编辑ant 执行文件build.xml <?xml version="1.0" encoding="GB2312"?> <project name="JmeterTest" default="all" basedir="."> <tstamp> <format ...
  • ant 执行jmeter脚本

    2019-09-26 15:46:37
    3、ant版本:Apache Ant(TM) version 1.10.5 版本都是对应的,看似一切美好; 4、将jmeter的extras目录中ant-jmeter-1.1.1.jar包拷贝至ant安装目录下的lib目录中 5、修改Jmeter的bin目录下j...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,148
精华内容 1,659
关键字:

ant执行