VS Code中集成Java运算模块插件的完整实现方案

与Delphi相比，Java与VS Code的集成更加自然，因为两者都是基于现代开发栈。我将从技术架构到具体实现详细说明。

一、技术架构概览

1.1 核心架构图

Java计算引擎(JAR/Spring Boot) 
    ← HTTP/RPC/Java进程 → 
TypeScript/JavaScript适配层 
    ← VS Code API → 
IDE用户界面

1.2 实现方案比较

二、推荐架构：混合模式

根据需求分层实现：

• 轻量级计算：TypeScript直接实现
• 中等复杂度：Java子进程调用
• 复杂/已有逻辑：REST API或Language Server

三、完整实现步骤

第一阶段：VS Code插件基础配置

1.1 创建插件项目结构

java-calculator-extension/
├── package.json              # 插件清单
├── tsconfig.json            # TypeScript配置
├── webpack.config.js        # 打包配置
├── src/
│   ├── extension.ts         # 插件入口
│   ├── java/
│   │   ├── JavaCalculatorClient.ts
│   │   └── JavaProcessManager.ts
│   ├── ui/
│   │   ├── CalculatorPanel.ts
│   │   └── ResultView.ts
│   ├── providers/
│   │   ├── HoverProvider.ts
│   │   ├── CompletionProvider.ts
│   │   └── CodeActionProvider.ts
│   └── commands/
│       ├── CalculateCommand.ts
│       └── OpenPanelCommand.ts
├── java/
│   ├── calculator-core/     # Maven/Gradle项目
│   └── calculator-server/   # Spring Boot服务
├── resources/
│   ├── calculator.html
│   └── styles/
└── out/                     # 编译输出

1.2 核心package.json配置

{
  "name": "java-calculator",
  "displayName": "Java Calculator Extension",
  "version": "1.0.0",
  "publisher": "your-company",
  "engines": {
    "vscode": "^1.75.0"
  },
  "categories": ["Other"],
  "activationEvents": [
    "onStartupFinished",
    "onCommand:javaCalculator.calculate",
    "onLanguage:java",
    "onLanguage:javascript",
    "onLanguage:python"
  ],
  "main": "./out/extension.js",
  "browser": "./out/web/extension.js",
  "contributes": {
    "commands": [
      {
        "command": "javaCalculator.calculate",
        "title": "Calculate with Java",
        "category": "Java Calculator"
      },
      {
        "command": "javaCalculator.openPanel",
        "title": "Open Calculator Panel"
      }
    ],
    "menus": {
      "editor/context": [
        {
          "command": "javaCalculator.calculate",
          "when": "editorHasSelection",
          "group": "navigation"
        }
      ],
      "view/title": [
        {
          "command": "javaCalculator.openPanel",
          "when": "view == javaCalculatorView",
          "group": "navigation"
        }
      ]
    },
    "views": {
      "explorer": [
        {
          "id": "javaCalculatorView",
          "name": "Java Calculator"
        }
      ]
    },
    "viewsContainers": {
      "activitybar": [
        {
          "id": "java-calculator",
          "title": "Java Calc",
          "icon": "resources/icon.svg"
        }
      ]
    },
    "configuration": {
      "title": "Java Calculator",
      "properties": {
        "javaCalculator.enable": {
          "type": "boolean",
          "default": true,
          "description": "Enable Java Calculator"
        },
        "javaCalculator.javaPath": {
          "type": "string",
          "default": "java",
          "description": "Path to Java executable"
        },
        "javaCalculator.serverPort": {
          "type": "number",
          "default": 7070,
          "description": "Port for Java server"
        },
        "javaCalculator.maxHeapSize": {
          "type": "string",
          "default": "512m",
          "description": "Max heap size for Java process"
        }
      }
    }
  },
  "scripts": {
    "vscode:prepublish": "npm run compile",
    "compile": "tsc -p ./",
    "watch": "tsc -watch -p ./",
    "lint": "eslint src --ext ts",
    "test": "npm run compile && node ./out/test/runTest.js",
    "package": "vsce package",
    "publish": "vsce publish"
  },
  "dependencies": {
    "axios": "^1.3.0",
    "socket.io-client": "^4.5.0",
    "vscode-languageclient": "^8.0.0",
    "vscode-languageserver": "^8.0.0",
    "web-worker": "^1.2.0"
  },
  "devDependencies": {
    "@types/node": "^18.0.0",
    "@types/vscode": "^1.75.0",
    "@typescript-eslint/eslint-plugin": "^5.0.0",
    "@typescript-eslint/parser": "^5.0.0",
    "eslint": "^8.0.0",
    "typescript": "^4.9.0",
    "vsce": "^2.0.0"
  }
}

第二阶段：Java计算模块实现

2.1 基础计算核心（Maven项目）

<project>
    <modelVersion>4.0.0modelVersion>
    <groupId>com.examplegroupId>
    <artifactId>calculator-coreartifactId>
    <version>1.0.0version>
    
    <dependencies>
        <dependency>
            <groupId>org.apache.commonsgroupId>
            <artifactId>commons-math3artifactId>
            <version>3.6.1version>
        dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-databindartifactId>
            <version>2.14.0version>
        dependency>
    dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-shade-pluginartifactId>
                <version>3.3.0version>
                <executions>
                    <execution>
                        <phase>packagephase>
                        <goals>
                            <goal>shadegoal>
                        goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.example.calculator.CalculatorCLImainClass>
                                transformer>
                            transformers>
                        configuration>
                    execution>
                executions>
            plugin>
        plugins>
    build>
project>

2.2 Java计算引擎实现

// CalculatorEngine.java
package com.example.calculator;

import org.apache.commons.math3.complex.Complex;
import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import java.util.HashMap;
import java.math.BigDecimal;
import java.math.RoundingMode;

public class CalculatorEngine {
    
    private static final ObjectMapper mapper = new ObjectMapper();
    
    public static class CalculationRequest {
        private String expression;
        private Map<String, Object> variables;
        private int precision = 10;
        // getters and setters
    }
    
    public static class CalculationResult {
        private boolean success;
        private Object result;
        private String error;
        private long executionTime;
        // getters and setters
    }
    
    public CalculationResult evaluate(CalculationRequest request) {
        long startTime = System.nanoTime();
        CalculationResult result = new CalculationResult();
        
        try {
            // 解析表达式
            Object calculated = evaluateExpression(
                request.getExpression(), 
                request.getVariables()
            );
            
            // 精度处理
            if (calculated instanceof BigDecimal) {
                calculated = ((BigDecimal) calculated)
                    .setScale(request.getPrecision(), RoundingMode.HALF_UP);
            }
            
            result.setSuccess(true);
            result.setResult(calculated);
            
        } catch (Exception e) {
            result.setSuccess(false);
            result.setError(e.getMessage());
        }
        
        result.setExecutionTime(System.nanoTime() - startTime);
        return result;
    }
    
    private Object evaluateExpression(String expr, Map<String, Object> vars) {
        // 使用Apache Commons Math或自定义解析器
        if (expr.contains("+")) {
            String[] parts = expr.split("+");
            BigDecimal sum = BigDecimal.ZERO;
            for (String part : parts) {
                sum = sum.add(new BigDecimal(evaluatePart(part, vars).toString()));
            }
            return sum;
        }
        // 更多运算符实现...
        return expr;
    }
    
    // 统计计算功能
    public Map<String, Object> statisticalAnalysis(double[] data) {
        Map<String, Object> stats = new HashMap<>();
        DescriptiveStatistics ds = new DescriptiveStatistics(data);
        
        stats.put("mean", ds.getMean());
        stats.put("median", ds.getPercentile(50));
        stats.put("stdDev", ds.getStandardDeviation());
        stats.put("variance", ds.getVariance());
        stats.put("min", ds.getMin());
        stats.put("max", ds.getMax());
        stats.put("sum", ds.getSum());
        
        return stats;
    }
    
    // 复数计算
    public Complex complexOperation(String op, Complex a, Complex b) {
        switch (op) {
            case "add": return a.add(b);
            case "subtract": return a.subtract(b);
            case "multiply": return a.multiply(b);
            case "divide": return a.divide(b);
            default: throw new IllegalArgumentException("Unknown operation: " + op);
        }
    }
}

2.3 Spring Boot REST API服务器

// CalculatorApplication.java
package com.example.calculator;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;

@SpringBootApplication
@RestController
@RequestMapping("/api/v1")
public class CalculatorApplication {
    
    private final CalculatorEngine engine = new CalculatorEngine();
    
    @PostMapping("/calculate")
    public ResponseEntity<?> calculate(@RequestBody CalculatorEngine.CalculationRequest request) {
        CalculatorEngine.CalculationResult result = engine.evaluate(request);
        return ResponseEntity.ok(result);
    }
    
    @PostMapping("/stats")
    public ResponseEntity<?> statistics(@RequestBody double[] data) {
        return ResponseEntity.ok(engine.statisticalAnalysis(data));
    }
    
    @PostMapping("/matrix")
    public ResponseEntity<?> matrixOperation(@RequestBody MatrixRequest request) {
        // 矩阵运算实现
        return ResponseEntity.ok(performMatrixOperation(request));
    }
    
    @GetMapping("/health")
    public ResponseEntity<?> healthCheck() {
        return ResponseEntity.ok(Map.of("status", "healthy", "timestamp", System.currentTimeMillis()));
    }
    
    public static void main(String[] args) {
        SpringApplication.run(CalculatorApplication.class, args);
    }
}

2.4 命令行接口（CLI）

// CalculatorCLI.java
package com.example.calculator;

import com.fasterxml.jackson.databind.ObjectMapper;

public class CalculatorCLI {
    public static void main(String[] args) {
        ObjectMapper mapper = new ObjectMapper();
        CalculatorEngine engine = new CalculatorEngine();
        
        try {
            if (args.length > 0) {
                CalculatorEngine.CalculationRequest request = mapper.readValue(
                    args[0], CalculatorEngine.CalculationRequest.class
                );
                
                CalculatorEngine.CalculationResult result = engine.evaluate(request);
                
                System.out.println(mapper.writeValueAsString(result));
                
                // 非零退出码表示错误
                if (!result.isSuccess()) {
                    System.exit(1);
                }
            }
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            System.exit(2);
        }
    }
}

第三阶段：VS Code插件实现

3.1 Java进程管理器

// src/java/JavaProcessManager.ts
import * as cp from 'child_process';
import * as path from 'path';
import * as vscode from 'vscode';
import { EventEmitter } from 'events';

export class JavaProcessManager extends EventEmitter {
    private javaProcess: cp.ChildProcess | null = null;
    private isServerRunning: boolean = false;
    private serverPort: number;
    private javaPath: string;

    constructor() {
        super();
        const config = vscode.workspace.getConfiguration('javaCalculator');
        this.serverPort = config.get<number>('serverPort') || 7070;
        this.javaPath = config.get<string>('javaPath') || 'java';
    }

    async startJavaServer(): Promise<boolean> {
        return new Promise((resolve, reject) => {
            try {
                const jarPath = path.join(__dirname, '../../java/calculator-server/target/calculator-server.jar');
                
                this.javaProcess = cp.spawn(this.javaPath, [
                    `-Xmx${this.getHeapSize()}`,
                    '-jar',
                    jarPath,
                    `--server.port=${this.serverPort}`
                ], {
                    cwd: path.dirname(jarPath),
                    stdio: ['pipe', 'pipe', 'pipe']
                });

                this.javaProcess.stdout?.on('data', (data) => {
                    const output = data.toString();
                    console.log(`Java Server: ${output}`);
                    
                    if (output.includes('Started CalculatorApplication')) {
                        this.isServerRunning = true;
                        this.emit('server-ready');
                        resolve(true);
                    }
                });

                this.javaProcess.stderr?.on('data', (data) => {
                    console.error(`Java Server Error: ${data}`);
                });

                this.javaProcess.on('close', (code) => {
                    this.isServerRunning = false;
                    this.emit('server-stopped', code);
                });

                // 超时处理
                setTimeout(() => {
                    if (!this.isServerRunning) {
                        reject(new Error('Java server startup timeout'));
                    }
                }, 30000);

            } catch (error) {
                reject(error);
            }
        });
    }

    async executeCalculation(expression: string): Promise<any> {
        if (this.isServerRunning) {
            return this.callRESTAPI(expression);
        } else {
            return this.callCLI(expression);
        }
    }

    private async callCLI(expression: string): Promise<any> {
        return new Promise((resolve, reject) => {
            const jarPath = path.join(__dirname, '../../java/calculator-core/target/calculator-core.jar');
            
            const request = JSON.stringify({
                expression: expression,
                precision: 10
            });

            const child = cp.spawn(this.javaPath, ['-jar', jarPath, request]);
            let output = '';
            let error = '';

            child.stdout.on('data', (data) => output += data);
            child.stderr.on('data', (data) => error += data);

            child.on('close', (code) => {
                if (code === 0) {
                    try {
                        resolve(JSON.parse(output));
                    } catch (e) {
                        reject(new Error(`Parse error: ${e.message}`));
                    }
                } else {
                    reject(new Error(`CLI error: ${error}`));
                }
            });
        });
    }

    private async callRESTAPI(expression: string): Promise<any> {
        const axios = require('axios');
        try {
            const response = await axios.post(
                `http://localhost:${this.serverPort}/api/v1/calculate`,
                {
                    expression: expression,
                    variables: {},
                    precision: 10
                },
                {
                    timeout: 5000,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
            return response.data;
        } catch (error) {
            throw new Error(`REST API error: ${error.message}`);
        }
    }

    private getHeapSize(): string {
        const config = vscode.workspace.getConfiguration('javaCalculator');
        return config.get<string>('maxHeapSize') || '512m';
    }

    stopServer(): void {
        if (this.javaProcess) {
            this.javaProcess.kill('SIGTERM');
            this.isServerRunning = false;
        }
    }

    getStatus(): { running: boolean; port: number } {
        return {
            running: this.isServerRunning,
            port: this.serverPort
        };
    }
}

3.2 插件主入口

// src/extension.ts
import * as vscode from 'vscode';
import { JavaProcessManager } from './java/JavaProcessManager';
import { CalculatorPanel } from './ui/CalculatorPanel';
import { HoverProvider } from './providers/HoverProvider';
import { registerCommands } from './commands/CalculateCommand';

let processManager: JavaProcessManager;
let statusBarItem: vscode.StatusBarItem;

export async function activate(context: vscode.ExtensionContext) {
    console.log('Java Calculator extension is now active!');

    // 初始化Java进程管理器
    processManager = new JavaProcessManager();
    
    // 创建状态栏项目
    statusBarItem = vscode.window.createStatusBarItem(
        vscode.StatusBarAlignment.Right,
        100
    );
    statusBarItem.text = "$(calculator) Java Calc";
    statusBarItem.tooltip = "Java Calculator - Ready";
    statusBarItem.command = 'javaCalculator.openPanel';
    statusBarItem.show();
    
    // 启动Java服务器
    try {
        await processManager.startJavaServer();
        statusBarItem.text = "$(check) Java Calc";
        vscode.window.showInformationMessage('Java计算服务器已启动');
    } catch (error) {
        statusBarItem.text = "$(error) Java Calc";
        vscode.window.showWarningMessage('Java服务器启动失败，将使用CLI模式');
    }
    
    // 注册命令
    const commands = registerCommands(processManager);
    context.subscriptions.push(...commands);
    
    // 注册悬停提示提供者
    const hoverProvider = vscode.languages.registerHoverProvider(
        [
            { language: 'javascript' },
            { language: 'typescript' },
            { language: 'java' },
            { language: 'python' }
        ],
        new HoverProvider(processManager)
    );
    
    // 注册代码补全提供者
    const completionProvider = vscode.languages.registerCompletionItemProvider(
        { language: 'javascript' },
        {
            provideCompletionItems(document, position) {
                const linePrefix = document.lineAt(position).text.substring(0, position.character);
                if (!linePrefix.includes('// calculate:')) {
                    return undefined;
                }
                
                const suggestions = [
                    'sum',
                    'average',
                    'stdDev',
                    'variance',
                    'matrixMult'
                ].map(item => {
                    const completion = new vscode.CompletionItem(
                        item,
                        vscode.CompletionItemKind.Function
                    );
                    completion.detail = 'Java Calculator Function';
                    return completion;
                });
                
                return suggestions;
            }
        }
    );
    
    // 注册配置变更监听
    const configListener = vscode.workspace.onDidChangeConfiguration(e => {
        if (e.affectsConfiguration('javaCalculator')) {
            vscode.window.showInformationMessage('Java Calculator配置已更新，部分更改需要重启');
        }
    });
    
    // 注册到订阅列表
    context.subscriptions.push(
        statusBarItem,
        hoverProvider,
        completionProvider,
        configListener,
        {
            dispose: () => processManager.stopServer()
        }
    );
}

export function deactivate() {
    if (processManager) {
        processManager.stopServer();
    }
    if (statusBarItem) {
        statusBarItem.dispose();
    }
}

3.3 计算命令实现

// src/commands/CalculateCommand.ts
import * as vscode from 'vscode';
import { JavaProcessManager } from '../java/JavaProcessManager';

export function registerCommands(processManager: JavaProcessManager): vscode.Disposable[] {
    const disposables: vscode.Disposable[] = [];
    
    // 基础计算命令
    const calculateCommand = vscode.commands.registerCommand(
        'javaCalculator.calculate',
        async () => {
            const editor = vscode.window.activeTextEditor;
            if (!editor) {
                vscode.window.showErrorMessage('没有活动的编辑器');
                return;
            }
            
            const selection = editor.selection;
            const text = editor.document.getText(selection);
            
            if (!text.trim()) {
                vscode.window.showErrorMessage('请先选择要计算的表达式');
                return;
            }
            
            try {
                vscode.window.withProgress({
                    location: vscode.ProgressLocation.Notification,
                    title: "Java计算中...",
                    cancellable: false
                }, async (progress) => {
                    progress.report({ increment: 0 });
                    
                    const result = await processManager.executeCalculation(text);
                    
                    progress.report({ increment: 100 });
                    
                    if (result.success) {
                        // 显示结果
                        await showCalculationResult(editor, selection, result.result);
                    } else {
                        vscode.window.showErrorMessage(`计算错误: ${result.error}`);
                    }
                });
            } catch (error) {
                vscode.window.showErrorMessage(`计算失败: ${error.message}`);
            }
        }
    );
    
    // 打开计算面板命令
    const openPanelCommand = vscode.commands.registerCommand(
        'javaCalculator.openPanel',
        () => {
            CalculatorPanel.createOrShow(context.extensionUri, processManager);
        }
    );
    
    // 批量计算命令
    const batchCalculateCommand = vscode.commands.registerCommand(
        'javaCalculator.batchCalculate',
        async () => {
            const input = await vscode.window.showInputBox({
                prompt: '输入多个表达式（每行一个）',
                placeHolder: '2+2
3*4
sqrt(16)'
            });
            
            if (input) {
                const expressions = input.split('
').filter(expr => expr.trim());
                const results = [];
                
                for (const expr of expressions) {
                    try {
                        const result = await processManager.executeCalculation(expr);
                        results.push(`${expr} = ${result.success ? result.result : 'Error'}`);
                    } catch (error) {
                        results.push(`${expr} = Error: ${error.message}`);
                    }
                }
                
                const doc = await vscode.workspace.openTextDocument({
                    content: results.join('
'),
                    language: 'plaintext'
                });
                
                await vscode.window.showTextDocument(doc);
            }
        }
    );
    
    disposables.push(calculateCommand, openPanelCommand, batchCalculateCommand);
    return disposables;
}

async function showCalculationResult(
    editor: vscode.TextEditor,
    selection: vscode.Selection,
    result: any
): Promise<void> {
    const resultStr = String(result);
    
    // 提供多种结果显示方式
    const actions = ['插入到文档', '显示通知', '复制到剪贴板', '在面板中查看'];
    const selected = await vscode.window.showQuickPick(actions, {
        placeHolder: `结果: ${resultStr}`
    });
    
    switch (selected) {
        case '插入到文档':
            await editor.edit(editBuilder => {
                editBuilder.insert(selection.end, ` = ${resultStr}`);
            });
            break;
            
        case '显示通知':
            vscode.window.showInformationMessage(`计算结果: ${resultStr}`);
            break;
            
        case '复制到剪贴板':
            await vscode.env.clipboard.writeText(resultStr);
            vscode.window.showInformationMessage('结果已复制到剪贴板');
            break;
            
        case '在面板中查看':
            // 打开计算面板
            break;
    }
}

3.4 Webview计算面板

// src/ui/CalculatorPanel.ts
import * as vscode from 'vscode';
import * as path from 'path';
import { JavaProcessManager } from '../java/JavaProcessManager';

export class CalculatorPanel {
    public static currentPanel: CalculatorPanel | undefined;
    private readonly _panel: vscode.WebviewPanel;
    private readonly _extensionUri: vscode.Uri;
    private readonly _processManager: JavaProcessManager;
    private _disposables: vscode.Disposable[] = [];

    public static createOrShow(extensionUri: vscode.Uri, processManager: JavaProcessManager) {
        const column = vscode.window.activeTextEditor?.viewColumn || vscode.ViewColumn.One;

        if (CalculatorPanel.currentPanel) {
            CalculatorPanel.currentPanel._panel.reveal(column);
            return;
        }

        const panel = vscode.window.createWebviewPanel(
            'javaCalculator',
            'Java Calculator',
            column,
            {
                enableScripts: true,
                retainContextWhenHidden: true,
                localResourceRoots: [
                    vscode.Uri.joinPath(extensionUri, 'resources')
                ]
            }
        );

        CalculatorPanel.currentPanel = new CalculatorPanel(panel, extensionUri, processManager);
    }

    private constructor(
        panel: vscode.WebviewPanel,
        extensionUri: vscode.Uri,
        processManager: JavaProcessManager
    ) {
        this._panel = panel;
        this._extensionUri = extensionUri;
        this._processManager = processManager;

        this._updateWebview();
        this._setupMessageHandlers();

        this._panel.onDidDispose(() => this.dispose(), null, this._disposables);
    }

    private _updateWebview() {
        this._panel.webview.html = this._getHtmlForWebview();
    }

    private _getHtmlForWebview(): string {
        const scriptUri = this._panel.webview.asWebviewUri(
            vscode.Uri.joinPath(this._extensionUri, 'resources', 'calculator.js')
        );
        
        const styleUri = this._panel.webview.asWebviewUri(
            vscode.Uri.joinPath(this._extensionUri, 'resources', 'styles', 'calculator.css')
        );

        return `
            
            
            
                
                
                ${styleUri}" rel="stylesheet">
                
            
            
                

                    

                        
Java Calculator
                        
Ready
                    
                    
                    

                        
                        
                        

                            
Variables
                            

                            Add Variable
                        
                        
                        

                            Calculate
                            Clear
                            Load Examples
                        
                    
                    
                    

                        
Result
                        

                        

                    
                    
                    

                        
History
                        

                    
                
                
                
            
            `;
    }

    private _setupMessageHandlers() {
        this._panel.webview.onDidReceiveMessage(
            async (message) => {
                switch (message.command) {
                    case 'calculate':
                        await this._handleCalculation(message.expression, message.variables);
                        break;
                    case 'getStatus':
                        const status = this._processManager.getStatus();
                        this._panel.webview.postMessage({
                            command: 'statusUpdate',
                            status: status
                        });
                        break;
                }
            },
            null,
            this._disposables
        );
    }

    private async _handleCalculation(expression: string, variables: any) {
        try {
            const result = await this._processManager.executeCalculation(expression);
            
            this._panel.webview.postMessage({
                command: 'calculationResult',
                success: result.success,
                result: result.result,
                error: result.error,
                executionTime: result.executionTime
            });
            
            // 更新状态栏
            vscode.window.setStatusBarMessage(
                `Calculation completed in ${result.executionTime / 1000000}ms`,
                3000
            );
            
        } catch (error) {
            this._panel.webview.postMessage({
                command: 'calculationResult',
                success: false,
                error: error.message
            });
        }
    }

    public dispose() {
        CalculatorPanel.currentPanel = undefined;
        this._panel.dispose();
        
        while (this._disposables.length) {
            const disposable = this._disposables.pop();
            if (disposable) {
                disposable.dispose();
            }
        }
    }
}

第四阶段：高级功能实现

4.1 Language Server Protocol (LSP) 集成

// src/language-server/CalculatorLanguageServer.ts
import * as path from 'path';
import { workspace, ExtensionContext } from 'vscode';
import {
    LanguageClient,
    LanguageClientOptions,
    ServerOptions,
    TransportKind
} from 'vscode-languageclient/node';

let client: LanguageClient;

export function activateLanguageServer(context: ExtensionContext) {
    const serverModule = context.asAbsolutePath(
        path.join('java', 'language-server', 'target', 'calculator-ls.jar')
    );

    const serverOptions: ServerOptions = {
        run: {
            command: 'java',
            args: ['-jar', serverModule, '--stdio'],
            transport: TransportKind.stdio
        },
        debug: {
            command: 'java',
            args: [
                '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005',
                '-jar',
                serverModule,
                '--stdio'
            ],
            transport: TransportKind.stdio
        }
    };

    const clientOptions: LanguageClientOptions = {
        documentSelector: [
            { scheme: 'file', language: 'plaintext' },
            { scheme: 'untitled', language: 'plaintext' }
        ],
        synchronize: {
            fileEvents: workspace.createFileSystemWatcher('**/.calc')
        }
    };

    client = new LanguageClient(
        'javaCalculatorLS',
        'Java Calculator Language Server',
        serverOptions,
        clientOptions
    );

    client.start();
}

export function deactivateLanguageServer(): Thenable<void> | undefined {
    if (!client) {
        return undefined;
    }
    return client.stop();
}

4.2 实时协作计算

// src/collaboration/CollaborationManager.ts
import * as vscode from 'vscode';
import * as WebSocket from 'ws';

export class CollaborationManager {
    private ws: WebSocket | null = null;
    private sessionId: string | null = null;
    
    async createCollaborationSession(): Promise<string> {
        const sessionId = this.generateSessionId();
        
        // 连接到协作服务器
        this.ws = new WebSocket(`ws://localhost:8080/collaborate/${sessionId}`);
        
        this.ws.on('message', (data) => {
            this.handleCollaborationMessage(data.toString());
        });
        
        return sessionId;
    }
    
    private handleCollaborationMessage(message: string) {
        const data = JSON.parse(message);
        
        switch (data.type) {
            case 'calculation':
                this.broadcastCalculation(data.expression, data.result);
                break;
            case 'variableUpdate':
                this.updateSharedVariables(data.variables);
                break;
        }
    }
    
    private broadcastCalculation(expression: string, result: any) {
        vscode.window.showInformationMessage(
            `Collaborative calculation: ${expression} = ${result}`
        );
    }
}

第五阶段：构建与打包

5.1 Webpack配置

// webpack.config.js
const path = require('path');

module.exports = {
    target: 'node',
    mode: 'production',
    entry: './src/extension.ts',
    output: {
        path: path.resolve(__dirname, 'out'),
        filename: 'extension.js',
        libraryTarget: 'commonjs2'
    },
    externals: {
        vscode: 'commonjs vscode'
    },
    resolve: {
        extensions: ['.ts', '.js']
    },
    module: {
        rules: [
            {
                test: /.ts$/,
                exclude: /node_modules/,
                use: 'ts-loader'
            }
        ]
    },
    optimization: {
        minimize: true
    }
};

5.2 自动化构建脚本

// package.json 构建脚本部分
{
  "scripts": {
    "build:java": "cd java/calculator-core && mvn clean package && cd ../calculator-server && mvn clean package",
    "build:ts": "webpack --mode production",
    "build:all": "npm run build:java && npm run build:ts",
    "package": "npm run build:all && vsce package",
    "deploy": "npm run package && vsce publish"
  }
}

第六阶段：使用示例

示例1：基础使用

// 用户选择表达式 "2 * (3 + 4)^2"
// 触发命令后：
// 1. 发送到Java计算引擎
// 2. 返回结果 "98"
// 3. 可选择插入文档或显示通知

// 代码中直接调用
const result = await javaCalculator.evaluate("sin(PI/2)");
console.log(result); // 1

示例2：复杂计算

// 矩阵运算
const matrixA = [[1, 2], [3, 4]];
const matrixB = [[5, 6], [7, 8]];

const result = await javaCalculator.matrixMultiply(matrixA, matrixB);
// 返回: [[19, 22], [43, 50]]

示例3：统计计算

// 数据分析
const data = [1.2, 2.3, 3.4, 4.5, 5.6];
const stats = await javaCalculator.statisticalAnalysis(data);

// 包含: { mean: 3.4, median: 3.4, stdDev: 1.581, ... }

七、关键注意事项

1. Java环境检测

async function checkJavaEnvironment(): Promise<boolean> {
    try {
        const { exec } = require('child_process');
        const { stdout } = await exec('java -version');
        return stdout.includes('version');
    } catch {
        return false;
    }
}

2. 内存管理

// 监控Java进程内存
setInterval(() => {
    if (javaProcess) {
        const memoryUsage = process.memoryUsage();
        if (memoryUsage.heapUsed > 500 * 1024 * 1024) {
            // 触发GC或重启进程
            restartJavaProcess();
        }
    }
}, 30000);

3. 错误恢复

// 自动重连机制
let retryCount = 0;
const maxRetries = 3;

async function executeWithRetry(operation: () => Promise<any>) {
    while (retryCount < maxRetries) {
        try {
            return await operation();
        } catch (error) {
            retryCount++;
            if (retryCount === maxRetries) throw error;
            await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
        }
    }
}

八、性能优化建议

1. 连接池管理
2. 计算结果缓存
3. 预启动Java进程
4. 使用Web Workers进行计算
5. 增量计算结果更新

九、安全性考虑

1. 表达式沙箱化
2. 资源限制
3. 输入验证
4. 传输加密
5. 权限控制

总结

Java在VS Code中的集成比Delphi更加自然，主要优势在于：

1. 成熟的工具链：Maven/Gradle + TypeScript
2. 丰富的通信选择：REST、WebSocket、进程间通信等
3. 强大的生态：Spring Boot、Apache Commons Math等
4. 更好的性能：JIT优化，内存管理成熟

实现的关键点：

• 选择合适的通信机制
• 设计良好的API接口
• 实现完善的错误处理
• 提供直观的用户界面
• 确保性能和稳定性

这种架构不仅适用于计算插件，也可作为其他Java功能集成到VS Code的参考模板。