创建 Client 端程序
计算引擎是一个相对简单的程序:它运行传递给它的任务。计算引擎的 Client 端更为复杂。Client 端需要调用计算引擎,但是它也必须定义要由计算引擎执行的任务。
在我们的示例中,两个单独的类构成了 Client 端。第一类ComputePi
查找并调用Compute
对象。第二类Pi
实现Task
interface,并定义计算引擎要完成的工作。 Pi
类的工作是计算
到小数位数
非远程Taskinterface的定义如下:
package compute;
public interface Task<T> {
T execute();
}
调用Compute
对象的方法的代码必须获得对该对象的引用,创建Task
对象,然后请求执行该任务。稍后显示任务类别Pi
的定义。 Pi
对象由单个参数构造,即结果的期望精度。任务执行的结果为java.math.BigDecimal
计算到指定的精度。
这是主要 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
中。最后,程序将打印结果。下图描述了ComputePi
Client 端,rmiregistry
和ComputeEngine
之间的消息流。
Pi
类实现Task
interface并计算的值
到指定的小数位数。对于此示例,实际算法并不重要。重要的是该算法的计算量很大,这意味着您希望在功能强大的服务器上执行该算法。
这是实现Task
interface的类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;
}
}
请注意,所有可序列化的类,无论它们是直接实现还是间接实现Serializable
interface,都必须声明一个名为serialVersionUID
的private
static
final
字段,以确保版本之间的序列化兼容性。如果没有发布该类的先前版本,则该字段的值可以是任何long
值,类似于Pi
所使用的227L
,只要该值在以后的版本中始终使用即可。如果已发布该类的先前版本而没有显式serialVersionUID
声明,但是与该版本的序列化兼容性很重要,则必须将先前版本的默认隐式计算值用作新版本的显式声明的值。可以针对先前版本运行serialver
工具,以确定其默认计算值。
此示例最有趣的功能是,在将Pi
对象作为参数传递给executeTask
方法之前,Compute
实现对象永远不需要Pi
类的定义。此时,RMI 将类的代码加载到Compute
对象的 Java 虚拟机中,调用execute
方法,并执行任务的代码。在Pi
任务的情况下,该结果是BigDecimal
对象,该结果将交还给调用方 Client 端,在此将其用于打印计算结果。
提供的Task
对象计算Pi
的值这一事实与ComputeEngine
对象无关。您还可以实现一个任务,例如,使用概率算法生成一个随机质数。该任务也将需要大量计算,因此是传递给ComputeEngine
的不错选择,但它需要非常不同的代码。当Task
对象传递到Compute
对象时,也可以下载此代码。以这种方式计算的算法
在需要时引入,生成随机素数的代码将在需要时引入。 Compute
对象仅知道接收到的每个对象都实现execute
方法。 Compute
对象不知道,也不需要知道实现的作用。