Java本地&远程调用Matlab函数及脚本
Matlab版本： 2020b
Matlab提供了丰富的工具箱，如果可以使用Java调用Matlab来实现一些特定的算法，确实是一个不错的想法，经过实验证明这个想法可行，但是性能差点事情，对于一些特殊场景还是可以尝试的。查阅了网上大量的资料，实现Java调用Matlab基本有两种实现思路：1. 将Matlab函数打成Jar类库 ，然后基于MCR运行 2. 使用Matlab提供的Java Matlab Engine API。 本篇文章也是围绕着两个思路，介绍具体实现方法，这其中也会分别介绍本地调用，以及远程调用两种方式。
1 准备工作
远程服务器一台，可以装有window server或者ubuntu系统，或者自己在开发机安装安装版本为2020b的matlab，关于matlab的安装可以参考这篇文章：https://www.bilibili.com/video/BV1uK4y1W7qB。这里我安装的window版本的，安装完成后，启动的时候遇到了一个问题，是由于忘记将压缩包中的补丁里bin复制到安装目录中了，这里一定要复制过去，不然启动不了，注意！！！开发机一台
注意：安装Matlab的时候，一定要安装如下组件：
2 将Matlab函数打成Jar类库 ，然后基于MCR运行
实现原理很简单，就是利用Matlab生成Java的包，使用这个包编写的程序，就可以在MCR的环境运行了。MCR的全拼MATLAB Compiler Runtime，就是一个Matlab的编译运行环境。网上大多数的文章都是基于这种原理实现的，官网文档也有介绍：https://ww2.mathworks.cn/help/compiler_sdk/gs/create-a-java-application-with-matlab-code.html。打包成Java类库有两种方式，通过Matlab界面，或者通过命令行。这篇文章只简单介绍通过Matlab软件界面进行打包。
2.1 安装MCR
如果安装Matlab，并且勾选的文章一开头说的那些选项，就会将MCR一起安装好，当然也可以单独安装MCR，参考：https://ww2.mathworks.cn/help/compiler/install-the-matlab-runtime.html，这里就不单独安装了。
2.2 打包Matlab函数
打开Matlab，在「主页」菜单里点击「新建脚本」，在编辑器中创建如下函数，并保存为mfft.m
function y = mfft(x,N)
y=abs(fft(x,N));
打包Java类库，在「APP」菜单点击「Library Compiler」打开类库编译器
在打开的类库编译器窗口中，「TYPE」一栏选择「Jav aPakage」，在「EXPORTED FUNCTIONS」一栏选择我们已经创建好的函数文件（这里可以选择多个函数），然后修改Jar的名称为signalprocessor，接着修改类名为SignalProcessor，最后点击右上角的「Package」按钮打包即可。
打包完成之后，会弹出打包后的文件夹，其中「for_redistribution_files_only」文件夹下的Jar就是我们打包后的类库，在我们自己的Java应用中引用这个类库即可。
2.3 本地调用
上面通过Matlab的「Library Compiler」成功打包了一个包含FFT函数的Java类库，接下来要介绍如何在我们自己的Java项目中去调用这个类库。
2.3.1 创建Java项目
使用IDEA创建一个名为matlab-mcr-java的Maven项目
2.3.2 使用Maven加载生成的类库
在项目中创建一个名字为「lib」的文件夹，并将matlab安装目录中的R2020b\toolbox\javabuilder\jar\javabuilder.jar，以及我们生成的类库signalprocessor.jar复制到这个文件夹下
修改pom.xml文件，加载lib中的两个类库
maven重新加载
2.3.3 编写本地调用程序
创建matlab.mcr.example包，并创建SignalProcessorExample类
public class SignalProcessorExamples {
public static void main(String[] args) throws Exception {
SignalProcessor processor = new SignalProcessor();
double[] x = new double[]{1.0, 2.0, 3.0, 1.0};
Object[] res = processor.mfft(1, x, (double) x.length);
MWArray a = (MWNumericArray) res[0];
System.out.println(Arrays.toString((double[]) a.getData()));
}
}
在装有MatlabMCR的机器上运行，注意，对象初始化会比较慢，如果要在项目中使用，可以提前初始化对象，后面直接进行方法调用即可
2.4 远程调用
上面开发的程序，必须要在具有MCR的环境中运行。其实在打包Java类库的时候，有一个选项，询问用户是否将Matlab Runtime的类库一并打包，如果选择这个选项的话，就不需要单独的MCR环境，显然实际项目中这么做不太理想，因为包含MCR的一个Java类库就几个G大小。另外一个问题就是，不能每一个应用都体用一个MCR环境，这样也会造成资源的浪费，所以Matlab提供了基于RMI远程调用的方式，关于什么是RMI，参考这篇文章：https://www.cnblogs.com/wxisme/p/5296441.html。
如上是Matlab官网提供的RMI远程调用的架构图，客户端不需要具有MCR环境，服务具有就可以了。下面将通过代码，分别实现客户端和服务端示例。
2.4.1 服务端示例
在官方的javabuilder.jar类库中，会包含RMI相关的封装，服务端只需要去创建监听对象即可。如下为服务端的代码
public class SignalProcessorServerExamples {
public static void main(String[] args) throws Exception {
BasicRemoteFactory factory = new BasicRemoteFactory(SignalProcessor.class, SignalProcessorRemote.class, true);
// 这里调用，是初始化单播远程对象
Remote stub = factory.getStub();
Registry reg = LocateRegistry.createRegistry(10990);
reg.rebind("FactoryInstance", factory);
System.out.println("Server registered and running successfully!!\n");
Thread.currentThread().join();
}
}
注意：创建BasicRemoteFactory对象的时候，构造函数中的最后一个布尔参数一定要设置成fMarshalOutputs=true，设置为true的话，服务端会将matlab的返回对象包装成Java类，否则客户端需要依赖MCR的库进行转换，这样的话，客户端也需要具有MCR环境，所以这里直接设置为true，让其在服务端就转换成Java的对象。
// 这段代码在com.mathworks.toolbox.javabuilder.remoting.RemoteProxy.ProxyInvocationHandler的invoke方法中
if (this.iMarshalOutputs) {
var11 = marshalMWArrayToObject(var11);
}
2.4.2 客户端示例
客户端需要获取远程的桩，然后再进行调用
public class SignalProcessorClientExamples {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.getRegistry("192.168.32.61", 10990);
RemoteFactory factory = (RemoteFactory) registry.lookup("FactoryInstance");
SignalProcessorRemote remote = (SignalProcessorRemote) factory.newInstance();
double[] x = new double[]{1.0, 2.0, 2.5, 1.0};
Object[] res = remote.mfft(1, x, 4.);
System.out.println(Arrays.toString(((double[][]) res[0])[0]));
}
}
其中通过主机IP和端口号获取远程的Registry，然后从Registry中获取到名字为FactorInstance的RemoteFactory对象，通过RemoteFactory创建SignalProcessorRemote。
2.4.3 运行验证
在装有Matlab的机器上运行服务端
在自己的开发机上运行客户端
2.5 完整代码
完整的代码已经提交到Github上了：https://github.com/shirukai/matlab-mcr-java.git
3 使用Matlab提供的Java Matlab Engine API
上一节介绍了通过Matlab打包成Java类库然后进行调用的方法，这一节将介绍另一个中方法，通过Matlab提供的Matlab Engine API进行调用，可以参考官网文章： https://ww2.mathworks.cn/help/matlab/matlab-engine-api-for-java.html。这种方法官网只提供了本地调用，即必须在装有Matlab的机器上，关于远程调用，笔者自己实现了两个方案，一个是借鉴上一节远程调用的RMI实现方案，另一种是我们比较熟悉的RPC调用。
注意：使用Matlab Engine API，需要提前配置好相关环境变量例如将安装目录\Polyspace\R2020b\bin\win64添加的Path中，其它机器参考：https://ww2.mathworks.cn/help/matlab/matlab_external/setup-environment.html
3.1 本地调用
3.1.1 创建Java项目
使用IDEA创建一个名为matlab-engine-java的Maven项目
_
3.1.2 引入相关依赖
这里需要engine api相关的依赖，在Matlab的安装目录\R2020b\extern\engines\java\jar\engine.jar，在项目中创建一个lib目录，将engine.jar复制到lib目录下。修改pom.xml，引入依赖
3.1.3 编写本地调用程序
在项目中创建包matlab.engine.remote.example并创建类MatlabEngineExamples:
public class MatlabEngineExamples {
public static void main(String[] args)throws Exception{
MatlabEngine engine = MatlabEngine.startMatlab();
engine.eval("y=0:1024-1;s=sin(2.0*pi*y*100.0/1000.0);fx=abs(fft(s));");
// 获取变量
double[] fx = engine.getVariable("fx");
System.out.println(Arrays.toString(fx));
}
}
在装有Matlab的机器上运行
如果遇到如下错误，参考：https://ww2.mathworks.cn/matlabcentral/answers/91874-why-do-i-receive-license-manager-error-103，将安装目录\licenses\下的许可证中的"SIGN=" 全局替换成 “TS_OK SIGN=”
3.2 远程调用
本篇文章提供两种远程调用的方式：RMI和RPC，设计模式都是相似的，都需要服务端、客户端。所以首先提取公共的部分，比如调用接口的定义，接口的实现、客户端及工厂定义、服务端及工程定义等。然后再分别实现具体的客户端以及服务端即可。设计UML类图如下：
如下为公共部分的类及接口
定义接口MatlabEngineService
在matlab.engine.remote.api包下创建MatlabEngineService接口
package matlab.engine.remote.api;
import java.rmi.Remote;
import java.rmi.RemoteException;
/**
* 定义Matlab引擎的接口，其中继承Remote用来兼容RMI方式调用
*
* @author shirukai
*/
public interface MatlabEngineService extends Remote {
/**
* 执行Matlab函数
*
*
* double[] x = {2.0, 4.0, 6.0};
* double[] res = service.feval("sqrt", (Object) x);
*
*
* @param funcName 函数名称
* @param params 函数的参数列表
* @param
* @return 执行结果
* @throws RemoteException 兼容RMI
*/
/**
* 执行Matlab脚本
*
* @param script 脚本
* @throws RemoteException 兼容RMI
*/
void eval(String script) throws RemoteException;
/**
* 获取变量
* 执行eval()方法之后，可以调用此方法获取脚本中的变量
*
* @param varName 变量名称
* @param
* @return 变量结果
* @throws RemoteException 兼容RMI
*/
}
实现接口MatlabEngineServiceImpl
在matlab.engine.remote.service包下创建MatlabEngineServiceImpl类
package matlab.engine.remote.service;
import com.mathworks.engine.EngineException;
import com.mathworks.engine.MatlabEngine;
import matlab.engine.remote.api.MatlabEngineService;
import java.io.Serializable;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
/**
* Matlab引擎服务接口的具体实现
* 参考：{@link MatlabEngine}
*
* @author shirukai
*/
public class MatlabEngineServiceImpl extends UnicastRemoteObject implements MatlabEngineService, Serializable {
private final MatlabEngine engine;
public MatlabEngineServiceImpl() throws RemoteException, EngineException, InterruptedException {
super();
// 启动Matlab服务
this.engine = MatlabEngine.startMatlab();
}
@Override
public
try {
return engine.feval(funcName, params);
} catch (Exception e) {
throw new RemoteException(e.getMessage());
}
}
@Override
public void eval(String script) throws RemoteException {
try {
engine.eval(script);
} catch (Exception e) {
throw new RemoteException(e.getMessage());
}
}
@Override
public
try {
return engine.getVariable(varName);
} catch (Exception e) {
throw new RuntimeException(e.getMessage());
}
}
}
定义服务端抽象类
在matlab.engine.remote.common包下创建Client抽象类
package matlab.engine.remote.common;
/**
* 定义客户端创建参数，及创建方法
*
* @author shirukai
*/
public abstract class Client {
protected final String host;
protected final Integer port;
public Client(String host, Integer port) {
this.host = host;
this.port = port;
}
abstract public
}
定义客户端抽象类
在matlab.engine.remote.common包下创建Server抽象类
package matlab.engine.remote.common;
/**
* 定义服务端创建参数，及启动方法
*
* @author shirukai
*/
public abstract class Server
protected final Integer port;
protected final T instance;
public Server(Integer port, T instance) {
this.port = port;
this.instance = instance;
}
public abstract void start() throws Exception;
}
定义服务端工厂类
在matlab.engine.remote.common包下创建ServerFactory类
package matlab.engine.remote.common;
import java.rmi.Remote;
/**
* 用来创建指定类型的服务端
*
* @author shirukai
*/
public class ServerFactory {
/**
* 创建RMI的服务端
*
* @param port 监听端口号
* @param instance 代理实例
* @param
* @return RMI服务端
*/
public static
// TODO
}
/**
* 创建RPC的服务端
*
* @param port 监听端口号
* @param instance 代理实例
* @param
* @return RPC服务端
*/
public static
//TODO
}
}
定义客户端工厂类
在matlab.engine.remote.common包下创建ClientFactory类
package matlab.engine.remote.common;
/**
* 用来创建指定类型的客户端
*
* @author shirukai
*/
public class ClientFactory {
/**
* 创建基于RMI方式的客户端
*
* @param host 远程服务端的地址
* @param port 远程服务端的端口
* @return RMI客户端
*/
public static Client createRMIClient(String host, Integer port) {
// TODO
return null;
}
/**
* 创建基于RPC方式的服务端
*
* @param host 远程服务端的地址
* @param port 远程服务端的端口
* @return RPC客户端
*/
public static Client createRPCClient(String host, Integer port) {
// TODO
return null;
}
}
3.2.1 基于RMI的实现
3.2.1.1 服务端
RMI的服务端比较简单，继承Server抽象类，实现start方法，直接创建一个Registry监听指定端口，然后绑定一个实例对象即可
package matlab.engine.remote.rmi.server;
import matlab.engine.remote.common.Server;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.rmi.Remote;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
/**
* RMI服务端
*
* @author shirukai
*/
public class RMIServer
private static final Logger LOG = LoggerFactory.getLogger(Server.class);
public RMIServer(Integer port, T instance) {
super(port, instance);
}
/**
* 启动监听服务
*
* @throws Exception e
*/
@Override
public void start() throws Exception {
LOG.info("Starting the RMI-based Matlab engine...");
LOG.info("Listening port: {}.", port);
LOG.info("Service backend: {}.", instance.getClass());
Registry registry = LocateRegistry.createRegistry(port);
String name = instance.getClass().getInterfaces()[0].getSimpleName();
registry.rebind(name, instance);
}
}
服务端创建完成之后，在ServerFactory中添加创建RMI服务端的代码
public static
return new RMIServer<>(port, instance);
}
3.2.1.2 客户端
客户单也是很简单，继承Client抽象类，实现get方法，get方法中，根据远程主机IP和端口号获取Registry，然后查找到对应的实例返回即可。
package matlab.engine.remote.rmi.client;
import matlab.engine.remote.common.Client;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
/**
* RMI客户端
*
* @author shirukai
*/
public class RMIClient extends Client {
public RMIClient(String host, Integer port) {
super(host, port);
}
/**
* 获取客户端
*
* @param interfaceClass 代理接口类
* @param
* @return 代理实例
* @throws Exception e
*/
@Override
@SuppressWarnings("unchecked")
public
Registry registry = LocateRegistry.getRegistry(this.host, this.port);
return (T) registry.lookup(interfaceClass.getSimpleName());
}
}
客户端创建完成之后，在ClientFactory中添加创建RMI客户端的代码
public static Client createRMIClient(String host, Integer port) {
return new RMIClient(host, port);
}
3.2.1.3 运行验证
编写服务端示例，在matlab.engine.remote.example包下
package matlab.engine.remote.example;
import matlab.engine.remote.common.Server;
import matlab.engine.remote.common.ServerFactory;
import matlab.engine.remote.service.MatlabEngineServiceImpl;
/**
* @author shirukai
*/
public class RMIEngineServerExamples {
public static void main(String[] args) throws Exception {
MatlabEngineServiceImpl service = new MatlabEngineServiceImpl();
Server
server.start();
}
}
编写客户端示例，在matlab.engine.remote.example包下
package matlab.engine.remote.example;
import matlab.engine.remote.api.MatlabEngineService;
import matlab.engine.remote.common.Client;
import matlab.engine.remote.common.ClientFactory;
import java.util.Arrays;
/**
* @author shirukai
*/
public class RMIEngineClientExamples {
public static void main(String[] args) throws Exception {
Client client = ClientFactory.createRMIClient("192.168.66.212", 10991);
MatlabEngineService service = client.get(MatlabEngineService.class);
// 调用matlab函数
double[] x = {2.0, 4.0, 6.0};
double[] res = service.feval("sqrt", (Object) x);
for (double e : res) {
System.out.println(e);
}
// 调用matlab脚本
String scripts = "y=0:1024-1;s=sin(2.0*pi*y*100.0/1000.0);fx=abs(fft(s));";
service.eval(scripts);
// 获取变量
double[] fx = service.getVariable("fx");
System.out.println(Arrays.toString(fx));
}
}
运行服务端示例
运行客户端示例
3.2.2 基于RPC的实现
RPC的核心实现有很多种，我们可以基于Netty、Dubbo、Thrift的等等框架，这里为了测试，使用了自己开发的RPC框架，底层基于Socket通信，之前在RPC的文章里有介绍过，这里就不再赘述，贴一下代码，在matlab.engine.remote.rpc.core包下实现。
RPCRequest
package matlab.engine.remote.rpc.core;
import java.io.Serializable;
/**
* RPC通信的请求类型
*
* @author shirukai
*/
public class RPCRequest implements Serializable {
private static final long serialVersionUID = 4932007273709224551L;
/**
* 方法名称
*/
private String methodName;
/**
* 参数列表
*/
private Object[] parameters;
/**
* 参数类型
*/
private Class[] parameterTypes;
public String getMethodName() {
return methodName;
}
public RPCRequest setMethodName(String methodName) {
this.methodName = methodName;
return this;
}
public Object[] getParameters() {
return parameters;
}
public RPCRequest setParameters(Object[] parameters) {
this.parameters = parameters;
return this;
}
public Class[] getParameterTypes() {
return parameterTypes;
}
public RPCRequest setParameterTypes(Class[] parameterTypes) {
this.parameterTypes = parameterTypes;
return this;
}
}
RPCResponse
package matlab.engine.remote.rpc.core;
import java.io.Serializable;
/**
* PRC响应类型
*
* @author shirukai
*/
public class RPCResponse implements Serializable {
public static String SUCCEED = "succeed";
public static String FAILED = "failed";
private static final long serialVersionUID = 6595683424889346485L;
/**
* 响应状态
*/
private String status = "succeed";
/**
* 响应信息，如异常信息
*/
private String message;
/**
* 响应数据，返回值
*/
private Object data;
public String getStatus() {
return status;
}
public RPCResponse setStatus(String status) {
this.status = status;
return this;
}
public String getMessage() {
return message;
}
public RPCResponse setMessage(String message) {
this.message = message;
return this;
}
public Object getData() {
return data;
}
public RPCResponse setData(Object data) {
this.data = data;
return this;
}
}
RpcProvider
package matlab.engine.remote.rpc.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 用来创建RPC服务
*
* @author shirukai
*/
public class RpcProvider {
private static final Logger LOG = LoggerFactory.getLogger(RpcProvider.class);
public static
try {
LOG.info("The RPC Server is starting, address:{}, bind:{}", InetAddress.getLocalHost().getHostAddress(), port);
ServerSocket listener = new ServerSocket(port);
while (true) {
Socket socket = listener.accept();
// 接收数据并进行反序列化
ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
// 获取请求对象
Object object = objectInputStream.readObject();
if (object instanceof RPCRequest) {
RPCRequest request = (RPCRequest) object;
LOG.info("Received request:{}", request);
// 处理请求
RPCResponse response = handleRequest(ref, request);
// 将结果返回给客户端
LOG.info("Send response to client.{}", response);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
objectOutputStream.writeObject(response);
}
socket.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
private static
RPCResponse response = new RPCResponse();
try {
LOG.info("The server is handling request.");
Method method = ref.getClass().getMethod(request.getMethodName(), request.getParameterTypes());
Object data = method.invoke(ref, request.getParameters());
response.setData(data);
} catch (Exception e) {
response.setStatus(RPCResponse.FAILED).setMessage(e.getMessage());
}
return response;
}
}
RPCConsumer
package matlab.engine.remote.rpc.core;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.Socket;
/**
* 用来创建PRC客户端
*
* @author shirukai
*/
public class RPCConsumer {
@SuppressWarnings("unchecked")
public static
// 实例化RPC代理处理器
RPCInvocationHandler handler = new RPCInvocationHandler(host, port);
return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, handler);
}
private static class RPCInvocationHandler implements InvocationHandler {
private final String host;
private final Integer port;
public RPCInvocationHandler(String host, Integer port) {
this.host = host;
this.port = port;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 构建请求对象
RPCRequest rpcRequest = new RPCRequest();
rpcRequest.setMethodName(method.getName()).setParameterTypes(method.getParameterTypes()).setParameters(args);
// 使用客户端发送请求
RPCResponse response = this.send(rpcRequest);
// 响应成功返回结果
if (RPCResponse.SUCCEED.equals(response.getStatus())) {
return response.getData();
}
throw new RuntimeException(response.getMessage());
}
public RPCResponse send(RPCRequest rpcRequest) throws Exception {
Socket socket = new Socket(host, port);
//请求序列化
ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
//将请求发给服务提供方
objectOutputStream.writeObject(rpcRequest);
// 将响应体反序列化
ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
Object response = objectInputStream.readObject();
if (response instanceof RPCResponse) {
return (RPCResponse) response;
}
throw new RuntimeException("Return error");
}
}
}
3.2.1.1 服务端
在matlab.engine.remote.rpc.server下创建RPCServer
package matlab.engine.remote.rpc.server;
import matlab.engine.remote.common.Server;
import matlab.engine.remote.rpc.core.RpcProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* RPC服务端
*
* @author shirukai
*/
public class RPCServer
private static final Logger LOG = LoggerFactory.getLogger(Server.class);
public RPCServer(Integer port, T instance) {
super(port, instance);
}
@Override
public void start() throws Exception {
LOG.info("Starting the RPC-based Matlab engine...");
LOG.info("Listening port: {}.", port);
LOG.info("Service backend: {}.", instance.getClass());
RpcProvider.start(port, instance);
}
}
服务端创建完成之后，在ServerFactory中添加创建RPC服务端的代码
public static
return new RPCServer<>(port, instance);
}
3.2.1.2 客户端
在matlab.engine.remote.rpc.client下创建RPCClient
package matlab.engine.remote.rpc.client;
import matlab.engine.remote.common.Client;
import matlab.engine.remote.rpc.core.RPCConsumer;
/**
* PRC客户端
*
* @author shirukai
*/
public class RPCClient extends Client {
public RPCClient(String host, Integer port) {
super(host, port);
}
@Override
public
return RPCConsumer.get(host, port, interfaceClass);
}
}
客户端创建完成之后，在ClientFactory中添加创建RPC客户端的代码
public static Client createRPCClient(String host, Integer port) {
return new RPCClient(host, port);
}
3.2.1.3 运行验证
编写服务端示例
package matlab.engine.remote.example;
import matlab.engine.remote.common.Server;
import matlab.engine.remote.common.ServerFactory;
import matlab.engine.remote.service.MatlabEngineServiceImpl;
/**
* @author shirukai
*/
public class RPCEngineServerExamples {
public static void main(String[] args) throws Exception {
MatlabEngineServiceImpl service = new MatlabEngineServiceImpl();
Server
server.start();
}
}
编写客户端示例
package matlab.engine.remote.example;
import matlab.engine.remote.api.MatlabEngineService;
import matlab.engine.remote.common.Client;
import matlab.engine.remote.common.ClientFactory;
/**
* @author shirukai
*/
public class RPCEngineClientExamples {
public static void main(String[] args)throws Exception {
Client client = ClientFactory.createRPCClient("192.168.66.212", 10992);
MatlabEngineService service = client.get(MatlabEngineService.class);
double[] x = {2.0, 4.0, 6.0};
double[] res = service.feval("sqrt", x);
for (double e : res) {
System.out.println(e);
}
}
}
运行服务端示例
运行客户端示例
3.3 完整代码
Matlab Engine调用的完整代码也提交到github上了：https://github.com/shirukai/matlab-engine-java.git
4 总结
Java 本地及远程调用Matlab的两种实现方案都已经介绍完了，简单总结一下优缺点。
基于MCR的Jar类库
优点：运行环境不依赖Matlab，Runtime不需要Lincese授权，依赖环境安装包较小，可以在容器运行，生成的类库中自带远程调用的实现。
缺点：只能运行函数，而且需要对函数进行单独打包
Matlab Engine API
优点：调用灵活，可以运行函数以及脚本，不需要单独打包
缺点：需要自己进行远程调用的实现，运行环境需要安装matlab，docker支持不友好。