Shulou(Shulou.com)06/02 Report--

This article focuses on "how to understand RPC through Java code", interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to understand RPC through Java code.

The whole process can be summed up in one sentence: machine An establishes a connection with machine B through the network, and A sends some parameters to Bline B to execute a process and returns the result to A.

"before writing the code, let's talk about a pre-background, suppose we have a commodity class:

Public class Product implements Serializable {private Integer id; private String name; public Product (Integer id, String name) {this.id = id; this.name = name;} / / toString () / / get set method}

There is a commodity service interface:

Public interface IProductService {Product getProductById (Integer id);}

The server has the implementation class of the commodity service interface:

Public class ProductServiceImpl implements IProductService {@ Override public Product getProductById (Integer id) {/ / actually, you should query the database to get the data. The following simplifies return new Product (id, "mobile phone");}}

Below, we send a commodity id to the server through the client. After obtaining the id, the server obtains the commodity information through the commodity service class and returns it to the client:

Public class Client {public static void main (String [] args) throws Exception {/ / establish Socket Socket socket = new Socket ("127.0.0.1", 8888); / / get the output stream ByteArrayOutputStream baos = new ByteArrayOutputStream (); DataOutputStream dos = new DataOutputStream (baos); / / transfer the commodity Id over the network to the server dos.writeInt (123) Socket.getOutputStream () .write (baos.toByteArray ()); socket.getOutputStream () .flush (); / / read the commodity information returned by the server DataInputStream dis = new DataInputStream (socket.getInputStream ()); Integer id = dis.readInt (); / / Commodity id String name = dis.readUTF (); / / Commodity name Product product = new Product (id, name) / / generate commodity System.out.println (product) from the commodity information returned by the server; / / close the stream resources to facilitate reading without try-catch processing dos.close (); baos.close (); socket.close ();}} public class Server {private static boolean running = true Public static void main (String [] args) throws Exception {/ / establish server Socket ServerSocket ss = new ServerSocket (8888); / / continuously monitor and process client request while (running) {Socket socket = ss.accept (); process (socket); socket.close ();} ss.close () } private static void process (Socket socket) throws Exception {InputStream is = socket.getInputStream (); OutputStream os = socket.getOutputStream (); DataInputStream dis = new DataInputStream (is); DataOutputStream dos = new DataOutputStream (os); / / read id Integer id = dis.readInt () sent by the client; / / call the service class to generate goods IProductService service = new ProductServiceImpl () Product product = service.getProductById (id); / / write the product information back to the client dos.writeInt (id); dos.writeUTF (product.getName ()); dos.flush (); dos.close (); dis.close (); os.close (); is.close ();}}

The above is the original simple version of RPC remote call, you can see that the networking code is written in the client, and the network part of the code is coupled with getProductById (). If you want to change other methods to remote calls, you have to rewrite the networking code, which is very troublesome.

In actual use, we write all kinds of remote calls. For example, the IProductService interface may be expanded like this in the future:

Public interface IProductService {Product getProductById (Integer id); Product getProductByName (String name); Product getMostExpensiveProduct ();}

We can't write a network connection code for every method, we have to think of a way to embed a common network connection code for all methods.

Then how exactly should it be embedded? We can use the proxy mode here.

Many excellent frameworks in Java use proxy mode for code embedding, such as Mybatis. It embeds the JDBC concatenation code around the sql statement through proxy mode, allowing us to focus on writing sql.

First of all, the code on the server side needs to be modified. Since multiple methods share a set of networked code, we need to identify which method is called on the server side:

Public class Server {private static boolean running = true; public static void main (String [] args) throws Exception {/. } private static void process (Socket socket) throws Exception {/ / get the input stream, output stream InputStream is = socket.getInputStream (); OutputStream os = socket.getOutputStream (); ObjectInputStream ois = new ObjectInputStream (is); ObjectOutputStream oos = new ObjectOutputStream (os); / / get the method name of this remote call String methodName = ois.readUTF () / / get the parameter type Class [] parameterTypes = (Class []) ois.readObject () of this remote call method; / / get the specific parameter object Object [] args = (Object []) ois.readObject (); / / create a commodity and service class instance, (you can continue to optimize it here later) IProductService service = new ProductServiceImpl () / / based on the method name and parameters obtained remotely, call the corresponding method Method method = service.getClass () .getMethod (methodName, parameterTypes); Product product = (Product) method.invoke (service, args); / / write the result back to the client oos.writeObject (product); oos.close (); ois.close (); socket.close ();}}

Then on the client side, we create a new proxy class that provides a method for getStub to get the proxy class. Dynamic proxies using JDK require three parameters, one is the class loader, one is the class class of the interface, and the last one is the InvocationHandler instance.

The logic behind the JDK dynamic proxy is that JVM dynamically creates a proxy class object based on the interface's class class, which implements the incoming interface, that is, it has the implementation of all the methods in the interface. The specific implementation of the method can be specified by the user, that is, calling the invoke method of InvocationHandler.

There are three parameters in the invoke method, which are the proxy proxy class, the method called by method, and the parameter of the method called by args. We can enhance the specific implementation method in the invoke method, which in this case is to make network calls. Public class Stub {public static IProductService getStub () {InvocationHandler h = new InvocationHandler () {@ Override public Object invoke (Object proxy, Method method, Object [] args) throws Throwable {/ / and server establish Socket connection Socket socket = new Socket ("127.0.0.1", 8888); ObjectOutputStream oos = new ObjectOutputStream (socket.getOutputStream ()) / / get the method name of the remote call String methodmethodName = method.getName (); / / get the parameter type of the remote call method Class [] parametersTypes = method.getParameterTypes (); / / pass the method name to the server oos.writeUTF (methodName) / / pass the method parameter type to the server oos.writeObject (parametersTypes); / / pass the method parameter to the server oos.writeObject (args); oos.flush () / / get the returned result of remote call ObjectInputStream ois = new ObjectInputStream (socket.getInputStream ()); Product product = (Product) ois.readObject (); ois.close (); oos.close (); socket.close (); return product;}} Object o = Proxy.newProxyInstance (IProductService.class.getClassLoader (), new Class [] {IProductService.class}, h); return (IProductService) o;}}

This new version is a little better than the first version, but it can still be optimized. Now that our proxy can only return the implementation class of IProductService, we have to find a way to get it to return any type of service implementation class.

The idea is similar to the remote invocation method, when we call the method remotely, we pass the method name, parameter type, parameter to the server; now to dynamically create the service class, we can pass the name of the service interface to the server. After the server gets the name of the remote interface, it can find the corresponding service implementation class in the service registry.

As for how the service implementation class registers with the service registry, here is an idea: consider using Spring's annotation injection. This is similar to writing spring code. After creating the service implementation class, we will add the annotation @ Service, so that after receiving the remote call, we can traverse the Bean that uses @ Service and find the corresponding implementation class.

At this point, I believe you have a deeper understanding of "how to understand RPC through Java code". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.