Question

我想要实现的是，使用我的程序，用户可以根据需要上传文件，当他们点击关闭按钮然后我想关闭或终止套接字连接，但是当我运行时尽管我还没有启动它，但GUI仍然在那里仍然存在。

while (true) { // >>>>>>>HERE IS MY PROBLEM<<<<<<<
    try{
    connectionSocket = welcomeSocket.accept();

    inFromClient = new BufferedReader(new InputStreamReader(
            connectionSocket.getInputStream()));

    outToClient = new DataOutputStream(
            connectionSocket.getOutputStream());

                 //Do something here.....
    }catch(IOException e){ }
}

因此，如果我保持while（true），连接将保持活跃状态，但即使我关闭Frame已经仍然连接。

我在这里关闭了窗口的@Override方法

    frame.addWindowListener(new WindowAdapter() {
        @Override
        public void windowClosing(WindowEvent b) {


            if(socket != null){
            try {
                socket = new Socket(hostIP, port);
            } catch (UnknownHostException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }


            }
            try {
              if (socket != null) {
               socket.close();
                socket = null;
                 }
                }
            catch (IOException e) { socket = null; }


            ftoc.dispose();

        }

    });

Answer 1

你有几个选择......

在套接字循环中创建一个“escape”标志，可以在外部触发（例如为false）。向框架添加WindowListener，然后在windowClosing上翻转标记并中断线程。这将允许循环终止。

您也可以尝试在守护程序线程中设置服务器套接字，但我怀疑这不起作用，因为服务器套接字的阻塞操作可能不关心。

更新了示例

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.GridBagLayout;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class TestSocket {

    private SocketThread socketThread;

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

    public TestSocket() {
        socketThread = new SocketThread();
        socketThread.start();
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new GridBagLayout());
                frame.add(new JLabel("Close me if you dare"));
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);

                frame.addWindowListener(new WindowAdapter() {
                    @Override
                    public void windowClosing(WindowEvent e) {
                        socketThread.stopThatSocket();
                    }
                });
            }
        });
    }

    public class SocketThread extends Thread {

        private volatile boolean flagToSetWhenYouWantToStop = true;
        private ServerSocket socket = null;

        public SocketThread() {
            setName("Socket");
            setDaemon(true);
        }

        public void stopThatSocket() {
            flagToSetWhenYouWantToStop = false;
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException ex) {
                }
            }
            interrupt();
            try {
                join();
            } catch (InterruptedException ex) {
            }
        }

        @Override
        public void run() {

            try {
                socket = new ServerSocket(1234);
                while (flagToSetWhenYouWantToStop) {
                    Socket accept = socket.accept();
                }
            } catch (IOException exp) {
                exp.printStackTrace();
            }
        }
    }
}

使用简单套接字命令示例

进行了更新

此示例基本通过套接字进行通信，告诉服务器它应该关闭...

import java.awt.EventQueue;
import java.awt.GridBagLayout;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.SocketFactory;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class TestSocket {

    private SocketThread socketThread;

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

    public TestSocket() {
        socketThread = new SocketThread();
        socketThread.start();
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new GridBagLayout());
                frame.add(new JLabel("Close me if you dare"));
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);

                frame.addWindowListener(new WindowAdapter() {
                    @Override
                    public void windowClosing(WindowEvent e) {
//                        socketThread.stopThatSocket();
                        Socket socket = null;

                        try {
                            socket = SocketFactory.getDefault().createSocket("localhost", 1234);

                            BufferedWriter bw = null;
                            try {
                                bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                                System.out.println("Out-Cmd = STOP");
                                bw.write("stop");
                                bw.newLine();
                            } finally {
                                try {
                                    bw.close();
                                } catch (Exception exp) {
                                }
                            }
                        } catch (IOException ex) {
                            ex.printStackTrace();
                        } finally {
                            try {
                                socket.close();
                            } catch (Exception exp) {
                            }
                        }
                    }
                });
            }
        });
    }

    public class SocketThread extends Thread {

        private volatile boolean flagToSetWhenYouWantToStop = true;
        private ServerSocket socket = null;

        public SocketThread() {
            setName("Socket");
            setDaemon(true);
        }

        public void stopThatSocket() {
            flagToSetWhenYouWantToStop = false;
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException ex) {
                }
            }
            interrupt();
            try {
                join();
            } catch (InterruptedException ex) {
            }
        }

        @Override
        public void run() {

            try {
                socket = new ServerSocket(1234);
                while (flagToSetWhenYouWantToStop) {
                    Socket accept = socket.accept();
                    /**
                     * Normally I would have a command processor take care of this,
                     * read in the command and then terminate the server thread by
                     * calling stopThatSocket...
                     */
                    BufferedReader br = null;
                    try {
                        br = new BufferedReader(new InputStreamReader(accept.getInputStream()));
                        String cmd = br.readLine();
                        System.out.println("In-Cmd = " + cmd);
                        if (cmd.equalsIgnoreCase("stop")) {
                            stopThatSocket();
                        }
                    } finally {
                        try {
                            br.close();
                        } catch (Exception e) {
                        }
                    }
                }
            } catch (IOException exp) {
                exp.printStackTrace();
            }
        }
    }
}

保持SocketServer活动直到帧关闭

1 个答案: