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

我们现在利用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();


    }
}

测试：

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

下面来看代码：
业务类：

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();
        }

    }

}

客户端：

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.net.Socket;

public class TestClient {

    public static void main(String[] args) throws Exception {



        Socket socket = new Socket("localhost", 9898);
        OutputStream out = socket.getOutputStream();
        InputStream in = socket.getInputStream();

        PrintWriter pw = new PrintWriter(new BufferedOutputStream(out));
        pw.println("cn.itcast_04_reflect.socket.TestBusiness:getPrice:yifu");
        pw.flush();

        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        String readLine = br.readLine();

        System.out.println("client get result: " + readLine);


        socket.close();



    }
}

测试：

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