47岁的大妈Susan唱了一段音乐剧《悲惨世界》里的选段《I Dream a Dream》
    Susan唱的这一段是《悲惨世界》中，冉阿让帮助过的妓女芳仃身患结核病，在医院里等死时的唱段。她思念她的女儿珂赛特，珂赛特已被冉阿让收养带去了巴黎，芳仃希望女儿能得到幸福，一边回想年轻时她自己对生活抱有的梦想。这是一个绝境中的女人的最后一丝念想。

评委评价:

“能听到你的歌声是我至高的荣誉~”

歌词翻译：

　　我梦到往日的一个梦
　　那时充满希望生命也有价值
　　我梦到爱永不凋零，我梦到上帝是宽容的
　　那时我仍年轻无惧~
　　我浪掷梦想，而无需付出任何代价
　　无歌不唱，无酒不尝
　　然而老虎却在夜里，带着他们低沉如雷的声音来到
　　他们将你的希望撕裂，他们让你的梦想幻灭
　　我曾梦想着我的人生
　　完全不像我现在地狱般的生活
　　现在完全不像我曾经想象的
　　如今这现实的生活已经扼杀了我昔日的梦想。

http://www.kekenet.com/broadcast/voaspecial/

雅思

http://www.cnielts.com/voa/list_31_2.html

一 通过Thread类创建线程
 

//ch02.OurClass.java
public class OurClass extends Thread {
    public void run() ...{
        for (int I = 0; I < 100; I++) {
            System.out.println("Hello");
        }
    }
}

//ch02.OurApplet.java
import java.applet.Applet;

public class OurApplet extends Applet {
    public void init() {
        OurClass c = new OurClass();
        oc.start();
    }
}
 start()方法实际上创建了一个新的线程。这个新的线程，在进行了一些初始化操作后调用run()方法。在run()方法运行结束后，该程序还作了一些与程序终止相关的工作。因而，在新线程中运行的run()方法大概是在start()方法返回到第一个线程的同时开始运行的。

创建一个线程两个步骤：

在子类中覆盖run()方法；

通过构造函数创建子类的一个对象并调用子类的start()方法；

==========================================================

二 使用Runnable接口的线程
对于一个已经有着详细继承树关系的类而言，如果想让它在自己的线程中运行，就不能如上那样使其从Thread类继承而来。Java中使用接口的机制来解决其不支持多重继承的缺陷。

实际上，线程化的类实现了Runnable接口。因此，当一个类继承自Thread类时，其子类也同时实现了Runnable接口。

简单地说，我们可以通过实现Runnable接口来代替从Thread类继承。

第一步：只需将 extends Thread  替换为 implements Runnable

//ch02.OurRunnableClass.java

public class OurRunnableClass implements Runnable ...{
    public void run() ...{
        for (int I = 0; I < 100; I++) ...{
            System.out.println("Hello, from another thread");
        }
    }
}
第二步：因为OurRunnableClass不再是Thread对象，不能使用默认的构造函数创建线程。不过可以通过OurRunnableClass对象的引用创建新的线程对象。

//ch02.OurRunnableApplet.java

import java.applet.Applet;

public class OurRunnableApplet extends Applet ...{
    public void init() ...{
        Runnable t = new OurRunnableClass();
        Thread th = new Thread(ot);
        th.start();
    }
}
 为什么会有这样一个构造函数呢？前面曾经提过Thread类的run()方法默认实现是一个空方法。代码如下：

public void run() ...{
           if ( target != null ) ...{
                      target.run();
           }
}
target其实就是传递给线程的构造函数的可运行对象(实现了Runnable接口的对象)。

有趣的是，通过使用Runnable接口而不是继承自Thread类的技术，第一步的OurClass类的代码可以和第二步的applet融合在一起了。

 如下所示：

import java.applet.Applet;

public class OurCompleteApplet extends Applet implements Runnable ...{
    public void init() ...{
        Thread th = new Thread(this);
        th.start();
    }

    public void run() ...{
        for (int I = 0; I < 100; I++) ...{
            System.out.println("Hello, from another thread");
        }
    }
}

===============================================

改写实例：

//线程子类
public class OurClass extends Thread {
    public void run() {
        for (int I = 0; I < 10; I++) {
            System.out.println("Hello");
        }
    }
}

//主体类
import java.applet.Applet;

public class OurApplet extends Applet {
   
    //public void init()
   
    public static void main(String[] args)
    {
        OurClass c = new OurClass();
        oc.start();
        OurClass oc2 = new OurClass();
        oc2.start();
    }
}

==============================================================

Runnable接口的实例化，区别

//一对多的服务端和客户机：一个服务端能同时服务多个客户端，需要使用多线程来实现

//服务端：调用具体的处理线程完成处理
package com.socket.multiserver;
import java.io.*;
import java.net.*;
import com.socket.multiserver.ChildTh;

public class MyMultiServer {
 public static void main(String[] args) throws IOException{
  ServerSocket server=new ServerSocket(5678);
  while (true){
                Socket client=server.accept();
                ChildTh child=new ChildTh(client);//用socket实例初始化具体的处理线程对象
                //使用Runnable接口和使用extends Thread的区别：
                // 如果是使用Runnable接口，需要这么写：
                   new Thread(child).start();               
                //注意：不能写成：child.run();
                // 如果使用extends Thread，只需要child.start()就可以，因为start()是Thread的方法
                }
        }
}       

============================================================

//处理线程类：
package com.socket.multiserver;
import java.io.*;
import java.net.*;

public class ChildTh implements Runnable{
        private Socket client;
        public ChildTh(Socket client){
                this.client=client;
        }
       
        public void run(){       
           try{       
             BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
             PrintWriter ut=new PrintWriter(client.getOutputStream());
             while(true){
                     String str=in.readLine();
                     System.out.println(str);
                     out.println("has receive....");
                     out.flush();
                     if(str.equals("end"))
                        break;
             }       
                       
             client.close();
            }catch(Exception e){
                  System.out.println("error in the close the socket!");                       
                  e.printStackTrace();
              }
              finally{
                                                               
              }
        }
       
}

===========================================================

//客户端
package com.socket.multiserver;
import java.net.*;
import java.io.*;

public class MyMultiClient{
 static Socket client;
 
 public static void main(String[] args)throws Exception{
 
  client=new Socket(InetAddress.getLocalHost(),5678);
 
         BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
         PrintWriter ut=new PrintWriter(client.getOutputStream());
        
         //从标准输入接收数据
  BufferedReader wt=new BufferedReader(new InputStreamReader(System.in));
 
  while(true){
           String str=wt.readLine();
           //String str = "jonathan";
           out.println(str);
           out.flush();
           if(str.equals("end")){
                    break;
          }
           System.out.println(in.readLine());
  }
  client.close();
 }
}

http://www.360doc.com/showWeb/0/0/174225.aspx

三个java文件

编译：javac -d . *.java
执行：java  包.类名

implements Runnable ：
        Runnable t = new OurRunnableClass();
        Thread th = new Thread(ot);
        th.start();

java多线程：复写run()方法

//一对一的服务端和客户机：一个服务端只能同时服务一个客户端
//服务端：

import java.io.*;
import java.net.*;

public class MyServer {
 public static void main(String[] args) throws IOException{
     
     ServerSocket server=new ServerSocket(5678);
     Socket client=server.accept();
       
        BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
        PrintWriter ut=new PrintWriter(client.getOutputStream());
       
        while(true){
                 String str=in.readLine();
                System.out.println(str);
                out.println("has receive....");
                 out.flush();
                 if(str.equals("end"))
                         break;
                }
                client.close();
        }
}

//客户端
import java.net.*;
import java.io.*;

public class Client{
 static Socket client;
 
 public static void main(String[] args)throws Exception{
  client=new Socket(InetAddress.getLocalHost(),5678);
         BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
         PrintWriter ut=new PrintWriter(client.getOutputStream());
         //标准输入
  BufferedReader wt=new BufferedReader(new InputStreamReader(System.in));
 
  while(true){
           String str=wt.readLine();
           //String str = "jonathan";
           out.println(str);
           out.flush();
           if(str.equals("end")){
                    break;
          }
           System.out.println(in.readLine());
  }
  client.close();
 }
}

可以参考PrintWriter的用法  方法：println(?)

java.io
类 PrintWriter

java.lang.Object
  java.io.Writer
      java.io.PrintWriter

服务端

import java.io.* ;
import java.net.* ;
import java.lang.*;

public class TCPServer
{
 public static void main(String args[]) throws Exception
 {
  try
  { 
   // 使用ServerSocket
   ServerSocket server = null ;
   // 每一个用户在程序中就是一个Socket
   Socket client = null ;
   server = new ServerSocket(8888) ;
   System.out.println("Server listen on :"+server.getLocalPort());
   
    boolean flag = true;
   
   
   while(flag)
     {
   
   // 等待客户端连接
   client = server.accept() ;
   // 向客户端打印信息：HELLO MLDN
   PrintWriter ut = null ;
   // 准备向客户端打印信息
   out = new PrintWriter(client.getOutputStream()) ;
   out.println("HELLO MLDN") ;
   
  
   
   
   out.close() ;
   client.close() ;
     } 
     server.close() ;
    
  }
  catch(Exception e)
      {
        System.out.println("Exception :"+e.getMessage());
       }
    
    
 }
};

客户端

import java.io.* ;
import java.net.* ;
public class TCPClient
{
 public static void main(String args[]) throws Exception
 {
  try
  {
   // 表示一个客户端的Socket
   Socket client = null ;
   // 表示一个客户端的输入信息
   BufferedReader buf = null ;
   client = new Socket("192.168.1.102",8888) ;
   
   
   buf = new BufferedReader(new InputStreamReader(client.getInputStream())) ;
   System.out.println(buf.readLine()) ;
   
   
   buf.close() ;
   client.close() ;
  }
  catch(Exception e)
  {
       System.out.println("错误信息；"+e.getMessage());
  } 
 }
};

//字符流

//从控制台输入字符，并打印出来

import java.lang.*;
import java.io.*;

public class Datain
{
 public static void main(String args[]) throws Exception
    {

      BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
      String s  = b.readLine();
      System.out.println(s);
     }
};

// 字节流

    复杂的不是Socket本身，他的结构不复杂，主要是输入、输出流的加入，由于io类练习的少，所以理解上费了些事，这就是java基础薄弱的表现哦，缺乏java基础类的练习

服务端：

 //package com.socket;

import java.net.*;
import java.io.*;
import java.lang.*;

public class TestSocketServer{
 
  public static void main(String args[])
  {
    try
    {
     boolean flag = true;
    
     Socket clientSocket = null;   
      //定义客户端套接字
     //JavaAPI 包java.net，找到Socket类，查看其包含的方法
     //Socket()
     //通过系统默认类型的 SocketImpl 创建未连接套接字
   
     String inputLine;
     int c;
    
     ServerSocket sSocket = new ServerSocket(8018);   
     // 创建绑定端口的服务端socket
     //JavaAPI 包java.net，找到ServerSocket类，查看其包含的方法
     //ServerSocket(int port)
     // 创建绑定到特定端口的服务器套接字。
        
     System.out.println("Server listen on :"+sSocket.getLocalPort());
       // int getLocalPort()  返回此套接字在其上侦听的端口。
   
   
   
    
     while(flag)
     {
      clientSocket = sSocket.accept();
      //Socket accept()
            // 侦听并接受到此套接字的连接。
     
      DataInputStream dataIn = new DataInputStream(new BufferedInputStream(clientSocket.getInputStream()));
      //InputStream getInputStream()
             //返回此套接字的输入流。
     
      OutputStream dataOut = clientSocket.getOutputStream();

      //OutputStream getOutputStream()
            //返回此套接字的输出流。
          
            while((inputLine = dataIn.readLine())!= null)
            {
             //当客户端输入stop的时候，服务器停止运行
             if(inputLine.equals("stop"))
                { flag = false;
                  break;
                
                 }
              else
                 {
                  System.out.println(inputLine);
                 
                   while((c = System.in.read())!=-1)       //System.in.read()   当返回   -1   时，表示流的结束
                
                 //java.lang 类 System
                 //     in
                 //    public static final InputStream in“标准”输入流。
                 //    此流已打开并准备提供输入数据。
                 //    通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。
                
                
                  // java.io 类 InputStream                      
                  // abstract  int read()
                   // 从输入流读取下一个数据字节。
                  
                   {
                      dataOut.write((byte)c);     
                     
                     
                     
                      if(c=='\n')       ////   如果读到的c是换行符    这里 '\n' 是字符，转换成整型数值后与c进行比较
                      {
                       dataOut.flush();  ////将c转成字节型写入输出流，将信息发送到客户端
                       break;
                       //类 OutputStream
                       //方法  flush
                       //public void flush()
                      //throws IOException刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。
                     //如果此流的预期目标是由基础操作系统提供的一个抽象（如一个文件），则刷新此流只能保证将以前写入到流的字节传递给操作系统进行写入，但不保证能将这些字节实际写入到物理设备（如磁盘驱动器）。
                     //OutputStream 的 flush 方法不执行任何操作。

                       }
                    }
                  }
             }
            
             dataIn.close();
             dataOut.close();
             clientSocket.close();
     
     }
    
     sSocket.close();
    
    
    }
   
    catch(Exception e)
    {
     System.out.println("Exception :"+e.getMessage());
     }
    
   }
 
 
 
 
}

客户端：

//package com.socket;
import java.lang.*;
import java.net.*;
import java.io.*;

public class TestSocketClient{
 
 public static void main(String args[])
 {
    try
    {
         //创建通讯并且和服务端主机连接
         Socket cSocket = new Socket("192.168.1.102",8018);
         //JavaAPI 包java.net，找到Socket类，查看其包含的方法
         // Socket(InetAddress address, int port)  构造方法
            // 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
       
         //打开这个Socket的输入/输出流
         OutputStream dataOut = cSocket.getOutputStream();
         DataInputStream dataIn = new DataInputStream(cSocket.getInputStream());
       
         int c;
         boolean flag = true;
       
         String responseline;
         responseline = null;
       
         while(flag)
         {
          //从标准输入输出接收字符并且写入系统
            while((c=System.in.read())!=-1)
            {
             dataOut.write((byte)c);
             if(c=='\n')
               {
                dataOut.flush();
                //将程序阻塞，直到回答信息被接收到后将他们显示在标准输出上
               
                responseline = dataIn.readLine();
                System.out.println("Message is:"+responseline);
               
                }
            
             }
         
          }
          dataOut.close();
          dataIn.close();
          cSocket.close();
     }
     catch(Exception e)
     {
         System.out.println("Exception :"+e.getMessage());
      }
  
  }
}

--------------------------------------------------------------

服务端的关键代码

  ServerSocket sSocket = new ServerSocket(8018);  

      while(flag)
     { 
       Socket clientSocket = sSocket.accept();
       DataInputStream dataIn = new DataInputStream(new BufferedInputStream(clientSocket.getInputStream()));
       OutputStream dataOut = clientSocket.getOutputStream();
       String inputLine = dataIn.readLine();
    
    
    
        while(inputLine != null)
            {
             if(inputLine.equals("stop"))
                { flag = false;
                  break;
                
                 }
              else
                 {
                  System.out.println(inputLine);
                 
                   while((c = System.in.read())!=-1)                
                   {
                      dataOut.write((byte)c);     
                      if(c=='\n')      
                      {
                       dataOut.flush();  
                       break;
                       }
                    }
                  }
             }
             dataIn.close();
             dataOut.close();
             clientSocket.close();  
       }
       sSocket.close();
      

帖子参考；

http://topic.csdn.net/u/20070518/09/5bfb2de8-8ab1-4c26-abfd-5d28fc410761.html?1410589227

上午又写了一遍，需要注意的地方还很多哦

客户端与服务端，需要交替输入数据来进行交互

服务端:

import java.net.*;
import java.lang.*;
import java.io.*;

public class MySocketServer
  {
 
    public static void main(String args[])     //throws IOException
     {
        try{
         ServerSocket myServer = new ServerSocket(8018);
         System.out.println("正在监听端口："+myServer.getLocalPort());
         Socket myClient = null;
        
         boolean flag = true;
         String InputMessage = null;
         int c;
      
     
         while(flag)
         {
           myClient = myServer.accept();
           //接收客户端的信息，如果不是Stop就继续监听，加个if判断
           DataInputStream dataIn = new DataInputStream(myClient.getInputStream());
           //DataInputStream dataIn = new DataInputStream(new BufferedInputStream(myClient.getInputStream()));       
           OutputStream dataOut = myClient.getOutputStream();
          
          while( (InputMessage = dataIn.readLine()) != null )
            {
             if( InputMessage.equals("stop"))
             {
                 flag = false;
                 break;
              }
             else
             {               
                  System.out.println("从客户端接收到的信息是："+InputMessage);
                  //输入：读取至 末尾-1结束，遇到回车'\n'结束：
                  while((c=System.in.read())!= -1)
                    {
                      dataOut.write((byte)c);
                       if(  c== '\n')
                       {
                         dataOut.flush();
                         break;
                       }
                     
                     }
  
              }
          }
          dataIn.close();    
           dataOut.close();
           myClient.close();
          }
         myServer.close(); 
         }
       catch(Exception e)
          {
             System.out.println(e.getMessage());
           } 
     
     } 
 
 }

客户端：

import java.io.*;
import java.lang.*;
import java.net.*;

public class MySocketClient
{
 public static void main(String args[])
 {
   try{   
     
       Socket myClient = new Socket("192.168.1.25",8018);
                          
       DataInputStream dataIn = new DataInputStream(myClient.getInputStream());
       OutputStream dataOut = myClient.getOutputStream();
      
       boolean flag = true;
       int c;
       String serverResponse = null ;
      
       while(flag)
       {
          while( (c=System.in.read())!= -1 )
            {
              dataOut.write((byte)c);
              if(c=='\n')
                 {
                    dataOut.flush();
                    serverResponse = dataIn.readLine();
                    System.out.println("服务器的返回信息是："+serverResponse);
                  
                  }
             }
        
        }
       dataIn.close();
       dataOut.close();
       myClient.close(); 
      }
    
   catch(Exception e)
   {
     System.out.println("Exception :"+e.getMessage());
    } 
 }  
}

例子是学习编程的法宝。你在学习java Socket 吗？看看下

面的这个例子吧！
实现Client端功能的ClientApp.java原文件：

import java.net.*;
import java.io.*;
import java.lang.*;

public class ClientApp
{
public static void main(String args[])
{
try
{
//创建通讯并且和主机Rock连接
Socket cSocket=new Socket("192.168.100.188",8018);
//打开这个Socket的输入/输出流
OutputStream s=cSocket.getOutputStream();
DataInputStream is=new DataInputStream

(cSocket.getInputStream());

int c;
boolean flag=true;

String responseline;

while(flag)
{
//从标准输入输出接受字符并且写如系统
while((c=System.in.read())!=-1)
{
os.write((byte)c);
if(c==''\n'')
{
os.flush();
//将程序阻塞，直到回答信息被收到后将他们在标准输出上

显示出来
responseline=is.readLine();
System.out.println("Message is:"+responseline);
}
}
}
os.close();
is.close();
cSocket.close();

}
catch(Exception e)
{
System.out.println("Exception :"+ e.getMessage());
}
}
}  

   实现Server端功能的ServerApp.java原文件：

import java.net.*;
import java.io.*;

public class ServerApp
{
public static void main(String args[])
{
try
{
boolean flag=true;
Socket clientSocket=null;
String inputLine;
int c;

ServerSocket sSocket=new ServerSocket(8018);
System.out.println("Server listen

on:"+sSocket.getLocalPort());

while(flag)
{
clientSocket=sSocket.accept();
DataInputStream is= new DataInputStream(new

BufferedInputStream(clientSocket.getInputStream()));
OutputStream s=clientSocket.getOutputStream();

while((inputLine=is.readLine())!=null)
{
//当客户端输入stop的时候服务器程序运行终止！
if(inputLine.equals("stop"))
{
flag=false;
break;
}
else
{
System.out.println(inputLine);

while((c=System.in.read())!=-1)
{
os.write((byte)c);
if(c==''\n'')
{
os.flush(); //将信息发送到客户端
break;
}
}
}

}
is.close();
os.close();
clientSocket.close();

}
sSocket.close();
}
catch(Exception e)
{
System.out.println("Exception :"+ e.getMessage());
}
}
}    

===========================================================

LR函数：

lr_start_transaction

为性能分析标记事务的开始

lr_end_transaction

为性能分析标记事务的结束

lr_rendezvous

在 Vuser 脚本中设置集合点

lr_think_time

暂停 Vuser 脚本中命令之间的执行 

lr_end_sub_transaction

标记子事务的结束以便进行性能分析

lr_end_transaction

标记 LoadRunner 事务的结束

Lr_end_transaction("trans1",Lr_auto);

lr_end_transaction_instance

标记事务实例的结束以便进行性能分析

lr_fail_trans_with_error

将打开事务的状态设置为 LR_FAIL 并发送错误消息

lr_get_trans_instance_duration

获取事务实例的持续时间（由它的句柄指定）

lr_get_trans_instance_wasted_time

获取事务实例浪费的时间（由它的句柄指定）

lr_get_transaction_duration

获取事务的持续时间（按事务的名称）

lr_get_transaction_think_time

获取事务的思考时间（按事务的名称）

lr_get_transaction_wasted_time

获取事务浪费的时间（按事务的名称）

lr_resume_transaction

继续收集事务数据以便进行性能分析

lr_resume_transaction_instance

继续收集事务实例数据以便进行性能分析

lr_set_transaction_instance_status

设置事务实例的状态

lr_set_transaction_status

设置打开事务的状态

lr_set_transaction_status_by_name

设置事务的状态

lr_start_sub_transaction

标记子事务的开始

lr_start_transaction

标记事务的开始

Lr_start_transaction("trans1");

lr_start_transaction_instance

启动嵌套事务（由它的父事务的句柄指定）

lr_stop_transaction

停止事务数据的收集

lr_stop_transaction_instance

停止事务（由它的句柄指定）数据的收集

lr_wasted_time

消除所有打开事务浪费的时间

lr_get_attrib_double

检索脚本命令行中使用的 double 类型变量

lr_get_attrib_long

检索脚本命令行中使用的 long 类型变量

lr_get_attrib_string

检索脚本命令行中使用的字符串

lr_user_data_point

记录用户定义的数据示例

lr_whoami

将有关 Vuser 脚本的信息返回给 Vuser 脚本

lr_get_host_name

返回执行 Vuser 脚本的主机名

lr_get_master_host_name

返回运行 LoadRunner Controller 的计算机名

lr_eval_string

用参数的当前值替换参数

lr_save_string

将以 NULL 结尾的字符串保存到参数中

lr_save_var

将变长字符串保存到参数中

lr_save_datetime

将当前日期和时间保存到参数中

lr _advance_param

前进到下一个可用参数

lr _decrypt

解密已编码的字符串

lr_eval_string_ext

检索指向包含参数数据的缓冲区的指针

lr_eval_string_ext_free

释放由 lr_eval_string_ext 分配的指针

lr_save_searched_string

在缓冲区中搜索字符串实例，并相对于该字符串实例，将该缓冲区的一部分保存到参数中

lr_debug_message

将调试信息发送到输出窗口

lr_error_message

将错误消息发送到输出窗口

lr_get_debug_message

检索当前消息类

lr_log_message

将消息发送到日志文件

lr_output_message

将消息发送到输出窗口

lr_set_debug_message

设置调试消息类

lr_vuser_status_message

生成带格式的输出，并将其写到 ControllerVuser 状态区域

lr_message

将消息发送到 Vuser 日志和输出窗口

lr_load_dll

加载外部 DLL

lr_peek_events

指明可以暂停 Vuser 脚本执行的位置

lr_think_time

暂停脚本的执行，以模拟思考时间（实际用户在操作之间暂停以进行思考的时间）

lr_continue_on_error

指定处理错误的方法

lr_continue_on_error (0）；lr_continue_on_error （1）；

lr_rendezvous

在 Vuser 脚本中设置集合点

TE_wait_cursor

等待光标出现在终端窗口的指定位置

TE_wait_silent

等待客户端应用程序在指定秒数内处于静默状态

TE_wait_sync

等待系统从 X-SYSTEM 或输入禁止模式返回

TE_wait_text

等待字符串出现在指定位置

TE_wait_sync_transaction

记录系统在最近的 X SYSTEM 模式下保持的时间

WEB函数列表：

web_custom_request

允许您使用 HTTP 支持的任何方法来创建自定义 HTTP 请求

web_image

在定义的图像上模拟鼠标单击

web_link

在定义的文本链接上模拟鼠标单击

web_submit_data

执行“无条件”或“无上下文”的表单

web_submit_form

模拟表单的提交

web_url

加载由“URL”属性指定的 URL

web_set_certificate

使 Vuser 使用在 Internet Explorer 注册表中列出的特定证书

web_set_certificate_ex

指定证书和密钥文件的位置和格式信息

web_set_user

指定 Web 服务器的登录字符串和密码，用于 Web 服务器上已验证用户身份的区域

web_cache_cleanup

清除缓存模拟程序的内容

web_find

在 HTML 页内搜索指定的文本字符串

web_global_verification

在所有后面的 HTTP 请求中搜索文本字符串

web_image_check

验证指定的图像是否存在于 HTML页内

web_reg_find

在后面的 HTTP 请求中注册对 HTML源或原始缓冲区中文本字符串的搜索

web_disable_keep_alive

禁用 Keep-Alive HTTP 连接

web_enable_keep_alive

启用 Keep-Alive HTTP 连接

web_set_connections_limit

设置 Vuser 在运行脚本时可以同时打开连接的最大数目

web_concurrent_end

标记并发组的结束

web_concurrent_start

标记并发组的开始

web_add_cookie

添加新的 Cookie 或修改现有的 Cookie

web_cleanup_cookies

删除当前由 Vuser 存储的所有 Cookie

web_remove_cookie

删除指定的 Cookie

web_create_html_param

将 HTML 页上的动态信息保存到参数中。（LR 6.5 及更低版本）

web_create_html_param_ex

基于包含在 HTML 页内的动态信息创建参数（使用嵌入边界）（LR 6.5 及更低版本）。

web_reg_save_param

基于包含在 HTML 页内的动态信息创建参数（不使用嵌入边界）

web_set_max_html_param_len

设置已检索的动态 HTML 信息的最大长度

web_add_filter

设置在下载时包括或排除 URL 的条件

web_add_auto_filter

设置在下载时包括或排除 URL 的条件

web_remove_auto_filter

禁用对下载内容的筛选

web_add_auto_header

向所有后面的 HTTP 请求中添加自定义标头

web_add_header

向下一个 HTTP 请求中添加自定义标头

web_cleanup_auto_headers

停止向后面的 HTTP 请求中添加自定义标头

web_remove_auto_header

停止向后面的 HTTP 请求中添加特定的标头

web_revert_auto_header

停止向后面的 HTTP 请求中添加特定的标头，但是生成隐性标头

web_save_header

将请求和响应标头保存到变量中

web_set_proxy

指定将所有后面的 HTTP 请求定向到指定的代理服务器

web_set_proxy_bypass

指定 Vuser 直接访问（即不通过指定的代理服务器访问）的服务器列表

web_set_proxy_bypass_local

指定 Vuser 对于本地 (Intranet) 地址是否应该避开代理服务器

web_set_secure_proxy

指定将所有后面的 HTTP 请求定向到服务器

web_set_max_retries

设置操作步骤的最大重试次数

web_set_timeout

指定 Vuser 等待执行指定任务的最长时间

web_convert_param

将 HTML 参数转换成 URL 或纯文本

web_get_int_property

返回有关上一个 HTTP 请求的特定信息

web_report_data_point

指定数据点并将其添加到测试结果中

web_set_option

在非 HTML 资源的编码、重定向和下载区域中设置 Web 选项

web_set_sockets_option

设置套接字的选项

概要步骤：

1.在eclipse建立java工程，编译要使用的java方法；

2.打开loadrunner，新建立脚本选择java脚本模式；

3.找到脚本存放的文件夹，把步骤1中整个的编译后的目录（class文件所在的整个目录）放如脚本文件夹中，

  loadrunner就可以使用该java方法；

 Java脚本开发基础

要想掌握Java虚拟用户的使用，测试脚本开发人员至少需要两方面的技能：一是具有Java语言方面的技能，并熟练使用至少一种Java集成开发工具，例如Eclipse；二是掌握LoadRunner的Java API，Java API是访问Vuser函数的基础，通过LoadRunner的Java API可以在脚本中很容易地创建事务与并发点、获取用户信息等功能。

不难看出，Java虚拟用户要求测试脚本开发人员具有良好的开发基础，否则Java Vuser很难发挥应有的作用。限于篇幅，本节在Java测试开发基础部分，仅对Java语言方面的知识做概要介绍，读者可以通过Java方面的书籍进行学习；在LoadRunner的Java API部分，将会介绍一些相对重要的方法。

1  Java虚拟用户开发基础

Java语言基础

Java语言博大精深，即使资深的Java开发工程师也未必敢自称精通，测试人员就更不容易成为“高手”了。但是如果仅仅为了满足测试开发，还是很容易快速入门的。表7-1列出了一些进行Java虚拟用户开发的知识点，读者可以自行学习。

表7-1  Java语言基础知识

续表

续表

测试人员在掌握了上面这些技能后，基本可以进行Java虚拟用户的开发了。同时，本着学无止境的原则，测试人员仍要以积极的态度来学习Java开发知识。

Java集成开发工具Eclipse

Eclipse是一个与NetBeans、Sun ONE Studio和Borland Jbuilder类似的，一种基于Java的整合型可扩展开发平台，也是目前最著名的开源项目之一。IBM一直在大力支持该项目的发展，并在2001年 11月宣布投入4千万美元到该项目的研发，这也是Eclipse项目发展较快的原因之一。

Eclipse专注于为高度集成的工具开发提供一个全功能的、具有商业品质的工业平台。它主要由Eclipse项目、Eclipse工具项目和Eclipse技术项目组成，具体包括四个组成部分：Eclipse Platform、JDT、CDT和PDE。JDT支持Java开发、CDT支持C开发、PDE用来支持插件开发，Eclipse Platform则是一个开放的可扩展IDE，提供了一个通用的开发平台。

Eclipse SDK（软件开发包）是Eclipse Platform、JDT和PDE所生产的组件合并，它们可以从eclipse.org网站（http://www.eclipse.org /downloads）上下载。这些组件提供了一个具有丰富特性的开发环境，允许开发者有效地建造可以无缝集成到Eclipse Platform中的工具。Eclipse SDK由Eclipse项目生产的工具和来自其他开放源代码的第三方软件组合而成。

在接下来的内容里，将介绍用Eclipse创建与编译Java类文件的过程以及如何在Java虚拟用户中调用编译好的类文件。关于Eclipse更深入的内容请读者参考其相关书籍。

l  创建Java项目

启动Eclipse后，依次选择菜单的“文件”→“新建”→“项目”，进入图7-7所示的界面。

图7-7  新建项目

在图7-7中选择Java项目，单击“下一步”，进入图7-8所示的界面。

图7-8  配置项目

在图7-8的“项目名称”输入“LoadRunnerDev”，“位置”下选择“在外部位置创建项目”，目录下选择“D:\LoadRunner”。然后点击“配置缺省值（O）...”，进入图7-9所示的界面。

图7-9  配置缺省值

在图7-9的“源和输出文件夹”处选择“文件夹（F）”，“源文件夹名（S）：”默认为“src”，无须改变，在“输出文件夹名（O）：”处输入“classes”，完成后返回图7-8所示界面。在图7-8中点击“下一步”，进入图7-10所示的界面。

图7-10  配置结果界面

在图7-10中，单击“完成”，新建Java项目工作完成。在图7-11中可以看到新建的项目“LoadRunnerDev”。

图7-11  包资源管理器

l  建立Java文件

如图7-12所示，在LoadRunnerDer中选中“src”，点击鼠标右键，进入“新建”，点击“类”，进入图7-13所示的新建Java类文件设置界面。

图7-12  新建Java类文件

在图7-13中，输入包名称“com.lr.test”、类名称“HelloWord”，其他各项设置默认即可。点击“完成”，进入源代码编辑界面，如图7-14所示。

图7-13  文件基本配置信息

图7-14  文件编辑界面

在源代码编辑界面，输入测试语句“System.out.println("HelloWord!");”如图7-14所示。代码编辑完成后，按照图7-15编译与运行程序。如果编译执行成功，可以在Eclipse的控制台看到输出结果，如图7-16所示。

图7-15  执行Java程序

图7-16  查看编译结果

l  编译与运行Java程序

编译后的class文件可以在“D:\LoadRunner\classes\com\lr\test”下找到，如图7-16所示。需要注意的是，类文件的存放路径是根据建立项目的设置来决定的。

l  开发虚拟用户脚本

进入到“D:\LoadRunner\classes”目录下，把整个“com”文件夹复制到“C:\j2sdk1.4.1\lib”，这样LoadRunner创建的所有Java Vuer脚本均可以直接调用；如果放到虚拟用户脚本的当前路径下，则只有当前的虚拟用户脚本可以调用。多台主机进行并发测试时，应该把编译好的类文件放到对应的虚拟用户脚本目录下。根据图7-1和图7-2所示新建一个Java虚拟用户脚本，并对照图7-17，输入同样的测试脚本，尤其要在代码开始处输入包的导入语句“import com.lr.test.*;”。

图7-17  Java虚拟用户示例脚本

l  运行虚拟用户脚本

点击Virtual User Generator 工具栏上的  图标开始执行脚本。正确的执行结果如图7-18所示，可以看到执行日志中有“System.out: HelloWord!”。如果运行不正确，读者可以参照前面的过程进行分析，同时检查JDK的路径设置。

图7-18  正确执行的虚拟用户脚本

与 C Vuser脚本相比，Java Vuser 脚本是先编译再执行，而C Vuser脚本是解释性的。VuGen在JDK安装路径内查找javac编译器，并在脚本内编译Java代码。该阶段由VuGen窗口底部的“正在编译... ”状态消息来指示。如果在编译期间出错，则这些错误将在执行日志中列出。

测试脚本保存后，接下来可以放到Controller中来运行，读者可以自己进行实验。需要注意的是，如果进行多台计算机联机测试，则所有运行测试脚本的客户机必须安装JDK环境并正确设置路径，否则将会出现如图7-19所示的提示。

图7-19  JDK环境不正确的提示

要想正确使用Java虚拟用户，首先要保证测试环境配置正确。执行测试时，可以先用本节的示例程序来检查环境是否正确，然后再进行复杂功能的开发。

2  LoadRunner的Java API

LoadRunner为访问Vuser函数提供了特定的 Java API，这些函数都是lrapi.lr类的静态方法。借助Java API可以大大增强Java虚拟用户脚本的可用性。本节将介绍常用的Java API的用法，更多的函数及其用法读者可以参考LoadRunner联机手册。

在Java虚拟用户中，Java API函数的用法与Vuser函数中的用法基本一致，只是写法稍稍不同，更符合Java语言的特点。

1. 事务函数（Transaction Functions）

（1）int lr.start_transaction( String transaction_name )：标记事务开始；

（2）int lr.end_transaction ( String transaction_name, int status )：标记事务结束。

2. 信息函数（Informational Functions）

（1）String lr.get_group_name( )：返回 Vuser 组的名称；

（2）String lr.get_host_name( )：返回执行 Vuser 脚本的负载生成器的名称；

（3）String lr.get_master_host_name ( )：返回运行Controller计算机的名称；

（4）int lr.get_scenario_id( )： 返回当前方案的ID；

（5）int lr.get_vuser_id( ) ：返回当前 Vuser 的ID。

3. 运行时函数（Run-Time Functions）

（1）void lr.peek_events ( );：指示可以暂停Vuser 脚本的位置；

（2）int lr.rendezvous( String rendezvous_name )：在 Vuser 脚本中设置集合点；

（3）void lr.think_time( double time )：暂停脚本执行，模拟实际用户操作之间的思考时间。

4. 字符串函数（String Functions）

（1）String lr.eval_string ( String instring )：用当前值替换参数；

（2）int lr.eval_int ( String name )：用整型值替换参数；

（3）int lr.next_row ( String dat_file )：指示使用指定参数的下一行数据。

5. 消息函数（Message Functions）

（1）int lr.debug_message( int message_level, String message)：向输出窗口发送测试过程的调试消息；

（2）int lr.error_message ( String message )：向Vuser日志文件和输出窗口发送错误消息以及位置的详细信息；

（3）int lr.log_message ( String message )：向 Vuser 日志文件发送消息；

（4）int lr.message ( String message )：向输出窗口发送消息；

（5）int lr.output_message ( String message )：向日志文件和输出窗口发送消息和位置信息；

（6）int lr.vuser_status_message ( String message )：向Controller窗口中的“Vuser状态”区域发送消息。

众所周知，Java语言是一门非常适合网络开发的语言，用 Java语言进行性能测试脚本开发将会大大提高测试开发效率。LoadRunner中提供了对Java虚拟用户的支持。Java虚拟用户依托于JDK，这大大扩充了LoadRunner的脚本开发功能。测试人员既可以用Java虚拟用户来测试基于Java的应用系统的性能，又可以使用Java语言的强大开发脚本功能来测试其他平台的系统性能。

本章将和读者一起探索LoadRunner的Java世界，重点讨论如何开发Java自定义的虚拟用户脚本。本章主要内容如下：

n  认识Java虚拟用户

n  Java脚本开发基础

n  Java算法测试案例

7.1  认识Java虚拟用户

7.1.1  Java虚拟用户协议

Java虚拟用户脚本主要有Java Vuser、Corba-Java、RMI-Java、EJB等类型。这些类型的虚拟用户脚本均可以用Java语言来手工编写。下面将对各类Java虚拟用户简单地进行介绍。

Java Vuser

Java Vuser是自定义的Java虚拟用户脚本，脚本中可以使用标准的Java语言。这种虚拟用户不可以录制，只能采用纯手工编写，其适用范围和C Vuser一样，非常广泛。

本章主要探讨Java Vuser的开发方法。

Corba-Java

Corba-Java类型的虚拟用户主要用来测试用Java编写的、使用Corba应用程序或小程序的性能，用户可以先运行VuGen录制的脚本，然后使用标准的Java库函数以及LoadRunner特有的Java方法来增强该脚本。

RMI-Java

RMI-Java 虚拟用户适用于测试RMI（远程方法调用）Java应用程序或小程序。选择RMI-Java 用户进行录制，VuGen可以创建对应的Java脚本。完成录制后，可以使用JDK或自定义类，通过标准的Java代码来增强或修改脚本，还可以通过特定于LoadRunner的Java方法增强该脚本。

EJB

EJB虚拟用户专门用于测试Enterprise Java Beans对象。采用EJB协议，VuGen会自动创建脚本以测试EJB功能，无需录制或编程，这和标准的Java Vuser明显不同。

在使用EJB协议类型的虚拟用户生成脚本前，需要指定 JNDI属性和关于应用程序服务器的其他信息。LoadRunner的EJB检测器首先扫描应用程序服务器并确定哪些EJB可用；接着选择要测试的 EJB，LoadRunner将生成要测试每个EJB方法的脚本，并为每个方法创建事务，便于度量其性能并找出问题。

需要注意的是，创建EJB虚拟用户测试脚本必须在应用程序服务器主机上安装LoadRunner EJB检测器，而且检测器必须处于活动状态。EJB检测器是一个独立的代理程序，必须将其安装在要扫描查找EJB的每一台计算机上。安装EJB检测器前，计算机上还需要安装有效的JDK环境。

本书中将以Java Vuser为例来讲解Java虚拟用户的开发和使用方法。Corba-Java、RMI-Java、EJB、Jacada Vuser等类型的虚拟用户使用方法可以参考LoadRunner的联机帮助手册，但是其手工脚本的开发方法与Java Vuser是一样的。

在“新建虚拟用户”对话框中的“自定义”或“全部协议”类别下选择“Java Vuser”即可创建空的Java Vuser脚本，如图7-1所示。

在自动生成的脚本中，vuser_init、 vuser_end部分没有任何内容，Actions部分生成的脚本如图7-2所示。对于Java类型的虚拟用户，可以编辑Actions类，而 init、end部分则不可以进行编辑。在Actions类中，有三个方法init、action和end，通常在init方法中编写初始化代码、在 action方法中编写业务流程、在end方法中编写诸如释放资源之类的代码。

Java Vuser脚本中可以放置任何标准Java代码，这也是Java虚拟用户的魅力所在。

7.1.2  Java虚拟用户适用范围

LoadRunner完全支持C语言，原则上可以用C语言实现任何想要录制的功能。但是C语言的特点决定了这样做是不现实的：一是性能测试脚本开发成本非常高；二是很多企业的测试人员开发基础不好。因此，性能测试开发多选用C++、C#、Java等面向对象语言——因为这类语言既有成熟的集成开发工具，又有庞大的类库来支撑，测试脚本开发速度会更快。下一章将重点介绍如何用.NET来开发性能测试脚本。

Java虚拟用户适用范围非常广，归纳起来主要有两大类：一类是不太适合录制的业务功能点的性能测试，例如网页上Http文件的下载过程、视频播放等；另一类是基于Java语言开发的应用系统的性能测试，这类应用更适合采用Java虚拟用户进行测试。

用Java Vuser实现无法录制的测试需求

这类测试需求往往关注于对服务器产生的压力，重点测试在一定压力下服务器的负载情况，为评估、部署、调优系统提供参考。在这类测试工作中，Java的作用仅是一门语言，用于辅助测试人员完成测试程序的开发。

在性能测试工作中，不能录制的测试点很多，主要有以下几类：

l  含有控件的Web应用

在Web应用中，很多包含一些插件的浏览器应用经常不能录制。这类应用往往涉及很多协议，因此录制起来不是特别方便。

对于这类应用，可以用Java语言调用其功能来完成用户行为的模拟。

l  一些和媒体播放、文件下载等相关的应用

媒体播放或文件下载等过程的录制往往不容易控制，如果是应用基于P2P的协议，则会更加复杂。因此，这类测试只能由测试人员开发虚拟用户脚本来完成。

用Java Vuser测试基于Java语言的应用系统性能

相比前面，基于Java语言开发的应用系统，在性能测试中采用Java虚拟用户更显得“门当户对”。这类虚拟用户主要应用在下面两类测试中：

l  核心算法或业务的执行效率

对银行、电信等大型的基于J2EE的架构应用系统中，开发阶段的性能测试是必不可少的。为了降低后期遇到性能问题的风险，往往在开发阶段进行一些核心业务的性能测试。这些核心业务或要求较高的执行效率，或者要求支持较多用户的并发。因此，可以利用Java Vuser来测试这些业务的执行效率。

l  Java应用中不能录制的业务模块

很多时候，一些J2EE架构的业务系统用 LoadRunner录制起来不是特别方便，例如一些Java智能客户端程序。这时可以手工编写测试代码，完成测试任务。与非Java应用相比，Java 应用中不能录制的业务功能更适合采用Java虚拟用户，因为可以直接对一些方法进行调用。

由于Java语言的强大功能，Java虚拟用户的应用远不止上面这些，读者可以慢慢挖掘。

Http客户端程序已集成在Java语言中，可以通过URLConnection类调用。遗憾的
是，由于SUN没有公布Http客户程序的源码，它实现的细节仍是一个谜。本文根据HTTP
协议规范，用Java.net.Socket类实现一个HTTP协议客户端程序。

1.Socket类:
了解TCP/IP协议集通信的读者知道，协议间的通信是通过Socket完成的。在
Java.net包中，Socket类就是对Socket的具体实现。它通过连接到主机后，返回一个
I/O流，实现协议间的信息交换。

2.HTTP协议
HTTP协议同其它TCP/IP协议集中的协议一样，是遵循客户/服务器模型工作的。客
户端发往服务端的信息格式如下:
------------------------------
请求方法URLHTTP协议的版本号
提交的元信息
**空行**
实体
------------------------------
请求方法是对这次连接工作的说明，目前HTTP协议已经发展到1.1版，它包括GET、
HEAD、POST、DELETE、OPTIONS、TRACE、PUT七种。元信息是关于当前请求的信息。通
过分析元信息，可以检查实体数据是否完整，接收过程是否出错，类型是否匹配等。元
信息的引入使HTTP协议通信更加稳妥可靠。实体是请求的具体内容。
将上述报文发往Web服务器，如果成功，应答格式如下:
--------------------------------
HTTP协议的版本号应答状态码应答状态码说明
接收的元信息
**空行**
实体
--------------------------------
以上报文发向客户端，并且接收成功，彼此间关闭连接，完成一次握手。
下面用最常用的GET方法，来说明具体的报文应用
----------------------------------
GEThttp://www.youhost.comHTTP/1.0
accept:www/source;text/html;image/gif;image/jpeg;*/*
User_Agent:myAgent
**空行**
-----------------------------------
这个报文是向www.youhost.com主机请求一个缺省HTML文档。客户端HTTP协议版本
号是1.0版，元信息包括可接收的文件格式，用户代理，每一段之间用回车换行符分
隔，最后以一个空行结束。发向服务器后，如果执行过程正常，服务器返回以下代码:
------------------------------------
HTTP/1.1200OK
Date:Tue,14Sep199902:19:57GMT
Server:Apache/1.2.6
Connection:close
Content-Type:text/html
**空行**
<html><head>...</head><body>...</body></html>
------------------------------------
HTTP/1.1表示这个HTTP服务器是1.1版，200是服务器对客户请求的应答状态码，OK
是对应答状态码的解释，之后是这个文档的元信息和文档正文。(相关应答状态码和元
信息的解释请参阅Inetrnet标准草案:RFC2616)。

Http.java


importjava.net.*;
importjava.io.*;
importjava.util.Properties;
importjava.util.Enumeration;

publicclassHttp{
protectedSocketclient;
protectedBufferedOutputStreamsender;
protectedBufferedInputStreamreceiver;
protectedByteArrayInputStreambyteStream;
protectedURLtarget;
privateintresponseCode=-1;
privateStringresponseMessage="";
privateStringserverVersion="";
privatePropertiesheader=newProperties();
publicHttp(){}
publicHttp(Stringurl){
GET(url);
}

/*GET方法根据URL，会请求文件、数据库查询结果、程序运行结果等多种内容*/
publicvoidGET(Stringurl){
try{
checkHTTP(url);
openServer(target.getHost(),target.getPort());
Stringcmd="GET"+getURLFormat(target)+"HTTP/1.0\r\n"
+getBaseHeads()+"\r\n";
sendMessage(cmd);
receiveMessage();
}catch(ProtocolExceptionp){
p.printStackTrace();
return;
}catch(UnknownHostExceptione){
e.printStackTrace();
return;
}catch(IOExceptioni){
i.printStackTrace();
return;
}
}

/*
*HEAD方法只请求URL的元信息，不包括URL本身。若怀疑本机和服务器上的
*文件相同，用这个方法检查最快捷有效。
*/
publicvoidHEAD(Stringurl){
try{
checkHTTP(url);
openServer(target.getHost(),target.getPort());
Stringcmd="HEAD"+getURLFormat(target)+"HTTP/1.0\r\n"
+getBaseHeads()+"\r\n";
sendMessage(cmd);
receiveMessage();
}catch(ProtocolExceptionp){
p.printStackTrace();
return;
}catch(UnknownHostExceptione){
e.printStackTrace();
return;
}catch(IOExceptioni){
i.printStackTrace();
return;
}
}


/*
*POST方法是向服务器传送数据，以便服务器做出相应的处理。例如网页上常用的
*提交表格。
*/
publicvoidPOST(Stringurl,Stringcontent){
try{
checkHTTP(url);
openServer(target.getHost(),target.getPort());
Stringcmd="POST"+getURLFormat(target)+"HTTP/1.0\r\n"+getBaseHeads();
cmd+="Content-type:application/x-www-form-urlencoded\r\n";
cmd+="Content-length:"+content.length()+"\r\n\r\n";
cmd+=content+"\r\n";
sendMessage(cmd);
receiveMessage();
}catch(ProtocolExceptionp){
p.printStackTrace();
return;
}catch(UnknownHostExceptione){
e.printStackTrace();
return;
}catch(IOExceptioni){
i.printStackTrace();
return;
}
}

protectedvoidcheckHTTP(Stringurl)throwsProtocolException{
try{
URLtarget=newURL(url);
if(target==null||!target.getProtocol().toUpperCase().equals("HTTP"))
thrownewProtocolException("这不是HTTP协议");
this.target=target;
}catch(MalformedURLExceptionm){
thrownewProtocolException("协议格式错误");
}
}

/*
*与Web服务器连接。若找不到Web服务器，InetAddress会引发UnknownHostException
*异常。若Socket连接失败，会引发IOException异常。
*/
protectedvoidopenServer(Stringhost,intport)throws
UnknownHostException,IOException{
header.clear();
responseMessage="";responseCode=-1;
try{
if(client!=null)closeServer();
if(byteStream!=null){
byteStream.close();byteStream=null;
}
InetAddressaddress=InetAddress.getByName(host);
client=newSocket(address,port==-1?80:port);
sender=newBufferedOutputStream(client.getOutputStream());
receiver=newBufferedInputStream(client.getInputStream());
}catch(UnknownHostExceptionu){
throwu;
}catch(IOExceptioni){
throwi;
}
}

/*关闭与Web服务器的连接*/
protectedvoidcloseServer()throwsIOException{
if(client==null)return;
try{
client.close();sender.close();receiver.close();
}catch(IOExceptioni){
throwi;
}
client=null;sender=null;receiver=null;
}

protectedStringgetURLFormat(URLtarget){
Stringspec="http://"+target.getHost();
if(target.getPort()!=-1)
spec+=":"+target.getPort();
returnspec+=target.getFile();
}

/*向Web服务器传送数据*/
protectedvoidsendMessage(Stringdata)throwsIOException{
sender.write(data.getBytes(),0,data.length());
sender.flush();
}

/*接收来自Web服务器的数据*/
protectedvoidreceiveMessage()throwsIOException{
bytedata[]=newbyte[1024];
intcount=0;
intword=-1;
//解析第一行
while((word=receiver.read())!=-1){
if(word=='\r'||word=='\n'){
word=receiver.read();
if(word=='\n')word=receiver.read();
break;
}
if(count==data.length)data=addCapacity(data);
data[count++]=(byte)word;
}
Stringmessage=newString(data,0,count);
intmark=message.indexOf(32);
serverVersion=message.substring(0,mark);
while(mark<message.length()&&message.charAt(mark+1)==32)mark++;
responseCode=Integer.parseInt(message.substring(mark+1,mark+=4));
responseMessage=message.substring(mark,message.length()).trim();

//应答状态码和处理请读者添加
switch(responseCode){
case400:
thrownewIOException("错误请求");
case404:
thrownewFileNotFoundException(getURLFormat(target));
case503:
thrownewIOException("服务器不可用");
}
if(word==-1)thrownewProtocolException("信息接收异常终止");
intsymbol=-1;
count=0;
//解析元信息
while(word!='\r'&&word!='\n'&&word>-1){
if(word=='\t')word=32;
if(count==data.length)data=addCapacity(data);
data[count++]=(byte)word;
parseLine:{
while((symbol=receiver.read())>-1){
switch(symbol){
case'\t':
symbol=32;break;
case'\r':
case'\n':
word=receiver.read();
if(symbol=='\r'&&word=='\n'){
word=receiver.read();
if(word=='\r')word=receiver.read();
}
if(word=='\r'||word=='\n'||word>32)breakparseLine;
symbol=32;break;
}
if(count==data.length)data=addCapacity(data);
data[count++]=(byte)symbol;
}
word=-1;
}
message=newString(data,0,count);
mark=message.indexOf(':');
Stringkey=null;
if(mark>0)key=message.substring(0,mark);
mark++;
while(mark<message.length()&&message.charAt(mark)<=32)mark++;
Stringvalue=message.substring(mark,message.length());
header.put(key,value);
count=0;
}
//获得正文数据
while((word=receiver.read())!=-1){
if(count==data.length)data=addCapacity(data);
data[count++]=(byte)word;
}
if(count>0)byteStream=newByteArrayInputStream(data,0,count);
data=null;
closeServer();
}

publicStringgetResponseMessage(){
returnresponseMessage;
}

publicintgetResponseCode(){
returnresponseCode;
}

publicStringgetServerVersion(){
returnserverVersion;
}

publicInputStreamgetInputStream(){
returnbyteStream;
}

publicsynchronizedStringgetHeaderKey(inti){
if(i>=header.size())returnnull;
Enumerationenum=header.propertyNames();
Stringkey=null;
for(intj=0;j<=i;j++)
key=(String)enum.nextElement();
returnkey;
}

publicsynchronizedStringgetHeaderValue(inti){
if(i>=header.size())returnnull;
returnheader.getProperty(getHeaderKey(i));
}

publicsynchronizedStringgetHeaderValue(Stringkey){
returnheader.getProperty(key);
}

protectedStringgetBaseHeads(){
Stringinf="User-Agent:myselfHttp/1.0\r\n"+
"Accept:www/source;text/html;image/gif;*/*\r\n";
returninf;
}

privatebyte[]addCapacity(byterece[]){
bytetemp[]=newbyte[rece.length+1024];
System.arraycopy(rece,0,temp,0,rece.length);
returntemp;
}


publicstaticvoidmain(String[]args){
Httphttp=newHttp();
//http.GET("http://192.168.1.5");
inti;
for(i=0;i<50000;i++){
http.GET("http://www.model-dl.com/modelinfo.asp?modelid=101");
http.POST("http://www.model-dl.com/modelinfo.asp?modelid=101","ratecontd=101&MM_insert=form1");
}
}

}

http://www.cnpaf.net/Class/HTTP/200408/74.html

C:\Documents and Settings\Administrator\Application Data\Microsoft\Templates

这个是在51上转载的。。

http://bbs.51testing.com/thread-158267-1-1.html

多谢楼主的奉献。。。

#include<lrd.h>
static LRD_INIT_INFO InitInfo={LRD_INIT_INFO_EYECAT};
static LRD_DEFAULT_DB_VERSION DBTypeVersion[]={{LRD_DBTYPE_NONE,LRD_DBVERSION_NONE}};

//这里的LRD_VAR_DESC数据结构声明是很重要的，他是用来存储sql结果数据集的结构体，第一个参数头文件中就是这么写的，第二个参数是最大行数，第三个参数是每一行的最大长度，如果获得的查询结果比定义的长，运行时就会报错，提示列被截断，最后一个参数是查询结果的类型，可以再帮助中的索引输入data types, database，列出的表格中是各种变量类型的名称
static LRD_VAR_DESC NUM ={LRD_VAR_DESC_EYECAT, 10, 32, LRD_DBTYPE_ORACLE, {1, 1, 0},DT_LONG_VARCHAR};

//下面这些句柄等变量的申请都可以照着帮助中的例子写
static void FAR * OraEnv1;
static void FAR * OraSvc1;
static void FAR * OraSrv1;
static void FAR * OraSes1;
static void FAR * OraStm1;
static void FAR * OraDef1;
unsigned long rownum;

vuser_init()
{
//初始化数据库  
lrd_init(&InitInfo,DBTypeVersion);
lrd_initialize_db(LRD_DBTYPE_ORACLE,3,0);
lrd_env_init(LRD_DBTYPE_ORACLE,&OraEnv1,0,0);
lrd_ora8_handle_alloc(OraEnv1,SVCCTX,&OraSvc1,0);
lrd_ora8_handle_alloc(OraEnv1,SERVER,&OraSrv1,0);
lrd_ora8_handle_alloc(OraEnv1,SESSION,&OraSes1,0);

//设置数据库名称，我的是oracle，odbc中连接数据库名称就是这个
lrd_server_attach(OraSrv1,"julang",-1,0,0);
lrd_ora8_attr_set_from_handle(OraSvc1,SERVER,OraSrv1,0,0);

//用户名和密码
lrd_ora8_attr_set(OraSes1,USERNAME,"netid",-1,0);
lrd_ora8_attr_set(OraSes1,PASSWORD,"111111",-1,0);
lrd_ora8_attr_set_from_handle(OraSvc1,SESSION,OraSes1,0,0);
lrd_session_begin(OraSvc1,OraSes1,1,0,0);
lrd_ora8_handle_alloc(OraEnv1,STMT,&OraStm1,0);
return 0;
}

//--------------------------------------------------------

Action()
{
//这里写上你的sql语句（我主要是需要查询的结果，如果你是插入或修改记录就不用往后看了）

    //Select  verifycode From mobileverify Where Data='101592' and   mobileverifyid ='1409'
//lrd_ora8_stmt(OraStm1,"select count(*) from codelist where status =2",1,0,0);

 lrd_ora8_stmt(OraStm1,"Select  verifycode From mobileverify Where Data='{usercode}' and   mobileverifyid ='{mobileverifyid}'",1,0,0);

//执行定义的sql，并且将结果行数返回到rownum中
lrd_ora8_exec(OraSvc1,OraStm1,0,0,&rownum,0,0,0,0,1);

//绑定该列
lrd_ora8_bind_col(OraStm1,&OraDef1,1,&NUM,0,0);

//设定保存列中的某个数据到row中，第二个参数为第几列，第三个参数为第几行（只能保存一个值），最后一个参数就是你想要保存到的parameter名称
lrd_ora8_save_col(OraStm1, 1, 1, 0, "result");

//这个遍历刚才查询的结果，第二个参数0表示就1行，负号表示遍历所有结果，绝对值表示实际有多少行，第三个参数表示一次遍历最大进行多少行（不能大于LRD_VAR_DESC中定义的第二个参数，即最大行数）
lrd_ora8_fetch(OraStm1, -2, 2 ,&rownum, 0, 2, 0, 0);

//这里我用error是为了看得醒目，不要认为是出错了
lr_error_message("sql result: %s", lr_eval_string("{result}"));

return 0;
}

//--------------------------------------------------------

vuser_end()
{
lrd_session_end(OraSvc1, OraSes1, 0, 0);
lrd_server_detach(OraSrv1, 0, 0);
lrd_handle_free(&OraEnv1, 0);
return 0;
}
//到此就结束了，但是这个东西目前我只是支持取出一个结果放到parameter中，还搞不懂如和将所有数据放入parameter中，来作为自动化时多用户使用的参数。在此抛砖引玉，希望有达人能够解决！！！
//另外要注意的是，如果你是录制了一个http协议的脚本，那么编译时无法通过的，需要创建一个odbc和http协议的混合脚本写入这些代码，然后再创建一个http脚本进行录制，然后将http中录制的脚本内容拷贝过来。俺也不知道为什么，如果我先录制脚本再插入这些代码总是提示lrd_init()未知错误：
//vuser_init.c(19): Error: C interpreter run time error: vuser_init.c (19):  Error -- Unresolved symbol : lrdfnc_init.
//vuser_init.c(19): Notify: CCI trace: Compiled_code(0): vuser_init()

因为第一次弄，又不熟悉VBS，弄了半天，多谢网上的各位前辈提供的资料

实现效果：连接Oracle数据库，在里面查出数据，并逐行显示

最后的脚步，如下：

Dim Conn
Set Conn = CreateObject("ADODB.Connection")

'----------------------------------------------------------
'方法一： '利用*.udl文件，建立连接后，复制地址
'Conn.ConnectionString = "Provider=OraOLEDB.Oracle.1;Password=jonathan;Persist Security Info=True;User ID=system;Data Source=jonathan;Server=192.168.1.25"
'      conn.open= "Provider=OraOLEDB.Oracle.1; Password=密码; Persist Security Info=True;User ID=用户名;Data Source=数据源服务名;Server=数据库服务器地址"         '利用*.udl文件
'-------------------------------------------------------------

'方法二： 添加数据库检查点，复制那个ConnectionString 
 Conn.ConnectionString =  "DSN=192.168.1.25;UID=SYSTEM;PWD=JONATHAN;DBQ=JONATHAN;DBA=W;APA=T;EXC=F;FEN=T;QTO=T;FRC=10;FDL=10;LOB=T;RST=T;GDE=F;FRL=F;BAM=IfAllSuccessful;MTS=F;MDI=F;CSR=F;FWC=F;PFC=10;TLO=0;"
Conn.Open

'查看是否连接成功，成功状态值为1
'msgbox Conn.state
If Conn.State = 0 Then
     msgbox  "连接数据库失败"
else
    msgbox   "连接数据库成功"
End If

''创建数据库记录集对象(也就是查询结果)
Set res = createobject("ADODB.Recordset") 

''打开以指定查询语句查询所得的记录集 
res.Open"select * from qtp",conn,2,2  

'从查询结果的指定字段取出值,循环输出

while(not Res.eof)

userid = res("userid")
username = res("name")
password = res("password")

msgbox userid
msgbox username
msgbox password
Res.MoveNext
wend

'msgbox res("userid")
'msgbox res("name")
'msgbox res("password")

res.close        '关闭记录集
Set res=nothing        '释放对象
conn.close        '关闭连接
Set conn=nothing        '释放对象

=============================================================

一、利用*.udl文件获得连接字符串的方法：

1、新建个空的文本文件，然后重命名为test.udl


2、双击打开test.udl，在Provider中选择Oracle Provider for OLE DB


3、点击Next或者上面的Connection标签，在DataSource中输入数据库服务器的网络名称(网址)，并输入登录数据库的用户名和密码，注意保存密码上打勾


4、点击 Test Connection，若测试通过，则点OK退出该udl文件

5、右键点击test.udl，选择用记事本打开，有没发现你要写的连接字符串已经乖乖躺在那里了~赶紧Ctrl+C,Ctrl+V吧~

二、利用插入数据库检查点的方法，获得连接字符串，就不说了

    Insert--->CheckPoint---->Database Checkpoint---->

其他：

有位仁兄说:odbc的文件数据源方式估计快淘汰了

看来要弄个更加通用的连接方法，继续摸索……

\,Q@'N6O'W;e/^2028481.标准检查点（Standard Checkpoint）检查对象的属性，如可以检查某个按钮的是否被选取；51Testing软件测试网#y4{+SF@*@,DMw
2.页面检查点（Page Checkpoint） 检查网页的特性，如可以检查加载页面所需的时间，或者检查网页是否包含损坏的链接；
9xsI8af Na2028483.图片检查点（Image Checkpoint）检查应用程序或网页中的图像的值，如可以检查所选图像的源文文件是否正确；
%S"n%r
G.u\!Q
A c2028484.位图检查点（Bitmap Checkpoint）检查位图格式的网页或应用程序区域；如。被测应用程序中有一个按钮，显示<查看文档>其中<号码>会被输入到应用程序中其它位置窗体的四位数字代码替换。可以创建一个文本区域检查点，以确认在该按钮上显示与窗体中的号码相同；
'ctF9KQ
cz?0[!V2028485.文本检查点（Text Checkpoint）检查网页或窗口中的文字内容是否正确；51Testing软件测试网0~eP*{9T!Rw
6.文本区域检查点（Text Area Checkpoint）检查网页或窗口中的文字是否在指定的区域显示；51Testing软件测试网O ^ R.DHN
7.表检查点（Table Checkpoint）检查表内部信息，假设被测试应用程序包含一个表，改表列出了从纽约到旧金山所有可用航班。可以添加一个表检查点，以检查该表中的第一个航班的时间是否正确；
)C S*Ao,G&tHje2028488.数据库检查点（Database Checkpoint）检查由应用程序访问的数据库到内容，如使用数据库检查点来检查网站上包含航班信息的数据库内容；51Testing软件测试网*s/n t6Q Q p)s0o-\

vU|@5q2028489.Output Value 输出值检查，如输出网页中某一图片的属性（长宽高等）；51Testing软件测试网a G l6JY4Q
10.可访问性检查点（Accessibility Checkpoint）对网站区域属性进行识别，以检查是否符合可访问性规则的要求；51Testing软件测试网#V~/cD(L pV
11.XML检查点（XML Checkpoint） 检查xml文件数据内容；51Testing软件测试网}B`7[2|2x_0rVg~

-----------------------------------------------------------51Testing软件测试网CdQ;@K

51Testing软件测试网oBI_-]3Z

1) 理解检查点51Testing软件测试网#`/|9qVV

QuickTest enables you to add checks to yourtestor component.51Testing软件测试网8V^Z$Ve

检查点比较指定属性的当前值与期望值，以判断当前的程序（或站点）功能是否正常。

当你增加了一个检查点以后，在KeyWord模式下会增加一个CheckPoint，在Expert模式下会增加一条CheckPoint语句。在运行测试时，QTP比较CheckPoint的期望值与当前值，如果结果不匹配，则检查点失败，你可以在TestResults窗口中查看到检查点的结果。51Testing软件测试网'[S&~TR%w2ow+W5@
?

如果你想获取 checkpoint的返回值（一个布尔值，表示检查成功或失败），你必须在专家模式下将checkpoint 参数两端加上括号。如51Testing软件测试网"m_TgN;`;I

a = browser("MyBrowser").page("MyPage").check (checkPoint("MyProperty"))

 51Testing软件测试网9F8i_*x1[Y?.]T ]

2) 向测试脚本中添加检查点

可以在录制脚本的过程中添加，也可以在修改脚本的过程中添加。51Testing软件测试网f5L_\ _!O'fW

途径：菜单 Insert－checkpoint、或按钮；在Keywork视图中选择一个STEP，然后选右键菜单Insert Standard Checkpoint；在Active Screan中选择任意一个object，然后选右键菜单Insert Standard Checkpoint。51Testing软件测试网a} @ ` w

 51Testing软件测试网-i.B~9E;FE4B[ W

3) checkpoint的种类：

可以在站点或应用程序中插入不同种类的checkpoint。51Testing软件测试网4tz(VS ^.pz

l         Standard Checkpoint （标准检查点）

检查程序或网页object的属性值，检查对象如buttons, radio buttons, combo boxes, lists, 等等。51Testing软件测试网
u}!i O$L;N b

标准检查点支持所有的add-in 环境 (see Supported Checkpoints).51Testing软件测试网,B;v2?)KPF,SC{a

l         Image Checkpoint （图像检查点）51Testing软件测试网:VL&@On

检查程序或网页中图像的值，如你可以检查图像 的源文件是否正确。51Testing软件测试网X H-]&o2a(o+K:F6M

注：你也可以给图片object插入一个标准检查点，这个标准检查点也是图像检查点。

l         Bitmap Checkpoint（图片检查点）

将程序或网页的某个区域作为一个图片，建立检查点。如，某个站点可以展示一个城市的地图，这个地图有控制地图缩放的按钮，你点击1次“zoom in”按钮后，录制下放大了的地图快照。通过建立bitmap 检查点，可以检查“zoom in”功能是否正确。51Testing软件测试网H y8K(eD

l         Table Checkpoint（表检查点）

检查一个表中的信息。例如，假设被测的程序或网站包括一个table，本table中包含了所有的从New York到San Fransisco的有效航班。你可以通过Table检查点来检查第1个航班的时间是否正确。51Testing软件测试网 PeSmp L+t$p

注意：你也可以通过为表Object插入标准检查点的方法创建表检查点。

l         Text Checkpoint（文本检查点）

检查位于程序或网站某个位置的字符串。例如，假设程序或网站显示“Flight departing from New York to San Francisco”的语句，你可以创建一个文本检查点检查"New York" 是否显示于"Flight departing from" 与 "to San Francisco"之间。

所有的add-in环境都支持文本检查点。51Testing软件测试网d"MT9U;Y?(]x

l         Text Area Checkpoint51Testing软件测试网iL$L5^5O"j hq:`

l         Accessibility Checkpoint51Testing软件测试网3` S|.B"T%N8y

l         Page Checkpoint

l         Database Checkpoint51Testing软件测试网N{]ACaX[

检查database的内容。例如，可以使用数据库检查点来检查包含航班信息的数据库的内容。

所有环境都支持数据库检查点。

l         XML Checkpoint51Testing软件测试网 \I(L0L"^ bG*q

l         下表是QTP中在不同环境下对各类检查点的支持情况。51Testing软件测试网0q"NJ:U;i.z7qK3?G,A

)e:q A#`'T#}5?d202848

{?6v:|'@202848---------------------------------------------