精华内容
下载资源
问答
  • BeanShell

    2008-07-28 11:22:31
    BeanShell BeanShell
  • beanshell

    2016-08-11 18:13:00
    http://www.beanshell.org/manual/bshmanual.html#Java_Statements_and_Expressions
    http://www.beanshell.org/manual/bshmanual.html#Java_Statements_and_Expressions
    展开全文
  • Beanshell

    2021-05-06 14:25:56
    常用参数: log 打印日志,写入信息到jmeber.log文件。 SampleResult 获取SampleResult对象,能通过这个对象获取想要的信息。 Response 获取Response对象,能通过这个对象... 案例 重要 BeanShell案例 BeanShell案例

    常用参数:

    1. log 打印日志,写入信息到jmeber.log文件。

    2. SampleResult 获取SampleResult对象,能通过这个对象获取想要的信息。

    3. Response 获取Response对象,能通过这个对象获取响应信息。

    4. Failure 查看接口调使用能否成功,假如返回false是成功的,true是失败的。

    5. FailureMessage 失败信息,没有设置的时候失败信息是空的,能set这个信息。

    6. ResponseData 获取response body类型是byte[]。

    7. ResponseCode 返回接口code成功是200。

    8. ResponseMessage 获取msg成功是OK。

    9. ResponseHeaders 获取接口服务端返回的头部信息。

    10. RequestHeaders 获取用户端请求的头部信息。

    11. SampleLabel 获取接口请求的名称。

    12. SamplerData 获取请求的url和body。

    13. ctx 代表上下文信息,能直接用。

    14. vars即JMeterVariables,操作jmeter变量,这个变量实际引用了JMeter线程中的局部变量容器(本质上是Map),常用方法:

    • vars.get(String key):从jmeter中获得变量值;

    • vars.put(String key,String value):数据存到jmeter变量中;

    1. prev 获取前面的sample返回的信息,常用方法:
    • getResponseDataAsString():获取响应信息。
    • getResponseCode() :获取响应code。

    案例

    展开全文
  • BeanShell

    2008-05-24 00:10:00
    BeanShell是一种脚本语言,一种完全符合java语法的java脚本语言,并且又拥有自己的一些语法和方法,beanShell是一种松散类型的脚本语言(这点和JS类似)。 下载地址:http://www.beanshell.org 设置环境 l ...
    	
    
    
    
    <script type="text/javascript">
    
    google_ad_client = "pub-8800625213955058";
    
    /* 336x280, 创建于 07-11-21 */
    
    google_ad_slot = "0989131976";
    
    google_ad_width = 336;
    
    google_ad_height = 280;
    
    //
    
    </script>
    
    <script type="text/javascript"
    
    src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
    
    </script>
    
    简介:
    
    BeanShell是一种脚本语言,一种完全符合java语法的java脚本语言,并且又拥有自己的一些语法和方法,beanShell是一种松散类型的脚本语言(这点和JS类似)。
    
    下载地址:http://www.beanshell.org
    
    
    
    设置环境
    
    l	把;bsh-xx.jar放到$JAVA_HOME/jre/lib/ext文件夹下
    
    l	unix:     export CLASSPATH=$CLASSPATH:bsh-xx.jar
    
    l	windows:  set classpath %classpath%;bsh-xx.jar
    
    
    
    运行方式:
    
    l	界面UI方式 :java bsh.Console
    
    l	命令行方式  :java bsh.Interpreter   
    
    l	运行脚本文件:java bsh.Interpreter filename [ args ]
    
    
    
    
    
    
    
    简单举例:
    
    在classpath中设置好环境变量,打开dos窗口,键入:java bsh.Console命令
    
    出现BeanShell图片代表设置成功,beanshell开始运行
    
    
    
    
    
    
    
    
    
    
    
    测试内容:
    
    设置变量
    
    foo = "Foo";    
    
    four = (2   2)*2/2;
    
    打印变量
    
    print( foo   " = "   four );
    
    循环
    
    for (i=0; i<5; i  )
    
        print(i);
    
    在窗口中打印按钮
    
    button = new JButton( "My Button" );
    
    frame = new JFrame( "My Frame" );
    
    frame.getContentPane().add( button, "Center" );
    
    frame.pack();
    
    frame.setVisible(true);
    
    
    
    完整代码:
    
    foo = "Foo";    
    
    four = (2   2)*2/2;
    
    print( foo   " = "   four ); 
    
    
    
    for (i=0; i<5; i  )
    
        print(i);   
    
    
    
    button = new JButton( "My Button" );
    
    frame = new JFrame( "My Frame" );
    
    frame.getContentPane().add( button, "Center" );
    
    frame.pack();
    
    frame.setVisible(true);
    
    
    
    
    
    在窗口中输入上面的代码
    
     
    
    敲回车执行,运行结果如图
    
    
    
     
    
    说明:
    
    因为beanshell是松散类型的脚本语言因此可以直接写
    
    foo = "Foo";    
    
    four = (2   2)*2/2;
    
    
    
    print是beanshell提供一种简单的打印命令相当于java中的System.out.println()
    
    
    
    
    
    
    
    
    
    
    
    其他的beanshell脚本命令
    
    ·	source(), run() – 读取,或者运行一个脚本文件
    
    ·	frame() – 显示一个窗口
    
    ·	load(), save() – 读取或者保存一个脚本对象到文件 
    
    ·	cd(), cat(), dir(), pwd(), etc. 使用Unix下面的命令
    
    ·	exec() – 运行一个本地的方法
    
    ·	javap() –使用javap命令. 
    
    ·	setAccessibility() – 设置可以接收private和protected类型的变量 
    
    BeanShell命令不一定都是内置的脚本命令,脚本方法会自动从classpath中取方法使用,因此你可以添加你自己的脚本到classpath中来扩充基本的命令
    
    
    
    
    
    
    
    
    
    
    
    
    
    脚本方法
    
    一般的方法:
    
    int addTwoNumbers( int a, int b ) {
    
        return a   b;
    
    }
    
    
    
    sum = addTwoNumbers( 5, 7 );  // 12
    
    也可以使用动态的变量类型(无状态)方法
    
    add( a, b ) {
    
        return a   b;
    
    }
    
    foo = add(1, 2);            // 3
    
    foo = add(1, “2”);        //”12” 只要有一个为字符串全部按照字符串处理,系统不会根据1是数字在前把“2”转换成数字处理(特别注意)
    
    foo = add("Oh", " baby");   // "Oh baby"
    
    
    
    
    
    
    
    
    
    实现接口
    
    实现任何接口需要java1.3或者更高
    
    可以使用缺省的java匿名类的语法实现一个接口类,例如:
    
    ActionListener scriptedListener = new ActionListener() {
    
        actionPerformed( event ) { ... }
    
    }
    
    不需要实现接口的所有的方法,只需要实现你使用的方法即可,如果使用你没有实现的方法,beanshell将抛出一个错误,
    
    ml = new MouseListener() {
    
        mousePressed( event ) { ... }
    
        // handle the rest
    
        invoke( name, args ) { print("Method: " name " invoked!");
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    脚本对象
    
    使用特殊的关键字this可以创建一个对象(根JS类似)
    
    foo() {
    
        print("foo");
    
        x=5;
    
    
    
        bar() {
    
            print("bar");
    
        }
    
    
    
        return this;
    
    }
    
    
    
    myfoo = foo();    // prints "foo"
    
    print( myfoo.x ); // prints "5"
    
    myfoo.bar();      // prints "bar"
    
    
    
    从应用程序中调用BeanShell
    
    创建一个BeanShell的解释器(interpreter)用eval()和source()命令可以对一个字符串求值和运行一个脚本文件
    
    使用set()方法可以给一个对象传入一个变量的参考
    
    使用get()方法可以重新得到一个变量的结果
    
    
    
      
    
    完整代码:
    
    package cn.com.sparknet.util;
    
    
    
    import bsh.*;
    
    import java.util.*;
    
    
    
    public class BeanShell {
    
      public static void main(String[] args) {
    
        try {
    
          Interpreter interpreter = new Interpreter(); // 构造一个解释器
    
          interpreter.set("foo", 5); // 设置变量
    
          interpreter.set("date", new Date()); //设置一个时间对象
    
          Date date = (Date) interpreter.get("date"); // 重新得到时间变量
    
          interpreter.println(date.toString()); //打印时间变量
    
          interpreter.eval("bar = foo*10"); // 对一段脚本求值,并得到结果
    
          System.out.println(interpreter.get("bar")); //打印变量
    
          interpreter.source("d://helloWorld.bsh"); // 导入并执行一个脚本文件
    
        }
    
        catch (Exception e) {
    
          //如果发生异常,写入日志文件
    
          Log.error(new BeanShell(), "main", FormatDate.getCurrDate(), e.getMessage());
    
        }
    
      }
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    BeanShell语法
    
    BeanShell是一种最原始的java解释器。
    
    标准的java语法
    
    /*
    
        Standard Java syntax
    
    */
    
    
    
    // Use a hashtable
    
    Hashtable hashtable = new Hashtable();
    
    Date date = new Date();
    
    hashtable.put( "today", date );
    
    
    
    // Print the current clock value
    
    print( System.currentTimeMillis() );
    
    
    
    // Loop
    
    for (int i=0; i<5; i  )
    
        print(i);
    
    
    
    // Pop up a frame with a button in it
    
    JButton button = new JButton( "My Button" );
    
    JFrame frame = new JFrame( "My Frame" );
    
    frame.getContentPane().add( button, "Center" );
    
    frame.pack();
    
    frame.setVisible(true);
    
    松散类型的java语法
    
    /*
    
        Loosely Typed Java syntax
    
    */
    
    
    
    // Use a hashtable
    
    hashtable = new Hashtable();
    
    date = new Date();
    
    hashtable.put( "today", date );
    
    
    
    // Print the current clock value
    
    print( System.currentTimeMillis() );
    
    
    
    // Loop
    
    for (i=0; i<5; i  )
    
        print(i);
    
    
    
    // Pop up a frame with a button in it
    
    button = new JButton( "My Button" );
    
    frame = new JFrame( "My Frame" );
    
    frame.getContentPane().add( button, "Center" );
    
    frame.pack();
    
    frame.setVisible(true);
    
    异常处理
    
    标准的java异常
    
    try {
    
        int i = 1/0;
    
    } catch ( ArithmeticException e ) {
    
        print( e );
    
    }
    
    松散的异常处理(类似JS)
    
    try {
    
        ...
    
    } catch ( e ) { 
    
        ...
    
    }
    
    松散类型变量的作用范围
    
    标准的java程序的变量作用范围是在一个模块中的(在模块中声明的变量),而在松散类型的语言中如果在一个模块中没有指定一个变量的类型,则认为是一个全局变量(只有它以后的代码可以使用该变量,系统在调用该变量的时候自动生成一个全局变量,也就为什么在调用模块之前不能使用该变量的原因)
    
    // Arbitrary code block
    
    {
    
        y = 2;      // Untyped variable assigned
    
        int x = 1;  // Typed variable assigned
    
    }
    
    print( y ); // 2
    
    print( x ); // Error! x is undefined.
    
    
    
    // Same with any block statement: if, while, try/catch, etc.
    
    if ( true ) {
    
        y = 2;      // Untyped variable assigned
    
        int x = 1;  // Typed variable assigned
    
    }
    
    print( y ); // 2
    
    print( x ); // Error! x is undefined.
    
    
    
    同样也使用于for-loop, if-else等循环语句
    
    for( int i=0; i<10; i   ) {  // typed for-init variable
    
        j=42;
    
    }
    
    print( i ); // Error! 'i' is undefined.
    
    print( j ); // 42
    
    
    
    for( z=0; z<10; z   ) { }   // untyped for-init variable
    
    print( z ); // 10
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    方便灵活的语法
    
    标准的java语法
    
    java.awt.Button button = new java.awt.Button();
    
    button.setLabel(“javaButton”);
    
    松散的语法
    
    button = new java.awt.Button();
    
    button.label = "my button";
    
    你也可以使用{}来对一个对象设置属性
    
    b = new java.awt.Button();
    
    b{"label"} = "my button";  // Equivalent to: b.setLabel("my button");
    
    
    
    h = new Hashtable();
    
    h{"foo"} = "bar";          // Equivalent to: h.put("foo", "bar");
    
    
    
    
    
    
    
    
    
    包装和未包装(box和unbox)
    
    BeanShell自动转为简单类型
    
    i=5;
    
    iw=new Integer(5);
    
    print( i * iw );  // 25
    
    导入类和包
    
    import javax.xml.parsers.*;
    
    import mypackage.MyClass;
    
    超级导入法:
    
    import *;
    
    BeanShell默认导入下面的包
    
    ·	java.lang 
    
    ·	java.io 
    
    ·	java.util 
    
    ·	java.net 
    
    ·	java.awt 
    
    ·	java.awt.event 
    
    ·	javax.swing 
    
    ·	javax.swing.event 
    
    友好文档实体
    
    BeanShell支持特殊的文档操作类型内容
    
    @gt	>	@lt	<
    
    @lteq	<=	@gteq	>=
    
    @or	||	@and	&&
    
    @bitwise_and	&	@bitwise_or	|
    
    @left_shift	<<	@right_shift	>>
    
    @right_unsigned_shift	>>>	@and_assign	&=
    
    @or_assign	|=	@left_shift_assign	<<=
    
    @right_shift_assign	>>=	@right_unsigned_shift_assign	>>>=
    
    脚本方法
    
    你可以定义方法象java中的定义方法一样
    
    int addTwoNumbers( int a, int b ) {
    
        return a   b;
    
    }
    
    你可以使用内馅的BeanShell方法使用他们
    
    sum = addTwoNumbers( 5, 7 );
    
    只有BeanShell变量可以被动态定义为动态类型,方法可以有动态的参数以及返回类型
    
    add( a, b ) {
    
        return a   b;
    
    }
    
    在这个方法中,BeanShell将动态的决定类型当这个方法被调用时并且能够准确的计算出你想要的结果
    
    foo = add(1, 2);
    
    print( foo ); // 3
    
    
    
    foo = add("Oh", " baby");
    
    print( foo ); // Oh baby
    
    在第一个例子中BeanShell将把参数定义为数字型,并返回数字型
    
    在第二个例子中BeanShell将把参数定义为字符型,并返回字符对象
    
    变量和方法的可见范围
    
    就像您所预期的那样,在方法内您可以参考到上下文中上面的变量和方法
    
    a = 42;
    
    someMethod() { ... }
    
    
    
    foo() {
    
        print( a );
    
        someMethod(); // invoke someMethod()
    
    }
    
    
    
    // invoke foo()
    
    foo(); // prints 42
    
    如果一个变量只有在方法内使用请定义成局部变量,即加上类型,如果是全局变量请在方法外定义
    
    var = "global";
    
    foo() {
    
      print(var);
    
      String var = "local";
    
      print(var);
    
    }
    
    foo();
    
    print(var);
    
    将打印出
    
    global
    
    local
    
    global
    
    方法内的var(第四行)变量属于局部变量,不会覆盖全局变量var(第一行)的因此改变var(第四行)变量不会影响到全局变量var(第一行)
    
    范围参考:super
    
    使用super关键字可以在局部参考到全局变量
    
    var = "global";
    
    foo() {
    
      String var = "local";
    
      print(var);
    
      print(super.var);
    
    }
    
    foo();
    
    将输出
    
    local
    
    global
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    脚本对象
    
    this对象
    
    在java标准语言中可以使用this返回一个类的一个实例
    
        // MyClass.java
    
        MyClass {
    
            Object getObject() {
    
                return this; // return a reference to our object
    
            }
    
        }
    
    在这个例子中getObject() 方法是返回MyClass类的一个实例
    
    在BeanShell中对象中的变量只是局部的变量在对象内可以使用,在对象外是不可以使用(不同于前面for-loop,if-else中的使用);
    
    // Define the foo() method:
    
    foo() {
    
        bar = 42;
    
        print( bar );
    
    }   
    
    
    
    // Invoke the foo() method:
    
    foo();  // prints 42
    
    
    
    print( bar ); // Error, bar is undefined here 
    
    可以使用this返回对象,使用对象加上“.”运算符参考属性(类似JS)
    
    foo() {
    
        bar = 42;
    
        return this;
    
    }
    
    
    
    fooObj = foo();
    
    print( fooObj.bar ); // prints 42!
    
    同样对象中也可以定义一些方法
    
    foo() {
    
        bar() {
    
            ...
    
        }
    
    }
    
    例如
    
    foo() {
    
        int a = 42;
    
        bar() {
    
            print("The bar is open!");
    
        }
    
        
    
        bar();
    
        return this;
    
    }
    
    
    
    // Construct the foo object
    
    fooObj = foo();     // prints "the bar is open!"
    
    // Print a variable of the foo object
    
    print ( fooObj.a )  // 42
    
    // Invoke a method on the foo object
    
    fooObj.bar();       // prints "the bar is open!"
    
    也可以把bar()和foo也可以代参数
    
    foo() {
    
    return this;
    
    }
    
    bar(int a) {
    
      print("The bar is open!"   a);
    
    }
    
    foo().bar(1);
    
    也可以把bar()方法定义到对象外面
    
    
    
     foo() {
    
      bar(int a) {
    
            print("The bar is open!"   a);
    
        }
    
    return this;
    
    }
    
    foo().bar(1);
    
    BeanShell一种松散的脚本语言,有很多中声明的方法可以使用
    
    This super global
    
    This是参考当前对象
    
    Super是参考父亲对象
    
    Global是参考最上层对象
    
    super.super.super...foo = 42;  // Chain super. to reach the top
    
    global.foo = 42; 
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    简单例子:
    
    文本拖动:
    
     
    
    dragText() {
    
        f = new Frame("Drag in the box");
    
        f.setFont( new Font("Serif", Font.BOLD, 24) );
    
        f.setSize(300, 300);
    
        f.show();
    
        gc = f.getGraphics();
    
        gc.setColor(Color.cyan);
    
        mouseDragged( e ) {
    
            gc.drawString("Drag Me!", e.getX(), e.getY());
    
        }
    
        mouseMoved( e ) { }
    
        f.addMouseMotionListener( this );
    
    }
    
    简单画图
    
     
    
    import bsh.util.BshCanvas;   // BshCanvas simply buffers graphics
    
    
    
    graph( int width, int height ) {
    
        canvas=new BshCanvas(); 
    
        canvas.setSize( width, height );
    
        frame=frame( canvas );
    
        graphics=canvas.getBufferedGraphics();
    
        // draw axis
    
        graphics.setColor( Color.red );
    
        graphics.drawLine( 0, height/2, width, height/2 );
    
        graphics.drawLine( width/2, 0, width/2, height );
    
        graphics.setColor( Color.black );
    
    
    
        plot(int x, int y) {
    
            graphics.fillOval( (x width/2-1), (y height/2-1), 3, 3);
    
            canvas.repaint();
    
        }
    
    
    
        return this;
    
    }
    
    
    
    drawSin( graph ) {
    
        for (int x=-100; x<100; x   ) {
    
            y=(int)(50*Math.sin( x/10.0 ));
    
            graph.plot( x, y );
    
        }
    
    }
    
    简单web浏览器
    
     
    
    import javax.swing.*;
    
    import javax.swing.event.*;
    
    import javax.swing.text.*;
    
    import java.awt.event.*;
    
    import java.awt.*;
    
    
    
    JFrame browser( startingUrl ) {
    
        invoke( method, args ) {}
    
    
    
        windowClosing(WindowEvent we) {
    
            we.getWindow().setVisible(false);
    
        }
    
    
    
        setPage( url ) {
    
            try {
    
              pane.setPage( url );
    
            } catch(Exception e) {
    
              statusBar.setText("Error opening page: " url);
    
            }
    
        }
    
    
    
        hyperlinkUpdate( HyperlinkEvent he ) {
    
            type = he.getEventType();
    
            if (type == HyperlinkEvent.EventType.ENTERED) {
    
                pane.setCursor(
    
                    Cursor.getPredefinedCursor( Cursor.HAND_CURSOR) );
    
                statusBar.setText(he.getURL().toString());
    
            } else 
    
                if (type == HyperlinkEvent.EventType.EXITED) {
    
                pane.setCursor( Cursor.getDefaultCursor() );
    
                statusBar.setText(" ");
    
            } else {
    
                setPage( he.getURL() );
    
                if (urlField != null)
    
                    urlField.setText(he.getURL().toString());
    
            }
    
        }
    
    
    
        frame = new JFrame("Browser");
    
        frame.setSize(400,300);
    
        frame.addWindowListener( this );
    
    
    
        urlPanel = new JPanel();
    
        urlPanel.setLayout(new BorderLayout());
    
        urlField = new JTextField(startingUrl);
    
        urlPanel.add(new JLabel("Site: "), BorderLayout.WEST);
    
        urlPanel.add(urlField, BorderLayout.CENTER);
    
    
    
        statusBar = new JLabel(" ");
    
        pane = new JEditorPane();
    
        pane.setEditable(false);
    
        setPage( startingUrl );
    
        jsp = new JScrollPane(pane); 
    
    
    
        frame.getContentPane().add(jsp, BorderLayout.CENTER);
    
        frame.getContentPane().add(urlPanel, BorderLayout.SOUTH);
    
        frame.getContentPane().add(statusBar, BorderLayout.NORTH);
    
    
    
        // This is the equivalent of an inner class in bsh.
    
        urlTextHandler() {
    
            actionPerformed(ActionEvent ae) {
    
                setPage( ae.getActionCommand() );
    
            }
    
            return this;
    
        }
    
    
    
        urlField.addActionListener( urlTextHandler() );
    
        pane.addHyperlinkListener( (HyperlinkListener)this );
    
    
    
        return frame;
    
    }
    
    browser = browser("http://java.sun.com/");
    
    browser.show();
    
    
    
    
    
    
    
    
    
    更多的文档参考BeanShell网站
    
    
    
    http://www.beanshell.org
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • JMeter BeanShell Sampler与JMeter BeanShell断言

    万次阅读 多人点赞 2019-06-25 21:35:07
    BeanShell是一种完全符合Java语法规范的脚本语言(当然,也有一些不一样的地方,比如BeanShell就不支持Java中的泛型),但又拥有一些独有的语法和方法。 BeanShell应用在JMeter的三个元件中:BeanShell Sampler...

    前言

    BeanShell是一种完全符合Java语法规范的脚本语言,但又拥有一些独有的语法和方法。(当然,也有一些不一样的地方,比如 BeanShell就不支持Java中的泛型,当初也是一个深坑)。

    BeanShell应用在JMeter的四个组件中:

    1. BeanShell Sampler:BeanShell取样器,位于 Sampler(取样器)中,与常用的【HTTP请求】取样器性质类似,也是一个独立的取样器,会被【聚合报告】所统计。
    2. BeanShell PreProcessor:BeanShell前置处理器,位于【前置处理器】中,作用于一个取样器上,且在取样器执行前执行,一般用于对取样器入参进行处理。
    3. BeanShell PostProcessor:BeanShell前置处理器,位于【后置处理器】中,作用于一个取样器上,且在该取样器执行后执行,一般用于对取样器结果进行处理。
    4. Beanshell Assertion:Beanshell 断言,位于【断言】中,作用于取样器上,且在该取样器执行后执行,用于对取样器响应结果进行断言。

    介绍几个BeanShell常用的独有方法:

    序号 名称 作用
    1 vars.get(“variableName”) 根据变量名获取内存中的变量值,前提是这个值在脚本前文中已经定义并赋值
    2 vars.put(“variableName”,“variableValue”) 将一个值存储到变量中,脚本下文中可以通过${variableName}引用
    3 prev.getResponseDataAsString() 获取sampler(取样器)的响应数据并以String类型接收,用在【后置处理器】的【BeanShell PostProcessor中】

    更多内置方法见JMeter API文档

    关于JMeter的使用,我花费一些精力写了JMeter的一系列文章,有图有案例,一方面总结起来作为备忘,一方面希望能给初学者一些帮助。觉得有所帮助的朋友,请点个赞,对于疏漏之处也欢迎指教。

    1 BeanShell操作变量

    前面说到了BeanShell的独有方法,vars.getvars.put了,BeanShell对变量的操作主要就是依赖这两个方法。

    首先创建一个脚本,【用户定义的变量】中定义了一个变量,变量名为paramIn,值为Mu
    在这里插入图片描述
    【BeanShell Sampler】中写入下面语句:
    在这里插入图片描述
    HTTP请求对【BeanShell Sampler】中put出的变量进行引用:
    在这里插入图片描述
    运行脚本,查看结果树,可以看到变量引用成功:在这里插入图片描述
    在这里插入图片描述
    在BeanShell中直接写代码,方便快捷,在代码量不大的情况下十分便利。如果出于规范化考虑,尤其代码量较大时,为了使BeanShell看起来更清晰,可以按下面的方式写,效果是一样的:
    在这里插入图片描述

    // 定义一个方法
    public void test(){
    	// vars.get 获取paramIn的值
    	String paramIn = vars.get("paramIn");
    	// 一个简单的字符串拼接
    	String string = "Hello," + paramIn;
    	// vars.put()生成一个变量且赋值
    	vars.put("param",string);
    	vars.put("paramOut",string + ",Welcome");
    }
    
    // 需要主动调用函数,否则函数不会自动起作用
    test();
    

    2 BeanShell引用外部资源

    如果JMeter脚本的代码量比较小,那么直接在将代码写在Beanshell中就可以了。如果代码量比较大,在Beanshell里写起来就比较困难,这时候可以考虑引用外部资源,包括引用.java文件、.class文件、.jar文件三种方式。

    首先,我们写好这么一个类,类内的md5Encryption方法,是将一个字符串转化为一个经过MD5加密过的新字符串。

    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    public class Md5Encryption {
    	public static String md5Encryption(String string) {
    		try {
    			MessageDigest md = MessageDigest.getInstance("MD5");
    			md.update(string.getBytes());
    			byte[] b = md.digest();
    			int i;
    			StringBuffer buf = new StringBuffer("");
    			for (int offset = 0; offset < b.length; offset++) {
    				i = b[offset];
    				if (i < 0)
    					i += 256;
    				if (i < 16)
    					buf.append("0");
    				buf.append(Integer.toHexString(i));
    			}
    			return buf.toString();
    		} catch (NoSuchAlgorithmException e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
    }
    

    2.1 引用java文件

    上面的代码在Md5Encryption.java文件中,JMeter支持直接引用java文件。
    在这里插入图片描述

    // 引用外部.java文件,注意路径中要使用"/"
    source("D:/Md5Encryption.java");
    
    String passwordIni = "123456";
    
    // 调用加密方法
    String passwordEncryp = new Md5Encryption().md5Encryption(passwordIni);
    vars.put("passwordEncryp",passwordEncryp);
    

    运行结果:
    在这里插入图片描述
    要注意的是,如果引用的java文件中,又依赖了其他jar包,那么也需要将相应的jar包导入JMeter的安装目录的/lib/etc中并重启JMeter,引用.class和.jar也是同理。

    2.2 addClassPath

    如果一个java文件不满足需求,那么可以把引用范围扩大到整个项目,如下,整个mutest项目src目录下的所有类都可以通过 import 方式引用:
    在这里插入图片描述

    // 添加路径:类所在项目的目录
    addClassPath("E:/project/workspace/mutest/src");
    
    // 引入
    import mutest.Md5Encryption;
    
    String passwordIni = "123456";
    // 调用加密方法
    String passwordEncryp = new Md5Encryption().md5Encryption(passwordIni);
    vars.put("passwordEncryp",passwordEncryp);
    

    2.3 引用jar包

    前面两种方式呢,受外部影响太大,比如Md5Encryption被修改了,或者路径发生变化了,JMeter脚本都会受影响。为了规避这种影响,我们可以将项目打成jar包,导入JMeter安装目录\lib\etc中,并重启JMeter

    上面步骤完成后,BeanShell中直接import即可使用:
    在这里插入图片描述

    // import时带上类的包名
    import mutest.Md5Encryption;
    
    String passwordIni = "123456";
    // 调用加密方法
    String passwordEncryp = new Md5Encryption().md5Encryption(passwordIni);
    vars.put("passwordEncryp",passwordEncryp);
    

    3 BeanShell断言

    接口测试中,所谓断言,是指用一定的判断规则对接口响应数据进行校验,不匹配则判定接口测试失败。在JMeter中,不加断言的话,默认校验接口的响应码。

    例如下面的例子,登录失败,但没有添加断言,且接口响应码是200,所以接口被JMeter判定为成功。
    在这里插入图片描述
    根据接口定义(一般由开发提供的接口文档定义),登录成功后,返回内容的message是“操作成功”,于是我们给接口添加一个【响应断言】
    在这里插入图片描述
    再次运行,可以看到接口被判定为失败:
    在这里插入图片描述
    对于这种校验比较简单的接口,【响应断言】能够满足要求,但遇到结果校验很复杂的接口,【响应断言】就无法胜任了,这时候就要用到【BeanShell断言】了。

    3.1 校验JSONObject

    首先使用【BeanShell Sampler】作为mock server返回这样的预期结果:

    {
    	"code" : 0,
    	"goodsInfo" : {
    		"name" : "computer",
    		"price" : 4500,
    		"size" : 60
    	}
    }
    

    1、首先,我们用BeanShell取样器模拟接口返回特定响应结果:
    在这里插入图片描述
    假如这个数据是根据id=1(id是接口的一个入参)的条件获取的,那么我们就可以编写sql语句去数据库查询数据了。
    数据库中的数据:
    在这里插入图片描述
    2、构造【JDBC Request】去获取数据库数据:
    在这里插入图片描述
    【BeanShell断言】,JSON处理用得是阿里的fastjson,jar包自行下载后放入JMeter的安装目录的/lib/etc中并重启JMeter
    在这里插入图片描述
    运行后,查看结果:
    在这里插入图片描述
    附上【BeanShell断言】代码

    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    // prev.getResponseDataAsString()方法获取接口响应数据
    String goodsDataRes = prev.getResponseDataAsString();
    // 将String解析成JSONObject并获取goodsInfo
    JSONObject goodsInfoRes = JSON.parseObject(goodsDataRes).getJSONObject("goodsInfo");
    // 定义一个新的JSONObject用来存储数据库数据
    JSONObject goodsInfoDb = new JSONObject();
    
    try{
    	goodsInfoDb.put("name",vars.get("name_1"));
    	// 这里注意将数字转为int类型
    	goodsInfoDb.put("price",Integer.valueOf(vars.get("price_1")));
    	goodsInfoDb.put("size",Integer.valueOf(vars.get("size_1")));
    
    	if(!goodsInfoRes.equals(goodsInfoDb)){
    		Failure = true;
    		String message = "接口返回数据与数据库数据不一致!\n";
    		FailureMessage = message + "数据库内容: " + goodsInfoDb + "\n响应内容: " + goodsInfoRes;
    	}
    }catch(Exception e){
    	Failure = true;
    	String message = "数据库数据为空!\n";
    	FailureMessage = message + "数据库内容: \n" + goodsInfoDb + "\n" + "响应内容: \n" + goodsInfoRes;
    }
    

    3.2 校验含JSONArray的JSON

    我们将问题复杂化一些,假如接口返回的是包含JSONArray的数据,如下:

    {
    	"code" : 0,
    	"data" : [{
    			"name" : "iphone",
    			"price" : 6000,
    			"size" : 55
    		}, {
    			"name" : "watch",
    			"price" : 500,
    			"size" : 35
    		},{
    			"name" : "computer",
    			"price" : 4500,
    			"size" : 60
    		}
    	]
    }
    
    return "{\"code\" : 0,\"data\" : [{\"name\" : \"iphone\",\"price\" : 6000,\"size\" : 55}, {\"name\" : \"watch\",\"price\" : 500,\"size\" : 35},{\"name\" : \"computer\",\"price\" : 4500,\"size\" : 60}]}";
    

    上面的数据,对应数据库里status=1的数据:
    在这里插入图片描述
    针对这种需求,sql语句要修改一下:
    在这里插入图片描述
    这个接口结果校验的难点在于,接口数据与数据库数据的顺序不对应,且无法事先确定其顺序,如果直接对比两个JSONObject,由于JSONArray中元素顺序不同,会导致对比返回false,尽管两个JSONObject中的数据除了顺序,其他都相同。

    要解决顺序问题,我想到的方案是对数据进行进一步加工,将JSONArray处理成JSONObject格式,这样就消除了顺序的影响(不含JSONArray的JSONObject的对比是不受元素顺序影响的),【BeanShell断言】内代码贴上:

    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.JSONArray;
    
    String goodsDataRes = prev.getResponseDataAsString();
    JSONArray goodsListRes = JSON.parseObject(goodsDataRes).getJSONArray("data");
    vars.put("goodsListRes",goodsListRes.toString());
    
    JSONObject goodsInfoDb = new JSONObject();
    JSONObject goodsInfoRes = new JSONObject();
    
    try{
    	for(int i = 1;i <= Integer.parseInt(vars.get("name_#"));i++){
    		JSONObject goods = new JSONObject();
    		goods.put("name",vars.get("name_" + i));
    		goods.put("price",Integer.parseInt(vars.get("price_" + i)));
    		goods.put("size",Integer.parseInt(vars.get("size_" + i)));
    		goodsInfoDb.put(vars.get("name_" + i),goods);
    	}
    
    	for(int i = 0; i < goodsListRes.size();i++){
    		JSONObject goods = goodsListRes.getJSONObject(i);
    		goodsInfoRes.put(goods.getString("name"), goods);
    	}
    	
    	if(goodsInfoRes.size() != goodsInfoDb.size()){
    		Failure = true;
    		String message = "接口返回数据与数据库数据的数量不一致!\n";
    		FailureMessage = message + "数据库数据数量: " + goodsInfoDb.size() + "\n响应数据数量: " + goodsInfoRes.size() + "\n数据库内容: " + goodsInfoDb + "\n响应内容: " + goodsInfoRes;
    	}else if(!goodsInfoRes.equals(goodsInfoDb)){ 
    		Failure = true;
    		String message = "接口返回数据与数据库数据的内容不一致!\n";
    		FailureMessage = message + "数据库内容: " + goodsInfoDb + "\n响应内容: " + goodsInfoRes;
    	}
    }catch(Exception e){
    	Failure = true;
    	String message = "数据处理异常!\n";
    	FailureMessage = message + "数据库内容: \n" + goodsInfoDb + "\n" + "响应内容: \n" + goodsInfoRes;
    }
    

    使用这个断言,我们测试一下:

    1. 数据处理异常,可以人为将sql写错,例如:select price,size from test.goods where status=1(缺少name字段);
      在这里插入图片描述
    2. 接口数据与数据库数据的数量不一致,可以将数据库数据篡改一下:
      在这里插入图片描述
      在这里插入图片描述
    3. 数据库数据和接口响应数据数量一致,但内容不同
      在这里插入图片描述
      在这里插入图片描述
    4. 数据库数据与接口响应数据一致,断言通过。
      在这里插入图片描述
      以上,是BeanShell的相关知识,后续还会更新更多的使用场景。
    展开全文
  • BeanShell-简单的Java脚本 BeanShell的官方活动项目主页。 注意:待发布新版本 唯一推荐的版本是master分支的手动构建。 对旧版本的支持达到了行尾,只能接受针对主版本的问题和拉取请求。 下一个版本将是概述的...
  • 该项目是用于执行BeanShell脚本的自动化且标准化的设置。 它为.bsh文件扩展名设置文件关联和图标。 它使用标准的CLASSPATH启动BeanShell脚本,该脚本包含用于添加您自己的命令的目录。 还包括一些不错的新命令。 ...
  • Beanshell使用

    2020-10-14 15:27:34
    这时,我们可以利用BeanShell来编写简单代码,实现文件的的保存。这里用到了BeanShell PostProcessor (后置处理器)。 下面以利用在线服务转换音频格式,生成特定speex格式的音频文件为例: 首先设置好http请求,并...
  • beanshell.pptx

    2019-06-20 14:46:57
    jmeter的beanshell基础使用,未包含jar包请自行下载。
  • jmeter BeanShell

    2019-10-03 21:31:57
    beanshell 取样器 作用:写java脚本和jmeter交互、输出日志 例如: log.info(“123”); beanshell 预处理器 作用:打印请求信息 beanshell后置处理器 作用: 打印响应信息 例如: 打印response String response = ...
  • beanshell使用

    2017-04-07 09:51:00
    jmeter的BeanShell  定时器: BeanShell Timer  前置处理器:BeanShell PreProcessor  采样器: BeanShell Sampler  后置处理器:BeanShell PostProcessor  断言: BeanShell断言  监听器: BeanShell ...
  • Beanshell断言

    2019-07-17 15:06:00
    1、Beanshell Beanshell 是一种轻量级的 Java 脚本,纯 Java 编写的,能够动态的执行标准 java 语法及一些扩展脚本语法,类似于 javaScript 和 perl。 2、内置变量 Beanshell Sampler 中除了可以使用标准 java ...
  • beanShell断言

    2019-06-26 14:02:15
    用户可以在jmeter- “beanShell断言”中自定义断言。自由灵活的用脚本实现自己的断言 beanShell断言接口介绍 在beanShell中直接可以调用的变量,无需加前缀。 1.log 打印日志 log.info(“在控制台打印日志”); 2...
  • 初识BeanShell

    2019-01-22 17:49:27
    一、什么是BeanShell BeanShell是一个小型嵌入式Java源代码解释器,具有对象脚本语言特性,能够动态地执行标准JAVA语法,并利用在JavaScript和Perl中常见的的松散类型、命令、闭包等通用脚本来对其进行拓展。...
  • BeanShell简介

    2019-08-13 00:13:54
    BeanShell是一种脚本语言,一种完全符合java语法的java脚本语言,并且又拥有自己的一些语法和方法,beanShell是一种松散类型的脚本语言(这点和JS类似)。 下载地址:http://www.beanshell.org 设置环境 l 把;...
  • BeanShell Timer

    2019-04-01 20:32:42
    1、使用场景:用BeanShell脚本语言来访问及设置JMeter的属性,访问及设置变量,还可用来记录日志。如用BeanShell来设置线程延迟间隔。 2、相关参数 Reset Interpreter:每次迭代是否重置解析器,默认为false...
  • beanshell 指南

    2012-10-30 13:00:50
    A Corsaire Guide:Assessing Java Clients with the BeanShell
  • New BeanShell release

    2020-12-30 21:27:54
    <a href="https://api.gh-polls.com/poll/01CHGF0S2MPRRZV3546T759VAR/BeanShell%208/vote"><img alt="" src="https://api.gh-polls.com/poll/01CHGF0S2MPRRZV3546T759VAR/BeanShell%208" /></a></p> <p>See next ...
  • Add BeanShell payload

    2021-01-09 20:18:22
    <div><p>A new BeanShell version was recently release that prevented the deserialization of XThis objects. I tried tried to write a gadget chain for it, but am yet unsuccessful. <p>Read more details ...

空空如也

空空如也

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

beanshell