java代码实现rpc

java代码实现rpc:

http://www.cnblogs.com/codingexperience/p/5930752.html

public interface CalcService{
    public String sayHello(String name);
}

public class CalcServiceImpl implements CalcService{
    @Override
    public String sayHello(String name) {
        return "hello " + name;
    }
}

public class RPCServer {  
      
    public static ConcurrentHashMap<String, Class<?>> classMap = new ConcurrentHashMap<String,Class<?>>();  
    private static void registeService(Class<?> inter,Class<?> impl) {
        classMap.put(inter.getName(), impl);
    }  
    
    private static Class<?> getService(String interName) {
        return classMap.get(interName);
    }  
    
    public static void main(String [] args) throws Exception{  
        registeService(CalcService.class,CalcServiceImpl.class);
        System.err.println("server start");  
        RPCServer.invoker(8080);  
    }  
    
    public static void invoker(int port) throws Exception{  
        ServerSocket server = new ServerSocket(port);  
        for(;;){  
            final Socket socket = server.accept();  
            new Thread(new Runnable() {  
                ObjectOutputStream output =  null;  
                @Override  
                public void run() {  
                    try {  
                        ObjectInputStream input = new ObjectInputStream(socket.getInputStream());  
                        String interName = input.readUTF();  
                        String methodName = input.readUTF();  
                        Class<?>[] parameterTypes = (Class<?>[])input.readObject();    
                        Object[] arguments = (Object[])input.readObject();    
                        Class<?> claszz = getService(interName);  
                        Object obj = claszz.newInstance();
                        Method method = claszz.getMethod(methodName, parameterTypes);
                        Object result = method.invoke(obj, arguments);    
                        output = new ObjectOutputStream(socket.getOutputStream());   
                        output.writeObject(result);   
                        output.close();
                    }catch(SecurityException e) {
                        e.printStackTrace();
                    } catch(InvocationTargetException e) {
                        e.printStackTrace();
                    }catch(IllegalArgumentException e){  
                        e.printStackTrace();  
                    }catch(IllegalAccessException e){  
                        e.printStackTrace();  
                    }catch(ClassNotFoundException e){  
                        e.printStackTrace();  
                    }catch(IOException e){  
                        e.printStackTrace();  
                    } catch (InstantiationException e) {
                        e.printStackTrace();
                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                    }finally {  
                        try {  
                        output.close(); 
                        socket.close();
                    } catch (IOException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
            }).start();  
        }  
    }  
} 

public class RpcProxy<T> {
    
    @SuppressWarnings("unchecked")
    public static <T>  T getProxy(Class<?> serviceInterface) {
        return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class<?>[]{serviceInterface}, new InvocationHandler() {
           
            @Override  
            public Object invoke(Object proxy, Method method, Object[] args)  
                    throws Throwable {  
                 Socket socket = new Socket("localhost", 8080);  
                 ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());    
                 try {    
                     output.writeUTF(serviceInterface.getName());  
                     output.writeUTF(method.getName());    
                     output.writeObject(method.getParameterTypes());    
                     output.writeObject(args);    
                     output.flush();
                     
                     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();    
                     socket.close();  
                 }   
            }
        });
    }
}

public class Client {
    public static void main(String[] args) {
        CalcService p = RpcProxy.getProxy(CalcService.class);
        String r = (String)p.sayHello("sfdsfds");
        System.out.println(r);
    }
}