什么是REST
REST是一种架构风格，指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。
REST规范把所有内容都视为资源，网络上一切皆资源。
REST并没有创造新的技术，组件或服务，只是使用Web的现有特征和能力。
可以完全通过HTTP协议实现，使用 HTTP 协议处理数据通信。
REST架构对资源的操作包括获取、创建、修改和删除资源的操作正好对应HTTP协议提供的GET、POST、PUT和DELETE方法。
什么是RPC
远程方法调用，就是像调用本地方法一样调用远程方法.
RPC框架要做到的最基本的三件事：
、服务端如何确定客户端要调用的函数；
在远程调用中，客户端和服务端分别维护一个【ID->函数】的对应表， ID在所有进程中都是唯一确定的。
客户端在做远程过程调用时，附上这个ID，服务端通过查表，来确定客户端需要调用的函数，然后执行相应函数的代码。
、如何进行序列化和反序列化；
客户端和服务端交互时将参数或结果转化为字节流在网络中传输，那么数据转化为字节流的或者将字节流转换成能读取
的固定格式时就需要进行序列化和反序列化，序列化和反序列化的速度也会影响远程调用的效率。
、如何进行网络传输（选择何种网络协议）；
多数RPC框架选择TCP作为传输协议，也有部分选择HTTP。如gRPC使用HTTP2。不同的协议各有利弊。TCP更加高效，
而HTTP在实际应用中更加的灵活。
RPC简单案例实现
创建client
package com.hadoop.hdfs.rpc2.client;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.Scanner;
public class Client<T> {
public T getClass(Class<?> clazz, InetSocketAddress address) {
T t = (T) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
new Class<?>[]{clazz.getInterfaces()[]}, (proxy, method, args) -> {
Socket socket = new Socket();
socket.connect(address);
try (
ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
) {
objectOutputStream.writeUTF(clazz.getName());
objectOutputStream.writeUTF(method.getName());
objectOutputStream.writeObject(method.getParameterTypes());
objectOutputStream.writeObject(args);
return objectInputStream.readObject();
}finally {
if (socket!=null){
socket.close();
}
}
});
return t;
}
}
创建server
package com.hadoop.hdfs.rpc2.server;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class Server {
//线程池
static Executor executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
public static void exporter(String host, int port) throws IOException {
try (ServerSocket serverSocket = new ServerSocket();) {
serverSocket.bind(new InetSocketAddress(host, port));
//不断监听
while (true) {
executor.execute(new Task(serverSocket.accept()));
}
}
}
private static class Task implements Runnable {
Socket client = null;
public Task(Socket client) {
this.client = client;
}
@Override
public void run() {
try (
ObjectInputStream objectInputStream = new ObjectInputStream(client.getInputStream());
ObjectOutputStream objectOutputStream = new ObjectOutputStream(client.getOutputStream());
) {
String interfaceName = objectInputStream.readUTF();
Class servce = Class.forName(interfaceName);
String methodName = objectInputStream.readUTF();
Class<?>[] parameterTypes = (Class<?>[]) objectInputStream.readObject();
Object[] arguments = (Object[]) objectInputStream.readObject();
Method method = servce.getMethod(methodName, parameterTypes);
Object obj = method.invoke(servce.newInstance(), arguments);
objectOutputStream.writeObject(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
创建调用的接口和实现类
package com.hadoop.hdfs.rpc2.server;
public interface Method {
public void method1();
}package com.hadoop.hdfs.rpc2.server;
public class MethodImpl implements Method {
@Override
public void method1() {
System.out.println("method1");
}
}创建测试类
package com.hadoop.hdfs.rpc2.client;
import com.hadoop.hdfs.rpc2.server.Method;
import com.hadoop.hdfs.rpc2.server.MethodImpl;
import com.hadoop.hdfs.rpc2.server.Server;
import java.io.IOException;
import java.net.InetSocketAddress;
public class Test {
public static void main(String[] args) {
//服务器
new Thread(() -> {
try {
Server.exporter("localhost",);
} catch (IOException e) {
e.printStackTrace();
}
}).start();
//客户端
new Thread(() -> {
Client<Method> import1 = new Client();
Method method = import1.getClass(MethodImpl.class,new InetSocketAddress("localhost",));
method.method1();
}).start();
}
}