Java 执行客户端RMI时出错

很抱歉，请使用翻译，我希望您能帮助我提供一个我正在测试的RMI示例

我在运行客户端时看到以下错误：

java.rmi.ServerException: RemoteException occurred in server thread; nested exception is:
    java.rmi.UnmarshalException: error unmarshalling arguments; nested exception is:
    java.lang.ClassNotFoundException: client.Pi

项目结构如下

|-Cliente\
|   |-client\  ComputePi (main class) and Pi(Task)
|      |-->ComputePi.java
|      |-->ComputePi.class
|      |-->Pi.java
|      |-->Pi.class
|   |-compute\
|      |-->Compute.java
|      |-->Compute.class
|      |-->Task.java
|      |-->Task.class
|   |-public\
|      |-classes\
|         |-->compute.jar 
|         |-client\
|            |--> Pi.class
|-->client.policy

|-Servidor\
|   |-compute\
|      |-->Compute.java
|      |-->Compute.class
|      |-->Task.java
|      |-->Task.class
|   |-engine\
|      |-->ComputeEngine.java
|      |-->ComputeEngine.class
|   |-public\
|      |-classes\
|         |-->compute.jar 
|-->server.policy

服务器启动正常，但当我启动客户端时，它会向我发送上面显示的错误。运行客户端时，我执行以下操作：

java -cp c:\Users\Mauricio\Documents\RMI\Cliente;c:\Users\Mauricio\Documents\RMI\Cliente\public\classes\compute.jar
   -Djava.rmi.server.codebase=file:/c:/Users/Mauricio/Documents/RMI/Cliente/public/classes/
   -Djava.security.policy=c:/Users/Mauricio/Documents/RMI/Cliente/client.policy 
   client.ComputePi 127.0.0.1 45

你能帮我理解是什么导致了这个错误吗

对不起，没有在代码前面加上

类计算

package compute;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Compute extends Remote {
    <T> T executeTask(Task<T> t) throws RemoteException;
}

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;
    }
}

包客户端；
导入计算任务；
导入java.io.Serializable；
导入java.math.BigDecimal；
公共类Pi实现任务，可序列化{
私有静态最终长serialVersionUID=227L；
/**pi计算中使用的常数*/
私有静态最终大十进制四=
BigDecimal.valueOf（4）；
/**pi计算期间使用的舍入模式*/
专用静态最终整数舍入模式=
BigDecimal.ROUND\u HALF\u偶数；
/**小数点后的精度位数*/
私有的最后整数位数；
/**
*构造一个任务，将pi计算到指定值
*精确性。
*/
公共Pi（整数位数）{
这个。数字=数字；
}
/**
*计算pi。
*/
公共BigDecimal执行（）{
返回computePi（位数）；
}
/**
*计算pi的值，使其达到指定的数量
*小数点后的数字。值为
*使用Machin公式计算：
*
*pi/4=4*arctan（1/5）-arctan（1/239）
*
*以及arctan（x）的幂级数扩展到
*足够精确。
*/
公共静态BigDecimal computePi（整数位数）{
整数刻度=数字+5；
BigDecimal arctan1_5=arctan（5，刻度）；
BigDecimal arctan1_239=arctan（239，刻度）；
BigDecimal pi=arctan1_5.乘（四）.减(
四乘；
返回pi.setScale（数字，
大十进制。四舍五入（向上取整）；
}
/**
*计算弧切线的值（以弧度为单位）
*提供的整数与指定值的倒数
*小数点后的位数。值
*使用的幂级数展开式计算
*反正切：
*
*arctan（x）=x-（x^3）/3+（x^5）/5-（x^7）/7+
*（x^9）/9。。。
*/   
公共静态BigDecimal arctan（int inverseX，
整数比例）
{
BigDecimal结果、数字、术语；
BigDecimal invX=BigDecimal.valueOf（InverseEx）；
BigDecimal invX2=
BigDecimal.valueOf（inverseX*inverseX）；
numer=BigDecimal.ONE.divide（invX，
比例，圆形模式）；
结果=数值；
int i=1；
做{
数字=
数字除法（invX2、刻度、舍入模式）；
int-denom=2*i+1；
术语=
数字除法（BigDecimal.valueOf（denom），
比例，圆形模式）；
如果（（i%2）！=0）{
结果=结果。减去（项）；
}否则{
结果=结果。添加（术语）；
}
i++；
}while（term.compareTo（BigDecimal.ZERO）！=0）；
返回结果；
}
}

类计算机引擎

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;
    }
}

包客户端；
导入计算任务；
导入java.io.Serializable；
导入java.math.BigDecimal；
公共类Pi实现任务，可序列化{
私有静态最终长serialVersionUID=227L；
/**pi计算中使用的常数*/
私有静态最终大十进制四=
BigDecimal.valueOf（4）；
/**pi计算期间使用的舍入模式*/
专用静态最终整数舍入模式=
BigDecimal.ROUND\u HALF\u偶数；
/**小数点后的精度位数*/
私有的最后整数位数；
/**
*构造一个任务，将pi计算到指定值
*精确性。
*/
公共Pi（整数位数）{
这个。数字=数字；
}
/**
*计算pi。
*/
公共BigDecimal执行（）{
返回computePi（位数）；
}
/**
*计算pi的值，使其达到指定的数量
*小数点后的数字。值为
*使用Machin公式计算：
*
*pi/4=4*arctan（1/5）-arctan（1/239）
*
*以及arctan（x）的幂级数扩展到
*足够精确。
*/
公共静态BigDecimal computePi（整数位数）{
整数刻度=数字+5；
BigDecimal arctan1_5=arctan（5，刻度）；
BigDecimal arctan1_239=arctan（239，刻度）；
BigDecimal pi=arctan1_5.乘（四）.减(
四乘；
返回pi.setScale（数字，
大十进制。四舍五入（向上取整）；
}
/**
*计算弧切线的值（以弧度为单位）
*提供的整数与指定值的倒数
*小数点后的位数。值
*使用的幂级数展开式计算
*反正切：
*
*arctan（x）=x-（x^3）/3+（x^5）/5-（x^7）/7+
*（x^9）/9。。。
*/   
公共静态BigDecimal arctan（int inverseX，
整数比例）
{
BigDecimal结果、数字、术语；
BigDecimal invX=BigDecimal.valueOf（InverseEx）；
BigDecimal invX2=
BigDecimal.valueOf（inverseX*inverseX）；
numer=BigDecimal.ONE.divide（invX，
比例，圆形模式）；
结果=数值；
int i=1；
做{
数字=
数字除法（invX2、刻度、舍入模式）；
int-denom=2*i+1；
术语=
数字除法（BigDecimal.valueOf（denom），
比例，圆形模式）；
如果（（i%2）！=0）{
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;
    }
}

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;
    }
}