如何通过编程（优先Java）实现打开指定.doc/.docx时启动目标程序？

Alright, let's break down how to make a specific Word document trigger a target program/audio file automatically when opened—with Java as our primary tool. The key here is that we're targeting one specific Word file, not all .doc/.docx files, so we can't just mess with global file associations. Here's the game plan:

Core Concept #

We'll create a Java "proxy" app that becomes the default program for opening that specific Word file. When the user opens the Word file, it launches our proxy app first. The proxy then does two things:

1. Starts the target program/audio file the user specified
2. Opens the actual Word file with the system's default Word application

We'll also add a simple GUI to let users pick their Word file and target program, plus a way to save that association so the proxy knows what to trigger later.

Step-by-Step Implementation (Windows-First) #

1. Build the Java Proxy App #

This app handles two scenarios:

• First run: Shows a GUI to let users select their Word file and target program, then saves the association and updates the file's default open settings.
• Subsequent runs: Triggered when the Word file is opened—reads the saved config, launches the target program, then opens the Word file.

Full Code Example

import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.util.Properties;

public class WordTrigger {
    private static final String CONFIG_FILE = "word_trigger_config.properties";
    private static Properties config = new Properties();

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

        // If called with a file path (user opened the Word file)
        if (args.length > 0) {
            String targetWordFile = args[0];
            launchTargetProgram(targetWordFile);
            openWordDocument(targetWordFile);
            return;
        }

        // First run: Show setup GUI
        showSetupWindow();
    }

    // Load saved associations from config file
    private static void loadConfig() {
        try (FileInputStream fis = new FileInputStream(CONFIG_FILE)) {
            config.load(fis);
        } catch (IOException e) {
            // No config exists yet—normal for first run
        }
    }

    // Save the Word file ↔ target program mapping
    private static void saveConfig(String wordPath, String targetPath) {
        config.setProperty(wordPath, targetPath);
        try (FileOutputStream fos = new FileOutputStream(CONFIG_FILE)) {
            config.store(fos, "Word File to Target Program Mapping");
        } catch (IOException e) {
            JOptionPane.showMessageDialog(null, "Failed to save config: " + e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
        }
    }

    // GUI for user to select files and save settings
    private static void showSetupWindow() {
        JFrame frame = new JFrame("Word Trigger Setup");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(450, 220);
        frame.setLayout(new GridBagLayout());
        frame.setLocationRelativeTo(null);
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.insets = new Insets(5, 5, 5, 5);

        // Word file selection
        JLabel wordLabel = new JLabel("Select Target Word File:");
        JTextField wordPathField = new JTextField(25);
        JButton browseWordBtn = new JButton("Browse");

        browseWordBtn.addActionListener(e -> {
            JFileChooser chooser = new JFileChooser();
            chooser.setFileFilter(new javax.swing.filechooser.FileNameExtensionFilter("Word Documents", "doc", "docx"));
            if (chooser.showOpenDialog(frame) == JFileChooser.APPROVE_OPTION) {
                wordPathField.setText(chooser.getSelectedFile().getAbsolutePath());
            }
        });

        // Target program/file selection
        JLabel targetLabel = new JLabel("Select Program/Audio to Trigger:");
        JTextField targetPathField = new JTextField(25);
        JButton browseTargetBtn = new JButton("Browse");

        browseTargetBtn.addActionListener(e -> {
            JFileChooser chooser = new JFileChooser();
            chooser.setAcceptAllFileFilterUsed(true);
            if (chooser.showOpenDialog(frame) == JFileChooser.APPROVE_OPTION) {
                targetPathField.setText(chooser.getSelectedFile().getAbsolutePath());
            }
        });

        // Save button
        JButton saveBtn = new JButton("Save & Apply Settings");
        saveBtn.addActionListener(e -> {
            String wordPath = wordPathField.getText().trim();
            String targetPath = targetPathField.getText().trim();

            if (wordPath.isEmpty() || targetPath.isEmpty()) {
                JOptionPane.showMessageDialog(frame, "Please fill both file paths!", "Warning", JOptionPane.WARNING_MESSAGE);
                return;
            }

            File wordFile = new File(wordPath);
            File targetFile = new File(targetPath);
            if (!wordFile.exists() || !targetFile.exists()) {
                JOptionPane.showMessageDialog(frame, "One or both files don't exist!", "Error", JOptionPane.ERROR_MESSAGE);
                return;
            }

            saveConfig(wordPath, targetPath);
            if (setDefaultOpenProgram(wordPath)) {
                JOptionPane.showMessageDialog(frame, "Setup complete! Opening the Word file will now trigger your target.", "Success", JOptionPane.INFORMATION_MESSAGE);
                frame.dispose();
            } else {
                JOptionPane.showMessageDialog(frame, "Failed to update file association—run the program as Administrator!", "Error", JOptionPane.ERROR_MESSAGE);
            }
        });

        // Add components to window
        gbc.gridx = 0; gbc.gridy = 0; frame.add(wordLabel, gbc);
        gbc.gridx = 1; gbc.gridy = 0; frame.add(wordPathField, gbc);
        gbc.gridx = 2; gbc.gridy = 0; frame.add(browseWordBtn, gbc);

        gbc.gridx = 0; gbc.gridy = 1; frame.add(targetLabel, gbc);
        gbc.gridx = 1; gbc.gridy = 1; frame.add(targetPathField, gbc);
        gbc.gridx = 2; gbc.gridy = 1; frame.add(browseTargetBtn, gbc);

        gbc.gridx = 1; gbc.gridy = 2; frame.add(saveBtn, gbc);

        frame.setVisible(true);
    }

    // Set our Java app as the default program for the specific Word file (Windows only)
    private static boolean setDefaultOpenProgram(String wordFilePath) {
        try {
            // Get path to our compiled JAR file
            String jarPath = new File(WordTrigger.class.getProtectionDomain().getCodeSource().getLocation().toURI()).getAbsolutePath();
            // Create registry entry for our app
            String regCommand = String.format(
                "reg add \"HKEY_CURRENT_USER\\Software\\Classes\\Applications\\WordTrigger.exe\\shell\\open\\command\" /d \"java -jar \\\"%s\\\" \\\"%%1\\\"\" /f",
                jarPath
            );
            Process regProcess = Runtime.getRuntime().exec(regCommand);
            if (regProcess.waitFor() != 0) return false;

            // Set the Word file's default open program to our app
            String fileExt = wordFilePath.substring(wordFilePath.lastIndexOf('.') + 1);
            String setFileCommand = String.format(
                "reg add \"HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts\\.%s\\UserChoice\" /v ProgId /d \"WordTrigger.exe\" /f",
                fileExt
            );
            regProcess = Runtime.getRuntime().exec(setFileCommand);
            return regProcess.waitFor() == 0;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // Launch the user-specified target program/file
    private static void launchTargetProgram(String wordFilePath) {
        String targetPath = config.getProperty(wordFilePath);
        if (targetPath == null || !new File(targetPath).exists()) {
            JOptionPane.showMessageDialog(null, "No target program found for this Word file!", "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }
        try {
            Desktop.getDesktop().open(new File(targetPath));
        } catch (IOException e) {
            JOptionPane.showMessageDialog(null, "Failed to launch target: " + e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
        }
    }

    // Open the Word file with the system's default Word app
    private static void openWordDocument(String wordFilePath) {
        try {
            // Directly call WINWORD.EXE for reliability
            Process wordProcess = Runtime.getRuntime().exec(String.format("WINWORD.EXE \"%s\"", wordFilePath));
        } catch (IOException e) {
            // Fallback to system default open if WINWORD isn't found
            try {
                Desktop.getDesktop().open(new File(wordFilePath));
            } catch (IOException ex) {
                JOptionPane.showMessageDialog(null, "Failed to open Word file: " + ex.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
            }
        }
    }
}

2. Package as an Executable JAR #

Use your IDE (IntelliJ/Eclipse) or the jar command to package the code into a runnable JAR file. Make sure to set the Main-Class attribute to WordTrigger in the manifest.

3. Key Notes #

• Administrator Rights: Modifying Windows registry entries requires admin privileges—run the JAR as Administrator when setting up the association.
• Cross-Platform: The above code is Windows-focused. For Mac, you'd use launchservices commands to set file associations; for Linux, xdg-mime.
• File Moves: If the Word file or target program is moved, you'll need to re-run the setup GUI to update the config.
• Reliability: Calling WINWORD.EXE directly is more reliable than Desktop.open() since it ensures Word (not another app) opens the document.

Alternative Non-Java Approach #

If Java's registry handling feels clunky, you could use Python's winreg module or an AutoHotkey script to achieve the same logic—both are lightweight and handle Windows system interactions smoothly.

内容的提问来源于stack exchange，提问作者Vishal Gajera