> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.

# जावा

> अपने जावा अनुप्रयोगों में डोडो भुगतान को एक मजबूत, प्रकार-सुरक्षित SDK के साथ एकीकृत करें

जावा SDK जावा में लिखे गए अनुप्रयोगों के लिए डोडो भुगतान REST API तक सुविधाजनक और एर्गोनोमिक पहुंच प्रदान करता है। यह आधुनिक जावा विकास के लिए Optional, Stream, और CompletableFuture जैसी जावा-विशिष्ट सुविधाओं का उपयोग करता है।

## स्थापना

### मावेन

अपने `pom.xml` में निर्भरता जोड़ें:

```xml pom.xml theme={null}
<dependency>
  <groupId>com.dodopayments.api</groupId>
  <artifactId>dodo-payments-java</artifactId>
  <version>1.97.1</version>
</dependency>
```

### ग्रेडल

अपने `build.gradle` में निर्भरता जोड़ें:

```kotlin build.gradle.kts theme={null}
implementation("com.dodopayments.api:dodo-payments-java:1.97.1")
```

<Tip>
  नवीनतम Dodo Payments सुविधाओं तक पहुँचने के लिए हमेशा नवीनतम SDK संस्करण का उपयोग करें। नवीनतम संस्करण के लिए [Maven Central](https://central.sonatype.com/artifact/com.dodopayments.api/dodo-payments-java) देखें।
</Tip>

<Info>
  SDK Java 8 और उसके बाद के सभी संस्करणों का समर्थन करता है, जिसमें Java 11, 17, और 21 शामिल हैं।
</Info>

## त्वरित प्रारंभ

क्लाइंट को प्रारंभ करें और एक चेकआउट सत्र बनाएं:

```java theme={null}
import com.dodopayments.api.client.DodoPaymentsClient;
import com.dodopayments.api.client.okhttp.DodoPaymentsOkHttpClient;
import com.dodopayments.api.models.checkoutsessions.CheckoutSessionCreateParams;
import com.dodopayments.api.models.checkoutsessions.CheckoutSessionRequest;
import com.dodopayments.api.models.checkoutsessions.ProductItemReq;

// Configure using environment variables (DODO_PAYMENTS_API_KEY, DODO_PAYMENTS_BASE_URL)
// Or system properties (dodopayments.apiKey, dodopayments.baseUrl)
DodoPaymentsClient client = DodoPaymentsOkHttpClient.fromEnv();

CheckoutSessionRequest params = CheckoutSessionRequest.builder()
    .addProductCart(ProductItemReq.builder()
        .productId("product_id")
        .quantity(1)
        .build())
    .build();
    
CheckoutSessionResponse checkoutSessionResponse = client.checkoutSessions().create(params);
System.out.println(checkoutSessionResponse.sessionId());
```

<Warning>
  हमेशा अपने API कुंजियों को पर्यावरण चर, सिस्टम गुण, या किसी सुरक्षित विन्यास प्रबंधन प्रणाली के माध्यम से सुरक्षित रूप से संग्रहित करें। उन्हें स्रोत कोड में कभी हार्डकोड न करें।
</Warning>

## मुख्य विशेषताएँ

<CardGroup cols={2}>
  <Card title="Type Safety" icon="shield-check">
    मजबूत-टाइप वाली API जो कम्पाइल-टाइम सुरक्षा प्रदान करती है
  </Card>

  <Card title="Thread-Safe" icon="bolt">
    मल्टी-थ्रेडेड एप्लिकेशन में समवर्ती उपयोग के लिए सुरक्षित
  </Card>

  <Card title="Builder Pattern" icon="layer-group">
    अनुरोधों को बनाने के लिए सहज रूप से समझ आने वाला बिल्डर पैटर्न
  </Card>

  <Card title="Async Support" icon="arrows-rotate">
    एसिंक्रोनस संचालन के लिए CompletableFuture समर्थन
  </Card>
</CardGroup>

## कॉन्फ़िगरेशन

### पर्यावरण चर

पर्यावरण चर या सिस्टम प्रॉपर्टीज का उपयोग करके कॉन्फ़िगर करें:

```bash .env theme={null}
DODO_PAYMENTS_API_KEY=your_api_key_here
DODO_PAYMENTS_BASE_URL=https://live.dodopayments.com
```

```java theme={null}
// Automatically reads from environment variables
DodoPaymentsClient client = DodoPaymentsOkHttpClient.fromEnv();
```

### मैनुअल कॉन्फ़िगरेशन

सभी विकल्पों के साथ मैन्युअल रूप से कॉन्फ़िगर करें:

```java theme={null}
import java.time.Duration;

DodoPaymentsClient client = DodoPaymentsOkHttpClient.builder()
    .bearerToken("your_api_key_here")
    .baseUrl("https://live.dodopayments.com")
    .maxRetries(4)
    .timeout(Duration.ofSeconds(30))
    .responseValidation(true)
    .build();
```

### परीक्षण मोड

परीक्षण/सैंडबॉक्स वातावरण के लिए कॉन्फ़िगर करें:

```java theme={null}
DodoPaymentsClient testClient = DodoPaymentsOkHttpClient.builder()
    .fromEnv()
    .testMode()
    .build();
```

## सामान्य संचालन

### चेकआउट सत्र बनाएं

एक चेकआउट सत्र उत्पन्न करें:

```java theme={null}
CheckoutSessionRequest params = CheckoutSessionRequest.builder()
    .addProductCart(ProductItemReq.builder()
        .productId("prod_123")
        .quantity(1)
        .build())
    .returnUrl("https://yourdomain.com/return")
    .build();

CheckoutSessionResponse session = client.checkoutSessions().create(params);
System.out.println("Checkout URL: " + session.checkoutUrl());
```

### ग्राहकों का प्रबंधन करें

ग्राहक जानकारी बनाएं और पुनः प्राप्त करें:

```java theme={null}
import com.dodopayments.api.models.customers.Customer;
import com.dodopayments.api.models.customers.CustomerCreateParams;

// Create a customer
CustomerCreateParams createParams = CustomerCreateParams.builder()
    .email("customer@example.com")
    .name("John Doe")
    .putMetadata("user_id", "12345")
    .build();

Customer customer = client.customers().create(createParams);

// Retrieve customer
Customer retrieved = client.customers().retrieve("cus_123");
System.out.println("Customer: " + retrieved.name() + " (" + retrieved.email() + ")");
```

### सदस्यताओं को संभालें

आवर्ती सदस्यताओं का निर्माण और प्रबंधन करें:

```java theme={null}
import com.dodopayments.api.models.payments.AttachExistingCustomer;
import com.dodopayments.api.models.payments.BillingAddress;
import com.dodopayments.api.models.payments.CountryCode;
import com.dodopayments.api.models.subscriptions.SubscriptionChargeParams;
import com.dodopayments.api.models.subscriptions.SubscriptionChargeResponse;
import com.dodopayments.api.models.subscriptions.SubscriptionCreateParams;
import com.dodopayments.api.models.subscriptions.SubscriptionCreateResponse;

// Create a subscription
SubscriptionCreateParams subscriptionParams = SubscriptionCreateParams.builder()
    .billing(BillingAddress.builder()
        .city("San Francisco")
        .country(CountryCode.US)
        .state("CA")
        .street("1 Market St")
        .zipcode("94105")
        .build())
    .customer(AttachExistingCustomer.builder()
        .customerId("cus_123")
        .build())
    .productId("pdt_456")
    .quantity(1)
    .paymentLink(true)
    .returnUrl("https://yourdomain.com/return")
    .build();

SubscriptionCreateResponse subscription = client.subscriptions().create(subscriptionParams);
System.out.println("Subscription ID: " + subscription.subscriptionId());

// Charge an on-demand subscription
// product_price is in the lowest currency denomination (e.g., 2500 = $25.00 USD)
SubscriptionChargeParams chargeParams = SubscriptionChargeParams.builder()
    .subscriptionId(subscription.subscriptionId())
    .productPrice(2500)
    .build();

SubscriptionChargeResponse chargeResponse = client.subscriptions().charge(chargeParams);
System.out.println("Payment ID: " + chargeResponse.paymentId());
```

<Info>
  `productPrice` को सबसे कम मुद्रा संप्रदाय में व्यक्त किया जाता है (जैसे, USD के लिए सेंट, INR के लिए पैसे)। \$25.00 चार्ज करने के लिए, पास करें `2500`।
</Info>

<Tip>
  `subscriptions().charge(...)` के माध्यम से चार्जिंग [ऑन-डिमांड सब्सक्रिप्शन्स](/developer-resources/ondemand-subscriptions) के लिए होती है। उत्पाद की मूल्य निर्धारण अनुसूची के आधार पर मानक निर्धारित सब्सक्रिप्शन स्वचालित रूप से बिल किए जाते हैं।
</Tip>

## उपयोग-आधारित बिलिंग

### मीटर कॉन्फ़िगर करें

उपयोग को ट्रैक करने के लिए मीटर बनाएं और प्रबंधित करें:

```java theme={null}
import com.dodopayments.api.models.meters.*;

// Create API calls meter
MeterCreateParams apiMeterParams = MeterCreateParams.builder()
    .name("API Requests")
    .eventName("api_request")
    .aggregation("count")
    .putMetadata("category", "api_usage")
    .build();

Meter apiMeter = client.meters().create(apiMeterParams);
System.out.println("Meter created: " + apiMeter.meterId());

// List all meters
client.meters().list()
    .autoPager()
    .forEach(m -> System.out.println("Meter: " + m.name() + " - " + m.aggregation()));
```

### उपयोग इवेंट प्राप्त करें

कस्टम इवेंट्स को ट्रैक करें:

```java theme={null}
import com.dodopayments.api.models.usageevents.*;
import java.time.OffsetDateTime;

// Ingest single event
UsageEventIngestParams singleEventParams = UsageEventIngestParams.builder()
    .addEvent(UsageEventIngestParams.Event.builder()
        .eventId("api_call_" + System.currentTimeMillis())
        .customerId("cus_abc123")
        .eventName("api_request")
        .timestamp(OffsetDateTime.now())
        .putMetadata("endpoint", "/api/v1/users")
        .putMetadata("method", "GET")
        .putMetadata("tokens_used", "150")
        .build())
    .build();

UsageEventIngestResponse response = client.usageEvents().ingest(singleEventParams);
System.out.println("Processed: " + response.ingestedCount());
```

### इवेंट्स बैच में इन्गेस्ट करें

कई इवेंट्स को प्रभावी ढंग से प्राप्त करें (प्रत्येक अनुरोध पर अधिकतम 1000):

```java theme={null}
UsageEventIngestParams.Builder batchBuilder = UsageEventIngestParams.builder();

for (int i = 0; i < 100; i++) {
    batchBuilder.addEvent(UsageEventIngestParams.Event.builder()
        .eventId("batch_event_" + i + "_" + System.currentTimeMillis())
        .customerId("cus_abc123")
        .eventName("video_transcode")
        .timestamp(OffsetDateTime.now().minusMinutes(i))
        .putMetadata("video_id", "video_" + i)
        .putMetadata("duration_seconds", String.valueOf(120 + i))
        .build());
}

UsageEventIngestResponse batchResponse = client.usageEvents().ingest(batchBuilder.build());
System.out.println("Batch processed: " + batchResponse.ingestedCount() + " events");
```

## त्रुटि प्रबंधन

विभिन्न स्थितियों के लिए व्यापक त्रुटि प्रबंधन:

```java theme={null}
import com.dodopayments.api.errors.*;

try {
    Payment payment = client.payments().retrieve("pay_invalid");
} catch (NotFoundException e) {
    System.err.println("Payment not found: " + e.getMessage());
} catch (UnauthorizedException e) {
    System.err.println("Authentication failed: " + e.getMessage());
} catch (PermissionDeniedException e) {
    System.err.println("Permission denied: " + e.getMessage());
} catch (BadRequestException e) {
    System.err.println("Invalid request: " + e.getMessage());
} catch (UnprocessableEntityException e) {
    System.err.println("Validation error: " + e.getMessage());
} catch (RateLimitException e) {
    System.err.println("Rate limit exceeded: " + e.getMessage());
    // SDK automatically retries with backoff
} catch (InternalServerException e) {
    System.err.println("Server error: " + e.getMessage());
} catch (DodoPaymentsServiceException e) {
    System.err.println("API error: " + e.statusCode() + " - " + e.getMessage());
}
```

<Tip>
  SDK स्वत: कनेक्शन त्रुटियों, 408, 409, 429, और 5xx त्रुटियों पर अनुरोधों को पुनः प्रयास करता है।
</Tip>

## एसिंक्रोनस ऑपरेशन्स

एसिंक्रोनस ऑपरेशन्स के लिए CompletableFuture का उपयोग करें:

```java theme={null}
import java.util.concurrent.CompletableFuture;

CompletableFuture<CheckoutSessionResponse> future = client.async()
    .checkoutSessions()
    .create(params);

// Handle response asynchronously
future.thenAccept(response -> {
    System.out.println("Session created: " + response.sessionId());
}).exceptionally(ex -> {
    System.err.println("Error: " + ex.getMessage());
    return null;
});
```

## स्प्रिंग बूट इंटीग्रेशन

### कॉन्फ़िगरेशन क्लास

```java theme={null}
import com.dodopayments.api.client.DodoPaymentsClient;
import com.dodopayments.api.client.okhttp.DodoPaymentsOkHttpClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DodoPaymentsConfig {
    
    @Value("${dodo.api.key}")
    private String apiKey;
    
    @Value("${dodo.environment:test}")
    private String environment;
    
    @Bean
    public DodoPaymentsClient dodoPayments() {
        return DodoPaymentsOkHttpClient.builder()
            .bearerToken(apiKey)
            .baseUrl(environment.equals("live") 
                ? "https://live.dodopayments.com" 
                : "https://test.dodopayments.com")
            .build();
    }
}
```

### सर्विस लेयर

```java theme={null}
import com.dodopayments.api.client.DodoPaymentsClient;
import com.dodopayments.api.models.checkoutsessions.*;
import org.springframework.stereotype.Service;

@Service
public class PaymentService {
    
    private final DodoPaymentsClient client;
    
    public PaymentService(DodoPaymentsClient client) {
        this.client = client;
    }
    
    public CheckoutSessionResponse createCheckout(List<ProductItemReq> items) {
        CheckoutSessionRequest params = CheckoutSessionRequest.builder()
            .productCart(items)
            .returnUrl("https://yourdomain.com/return")
            .build();
            
        return client.checkoutSessions().create(params);
    }
}
```

## संसाधन

<CardGroup cols={2}>
  <Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/dodopayments-java">
    स्रोत कोड देखें और योगदान करें
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    पूरा API दस्तावेज देखें
  </Card>

  <Card title="Discord Community" icon="discord" href="https://discord.gg/bYqAp4ayYh">
    सहायता प्राप्त करें और डेवलपर्स से जुड़ें
  </Card>

  <Card title="Report Issues" icon="bug" href="https://github.com/dodopayments/dodopayments-java/issues">
    त्रुटियों की रिपोर्ट करें या फीचर्स का अनुरोध करें
  </Card>
</CardGroup>

## समर्थन

जावा SDK के साथ सहायता चाहिए?

* **Discord**: वास्तविक समय समर्थन के लिए हमारे [समुदाय सर्वर](https://discord.gg/bYqAp4ayYh) में शामिल हों
* **Email**: हमें [support@dodopayments.com](mailto:support@dodopayments.com) पर संपर्क करें
* **GitHub**: [रिपोज़िटरी](https://github.com/dodopayments/dodopayments-java) पर एक समस्या खोलें

## योगदान

हम योगदान का स्वागत करते हैं! शुरू करने के लिए [योगदान दिशानिर्देश](https://github.com/dodopayments/dodopayments-java/blob/main/CONTRIBUTING.md) देखें।