Question

当用户＆＃34;关闭时，尝试这样做。程序单击所有退出按钮，因此没有托盘图标。

我调用了Platform.setImplicitExit（false）;所以程序仍然在后台运行。

我正在尝试学习如何在用户重新单击运行jar的.exe文件时，而不是运行新程序，它重新显示在后台运行的程序。

 Platform.setImplicitExit(false);

Answer 1

这是基于博文中的解决方案：Java Single Instance Application。

解决方案使用＆＃34;套接字技术＆＃34;：

使用这种技术我们开始监听一个端口，只有一个进程可以监听套接字，所以在我们的应用程序的第一个实例绑定到套接字后，其他实例将获得BindException，这意味着我们已经在运行。

这种方法的缺点是，当应用程序开始在套接字上侦听时，某些病毒扫描程序会发出警告，具体取决于您的用户群，这可能会被严重解释。您应该选择一个不常用且很高的端口号，或者您甚至不会让应用程序的单个实例运行。

在示例中，我们为应用程序实例创建了一个唯一的实例ID，并记录了一些选项。

最小化将最小化窗口。
隐藏会隐藏它（因此它不会显示为最小化，但应用仍在运行）。
退出将结束申请流程。

窗口上的操作系统关闭按钮将关闭应用程序窗口，但应用程序进程将继续在后台运行（因此它的行为与＆＃34;隐藏＆＃34;按钮相同）。

当你启动一个应用程序实例时，它会打开一个套接字并监听它。

当您尝试启动另一个应用程序实例时，它将尝试绑定到侦听套接字。如果它无法绑定，那么它知道已经在该套接字上运行了一个应用程序实例。如果检测到另一个实例，则会通过套接字向现有实例发送一条消息，导致现有实例取消隐藏或取消最小化，并尝试将其阶段置于最前面。

请不要滥用此功能，有许多程序隐藏在后台，我不喜欢。

import javafx.application.*;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.stage.Stage;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;

public class SingleInstanceApp extends Application {

    private static final int SINGLE_INSTANCE_LISTENER_PORT = 9999;
    private static final String SINGLE_INSTANCE_FOCUS_MESSAGE = "focus";

    private static final String instanceId = UUID.randomUUID().toString();

    // We define a pause before focusing on an existing instance
    // because sometimes the command line or window launching the instance
    // might take focus back after the second instance execution complete
    // so we introduce a slight delay before focusing on the original window
    // so that the original window can retain focus.
    private static final int FOCUS_REQUEST_PAUSE_MILLIS = 500;

    private Stage stage;

    public void init() {
        CountDownLatch instanceCheckLatch = new CountDownLatch(1);

        Thread instanceListener = new Thread(() -> {
            try (ServerSocket serverSocket = new ServerSocket(SINGLE_INSTANCE_LISTENER_PORT, 10)) {
                instanceCheckLatch.countDown();

                while (true) {
                    try (
                            Socket clientSocket = serverSocket.accept();
                            BufferedReader in = new BufferedReader(
                                    new InputStreamReader(clientSocket.getInputStream()))
                    ) {
                        String input = in.readLine();
                        System.out.println("Received single instance listener message: " + input);
                        if (input.startsWith(SINGLE_INSTANCE_FOCUS_MESSAGE) && stage != null) {
                            Thread.sleep(FOCUS_REQUEST_PAUSE_MILLIS);
                            Platform.runLater(() -> {
                                System.out.println("To front " + instanceId);
                                stage.setIconified(false);
                                stage.show();
                                stage.toFront();
                            });
                        }
                    } catch (IOException e) {
                        System.out.println("Single instance listener unable to process focus message from client");
                        e.printStackTrace();
                    }
                }
            } catch(java.net.BindException b) {
                System.out.println("SingleInstanceApp already running");

                try (
                        Socket clientSocket = new Socket(InetAddress.getLocalHost(), SINGLE_INSTANCE_LISTENER_PORT);
                        PrintWriter out = new PrintWriter(new OutputStreamWriter(clientSocket.getOutputStream()))
                ) {
                    System.out.println("Requesting existing app to focus");
                    out.println(SINGLE_INSTANCE_FOCUS_MESSAGE + " requested by " + instanceId);
                } catch (IOException e) {
                    e.printStackTrace();
                }

                System.out.println("Aborting execution for instance " + instanceId);
                Platform.exit();
            } catch(Exception e) {
                System.out.println(e.toString());
            } finally {
                instanceCheckLatch.countDown();
            }
        }, "instance-listener");
        instanceListener.setDaemon(true);
        instanceListener.start();

        try {
            instanceCheckLatch.await();
        } catch (InterruptedException e) {
            Thread.interrupted();
        }
    }

    public void stop() {
        System.out.println("Exiting instance " + instanceId);
    }

    @Override
    public void start(Stage stage) throws Exception{
        this.stage = stage;

        System.out.println("Starting instance " + instanceId);

        Platform.setImplicitExit(false);

        Button minimize = new Button("Minimize");
        minimize.setOnAction(event -> stage.setIconified(true));

        Button hide = new Button("Hide");
        hide.setOnAction(event -> stage.hide());

        Button exit = new Button("Exit");
        exit.setOnAction(event -> Platform.exit());

        Label instance = new Label(instanceId);

        Pane layout = new VBox(10, instance, new HBox(10, minimize, hide, exit));
        layout.setPadding(new Insets(10));

        Scene scene = new Scene(layout);
        stage.setScene(scene);
        stage.show();
    }

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

JavaFX单实例应用程序

1 个答案: