/*

 * 定义了服务器提供的服务类型

 */

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;

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                 Invocation invo = new Invocation();

                 invo.setInterfaces(clazz);

                 //利用反射机制将java.lang.reflect.Method 所代表的方法名,参数 封装到 Invocation invo对象中

                 invo.setMethod(new org.jy.rpc.protocal.Method(method.getName(),method.getParameterTypes()));

                 invo.setParams(args);

                 /*

                  * 当把需要调用的远程server端的方法名和参数封装到invo之后，Client 对象 就可以把 invo 作为参数 传递给服务器了.

                  * 为什么需要这样做呢？InvocationHandler 的invoke方法是自动执行的，在该方法里面，它根据生成的代理对象 proxy (第一个参数)

                  * 所实现的接口(由 Proxy.newProxyInstance()的第二个参数指定) 就可以知道这个接口中定义了哪些方法

                  * InvocationHandler 的 invoke 方法的第二个参数Method method 就可以解析出接口中的方法名和参数了

                  * 把它们封装进Invocation invo对象中,再将 invo 作为 client.invoke(invo)的参数 发送到服务器方

                  */

                 client.invoke(invo);//invoke 先调用init发起一个Socket连接,再将invo 发送至输出流中

                 return invo.getResult();

             }

     public void invoke(Invocation invo) throws UnknownHostException, IOException, ClassNotFoundException {

         init();

         System.out.println("写入数据");

         oos.writeObject(invo);//将Client 需要调用的Server的 接口、方法、参数 封装起来 发给服务器

         oos.flush();

         ois = new ObjectInputStream(socket.getInputStream());//用来接收从 server 返回 回来的执行结果 的输入流

         Invocation result = (Invocation) ois.readObject();

         invo.setResult(result.getResult());//将结果 保存到 Invocation result对象中

     }

 public void call(Invocation invo) {

             System.out.println(invo.getClass().getName());

             Object obj = serviceEngine.get(invo.getInterfaces().getName());

             if(obj!=null) {

                 try {

                     Method m = obj.getClass().getMethod(invo.getMethod().getMethodName(), invo.getMethod().getParams());

                     /*

                      * 利用JAVA反射机制来执行java.lang.reflect.Method 所代表的方法

                      * @param result : 执行实际方法后 得到的 服务的执行结果

                      */

                     Object result = m.invoke(obj, invo.getParams());

                     invo.setResult(result);//将服务的执行结果封装到invo对象中。在后面的代码中，将该对象写入到输出流中

                 } catch (Throwable th) {

                     th.printStackTrace();

                 }

             } else {

                 throw new IllegalArgumentException("has no these class");

             }

         }