rpc 簡單模型

package com.self.socket.cli;

import java.lang.reflect.Method;

public class ClientTask {
    private String clz;
    private Method method;
    private Object[] args;
    private Object object;
    public synchronized void setResult(Object obj){
        this.object=obj;
        this.notify();
    }

    public synchronized Object getObject() {
        if(object==null){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return object;
    }

    public ClientTask(String clz, Method method, Object[] args) {
        this.clz = clz;
        this.method = method;
        this.args = args;
    }

    public String getClz() {
        return clz;
    }

    public Method getMethod() {
        return method;
    }

    public Object[] getArgs() {
        return args;
    }
}

package com.self.socket.cli;

import com.ali.service.Learn;
import com.self.socket.system.Common;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SocketCli {

    public static void main(String[] args) {
        SocketWork.work(Common.client_do);
        Learn learn= SocketWork.refer(Learn.class);
        ExecutorService executorService= Executors.newCachedThreadPool();
        for(int i=0;i<1000;i++){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    //System.out.println(learn.get());
                    learn.time(System.currentTimeMillis());
                }
            });

        }
    }
}

package com.self.socket.cli;

import com.self.socket.system.Common;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.Socket;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class SocketWork {
    public static LinkedBlockingQueue<ClientTask> queue=new LinkedBlockingQueue();

    public static  <T> T refer(final Class<T> referClass){
        InvocationHandler invocationHandler=  new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                String key=referClass.getCanonicalName();
                ClientTask task=new ClientTask(key,method,args);
                SocketWork.queue.put(task);
                return task.getObject();
            }
        };
        return (T) Proxy.newProxyInstance(referClass.getClassLoader(), new Class[]{referClass},invocationHandler);
    }

    public static void work(int num){
        ExecutorService executorService= Executors.newCachedThreadPool();
        for(int i=0;i<num;i++){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Socket socket=new Socket(Common.ip,Common.port);
                        OutputStream outputStream = socket.getOutputStream();
                        ObjectOutputStream objectOutputStream=new ObjectOutputStream(outputStream);
                        ObjectInputStream objectInputStream=new ObjectInputStream(socket.getInputStream());
                        for (;;){
                            ClientTask task=queue.take();
                            objectOutputStream.writeUTF(task.getClz());
                            objectOutputStream.writeUTF(task.getMethod().getName());
                            objectOutputStream.writeObject(task.getMethod().getParameterTypes());
                            objectOutputStream.writeObject(task.getArgs());
                            objectOutputStream.flush();
                            Object object=objectInputStream.readObject();
                            task.setResult(object);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

package com.self.socket.server;
import com.self.socket.system.Common;
import com.self.socket.system.Cache;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.*;


public class RegisterSocket {
    //存放socket任務
    static LinkedBlockingQueue queue=new LinkedBlockingQueue();
    public static void main(String[] args) {
        ServerSocket serverSocket= null;
        try {
            serverSocket = new ServerSocket(Common.port);
            work();
           for(;;){
               Socket  socket=serverSocket.accept();
               System.out.println("一個新客戶端進來了！");
               ServerWork serverWork =new ServerWork(socket);
               Cache.cacheSocket.put(serverWork.hashCode(), serverWork);
           }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private static void work(){
        //檢測是否有socket傳遞數據過來
        new Thread(new Runnable() {
            public void run() {
                for (;;) {
                    for (ServerWork serverWork: Cache.cacheSocket.values()) {
                        if(serverWork.isAvailable()){
                            try {
                                System.out.println("name:"+serverWork.hashCode());
                                queue.put(serverWork);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }

                }
            }
        }).start();
        //處理socket數據
        ExecutorService executorService= Executors.newFixedThreadPool(Common.server_do);
        for (int i=0;i<Common.server_do;i++){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        for(;;){
                            ServerWork serverWork = (ServerWork)queue.take();
                            serverWork.doGet();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

}

package com.self.socket.server;
import com.self.socket.system.Cache;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.Socket;
import java.util.Random;


public class ServerWork{
    private Socket socket;
    private InputStream inputStream;
    private volatile  boolean isRead=true;
    private ObjectInputStream objectInputStream;
    private  ObjectOutputStream objectOutputStream;
    public  ServerWork(Socket socket) {
        this.socket=socket;
        init();
    }
    private  void init(){
        try {
            inputStream=socket.getInputStream();
            objectInputStream=new ObjectInputStream(inputStream);
            objectOutputStream=new ObjectOutputStream(socket.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public synchronized boolean isAvailable(){
        try {
            if(inputStream.available()>0&&isRead){
                isRead=false;
                return true;
            }
            return false;
        } catch (IOException e) {
            e.printStackTrace();
            close();
            Cache.cacheSocket.remove(this.hashCode());
            return false;
        }
    }
    public void doGet()  {
        System.out.println(Thread.currentThread().getName()+" server is running");
        try {
            try {
               String clz= objectInputStream.readUTF()+"Impl";
               String methodName=objectInputStream.readUTF();
                Class<?>[] classes= (Class<?>[]) objectInputStream.readObject();
                Object[] args= (Object[]) objectInputStream.readObject();
                Method method=Class.forName(clz).getMethod(methodName,classes);
                Object obj=method.invoke(Class.forName(clz).newInstance(),args);
                objectOutputStream.writeObject(obj);
                objectOutputStream.flush();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }finally {
                isRead=true;
            }
        } catch (IOException e) {
            e.printStackTrace();
            close();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public void close(){
        try {
            inputStream.close();
            objectInputStream.close();
            objectOutputStream.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package com.self.socket.system;

import com.self.socket.server.ServerWork;

import java.util.concurrent.ConcurrentHashMap;

public class Cache {
    //存放服務端 socket  一直遍歷循環 檢測是否有數據過來
    public  static ConcurrentHashMap<Integer,ServerWork> cacheSocket=new ConcurrentHashMap<Integer, ServerWork>();
}

package com.self.socket.system;

public interface Common {
    String ip="localhost";
    int port =10086;
    //服務端處理數據 線程、
    int server_do=10;
    //服務端線程數量
    int client_do=10;
}