Matlab版本: 2020b
Matlab提供了丰富的工具箱,如果可以使用Java调用Matlab来实现一些特定的算法,确实是一个不错的想法,经过实验证明这个想法可行,但是性能差点事情,对于一些特殊场景还是可以尝试的。查阅了网上大量的资料,实现Java调用Matlab基本有两种实现思路:1. 将Matlab函数打成Jar类库 ,然后基于MCR运行 2. 使用Matlab提供的Java Matlab Engine API。 本篇文章也是围绕着两个思路,介绍具体实现方法,这其中也会分别介绍本地调用,以及远程调用两种方式。
注意:安装Matlab的时候,一定要安装如下组件:
实现原理很简单,就是利用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软件界面进行打包。
如果安装Matlab,并且勾选的文章一开头说的那些选项,就会将MCR一起安装好,当然也可以单独安装MCR,参考:https://ww2.mathworks.cn/help/compiler/install-the-matlab-runtime.html,这里就不单独安装了。
打开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应用中引用这个类库即可。
上面通过Matlab的「Library Compiler」成功打包了一个包含FFT函数的Java类库,接下来要介绍如何在我们自己的Java项目中去调用这个类库。
使用IDEA创建一个名为matlab-mcr-java的Maven项目
在项目中创建一个名字为「lib」的文件夹,并将matlab安装目录中的R2020b\toolbox\javabuilder\jar\javabuilder.jar
,以及我们生成的类库signalprocessor.jar
复制到这个文件夹下
修改pom.xml文件,加载lib中的两个类库
<dependencies>
<dependency>
<groupId>matlabgroupId>
<artifactId>matlab.javabuilderartifactId>
<version>2020Rversion>
<scope>systemscope>
<systemPath>${basedir}/lib/javabuilder.jarsystemPath>
dependency>
<dependency>
<groupId>matlabgroupId>
<artifactId>matlab.signalprocessorartifactId>
<version>1.0version>
<scope>systemscope>
<systemPath>${basedir}/lib/signalprocessor.jarsystemPath>
dependency>
dependencies>
maven重新加载
创建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的机器上运行,注意,对象初始化会比较慢,如果要在项目中使用,可以提前初始化对象,后面直接进行方法调用即可
上面开发的程序,必须要在具有MCR的环境中运行。其实在打包Java类库的时候,有一个选项,询问用户是否将Matlab Runtime的类库一并打包,如果选择这个选项的话,就不需要单独的MCR环境,显然实际项目中这么做不太理想,因为包含MCR的一个Java类库就几个G大小。另外一个问题就是,不能每一个应用都体用一个MCR环境,这样也会造成资源的浪费,所以Matlab提供了基于RMI远程调用的方式,关于什么是RMI,参考这篇文章:https://www.cnblogs.com/wxisme/p/5296441.html。
如上是Matlab官网提供的RMI远程调用的架构图,客户端不需要具有MCR环境,服务具有就可以了。下面将通过代码,分别实现客户端和服务端示例。
在官方的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);
}
客户端需要获取远程的桩,然后再进行调用
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。
完整的代码已经提交到Github上了:https://github.com/shirukai/matlab-mcr-java.git
上一节介绍了通过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
使用IDEA创建一个名为matlab-engine-java的Maven项目
_
这里需要engine api相关的依赖,在Matlab的安装目录\R2020b\extern\engines\java\jar\engine.jar,在项目中创建一个lib目录,将engine.jar复制到lib目录下。修改pom.xml,引入依赖
<dependencies>
<dependency>
<groupId>matlabgroupId>
<artifactId>matlab.engineartifactId>
<version>2020Rversion>
<scope>systemscope>
<systemPath>${basedir}/lib/engine.jarsystemPath>
dependency>
<dependency>
<groupId>org.slf4jgroupId>
<artifactId>slf4j-log4j12artifactId>
<version>1.7.36version>
dependency>
dependencies>
在项目中创建包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=”
本篇文章提供两种远程调用的方式: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
*/
<T> T feval(String funcName, Object... params) throws RemoteException;
/**
* 执行Matlab脚本
*
* @param script 脚本
* @throws RemoteException 兼容RMI
*/
void eval(String script) throws RemoteException;
/**
* 获取变量
* 执行eval()方法之后,可以调用此方法获取脚本中的变量
*
* @param varName 变量名称
* @param 返回值类型
* @return 变量结果
* @throws RemoteException 兼容RMI
*/
<T> T getVariable(String varName) throws RemoteException;
}
实现接口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 <T> T feval(String funcName, Object... params) throws RemoteException {
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 <T> T getVariable(String varName) throws RemoteException {
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 <T> T get(Class<T> interfaceClass) throws Exception;
}
定义客户端抽象类
在matlab.engine.remote.common
包下创建Server抽象类
package matlab.engine.remote.common;
/**
* 定义服务端创建参数,及启动方法
*
* @author shirukai
*/
public abstract class Server<T> {
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 <T extends Remote> Server<T> createRMIServer(Integer port, T instance) {
// TODO
}
/**
* 创建RPC的服务端
*
* @param port 监听端口号
* @param instance 代理实例
* @param 实例类型
* @return RPC服务端
*/
public static <T> Server<T> createRPCServer(Integer port, T instance) {
//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;
}
}
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<T extends Remote> extends Server<T> {
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 <T extends Remote> Server<T> createRMIServer(Integer port, T instance) {
return new RMIServer<>(port, instance);
}
客户单也是很简单,继承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 <T> T get(Class<T> interfaceClass) throws Exception {
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);
}
编写服务端示例,在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<MatlabEngineServiceImpl> server = ServerFactory.createRMIServer(10991, service);
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));
}
}
运行服务端示例
运行客户端示例
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 <T> void start(int port, T ref) {
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 <T> RPCResponse handleRequest(T ref, RPCRequest request) {
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 <T> T get(String host, Integer port, Class<?> interfaceClass) {
// 实例化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");
}
}
}
在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<T> extends Server<T> {
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 <T> Server<T> createRPCServer(Integer port, T instance) {
return new RPCServer<>(port, instance);
}
在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 <T> T get(Class<T> interfaceClass) throws Exception {
return RPCConsumer.get(host, port, interfaceClass);
}
}
客户端创建完成之后,在ClientFactory中添加创建RPC客户端的代码
public static Client createRPCClient(String host, Integer port) {
return new RPCClient(host, port);
}
编写服务端示例
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<MatlabEngineServiceImpl> server = ServerFactory.createRPCServer(10992, service);
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);
}
}
}
Matlab Engine调用的完整代码也提交到github上了:https://github.com/shirukai/matlab-engine-java.git
Java 本地及远程调用Matlab的两种实现方案都已经介绍完了,简单总结一下优缺点。
基于MCR的Jar类库
优点:运行环境不依赖Matlab,Runtime不需要Lincese授权,依赖环境安装包较小,可以在容器运行,生成的类库中自带远程调用的实现。
缺点:只能运行函数,而且需要对函数进行单独打包
Matlab Engine API
优点:调用灵活,可以运行函数以及脚本,不需要单独打包
缺点:需要自己进行远程调用的实现,运行环境需要安装matlab,docker支持不友好。