Java Socket分發服務負載均衡

1、 設備請求分發服務器，分發服務器返回有效的socket服務器ip與port，然后斷開連接。
a) 設備與服務器建立連接。
b) 服務器接收到連接請求后，立即將分配好的socket服務器ip與port信息響應給設備。
c) 服務器主動斷開socket連接。
2、 設備得到ip與port以后，設備去連接socket服務器，然后與其進行協議通訊。
a) 設備連接到socket服務器。
b) socket服務器響應連接成功響應信息。
c) 設備與socket服務器保持長鏈接通訊。

*. 若設備未收到連接成功響應則再次嘗試連接，若三次請求依舊沒有成功建立連接，那么設備需要去請求分發服務器然后再重新上述操作。
*. 當設備在異常情況下鏈接不上socket服務器時，依舊嘗試三次若不能成功，則直接請求分發服務器，然后再重復上述操作。

分發服務器代碼：
分發服務與客戶端是短鏈接：
package com.easygo.server;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CenterServer implements Runnable{
    ServerSocket serverSocket=null;
    static volatile String server_ip="127.0.0.1";
    static volatile int serverport1=8085;
    static volatile int serverport2=8086;
    public static void main(String[] args) {
        new Thread(new CenterServer()).start();
        
    }

    @Override
    public void run() {
         ExecutorService cachedThreadPool = null;//線程池
            cachedThreadPool = Executors.newCachedThreadPool();//線程池
            try {
                serverSocket=new ServerSocket(9999);
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        while(true){
            try {
                
                cachedThreadPool.execute(new ServerRun(serverSocket.accept()));
                System.out.println("有一個客戶端連進來了..");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }

    
    
}
class ServerRun implements Runnable{
    Socket socket=null;
    ServerRun(Socket socket){
        this.socket=socket;
        
    }
    @Override
    public void run() {
        
        receive();
        
        
    }
    public void send(String message){
        try {
            socket.getOutputStream().write(message.getBytes());
            socket.getOutputStream().flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
    }
    public void receive(){
        
        byte[]tmp=null;
        String message=null;
        
        boolean runs=true;
        while(runs){
            if(null!=socket){
                tmp=new byte[30];
                
                @SuppressWarnings("unused")
                int count =0;
                try {
                    while((count=socket.getInputStream().read(tmp))!=-1){
                        message=new String(tmp);
                        System.out.println("Clent:"+message.trim());
                        if(message.trim().split(",")[0].equals("login")&&message.trim().split(",")[1].equals("1")){
                            
                            send("login,"+CenterServer.server_ip+","+CenterServer.serverport1);
                        }else if(message.trim().split(",")[0].equals("login")&&message.trim().split(",")[1].equals("2")){
                            
                            send("login,"+CenterServer.server_ip+","+CenterServer.serverport2);
                        }else if(message.equals("0")){
                            if(socket!=null){
                                socket.close();
                                
                            }
                            
                            
                        }
                        if(socket.isClosed()){
                            runs=false;
                        }
                        tmp=null;
                        message=null;
                        tmp=new byte[30];
                    }
                    
                    
                } catch (IOException e) {
                    
                }
                
            }
            
            
        }
    }
    
}



客戶端代碼案例：

package com.easygo.server;


import java.io.IOException;
import java.net.Socket;


public class Client implements Runnable{
    Socket socket=null;
    final int CENTER_SERVER_PORT=9999;//分發服務器端口
    final String CENTER_SERVER_IP="127.0.0.1";
     int CENTER_SERVER_PORTS;
     String CENTER_SERVER_IPS;
    boolean conn=false;
    volatile boolean receive;
public static void main(String[] args) {
    new Thread(new Client()).start();
}

@Override
public void run() {
    try {
        connection();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    
    
}

public void connection() throws Exception{
    
    while(true){
        if(null==socket&&conn==false){//登入分發服務器
            socket=new Socket(CENTER_SERVER_IP, CENTER_SERVER_PORT);
            receive=true;
            
            send("login,1");//login,登入分發服務器，1指定登入服務
                    
            
            new Thread(){
                public void run(){
                    try {
                        receiveX();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    
                }
                
            }.start();
        }else if(null==socket&&conn==true){//登入指定服務
            socket=new Socket(CENTER_SERVER_IPS, CENTER_SERVER_PORTS);
            receive=true;
            new Thread(){
                @Override
                public void run(){
                    while(true){
                        send("message,我是客戶端");
                        
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    
                    
                }
                
            }.start();
            new Thread(){
                public void run(){
                    try {
                        receiveX();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    
                }
                
            }.start();
        }
        
        Thread.sleep(1000);
        
    }
}

public void send(String message){
    System.out.println("send:"+message);
    try {
        socket.getOutputStream().write(message.getBytes());
        socket.getOutputStream().flush();
    } catch (IOException e) {
    
    }
    
}

public void receiveX() throws IOException{
    byte[]tmp=null;
    String messaage=null;
    while(receive){
        if(null!=socket){
            tmp=new byte[50];
            @SuppressWarnings("unused")
            int count=0;
            while((count=socket.getInputStream().read(tmp))!=-1){
                messaage=new String(tmp);
                System.out.println("result:"+messaage);
                if(messaage.trim().contains("login")){
                    String[]arr=messaage.trim().split(",");
                    System.out.println(":"+arr[1]+":"+arr[2]);
                    CENTER_SERVER_IPS=arr[1];
                    CENTER_SERVER_PORTS=Integer.parseInt(arr[2]);
                    
                    
                    conn=true;
                    //send("0");
                    closeXX();//獲取到對應服務ip和端口后斷開連接
                    receive=false;//
                    
                    
                }else if(messaage.trim().contains("message")){
                    send(messaage);
                    
                }
                tmp=null;
                tmp=new byte[50];
            }
            
            
            
            
        }
        tmp=null;
        messaage=null;
    }
    
}
public void closeXX(){
    if(this.socket!=null){
        try {
            socket.close();
            socket=null;
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}
}


指定登入處理客戶端服務代碼
package com.easygo.server;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Server implements Runnable{
    volatile int port=8086;
    ServerSocket serverSocket=null;
    public static void main(String[] args) {
        new Thread(new Server()).start();
    }

    @Override
    public void run() {
        int count=0;
        try {
            serverSocket=new ServerSocket(port);
            ExecutorService cachedThreadPool = null;//線程池
            cachedThreadPool = Executors.newCachedThreadPool();//線程池
            
            while(true){
                cachedThreadPool.execute(new ServerRunS(serverSocket.accept()));
                System.out.println("a client conn:"+count++);
                
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

}
class ServerRunS implements Runnable{
    Socket socket=null;
    ServerRunS(Socket socket){
        
        this.socket=socket;
    }
    @Override
    public void run() {
        byte[]tmp=null;
        
        while(true){
            
            if(socket!=null){
                tmp=new byte[30];
                @SuppressWarnings("unused")
                int count=0;
                try {
                    while((count=socket.getInputStream().read(tmp))!=-1){
                    System.out.println("客戶端發來的消息："+new String(tmp));
                        
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
            tmp=null;
        }
    }
    
    
    
}

流程：
1啟動server
2啟動CenterServer服務
3啟動客戶端一，參數（login,1）
4啟動客戶端二，參數（login,2）

運行結果：
客戶端1
send:login,1
result:login,127.0.0.1,8085
send:message,我是客戶端
send:message,我是客戶端
send:message,我是客戶端
send:message,我是客戶端
send:message,我是客戶端
send:message,我是客戶端

客戶端2
send:login,2
result:login,127.0.0.1,8086
send:message,我是客戶端
send:message,我是客戶端
send:message,我是客戶端
send:message,我是客戶端
send:message,我是客戶端
send:message,我是客戶端

分發服務器：
有一個客戶端連進來了
UUlogin,2
有一個客戶端連進來了
UUlogin,1

服務器1（8085端口）
8085
客戶端發來的消息：message,我是客戶端
客戶端發來的消息：message,我是客戶端
.
.
.
服務器1（8086端口）
8086
客戶端發來的消息：message,我是客戶端
客戶端發來的消息：message,我是客戶端
.
.
.