Groovy has one feature I always wanted to have in Java - Grapes. Grapes let you define Maven dependencies inside the source code file and Groovy resolves them when you run the script. This enables writing applications that leverage whole ecosystem of Java libraries in a single-file.
groovy
@Grab('org.apache.httpcomponents:httpclient:4.2.1')
import org.apache.http.impl.client.DefaultHttpClient
import org.apache.http.client.methods.HttpGet
def httpClient = new DefaultHttpClient()
def url = 'http://www.google.com/search?q=Groovy'
def httpGet = new HttpGet(url)
def httpResponse = httpClient.execute(httpGet)
new File('result.html').text =httpResponse.entity.content.textWhile such thing cannot be done with pure Java, it can work with a help of JBang.
JBang - a CLI created by Max Rydahl Andersen (who happens to be also Quarkus co-lead) lets you run Java code with minimum setup. It handles resolving dependencies and even installing the JDK version you declare.
This is an equivalent of the Groovy script from above:
java
//usr/bin/env jbang "$0" "$@" ; exit $?
//JAVA 17
//DEPS org.apache.httpcomponents:httpclient:4.2.1
import java.io.FileOutputStream;
import java.io.IOException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
public class HttpClientDemo {
public static void main(String[] args) throws IOException {
var httpClient = new DefaultHttpClient();
var httpGet = new HttpGet("http://www.google.com/search?q=Groovy");
var httpResponse = httpClient.execute(httpGet);
try(var writer = new FileOutputStream("result.html")) {
writer.write(httpResponse.getEntity().getContent().readAllBytes());
}
}
}Which can be run with:
bash
$ jbang run HttpClientDemo.javaNo Maven, no Gradle, no complex directory structure. Just one single command to use.
It makes Java feel almost like a scripting language, just better.
Why not use this approach to develop a Spring Boot application? Lets try:
java
//usr/bin/env jbang "$0" "$@" ; exit $?
//JAVA 17
//DEPS org.springframework.boot:spring-boot-starter-web:2.7.5
package app;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class, args);
}
@GetMapping("/")
String hello() {
return "hello world";
}
}Executing:
bash
$ jbang run MyApp.javastarts a Spring Boot application on port 8080.
JBang can also build an executable JAR file:
bash
$ jbang export portable MyApp.javaIt will create a MyApp.jar file containing our source code, and all the dependencies will land in lib directory. At this stage, there is no option to build a single fat-jar containing both our code and the dependencies.
To make it a bit more production ready, we can easily build a Docker image:
Dockerfile
FROM jbangdev/jbang-action AS build
RUN mkdir /app
WORKDIR /app
COPY . /app
RUN jbang export portable MyApp.java
FROM openjdk:17-alpine
RUN mkdir /app/
RUN mkdir /app/lib
COPY --from=build /app/MyApp.jar /app/MyApp.jar
COPY --from=build /app/lib/* /app/lib/
WORKDIR /app
CMD "java" "-jar" "MyApp.jar"(please don't take it as an example of production ready Dockerfile - it's just for educational purposes 🙃)
Then build & run:
bash
docker build . -t my-app
docker run -p 8080:8080 my-appI can't really write Java code without a proper IDE and autocompletion. The good thing is that there are JBang plugins for major IDEs:
I think JBang is a great addition to Java ecosystem. It is not a replacement for regular toolchain, but definitely enables experimenting with Java language and Java libraries by taking away all the heavy lifting related with setting up build files.
Let's stay in touch and follow me on Twitter: @maciejwalkowiak
Subscribe to RSS feed 
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。