Question

我有一个必须在退出时处理一些方法的应用程序。但是，当用户在未先关闭我的应用程序的情况下关闭Windows时，Windows会终止应用程序，并且关闭方法也不会运行。

如何检测用户何时请求关闭或注销Windows？我需要运行的方法需要几毫秒才能完成，因此我不需要推迟或中断关机过程。

我已经使用JNA来响应锁定/解锁的计算机，但onMachineLogoff()方法似乎也没有捕获关闭请求。

Answer 1

当您可以处理关闭和注销事件时，有three different scenarios。我将专注于Windows应用程序，因为它也适用于控制台应用程序，如果由于某种原因你的应用程序导入User32函数，那么控制台句柄将无法工作。

基本上你需要2个功能：

ATOM RegisterClassEx(WNDCLASSEX *lpwcx);

RegisterClassEx使用与之关联的钩子（即我们的关闭/注销处理程序）创建一种新窗口。

HWND WINAPI CreateWindowEx(
    int dwExStyle, LPCTSTR lpClassName, LPCTSTR lpWindowName,
    int dwStyle, int x, int y, int nWidth, int nHeight,
    HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam
);

CreateWindowEx实例化一个新窗口，这个窗口有一个关联的事件挂钩（由注册的类），这样Windows将通过all possible events通知关联的钩子。

这是一个完整的工作示例，只需启动它并注销或关闭计算机，在启动它之后，查看%userprofile%\shutdown-hook.log文件它必须通过记录类似

来处理这些事件

...
action=proc-callback, event=22 
...

code

public class Main {

    /**
     * <pre>
     * Steps:
     *
     * 1. Create a  WinProc (this function will handle all events)
     * 2. Create a window class using the created WinProc
     * 3. Create a window using the created window class
     * 4. Use the WinProc to handle shutdown events
     * </pre>
     */
    public static void main(String[] args) {
//  registering a window - https://msdn.microsoft.com/pt-br/library/windows/desktop/ms633587
//                          https://msdn.microsoft.com/pt-br/library/windows/desktop/ms633577
//  typedef struct tagWNDCLASSEX {
//    UINT      cbSize;
//    UINT      style;
//    WNDPROC   lpfnWndProc;
//    int       cbClsExtra;
//    int       cbWndExtra;
//    HINSTANCE hInstance;
//    HICON     hIcon;
//    HCURSOR   hCursor;
//    HBRUSH    hbrBackground;
//    LPCTSTR   lpszMenuName;
//    LPCTSTR   lpszClassName;
//    HICON     hIconSm;
//  } WNDCLASSEX, *PWNDCLASSEX;
//
//  ATOM WINAPI RegisterClassEx(
//    _In_ const WNDCLASSEX *lpwcx
//  );
        final WinUser.WNDCLASSEX clazz = new WinUser.WNDCLASSEX();
        clazz.lpszClassName = "MyCustomWindow";
        clazz.cbSize = Native.getNativeSize(WinUser.WNDCLASSEX.class, null);
        clazz.lpfnWndProc = new MyWinProc();

        WinDef.ATOM classInst = User32.INSTANCE.RegisterClassEx(clazz);
        System.out.printf("action=registerclass, clazz=%s, error=%d\n", classInst, Native.getLastError());

        WinDef.HWND w = User32.INSTANCE.CreateWindowEx(
            512, clazz.lpszClassName, "My Window",
            WinUser.WS_OVERLAPPEDWINDOW, -2147483648, -2147483648, 250, 100,
            null, null, null, null
        );
        System.out.printf("action=createWindow, w=%s, error=%d\n", w, Native.getLastError());

        WinUser.MSG msg = new WinUser.MSG();
        while (User32.INSTANCE.GetMessage(msg, null, 0, 0)) {
            User32.INSTANCE.DispatchMessage(msg);
        }
    }

    public interface User32 extends Library {

        User32 INSTANCE = Native.loadLibrary("User32", User32.class, W32APIOptions.UNICODE_OPTIONS);

//      ATOM WINAPI RegisterClassEx(
//          _In_ const WNDCLASSEX *lpwcx
//      );
        WinDef.ATOM RegisterClassEx(WinUser.WNDCLASSEX lpwcx);

//  HWND WINAPI CreateWindowEx(
//    _In_     DWORD     dwExStyle,
//    _In_opt_ LPCTSTR   lpClassName,
//    _In_opt_ LPCTSTR   lpWindowName,
//    _In_     DWORD     dwStyle,
//    _In_     int       x,
//    _In_     int       y,
//    _In_     int       nWidth,
//    _In_     int       nHeight,
//    _In_opt_ HWND      hWndParent,
//    _In_opt_ HMENU     hMenu,
//    _In_opt_ HINSTANCE hInstance,
//    _In_opt_ LPVOID    lpParam
//  );
        WinDef.HWND CreateWindowEx(
            int dwExStyle,
            String lpClassName,
            String lpWindowName,
            int dwStyle,
            int x,
            int y,
            int nWidth,
            int nHeight,
            WinDef.HWND hWndParent,
            WinDef.HMENU hMenu,
            WinDef.HINSTANCE hInstance,
            WinDef.LPVOID lpParam
        );

//      BOOL WINAPI GetMessage(
//          _Out_    LPMSG lpMsg,
//          _In_opt_ HWND  hWnd,
//          _In_     UINT  wMsgFilterMin,
//          _In_     UINT  wMsgFilterMax
//      );
        boolean GetMessage(WinUser.MSG lpMsg, WinDef.HWND hWnd, int wMsgFilterMin, int wMsgFilterMax);

//      LRESULT WINAPI DispatchMessage(
//          _In_ const MSG *lpmsg
//      );
        WinDef.LRESULT DispatchMessage(WinUser.MSG lpmsg);

        WinDef.LRESULT DefWindowProc(WinDef.HWND hWnd, int uMsg, WinDef.WPARAM wParam, WinDef.LPARAM lParam);
    }

    /**
     * <pre>
     * All Possible events -
     * https://msdn.microsoft.com/en-us/library/windows/desktop/ms644927.aspx#system_defined
     * https://github.com/tpn/winsdk-10/blob/master/Include/10.0.10240.0/um/WinUser.h
     * </pre>
     */
    public static class MyWinProc implements WinUser.WindowProc {
        private final OutputStream out;

        public MyWinProc() {
            try {
                // this is unsafe because this file will never be closed, anyway it is just for a example
                out = new FileOutputStream(new File(System.getProperty("user.home") + File.separator + "shutdown-hook.log"));
            } catch (FileNotFoundException e) {
                throw new RuntimeException(e);
            }
        }

        @Override
        public WinDef.LRESULT callback(WinDef.HWND hWnd, int uMsg, WinDef.WPARAM wParam, WinDef.LPARAM lParam) {
            final String msg = String.format("action=proc-callback, event=%d %n", uMsg);
            System.out.print(msg);
            try {
                out.write(msg.getBytes());
                switch (uMsg){
                    case 0x0016:
                        out.write("shutdown".getBytes());
                        break;
                    case 0x0011:
                        out.write("logoff".getBytes());
                        break;
                }
                out.flush();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return User32.INSTANCE.DefWindowProc(hWnd, uMsg, wParam, lParam);
        }
    }
}

obs ：只是一个建议，根据您的要求我认为如果你只是开始一个后台线程并且时间可以做你必须做的任务可能会更有意义，因为如果Windows获得blue screen of death或电源消失或有人只是插上电源然后Windows事件将无法帮助您。无论如何，后台线程解决方案都非常简单。

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {

    public static void main(String[] args) {
        Executors.newSingleThreadExecutor().execute(() -> {
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("do a background stuff");
                try {
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {/*I will look at that in the while clause*/}
            }
        });
        System.out.println("doing another stuff");
    }
}

我的依赖

compile group: 'net.java.dev.jna', name: 'jna', version: '4.5.0'
compile group: 'net.java.dev.jna', name: 'jna-platform', version: '4.5.0'

JavaFX - 如何检测Windows注销/关闭请求？

1 个答案: