1. 一个特殊构造的程序

考虑下面这个专门为说明多线程中的死锁现象而构造的程序：

import java.util.LinkedList;

public class Stack {
public static void main(String[] args) {
   final Stack stack = new Stack();
   new Thread("push") {
    @Override
    public void run() {
     for(int i = 0; i < 100; i++)
     {
      try {
       Thread.sleep(10);
      } catch (InterruptedException e) {}
      stack.push("object " + i);
     }
    }   
   }.start();
   new Thread("pop") {
    @Override
    public void run() {
     for(int i = 0; i < 100; i++)
     {
      try {
       System.out.println(stack.pop());
      } catch (Exception e) {}
     }
    }   
   }.start();
}

LinkedList<Object> list = new LinkedList<Object>();
public synchronized void push(Object x) {
   System.out.println("begin to push " + x);
   synchronized (list) {
    list.addLast(x);
    notify();
   }
   System.out.println("end to push " + x);
}
public synchronized Object pop() throws Exception {
   System.out.println("begin to pop");
   synchronized (list) {
    if (list.size() <= 0) {
     wait();
    }
    return list.removeLast();
   }
}
}

该程序构造了一个 Stack，启动了两个线程。一个线程向 Stack 中添加数据，另外一个线程从 Stack 中取出数据并打印。但是运行程序后就会发现程序输出：

begin to pop
begin to push object 0

后，在再也没有后续输出了。

2. Dump 并分析线程状态

启动 jvisualvm 查看该程序线程的状态，将其 Dump，就可以得到以下结果：

"pop" prio=6 tid=0x02b11800 nid=0x3648 in Object.wait() [0x02eaf000..0x02eafd14]
   java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x22ee0000> (a Stack)
at java.lang.Object.wait(Object.java:485)
at Stack.pop(Stack.java:44)
- locked <0x22ee0010> (a java.util.LinkedList)
- locked <0x22ee0000> (a Stack)
at Stack$2.run(Stack.java:24)

   Locked ownable synchronizers:
- None

"push" prio=6 tid=0x02b28800 nid=0x4120 waiting for monitor entry [0x02e5f000..0x02e5fd94]
   java.lang.Thread.State: BLOCKED (on object monitor)
at Stack.push(Stack.java:35)
- waiting to lock <0x22ee0010> (a java.util.LinkedList)
- locked <0x22ee0000> (a Stack)
at Stack$1.run(Stack.java:14)

   Locked ownable synchronizers:
- None

可以看到，pop 线程正在运行 wait(); 语句，处于 WAITING 状态，同时，该线程锁住了 list 和 stack 对象。push 线程处于 BLOCKED 状态，等待其他线程释放 list 对象。

3. 运行过程及死锁原因分析

步骤	主程序	pop 线程	push 线程
1	启动
2	创建 stack 对象
3	创建 list 对象
4		启动
5			启动
6			sleep 10ms
7		调用 stack.pop()
8		锁住 stack 对象
9		打印 "begin to pop"
10		锁住 list 对象
11		调用 stack.wait() （暂时释放 stack 对象）
12			锁住 stack 对象
13			打印 "begin to push 0"
14			企图锁住 list 对象 (发现 list 已被其他线程锁住)
15	进入死锁状态

1. ServiceContext

ServiceContext 代表为 Hessian 客户端提供服务的上下文环境，用来处理与客户端请求有关的信息。在最简单和常用的应用中，在服务器端可以通过 ServiceContext 来获取代表客户端的 ServletRequest (在 HTTP 环境中为 HttpServletRequest)，因此就可以知道客户端的相关信息，如客户端的 IP 地址、端口、Header和用户名等，重要的是可以获取到代表会话的 Session 对象。

代码举例：
package example;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.caucho.services.server.ServiceContext;

public class BasicService implements Basic {
public String hello(String name) {
   System.out.println("======== hello ========\n");
   HttpServletRequest req = (HttpServletRequest) ServiceContext
     .getContextRequest();
   req.getSession().setAttribute("port", 1000);

   System.out.println("getRemoteAddr() = " + req.getRemoteAddr());
   System.out.println("getRemotePort() = " + req.getRemotePort());
   System.out.println("getRemoteUser() = " + req.getRemoteUser());
   System.out
     .println("getSession().getId() = " + req.getSession().getId());
   for (Enumeration<String> e = req.getHeaderNames(); e.hasMoreElements();) {
    String headerName = e.nextElement();
    System.out.println(headerName + " = " + req.getHeader(headerName));

   }

   return "Hello, " + name;
}
}
在上面的示例中，通过 ServiceContext 的静态方法 getContextRequest() 获取代表客户端请求的 HttpServletRequest 对象，然后就可以像普通 Web 编程那样使用 Request 和 Session 对象了。

2. Hessian 中 Sessian 的问题

一般来说，RPC 或 Web Service 这类的应用都是无状态的，但是有些应用则需要有状态的远程调用，比如先登录认证，然后再执行其他操作。
Hessian 本身也没有对有状态的应用提供直接支持。查看 HessianProxy 的代码可以发现，每次发送请求的时候，Hessain 都会调用 HessianProxyFactory 类的 openConnection 重新打开连接，并且在远程调用完成后关闭连接。

重新打开连接
protected URLConnection sendRequest(String methodName, Object []args)
    throws IOException
{
    URLConnection conn = null;
   
    conn = _factory.openConnection(_url);
    boolean isValid = false;

    try {
      // Used chunked mode when available, i.e. JDK 1.5.
      if (_factory.isChunkedPost() && conn instanceof HttpURLConnection) {
try {
   HttpURLConnection httpConn = (HttpURLConnection) conn;

   httpConn.setChunkedStreamingMode(8 * 1024);
} catch (Throwable e) {
}
      }
   
      addRequestHeaders(conn);

      OutputStream os = null;

      try {
os = conn.getOutputStream();
      } catch (Exception e) {
throw new HessianRuntimeException(e);
      }

      if (log.isLoggable(Level.FINEST)) {
PrintWriter dbg = new PrintWriter(new LogWriter(log));
os = new HessianDebugOutputStream(os, dbg);
      }
     
      AbstractHessianOutput out = _factory.getHessianOutput(os);

      out.call(methodName, args);
      out.flush();

      isValid = true;

      return conn;
    } finally {
      if (! isValid && conn instanceof HttpURLConnection)
((HttpURLConnection) conn).disconnect();
    }
}

关闭连接
public Object invoke(Object proxy, Method method, Object []args)
    throws Throwable
{
...
     
      conn = sendRequest(mangleName, args);

      if (conn instanceof HttpURLConnection) {
httpConn = (HttpURLConnection) conn;
        int code = 500;

        try {
          code = httpConn.getResponseCode();
        } catch (Exception e) {
        }

        parseResponseHeaders(conn);
    ...
       
      try {
if (httpConn != null)
   httpConn.disconnect();
      } catch (Exception e) {
log.log(Level.FINE, e.toString(), e);
      }
    }
}

在登录认证的应用中，在调用登录认证的方法后执行其他业务操作时，需要对用户是否登录进行验证，由于 Hessian 每次调用都会重新打开和关闭连接，因此每次调用都是一个新的 Session，前面是否登录的信息就不能获取到。

3. 扩展 Hessian 的客户端程序实现对 Sessian 的支持

HTTP 是一个无状态的协议，其状态的实现是通过 Cookie 来实现的，根据 HTTP 的这个特点，我们可以在 Hessian 客户端首次调用后的每次调用中，将首次调用得到的 Cookie 添加到 HTTP Header 中，从而模拟出有状态的 HTTP 连接。
通过查看 HessianProxy 类的代码发现，其中有两个没有实现内容方法，可以获取服务器端返回的头信息 和设置发送给服务器端的 HTTP 请求头信息：

/**
   * Method that allows subclasses to parse response headers such as cookies.
   * Default implementation is empty.
   * @param conn
   */
protected void parseResponseHeaders(URLConnection conn) {
  
}

/**
   * Method that allows subclasses to add request headers such as cookies.
   * Default implementation is empty.
   */
protected void addRequestHeaders(URLConnection conn) {
  
}

在使用 Hessian 进行远程调用时，addRequestHeaders 方法在 sendRequest 时调用，parseResponseHeaders 在成功发送请求后调用。因此我们可以扩展 HessianProxy 类，重新实现这两个方法，在首次调用时获取 Cookie 新，在随后的调用中 将 Cookie 添加到请求头信息中。
除了重新实现 HessianProxy 类外，还需要重新实现 HessianProxyFactory 类的 public Object create(Class api, String urlName, ClassLoader loader) 方法，以便让 HessianProxyFactory 使用重新实现的 HessianProxy 类。

重新实现的代码：
package example;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.List;

import com.caucho.hessian.client.HessianProxy;
import com.caucho.hessian.client.HessianProxyFactory;
import com.caucho.hessian.io.HessianRemoteObject;

public class MyHessianProxyFactory extends HessianProxyFactory {

@Override
public Object create(Class api, String urlName, ClassLoader loader)
    throws MalformedURLException {
   if (api == null)
    throw new NullPointerException(
      "api must not be null for HessianProxyFactory.create()");
   InvocationHandler handler = null;

   URL url = new URL(urlName);
   handler = new MyHessianProxy(url, this);

   return Proxy.newProxyInstance(loader, new Class[] { api,
     HessianRemoteObject.class }, handler);
}
}

class MyHessianProxy extends HessianProxy {
/** Variable for saving cookie list */
private List<String> cookies = null;

public MyHessianProxy(URL url, HessianProxyFactory factory) {
   super(url, factory);
}

/** Get cookie list from the headers of response */
@Override
protected void parseResponseHeaders(URLConnection conn) {
   List<String> _cookies = conn.getHeaderFields().get("Set-Cookie");
   if (_cookies != null)
    cookies = _cookies;
}

/** Add cookie list to request headers*/
@Override
protected void addRequestHeaders(URLConnection conn) {
   if (cookies != null) {
    for (String cookieString : cookies) {
     conn.setRequestProperty("Cookie", cookieString);
    }
   }
}

}

4. 应用举例
接口：
package example;

import java.util.List;

public interface Basic {

public boolean login(String user, String password);
public int giveMeMoney();
public void increaseMyMoney() throws Exception;
}

实现接口的服务：
package example;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.caucho.services.server.ServiceContext;

public class BasicService implements Basic {

public boolean login(String user, String password) {
   HttpServletRequest req = (HttpServletRequest) ServiceContext
   .getContextRequest();
   if (user.equals("user") && password.equals("password"))
   {
    req.getSession().setAttribute("user", user);
    return true;   
   }
   return false;
}
public int giveMeMoney()
{
   HttpServletRequest req = (HttpServletRequest) ServiceContext
   .getContextRequest();
   if(req.getSession().getAttribute("user") != null)
    return 1000;
   return 0;  
}
public void increaseMyMoney() throws Exception
{
   HttpServletRequest req = (HttpServletRequest) ServiceContext
   .getContextRequest();
   if(req.getSession().getAttribute("user") != null)
   {
    System.out.println(req.getSession().getAttribute("user") + "'s money increased!!!");
   }
   else
    throw new Exception("Invalid User");
   
}
}

客户端程序：
package example;
import java.net.MalformedURLException;

import com.caucho.hessian.client.HessianProxyFactory;

public class BasicClient {
public static void main(String []args) throws MalformedURLException
{
    String url = "http://127.0.0.1:8080/hproj/hello";

    HessianProxyFactory factory = new MyHessianProxyFactory();
    factory.setUser("tomcat");
    factory.setPassword("tomcat");
    Basic basic = (Basic) factory.create(Basic.class, url);

    try {
   basic.increaseMyMoney();
} catch (Exception e) {
     System.out.println("ERROR: " + e.getMessage());
}
    basic.login("user", "password");
    System.out.println(basic.giveMeMoney());
    try {
   basic.increaseMyMoney();
} catch (Exception e) {
     System.out.println("ERROR: " + e.getMessage());
}   
}
}

在客户端程序中，不在使用原来的 HessianProxyFactory， 而是使用重新实现的 MyHessianProxyFactory 类。

Hessian 这个轻量级 Web 服务框架的结构基本如下图所示：

对于 Hessian 的基本介绍，可以参见 Hessian 简介。在应用程序的实际开发中，情况往往比较复杂，但是 Hessian 是一个功能比较强大的 Web service 框架，提供了诸如访问受到 BASIC 认证保护的服务、传递Date、List、Map等常用类型以及对象等复杂数据类型的功能。

1. 使用 Basic 认证保护 Web 服务

如果没有认证机制，那么能够连接到 Web service 服务器上的客户端都有可能访问到 Web 服务。可以利用 Web 服务器的安全机制将 Web service 配置成 Basic 认证模式，这样访问 Web service 的客户端都必须提供用户名和密码才能访问。就 Tomcat 来说，对于在 Hessian 简介中介绍的应用，可以在 web.xml 增加一下内容来设置 hello 服务使用安全认证机制：

<!-- Define reference to the user database for looking up roles -->
<resource-env-ref>
    <description></description>
    <resource-env-ref-name>users</resource-env-ref-name>
    <resource-env-ref-type>org.apache.catalina.UserDatabase</resource-env-ref-type>
</resource-env-ref>

<!-- Define a Security Constraint on this Application -->
<security-constraint>
    <web-resource-collection>
      <web-resource-name>Hessian Example</web-resource-name>
      <url-pattern>/hello</url-pattern>
    </web-resource-collection>
    <auth-constraint>
       <role-name>tomcat</role-name>
    </auth-constraint>   
</security-constraint>

<!-- Define the Login Configuration for this Application -->
<login-config>
    <auth-method>BASIC</auth-method>
    <realm-name>Hessian Example</realm-name>
</login-config>

<!-- Security roles referenced by this web application -->
<security-role>
    <description></description>
    <role-name>tomcat</role-name>
</security-role>

这样，只有属于 tomcat 这个角色的用户才能访问 hello 服务。
相应地，在编写 Hessian 客户端程序的时候，就必须提供用户名和密码，才能访问。HessianProxyFactory 提供了 setUser() 和 setPassword() 两个方法用来设置用户名和密码。对于上述应用，应该在代码中添加：

    factory.setUser("tomcat");
    factory.setPassword("tomcat");

2. 让 Web service 返回数组

在 Basic.java 接口中增加方法：

public String[] getNames();

在 BasicService.java 中实现该方法：

public String[] getNames() {
   return new String[] { "Apache", "Tomcat", "Hessian" };
}

在客户端可以这样访问：

    String[] names = basic.getNames();
    for(int i = 0; i < names.length; i++)
    {
        System.out.println(names[i]);
    }

3. 让 Web service 返回一个对象

（1）不成功的做法
创建一个简单 JavaBean 类 Person，只包含三个属性：
package example;

import java.util.Date;

public class Person{
private int id = 0;
private String name = "";
private Date birthday = null;

public Person(int id, String name, Date birthday) {
   super();
   this.id = id;
   this.name = name;
   this.birthday = birthday;
}

public int getId() {
   return id;
}
public void setId(int id) {
   this.id = id;
}
public String getName() {
   return name;
}
public void setName(String name) {
   this.name = name;
}
public Date getBirthday() {
   return birthday;
}
public void setBirthday(Date birthday) {
   this.birthday = birthday;
}

}

在接口中定义：

public Person getPerson(int id);

在服务类中实现：

public Person getPerson(int id) {
   Person p = null;
   switch (id) {
   case 1:
    p = new Person(1, "Tom", new java.util.Date(1980, 1, 1));
    break;
   case 2:
    p = new Person(2, "Rose", new java.util.Date(1981, 1, 1));
    break;
   default:
    break;
   }
   return p;
}

客户端程序
   
    Person p = basic.getPerson(1);
    System.out.println(p.getName());

运行客户端程序，抛出异常：

Exception in thread "main" com.caucho.hessian.client.HessianConnectionException: 500: java.io.IOException: Server returned HTTP response code: 500 for URL: http://127.0.0.1:8080/htest/hello
at com.caucho.hessian.client.HessianProxy.invoke(HessianProxy.java:202)
at $Proxy0.getPerson(Unknown Source)
at example.BasicClient.main(BasicClient.java:25)

查看服务器日志，得到异常信息：
java.lang.IllegalStateException: Serialized class example.Person must implement java.io.Serializable
at com.caucho.hessian.io.SerializerFactory.getDefaultSerializer(SerializerFactory.java:262)
at com.caucho.hessian.io.SerializerFactory.getSerializer(SerializerFactory.java:234)
at com.caucho.hessian.io.Hessian2Output.writeObject(Hessian2Output.java:406)
...

异常提示 example.Person 必须实现 java.io.Serializable 接口。

（2）Serializable 和序列化
对于简单数据类型，如int, double, char，数组等，以及常用的一些类型，如String，java.util.Date，List, Map等，Hessian 本身对其进行了特殊处理，也就是 Hessian 对其进行了序列化操作，但是 Hessian 不可能了解其他的类以及在您的应用程序中使用的那些类。对于这些类，Hessian 则要求这些类本身能够被序列化，也就是要求这些必须实现 Serializable 接口。

（3）正确的做法
让 Person 实现 Serializable 接口，则 Person.java 应该被修改成：
package example;

import java.io.Serializable;
import java.util.Date;

public class Person implements Serializable{
private int id = 0;
private String name = "";
private Date birthday = null;
...

重新启动 Web 服务器，就可以成功运行客户端程序了。

4. 让 Web service 返回一个包含 Person 对象 List

在 Basic.java 接口中增加方法：

public List<Person> listPersons();

在 BasicService.java 中实现该方法：

public List<Person> listPersons() {
   List<Person> list = new ArrayList<Person>();
   list.add(new Person(1, "Tom", new java.util.Date(1980, 1, 1)));
   list.add(new Person(2, "Rose", new java.util.Date(1981, 1, 1)));
   return list;
}

在客户端可以这样访问：

    List<Person> list = basic.listPersons();
    System.out.println(list.size());
   

说到 web service，首先想到的便是SOAP，对于很多人来说，SOAP基本上就等同于 Web service了。其实，Web service 是一种概念，SOAP 则是这种概念的一种实现而已，除此之外，还有其他针对 Web service 的实现，Hessian 就是其中的一个。
Hessian 与 web service 常用的 SOAP 协议类似，将协议报文封装在HTTP封包中，通过HTTP信道进行传输的。不同的是，Hessian 使用的是二进制协议，而不是像 SOAP 那样使用 XML，使用 Hessian 传输数据量比 SOAP 协议要小很多。Hessian 是一个轻量级的 Web service 实现框架，使用起来也非常简单，只需要将 Hessian 的 jar 包即可编写服务端和客户端的程序，不需要其他附加包。由于其轻量，因此还可以用来编写手机上的应用程序。

1、接口 - Web 服务协议

通常，需要根据应用程序的业务逻辑为 Web service 和其客户端程序交互定义一个协议来描述 Web service 所能提供的服务，在程序实现上，就表现为编写一个接口。Web service 程序实现该接口，客户端按照该接口定义的方法进行业务操作。

package example;

public interface Basic {
public String hello();
}

2、Web 服务程序

位于服务器端的 Web 服务程序需要实现为业务逻辑定义的接口。

package example;

public class BasicService implements Basic {
public String hello(String name)
{
    return "Hello, " + name;
}
}

3、Web 服务器配置

Hessian 通过在 Web 服务器上配置 HessianServlet 这个 Servlet 来提供 Web service。为 HessianServlet 指定不同的 init-param 来使 HessianServlet 提供不同的 Web service 服务。

<web-app>
<servlet>
   <servlet-name>hello</servlet-name>
   <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>
    <init-param>
      <param-name>home-class</param-name>
      <param-value>example.BasicService</param-value>
    </init-param>
    <init-param>
      <param-name>home-api</param-name>
      <param-value>example.Basic</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <url-pattern>/hello</url-pattern>
    <servlet-name>hello</servlet-name>
</servlet-mapping>
</web-app>

其中，home-class 指示实现接口的类名称，home-api 指示描述 Web service 的接口名称。

4、客户端程序

在 Java 客户端使用 Hessian service 就像调用一个普通的 Java 方法那样简单。通过指定目标 web service 的 URL 和描述 Web service 的接口，HessianProxyFactory 将创建一个实现了该接口的对象，然后就可以像使用本地对象那样使用该对象了。

package example;

import com.caucho.hessian.client.HessianProxyFactory;

public class BasicClient {
public static void main(String []args)
    throws Exception
{
    String url = "http://127.0.0.1:8080/htest/hello";

    HessianProxyFactory factory = new HessianProxyFactory();
    Basic basic = (Basic) factory.create(Basic.class, url);

    System.out.println(basic.hello("hessian"));
}
}

5、参考

http://hessian.caucho.com/

作者：终南   <li.zhongnan@hotmail.com>

-------------------------------------------------
- README file for the LTP GCOV extension (LCOV) -
- Last changes: 2008-11-17                      -
-------------------------------------------------

说明
-----------
GCOV 是一个 GNU 工具，当运行一个特定的测试用例后，通过GCOV 可以查看一个程序的那些代码被实际执行。 LCOV 是GCOV的一个扩展工具。该扩展由一套 PERL 脚本组成，基于 GCOV 的文本式输出来实现以下增强的功能：

    * 基于 HTML 的输出：使用条形图和不同的颜色来表示。

    * 支持大型项目：信息汇总页面提供三个层次的代码覆盖细节信息：目录视图、文件视图和源代码视图，允许快速浏览代码覆盖数据。

LCOV 最初为支持 Linux 内核代码覆盖评估而设计，但是同样可用于测量标准用户空间应用程序的代码覆盖率。


README 目录
-----------------------
1. 相关文件
2. 安装 LCOV
3. 如何访问内核代码覆盖数据的示例
4. 如何访问用户空间应用程序代码覆盖数据的示例
5. 问题和评论



1. 相关文件
------------------
README             - 该 README 文件
CHANGES           - 各发行版本的更新列表
bin/lcov                - 收集 LCOV 代码覆盖数据的工具
bin/genhtml         - 根据 LCOV 数据生成 HTML 输出的工具
bin/gendesc        - 创建说明文件的工具，同时也被 genhtml 使用
bin/geninfo         - 内部工具（创建 LCOV 数据文件）
bin/genpng          - 内部工具（创建源代码文件的 png 图形汇总信息）
bin/install.sh        - 内部工具（安装和卸载）
descriptions.tests - LTP 软件包的测试说明文件，被 gendesc 使用
man                      - 放置 LCOV 使用工具的 man 页面的目录
example               - 用来演示 LCOV 的示例文件目录
lcovrc                  - LCOV 配置文件
Makefile               - Makefile 文件，包含 'install' 和 'uninstall' 目标


2. 安装 LCOV
------------------
可以从以下页面选择下载 LCOV 软件包，RPM 或 tarball 形式：
    
http://ltp.sourceforge.net/coverage/lcov.php

为安装 tarball，将软件包解压到一个目录然后运行：

make install

也可以使用匿名 CVS 来获取最新版本（但可能是不稳定的版本）：

cvs -d:pserver:anonymous@ltp.cvs.sourceforge.net:/cvsroot/ltp login

（当询问密码时，按回车即可）

cvs -z3 -d:pserver:anonymous@ltp.cvs.sourceforge.net:/cvsroot/ltp export -D now utils

切换到 utils/analysis/lcov 目录然后输入：

make install


3. 如何访问内核代码覆盖数据的示例
---------------------------------------------------
前提条件：从以下页面下载并安装 gcov-kernel 软件包：

http://sourceforge.net/projects/ltp

将最终的 gcov 内核模块文件复制到 system wide modules 目录或者 PERL 脚本所在目录。以 root 身份， 执行：

a) 重置计数器

     lcov --zerocounters

b) 收集当前代码覆盖状态到一个文件

     lcov --capture --output-file kernel.info

c) 获取 HTML 输出

     genhtml kernel.info

使用 web 浏览器打开 index.html 文件查看代码覆盖结果。


4. 如何访问用户空间应用程序代码覆盖数据的示例
---------------------------------------------------------------------
前提条件：使用 GCC 以 -fprofile-arcs 和-ftest-coverage 选项编译程序。假设编译目录名称为 "appdir"，然后执行：

a) 重置计数器

     lcov --directory appdir --zerocounters

b) 收集当前代码覆盖状态到一个文件（应用程序启动和停止至少一次后，该命令才能正常工作）

     lcov --directory appdir --capture --output-file app.info

c) 获取 HTML 输出

     genhtml app.info

使用 web 浏览器打开 index.html 文件查看代码覆盖结果。


5. 问题和评论
-------------------------
参见软件包中的 man 页面，以便获取如何使用 LCOV 工具的详细信息。

有关这些工具的问题和评论，请通过电子邮件联系，LTP 电子邮件列表：ltp-coverage@lists.sourceforge.net。

LCOV - LTP GCOV 扩展

关于LCOV

LCOV 是一个建立在GCC代码覆盖率测试工具 gcov 上的图形化工具。它收集源代码文件的 gcov 数据，生成包含源代码、标注有代码覆盖信息的 HTML 页面。同时为了方便浏览，也添加了信息汇总页面。Example output

一个小示例项目的 HTML output 。

截图 1：信息汇总页面		截图 2：标注有代码覆盖率信息的源代码

注：该示例的源代码和 Makefile 文件包含在 .tar.gz 文件中（参见下载章节）。

下载

最新版本：LCOV 1.7 （更新日志）。

• lcov-1.7-1.noarch.rpm

源代码：LCOV 按照 GPL 许可协议发布。

• lcov-1.7-1.src.rpm
• lcov-1.7.tar.gz
• CVS 访问：模块名称为 "utils"，目录为 "utils/analysis/lcov"
• 浏览 CVS

文档

• README 文件
• man 手册：lcov.1, genhtml.1, lcovrc, geninfo.1, gendesc.1, genpng.1

评论和问题

有关评论和问题，请联系：ltp-coverage@lists.sourceforge.net

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

原文档地址：

http://ltp.sourceforge.net/coverage/lcov.php

C语言的标准库中缺少对字符串进行操作的trim()函数，使用起来有些不便，可以使用利用 strlen 和 isspace 函数以及指针来自己写一个。

1、strlen 函数

原型：extern int strlen(char *s);
       
用法：#include <string.h>

功能：计算字符串s的长度

说明：返回s的长度，不包括结束符NULL。

2、isspace 函数

原型：extern int isspace(int c);

用法：#include <ctype.h>

功能：判断字符c是否为空白符

说明：当c为空白符时，返回非零值，否则返回零。
　　　空白符指空格、水平制表、垂直制表、换页、回车和换行符。

3、trim 函数

#include <string.h>
#include <ctype.h>

char *trim(char *str)
{
        char *p = str;
        char *p1;
        if(p)
        {
                p1 = p + strlen(str) - 1;
                while(*p && isspace(*p)) p++;
                while(p1 > p && isspace(*p1)) *p1-- = '\0';
        }
        return p;
}

4、应用举例

int main()
{
int i = 0;
char strs[][128] = {
   NULL,
   "",
   " ",
   "hello world",
   " hello",
   "hello world ",
   " hello world ",
   "\t\n\thello world ",
   "END"
};
do
{
        printf("trim(\"%s\")=%s.\n", strs[i], trim(strs[i]));
}while(strcmp(strs[i++], "END"));

        return 0;
}

先列以下以前写过的文章作为参考：

1。JRobin简介

2。基于JRobin的网络监控管理，以及基于JRobin的CPU使用率监控

3。磁盘IO性能监控（Linux 和 Windows）

这些文章介绍了JRobin、利用JRobin以及WIndows脚本技术监控网络和CPU使用率，以及如何获取Linux以及Windows下磁盘IO性能数据。将这些结合在一起，于是就有了使用Java语言写成的基于JRobin的磁盘IO监控代码。

监控程序的代码与利用ping监控网络和监控CPU基本类似，但是还是有一些不同：

1。由于可能有多个逻辑磁盘，因此需要先获取磁盘列表，然后才即每个磁盘的IO数据。

2。出于性能考虑，特别是在Windows下，在获取磁盘IO数据时，可以在执行脚本时一次性采集这些数据，根据磁盘名称保存，不用分别获取，这样可以提高性能。

3。数据的单位和显示在图形上的格式不同。

4。JRobin对数据源名称及其程度有要求，因此需要对磁盘名称进行一定的变更。

成果：

Java代码：

import java.awt.Color;
import java.awt.Font;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Logger;

import org.jrobin.core.RrdDb;
import org.jrobin.core.RrdDef;
import org.jrobin.core.Sample;
import org.jrobin.graph.RrdGraph;
import org.jrobin.graph.RrdGraphDef;

public class DiskIoMonitor {
String[] disks = null;

public static String[] execute(String[] commands) {
   String[] strs = null;
   File scriptFile = null;
   try {
    List<String> cmdList = new ArrayList<String>();
    String osName = System.getProperty("os.name");
    if (osName.indexOf("Windows") > -1) {
     scriptFile = File.createTempFile("monitor", ".vbs");
     cmdList.add("CMD.EXE");
     cmdList.add("/C");
     cmdList.add("CSCRIPT.EXE");
     cmdList.add("//NoLogo");
    } else {
     scriptFile = File.createTempFile("monitor", ".sh");
     cmdList.add("/bin/bash");
    }
    String fileName = scriptFile.getCanonicalPath();
    PrintWriter writer = new PrintWriter(scriptFile);
    for (int i = 0; i < commands.length; i++) {
     writer.println(commands[i]);
    }
    writer.flush();
    writer.close();
    cmdList.add(fileName);

    writer.flush();
    writer.close();
    cmdList.add(fileName);

    ProcessBuilder pb = new ProcessBuilder(cmdList);
    Process p = pb.start();

    p.waitFor();

    String line = null;
    BufferedReader stdout = new BufferedReader(new InputStreamReader(p
      .getInputStream()));
    List<String> stdoutList = new ArrayList<String>();
    while ((line = stdout.readLine()) != null) {
     stdoutList.add(line);
    }

    BufferedReader stderr = new BufferedReader(new InputStreamReader(p
      .getErrorStream()));
    List<String> stderrList = new ArrayList<String>();
    while ((line = stderr.readLine()) != null) {
     stderrList.add(line);
    }

    strs = stdoutList.toArray(new String[0]);
   } catch (Exception e) {
    e.printStackTrace();
   } finally {
    if (scriptFile != null)
     scriptFile.delete();
   }

   return strs;
}

private String dataFormat = "%5.1lf%sB";
private Logger logger = Logger.getLogger(this.getClass().getName());
private String monitorName = "diskio";
private String dataDir = ".";
private int step = 10;
private String rrdPath = "";
private Timer timer = new Timer();
private long timeStart = 0;
protected int width = 600;
protected int height = 150;

public DiskIoMonitor() {
   this(null);
}

public DiskIoMonitor(String diskName) {
   this.rrdPath = this.dataDir + File.separator + monitorName + ".rrd";

   disks = getDisks();
   if (diskName != null) {
    for (int i = 0; i < disks.length; i++) {
     if (diskName.equals(disks[i])) {
      disks = new String[] { diskName };
      break;
     }
    }
   }
   if (disks == null)
    disks = new String[0];
}

public String generateGraph() {
   long timeCur = org.jrobin.core.Util.getTimestamp();
   return generateGraph(timeStart, timeCur);
}

public String generateGraph(long start, long end) {
   RrdDb rrdDb = null;
   try {
    Color[] colors = new Color[] { Color.GREEN, Color.BLUE,
      Color.MAGENTA, Color.YELLOW, Color.RED, Color.CYAN,
      Color.ORANGE, Color.PINK, Color.BLACK };
    String graphPath = this.dataDir + File.separator + monitorName
      + ".png";

    // create graph
    logger.info("Creating graph");
    RrdGraphDef gDef = new RrdGraphDef();
    gDef.setWidth(width);
    gDef.setHeight(height);
    gDef.setFilename(graphPath);
    gDef.setStartTime(start);
    gDef.setEndTime(end);

    gDef.setTitle("Disk IO");
    gDef.setVerticalLabel("Byte/s");

    String[] dsNames = null;

    rrdDb = new RrdDb(rrdPath);
    dsNames = rrdDb.getDsNames();

    for (int i = 0; i < dsNames.length; i++) {
     String dsName = dsNames[i];
     String legend = dsName;
     if (legend == null || legend.equals(""))
      legend = dsName;
     gDef.datasource(dsName, rrdPath, dsName, "AVERAGE");
     gDef.line(dsName, colors[i % colors.length], legend, 2);

     gDef.gprint(dsName, "MIN", dataFormat + " Min");
     gDef.gprint(dsName, "AVERAGE", dataFormat + " Avg");
     gDef.gprint(dsName, "MAX", dataFormat + " Max");
     gDef.gprint(dsName, "LAST", dataFormat + " Last\\r");

     gDef.print(dsName, "MIN", "min" + dsName + " = %.3f");
     gDef.print(dsName, "AVERAGE", "avg" + dsName + " = %.3f");
     gDef.print(dsName, "MAX", "max" + dsName + " = %.3f");
     gDef.print(dsName, "LAST", "last" + dsName + " = %.3f");
    }

    gDef.setImageInfo("<img src='%s' width='%d' height = '%d'>");
    gDef.setPoolUsed(false);
    gDef.setImageFormat("png");

    gDef.setSmallFont(new Font("Monospaced", Font.PLAIN, 11));
    gDef.setLargeFont(new Font("SansSerif", Font.BOLD, 14));
    // gDef.setAltYMrtg(true);

    // create graph finally
    RrdGraph graph = new RrdGraph(gDef);

    // logger.info(graph.getRrdGraphInfo().dump());
    logger.info("Graph created");

    return graph.getRrdGraphInfo().getFilename();
   } catch (Exception e) {
    logger.warning("Error in generating graph: " + e.getMessage());
   } finally {
    if (rrdDb != null)
     try {
      rrdDb.close();
     } catch (IOException e) {
      e.printStackTrace();
     }
   }
   return null;
}

/**
* Return a HashMap which contains the current value of each data source.
*
* @return the current value of each data source.
*/
public HashMap<String, Double> getValues() {
   String osName = System.getProperty("os.name");
   if (osName.indexOf("Windows") > -1) {
    return getWinDSValues();
   } else {
    return getLinuxDSValues();
   }

}

/**
* Initialization.
*/
public void initialize() throws Exception {
   RrdDb rrdDb = null;
   try {
    rrdDb = new RrdDb(rrdPath);
   } catch (Exception e) {
   }

   if (rrdDb == null) {
    logger.info("RRD data is not located in " + rrdPath
      + ", create a new one");

    RrdDef rrdDef = new RrdDef(rrdPath, timeStart - 1, step);

    for (int i = 0; i < disks.length; i++)
    {
     rrdDef.addDatasource(disks[i] + "read", "GAUGE", 2 * step, 0, Double.NaN);
     rrdDef.addDatasource(disks[i] + "write", "GAUGE", 2 * step, 0, Double.NaN);    
    }
   
    rrdDef.addArchive("AVERAGE", 0.5, 1, 24 * 3600 / step);
    rrdDef.addArchive("AVERAGE", 0.5, 300 / step, 7 * 288);

    logger.info("Estimated file size: " + rrdDef.getEstimatedSize());
    rrdDb = new RrdDb(rrdDef);
    logger.info("RRD file created.");
   }

   logger.info(monitorName + " RRD Db Defs: " + rrdDb.getRrdDef().dump());
   if (rrdDb != null)
    rrdDb.close();
}

/**
* Start monitor.
*
* @return true if succeed, else false.
*/
public boolean start() {
   logger.info("start to monitor " + monitorName);

   try {
    timeStart = org.jrobin.core.Util.getTimestamp();
    initialize();
    timer.scheduleAtFixedRate(new TimerTask() {
     public void run() {
      try {
       updateData();
      } catch (Exception e) {
       e.printStackTrace();
       logger.severe("Timer running error: " + e.getMessage());
      }
     }
    }, 0, step * 1000);
    return true;
   } catch (Exception e) {
    e.printStackTrace();
   }
   return false;
}

/**
* Stop monitor.
*/
public void stop() {
   timer.cancel();
}

private void updateData() throws Exception {
   RrdDb rrdDb = null;
   try {
    logger.info("update rrd data for " + monitorName);

    rrdDb = new RrdDb(rrdPath);
    String[] dsNames = rrdDb.getDsNames();

    long lastUpdateTime = rrdDb.getLastUpdateTime();
    long t = org.jrobin.core.Util.getTimestamp();
    if (t > lastUpdateTime) {
     rrdDb.setInfo("T=" + t);
     Sample sample = rrdDb.createSample();
     sample.setTime(t);
     HashMap<String, Double> hm = getValues();
     System.out.println(hm);
     for (int i = 0; i < dsNames.length; i++) {
      String dsName = dsNames[i];
      Double value = hm.get(dsName);
      logger.fine(dsName + " = " + value);
      if (value == null)
       value = Double.NaN;
      sample.setValue(dsName, value);
     }
     sample.update();
    } else {
     logger.warning("Bad sample time " + t + "("
       + new Date(t * 1000L) + ")" + new Date()
       + ", the last update time was " + lastUpdateTime + "("
       + new Date(lastUpdateTime * 1000L) + ") - "
       + monitorName);
    }
   } finally {
    if (rrdDb != null)
     try {
      rrdDb.close();
     } catch (IOException e) {
      e.printStackTrace();
     }
   }
}

private String[] getDisks() {
   String[] scripts = null;
   String osName = System.getProperty("os.name");
   if (osName.indexOf("Windows") > -1) {
    scripts = new String[] {
      "strComputer = \".\"",
      "Set objWMIService = GetObject(\"winmgmts:\" _",
      "   & \"{impersonationLevel=impersonate}!\\\\\" & strComputer & \"\\root\\cimv2\")",
      "Const HARD_DISK = 3",
      "Set colDisks = objWMIService.ExecQuery _",
      " (\"Select * from Win32_LogicalDisk Where DriveType = \" & HARD_DISK)",
      "For Each objDisk in colDisks",
      " Wscript.Echo objDisk.DeviceID", "Next" };
   } else {
    scripts = new String[] { "df | grep \"^/\" | awk '{print $1}'" };
   }

   String[] strs = execute(scripts);
   if (strs == null) {
    logger.fine("not get disk information");
   } else {
    logger.fine(strs.length + " disks:");
    for (int i = 0; i < strs.length; i++) {
     strs[i] = normalizeDiskName(strs[i]);
     logger.fine("disk " + i + ": " + strs[i]);
    }
   }
   return strs;
}

private HashMap<String, Double> getWinDSValues() {
   HashMap<String, Double> dsValues = new HashMap<String, Double>();

   String[] scripts = new String[] {
     "strComputer = \".\"",
     "Set objWMIService = GetObject(\"winmgmts:\" _",
     "   & \"{impersonationLevel=impersonate}!\\\\\" & strComputer & \"\\root\\cimv2\")",
     "set objRefresher = CreateObject(\"WbemScripting.SWbemRefresher\")",
     "Set colDisks = objRefresher.AddEnum(objWMIService, \"Win32_PerfFormattedData_PerfDisk_LogicalDisk\").objectSet",
     "objRefresher.Refresh",
     "Wscript.Sleep 2000",

     "objRefresher.Refresh",
     "For Each objDisk in colDisks",
     "    Wscript.Echo objDisk.Name & \" \" & objDisk.DiskReadBytesPerSec & \" \" & objDisk.DiskWriteBytesPerSec",
     "Next" };

   String[] strs = execute(scripts);

   if (strs != null && strs.length > 0) {
    for (int i = 0; i < strs.length; i++) {
     String strValue = strs[i].trim();
     String[] values = strValue.split(" ");
     if (values.length == 3) {
      String diskName = normalizeDiskName(values[0]);
      long read = Long.parseLong(values[1]);
      long write = Long.parseLong(values[2]);

      dsValues.put(diskName + "read", (double) read);
      dsValues.put(diskName + "write", (double) write);
     }
    }
   }

   return dsValues;
}

private HashMap<String, Double> getLinuxDSValues() {
   HashMap<String, Double> dsValues = new HashMap<String, Double>();

   String[] scripts = new String[] { "iostat -d -k 2 2" };

   String[] strs = execute(scripts);

   int count = 0;
   if (strs != null && strs.length > 0) {
    for (int i = 0; i < strs.length; i++) {
     String strValue = replaceSpaces(strs[i].trim());
     if (strValue.startsWith("Device:")) {
      count++;
      continue;
     }
     if (count == 2) {
      String[] values = strValue.split(" ");
      if (values.length == 6) {
       String diskName = normalizeDiskName(values[0]);
       long read = (long) (Double.parseDouble(values[2]) * 1024);
       long write = (long) (Double.parseDouble(values[3]) * 1024);

       dsValues.put(diskName + "read", (double) read);
       dsValues.put(diskName + "write", (double) write);
      }
     }
    }
   }

   return dsValues;
}

private String replaceSpaces(String str) {
   if (str == null)
    return "";
   String str1;
   do {
    str1 = str;
    str = str.replace("\t", " ");
    str = str.replace(" ", " ");
   } while (!str1.equals(str));

   return str;
}

private String normalizeDiskName(String name) {
   String str = "";

   str = name.replace(":", "");
   String[] strs = str.split("/");
   str = strs[strs.length - 1];

   str = str.replaceAll("VolGroup", "vg");
   str = str.replaceAll("LogVol", "lv");

   return str;
}

public static void main(String[] args) {
   DiskIoMonitor p = new DiskIoMonitor();
   p.start();

   try {
    Thread.sleep(5 * 60 * 1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }

   p.stop();
   p.generateGraph();
}
}

磁盘的IO性能是衡量计算机总体性能的一个重要指标。Linux提供了iostat命令来获却磁盘输入／输出（即IO）统计信息，Windows则提供了WMI接口，可以通过编写一个简单的脚本来获取与iostat相当的功能。

1、Linux下的iostat命令

iostat -d -k -t 2

每隔2秒统计一次磁盘IO信息，直到按Ctrl+C终止程序，-d 选项表示统计磁盘信息， -k 表示以每秒KB的形式显示，-t 要求打印出时间信息，2 表示每隔 2 秒输出一次。第一次输出的磁盘IO负载状况提供了关于自从系统启动以来的统计信息。随后的每一次输出则是每个间隔之间的平均IO负载状况。

运行该命令后，输出:

Linux 2.6.9-67.0.7.ELsmp (localhost.localdomain)        11/19/2008

Time: 03:15:25 PM
Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sda               3.53        26.66        54.76   30122033   61864280
sda1              0.51         1.07         1.73    1207649    1949740
sda2              0.00         0.00         0.00        538        256
sda3             13.84        25.59        53.03   28913291   59914092

Time: 03:15:27 PM
Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sda             275.38         0.00      1738.69          0       3460
sda1             14.57         0.00        58.29          0        116
sda2              0.00         0.00         0.00          0          0
sda3            419.60         0.00      1678.39          0       3340

...

每次输出都会打印时间信息, 接下来显示磁盘IO情况列表。

Device: 显示磁盘名称
tps: 表示每秒钟输出到物理磁盘的传输次数。一次传输就是一个对物理磁盘的 I/O 请求。多个逻辑请求可被并为对磁盘的一个单一 I／O 请求。传输具有中等的大小。
kB_read/s: 每秒从磁盘读取的数据量，单位为KB。
kB_wrtn/s: 每秒从写入磁盘的数据量，单位为KB。
Kb_read: 读取的 KB 总数。
Kb_wrtn: 写入的 KB 总数。

2、WMI中的 Win32_PerfFormattedData_PerfDisk_LogicalDisk 对象

Win32_PerfFormattedData_PerfDisk_LogicalDisk 代表逻辑磁盘性能数据对象，利用该对象可以获得磁盘的心能信息。Win32_PerfFormattedData_PerfDisk_LogicalDisk对象有以下一些主要的属性：

Name： 磁盘名称
DiskTransfersPerSec：每秒磁盘传输次数。
DiskReadBytesPerSec：每秒从磁盘读取得数据量，单位为Byte。
DiskWriteBytesPerSec：每秒从磁盘读取得数据量，单位为Byte。
PercentFreeSpace：可用磁盘百分比。

3、使用 Win32_PerfFormattedData_PerfDisk_LogicalDisk 的注意事项

在使用 Win32_PerfFormattedData_PerfDisk_LogicalDisk 时，需要注意：

（1）不能使用 objWMIService.ExecQuery 执行 Select 语句来获取磁盘性能数据
（2）必须使用 WbemScripting.SWbemRefresher 将 Win32_PerfFormattedData_PerfDisk_LogicalDisk 加入，然后不断调用 Refresh 方法刷新数据来获取性能信息
（3）第一次刷新的时候，并不能获取有用的数据，从第二次开始，才能获取到磁盘性能数据
（4）以上问题与 WMI 中性能监控使用计数器的机制有关

4、使用举例

为了对监控磁盘性能提供一个良好的用户界面，可以利用VBScript编写脚本来获取磁盘性能数据。脚本的代码如下：

'Script File Name: DiskMonitor.vbs

strComputer = "."
Set objWMIService = GetObject("winmgmts:" _
   & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
set objRefresher = CreateObject("WbemScripting.SWbemRefresher")
Set colDisks = objRefresher.AddEnum(objWMIService, "Win32_PerfFormattedData_PerfDisk_LogicalDisk").objectSet

If Wscript.Arguments.Count = 0 Then
objRefresher.Refresh
For Each objDisk in colDisks
   Wscript.Echo objDisk.Name & " " & objDisk.DiskReadBytesPerSec & " " & objDisk.DiskWriteBytesPerSec
Next
End If

If Wscript.Arguments.Count = 1 Then
Interval = CInt(Wscript.Arguments(0)) * 1000
Do While True
   objRefresher.Refresh

   Wscript.Echo
   Wscript.Echo "Time: " & " " & Time()
   Wscript.Echo FormatStr("Device:", 15, 0) & FormatStr("tps", 7, 1) & FormatStr("    kB_read/s", 13, 1) & FormatStr("kB_wrtn/s", 13, 1) & FormatStr("Free Space", 13, 1)

   For Each objDisk in colDisks
    Wscript.Echo FormatStr(objDisk.Name, 15, 0) & FormatStr(objDisk.DiskTransfersPerSec, 7, 1) & FormatStr(objDisk.DiskReadBytesPerSec, 13, 1) & FormatStr(objDisk.DiskWriteBytesPerSec, 13, 1) & FormatStr(objDisk.PercentFreeSpace & "%", 13, 1)
   Next
   Wscript.Sleep Interval
Loop
End If

If Wscript.Arguments.Count = 2 Then
i = 0
Interval = CInt(Wscript.Arguments(0)) * 1000
Count = CInt(Wscript.Arguments(1))
Do While i < Count
   objRefresher.Refresh

   Wscript.Echo
   Wscript.Echo "Time: " & " " & Time()
   Wscript.Echo FormatStr("Device:", 15, 0) & FormatStr("tps", 7, 1) & FormatStr("    kB_read/s", 13, 1) & FormatStr("kB_wrtn/s", 13, 1) & FormatStr("Free Space", 13, 1)

   For Each objDisk in colDisks
    Wscript.Echo FormatStr(objDisk.Name, 15, 0) & FormatStr(objDisk.DiskTransfersPerSec, 7, 1) & FormatStr(objDisk.DiskReadBytesPerSec, 13, 1) & FormatStr(objDisk.DiskWriteBytesPerSec, 13, 1) & FormatStr(objDisk.PercentFreeSpace & "%", 13, 1)
   Next
   Wscript.Sleep Interval
   i = i + 1
Loop
End If

Function FormatStr(str, tLen, direction)
sLen = Len(str)
fStr = ""
num = tLen - sLen

j = 0
Do While j < num
   fStr = fStr & " "
   j = j + 1
Loop

If direction = 1 Then
   fStr = fStr & str
Else
   fStr = str & fStr
End If
FormatStr = fStr
End Function

使用举例：

（1）CSCript DiskMonitor.vbs
止刷新一次 Win32_PerfFormattedData_PerfDisk_LogicalDisk 对象，不会获取到有用的数据。

（2）CSCript DiskMonitor.vbs 2
每隔 2 秒获取一次磁盘性能数据并输出，直到按 Ctrl+C 终止程序。

（3）CSCript DiskMonitor.vbs 2 100
每隔 2 秒获取一次磁盘性能数据并输出，总共获取 100 次，然后退出。

该脚本输出的信息包括 DiskTransfersPerSec、DiskReadBytesPerSec、DiskWriteBytesPerSec 和 PercentFreeSpace。

1、介绍

Windows操作系统是应用最关的操作系统，因此动态链接库也为程序员所熟悉，即使对于普通的使用者来说，很多时候也会碰到.dll结尾的文件，这就是动态链接库文件。Windows下的动态链接库可以通过参考头文件和.lib库文件进行编译，从而使得动态链接库隐式地被使用；也可以使用LoadLibrary、GetProcAddress等函数来显式调用动态链接库。

2、语法、导入导出

在Windows编程中，对于要使用或被使用的函数或者变量，需要使用 __declspec 关键字来声明，以告诉编译器该变量或函数不是普通的变量或函数，而是一个动态链接库的接口属性。

如果定义一个要被其他代码使用的函数，可以写成：
__declspec( dllexport ) int add(int a, int b)；

如果在该代码中，打算使用另外一个程序中的变量，则可以写成：
__declspec( dllimport ) char *name；

动态链接库通常包含一系列供其他程序使用函数，因此 declspec( dllexport ) 语法形式最为常用。如果动态库需要其他程序中的定义的全局变量，则需要在其他程序中使用导出该变量，在动态链接库中则需要使用 extern declspec( dllexport ) 将该变量声明为外部变量以便使用。

3、链接方式

可以以下列两种方式之一链接到（或加载）DLL：

隐式链接
显式链接

隐式链接有时称为静态加载或加载时动态链接。显式链接有时称为动态加载或运行时动态链接。在隐式链接下，使用 DLL 的可执行文件链接到该 DLL 的创建者所提供的导入库（.lib 文件）。使用 DLL 的可执行文件加载时，操作系统加载此 DLL。客户端可执行文件调用 DLL 的导出函数，就好像这些函数包含在可执行文件内一样。

在显式链接下，使用 DLL 的可执行文件必须进行函数调用以显式加载和卸载该 DLL，并访问该 DLL 的导出函数。客户端可执行文件必须通过函数指针调用导出函数。可执行文件对两种链接方法可以使用同一个 DLL。另外，由于一个可执行文件可隐式链接到某个 DLL，而另一个可显式附加到此 DLL，故这些机制不是互斥的。

4、隐式链接

隐式链接动态链接库比较简单，不予详述。

5、显式链接API函数

显式链接主要涉及到3个API函数（ LoadLibrary , GetProcAddress 和 FreeLibrary ），要使用这些函数包含windows.h头文件即可。

（1）HINSTANCE LoadLibrary(LPCSTR lpLibFileName);

该函数用来加载指定动态库文件，并且返回句柄。

参数lpLibFileName为动态链接库的名称。Windows 首先搜索“已知 DLL”，如 Kernel32.dll 和 User32.dll。然后按下列顺序搜索 DLL：

1、当前进程的可执行模块所在的目录。
2、当前目录。
3、Windows 系统目录。GetSystemDirectory 函数检索此目录的路径。
4、Windows 目录。GetWindowsDirectory 函数检索此目录的路径。
5、PATH 环境变量中列出的目录。

（2）FARPROC GetProcAddress (HMODULE hModule, LPCSTR lpProcName);

函数GetProcAddress 用来获取 DLL 导出函数的地址。返回由lpProcName指定的变量或函数指针。

参数hModule为已经加载的动态库文件的句柄。

参数lpProcName为要调用的变量或函数名称。

（3）BOOL FreeLibrary(HMODULE hModule);
从内存中释放hModule所代表的动态链接库。

（4）如果发生错误，可以调用GetLastError()函数或去错误代码。

6、显示链接举例

（1）动态库文件代码：dll_demo.c

#include <stdio.h>

__declspec( dllexport ) int add(int a, int b)
{
printf("calling add\n");
return a + b;
}

该文件中的add()函数计算两个整数之和，并且返回之前打印提示字符串。函数使用 __declspec( dllexport ) 语法来说明函数add(int a, int b)要被导出。

（2）客户端事例代码：main.c

#include <stdio.h>
#include <windows.h>

int main (int argc, char *argv[])
{
int a = 10, b = 20;
int c = 0;
HINSTANCE   hInstLibrary   =   NULL;
int (*add)();

printf ("Load DLL file\n");
if ((hInstLibrary = LoadLibrary(L"dll_demo.dll")) == NULL)
{
   printf ("***LoadLibrary ERROR: %d.\n", GetLastError());
   return 1;
}
if((add = (int (*)())GetProcAddress(hInstLibrary, "add")) == NULL) {
   printf ("***GetProcAddress ERROR: %d.\n", GetLastError());
   return 1;
}

c = add(a, b);
printf("%d + %d = %d\n", a, b, c);

FreeLibrary(hInstLibrary);
return 0;
}

程序利用LoadLibrary函数加载动态链接dll_demo.dll，利用FreeLibrary关闭句柄，利用GetLastError()获取错误代码，利用GetProcAddress定位共享库中的add函数，然后调用该函数执行加法计算，并打印结果。

（3）编译与运行

编译共享库：

在VS.Net中创建一个动态链接库项目，名称为dll_demo，加入文件dll_demo.c，编译后生成dll_demo.dll文件。

编译事例程序：

在VS.Net中创建一个动态链接库项目，名称为dll_main，加入文件main.c，编译后生成dll_main.exe可以执行文件。

运行：

将 dll_demo.dll 和 dll_main.exe 放在同一个目录下，然后双击运行 dll_main.exe。

输出：

Load DLL file
calling add
10 + 20 = 30

7、调用动态链接库中的变量

也可以使用动态链接库中的变量。例如，在动态链接库中定义：

__declspec( dllexport ) int num = 100;

那么可以在事例程序中这样调用：

int *d;
d = (int *)GetProcAddress(hInstLibrary, "num");
printf("num = %d\n", *d);
   

1、介绍

动态库是程序设计常用的技术，采用动态库可以有效的减少程序大小，节省空间，提高效率，增加程序的可扩展性，便于模块化管理。在Windows和Linux操作系统中都有动态库的概念。Windows将其称为动态链接库（Dynamic Link Library，DLL），其文件扩展名为.dll，Linux称其为共享库技术（Shared Library），相应的共享库文件扩展名为.so。

故名思义，动态库在程序运行的时候被动态链接。但是在具体使用动态库的时候却有两种不同的方式：隐式链接和显式链接。隐式链接在编译/链接阶段完成，由编译系统根据动态库的头文件和库文件进行编译和链接，从而确定待调用的函数原形和地址。显式链接则是利用API函数实现加载和卸载共享库，获取带调用函数地址，获取错误信息等功能。

2、隐式链接举例

（1）动态库文件代码：dl_func.c

#include <stdio.h>
extern char name[];
int add(int a, int b)
{
        printf("calling add\n");
        printf("Hello, %s!\n", name);
        return a + b;
}

该文件中的add()函数计算两个整数之和，并且打印外部变量的值，该外部变量由调用共享库的事例程序定义。

（2）客户端事例代码：dl_demo1.c

#include <stdio.h>
#include <dlfcn.h>

int add(int a, int b);

char name[100];
int main(int argc, char *argv[]) {
        int a = 10, b = 20;
        int c = 0;

        strcpy(name, "NHN XDBMS");
        c = add(a, b);
        printf("%d + %d = %d\n", a, b, c);

        return 0;
}

该事例程序调用共享库的中的add()函数计算两数之后并打印，同时在事例程序中，给变量name赋值，以便在add()函数中打印。

（3）编译与运行

编译共享库：

gcc -o libdl_func.so -fPIC -rdynamic -shared dl_func.c
选项-fPIC指示编译器将代码编译成位置独立的代码，一般需要以程序文件共享其函数或变量给其他程序文件的代码都应该以此选项进行编译，选项-rdynamic指示编译器所编译/链接的为共享库程序文件。由于要使用外部变量，因此需要-shared选项，否则编译器会抛出错误信息：undefined reference to `name'，表示不能找到name变量。

编译事例程序：

gcc -o dl_demo1 -L./ -ldl_func dl_demo1.c
选项-L./ 指示编译器在当前目录下寻找共享库文件，-ldl_func指示需要的共享库文件名为libdl_func.so。

运行：

./dl_demo1

输出：

calling add
Hello, NHN XDBMS!
10 + 20 = 30

3、显式链接API函数

显式链接主要涉及到4个API函数（ dlopen , dlerror , dlsym 和 dlclose ），这些函数原形定义包含在dlfcn.h头文件中。

（1）void *dlopen(const char *file, int mode);

该函数用来按照指定模式打开指定的共享库，将其影射到内存中，并且返回句柄。
第一个参数：指定共享库的名称，将会在下面位置查找指定的共享库。
－环境变量LD_LIBRARY_PATH列出的用分号间隔的所有目录。
－文件/etc/ld.so.cache中找到的库的列表，用ldconfig维护。
－目录usr/lib。
－目录/lib。
－当前目录。
第二个参数：指定如何打开共享库。
－RTLD_NOW：将共享库中的所有函数加载到内存
－RTLD_LAZY：会推后共享库中的函数的加载操作，直到调用dlsym()时方加载某函数

（2）void *dlsym(void *restrict handle, const char *restrict name);

该函数返回一个指向由name所确定的请求入口点的指针。调用dlsym时，利用dlopen()返回的共享库的phandle以及函数/变量名称作为参数，返回要加载函数/变量的入口地址。

（3）char *dlerror(void);

dlerror 返回 NULL 或者一个指向描述最近错误的 ASCII 字符串的指针

（4）int dlclose(void *handle);

关闭句柄并且取消共享目标文件的映射  

4、显式链接举例

（1）动态库文件代码：dl_func.c

与隐式链接的代码相同。

（2）客户端事例代码：dl_demo.c

#include <stdio.h>
#include <dlfcn.h>

char name[100];
int main(int argc, char *argv[]) {
        int a = 10, b = 20;
        int c = 0;
        void *dlh = NULL;
        int (*add)();

        strcpy(name, "NHN XDBMS");
        if((dlh = dlopen("libdl_func.so", RTLD_LAZY)) == NULL) {
                fprintf (stderr, "***DL ERROR: %s.\n", dlerror ());
                return 1;
        }
        if((add = (int (*)())dlsym(dlh, "add")) == NULL) {
                fprintf (stderr, "***DL ERROR: %s.\n", dlerror ());
                return 1;
        }

        c = add(a, b);
        printf("%d + %d = %d\n", a, b, c);
        dlclose(dlh);
        return 0;
}

该事例程序给变量name赋值，以便在add()函数中打印。程序利用dlopen函数加载共享库libdl_func.so，利用dlclose关闭句柄，利用dlerror获取错误信息，利用dlsym定位共享库中的add函数，然后调用该函数执行加法计算。

（3）编译与运行

编译共享库：

与前述共享库编译方法相同。

编译事例程序：

gcc -o dl_demo -fPIC -ldl dl_demo.c
由于变量name需要被共享库中的add()函数使用，因此必须使用选项-fPIC。选项-ldl指示编译器需要用来到libdl.so库文件。

运行：

./dl_demo

输出：

与隐式链接事例的输出相同。

5、其他

（1）如事例中所给出的，除了共享库可以给别人使用外，共享库也可以使用调用程序中的变量，如在共享库中打印事例程序中的name。不过由于name在外部定义和声明因此在链接共享库时需要使用-shared选项。

（2）除了可以共享函数外，还可以共享变量，如果在dl_func.c中定义个变量:

int num = 100;

那么可以在事例程序中这样调用：

int *d;
d = (int *)dlsym(dlh, "num");
printf("num = %d\n", *d);
    

自从春节过后在在此开博至今，其间时而勤快，时而懒散，时至今日累计访问量终于突破10000大关，特此发贴庆祝。

ResultSet是使用Jdbc编程的人入门和常用的操作数据库的类，自 JDK 1.4 开始，易于使用RowSet接口被引入。RowSet 接口扩展了标准 java.sql.ResultSet 接口。RowSetMetaData 接口扩展了 java.sql.ResultSetMetaData 接口。因此，熟悉 JDBC API 的开发人员必须学习少数几个新 API 才能使用 rowset。此外，与 JDBC ResultSet 对象配套使用的第三方软件工具也可以方便地用于 rowset。但是在JDK 1.4中，只有一个RowSet接口，使得RowSet的使用范围打了折扣。不过 JDK 5.0 定义了5 个标准的 JDBC RowSet 接口，并且给出了相应的参考实现，因此可以很方便的使用RowSet接口所提供的功能。

RowSet 对象可以建立一个与数据源的连接并在其整个生命周期中维持该连接，在此情况下，该对象被称为连接的 rowset。rowset 还可以建立一个与数据源的连接，从其获取数据，然后关闭它。这种 rowset 被称为非连接 rowset。非连接 rowset 可以在断开时更改其数据，然后将这些更改发送回原始数据源，不过它必须重新建立连接才能完成此操作。 相比较 java.sql.ResultSet 而言，RowSet 的离线操作能够有效的利用计算机越来越充足的内存，减轻数据库服务器的负担，由于数据操作都是在内存中进行然后批量提交到数据源，灵活性和性能都有了很大的提高。RowSet 默认是一个可滚动，可更新，可序列化的结果集，而且它作为 JavaBeans，可以方便地在网络间传输，用于两端的数据同步。

1、与ResultSet比较

（1）RowSet扩展了ResultSet接口，因此可以像使用ResultSet一样使用RowSet。

（2）RowSet扩展了ResultSet接口，因此功能比ResultSet更多、更丰富。

（3）默认情况下，所有 RowSet 对象都是可滚动的和可更新的。而ResultSet是只能向前滚动和只读的。

（4）RowSet可以是非链接的，而ResultSet是连接的。因此利用CacheRowSet接口可以离线操作数据。

（5）RowSet接口添加了对 JavaBeans 组件模型的 JDBC API 支持。rowset 可用作可视化 Bean 开发环境中的 JavaBeans 组件。

（6）RowSet采用了新的连接数据库的方法。

（7）CacheRowSet是可以序列化的。

（8）RowSet和ResultSet都代表一行行的数据、属性以及相关操作方法。

（9）自己认为，应该倾向于把RowSet看成是与数据库无关的东西，它只是一个代表一行行数据的对象，而ResultSet则是一个与数据库紧密联系的东西。

2、JDK 5.0 的5个标准RowSet接口

在JDK 5.0中，5个标准RowSet接口包括 CachedRowSet，WebRowSet，FilteredRowSet，JoinRowSet 和 JdbcRowSet。相应的参考实现是Sun公司给出的，位于com.sun.rowset包下，分别为为CachedRowSetImpl，WebRowSetImpl，FilteredRowSetImpl，JoinRowSetImpl 和 JdbcRowSetImpl。这5个标准接口中JdbcRowSet是链接的rowset，而其他4个是非链接的rowset。

（1）CachedRowSet：最常用的一种 RowSet。其他三种 RowSet（WebRowSet，FilteredRowSet，JoinRowSet）都是直接或间接继承于它并进行了扩展。它提供了对数据库的离线操作，可以将数据读取到内存中进行增删改查，再同步到数据源。CachedRowSet是可滚动的、可更新的、可序列化，可作为 JavaBeans 在网络间传输。支持事件监听，分页等特性。 CachedRowSet 对象通常包含取自结果集的多个行，但是也可包含任何取自表格式文件（如电子表格）的行。

（2）WebRowSet：继承自 CachedRowSet，并可以将 WebRowSet 写到 XML 文件中，也可以用符合规范的 XML 文件来填充 WebRowSet。

（3）FilteredRowSet：通过设置 Predicate（在 javax.sql.rowset 包中），提供数据过滤的功能。可以根据不同的条件对 RowSet 中的数据进行筛选和过滤。

（4）JoinRowSet：提供类似 SQL JOIN 的功能，将不同的 RowSet 中的数据组合起来。目前在 Java 6 中只支持内联（Inner Join）。

（5）JdbcRowSet：对 ResultSet 的一个封装，使其能够作为 JavaBeans 被使用，是唯一一个保持数据库连接的 RowSet。JdbcRowSet 对象是连接的 RowSet 对象，也就是说，它必须使用启用 JDBC 技术的驱动程序（“JDBC 驱动程序”）来持续维持它与数据源的连接。

3、填充RowSet

前面说过，应该倾向于把RowSet看成是与数据库无关而只代表一行行数据的对象，因此就涉及到数据从哪里来的问题。

（1）从数据库直接获取数据

由于大部分情况下，与数据打交道也就是与数据库打交道，因此RowSet接口提供了通过JDBC直接从数据库获取数据的方法，以参考实现JdbcRowSetImpl为例，就是这样：

   RowSet rs = new JdbcRowSetImpl(); //也可以是CachedRowSetImpl，WebRowSetImpl，FilteredRowSetImpl，JoinRowSetImpl。
   rs.setUrl("jdbc:mysql:///test");
   rs.setUsername("root");
   rs.setPassword("");
   rs.setCommand("SELECT * FROM EMPLOYEES");
   rs.execute();

设置好相关属性，运行execute()方法后，EMPLOYEES表中的数据就被填充到rs对象中了。
除了通过设置JDBC连接URL、用户名和密码外，RowSet也可以使用数据源名称属性的值来查找已经在命名服务中注册的 DataSource 对象。完成检索后，可以使用 DataSource 对象创建到它所表示的数据源的连接，设置数据源名称可以使用setDataSourceName()方法。

（2）用ResultSet填充

在有现成ResultSet的情况下，如果想将其作为RowSet使用；或者当 DBMS 不提供对滚动和更新的完全支持时，如果想使不可滚动和只读的 ResultSet 对象变得可滚动和可更新，可以创建一个使用该 ResultSet 对象的数据所填充的 CachedRowSet 对象。

ResultSet rs = stmt.executeQuery("SELECT * FROM EMPLOYEES");
   CachedRowSet crs = new CachedRowSetImpl(); //也可以是WebRowSetImpl，FilteredRowSetImpl，JoinRowSetImpl，因为他们均继承自CachedRowSetImpl
   crs.populate(rs);

运行populate()方法后，ResultSet对象rs中的数据就被填充到crs对象中了。

（3）用XML填充

如果您打算将XML作为数据交换格式在客户端和你的服务器之间传输数据并且向实现数据离线编辑、或者向使用XML格式的数据的话，可以使用WebRowSet接口来用XML填充数据。

   WebRowSet wrs = new WebRowSetImpl();
   wrs.readXml(new FileReader(new File("D:\\employees.xml")));

运行readXml()方法后，employees.xml文件的数据就被填充到wrs对象中了。employees.xml 文件的格式参见附录。

（4）用其他方法填充

如果形用其他方式填充，比如csv、excel、text、http等格式或方法填充数据，那么就需要自己编写代码实现RowSet。

4、操作RowSet中的数据及元数据

除了ResultSet提供的操作数据和元数据方法外，RowSet接口没有提供太多额外的方法。

1）更新数据
   rs.absolute(5);
   rs.updateInt(1, 10);
   rs.updateInt(2, 1000);
   rs.updateString(3, "John");
   rs.updateRow();

（2）插入数据
   rs.moveToInsertRow();
   rs.updateInt(1, 10);
   rs.updateInt(2, 1000);
   rs.updateString(3, "John");
   rs.insertRow();

（3）删除数据
   rs.absolute(5);
   rs.deleteRow();

（4）设置属性
   rs.setCommand("select id, salary, name from employees where id = ?");
   rs.setInt(1, 1);
   rs.execute();

（5）元数据
   RowSetMetaData rsmd = (RowSetMetaData)rs.getMetaData();
   int count = rsmd.getColumnCount();
   int type = rsmd.getColumnType(2);
   
5、事务与更新底层数据源

RowSet本身只代表具体数据，事务以及底层数据源的更新是与底层数据源密切相关的概念。对于JDBC数据源，相应的标准接口JdbcRowSet通过与数据库相关的方法来来实现，如commit()，rollback()等。对于标准接口的中非连接rowset，如CachedRowSet，则在对RowSet中的数据改动后，通过运行acceptChanges()方法，在内部调用 RowSet 对象的 writer 将这些更改写入数据源，从而将 CachedRowSet 对象中的更改传播回底层数据源。

6、可序列化非连接RowSet

使用 CachedRowSet 对象的主要原因之一是要在应用程序的不同组件之间传递数据。因为 CachedRowSet 对象是可序列化的，所以可使用它（举例来说）将运行于服务器环境的企业 JavaBeans 组件执行查询的结果通过网络发送到运行于 web 浏览器的客户端。

由于 CachedRowSet 对象是非连接的，所以和具有相同数据的 ResultSet 对象相比更为简洁。因此，它特别适于向瘦客户端（如 PDA）发送数据，这种瘦客户端由于资源限制或安全考虑而不适于使用 JDBC 驱动程序。所以 CachedRowSet 对象可提供一种“获取各行”的方式而无需实现全部 JDBC API。

ebRowSet继承自CachedRowSet，除了拥有CachedRowSet的优点外，还可以将WebRowSet输出成XML，也可以将XML转换成WebRowSet，更加适合在Web环境中使用。标准的 WebRowSet XML 模式定义位于 URI http://java.sun.com/xml/ns/jdbc/webrowset.xsd。将WebRowSet保存为XML的代码事例如下：

   wrs.setCommand("select id, salary, name from employees");
   wrs.execute();   
   wrs.writeXml(new FileWriter(new File("D:\\employees.xml")));

附：employees.xml

<?xml version="1.0"?>
<webRowSet xmlns="http://java.sun.com/xml/ns/jdbc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/jdbc http://java.sun.com/xml/ns/jdbc/webrowset.xsd">
<properties>
    <command>select id, salary, name from employees</command>
    <concurrency>1008</concurrency>
    <datasource><null/></datasource>
    <escape-processing>true</escape-processing>
    <fetch-direction>1000</fetch-direction>
    <fetch-size>0</fetch-size>
    <isolation-level>2</isolation-level>
    <key-columns>
    </key-columns>
    <map>
    </map>
    <max-field-size>0</max-field-size>
    <max-rows>0</max-rows>
    <query-timeout>0</query-timeout>
    <read-only>true</read-only>
    <rowset-type>ResultSet.TYPE_SCROLL_INSENSITIVE</rowset-type>
    <show-deleted>false</show-deleted>
    <table-name>employees</table-name>
    <url>jdbc:mysql:///test</url>
    <sync-provider>
      <sync-provider-name>com.sun.rowset.providers.RIOptimisticProvider</sync-provider-name>
      <sync-provider-vendor>Sun Microsystems Inc.</sync-provider-vendor>
      <sync-provider-version>1.0</sync-provider-version>
      <sync-provider-grade>2</sync-provider-grade>
      <data-source-lock>1</data-source-lock>
    </sync-provider>
</properties>
<metadata>
    <column-count>3</column-count>
    <column-definition>
      <column-index>1</column-index>
      <auto-increment>false</auto-increment>
      <case-sensitive>false</case-sensitive>
      <currency>false</currency>
      <nullable>0</nullable>
      <signed>true</signed>
      <searchable>true</searchable>
      <column-display-size>11</column-display-size>
      <column-label>id</column-label>
      <column-name>id</column-name>
      <schema-name></schema-name>
      <column-precision>11</column-precision>
      <column-scale>0</column-scale>
      <table-name>employees</table-name>
      <catalog-name>test</catalog-name>
      <column-type>4</column-type>
      <column-type-name>INT</column-type-name>
    </column-definition>
    <column-definition>
      <column-index>2</column-index>
      <auto-increment>false</auto-increment>
      <case-sensitive>false</case-sensitive>
      <currency>false</currency>
      <nullable>1</nullable>
      <signed>true</signed>
      <searchable>true</searchable>
      <column-display-size>11</column-display-size>
      <column-label>salary</column-label>
      <column-name>salary</column-name>
      <schema-name></schema-name>
      <column-precision>11</column-precision>
      <column-scale>0</column-scale>
      <table-name>employees</table-name>
      <catalog-name>test</catalog-name>
      <column-type>4</column-type>
      <column-type-name>INT</column-type-name>
    </column-definition>
    <column-definition>
      <column-index>3</column-index>
      <auto-increment>false</auto-increment>
      <case-sensitive>false</case-sensitive>
      <currency>false</currency>
      <nullable>1</nullable>
      <signed>false</signed>
      <searchable>true</searchable>
      <column-display-size>25</column-display-size>
      <column-label>name</column-label>
      <column-name>name</column-name>
      <schema-name></schema-name>
      <column-precision>25</column-precision>
      <column-scale>0</column-scale>
      <table-name>employees</table-name>
      <catalog-name>test</catalog-name>
      <column-type>12</column-type>
      <column-type-name>VARCHAR</column-type-name>
    </column-definition>
</metadata>
<data>
    <currentRow>
      <columnValue>1</columnValue>
      <columnValue>1000</columnValue>
      <columnValue>John</columnValue>
    </currentRow>
    <currentRow>
      <columnValue>2</columnValue>
      <columnValue>1200</columnValue>
      <columnValue>Tom</columnValue>
    </currentRow>
</data>
</webRowSet>

1、我家宝宝

2、小猪鞋

3、公鸡鞋

4、老虎鞋

5、小猫鞋

6、小鸟鞋

7、小红鞋