Comment mettre à jour en continu un JLabel à l'aide de Swing Timer et SwingWorker ?

Utiliser Swing Timer et SwingWorker pour mettre à jour JLabel en continu

Afin de mettre à jour régulièrement un JLabel avec les résultats d'une activité chronophage, il est recommandé d'utiliser à la fois un Swing Timer et un SwingWorker. Le Swing Timer gère les tâches récurrentes, tandis que le SwingWorker gère les entreprises chronophages. Voici un exemple de code qui illustre le fonctionnement de cette stratégie :

<code class="java">import java.awt.event.*;
import javax.swing.*;
import java.net.Socket;

public class LabelUpdateUsingTimer {

    static String hostnameOrIP = "stackoverflow.com";
    int delay = 5000;
    JLabel label = new JLabel("0000");

    LabelUpdateUsingTimer() {
        label.setFont(label.getFont().deriveFont(120f));

        ActionListener timerListener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new PingWorker().execute();
            }
        };
        Timer timer = new Timer(delay, timerListener);

        timer.start();
        JOptionPane.showMessageDialog(
                null, label, hostnameOrIP, JOptionPane.INFORMATION_MESSAGE);
        timer.stop();
    }

    class PingWorker extends SwingWorker {

        int time;

        @Override
        protected Object doInBackground() throws Exception {
            time = pingTime();
            return new Integer(time);
        }

        @Override
        protected void done() {
            label.setText("" + time);
        }
    };

    public static int pingTime() {
        Socket socket = null;
        long start = System.currentTimeMillis();
        try {
            socket = new Socket(hostnameOrIP, 80);
        } catch (Exception weTried) {
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (Exception weTried) {}
            }
        }
        long end = System.currentTimeMillis();
        return (int) (end - start);
    }

    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                new LabelUpdateUsingTimer();
            }
        };
        SwingUtilities.invokeLater(r);
    }
}</code>

Pour plus de détails concernant le fil de répartition d'événements et l'exécution de tâches répétitives ou étendues dans une interface graphique, veuillez consulter le document Concurrency in Swing.

Comment fonctionne le code :

1. Initialisation : Le constructeur LabelUpdateUsingTimer initialise un JLabel nommé label et définit sa police.
2. ActionListener et Timer : Un ActionListener appelé timerListener est créé, et il déclenchera l'exécution du PingWorker toutes les millisecondes de retard. Un objet Timer est ensuite lancé en utilisant delay et timerListener comme arguments, puis il est démarré.
3. JOptionPane : Le JLabel est affiché dans une boîte de dialogue JOptionPane avec le nom d'hôte ou IP spécifié.
4. PingWorker : La classe PingWorker, une sous-classe de SwingWorker, effectue l'opération fastidieuse dans un thread d'arrière-plan.
5. Ping Time : La méthode pingTime établit une connexion TCP au nom d'hôte ou IP spécifié et calcule la latence.

En employant cette technique, vous pouvez mettre à jour en permanence un JLabel avec les derniers résultats d'une tâche fastidieuse, permettant une surveillance et une surveillance en temps réel des utilisateurs. interaction.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!