创建 Client 端程序

计算引擎是一个相对简单的程序:它运行传递给它的任务。计算引擎的 Client 端更为复杂。Client 端需要调用计算引擎,但是它也必须定义要由计算引擎执行的任务。

在我们的示例中,两个单独的类构成了 Client 端。第一类ComputePi查找并调用Compute对象。第二类Pi实现Taskinterface,并定义计算引擎要完成的工作。 Pi类的工作是计算

pi 符号

到小数位数

非远程Taskinterface的定义如下:

package compute;

public interface Task<T> {
    T execute();
}

调用Compute对象的方法的代码必须获得对该对象的引用,创建Task对象,然后请求执行该任务。稍后显示任务类别Pi的定义。 Pi对象由单个参数构造,即结果的期望精度。任务执行的结果为java.math.BigDecimal

pi 符号

计算到指定的精度。

这是主要 Client 端类client.ComputePi的源代码:

package client;

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.math.BigDecimal;
import compute.Compute;

public class ComputePi {
    public static void main(String args[]) {
        if (System.getSecurityManager() == null) {
            System.setSecurityManager(new SecurityManager());
        }
        try {
            String name = "Compute";
            Registry registry = LocateRegistry.getRegistry(args[0]);
            Compute comp = (Compute) registry.lookup(name);
            Pi task = new Pi(Integer.parseInt(args[1]));
            BigDecimal pi = comp.executeTask(task);
            System.out.println(pi);
        } catch (Exception e) {
            System.err.println("ComputePi exception:");
            e.printStackTrace();
        }
    }    
}

ComputeEngine服务器一样,Client 端从安装安全 管理 器开始。此步骤是必需的,因为接收服务器远程对象的存根的过程可能需要从服务器下载类定义。为了使 RMI 下载类,必须启用安全 管理 器。

安装安全 管理 器后,Client 端将使用ComputeEngine绑定其远程对象的名称来构造用于查找Compute远程对象的名称。此外,Client 端使用LocateRegistry.getRegistry API 来综合对服务器主机上注册表的远程引用。第一个命令行参数args[0]的值是Compute对象在其上运行的远程主机的名称。然后,Client 端在注册表上调用lookup方法,以在服务器主机的注册表中按名称查找远程对象。使用的具有单个String参数的LocateRegistry.getRegistry的特定重载会返回对命名主机和默认注册表端口 1099 的注册表的引用。如果注册表是在端口上创建的,则必须使用具有int参数的重载。除了 1099.

接下来,Client 端创建一个新的Pi对象,将解析为整数的第二个命令行参数args[1]的值传递给Pi构造函数。此参数指示在计算中使用的小数位数。最后,Client 端调用Compute远程对象的executeTask方法。传递给executeTask调用的对象将返回BigDecimal类型的对象,程序会将其存储在变量result中。最后,程序将打印结果。下图描述了ComputePiClient 端,rmiregistryComputeEngine之间的消息流。

计算引擎,注册表和 Client 端之间的消息流。

Pi类实现Taskinterface并计算的值

pi 符号

到指定的小数位数。对于此示例,实际算法并不重要。重要的是该算法的计算量很大,这意味着您希望在功能强大的服务器上执行该算法。

这是实现Taskinterface的类client.Pi的源代码:

package client;

import compute.Task;
import java.io.Serializable;
import java.math.BigDecimal;

public class Pi implements Task<BigDecimal>, Serializable {

    private static final long serialVersionUID = 227L;

    /** constants used in pi computation */
    private static final BigDecimal FOUR =
        BigDecimal.valueOf(4);

    /** rounding mode to use during pi computation */
    private static final int roundingMode = 
        BigDecimal.ROUND_HALF_EVEN;

    /** digits of precision after the decimal point */
    private final int digits;
    
    /**
     * Construct a task to calculate pi to the specified
     * precision.
     */
    public Pi(int digits) {
        this.digits = digits;
    }

    /**
     * Calculate pi.
     */
    public BigDecimal execute() {
        return computePi(digits);
    }

    /**
     * Compute the value of pi to the specified number of 
     * digits after the decimal point.  The value is 
     * computed using Machin's formula:
     *
     *          pi/4 = 4*arctan(1/5) - arctan(1/239)
     *
     * and a power series expansion of arctan(x) to 
     * sufficient precision.
     */
    public static BigDecimal computePi(int digits) {
        int scale = digits + 5;
        BigDecimal arctan1_5 = arctan(5, scale);
        BigDecimal arctan1_239 = arctan(239, scale);
        BigDecimal pi = arctan1_5.multiply(FOUR).subtract(
                                  arctan1_239).multiply(FOUR);
        return pi.setScale(digits, 
                           BigDecimal.ROUND_HALF_UP);
    }
    /**
     * Compute the value, in radians, of the arctangent of 
     * the inverse of the supplied integer to the specified
     * number of digits after the decimal point.  The value
     * is computed using the power series expansion for the
     * arc tangent:
     *
     * arctan(x) = x - (x^3)/3 + (x^5)/5 - (x^7)/7 + 
     *     (x^9)/9 ...
     */   
    public static BigDecimal arctan(int inverseX, 
                                    int scale) 
    {
        BigDecimal result, numer, term;
        BigDecimal invX = BigDecimal.valueOf(inverseX);
        BigDecimal invX2 = 
            BigDecimal.valueOf(inverseX * inverseX);

        numer = BigDecimal.ONE.divide(invX,
                                      scale, roundingMode);

        result = numer;
        int i = 1;
        do {
            numer = 
                numer.divide(invX2, scale, roundingMode);
            int denom = 2 * i + 1;
            term = 
                numer.divide(BigDecimal.valueOf(denom),
                             scale, roundingMode);
            if ((i % 2) != 0) {
                result = result.subtract(term);
            } else {
                result = result.add(term);
            }
            i++;
        } while (term.compareTo(BigDecimal.ZERO) != 0);
        return result;
    }
}

请注意,所有可序列化的类,无论它们是直接实现还是间接实现Serializableinterface,都必须声明一个名为serialVersionUIDprivate static final字段,以确保版本之间的序列化兼容性。如果没有发布该类的先前版本,则该字段的值可以是任何long值,类似于Pi所使用的227L,只要该值在以后的版本中始终使用即可。如果已发布该类的先前版本而没有显式serialVersionUID声明,但是与该版本的序列化兼容性很重要,则必须将先前版本的默认隐式计算值用作新版本的显式声明的值。可以针对先前版本运行serialver工具,以确定其默认计算值。

此示例最有趣的功能是,在将Pi对象作为参数传递给executeTask方法之前,Compute实现对象永远不需要Pi类的定义。此时,RMI 将类的代码加载到Compute对象的 Java 虚拟机中,调用execute方法,并执行任务的代码。在Pi任务的情况下,该结果是BigDecimal对象,该结果将交还给调用方 Client 端,在此将其用于打印计算结果。

提供的Task对象计算Pi的值这一事实与ComputeEngine对象无关。您还可以实现一个任务,例如,使用概率算法生成一个随机质数。该任务也将需要大量计算,因此是传递给ComputeEngine的不错选择,但它需要非常不同的代码。当Task对象传递到Compute对象时,也可以下载此代码。以这种方式计算的算法

pi 符号

在需要时引入,生成随机素数的代码将在需要时引入。 Compute对象仅知道接收到的每个对象都实现execute方法。 Compute对象不知道,也不需要知道实现的作用。