socket programming transfer data from server to server

Question

i have a client_1 , centerlized_server and server_1 the client send request to a centerlized_server and centerlized_server transfer the request to the server_1

the problem is how i transfer the request from centerlized_serve to server_1??

I appreciate your help

... Client1 code

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;



public class Client1 {

private Socket server;
private ObjectOutputStream out;
private ObjectInputStream in;

public Client1() {

    try 
    {
        server = new Socket("localhost", 5050);
        out = new ObjectOutputStream(server.getOutputStream());
        in = new ObjectInputStream(server.getInputStream());

        while (true) 
        {
            Scanner s = new Scanner(System.in);
            System.out.println("press 2 to date or 1 for time:");
            Message msg = new Message();
            msg.Type = s.nextInt();
            out.writeObject(msg);
            msg = (Message) in.readObject();
            System.out.println(msg.message);
        }
    } 
    catch (Exception ex) 
    {
        ex.printStackTrace();
    }
}

public static void main(String[] args) {
    new Client1();
}
 }

CernterlizedServer code

 import java.io.IOException;
 import java.io.ObjectInput;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.net.Socket;
 import java.util.Date;


 public class CentralizedServer extends Thread {

private Socket client;
private ObjectOutputStream out;
private ObjectInputStream in;

public CentralizedServer(Socket current_socket) 
{
    try
    {
        client = current_socket;
        out = new ObjectOutputStream(client.getOutputStream());
        in = new ObjectInputStream(client.getInputStream());
    }
    catch (Exception ex) {
        ex.printStackTrace();
    }
}

@Override
public void run() 
{
    try 
    {
        while (true) 
        {
            Message msg = (Message) in.readObject();
            if (msg.Type == 1)
            {
                OnTimeRequst();
            } 
            else if (msg.Type == 2) 
            {
                OnDateRequst();
            }
        }
    } 
    catch (Exception ex) 
    {
        try
        {
            out.close();
            in.close();
            client.close();
        } 
        catch (Exception e) 
        {
            e.printStackTrace();
        }
    }
}

private void OnTimeRequst() throws IOException 
{
    Date d = new Date();
    Message msg = new Message();
    msg.message = d.getHours() + ":" + d.getMinutes() + ":" + d.getSeconds();
    out.writeObject(msg);
}

private void OnDateRequst() throws IOException 
{
    Date d = new Date();
    Message msg = new Message();
    msg.message = d.toString() + "";
    out.writeObject(msg);
}
       }

Server code

 import java.net.ServerSocket;
 import java.util.ArrayList;


 public class Server {

ServerSocket server;
ArrayList<CentralizedServer> list = new ArrayList<>();

public Server() 
{
    try 
    {
        server = new ServerSocket(5050);
        while (true) 
        {
            CentralizedServerthr = new CentralizedServer(server.accept());
            list.add(thr);
            thr.start();
        }
    } 
    catch (Exception ex)
    {
        ex.printStackTrace();
    }

}

public static void main(String... args) {
    new Server();
}
    }

Answer 1

You can design this one of two ways.

Option 1: Redirect. The centralized server sends back a response to the client to "redirect" him to server1. (ala http 30x response). Then the client just makes a separate connection to server1 and resends the request.

Option 2: Proxy. Upon receiving the request from the client, the centralized server makes a connection to server1 and sends the request on behalf of the client. When the centralized server receives the response from server1, it just forwards the response to the client.

The redirect method is simpler, but not always possible if "server1" is meant to be protected from direct client access or only accessible from other servers.

The proxy method is a bit harder, but allows for different designs.