/*
 * 定义了服务器提供的服务类型
 */
public interface Echo {
    public String echo(String string);
}

Echo echo = RPC.getProxy(Echo.class, "127.0.0.1", 20382);
System.out.println(echo.echo("hello,hello"));//使用代理对象调用服务器的服务.并将结果输出

        Server server = new RPC.RPCServer();

        /*
         * server 启动后,需要注册server端能够提供的服务,这样client使用 服务的名字、
         * 服务器的IP、以及服务所运行的端口 来调用 server 的服务
         */
        server.register(Echo.class, RemoteEcho.class);//注册服务的名字
        server.register(AnOtherEchoService.class, AnOtherEchoServiceImpl.class);
        
        server.start();//启动server

public void start() {
            System.out.println("启动服务器");
            
            /*
             * server 启动时,需要Listener监听是否有client的请求连接
             * listener 是一个线程,由它来监听连接
             */
            listener = new Listener(this);
            this.isRuning = true;
            listener.start();//listener 是一个线程类,start()后会执行线程的run方法
        }

/*
 * accept()是一个阻塞方法,server_socket 一直等待client 是否有连接到来
 */
 Socket client = server_socket.accept();//建立一条TCP连接

/*
         * @param Class[]{} 该参数声明了动态生成的代理对象实现了的接口,即 clazz 所代表的接口类型 .
         * 这表明了生成的代理对象它是一个它所实现了的接口类型的对象
         * 从而就可以用它来调用它所实现的接口中定义的方法
         * 
         * @param handler 生成代理实例对象时需要传递一个handler参数
         * 这样当该 代理实例对象调用接口中定义的方法时,将会委托给InvocationHandler 接口中声明的invoke方法
         * 此时,InvocationHandler 的invoke 方法将会被自动调用
         */
        T t = (T) Proxy.newProxyInstance(RPC.class.getClassLoader(), new Class[] {clazz}, handler);
        return t;

 1 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 2                 Invocation invo = new Invocation();
 3                 invo.setInterfaces(clazz);
 4                 
 5                 //利用反射机制将java.lang.reflect.Method 所代表的方法名,参数 封装到 Invocation invo对象中
 6                 invo.setMethod(new org.jy.rpc.protocal.Method(method.getName(),method.getParameterTypes()));
 7                 invo.setParams(args);
 8                 
 9                 /*
10                  * 当把需要调用的远程server端的方法名和参数封装到invo之后，Client 对象 就可以把 invo 作为参数 传递给服务器了.
11                  * 为什么需要这样做呢？InvocationHandler 的invoke方法是自动执行的，在该方法里面，它根据生成的代理对象 proxy (第一个参数)
12                  * 所实现的接口(由 Proxy.newProxyInstance()的第二个参数指定) 就可以知道这个接口中定义了哪些方法
13                  * InvocationHandler 的 invoke 方法的第二个参数Method method 就可以解析出接口中的方法名和参数了
14                  * 把它们封装进Invocation invo对象中,再将 invo 作为 client.invoke(invo)的参数 发送到服务器方
15                  */
16                 client.invoke(invo);//invoke 先调用init发起一个Socket连接,再将invo 发送至输出流中
17                 return invo.getResult();
18             }

1     public void invoke(Invocation invo) throws UnknownHostException, IOException, ClassNotFoundException {
2         init();
3         System.out.println("写入数据");
4         oos.writeObject(invo);//将Client 需要调用的Server的 接口、方法、参数 封装起来 发给服务器
5         oos.flush();
6         ois = new ObjectInputStream(socket.getInputStream());//用来接收从 server 返回 回来的执行结果 的输入流
7         Invocation result = (Invocation) ois.readObject();
8         invo.setResult(result.getResult());//将结果 保存到 Invocation result对象中
9     }

 1 public void call(Invocation invo) {
 2             System.out.println(invo.getClass().getName());
 3             Object obj = serviceEngine.get(invo.getInterfaces().getName());
 4             if(obj!=null) {
 5                 try {
 6                     Method m = obj.getClass().getMethod(invo.getMethod().getMethodName(), invo.getMethod().getParams());
 7                     /*
 8                      * 利用JAVA反射机制来执行java.lang.reflect.Method 所代表的方法
 9                      * @param result : 执行实际方法后 得到的 服务的执行结果
10                      */
11                     Object result = m.invoke(obj, invo.getParams());
12                     invo.setResult(result);//将服务的执行结果封装到invo对象中。在后面的代码中，将该对象写入到输出流中
13                 } catch (Throwable th) {
14                     th.printStackTrace();
15                 }
16             } else {
17                 throw new IllegalArgumentException("has no these class");
18             }
19         }