Guava is Google's production-grade core Java library, consumed as a dependency by thousands of projects. It provides high-performance collection types (immutable collections, multimaps, multisets, bimaps, tables), concurrency utilities (ListenableFuture, Futures, RateLimiter, Monitor, Service), a graph model and traversal APIs, caching, hashing, I/O, math, primitives, and string utilities. There are no application entry points, web endpoints, or CLI tools; the repository's "entry points" are the public APIs under com.google.common.*. Architecturally it is a multi-module Maven project with separate JRE and Android flavors, plus GWT/J2CL emulation sources and a dedicated test-support module, guava-testlib. The codebase demonstrates exceptionally high craftsmanship: lock-free concurrency, carefully memory-tuned immutable data structures, custom heap algorithms, and a generic collection-contract testing framework. It is actively maintained with regular releases, GitHub Actions CI, and security scorecard automation. The dual JRE/Android source trees and cross-platform emulation layers require deliberate synchronization, but this complexity is managed rigorously rather than showing signs of abandonment. No data-research or pipeline elements exist; this is a pure library/application dependency, not a data project.
This is the central governance and documentation repository for the Jackson project, the premier Java JSON processing library. It does not contain the core library source code (which lives in separate repos like `jackson-core`, `jackson-databind`, and `jackson-annotations`). Instead, it serves as the project's hub, containing all essential governance documents (CLAs, contributing guidelines, security policy, versioning strategy), a comprehensive API reference manual (`MANUAL.md`), and an exceptionally detailed migration guide from Jackson 2.x to 3.x. The repository is a masterclass in open-source project management and technical documentation, providing a clear, well-structured, and authoritative source of truth for the entire Jackson ecosystem. Its primary value lies not in executable code, but in the high-quality, reusable patterns it establishes for project governance, release engineering, and technical communication.
RxJava 4 is a reactive programming library for the JVM, implementing the Reactive Streams specification via `java.util.concurrent.Flow` (Publisher/Subscriber). It provides six core reactive types: `Flowable` (backpressured), `Observable` (unbounded), `Single` (single value), `Maybe` (optional value), `Completable` (completion signal), and the new `Streamable` (pull-based streaming with `CompletionStage`). The library offers a comprehensive set of operators (map, filter, flatMap, concat, merge, window, buffer, etc.) for composing asynchronous data flows, along with schedulers for threading control (`Schedulers.computation()`, `Schedulers.io()`, `Schedulers.virtual()` for virtual threads). It includes advanced features like operator fusion (`QueueFuseable`), backpressure strategies, and configurable operator parameters via immutable records. The architecture is modular: each operator is a final class extending the base reactive type with an inner observer/subscriber class managing state. External dependencies are minimal (only JDK standard library), and the library is designed for embedding in applications, frameworks, and Android. Key entry points are the static factory methods on `Flowable`, `Observable`, `Single`, `Maybe`, `Completable`, and `Streamable`. Data flows are constructed by chaining operators that transform and combine reactive streams, with lifecycle managed through `Disposable` and `Subscription` contracts.
JsonUnit is a Java/Kotlin library for comparing JSON documents in unit tests, providing a rich set of assertion APIs across Hamcrest, AssertJ, Spring MVC/WebTestClient/RestTestClient, and Kotest. The core engine offers flexible comparison options (tolerance, ignoring values/paths, placeholder macros, custom matchers, unordered array matching) and supports multiple JSON parsers (Jackson 2/3, Gson, Moshi, Johnzon, org.json) via a plugin architecture. The library is designed for test scope and integrates deeply with popular testing frameworks, enabling precise JSON diffing and validation in complex CI/CD pipelines. The codebase is well-structured with clear separation of core comparison logic, adapter layers for each JSON library, and dedicated integration modules. It demonstrates strong engineering practices: immutable configuration, SPI-based extensibility, and comprehensive test suites covering various JSON libraries and edge cases. While the library is mature and actively maintained, its extensive integration surface (six JSON libraries, four assertion frameworks) introduces coupling risks and requires ongoing compatibility management.
Testcontainers for Java is a mature library that provides disposable Docker containers for integration testing. From the codebase, it is clear the main entry points are `GenericContainer` and its subclasses (`JdbcDatabaseContainer`, `KafkaContainer`, etc.), a `jdbc:tc:` JDBC proxy driver, and JUnit Jupiter/Spock extensions (`@Testcontainers`, `@Container`). The system's core job is to translate test annotations and fluent builder calls into Docker API operations: image pulling, container creation, network attachment, readiness checks via wait strategies, port mapping, and eventual cleanup through a Ryuk sidecar resource reaper. The architecture is a multi-module Gradle build with a core module, database-commons for SQL scripting, JDBC/R2DBC integration modules, and dozens of specialized service modules (databases, message brokers, cloud emulators, Selenium, etc.). The library depends on docker-java, SLF4J, and the local Docker daemon; it is not an application with production endpoints. There is no data/research component — all SQL scripts and data files are test fixtures. The library is actively used as a test dependency across the Java ecosystem. Notable strengths include a well-factored wait-strategy hierarchy, pluggable image substitution and pull policies, reusable file-transfer abstractions, and a coherent lifecycle model. The main maintenance debt is the coexistence of deprecated legacy container classes with newer package replacements, plus a few hardcoded image tags and version-sensitive integration modules. Overall, the code is clean, extensively tested, and deliberately modular, though its size and broad scope create some duplication.
Micrometer is a Java library that provides a unified facade for application metrics, enabling instrumentation of code with counters, timers, gauges, and distribution summaries, and publishing them to various monitoring backends (Prometheus, Datadog, OTLP, Graphite, InfluxDB, etc.). It is not an application itself but a library designed to be embedded in Java applications. The architecture is modular: the core module defines the metrics API and abstractions (MeterRegistry, Meter, Counter, Timer, Gauge, DistributionSummary), while separate implementation modules provide backend-specific registries with their own naming conventions and transport protocols. Additionally, the observation module offers a higher-level API for tracing and context propagation, bridging metrics with observability. Key entry points include the MeterRegistry (for creating and managing meters) and the ObservationRegistry (for observation lifecycle). Data flows involve application code recording measurements via meters, which are aggregated in-memory and periodically pushed to configured backends via HTTP, UDP, or other protocols. The library also includes extensive instrumentation binders for popular frameworks (Jetty, OkHttp, gRPC, Kafka, JVM internals, etc.) that automatically collect metrics from those systems. External dependencies vary by implementation module but include HTTP clients (OkHttp, HttpURLConnection), monitoring system SDKs (AWS SDK for CloudWatch, Google Cloud for Stackdriver), and protocol libraries (OTel protobuf, StatsD). The core module has minimal dependencies, relying only on Java standard library and optional logging frameworks (SLF4J, Log4j, Logback).
JDA is a mature Java library for building Discord bots. It implements both the Discord REST API and the real-time WebSocket gateway, exposing them through a clean event-driven API. Developers configure a JDA instance via JDABuilder or DefaultShardManagerBuilder, register typed event listeners, and make HTTP calls through fluent RestAction objects. Internally, gateway dispatch handlers parse JSON or ETF payloads, maintain threaded cache views of Discord entities, and translate them into public events, while REST actions are executed through an OkHttp-backed requester with rate-limit handling and retry logic. The library is strictly split into a public API package (net.dv8tion.jda.api) and an internal implementation package (net.dv8tion.jda.internal), so most users depend only on the stable API surface.
The Google Auth Library for Java provides authentication mechanisms for Google Cloud services. It supports multiple credential types including service account, user credentials, external account credentials (AWS, identity pools), API keys, and workload identity federation. The library implements Application Default Credentials (ADC) for automatic credential discovery, handles token acquisition/refresh/verification, and includes specialized credentials for Compute Engine, App Engine, and impersonation scenarios. It also supports mTLS authentication and client-side Credential Access Boundary (CAB) for least-privilege access. Structured as a multi-module Maven project, it is designed to be used by applications requiring Google Cloud authentication.
Gson is a Java library for converting Java objects to JSON and back, widely used in the Java ecosystem. The core architecture centers on the `Gson` facade class, which orchestrates serialization/deserialization via a chain of `TypeAdapter` instances. `TypeAdapter` is an abstract class that defines the contract for reading/writing a specific type; concrete implementations are provided for primitives, collections, maps, dates, enums, and arbitrary objects via reflection. The library offers two complementary APIs: a streaming API (`JsonReader`/`JsonWriter`) for low-level token-by-token processing, and a tree model (`JsonElement` hierarchy) for in-memory manipulation. Customization is achieved through `TypeAdapterFactory` registration, annotations (`@JsonAdapter`, `@SerializedName`, `@Expose`, `@Since`/`@Until`), and configuration via `GsonBuilder` (e.g., strictness, formatting, naming policies, exclusion strategies). The primary data flow for serialization is: Java object → `TypeAdapter.write()` → `JsonWriter` → JSON string. For deserialization: JSON string → `JsonReader` → `TypeAdapter.read()` → Java object. The library handles complex scenarios including generics, inheritance, circular references, Java records, and `java.time` types. It supports optional modules for Protocol Buffers (`proto/`), runtime type adapters (`extras/`), and benchmarks (`metrics/`). Gson is in maintenance mode, meaning new features are unlikely but bug fixes and compatibility updates continue. It has no runtime dependencies beyond the Java standard library, with optional support for `java.sql` and `java.time`. Key entry points are `Gson` and `GsonBuilder` in the `com.google.gson` package. The streaming parser (`JsonReader`) is a standout component: it implements RFC 8259 with configurable strictness, path tracking, and nesting limits, and is designed for both performance and correctness. The `TypeAdapter`/`TypeAdapterFactory` pattern provides a clean, extensible abstraction that has been reused in other projects. The codebase is well-tested with hundreds of unit and integration tests, including concurrency, security, and environment-specific tests (JPMS, GraalVM native image, code shrinkers).
This is the official Stripe Java SDK, a comprehensive client library for the Stripe REST API. It provides typed Java bindings for all Stripe resources (charges, customers, payment intents, invoices, subscriptions, etc.), with a consistent service-based architecture. The library is heavily auto-generated from Stripe's OpenAPI specification, ensuring broad API coverage. Key features include a builder pattern for request parameters, automatic pagination, webhook signature verification and typed event notifications, expandable fields for lazy-loaded nested resources, and configurable retry/timeout logic. The codebase demonstrates strong engineering practices: clean separation of concerns (model, service, param, net layers), extensive use of Lombok for boilerplate reduction, Gson for JSON serialization with custom type adapters, and a comprehensive test suite. While the generated nature leads to some duplication, the core abstractions (StripeResponseGetter, ApiService, ApiRequestParams) are well-designed and reusable.
Sudachi is a professional-grade Japanese morphological analyzer implemented as a Java library and CLI tool. It performs tokenization, part-of-speech tagging, and text normalization using a plugin-based architecture with configurable input rewriting, out-of-vocabulary (OOV) handling, and lattice path rewriting. The system relies on precompiled binary dictionaries (system and user) built from CSV lexicons, and supports three segmentation modes (A, B, C) to balance between shortest and longest tokenization for different use cases. Internally, Sudachi uses a double-array trie for fast common-prefix search, memory-mapped file I/O for efficient dictionary loading, and a Viterbi-style lattice search for optimal path selection. The project includes a command-line interface, a comprehensive test suite, JMH benchmarks, and CI/CD pipelines. It is designed for embedding in larger applications (e.g., Elasticsearch via a separate plugin) and has been used in production at Works Applications.
Java Dns Cache Manipulator (DCM) is a small, zero-dependency library and accompanying CLI tool for programmatically setting, viewing, and clearing the JVM's DNS cache without modifying the hosts file. It works by using reflection to access private fields of `java.net.InetAddress` and `sun.net.InetAddressCachePolicy`. The library handles both pre-JDK 9 (old `InetAddress.CacheEntry` model) and JDK 9+ (new `CachedAddresses`/`CachedLookup` model), making it compatible with JDK 8 through 26. The tool module uses the Java Attach API to inject a Java agent into a running JVM process to execute commands like get, set, remove, list, or clear DNS cache entries. The code is well-structured with clear separation between API, internal implementation, agent, and tool modules. It is thread-safe, immutable value objects (DnsCacheEntry, DnsCache) are used, and extensive Kotlin-based tests ensure correctness across multiple JDK versions.
This repository is a Java/Kotlin client library for the Telegram Bot API, providing type-safe wrappers for all bot API methods and models. The architecture is a classic library with a fluent builder pattern: users create request objects (e.g., `SendMessage`, `GetUpdates`), execute them via the `TelegramBot` class, and receive typed responses. The library handles both synchronous and asynchronous execution, supports long-polling and webhook modes, and includes Telegram Passport encryption/decryption utilities. The codebase is well-structured, with clear separation into model, request, response, and utility packages. It features custom Gson adapters for polymorphic API types (e.g., reaction types, chat boost sources) that demonstrate a clean discriminated union deserialization pattern. The library is actively maintained, tracking Telegram Bot API updates closely, and includes Kotlin extension functions for idiomatic usage. It is not a data research project; it is purely an integration library.
Discord4J is a mature multi-module Java/Kotlin reactive client library for the Discord API, designed for building Discord bots rather than running as a standalone service. The codebase is organized into `common`, `rest`, `gateway`, `core`, `voice`, and `oauth2` modules. `rest` implements a bucket-aware HTTP client with retries, rate limiting, and response transformations; `gateway` handles the WebSocket lifecycle with sharding, resumption, intents, and event dispatch; `core` layers a typed entity/event model and fluent request specs on top; `voice` provides audio connections with encryption and DAVE protocol support; `oauth2` adds Discord login flows. Everything is built on Project Reactor and Reactor Netty, returning `Mono`/`Flux` throughout, giving the library a consistent non-blocking and composable architecture.
This repository is a Java library, published as net.bramp.ffmpeg:ffmpeg, that programmatically drives the FFmpeg and FFprobe command-line binaries. It does not perform media processing itself; it constructs exact argument lists through a fluent builder hierarchy (FFmpegBuilder, FFmpegOutputBuilder, FFmpegHlsOutputBuilder) and executes them as subprocesses via FFmpegExecutor, with ProgressListener hooks for live encoding status. FFprobe invocation is wrapped by FFprobe, which deserializes JSON into typed probe models (FFmpegProbeResult, FFmpegStream, FFmpegChapter, FFmpegPacket, and others). Architecture is a layered library: builder and option packages model CLI syntax; job classes manage one- and two-pass encoding; progress parsers support line- and socket-based progress; probe models and Gson adapters handle JSON parsing; and a ProcessFunction abstraction decouples process execution from callers. Entry points are the FFmpeg/FFprobe constructors, builder.build() returning List<String>, and FFmpegExecutor.createJob()/createTwoPassJob(). Primary data flows move from Java objects to command-line arguments, then to external binary stdout/stderr, and finally to parsed progress events or typed probe results. Engineering quality is strong: tests assert exact command argument lists and parse fixture outputs, CI runs on JDK 11/17/21, examples are generated from test code and verified, and release automation publishes to Maven Central. Some drift exists: AudioCodec/VideoCodec are static snapshots of FFmpeg codec names, several builder methods are deprecated, the NUT demuxer is marked incomplete/experimental, and some fixture files date back to older FFmpeg/Libav versions. Overall this is an active, well-crafted library rather than a standalone application or data project.
pg-index-health is an embeddable Java library and schema linter for PostgreSQL that detects common database anti-patterns and promotes best practices. It provides over 40 diagnostic checks covering duplicated/intersected indexes, bloat, missing indexes, inappropriate column types, naming violations, unlogged tables, sequence overflow, and many more. The library is designed for integration into applications (via Spring Boot starter) or use in CI pipelines to enforce schema quality. It supports both single-host and high-availability PostgreSQL clusters, with checks that can run statically (against schema only) or require accumulated statistics. The architecture is a multi-module Gradle project: `pg-index-health-model` defines immutable domain objects (Table, Index, Column, ForeignKey, etc.) with validation and composable predicates; `pg-index-health-core` implements host-level checks using a template pattern (`AbstractCheckOnHost`) with SQL queries loaded from a separate submodule; `pg-index-health` wraps these into cluster-level checks (`AbstractCheckOnCluster`) that aggregate results across primary and standby nodes; `pg-index-health-jdbc-connection` provides connection factories with primary host detection and multi-host URL parsing; `pg-index-health-generator` produces corrective SQL migrations; `pg-index-health-logger` formats results; and `pg-index-health-testing` offers Testcontainers-based test fixtures. Optional Jackson 2/3 modules enable JSON serialization of results. Key entry points include `StandardChecksOnHost` and `StandardChecksOnCluster` which enumerate all available checks, and the Spring Boot auto-configuration (`DatabaseStructureHealthAutoConfiguration`) that registers check beans. Data flows involve querying PostgreSQL system catalogs (`pg_catalog`, `pg_stat_*`), mapping result sets to domain objects via `ResultSetExtractor` implementations, applying exclusion predicates (e.g., skip Flyway/Liquibase tables, small tables, named objects), and returning lists of deviations. External dependencies are minimal: PostgreSQL JDBC driver, Apache DBCP2 connection pool, and Testcontainers for testing. The library is published to Maven Central and includes a BOM for dependency management.
Alibaba Druid is a production-grade Java library providing a high-performance JDBC connection pool, a multi-dialect SQL parser, an SQL injection firewall, and built-in monitoring/statistics. In production, it replaces or augments standard connection pools (HikariCP, DBCP) with advanced features like connection leak detection, PSCache, and web console monitoring. The SQL parser supports 30+ dialects (MySQL, PostgreSQL, Oracle, Hive, ClickHouse, etc.) and is used for SQL formatting, parameterization, and analysis. The WallFilter provides configurable security rules to block SQL injection and dangerous operations. The library integrates deeply with Spring Boot via dedicated starters for Boot 2/3/4, and exposes metrics through JMX. Architecture is organized around a filter chain pattern for intercepting JDBC calls, a visitor pattern for AST manipulation, and an SPI-based provider system for firewall rules.
redis-replicator is a Java library for Redis replication and data parsing. It provides event-driven APIs to consume Redis RDB snapshots, AOF logs, and live replication streams (PSYNC/SCAN). The architecture is based on a `Replicator` interface with multiple implementations (`RedisRdbReplicator`, `RedisAofReplicator`, `RedisSocketReplicator`, `RedisMixReplicator`, `RedisScanReplicator`). Key entry points are `RedisReplicator` (facade) and `Configuration` (URI-based settings). Data flows: raw bytes from Redis or files are parsed by `RdbParser` or `CommandParser` into typed `Event` objects (e.g., `KeyValuePair`, `Command`), which are dispatched to registered `EventListener` instances. The library supports all major Redis data types, commands, and versions 2.6–8.4.x, with extensions for Valkey and custom modules. External dependencies include SLF4J for logging and Jedis for online tests. It is used for data migration, backup, real-time synchronization, and building custom Redis-compatible tools.
bson4jackson is a Java library that adds BSON support to Jackson 3.x. It provides a BsonFactory (a JsonFactory subclass) that creates BsonGenerator and BsonParser instances, plus a BsonModule that registers serializers and deserializers for BSON-specific types such as ObjectId, JavaScript, Symbol, Timestamp, Decimal128, regex, UUID, Date, and Calendar. The library is used by constructing a Jackson ObjectMapper with a BsonFactory and optionally registering BsonModule, allowing Java objects to be written to and read from the binary BSON format commonly used by MongoDB. Architecturally, this is a library rather than a service or CLI. The main entry points are BsonFactory, BsonModule, BsonGenerator, and BsonParser. Serialization flows from Java objects through Jackson's ObjectMapper into BsonGenerator, which buffers output in a custom little-endian DynamicOutputBuffer and optionally streams completed chunks to an OutputStream. Deserialization flows from an InputStream through LittleEndianInputStream into BsonParser, which translates BSON type markers into Jackson tokens and embedded objects. The parser supports embedded documents, arrays, binary subtypes, regexes, JavaScript with scope, DBPointer, MinKey/MaxKey, and Decimal128. The generator supports a non-spec-compliant streaming mode, BigDecimal-as-string or Decimal128 modes, and custom character escapes. The codebase is well-structured and performance-conscious: it avoids synchronized IO classes, reuses thread-local buffers via StaticBuffers, and includes hand-written UTF-8 encoding/decoding paths. Unit tests are comprehensive and include integration tests against Jackson 3.0, 3.1, and 3.2, plus the MongoDB Java driver. CI runs on Java 17, 21, and 25, and the project has active dependabot and stale-issue automation. The only runtime dependency is Jackson core/databind; the MongoDB driver is test-only. Overall, this is a mature, well-maintained library with low technical drift.
Jayway JsonPath is a mature Java library that implements Stefan Goessner's JSONPath specification, providing an XPath-like query language for JSON documents. It enables reading, filtering, writing, and transforming JSON data through a fluent API. The core entry point is the `JsonPath` class, which offers static methods like `read()` and `parse()`, returning `DocumentContext` for chained operations such as `set()`, `delete()`, `add()`, `put()`, `renameKey()`, and `map()`. The library supports a rich filter system via `Filter`, `Criteria`, and `Predicate` interfaces, allowing both inline path filters (e.g., `[?(@.price < 10)]`) and programmatic construction. It also includes a function system for aggregation (`min`, `max`, `avg`, `sum`, `stddev`) and text operations (`length`, `concat`). Architecturally, the library follows a Service Provider Interface (SPI) pattern with `JsonProvider` and `MappingProvider` abstractions, enabling pluggable JSON backends. It ships with providers for Jackson 2, Jackson 3, Gson, Json-smart, JsonOrg, Jakarta JSON-P, Jettison, and Tapestry. The `Configuration` class is immutable and built via a builder, centralizing options like `REQUIRE_PROPERTIES` and `DEFAULT_PATH_LEAF_TO_NULL`. Path compilation is cached via a configurable `CacheProvider` (default LRU). The separate `json-path-assert` module provides Hamcrest matchers (`hasJsonPath`, `withJsonPath`, `isJson`) for testing. External dependencies are minimal for the core module (only `net.minidev:json-smart` for the default provider), with optional dependencies for other providers. The library is built with Gradle, targets Java 17, and has extensive JUnit 5 test coverage including regression tests for hundreds of reported issues. It is designed for integration into any Java application that needs to query or manipulate JSON data programmatically.