路径: RMI

创建客户端程序

计算引擎是一个相对简单的程序：它运行被交给它的任务。计算引擎的客户端更加复杂。客户端需要调用计算引擎，但它也必须定义计算引擎要执行的任务。

在我们的例子中，客户端由两个独立的类组成。第一个类ComputePi查找并调用一个Compute对象。第二个类Pi实现了Task接口，并定义了计算引擎要执行的工作。Pi类的工作是计算的值到一定的小数位数。

非远程的Task接口定义如下：

package compute;

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

调用Compute对象的方法的代码必须获取对该对象的引用，创建一个Task对象，然后请求执行任务。任务类Pi的定义稍后会展示。一个Pi对象被构造时带有一个参数，即所需结果的精度。任务执行的结果是一个表示以指定精度计算的的java.math.BigDecimal对象。

这是主客户端类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异常:");
            e.printStackTrace();
        }
    }    
}

像ComputeEngine服务器一样，客户端首先安装了一个安全管理器。这一步是必需的，因为接收服务器远程对象的存根可能需要从服务器下载类定义。为了使RMI能够下载类，必须启用安全管理器。

在安装安全管理器之后，客户端构造一个名称用于查找Compute远程对象，使用与ComputeEngine绑定其远程对象时相同的名称。此外，客户端使用LocateRegistry.getRegistry API在服务器主机上合成对注册表的远程引用。第一个命令行参数args[0]的值是Compute对象运行的远程主机的名称。然后，客户端调用注册表上的lookup方法，通过名称在服务器主机的注册表中查找远程对象。所使用的LocateRegistry.getRegistry的特定重载版本，它有一个String参数，返回对命名主机和默认注册表端口1099的注册表的引用。如果注册表在除1099以外的端口上创建，则必须使用具有int参数的重载。

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

Pi类实现了Task接口，并计算指定小数位数的的值。对于此示例，实际算法并不重要。重要的是算法是计算密集型的，这意味着您希望在一台性能强大的服务器上执行它。

下面是实现Task接口的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;

    /** 在pi计算中使用的常量 */
    private static final BigDecimal FOUR =
        BigDecimal.valueOf(4);

    /** 在pi计算中使用的舍入模式 */
    private static final int roundingMode = 
        BigDecimal.ROUND_HALF_EVEN;

    /** 小数点后的精度位数 */
    private final int digits;
    
    /**
     * 构造一个任务，计算到指定的精度位数的pi值。
     */
    public Pi(int digits) {
        this.digits = digits;
    }

    /**
     * 计算pi。
     */
    public BigDecimal execute() {
        return computePi(digits);
    }

    /**
     * 计算到指定小数点后的精度位数的pi值。使用Machin's公式计算：
     *
     *          pi/4 = 4*arctan(1/5) - arctan(1/239)
     *
     * 和arctan(x)的幂级数展开，以足够的精度计算。
     */
    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);
    }
    /**
     * 计算反正切函数的值（弧度制），反正切函数的值是指定整数的倒数到小数点后的精度位数。使用反正切的幂级数展开计算：
     *
     * 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;
    }
}

注意，所有可序列化的类，无论是直接还是间接实现Serializable接口，都必须声明一个名为serialVersionUID的private static final字段，以确保版本之间的序列化兼容性。如果该类没有之前的版本发布过，那么该字段的值可以是任何long值，类似于Pi中使用的227L，只要该值在将来的版本中一致使用。如果之前的版本发布时没有明确声明serialVersionUID，但是与该版本的序列化兼容性很重要，则新版本的显式声明的值必须使用之前版本的隐式计算值。可以对之前的版本运行serialver工具以确定其默认计算值。

这个例子最有趣的特点是，Compute 实现对象在调用 executeTask 方法时，不需要事先加载 Pi 类的定义。在这个时候，RMI会将 Pi 类的代码加载到 Compute 对象的Java虚拟机中，然后调用 execute 方法，执行任务的代码。最后，任务的结果（在本例中是一个 BigDecimal 对象）会返回给调用方的客户端，用于打印计算的结果。

提供的 Task 对象计算 Pi 的值对于 ComputeEngine 对象来说并不重要。你也可以实现一个任务，例如使用概率算法生成一个随机质数。这个任务也是计算密集型的，因此非常适合传递给 ComputeEngine，但是它需要完全不同的代码。当 Task 对象传递给 Compute 对象时，这些代码也可以被下载。就像在需要时加载计算的算法一样，生成随机质数的代码也会在需要时加载。Compute 对象只知道每个接收到的对象都实现了 execute 方法。Compute 对象不知道也不需要知道实现的细节。