Java利用socket进行简单的远程过程调用

清疚 2022-05-22 09:41 315阅读 0赞

我们现在利用socket写一个简单的远程调用。

最简单实现远程调用的方式就是我们有一个客户端，然后我们去请求连接服务端，然后和服务端建立连接。然后客户端发送请求参数给服务端，服务端的代码中直接调用业务类中的指定方法并传入参数，最后将方法返回的结果发送会给客户端。

代码示例：  
这是我们的业务类，里面有我们客户端需要调用的方法。

package cn.itcast.bigdata.socket;
    
    public class GetDataServiceImpl {
    
        public String getData(String param){
    
            return "ok-"+param;
        }
    
    
    }

下面是服务端代码，和客户端建立起连接之后，开启一个服务线程。

package cn.itcast.bigdata.socket;
    
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class ServiceServer { 
    
        public static void main(String[] args) throws Exception {
    
            // 创建一个serversocket，绑定到本机的8899端口上
            ServerSocket server = new ServerSocket();
            server.bind(new InetSocketAddress("localhost", 8899));
    
            // 接受客户端的连接请求;accept是一个阻塞方法，会一直等待，到有客户端请求连接才返回
            while (true) {
                Socket socket = server.accept();
                new Thread(new ServiceServerTask(socket)).start();
            }
        }
    
    }

下面服务线程代码，服务端和客户端建立起连接之后，接受服务端发送来的请求参数，然后调用业务类中的`getDataServiceImpl.getData(param)`方法，最后将执行结果再发送给客户端。  
在这里的代码中，我们请求的业务类还有请求的方法都是写死的。当然后面我们会改造一下，写一个服务端可以根据客户端请求的业务类、业务方法来进行动态远程调用的示例，通过反射就可以实现。

package cn.itcast.bigdata.socket;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    public class ServiceServerTask implements Runnable{ 
        Socket socket ;
        InputStream in=null;
        OutputStream out = null;
    
        public ServiceServerTask(Socket socket) {
            this.socket = socket;
        }
    
        //业务逻辑：跟客户端进行数据交互
        @Override
        public void run() {
             try {
                //从socket连接中获取到与client之间的网络通信输入输出流 
                in = socket.getInputStream();
                out = socket.getOutputStream();
    
    
                BufferedReader br = new BufferedReader(new InputStreamReader(in));
                //从网络通信输入流中读取客户端发送过来的数据
                //注意：socketinputstream的读数据的方法都是阻塞的 
                String param = br.readLine();
    
    
                /** * * 将以下业务调用逻辑写成更加通用的：可以根据客户端发过来的调用类名、调用方法名、调用该参数来灵活调用 * * 实现：反射 * */
    
                GetDataServiceImpl getDataServiceImpl = new GetDataServiceImpl();
                String result = getDataServiceImpl.getData(param);
    
    
                //将调用结果写到sokect的输出流中，以发送给客户端
                PrintWriter pw = new PrintWriter(out);
                pw.println(result);
                pw.flush();
    
    
    
            } catch (IOException e) {
    
                e.printStackTrace();
            }finally{
                try {
                    in.close();
                    out.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            }
    
        }
    
    }

客户端代码，请求服务端建立连接，然后发送方法参数给服务端，最后获取服务端的执行结果。

package cn.itcast.bigdata.socket;
    
    import java.io.BufferedReader;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    public class ServiceClient {
    
        public static void main(String[] args) throws Exception {
    
    
            // 向服务器发出请求建立连接
            Socket socket = new Socket("localhost", 8899);
            // 从socket中获取输入输出流
            InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream();
    
            PrintWriter pw = new PrintWriter(outputStream);
            pw.println("hello");
            pw.flush();
    
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            String result = br.readLine();
            System.out.println(result);
    
            inputStream.close();
            outputStream.close();
            socket.close();
    
    
        }
    }

测试：  
![这里写图片描述][70]

接下来我们把业务调用逻辑写成更加通用的：可以根据客户端发过来的调用类名、调用方法名、调用该参数来灵活调用。  
下面我们来看看简单的远程调用过程实现图：  
![这里写图片描述][70 1]

下面来看代码：  
业务类：

package cn.itcast_04_reflect.socket;
    
    public interface IBusiness {
        public int getPrice(String good);
    }

package cn.itcast_04_reflect.socket;
    
    public class TestBusiness implements IBusiness{ 
        @Override
        public int getPrice(String good){
            return good.equals("yifu")?10:20;
        }
    }

服务端：

package cn.itcast_04_reflect.socket;
    
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class TestServer { 
    
        public static void main(String[] args) throws Exception {
            ServerSocket server = new ServerSocket();
            server.bind(new InetSocketAddress("localhost",9898));
            while(true){
                Socket socket = server.accept();
                new Thread(new TestServerTask(socket)).start();
            }
        }
    
    
    }

服务端线程类：

package cn.itcast_04_reflect.socket;
    
    import java.io.BufferedOutputStream;
    import java.io.BufferedReader;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.lang.reflect.Method;
    import java.net.Socket;
    
    public class TestServerTask implements Runnable{
        private Socket socket;
        public TestServerTask(Socket socket){
            this.socket = socket;
        }
    
        @Override
        public void run() {
            InputStream in;
            OutputStream out;
            try {
                in = socket.getInputStream();
                out = socket.getOutputStream();
    
                BufferedReader br = new BufferedReader(new InputStreamReader(in));
                String request = br.readLine();
                String[] split = request.split(":");
                String className = split[0];
                String methodName = split[1];
                String methodParam= split[2];
    
                Class<?> forName = Class.forName(className);
                System.out.println("calling class: " + forName);
                Object newInstance = forName.newInstance();
                Method method = forName.getMethod(methodName,String.class);
                System.out.println("calling method: " + method);
                Object invoke = method.invoke(newInstance, methodParam);
                System.out.println("results: " + (int)invoke);
    
    
                PrintWriter pw = new PrintWriter(new BufferedOutputStream(out));
                pw.println((int)invoke);
                pw.flush();
    
                br.close();
                pw.close();
                socket.close();
    
            } catch (Exception e) {
    
                e.printStackTrace();
            }
    
        }
    
    }

客户端：

测试：  
![这里写图片描述][70 2]

![这里写图片描述][70 3]

这就是Java利用socket进行简单的远程过程调用的实现。

[70]: /images/20220522/fb230a974df94b8aba353a5280bc31a9.png
[70 1]: /images/20220522/b08fadadfe464b5b94604149cc976039.png
[70 2]: /images/20220522/d656c6a232c446bbb422250bb52466d8.png
[70 3]: /images/20220522/2ffc9c603f12402ea381e9d98398f7c3.png