正文
远程调用代码java,远程代码执行
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
JAVA 远程 调用的几种实现方式简析 详细�0�3
基本原理 要实现网络机器间的通讯，首先得来看看计算机系统网络通信的基本原理，在底层层面去看，网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http、tcp、 udp 等等，http、tcp、udp 都是在基于Socket 概念上为某类应用场景而扩展出的传输协议，网络IO，主要有bio、nio、aio 三种方式，所有的分布式应用通讯都基于这个原理而实现，只是为了应用的易用，各种语言通常都会提供一些更为贴近应用易用的应用层协议。 应用级协议 远程服务通讯，需要达到的目标是在一台计算机发起请求，另外一台机器在接收到请求后进行相应的处理并将结果返回给请求端，这其中又会有诸如 onewayrequest、同步请求、异步请求等等请求方式，按照网络通信原理，需要实现这个需要做的就是将请求转换成流，通过传输协议传输至远端，远端计算机在接收到请求的流后进行处理，处理完毕后将结果转化为流，并通过传输协议返回给调用端。原理是这样的，但为了应用的方便，业界推出了很多基于此原理之上的应用级的协议，使得大家可以不用去直接操作这么底层的东西，通常应用级的远程通信协议会提供: 1.为了避免直接做流操作这么麻烦，提供一种更加易用或贴合语言的标准传输格式;2.网络通信机制的实现，就是替你完成了将传输格式转化为流，通过某种传输协议传输至远端计算机，远端计算机在接收到流后转化为传输格式，并进行存储或以某种方式通知远端计算机。 所以在学习应用级的远程通信协议时，我们可以带着这几个问题进行学习: 1.传输的标准格式是什么?2.怎么样将请求转化为传输的流?3.怎么接收和处理流?4.传输协议是? 不过应用级的远程通信协议并不会在传输协议上做什么多大的改进，主要是在流操作方面，让应用层生成流和处理流的这个过程更加的贴合所使用的语言或标准，至于传输协议则通常都是可选的，在java 领域中知名的有:RMI、 XML-RPC、Binary-RPC、SOAP、CORBA、JMS，来具体的看看这些远程通信的应用级协议: RMIRMI 是个典型的为java 定制的远程通信协议，我们都知道，在 singlevm 中，我们可以通过直接调用javaobjectinstance 来实现通信，那么在远程通信时，如果也能按照这种方式当然是最好了，这种远程通信的机制成为RPC(RemoteProcedureCall)，RMI 正是朝着这个目标而诞生的。 来看下基于RMI 的一次完整的远程通信过程的原理: 1.客户端发起请求，请求转交至RMI 客户端的stub 类;2.stub 类将请求的接口、方法、参数等信息进行序列化;3.基于socket 将序列化后的流传输至服务器端;4.服务器端接收到流后转发至相应的skelton 类;5.skelton 类将请求的信息反序列化后调用实际的处理类;6.处理类处理完毕后将结果返回给 skelton 类;7.Skelton 类将结果序列化，通过socket 将流传送给客户端的 stub;8.stub 在接收到流后反序列化，将反序列化后的JavaObject 返回给调用者。 根据原理来回答下之前学习应用级协议带着的几个问题: 1.传输的标准格式是什么?是JavaObjectStream。2.怎么样将请求转化为传输的流?基于Java 串行化机制将请求的javaobject 信息转化为流。3.怎么接收和处理流?根据采用的协议启动相应的监听端口，当有流进入后基于Java 串行化机制将流进行反序列化，并根据RMI 协议获取到相应的处理对象信息，进行调用并处理，处理完毕后的结果同样基于java 串行化机制进行返回。4.传输协议是?Socket。 XML-RPCXML-RPC 也是一种和RMI 类似的远程调用的协议，它和RMI 的不同之处在于它以标准的 xml 格式来定义请求的信息(请求的对象、方法、参数等)，这样的好处是什么呢，就是在跨语言通讯的时候也可以使用。 来看下XML-RPC 协议的一次远程通信过程: 1.客户端发起请求，按照XML-RPC 协议将请求信息进行填充;2.填充完毕后将xml 转化为流，通过传输协议进行传输;3.接收到在接收到流后转换为xml，按照XML-RPC 协议获取请求的信息并进行处理;4.处理完毕后将结果按照XML- RPC 协议写入xml 中并返回。 同样来回答问题: 1.传输的标准格式是?标准格式的XML。2.怎么样将请求转化为传输的流? 将XML 转化为流。3.怎么接收和处理流?通过监听的端口获取到请求的流，转化为XML，并根据协议获取请求的信息，进行处理并将结果写入XML 中返回。4. 传输协议是?Http。 Binary-RPCBinary-RPC 看名字就知道和XML-RPC 是差不多的了，不同之处仅在于传输的标准格式由XML 转为了二进制的格式。 同样来回答问题: 1.传输的标准格式是?标准格式的二进制文件。2.怎么样将请求转化为传输的流?将二进制格式文件转化为流。3.怎么接收和处理流?通过监听的端口获取到请求的流，转化为二进制文件，根据协议获取请求的信息，进行处理并将结果写入XML 中返回。4.传输协议是?Http。 SOAPSOAP 原意为SimpleObjectAccessProtocol，是一个用于分布式环境的、轻量级的、基于XML 进行信息交换的通信协议，可以认为SOAP 是XMLRPC 的高级版，两者的原理完全相同，都是http+XML，不同的仅在于两者定义的XML 规范不同，SOAP 也是Webservice 采用的服务调用协议标准，因此在此就不多加阐述了。 CORBACommonObjectRequestBrokerArchitecture(公用对象请求代理[调度]程序体系结构)，是一组用来定义"分布式对象系统"的标准，由 OMG(ObjectMenagementGroup)作为发起和标准制定单位。CORBA 的目的是定义一套协议，符合这个协议的对象可以互相交互，不论它们是用什么样的语言写的，不论它们运行于什么样的机器和操作系统。CORBA 在我看来是个类似于SOA 的体系架构，涵盖可选的远程通信协议，但其本身不能列入通信协议这里来讲，而且CORBA 基本淘汰，再加上对CORBA 也不怎么懂，在此就不进行阐述了。 JMSJMS 呢，是实现java 领域远程通信的一种手段和方法，基于JMS 实现远程通信时和RPC 是不同的，虽然可以做到RPC 的效果，但因为不是从协议级别定义的，因此我们不认为JMS 是个RPC 协议，但它确实是个远程通信协议，在其他的语言体系中也存在着类似JMS 的东西，可以统一的将这类机制称为消息机制，而消息机制呢，通常是高并发、分布式领域推荐的一种通信机制，这里的主要一个问题是容错(详细见ErLang 论文)。 来看JMS 中的一次远程通信的过程: 1.客户端将请求转化为符合JMS 规定的Message;2.通过JMSAPI 将Message 放入JMSQueue 或Topic 中;3.如为JMSQueue，则发送中相应的目标Queue 中，如为Topic，则发送给订阅了此Topic 的JMSQueue。4.处理端则通过轮训 JMSQueue，来获取消息，接收到消息后根据JMS 协议来解析Message 并处理。 回答问题: 1.传输的标准格式是?JMS 规定的Message。2.怎么样将请求转化为传输的流?将参数信息放入Message 中即可。3.怎么接收和处理流?轮训JMSQueue 来接收Message，接收到后进行处理，处理完毕后仍然是以Message 的方式放入 Queue 中发送或Multicast。4.传输协议是?不限。 基于JMS 也是常用的实现远程异步调用的方法之一。
相关问答
Q1: java远程调用接口的原理和范例，谢谢
Java 远程处理
Java远程方法调用(RMI)提供了Java程序语言的远程通讯功能,这种特性使客户机上运行的程序可以调用远程服务器上的对象,使Java编程人员能够在网络环境中分布操作。
创建一个简单的Java分布式远程方法调用程序可以按以下几个步骤操作,
一、定义远程接口：
在 Java 中，远程对象是实现远程接口的类的实例, 远程接口声明每个要远程调用的方法。在需要创建一个远程对象的时候，我们通过传递一个接口来隐藏基层的实施细节，客户通过接口句柄发送消息即可。
远程接口具有如下特点：
1) 远程接口必须为public属性。如果不这样，除非客户端与远程接口在同一个包内，否则 当试图装入实现该远程接口的远程对象时，调用会得到错误结果。
2) 远程接口必须扩展接口java.rmi.Remote。
3) 除与应用程序本身特定的例外之外，远程接口中的每个方法都必须在自己的throws从句中 声明java.rmi.RemoteException。（或 RemoteException 的父类）。
4) 作为参数或返回值传递的一个远程对象(不管是直接，还是本地对象中嵌入)必须声明为远 程接口，而不应声明为实施类。
下面是远程接口的定义
[java] view plaincopy
package test;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.math.BigInteger;
public interface Fib extends Remote {
public int getFib(int n) throws RemoteException;
// public BigInteger getFib(BigInteger n) throws RemoteException;
}
二、实现远程接口：
远程对象实现类必须扩展远程对象java.rmi.UnicastRemoteObject类，并实现所定义的远程接口。远程对象的实现类中包含实现每个远程接口所指定的远程方法的代码。这个类也可以含有附加的方法，但客户只能使用远程接口中的方法。因为客户是指向接口的一个句柄，而不是它的哪个类。必须为远程对象定义构造函数，即使只准备定义一个默认构造函数，用它调用基础类构造函数。因为基础类构造函数可能会抛出 java.rmi.RemoteException，所以即使别无它用必须抛出java.rmi.RemoteException例外。
以下是远程对象实现类的声明：
[java] view plaincopy
package test;
import java.math.BigInteger;
import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
public class FibImp extends UnicastRemoteObject implements Fib {
public FibImp() throws RemoteException {
super();
}
public int getFib(int n) throws RemoteException {
return n+2;
}
}
三、编写服务器类:
包含 main 方法的类可以是实现类自身，也可以完全是另一个类。下面通过RmiSampleServer 来创建一个远程对象的实例，并通过java.rmi.registry.LocateRegistry类的createRegistry 方法从指定端口号启动注册服务程序，也可以通过执行 rmiregistry 命令启动注册服务程序，注册服务程序的缺省运行端口为 1099。必须将远程对象名字绑定到对远程对象的引用上： Naming.rebind("//localhost:8808/SAMPLE-SERVER" , Server);
以下是服务器类的声明：
[java] view plaincopy
package test;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
public class FibonacciServer {
/**
* @param args
*/
public static void main(String[] args) {
try {
LocateRegistry.createRegistry(8804);
FibImp f = new FibImp();
// 注册到 registry 中
Naming.rebind("//localhost:8804/SAMPLE-SERVER", f);
System.out.println("fib server ready");
} catch (RemoteException re) {
System.out.println("Exception in FibonacciImpl.main: " + re);
} catch (MalformedURLException e) {
System.out.println("MalformedURLException " + e);
}
}
}
四、编写使用远程服务的客户机类:
客户机类的主要功能有两个，一是通过Naming.lookup方法来构造注册服务程序 stub 程序实例，二是调用服务器远程对象上的远程方法。
以下是客户端类的声明：
[java] view plaincopy
package testClient;
import test.Fib;
import java.math.BigInteger;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
public class FibClient {
/**
* @param args
*/
public static void main(String[] args) {
String url = "//localhost:8804/SAMPLE-SERVER";
try {
Fib calc = (Fib) Naming.lookup(url);
for (int i = 0; i 10; ++i) {
int f = calc.getFib(i);
System.out.println(f);
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (RemoteException e) {
e.printStackTrace();
} catch (NotBoundException e) {
e.printStackTrace();
}
}
}
Q2: 救，air调用本地java程序和远程java怎么实现
JNI是JavaNativeInterface的缩写，中文为JAVA本地调用。从Java1.1开始，JavaNativeInterface(JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他语言，只要调用约定受支持就可以了。
使用java与本地已编译的代码交互，通常会丧失平台可移植性。但是，有些情况下这样做是可以接受的，甚至是必须的，比如，使用一些旧的库，与硬件、操作系统进行交互，或者为了提高程序的性能。JNI标准至少保证本地代码能工作在任何Java虚拟机实现下。
------------------------------------------------------------------
编写带有native声明的方法的java类
·使用javac命令编译所编写的java类
·使用javah?jnijava类名生成扩展名为h的头文件
·使用C/C++实现本地方法
·将C/C++编写的文件生成动态连接库
·ok
1)编写java程序：这里以HelloWorld为例。
代码1：
classHelloWorld{
publicnativevoiddisplayHelloWorld();
static{
System.loadLibrary("hello");
}
publicstaticvoidmain(String[]args){
newHelloWorld().displayHelloWorld();
}
}
声明native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明改方法为native的，并且不能实现。其中方法的参数和返回值在后面讲述。Load动态库：System.loadLibrary("hello");加载动态库（我们可以这样理解：我们的方法displayHelloWorld()没有实现，但是我们在下面就直接使用了，所以必须在使用之前对它进行初始化）这里一般是以static块进行加载的。同时需要注意的是System.loadLibrary();的参数“hello”是动态库的名字。
2)编译
没有什么好说的了javacHelloWorld.java
3)生成扩展名为h的头文件javah?
jniHelloWorld头文件的内容：/*DONOTEDITTHISFILE-itismachinegenerated*/
1.include
/*HeaderforclassHelloWorld*/
1.ifndef_Included_HelloWorld
2.define_Included_HelloWorld
3.ifdef__cplusplus
extern"C"{
1.endif
/*
*Class:HelloWorld
*Method:displayHelloWorld
*Signature:()V
*/
JNIEXPORTvoidJNICALLJava_HelloWorld_displayHelloWorld(JNIEnv*,jobject);
1.ifdef__cplusplus
}
1.endif
2.endif
（这里我们可以这样理解：这个h文件相当于我们在java里面的接口，这里声明了一个Java_HelloWorld_displayHelloWorld(JNIEnv*,jobject);方法，然后在我们的本地方法里面实现这个方法，也就是说我们在编写C/C++程序的时候所使用的方法名必须和这里的一致）。
4)编写本地方法实现和由javah命令生成的头文件里面声明的方法名相同的方法。
代码2：
1#include"jni.h"
2#include"HelloWorld.h"
3//#includeotherheaders
4JNIEXPORTvoidJNICALLJava_HelloWorld_displayHelloWorld(JNIEnv*env,jobjectobj)
{
printf("Helloworld!\n");
return;
}
注意代码2中的第1行，需要将jni.h（该文件可以在%JAVA_HOME%/include文件夹下面找到）文件引入，因为在程序中的JNIEnv、jobject等类型都是在该头文件中定义的；另外在第2行需要将HelloWorld.h头文件引入（我是这么理解的：相当于我们在编写java程序的时候，实现一个接口的话需要声明才可以，这里就是将HelloWorld.h头文件里面声明的方法加以实现。当然不一定是这样）。然后保存为HelloWorldImpl.c就ok了。
5)生成动态库
这里以在Windows中为例，需要生成dll文件。在保存HelloWorldImpl.c文件夹下面，使用VC的编译器cl成。cl-I%java_home%\include-I%java_home%\include\win32-LDHelloWorldImp.c-Fehello.dll注意：生成的dll文件名在选项-Fe后面配置，这里是hello，因为在HelloWorld.java文件中我们loadLibary的时候使用的名字是hello。当然这里修改之后那里也需要修改。另外需要将-I%java_home%\include-I%java_home%\include\win32参数加上，因为在第四步里面编写本地方法的时候引入了jni.h文件。
6)运行程序javaHelloWorld就ok.
---------------------------------------------------------------
下面是一个简单的例子实现打印一句话的功能，但是用的c的printf最终实现。一般提供给java的jni接口包括一个so文件（封装了c函数的实现）和一个java文件（需要调用path的类）。
1．JNI的目的是使java方法中能够调用c实现的一些函数，比如以下的java类，就需要调用一个本地函数testjni（一般声明为privatenative类型），首先需要创建文件weiqiong.java，内容如下：
classweiqiong{static{System.loadLibrary("testjni");//载入静态库，test函数在其中实现}privatenativevoidtestjni();//声明本地调用publicvoidtest(){testjni();}publicstaticvoidmain(Stringargs[]){weiqionghaha=newweiqiong();haha.test();}}
2．然后执行javacweiqiong.java，如果没有报错，会生成一个weiqiong.class。
3．然后设置classpath为你当前的工作目录，如直接输入命令行：setclasspath=weiqiong.class所在的完整目录（如c:\test)再执行javahweiqiong，会生成一个文件weiqiong.h文件，其中有一个函数的声明如下：
JNIEXPORTvoidJNICALLJava_weiqiong_testjni(JNIEnv*,jobject);
4．创建文件testjni.c将上面那个函数实现，内容如下：
1.include
2.include
JNIEXPORTvoidJNICALLJava_weiqiong_testjni(JNIEnv*env,jobjectobj){printf("haha---------gointoc!!!\n");}
5．为了生成.so文件，创建makefile文件如下：
libtestjni.so:testjni.omakefilegcc-Wall-rdynamic-shared-olibtestjni.sotestjni.otestjni.o:testjni.cweiqiong.hgcc-Wall-ctestjni.c-I./-I/usr/java/j2sdk1.4.0/include-I/usr/java/j2sdk1.4.0/include/linuxcl:rm-rf*.o*.so注意：gcc前面是tab空，j2sdk的目录根据自己装的j2sdk的具体版本来写，生成的so文件的名字必须是loadLibrary的参数名前加“lib”。
6．exportLD_LIBRARY_PATH=.，由此设置library路径为当前目录，这样java文件才能找到so文件。一般的做法是将so文件copy到本机的LD_LIBRARY_PATH目录下。
7．执行javaweiqiong，打印出结果：“haha---------gointoc!!!”
Q3: java如何远程调用。。。。。。。。。
RMI远程调用。你查一下这个。
或是webservices
下边是一个例子，运行server,
再运行client,可以得到对象。
-------------------------------------------------------
import java.rmi.Remote;
import java.rmi.registry.LocateRegistry;
import java.util.Date;
import javax.naming.Context;
import javax.naming.InitialContext;
public class Server {
public static void main(String[] args) throws Exception {
LocateRegistry.createRegistry(2099);
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
System.setProperty(Context.PROVIDER_URL, "rmi://localhost:2099");
Context ctx = new InitialContext();
ctx.bind("systemStartTime", new RemoteDate());
ctx.close();
while (true)
Thread.sleep(1000);
}
}
class RemoteDate extends Date implements Remote {
}
--------------------
import java.util.Date;
import javax.naming.Context;
import javax.naming.InitialContext;
public class Client {
public static void main(String[] args) throws Exception {
Context ctx = new InitialContext();
Date startTime = (Date) ctx
.lookup("rmi://localhost:2099/systemStartTime");
System.out.println(startTime);
}
}
Q4: 怎么用java代码调用远程Linux上的shell脚本
package org.shirdrn.shell;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.Session;
/**
* 远程Shell脚本执行工具
*
* @author Administrator
*/
public class RemoteShellTool {
private Connection conn;
private String ipAddr;
private String charset = Charset.defaultCharset().toString();
private String userName;
private String password;
public RemoteShellTool(String ipAddr, String userName, String password, String charset) {
this.ipAddr = ipAddr;
this.userName = userName;
this.password = password;
if(charset != null) {
this.charset = charset;
}
}
/**
* 登录远程Linux主机
*
* @return
* @throws IOException
*/
public boolean login() throws IOException {
conn = new Connection(ipAddr);
conn.connect(); // 连接
return conn.authenticateWithPassword(userName, password); // 认证
}
/**
* 执行Shell脚本或命令
*
* @param cmds 命令行序列
* @return
*/
public String exec(String cmds) {
InputStream in = null;
String result = "";
try {
if (this.login()) {
Session session = conn.openSession(); // 打开一个会话
session.execCommand(cmds);
in = session.getStdout();
result = this.processStdout(in, this.charset);
conn.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
return result;
}
/**
* 解析流获取字符串信息
*
* @param in 输入流对象
* @param charset 字符集
* @return
*/
public String processStdout(InputStream in, String charset) {
byte[] buf = new byte[1024];
StringBuffer sb = new StringBuffer();
try {
while (in.read(buf) != -1) {
sb.append(new String(buf, charset));
}
} catch (IOException e) {
e.printStackTrace();
}
return sb.toString();
}
}
