如果打开，Java 会自动连接到服务器

Question

我正在尝试创建一个程序来确定服务器是连接、关闭还是断开连接。 我需要让客户端在打开时自动连接到服务器。

问题：

1. How can I continuously ping the server, to determine if the server is up?

2. Why is it when I click the button the server can only receive once.

3. Determine when the Server is disconnected

这是我的代码：

服务器

   public Server()
    {
        super("Server");
        server.setLayout(new BorderLayout());
        main.setLayout(new BorderLayout());
        top.setLayout(new BorderLayout());
        bot.setLayout(new BorderLayout());
        console.setEditable(false);
        console.setFont(new Font("Courier New",Font.PLAIN,14));
        console.setBackground(Color.BLACK);
        console.setForeground(Color.WHITE);
        bot.add(console);
        top.add(btnReply,BorderLayout.EAST);
        top.add(queryline,BorderLayout.CENTER);
        main.add(top,BorderLayout.NORTH);
        main.add(bot,BorderLayout.CENTER);
        add(main);
    }

    private void runServer() throws IOException
    {
        int port = 25000;
        ServerSocket serverSocket = new ServerSocket(port);
        console.setText("Server is Up and listening to the port: "+port+"\n");
        System.out.println("Server is Up and listening to the port: "+port+"\n");

        while(true)
        {
            Thread thread = new Thread(new Handler(socket));
            thread.start();
        }
    }

    public static void main(String args[]) 
    {
        Server f=new Server();
        f.setVisible(true);
        f.setExtendedState(JFrame.MAXIMIZED_BOTH);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        try
        {
            f.runServer();
        }catch(IOException ex)
        {
            //JOptionPane.showMessageDialog(null,ex.getMessage());
        }
    }

    @Override
    public void actionPerformed(ActionEvent e) 
    {

    }
}

class Handler implements Runnable 
{
    private Socket socket;
    public Handler(Socket socket){
        this.socket = socket;
    }

    public void run() 
    {
        // You may need to add a repeat and exit clause here...
        Server f=new Server();
        try
        {
            InputStreamReader ir = new InputStreamReader(socket.getInputStream());
            BufferedReader br = new BufferedReader(ir);
            String message = br.readLine();
            System.out.println(message);
            String[] received=message.split("~");
            f.console.append(received[1]+": requesting for "+received[0]+"\n");
            System.out.println(received[1]+": requesting for "+received[0]+"\n");
        }catch(IOException ex)
        {
            ex.printStackTrace();
        }
    }
}

客户

public class Branch extends JFrame
{
    private static Socket socket;
    JPanel main=new JPanel();
    JPanel top=new JPanel();
    JPanel bot=new JPanel();
    JButton btnItem=new JButton("item");
    JButton btnGlstock=new JButton("glstock");
    JTextArea console=new JTextArea();
    JScrollPane scrollv=new JScrollPane(console);

    ActionListener item=new ActionListener()
    {
        @Override
        public void actionPerformed(ActionEvent e)
        {
            String ip="";
            String send="";
            try
            {
                ip=InetAddress.getLocalHost().getHostAddress();
                send="item~"+ip;
                request(send);
            }catch(Exception ex)
            {
                JOptionPane.showMessageDialog(null,ex.getMessage());
            }
        }
    };

    ActionListener glstock=new ActionListener()
    {
        @Override
        public void actionPerformed(ActionEvent e)
        {
            String ip="";
            String send="";
            try
            {
                ip=InetAddress.getLocalHost().getHostAddress();
                send="glstock~"+ip;
                request(send);
            }catch(Exception ex)
            {
                JOptionPane.showMessageDialog(null,ex.getMessage());
            }
        }
    };

    private void request(String send)
    {
        try
        {
            OutputStream os = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(os);
            BufferedWriter bw = new BufferedWriter(osw);
            bw.write(send+"\n");
            bw.flush();
        }catch(Exception ex)
        {
            ex.printStackTrace();
        }
    }

    public Branch()
    {
        super("Branch");
        scrollv.setAutoscrolls(true);
        main.setLayout(new BorderLayout());
        top.setLayout(new FlowLayout());
        top.add(btnItem);
        top.add(btnGlstock);
        btnItem.addActionListener(item);
        btnGlstock.addActionListener(glstock);
        bot.setLayout(new BorderLayout());
        console.setEditable(false);
        console.setForeground(Color.white);
        console.setBackground(Color.black);
        bot.add(scrollv,BorderLayout.CENTER);
        main.add(top,BorderLayout.NORTH);
        main.add(bot,BorderLayout.CENTER);
        add(main);
    }

   private void connect2Server() throws IOException
   {
    Timer timer=new Timer(5000,checkPing);

    try
    {
        socket = new Socket(IP,port);
        console.append("You are now Connected to the Server\r\n");
        //timer.start();
        socket.setSoTimeout(5000);
        InputStreamReader isr=new InputStreamReader(socket.getInputStream());
        isr.read();
    }
    catch(SocketTimeoutException ex)
    {
        ex.printStackTrace();
    }
    catch(IOException ex)
    {
        console.append("Server is offline\r\n");
        ex.printStackTrace();
    }
    connect2Server();
  }

    public static void main(String args[]) 
    {
        Branch frame=new Branch();
        frame.setVisible(true);
        frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.connect2Server();
        frame.connectDatabase();
    }
}

Answer 1

如何持续 ping 服务器，以确定服务器是否已启动？

使用某种计时器来安排定期回调并在那里进行测试。 ping 服务器（在这种情况下）可能就像尝试与它建立连接一样简单......

你也可以使用InetAddress#isReachable...

为什么我点击按钮时服务器只能接收一次

因为服务器不再处理您的连接。看看你的服务器代码...

while(true)
{
    //^Reading the message from the client
    // Wait for a NEW client connection
    socket = serverSocket.accept();
    // Process request...
    InputStream is = socket.getInputStream();
    InputStreamReader isr = new InputStreamReader(is);
    BufferedReader br = new BufferedReader(isr);
    String message = br.readLine();
    System.out.println(message);
    String[] received=message.split("~");
    console.append(received[1]+": requesting for "+received[0]+"\n");
    // ... No longer monitoring for new content...
}

serverSocket.accept(); 正在等待新的客户端连接，而不是监视现有连接。

您应该做的是产生某种Thread，传递对客户端Socket 连接的引用并在那里处理它，在它自己的循环中......提供超时或可能的退出条件，所以可以关闭套接字和线程...

判断服务器何时断开

基本上，如果您尝试向服务器（或客户端）发送内容，它会抛出某种Exception，这很好地表明连接由于某种原因断开了。

您也可以使用某种计时器定期向服务器发送“健康”检查消息，但是，您需要确保您正在同步您的通信，因此两个（客户端）线程不会尝试同时发送消息。

旁注

您当前的代码在发送消息时会阻塞事件调度线程。当您在本地进行测试时，这可能不是什么大事，但是，根据连接速度和服务器及时响应的能力，可能会导致您的 UI 出现“冻结”一两秒（或更长）

查看Concurrency in Swing了解更多详情

更新示例

为了让您的服务器能够处理多个客户端连接，您需要为每个新连接生成一个新线程，例如...

private void runServer() throws IOException
{
    int port = 25000;
    ServerSocket serverSocket = new ServerSocket(port);
    console.setText("Server is Up and listening to the port: "+port+"\n");
    System.out.println("Server is Up and listening to the port: "+port+"\n");

    while(true)
    {
        Socket socket = serverSocket.accept();
        Thread thread = new Thread(new Handler(socket));
        thread.start();
    }
}

然后在您的“客户端套接字处理程序”中，您需要设置一个循环，该循环将继续从客户端套接字读取，直到出现问题或客户端请求终止通信，例如...

class Handler implements Runnable 
{
    private Socket socket;
    public Handler(Socket socket){
        this.socket = socket;
    }

    public void run() 
    {
        // You may need to add a repeat and exit clause here...
        try
        {
            boolean keepRunning = true;
            while (keepRunning) {
                InputStreamReader ir = new InputStreamReader(socket.getInputStream());
                BufferedReader br = new BufferedReader(ir);
                String message = br.readLine();
                System.out.println(message);
                String[] received=message.split("~");
                System.out.println(received[1]+": requesting for "+received[0]+"\n");
                // Check for a valid "exit" state and change keepRunning
                // if the client want's to disconnect...
            }
        }catch(IOException ex)
        {
            ex.printStackTrace();
        } finally {
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (Exception exp) {
            }
        }
    }
}

另外，请确保您正确关闭资源；）

Answer 2

如何持续 ping 服务器，以确定服务器是否已启动？

继续尝试连接它，如果失败则睡眠和循环。

为什么我点击按钮时服务器只能接收一次。

因为您的服务器每次连接只读取一次。 Handler.run()方法需要循环直到readLine()返回null或者发生异常。

确定服务器何时断开

read() 将返回 -1，readLine() 将返回 null，任何其他 readXXX() 将抛出 EOFException. 但是您的客户端根本不会读取。您可能应该调整您的应用程序协议，以便服务器回复每次发送。否则，您将不得不等到发送时出现IOException，由于 TCP 缓冲，这可能需要多次迭代才能发生。

其他说明：

1. 不要在每次发送时创建新的流。在套接字的整个生命周期中使用相同的流、读取器、写入器。
2. 不要在事件线程中执行网络代码。使用单独的线程。