CODEWITHSUNDEEP
javasockets
Ali
Ali

Reputation: 10453

Keep the SocketServer alive until the Frame is close

What I'm trying to achieve is that with my program the user can upload the file as many time as they want, and when they click the close button then I want to close or terminate the socket connection, but when I run the GUI again the connection its still there even though I didn't start it yet.

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

So if I keep the while(true) the connection will stay alive, but even though when I closed the Frame already its still connecting.

I have the @Override method for window closed here

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

        }

    });

Upvotes: 0

Views: 682

Answers (1)

MadProgrammer
MadProgrammer

Reputation: 347204

You have a few choices...

Create a "escape" flag in your socket loop that can be triggered (to false for example) externally. Add a WindowListener to the frame and on windowClosing flip the flag and interrupt the thread. This will allow the loop to terminate.

You could also try setting up the server socket in a daemon thread, but I suspect that this won't work as the blocking operation of the server socket probably won't care.

Updated with example

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

Updated with simple socket command example

This example basic communicates via the socket to tell the server it should shut down...

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

Upvotes: 1

Related Questions