JeKa is a modern Java build tool focused on simplicity.

When starting with Java, developers usually just write some code, compile it, and run it. However, this is not enough to create useful Java applications or libraries that others can reuse. To build something practical in Java, we need to:

• Use third-party libraries (e.g., Guava, Gson, Commons CLI, etc.)
• Package and deploy the application/library so others can use it.

This is often done with traditional build tools like Maven or Gradle. These tools require significant learning and can involve tedious configuration.
A simpler alternative is JBang, which lets you write almost single-file Java apps and easily share them.

On the other hand, Jeka offers simple dependency management and deployment ala JBang while allowing you to build standard multi-class applications or libraries with proper tests included.

Scaffold a New Code Base

Prerequisite: Jeka must be installed.

Tip: To list available options, execute: jeka base: --doc.

To create a base structure, ready for starting coding right away, execute:

jeka base: scaffold scaffold.kind=APP

You’ll get the following project structure:

. 
├── jeka-src             <- Source root directory
│   ├── _dev             <- Optional package containing all non-prod (build and test)
│   │   ├── test
│   │   └── Build.java  
│   └── app              <- Sugested base package for production code/resources
│       └── App.java     
├── jeka-output          <- Generated dir where artifacts as jars, classes, reports or doc are generated
├── jeka.properties      <- Build configuration  (Java and jeka version, kben configurations, ...)
└── README.md            <- Describes available build commands

All your Java code is supposed to be in the jeka-src folder.

_dev is a special package for source code and dependencies used only for development (e.g., tests, builds).If you're new to Java, you can ignore or delete it.

The scaffolded example includes an App class in the app package. You can add or modify classes in any package you like.

Sync with IntelliJ

To sync with IntelliJ, execute:

jeka intellij: iml --force

If changes don't appear in IntelliJ, go to the project's root directory, and run: jeka intellij: initProject.

Add Dependencies

The App.java class declares a @JkDep annotation to reference a library. You can add as many libraries as needed. A good practice is to declare all libraries in the same base class.

@JkDep("com.github.lalyos:jfiglet:0.8.9")
@JkDep("com.fasterxml.jackson:jackson-bom::pom:2.18.2")
@JkDep("com.fasterxml.jackson.core:jackson-core")
@JkDep("com.fasterxml.jackson.core:jackson-annotations")
public class App {

    public static void main(String[] args) {
        ...
    }
}

See details on dependency notations.

Additionally, you can copy-paste JAR files into the following directory to automatically include them as dependencies:

├── jeka-boot      <- Jars included in the production classpath.

Declare non-prod dependencies

Declare dependency on any class under _dev package, to add dependency with embedding them in production.

package _dev;

@JkDep("org.junit.jupiter:junit-jupiter:5.11.4")
@JkDep("org.mockito:mockito-junit-jupiter:5.15.2")
class Build extends KBean {
    ...
}

Reminder: Don't forget to run jeka intellij: iml once you have modified the dependencies.

Run your Application

The application can be run using:

jeka base: scaffold scaffold.kind=APP

To clean compilation before starting, use --clean option (-c for short).

If ths source code is hosted in a Git repo, the application can be directly executed by referencing the repo as:

. 
├── jeka-src             <- Source root directory
│   ├── _dev             <- Optional package containing all non-prod (build and test)
│   │   ├── test
│   │   └── Build.java  
│   └── app              <- Sugested base package for production code/resources
│       └── App.java     
├── jeka-output          <- Generated dir where artifacts as jars, classes, reports or doc are generated
├── jeka.properties      <- Build configuration  (Java and jeka version, kben configurations, ...)
└── README.md            <- Describes available build commands

Create a Library

If you want to write a library, instead of an application, you need to declare both moduleId and versioning in order to publish it on a Maven repository:

jeka intellij: iml --force

Now, you can publish your library by executing:

@JkDep("com.github.lalyos:jfiglet:0.8.9")
@JkDep("com.fasterxml.jackson:jackson-bom::pom:2.18.2")
@JkDep("com.fasterxml.jackson.core:jackson-core")
@JkDep("com.fasterxml.jackson.core:jackson-annotations")
public class App {

    public static void main(String[] args) {
        ...
    }
}

Test your Code

The scaffolded code already contains a _dev.test.MyTest test class, ready to run.

├── jeka-boot      <- Jars included in the production classpath.

You can add more tests in any package you like. However, keep in mind that test classes not located in the _dev package (or its sub-packages) will be included in the production JAR as dead code.

Change Java Version

Nowadays, Java evolves rapidly, with new releases every six months. JeKa provides a very convenient way to switch between Java versions. Simply specify the version in the jeka.properties file:

package _dev;

@JkDep("org.junit.jupiter:junit-jupiter:5.11.4")
@JkDep("org.mockito:mockito-junit-jupiter:5.15.2")
class Build extends KBean {
    ...
}

This will automatically install JDK 23 during the next application compile or run.

Pre-defined Build Commands

Among others, Jeka provides the following commands:

jeka --program arg0 args1 ... # or `jeka -p` for short

Other commands:

jeka --remote [git repo url] --program arg0 arg1 ... # or jeka -r [git repo url] -p

Move to Full Project Structure

As the codebase is growing, you'll migh find more confortable in using a full project structure.
Moving to project is easy, to figure out how to do, visit the Build Projects Tutorial.

Code with Kotlin

You can also write Kotlin code in the code base. Just specify the kotlin version you want to use in jeka.properties file:

@base.moduleId=org.example:my-lib
@base.version=1.0.0-SNAPSHOT

Now, you can edit Kotlin code as shown below, seamlessly integrate it with the existing Java code in your codebase, or even create a 100% Kotlin application:

jeka maven: publish

Conclusion

Jeka offers a practical mode to start writing real-life Java application without the burden of traditional build tools.

Its polymorphic structure allows handling increasing complexity and size gradually, without sacrificing simplicity.

Resoures:

• Jeka
• Simple app Example
• Spring-Boot app Example
• Build Base Tutorial
• Other Examples

The above is the detailed content of JeKa: The Simplest Way to Start with Java for Real. For more information, please follow other related articles on the PHP Chinese website!