1. Project Overview

Dante OSS

Rich · Comprehensive | Simple · Convenient

Making Object Storage Integration and Usage Simpler

Dante OSS is an open-source framework designed to simplify Object Storage Service (OSS) operations. Inspired by the standardized design principles of JPA, it gradually extracts and abstracts standardized OSS operations from different providers to build a unified Java OSS API specification. It establishes an object storage usage model similar to the JPA specification, centered around the Java OSS API and implemented through different OSS provider SDKs. This allows users to switch between different OSS providers without modifying their code.

2. Open Source License

Licensed under Apache-2.0

3. Screenshots

Currently, Minio is used as the default implementation of the Java OSS API specification. At present, only REST API implementations for Minio-specific operations are provided.

4. Feature Overview

Goals | Goal

• Build a Java OSS API specification similar to JPA, allowing users to switch object storage providers simply by changing the underlying OSS SDK implementation without modifying the API.
• Go beyond common upload and download operations to cover all common operations across OSS SDKs. Not only does it simplify uploading and downloading, but it also enables developers to quickly build their own OSS management applications.
• Provide unified Java APIs and REST APIs for common operations, while offering separate REST API implementations for provider-specific operations when appropriate.

Design | Design Thinking

Dante OSS was initially designed to deeply encapsulate the Minio Java SDK, making complex Minio management operations easier to implement while improving the convenience of custom development with Minio. As versions have evolved and feedback from more users has been collected, the design philosophy of Dante OSS has continued to evolve.

As SDKs from different OSS providers, such as Amazon S3 and Alibaba Cloud, were gradually integrated, we discovered that although most OSS products are compatible with the S3 standard and the Amazon S3 SDK can perform operations on other providers' OSS services, this is limited to conventional, basic OSS operations and cannot fully leverage provider-specific features. Furthermore, due to implementation differences, even identical OSS operations may require different parameters and return different values. As a result, code implementing the same business logic with Provider A's SDK cannot be used with Provider B's SDK. It must be reimplemented before it can work, significantly increasing the cost of migrating between OSS providers.

Although many excellent object storage frameworks are available and support a wide range of OSS providers, the range of supported operations is often limited. In addition to supporting conventional OSS operations, Dante OSS aims to provide richer and more standardized OSS management capabilities, allowing users to integrate and develop more comprehensive and detailed OSS management features in their own applications with greater ease.

Therefore, while maintaining its original goal of simplifying Minio management operations, Dante OSS adopts the standardized design principles of JPA to extract and abstract standardized OSS operations, establishing a unified Java OSS API specification. It also encapsulates unified REST APIs capable of operating with different OSS providers, creating an application model with a consistent definition and dynamic implementation (similar to how Hibernate implements JPA and supports different databases through Dialect). This makes switching and migrating between different OSS providers easier.

Advantages

• Zero Additional Learning Costs
  Developers only need basic knowledge of Spring and REST development to seamlessly integrate and use Dante OSS.
• Lower Development Barriers
  Hides the complexity of using Java OSS SDKs such as Minio and simplifies the original APIs through standard encapsulation in the Spring environment. Service APIs and REST APIs are ready to use out of the box.
• Unified Development Interfaces
  Establishes a unified Java OSS API specification with consistent Service API and REST API interfaces, allowing users to switch between different OSS providers without modifying code.
• Rich Feature Set
  Almost all features of the Minio Java SDK have been enhanced. Features such as large-file multipart uploads, instant uploads, direct uploads, and resumable uploads are implemented and integrated using industry-leading solutions.
• Clean and Well-Structured Code
  Function parameters preserve the original OSS SDK builder structure rather than breaking it. Instead, the existing approach is abstracted and simplified, significantly improving the programming experience and code readability.
• Comprehensive Documentation and Comments
  Provides detailed comments, explanations, and OpenAPI annotations for request parameters, methods, REST APIs, and Validation. Their purpose and usage are clear at a glance, eliminating the need to repeatedly consult Minio documentation and source code, helping you save more time.
• Comprehensive Stability and Reliability
  A unified, user-friendly error handling system, built-in REST API anti-abuse protection, idempotency protection, and detailed, accurate Spring Validation checks.
• Complete Frontend Examples
  The frontend is provided as a complete project rather than a simple demo, comprehensively demonstrating all aspects of frontend-backend interaction, API calls, parameter usage, TypeScript type definitions, and more. It can be used directly in real-world projects or easily customized to build your own products.

5. Tech Stack

Usage | How to Use

5.1. Basic Usage

<dependency>
    <groupId>cn.herodotus.oss</groupId>
    <artifactId>oss-spring-boot-starter</artifactId>
    <version>Latest Version</version>
</dependency>

herodotus:
  oss:
    dialect: minio
    minio:
      endpoint: http://127.0.0.1:9000
      access-key: XXXXXXXXX
      secret-key: XXXXXXXXX
      use-proxy: true
      proxy-source-endpoint: http://localhost:3000/api

// Reference Code
public static Result<String> resolveException(Exception ex， String path) {
    return GlobalExceptionHandler.resolveException(ex， path);
}
// Alternatively
@ExceptionHandler({HerodotusException.class， PlatformException.class})
public static Result<String> exception(Exception ex， HttpServletRequest request， HttpServletResponse response) {
    ······
}

// In the system-wide error handler, simply call the following code to return more interactive error messages containing custom error codes.
if (ex instanceof HerodotusException exception) {
    Result<String> result = exception.getResult();
    result.path(path);
    log.error("[Herodotus] |- Global Exception Handler, Error is : {}", result);
    return result;
}

5.2. Optional Configuration

See the README.md documentation for details