eclipse.jdt.ls

Java language server

1,748

389

1,748

400

View on GitHub

Top Related Projects

vscode-java

2,070

Java Language Support for Visual Studio Code

language-server-protocol

11,088

Defines a common protocol for language servers.

Quick Overview

Eclipse JDT Language Server (eclipse.jdt.ls) is an implementation of the Language Server Protocol for Java. It provides Java language support features like code completion, refactoring, and debugging to various IDEs and text editors that support the Language Server Protocol.

Pros

Provides a standardized way to add Java language support to multiple editors and IDEs
Offers rich Java development features, including code completion, refactoring, and debugging
Regularly updated and maintained by the Eclipse Foundation
Supports both Maven and Gradle project structures

Cons

Can be resource-intensive, especially for large projects
Initial setup and configuration can be complex for some editors
May have occasional compatibility issues with certain Java versions or project structures
Performance may vary depending on the client editor and project size

Getting Started

To use eclipse.jdt.ls in your development environment:

Ensure you have Java 11 or later installed on your system.
Install a compatible editor or IDE that supports the Language Server Protocol (e.g., VS Code, Vim, Emacs).
Install the appropriate extension or plugin for your editor that integrates with eclipse.jdt.ls.
Configure your editor settings to use eclipse.jdt.ls for Java language support.
Open a Java project in your editor and start coding with enhanced Java language features.

For specific installation and configuration instructions, refer to the documentation of your chosen editor and its eclipse.jdt.ls integration plugin.

Competitor Comparisons

vscode-java

2,070

Java Language Support for Visual Studio Code

Pros of vscode-java

Tighter integration with Visual Studio Code, providing a more seamless experience for VSCode users
More frequent updates and active community support
Includes additional features like code snippets and refactoring tools specific to VSCode

Cons of vscode-java

Limited to Visual Studio Code, while eclipse.jdt.ls can be used with multiple editors
May have a slightly larger memory footprint due to additional VSCode-specific features
Potentially slower startup time compared to the more lightweight eclipse.jdt.ls

Code Comparison

vscode-java:

@Override
public void initialize(InitializeParams params) {
    super.initialize(params);
    // VSCode-specific initialization
    initializeVSCodeFeatures();
}

eclipse.jdt.ls:

@Override
public void initialize(InitializeParams params) {
    super.initialize(params);
    // Generic initialization
    initializeLanguageServer();
}

The code snippets illustrate the difference in initialization processes, with vscode-java including additional VSCode-specific features.

language-server-protocol

11,088

Defines a common protocol for language servers.

Pros of language-server-protocol

Language-agnostic specification, enabling broader adoption across different programming languages
Extensive documentation and community support, facilitating easier implementation and integration
Standardized protocol, promoting interoperability between various editors and IDEs

Cons of language-server-protocol

More abstract and general, potentially requiring additional work to implement language-specific features
May have a steeper learning curve for developers new to the concept of language servers

Code Comparison

language-server-protocol (JSON-RPC message):

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "textDocument/completion",
  "params": {
    "textDocument": { "uri": "file:///path/to/file.txt" },
    "position": { "line": 10, "character": 15 }
  }
}

eclipse.jdt.ls (Java implementation):

CompletionParams params = new CompletionParams();
params.setTextDocument(new TextDocumentIdentifier("file:///path/to/file.txt"));
params.setPosition(new Position(10, 15));
CompletionList completions = languageServer.getTextDocumentService().completion(params).get();

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Eclipse JDT Language Server

The Eclipse JDT Language Server is a Java language specific implementation of the Language Server Protocol and can be used with any editor that supports the protocol, to offer good support for the Java Language. The server is based on:

Eclipse LSP4J, the Java binding for the Language Server Protocol,
Eclipse JDT, which provides Java support (code completion, references, diagnostics...),
M2Eclipse, which provides Maven support,
Buildship, which provides Gradle support.

Features

Supports compiling projects from Java 1.8 through 22
Maven pom.xml project support
Gradle project support (with experimental Android project import support)
Standalone Java files support
As-you-type reporting of syntax and compilation errors
Code completion
Javadoc hovers
Organize imports
Type search
Code actions (quick fixes, source actions & refactorings)
Code outline
Code folding
Code navigation
Code lens (references/implementations)
Code formatting (on-type/selection/file)
Code snippets
Highlights (semantic highlighting)
Semantic selection
Diagnostic tags
Call Hierarchy
Type Hierarchy
Annotation processing support (automatic for Maven projects)
Automatic source resolution for classes in jars with maven coordinates
Extensibility

Requirements

The language server requires a runtime environment of Java 17 (at a minimum) to run. This should either be set in the JAVA_HOME environment variable, or on the user's path.

Installation

There are several options to install eclipse.jdt.ls:

Download and extract a milestone build from http://download.eclipse.org/jdtls/milestones/
Download and extract a snapshot build from http://download.eclipse.org/jdtls/snapshots/
Under some Linux distributions you can use the package manager. Search the package repositories for jdtls or eclipse.jdt.ls.
Build it from source. Clone the repository via git clone and build the project via JAVA_HOME=/path/to/java/17 ./mvnw clean verify. Optionally append -DskipTests=true to by-pass the tests. This command builds the server into the ./org.eclipse.jdt.ls.product/target/repository folder.

Some editors or editor extensions bundle eclipse.jdt.ls or contain logic to install it. If that is the case, you only need to install the editor extension. For example for Visual Studio Code you can install the Extension Pack for Java and it will take care of the rest.

Running from the command line

If you built eclipse.jdt.ls from source, cd into ./org.eclipse.jdt.ls.product/target/repository. If you downloaded a milestone or snapshot build, extract the contents.

To start the server in the active terminal, adjust the following command as described further below and run it:

java \
	-Declipse.application=org.eclipse.jdt.ls.core.id1 \
	-Dosgi.bundles.defaultStartLevel=4 \
	-Declipse.product=org.eclipse.jdt.ls.core.product \
	-Dlog.level=ALL \
	-Xmx1G \
	--add-modules=ALL-SYSTEM \
	--add-opens java.base/java.util=ALL-UNNAMED \
	--add-opens java.base/java.lang=ALL-UNNAMED \
	-jar ./plugins/org.eclipse.equinox.launcher_1.5.200.v20180922-1751.jar \
	-configuration ./config_linux \
	-data /path/to/data

Choose a value for -configuration: this is the path to your platform's configuration directory. For Linux, use ./config_linux. For windows, use ./config_win. For mac/OS X, use ./config_mac.
Change the filename of the jar in -jar ./plugins/... to match the version you built or downloaded.
Choose a value for -data: An absolute path to your data directory. eclipse.jdt.ls stores workspace specific information in it. This should be unique per workspace/project.

If you want to debug eclipse.jdt.ls itself, add -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=1044 right after java and ensure nothing else is running on port 1044. If you want to debug from the start of execution, change suspend=n to suspend=y so the JVM will wait for your debugger prior to starting the server.

Running from command line with wrapper script

There is also a Python wrapper script available that makes the start up of eclipse.jdt.ls more convenient (no need to juggle with Java options etc.). A sample usage is described below. The script requires Python 3.9.

./org.eclipse.jdt.ls.product/target/repository/bin/jdtls \
	-configuration ~/.cache/jdtls \
	-data /path/to/data

All shown Java options will be set by the wrapper script. Please, note that the -configuration options points to a user's folder to ensure that the configuration folder in org.eclipse.jdt.ls.product/target/repository/config_* remains untouched.

Development Setup

See Contributing

Managing connection types

The Java Language server supports sockets, named pipes, and standard streams of the server process to communicate with the client. Client can communicate its preferred connection methods by setting up environment variables or alternatively using system properties (e.g. -DCLIENT_PORT=...)

To use a plain socket, set the following environment variables or system properties before starting the server:
- CLIENT_PORT: the port of the socket to connect to
- CLIENT_HOST: the host name to connect to. If not set, defaults to localhost.
The connection will be used for in and output.
To use standard streams(stdin, stdout) of the server process do not set any of the above environment variables and the server will fall back to standard streams.

For socket and named pipes, the client is expected to create the connections and wait for the server to connect.

Feedback

File a bug in GitHub Issues.
Join the discussion on our Mattermost channel
Tweet us with other feedback.

Clients

This repository only contains the server implementation. Here are some known clients consuming this server:

vscode-java : an extension for Visual Studio Code
ide-java : an extension for Atom
ycmd : a code-completion and code-comprehension server for multiple clients
Oni : modern modal editing - powered by Neovim.
LSP Java : a Java LSP client for Emacs
Eclipse Theia : Theia is a cloud & desktop IDE framework implemented in TypeScript
Eclipse IDE JDT.LS : an extension for Eclipse IDE
coc-java : an extension for coc.nvim
MS Paint IDE : an IDE for programming in MS Paint
nvim-jdtls : an extension for Neovim
multilspy from monitors4codegen : A language-agnostic LSP client in Python, with a library interface. Intended to be used to build applications around language servers
OpenSumi : A framework that helps you quickly build Cloud or Desktop IDE products.

Continuous Integration Builds

Our CI server publishes the server binaries to http://download.eclipse.org/jdtls/snapshots/.

P2 repositories are available under http://download.eclipse.org/jdtls/snapshots/repository/.

Milestone builds are available under http://download.eclipse.org/jdtls/milestones/.

License

EPL 2.0, See LICENSE file.

Top Related Projects

vscode-java

2,070

Java Language Support for Visual Studio Code

language-server-protocol

11,088

Defines a common protocol for language servers.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot