Awesome-Java Libraries

A curated guide to Java’s most useful libraries organized by category with Maven/Gradle dependencies and code examples.

Build Tools

Maven

# Create new project
mvn archetype:generate -DgroupId=com.example -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart

# Build project
mvn clean install

# Run tests
mvn test

# Package JAR
mvn package

# Run specific class
mvn exec:java -Dexec.mainClass="com.example.Main"

Gradle

# Create new project
gradle init --type java-application

# Build project
gradle build

# Run tests
gradle test

# Run application
gradle run

Web Frameworks

Framework	Maven Dependency	Purpose
Spring Boot	`org.springframework.boot:spring-boot-starter-web`	Full-featured web framework
Spring MVC	`org.springframework:spring-webmvc`	Web MVC framework
Jakarta EE	`jakarta.platform:jakarta.platform-api`	Enterprise Java Platform
Quarkus	`io.quarkus:quarkus-spring-web`	Cloud-native framework

Spring Boot REST API Example

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>3.0.0</version>
</dependency>

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return new User(id, "John Doe");
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return user;
    }
}

Database & ORM

Library	Maven Dependency	Purpose
Hibernate	`org.hibernate:hibernate-core`	ORM framework
JPA/Jakarta	`jakarta.persistence:jakarta.persistence-api`	Persistence API
MyBatis	`org.mybatis:mybatis`	SQL mapper
JDBC	Built-in	Raw database access
Liquibase	`org.liquibase:liquibase-core`	Database migrations
Flyway	`org.flywaydb:flyway-core`	Database version control

Hibernate Configuration

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.2.0</version>
</dependency>

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.6.0</version>
</dependency>

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(unique = true)
    private String email;

    // Getters and setters
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

Testing Frameworks

Framework	Maven Dependency	Purpose
JUnit 5	`org.junit.jupiter:junit-jupiter`	Unit testing
Mockito	`org.mockito:mockito-core`	Mocking framework
TestNG	`org.testng:testng`	Testing framework
AssertJ	`org.assertj:assertj-core`	Fluent assertions

JUnit 5 Test Example

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.2.0</version>
    <scope>test</scope>
</dependency>

public class CalculatorTest {
    private Calculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }

    @Test
    void testAddition() {
        assertEquals(5, calculator.add(2, 3));
    }

    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3})
    void testPositiveNumbers(int number) {
        assertTrue(number > 0);
    }
}

Logging Frameworks

Framework	Maven Dependency	Purpose
Logback	`ch.qos.logback:logback-classic`	Logging framework
Log4j2	`org.apache.logging.log4j:log4j-core`	High-performance logging
SLF4J	`org.slf4j:slf4j-api`	Logging facade
Log4j	`log4j:log4j`	Legacy logging library

Logback Configuration

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.5</version>
</dependency>

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.5</version>
</dependency>

<!-- logback.xml -->
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="INFO">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyService {
    private static final Logger logger = LoggerFactory.getLogger(MyService.class);

    public void doSomething() {
        logger.info("Doing something");
        logger.debug("Debug information");
        logger.error("An error occurred", new Exception());
    }
}

JSON Processing

Library	Maven Dependency	Purpose
Jackson	`com.fasterxml.jackson.core:jackson-databind`	JSON serialization
Gson	`com.google.code.gson:gson`	JSON parser
JSON-B	`jakarta.json.bind:jakarta.json.bind-api`	JSON binding

Jackson Example

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.14.2</version>
</dependency>

ObjectMapper mapper = new ObjectMapper();

// Serialize to JSON
User user = new User(1L, "John Doe");
String json = mapper.writeValueAsString(user);

// Deserialize from JSON
User deserializedUser = mapper.readValue(json, User.class);

// Pretty print
String prettyJson = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);

Data Processing

Library	Maven Dependency	Purpose
Apache Commons	`org.apache.commons:commons-lang3`	Utility functions
Guava	`com.google.guava:guava`	Google core utilities
StreamEx	`one.util:streamex`	Stream API extensions

Apache Commons Example

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

import org.apache.commons.lang3.StringUtils;

String text = "Hello World";
StringUtils.capitalize(text);  // "Hello world"
StringUtils.reverse(text);     // "dlroW olleH"
StringUtils.contains(text, "World");  // true

HTTP Clients

Library	Maven Dependency	Purpose
OkHttp	`com.squareup.okhttp3:okhttp`	HTTP client
HttpClient	`org.apache.httpcomponents:httpclient`	Apache HTTP client
Retrofit	`com.squareup.retrofit2:retrofit`	Type-safe HTTP client

OkHttp Example

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.10.0</version>
</dependency>

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
    .url("https://api.github.com/users/github")
    .build();

try (Response response = client.newCall(request).execute()) {
    System.out.println(response.body().string());
}

Cryptography & Security

Library	Maven Dependency	Purpose
Bouncy Castle	`org.bouncycastle:bcprov-jdk15on`	Cryptography provider
Spring Security	`org.springframework.security:spring-security-core`	Security framework
JJWT	`io.jsonwebtoken:jjwt`	JWT library

Spring Security Authentication

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-core</artifactId>
    <version>6.0.0</version>
</dependency>

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(authz -> authz
            .requestMatchers("/public/**").permitAll()
            .anyRequest().authenticated()
        ).formLogin();
        return http.build();
    }
}

Dependency Injection

Framework	Maven Dependency	Purpose
Spring DI	`org.springframework:spring-context`	Dependency injection
Guice	`com.google.inject:guice`	Lightweight DI
Dagger	`com.google.dagger:dagger`	Compile-time DI

Common Maven Commands

# Create project
mvn archetype:generate -DgroupId=com.example -DartifactId=myapp

# Clean build
mvn clean install

# Skip tests
mvn clean install -DskipTests

# Run specific test
mvn test -Dtest=MyTest

# Generate Javadoc
mvn javadoc:javadoc

# Create IDE project
mvn idea:idea  # For IntelliJ
mvn eclipse:eclipse  # For Eclipse

# Check for dependency updates
mvn versions:display-dependency-updates

# Show dependency tree
mvn dependency:tree

# Run Maven plugin
mvn org.codehaus.mojo:exec-maven-plugin:exec

Project Structure

myproject/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/
│   │   │       ├── Main.java
│   │   │       ├── controller/
│   │   │       ├── service/
│   │   │       ├── repository/
│   │   │       └── model/
│   │   └── resources/
│   │       ├── application.properties
│   │       └── logback.xml
│   └── test/
│       └── java/
│           └── com/example/
└── target/

Useful Plugins

Plugin	Purpose
maven-compiler-plugin	Compile Java code
maven-surefire-plugin	Run unit tests
maven-failsafe-plugin	Run integration tests
maven-assembly-plugin	Create executable JARs
maven-shade-plugin	Create fat JARs
jacoco-maven-plugin	Code coverage

Best Practices

Use dependency management for consistent versions
Keep dependencies up-to-date
Use proper logging instead of System.out
Write unit tests with JUnit 5
Use Spring Boot for web applications
Implement proper exception handling
Use final classes by default
Follow SOLID principles
Use immutable objects where possible
Avoid null pointers with Optional

Last updated: 2026-03-30