用JAVA动态代理实现RPC框架

原创 2016年08月17日 17:15:25

        先贴一段看到的对动态代理的比较不错的解释


动态代理其实就是Java.lang.reflect.Proxy类动态的根据指定的所有接口生成一个class byte,该class会继承Proxy类,并实现所有指定的接口(在参数中传入的接口数组),也就是说,返回的对象可以转换类型为接口数组中的任何一个接口类型。然后再利用第一个参数的classloader将class byte加载进系统,最后生成这样一个类的对象并初始化该对象的一些值,如invocationHandler,则是在参数中传入的第三个参数,以及所有的接口对应的method成员,初始化之后将对象返回给调用的客户端,这样客户端就拿到了一个实现所有接口的Proxy对象 


还有一部分很关键,就是动态代理会代理哪些方法:


在Proxy.newProxyInstance方法调用时,具体步骤如下

1  根据传入的第二个参数interface数组动态生成类,实现interfaces数组中每个interface的接口方法,并且继承了Proxy类,重写了hashcode,toString,equals等方法,对应的类名称为$Proxy0,这里有一个很重要的点,就是会重写哪些方法,上面已经介绍了包括所有interfacade的接口方法,重写了3个基本Object的方法,所以例如getClass等方法是不会被重写的,可以通过对比动态代理的返回的对象调用toString和getClass方法来测试,前者是会经过代理方法,而后者却不会经过代理方式。


2  通过传入的第一个参数classloader将第一步生成的类加载到jvm中


3  利用第三个参数,调用$Proxy0的$Proxy0(InvocationHandler)构造方法,创建这个类的实例,并且将invocationHandler对象设置进类实例中,循环所有接口方法,将invocationHandler对象织入实现中,所以调用任何一个接口方法,实际上都是调用的invocationHandler.invoke方法,真正的业务逻辑实际也在invoke里面,通过传入的具体的invocationHandler对象来实现(一般是新建类继承InvocationHandler类,并且将真正的实现者注入进去),至于$Proxy0会不会在invoke方法的前后加入代码,例如日志,统计等没有具体研究。另外还会生成Method对象,初始化$Proxy0实例的几个Method成员变量


4  将第三部生成的$Proxy0实例返回给客户端。



再来贴出通过动态代理的实现的RPC调用的代码,从这个例子学到了很多东西,包括动态代理,以及基于Java动态代理的RPC调用的基础原理,当然这个例子只是用Java实现

的RPC框架调用。



1  基础RPC框架类,包括暴露服务和引用服务

package whu;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Locale.Category;

public class RpcFramework {

    public static void export(Object service, Class interfaceClazz, int port) throws Exception {
        if (service == null) {
            throw new IllegalAccessException("service instance == null");
        }
        if (port < 0 || port > 65535) {
            throw new IllegalAccessException("Invalid port " + port);
        }
        System.out.println("Export service " + service.getClass().getName() + " on port " + port);

        ServerSocket server = new ServerSocket(port);
        for (;;) {
            final Socket socket = server.accept();
            try {
                new Thread(new Runnable() {

                    @Override
                    public void run() {
                        try {
                            try {
                                ObjectInputStream input = new ObjectInputStream(socket.getInputStream());

                                try {
                                    String interfaceName = input.readUTF();
                                    String methodName = input.readUTF();
                                    Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
                                    Object[] arguments = (Object[]) input.readObject();
                                    ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());

                                    try {
                                        if (!interfaceName.equals(interfaceClazz.getName())) {
                                            throw new IllegalAccessException("Interface wrong, export:" + interfaceClazz
                                                    + " refer:" + interfaceName);
                                        }
                                        Method method = service.getClass().getMethod(methodName, parameterTypes);
                                        Object result = method.invoke(service, arguments);
                                        output.writeObject(result);
                                    } catch (Throwable t) {
                                        output.writeObject(t);
                                    } finally {
                                        output.close();
                                    }
                                } finally {
                                    input.close();
                                }
                            } finally {
                                socket.close();
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    @SuppressWarnings("unchecked")
    public static <T> T refer(Class<T> interfaceClass, String host, int port) throws Exception {
        if (interfaceClass == null) {
            throw new IllegalAccessException("Interface class == null");
        }
        if (!interfaceClass.isInterface()) {
            throw new IllegalAccessException(interfaceClass.getName() + " must be interface");
        }
        if (host == null || host.length() == 0) {
            throw new IllegalAccessException("host == null");
        }
        if (port <= 0 || port > 65535) {
            throw new IllegalAccessException("Invalid port " + port);
        }
        System.out.println("Get remote service " + interfaceClass.getName() + " from server " + host + ":" + port);
        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] { interfaceClass },
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // TODO Auto-generated method stub
                        Socket socket = new Socket(host, port);
                        try {
                            ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());

                            try {
                                output.writeUTF(method.getName());
                                output.writeObject(method.getParameterTypes());
                                output.writeObject(args);

                                ObjectInputStream input = new ObjectInputStream(socket.getInputStream());

                                try {
                                    Object result = input.readObject();
                                    if (result instanceof Throwable) {
                                        throw (Throwable) result;
                                    }
                                    return result;
                                } finally {
                                    input.close();
                                }

                            } finally {
                                output.close();
                            }

                        } finally {
                            socket.close();
                        }
                    }
                });
    }

}

2   接口类

package whu;

public interface HelloService {

    String hello();

    String hello(String name);

}


 3  接口实现类

package impl;

import whu.HelloService;

public class HelloServiceImpl implements HelloService {

    @Override
    public String hello() {
        return "Hello";
    }

    @Override
    public String hello(String name) {
        return "Hello," + name;
    }

}

4   服务提供方+Server


package whu;

import impl.HelloServiceImpl;

public class RpcProvider {

    public static void main(String[] args) throws Exception {
        HelloService service = new HelloServiceImpl();
        RpcFramework.export(service, HelloService.class, 9000);
    }

}


5   服务消费方+Client


package whu;

public class RpcConsumer {

    public static void main(String[] args) throws Exception {
        HelloService service = RpcFramework.refer(HelloService.class, "127.0.0.1", 9000);
        String result = service.hello("rod");
        System.out.println(result);
    }

}





JAVA中几种常用的RPC框架介绍

RPC是远程过程调用的简称,广泛应用在大规模分布式应用中,作用是有助于系统的垂直拆分,使系统更易拓展。Java中的RPC框架比较多,各有特色,广泛使用的有RMI、Hessian、Dubbo等。 1、R...
  • zhaowen25
  • zhaowen25
  • 2015年05月02日 23:17
  • 86251

JAVA中几种常用的RPC框架介绍

RPC是远程过程调用的简称,广泛应用在大规模分布式应用中,作用是有助于系统的垂直拆分,使系统更易拓展。Java中的RPC框架比较多,各有特色,广泛使用的有RMI、Hessian、Dubbo等。...
  • volts
  • volts
  • 2017年01月22日 22:36
  • 5138

深入浅出 RPC - 深入篇

《深入篇》我们主要围绕 RPC 的功能目标和实现考量去展开,一个基本的 RPC 框架应该提供什么功能,满足什么要求以及如何去实现它? RPC 功能目标 RPC 的主要功能目标是让构建分布式计算(应用)...
  • mindfloating
  • mindfloating
  • 2014年09月22日 11:25
  • 222474

java实现简单的RPC框架(源码)

java自定义rpc框架:RpcFramework.java: Java代码   /*   * Copyright 2011 Alibaba.com All right ...
  • zmx729618
  • zmx729618
  • 2016年11月17日 11:38
  • 2566

Java实现简单的RPC框架

一、RPC简介 RPC,全称为Remote Procedure Call,即远程过程调用,它是一个计算机通信协议。它允许像调用本地服务一样调用远程服务。它可以有不同的实现方式。如RMI(远程方法...
  • u014731752
  • u014731752
  • 2016年11月29日 17:57
  • 592

Java实现一个简单的RPC框架(四) 编码和解码

参考: crylearner专栏  一个简单的RPC框架是如何炼成的 :http://blog.csdn.net/crylearner/article/details/46898537 前面我们...
  • v_xchen_v
  • v_xchen_v
  • 2016年12月13日 22:12
  • 496

Java实现一个简单的RPC框架(五) 基于Socket的传输层实现

参考: crylearner专栏  一个简单的RPC框架是如何炼成的 :http://blog.csdn.net/crylearner/article/details/46898537 前面我们已...
  • v_xchen_v
  • v_xchen_v
  • 2016年12月24日 08:36
  • 743

Java简易RPC框架学习(一)

1、前言 更多请前往个人博客 随着web技术越发成熟,技术体系越发地完善。在小公司经常会看见一个项目就是全部,但是大公司的系统就不一样了,由于业务种类的繁多,业务量的巨大,大公司的项目通常会将一些...
  • Maitianshouwei
  • Maitianshouwei
  • 2016年11月26日 22:30
  • 978

Java常见分布式协议比较-RPC

Java的远程调用有多种分布式协议可供使用,但其种类繁多,容易让人困扰。本系列博客分别对它们做入门介绍: RMI: 含JBoss-Remoting,Spring Remoting RPC: 含...
  • zfc2201
  • zfc2201
  • 2013年04月13日 01:22
  • 2239

简单的RPC java实现

我也承认,RPC的名声大噪之时是在2003年,那一个“冲击波”病毒(Blaster Worm virus)袭卷全球的一年。而“冲击波”正是用着RPC这把刀来敲开了远程电脑的大门。当然RPC 有更多正...
  • jackliang55
  • jackliang55
  • 2012年05月18日 15:53
  • 19343
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:用JAVA动态代理实现RPC框架
举报原因:
原因补充:

(最多只允许输入30个字)