How microsoft/vscode-java-dependency works
Project Type and Purpose
• This is a Visual Studio Code extension (“Project Manager for Java”) written in TypeScript/JavaScript, which integrates with the Red Hat Java Language Server (jdtls) and a companion Java plugin (jdtls.ext) to provide enhanced Java-project exploration, creation, dependency management, and JAR export in VS Code.
Main Architectural Components
a. VS Code Client & UI Layer
• VS Code Editor (UI host)
• Java Projects Explorer view (tree view UI)
b. Extension Host & Business Logic (Node.js process)
• The TypeScript/JavaScript entry point (extension.ts → controllers → views → commands → utility modules)
• LanguageServerApiManager: manages LSP connections & modes
• Controllers (e.g., projectController, libraryController) implementing commands (create, rename, delete, export)
• Task Providers (buildTaskProvider, BuildArtifactTaskProvider): exposes VS Code tasks for building and exporting jars
• ExperimentationService / Telemetry
• Copilot integration modules
• File-system watchers / syncHandler
• Template engine (templates/invisible-project for project scaffolding)
c. Language Server & Java Plugin
• Red Hat Java Language Server (external process speaking LSP)
• jdtls.ext (a Maven-based Java plugin that is built and loaded by the language server): adds commands & model providers (com.microsoft.jdtls.ext.core)
d. File System & Build Tools
• Local disk (workspace folders, .java files, user-referenced JARs)
• Maven wrapper & pom.xml for jdtls.ext plugin build
e. Testing & CI/CD
• Mocha/TypeScript test suite under /test
• GitHub Actions & Azure Pipelines for multi-platform build & release
Relationships and Data Flows
• VS Code UI ←→ Extension Host via VS Code Extension API
• Extension Host ↔ Java Language Server via the Language Server Protocol (requests for project structure, symbols, diagnostics)
• Java Language Server loads the jdtls.ext plugin (Java VM loads compiled plugin JAR produced by Maven wrapper)
• Extension Host invokes VS Code Tasks API to run build/export commands (spawn processes: mvn, javac, jar)
• Controllers update the UI tree by reading the file system or by querying the language server plugin model (Trie-based package/project model)
• Telemetry and ExperimentationService collect usage/events and send to Microsoft
Key Architectural Patterns & Principles
• Modular MVC-style separation:
• Views (src/views) generate the UI nodes
• Controllers (src/controllers) mediate commands and user actions
• Models (src/java/*, jdtls.ext/* model packages) represent project/package trees
• Command Pattern: each user action (new, delete, rename, export) is encapsulated in its own command module
• Provider Pattern: TreeDataProvider for explorer, TaskProvider for build tasks, CodeActionProviders for migration
• LSP Integration: wraps language server interactions in a manager class (LanguageServerApiManager)
• Template-driven scaffolding: uses project templates for “invisible-project” creation