import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
public static void main(final String[] args) {
  try {
    ServerModule _serverModule = new ServerModule();
    final Injector injector = Guice.createInjector(_serverModule);
    final LanguageServer languageServer = injector.<LanguageServer>getInstance(LanguageServer.class);
    final ServerSocketChannel serverSocket = ServerSocketChannel.open();
    InetSocketAddress _inetSocketAddress = new InetSocketAddress("localhost", 5007);
    serverSocket.bind(_inetSocketAddress);
    final SocketChannel socketChannel = serverSocket.accept();
    InputStream _newInputStream = Channels.newInputStream(socketChannel);
    OutputStream _newOutputStream = Channels.newOutputStream(socketChannel);
    PrintWriter _printWriter = new PrintWriter(System.out);
    final Launcher<LanguageClient> launcher = LSPLauncher.createServerLauncher(languageServer, _newInputStream, _newOutputStream, true, _printWriter);
    launcher.startListening().get();
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
/**
 * creates a proxy, delegating to a remote endpoint, forwarding to another remote endpoint, that delegates to an actual implementation.
 * @param intf
 * @param impl
 * @return
 * @throws IOException 
 */
public <T> T wrap(Class<T> intf, T impl) {
	PipedInputStream in1 = new PipedInputStream();
	PipedOutputStream out1 = new PipedOutputStream();
	Launcher<T> launcher1 = Launcher.createLauncher(impl, intf, in1, out1);
	
	PipedInputStream in2 = new PipedInputStream();
	PipedOutputStream out2 = new PipedOutputStream();
	Launcher<T> launcher2 = Launcher.createLauncher(new Object(), intf, in2, out2);
	try {
		in1.connect(out2);
		in2.connect(out1);
	} catch (IOException e) {
		throw new IllegalStateException(e);
	}
	launcher1.startListening();
	launcher2.startListening();
	return launcher2.getRemoteProxy();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
@Test public void testCanceled() throws Exception {
	A a = new A() {
		@Override
		public void say(Param p) {
		}
	};
	Launcher<A> launcher = Launcher.createLauncher(a, A.class, new InputStream() {
		@Override
		public int read() throws IOException {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
			return '\n';
		}
	}, new ByteArrayOutputStream());
	Future<?> startListening = launcher.startListening();
	startListening.cancel(true);
	Assert.assertTrue(startListening.isDone());
	Assert.assertTrue(startListening.isCancelled());
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
@Override
public LanguageServer launch(String projectPath, LanguageClient client)
    throws LanguageServerException {
  try {
    Socket socket = new Socket(host, port);
    socket.setKeepAlive(true);
    InputStream inputStream = socket.getInputStream();
    OutputStream outputStream = socket.getOutputStream();

    Launcher<LanguageServer> launcher =
        Launcher.createLauncher(client, LanguageServer.class, inputStream, outputStream);

    launcher.startListening();
    return launcher.getRemoteProxy();
  } catch (IOException e) {
    throw new LanguageServerException(
        "Can't launch language server for project: " + projectPath, e);
  }
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
/**
 * Listen for requests from the parent node process. Send replies asynchronously. When the
 * request stream is closed, wait for 5s for all outstanding responses to compute, then return.
 */
public static void run(Socket connection) throws IOException {
    JavaLanguageServer server = new JavaLanguageServer();
    Launcher<LanguageClient> launcher =
            LSPLauncher.createServerLauncher(
                    server, connection.getInputStream(), connection.getOutputStream());

    server.installClient(launcher.getRemoteProxy());
    launcher.startListening();
    LOG.info(String.format("java.version is %s", System.getProperty("java.version")));
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
static <T> Launcher<T> createSocketLauncher(Object localService, Class<T> remoteInterface, SocketAddress socketAddress, ExecutorService executorService, Function<MessageConsumer, MessageConsumer> wrapper) throws IOException {
    AsynchronousServerSocketChannel serverSocket = AsynchronousServerSocketChannel.open().bind(socketAddress);
    AsynchronousSocketChannel socketChannel;
    try {
        socketChannel = serverSocket.accept().get();
        return Launcher.createIoLauncher(localService, remoteInterface, Channels.newInputStream(socketChannel), Channels.newOutputStream(socketChannel), executorService, wrapper);
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
    return null;
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
static <T> Launcher<T> createSocketLauncher(Object localService, Class<T> remoteInterface,
		SocketAddress socketAddress, ExecutorService executorService,
		Function<MessageConsumer, MessageConsumer> wrapper, InputStream inputStream, OutputStream outputStream)
		throws IOException {
	return Launcher.createIoLauncher(localService, remoteInterface, inputStream, outputStream, executorService,
			wrapper);
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
private void startConnection() throws IOException {
	protocol = new JDTLanguageServer(projectsManager, preferenceManager);
	ConnectionStreamFactory connectionFactory = new ConnectionStreamFactory();
	Launcher<JavaLanguageClient> launcher = Launcher.createLauncher(protocol,
																	JavaLanguageClient.class,
																	connectionFactory.getInputStream(),
																	connectionFactory.getOutputStream(),
																	Executors.newCachedThreadPool(), new ParentProcessWatcher(this.languageServer));
	protocol.connectClient(launcher.getRemoteProxy());
	launcher.startListening();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
@Test
public void testUnexpectedParams() throws Exception {
	// intercept log messages
	LogMessageAccumulator logMessages = new LogMessageAccumulator();
	try {
		logMessages.registerTo(GenericEndpoint.class);
		
		// create client messages
		String notificationMessage = "{\"jsonrpc\":\"2.0\","
				+ "\"method\":\"myNotification\",\n" 
				+ "\"params\": { \"value\": \"foo\" }\n"
				+ "}";
		String clientMessages = getHeader(notificationMessage.getBytes().length) + notificationMessage;
		
		// create server side
		ByteArrayInputStream in = new ByteArrayInputStream(clientMessages.getBytes());
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		UnexpectedParamsTestServer server = new UnexpectedParamsTestServer() {
			public void myNotification() {
			}
		};
		Launcher<MyClient> serverSideLauncher = Launcher.createLauncher(server, MyClient.class, in, out);
		serverSideLauncher.startListening();
		
		logMessages.await(Level.WARNING, "Unexpected params '{\"value\":\"foo\"}' for "
				+ "'public abstract void org.eclipse.lsp4j.jsonrpc.test.IntegrationTest$UnexpectedParamsTestServer.myNotification()' is ignored");
	} finally {
		logMessages.unregister();
	}
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
@Test public void testDone() throws Exception {
	A a = new A() {
		@Override
		public void say(Param p) {
		}
	};
	Launcher<A> launcher = Launcher.createLauncher(a, A.class, new ByteArrayInputStream("".getBytes()), new ByteArrayOutputStream());
	Future<?> startListening = launcher.startListening();
	startListening.get(TIMEOUT, TimeUnit.MILLISECONDS);
	Assert.assertTrue(startListening.isDone());
	Assert.assertFalse(startListening.isCancelled());
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
@Override
protected LanguageServer connectToLanguageServer(
    Process languageServerProcess, LanguageClient client) throws LanguageServerException {
  Launcher<LanguageServer> launcher =
      Launcher.createLauncher(
          client,
          LanguageServer.class,
          languageServerProcess.getInputStream(),
          languageServerProcess.getOutputStream());
  launcher.startListening();
  return launcher.getRemoteProxy();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
@Override
protected LanguageServer connectToLanguageServer(
    final Process languageServerProcess, LanguageClient client) {
  Launcher<LanguageServer> launcher =
      Launcher.createLauncher(
          client,
          LanguageServer.class,
          languageServerProcess.getInputStream(),
          languageServerProcess.getOutputStream());
  launcher.startListening();
  return launcher.getRemoteProxy();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
protected LanguageServer connectToLanguageServer(
    final Process languageServerProcess, LanguageClient client) {
  Launcher<LanguageServer> launcher =
      Launcher.createLauncher(
          client,
          LanguageServer.class,
          languageServerProcess.getInputStream(),
          languageServerProcess.getOutputStream());
  launcher.startListening();
  return launcher.getRemoteProxy();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
protected LanguageServer connectToLanguageServer(
    final Process languageServerProcess, LanguageClient client) {
  Launcher<LanguageServer> launcher =
      Launcher.createLauncher(
          client,
          LanguageServer.class,
          languageServerProcess.getInputStream(),
          languageServerProcess.getOutputStream());
  launcher.startListening();
  setYamlLanguageServer(launcher.getRemoteProxy());
  return launcher.getRemoteProxy();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
public static void main(String[] args) {
	CamelLanguageServer server = new CamelLanguageServer();
	Launcher<LanguageClient> launcher = Launcher.createLauncher(server, LanguageClient.class, System.in, System.out);
	server.connect(launcher.getRemoteProxy());
	launcher.startListening();
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
public static Launcher<LanguageClient> createServerLauncher(LanguageServer server, InputStream in, OutputStream out) {
	return Launcher.createLauncher(server, LanguageClient.class, in, out);
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
public static Launcher<LanguageServer> createClientLauncher(LanguageClient client, InputStream in, OutputStream out) {
	return Launcher.createLauncher(client, LanguageServer.class, in, out);
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
public static Launcher<IDebugProtocolClient> createServerLauncher(IDebugProtocolServer server, InputStream in,
		OutputStream out) {
	return DebugLauncher.createLauncher(server, IDebugProtocolClient.class, in, out);
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
public static Launcher<IDebugProtocolServer> createClientLauncher(IDebugProtocolClient client, InputStream in,
		OutputStream out) {
	return DebugLauncher.createLauncher(client, IDebugProtocolServer.class, in, out);
}
 

import org.eclipse.lsp4j.jsonrpc.Launcher; //导入依赖的package包/类
@Test
public void testCancellationResponse() throws Exception {
	// create client messages
	String requestMessage = "{\"jsonrpc\":\"2.0\","
			+ "\"id\":\"1\",\n" 
			+ "\"method\":\"askServer\",\n" 
			+ "\"params\": { value: \"bar\" }\n"
			+ "}";
	String cancellationMessage = "{\"jsonrpc\":\"2.0\","
			+ "\"method\":\"$/cancelRequest\",\n" 
			+ "\"params\": { id: 1 }\n"
			+ "}";
	String clientMessages = getHeader(requestMessage.getBytes().length) + requestMessage
			+ getHeader(cancellationMessage.getBytes().length) + cancellationMessage;
	
	// create server side
	ByteArrayInputStream in = new ByteArrayInputStream(clientMessages.getBytes());
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	MyServer server = new MyServer() {
		@Override
		public CompletableFuture<MyParam> askServer(MyParam param) {
			return CompletableFutures.computeAsync(cancelToken -> {
				try {
					long startTime = System.currentTimeMillis();
					do {
						cancelToken.checkCanceled();
						Thread.sleep(50);
					} while (System.currentTimeMillis() - startTime < TIMEOUT);
				} catch (InterruptedException e) {
					Assert.fail("Thread was interrupted unexpectedly.");
				}
				return param;
			});
		}
	};
	Launcher<MyClient> serverSideLauncher = Launcher.createLauncher(server, MyClient.class, in, out);
	serverSideLauncher.startListening().get(TIMEOUT, TimeUnit.MILLISECONDS);
	
	Assert.assertEquals("Content-Length: 132" + CRLF + CRLF
			+ "{\"jsonrpc\":\"2.0\",\"id\":\"1\",\"error\":{\"code\":-32800,\"message\":\"The request (id: 1, method: \\u0027askServer\\u0027) has been cancelled\"}}",
			out.toString());
}