dubbo源码学习笔记----RPC

public class RpcContext {    private static final ThreadLocal<RpcContext> LOCAL = new ThreadLocal<RpcContext>() {
        @Override        protected RpcContext initialValue() {            return new RpcContext();
        }
    };    private final Map<String, String> attachments = new HashMap<String, String>();    private final Map<String, Object> values = new HashMap<String, Object>();    private Future<?> future;    private List<URL> urls;    private URL url;    private String methodName;    private Class<?>[] parameterTypes;    private Object[] arguments;    private InetSocketAddress localAddress;    private InetSocketAddress remoteAddress;
    @Deprecated    private List<Invoker<?>> invokers;
    @Deprecated    private Invoker<?> invoker;
    @Deprecated    private Invocation invocation;

    public <T> Future<T> asyncCall(Callable<T> callable) {        try {            try {
                setAttachment(Constants.ASYNC_KEY, Boolean.TRUE.toString());                final T o = callable.call();                //local invoke will return directly
                if (o != null) {
                    FutureTask<T> f = new FutureTask<T>(new Callable<T>() {                        public T call() throws Exception {                            return o;
                        }
                    });
                    f.run();                    return f;
                } else {

                }
            } catch (Exception e) {                throw new RpcException(e);
            } finally {
                removeAttachment(Constants.ASYNC_KEY);
            }
        } catch (final RpcException e) {            return new Future<T>() {                public boolean cancel(boolean mayInterruptIfRunning) {                    return false;
                }                public boolean isCancelled() {                    return false;
                }                public boolean isDone() {                    return true;
                }                public T get() throws InterruptedException, ExecutionException {                    throw new ExecutionException(e.getCause());
                }                public T get(long timeout, TimeUnit unit)
                        throws InterruptedException, ExecutionException,
                        TimeoutException {                    return get();
                }
            };
        }        return ((Future<T>) getContext().getFuture());
    }

public class RpcInvocation implements Invocation, Serializable {    private static final long serialVersionUID = -4355285085441097045L;    private String methodName;    private Class<?>[] parameterTypes;    private Object[] arguments;    private Map<String, String> attachments;    private transient Invoker<?> invoker;

public class JavassistProxyFactory extends AbstractProxyFactory {    @SuppressWarnings("unchecked")
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }

    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {        // TODO Wrapper cannot handle this scenario correctly: the classname contains '$'
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);        return new AbstractProxyInvoker<T>(proxy, type, url) {            @Override
            protected Object doInvoke(T proxy, String methodName,                                      Class<?>[] parameterTypes,                                      Object[] arguments) throws Throwable {                return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
            }
        };
    }

}


public class JdkProxyFactory extends AbstractProxyFactory {    @SuppressWarnings("unchecked")
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {        return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), interfaces, new InvokerInvocationHandler(invoker));
    }

    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {        return new AbstractProxyInvoker<T>(proxy, type, url) {            @Override
            protected Object doInvoke(T proxy, String methodName,                                      Class<?>[] parameterTypes,                                      Object[] arguments) throws Throwable {                Method method = proxy.getClass().getMethod(methodName, parameterTypes);                return method.invoke(proxy, arguments);
            }
        };
    }

}

          resource = jedisPool.getResource();                        if (get.equals(invocation.getMethodName())) {                            if (invocation.getArguments().length != 1) {                                throw new IllegalArgumentException("The redis get method arguments mismatch, must only one arguments. interface: " + type.getName() + ", method: " + invocation.getMethodName() + ", url: " + url);
                            }                            byte[] value = resource.get(String.valueOf(invocation.getArguments()[0]).getBytes());                            if (value == null) {                                return new RpcResult();
                            }
                            ObjectInput oin = getSerialization(url).deserialize(url, new ByteArrayInputStream(value));                            return new RpcResult(oin.readObject());