套接字编程在服务器之间传输数据

Question

我有一个client_1，centerlized_server和server_1，该客户端将请求发送到centerlized_server，并且centerlized_server将请求传输到server_1

问题是我如何将请求从centerlized_serve转移到server_1？

我感谢您的帮助

... Client1代码

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代码

 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);
}
       }

服务器代码

 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

您可以设计两种方法之一。

选项1：重定向。 集中式服务器将响应发送回客户端，以将其“重定向”到服务器1。 （ala http 30x响应）。 然后，客户端仅与server1建立单独的连接并重新发送请求。

选项2：代理。 接收到来自客户端的请求后，集中式服务器将与server1建立连接，并代表客户端发送请求。 当集中式服务器从server1收到响应时，它将转发该响应到客户端。

重定向方法比较简单，但是如果要保护“ server1”以防止直接客户端访问或只能从其他服务器访问，则重定向方法并不总是可行的。

代理方法有点难，但是允许不同的设计。