EmailVerify LogoEmailVerify
SDK

Java

Java email checker SDK. Maven/Gradle setup, verify emails with Java. Code examples included.

EmailVerify 公式 Java SDK は、Spring Boot 統合サポートを備えたメール検証のための堅牢なインターフェースを提供します。

インストール

Maven

<dependency>
    <groupId>com.emailverify</groupId>
    <artifactId>emailverify-java</artifactId>
    <version>1.0.0</version>
</dependency>

Gradle

implementation 'com.emailverify:emailverify-java:1.0.0'

要件

  • Java 11 以上
  • Maven または Gradle

クイックスタート

import com.emailverify.Client;
import com.emailverify.model.VerificationResult;

public class Main {
    public static void main(String[] args) {
        Client client = new Client(System.getenv("EMAILVERIFY_API_KEY"));

        VerificationResult result = client.verify("user@example.com");
        System.out.println("Status: " + result.getStatus());
        System.out.println("Score: " + result.getScore());
    }
}

設定

クライアントビルダー

import com.emailverify.Client;
import java.time.Duration;

Client client = Client.builder()
    .apiKey(System.getenv("EMAILVERIFY_API_KEY"))
    .timeout(Duration.ofSeconds(30))
    .retries(3)
    .baseUrl("https://api.emailverify.ai")
    .build();

設定プロパティ

プロパティ型デフォルト説明
apiKeyString必須API キー
timeoutDuration30sリクエストタイムアウト
retriesint3リトライ回数
baseUrlStringAPI URLカスタム API エンドポイント

型

VerificationResult

public class VerificationResult {
    private String email;
    private String status;        // "valid", "invalid", "unknown", "accept_all"
    private ResultDetails result;
    private double score;
    private String reason;

    // ゲッター...
}

public class ResultDetails {
    private Boolean deliverable;
    private boolean validFormat;
    private boolean validDomain;
    private boolean validMx;
    private boolean disposable;
    private boolean role;
    private boolean catchall;
    private boolean free;
    private Boolean smtpValid;

    // ゲッター...
}

BulkJob

public class BulkJob {
    private String id;
    private String status;        // "pending", "processing", "completed", "failed"
    private int total;
    private int processed;
    private int valid;
    private int invalid;
    private int unknown;
    private Instant createdAt;
    private Instant completedAt;

    // ゲッター...
}

単一検証

基本的な検証

VerificationResult result = client.verify("user@example.com");

System.out.println("Email: " + result.getEmail());
System.out.println("Status: " + result.getStatus());
System.out.println("Score: " + result.getScore());
System.out.println("Deliverable: " + result.getResult().getDeliverable());
System.out.println("Disposable: " + result.getResult().isDisposable());

オプション付き検証

import com.emailverify.model.VerifyOptions;

VerifyOptions options = VerifyOptions.builder()
    .smtpCheck(true)
    .timeout(Duration.ofSeconds(5))
    .build();

VerificationResult result = client.verify("user@example.com", options);

非同期検証

import java.util.concurrent.CompletableFuture;

CompletableFuture<VerificationResult> future = client.verifyAsync("user@example.com");

future.thenAccept(result -> {
    System.out.println("Status: " + result.getStatus());
}).exceptionally(ex -> {
    System.err.println("Error: " + ex.getMessage());
    return null;
});

一括検証

ジョブの送信

import java.util.Arrays;
import java.util.List;

List<String> emails = Arrays.asList(
    "user1@example.com",
    "user2@example.com",
    "user3@example.com"
);

BulkJob job = client.verifyBulk(emails);
System.out.println("Job ID: " + job.getId());

ステータスの確認

BulkJob status = client.getBulkJobStatus(job.getId());

System.out.println("Status: " + status.getStatus());
System.out.println("Progress: " + status.getProcessed() + "/" + status.getTotal());
System.out.println("Valid: " + status.getValid());
System.out.println("Invalid: " + status.getInvalid());

結果の取得

List<VerificationResult> results = client.getBulkJobResults(job.getId());

for (VerificationResult result : results) {
    System.out.println(result.getEmail() + ": " + result.getStatus());
}

Webhook 付き

import com.emailverify.model.BulkOptions;

BulkOptions options = BulkOptions.builder()
    .webhookUrl("https://your-domain.com/webhooks/emailverify")
    .build();

BulkJob job = client.verifyBulk(emails, options);

クレジット管理

import com.emailverify.model.Credits;

Credits credits = client.getCredits();

System.out.println("Available: " + credits.getAvailable());
System.out.println("Used: " + credits.getUsed());
System.out.println("Total: " + credits.getTotal());

エラーハンドリング

例外タイプ

import com.emailverify.exception.*;

try {
    VerificationResult result = client.verify("invalid-email");
} catch (AuthenticationException e) {
    System.err.println("API キーが無効です");
} catch (RateLimitException e) {
    System.err.println("レート制限に達しました。" + e.getRetryAfter() + " 秒後にリトライしてください");
} catch (ValidationException e) {
    System.err.println("入力が無効です: " + e.getMessage());
} catch (EmailVerifyException e) {
    System.err.println("API エラー: " + e.getMessage());
}

カスタム例外ハンドラー

public class VerificationService {
    private final Client client;

    public Optional<VerificationResult> safeVerify(String email) {
        try {
            return Optional.of(client.verify(email));
        } catch (RateLimitException e) {
            logger.warn("レート制限に達しました。リトライまで: {}", e.getRetryAfter());
            return Optional.empty();
        } catch (EmailVerifyException e) {
            logger.error("検証に失敗しました: {}", e.getMessage());
            return Optional.empty();
        }
    }
}

Spring Boot 統合

依存関係

Spring Boot スターターを追加：

<dependency>
    <groupId>com.emailverify</groupId>
    <artifactId>emailverify-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

設定

# application.yml
emailverify:
  api-key: ${EMAILVERIFY_API_KEY}
  timeout: 30s
  retries: 3

または application.properties で：

emailverify.api-key=${EMAILVERIFY_API_KEY}
emailverify.timeout=30s
emailverify.retries=3

自動設定

クライアントは自動的に設定され、インジェクションで利用可能になります：

import com.emailverify.Client;
import org.springframework.stereotype.Service;

@Service
public class EmailVerificationService {
    private final Client emailVerifyClient;

    public EmailVerificationService(Client emailVerifyClient) {
        this.emailVerifyClient = emailVerifyClient;
    }

    public boolean isValidEmail(String email) {
        VerificationResult result = emailVerifyClient.verify(email);
        return "valid".equals(result.getStatus());
    }
}

REST コントローラー

import com.emailverify.Client;
import com.emailverify.model.VerificationResult;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/verify")
public class VerificationController {
    private final Client client;

    public VerificationController(Client client) {
        this.client = client;
    }

    @PostMapping
    public ResponseEntity<?> verify(@RequestBody VerifyRequest request) {
        try {
            VerificationResult result = client.verify(request.getEmail());
            return ResponseEntity.ok(new VerifyResponse(
                result.getEmail(),
                result.getStatus(),
                result.getScore()
            ));
        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                .body(new ErrorResponse("検証に失敗しました"));
        }
    }
}

record VerifyRequest(String email) {}
record VerifyResponse(String email, String status, double score) {}
record ErrorResponse(String error) {}

カスタムバリデーターアノテーション

// アノテーション
import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

@Documented
@Constraint(validatedBy = ValidEmailValidator.class)
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface ValidEmail {
    String message() default "無効なメールアドレスです";
    boolean rejectDisposable() default true;
    double minScore() default 0.5;
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

// バリデーター
import com.emailverify.Client;
import com.emailverify.model.VerificationResult;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class ValidEmailValidator implements ConstraintValidator<ValidEmail, String> {
    private final Client client;
    private boolean rejectDisposable;
    private double minScore;

    public ValidEmailValidator(Client client) {
        this.client = client;
    }

    @Override
    public void initialize(ValidEmail annotation) {
        this.rejectDisposable = annotation.rejectDisposable();
        this.minScore = annotation.minScore();
    }

    @Override
    public boolean isValid(String email, ConstraintValidatorContext context) {
        if (email == null || email.isBlank()) {
            return false;
        }

        try {
            VerificationResult result = client.verify(email);

            if (!"valid".equals(result.getStatus())) {
                return false;
            }

            if (rejectDisposable && result.getResult().isDisposable()) {
                return false;
            }

            return result.getScore() >= minScore;
        } catch (Exception e) {
            return false;
        }
    }
}

// 使用例
public class RegisterRequest {
    @ValidEmail(rejectDisposable = true, minScore = 0.7)
    private String email;

    // ゲッター、セッター...
}

非同期サービス

import com.emailverify.Client;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncVerificationService {
    private final Client client;

    public AsyncVerificationService(Client client) {
        this.client = client;
    }

    @Async
    public CompletableFuture<VerificationResult> verifyAsync(String email) {
        return client.verifyAsync(email);
    }

    @Async
    public CompletableFuture<List<VerificationResult>> verifyBatchAsync(List<String> emails) {
        return CompletableFuture.supplyAsync(() -> {
            BulkJob job = client.verifyBulk(emails);

            // 完了をポーリング
            while (true) {
                BulkJob status = client.getBulkJobStatus(job.getId());
                if ("completed".equals(status.getStatus())) {
                    break;
                }
                if ("failed".equals(status.getStatus())) {
                    throw new RuntimeException("一括ジョブが失敗しました");
                }
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException(e);
                }
            }

            return client.getBulkJobResults(job.getId());
        });
    }
}

完全な例

登録サービス

import com.emailverify.Client;
import com.emailverify.model.VerificationResult;

public class RegistrationService {
    private final Client client;

    public RegistrationService(Client client) {
        this.client = client;
    }

    public ValidationResult validateEmail(String email) {
        VerificationResult result = client.verify(email);

        // 無効なメールを拒否
        if ("invalid".equals(result.getStatus())) {
            return ValidationResult.invalid("invalid_email",
                "このメールアドレスは無効です");
        }

        // 使い捨てメールを拒否
        if (result.getResult().isDisposable()) {
            return ValidationResult.invalid("disposable",
                "恒久的なメールアドレスを使用してください");
        }

        // ロールベースメールについて警告
        if (result.getResult().isRole()) {
            return ValidationResult.warning("role_based",
                "個人メールの使用をお勧めします",
                result.getScore());
        }

        return ValidationResult.valid(result.getScore());
    }
}

class ValidationResult {
    private final boolean valid;
    private final String reason;
    private final String message;
    private final Double score;

    private ValidationResult(boolean valid, String reason, String message, Double score) {
        this.valid = valid;
        this.reason = reason;
        this.message = message;
        this.score = score;
    }

    public static ValidationResult valid(double score) {
        return new ValidationResult(true, null, null, score);
    }

    public static ValidationResult invalid(String reason, String message) {
        return new ValidationResult(false, reason, message, null);
    }

    public static ValidationResult warning(String reason, String message, double score) {
        return new ValidationResult(true, reason, message, score);
    }

    // ゲッター...
}

並行検証

import com.emailverify.Client;
import java.util.List;
import java.util.concurrent.*;
import java.util.stream.Collectors;

public class ConcurrentVerifier {
    private final Client client;
    private final ExecutorService executor;

    public ConcurrentVerifier(Client client, int threads) {
        this.client = client;
        this.executor = Executors.newFixedThreadPool(threads);
    }

    public List<VerificationResult> verifyAll(List<String> emails) {
        List<CompletableFuture<VerificationResult>> futures = emails.stream()
            .map(email -> CompletableFuture.supplyAsync(
                () -> client.verify(email), executor))
            .collect(Collectors.toList());

        return futures.stream()
            .map(CompletableFuture::join)
            .collect(Collectors.toList());
    }

    public void shutdown() {
        executor.shutdown();
    }
}

// 使用例
ConcurrentVerifier verifier = new ConcurrentVerifier(client, 10);
try {
    List<String> emails = Arrays.asList("user1@example.com", "user2@example.com");
    List<VerificationResult> results = verifier.verifyAll(emails);
    results.forEach(r -> System.out.println(r.getEmail() + ": " + r.getStatus()));
} finally {
    verifier.shutdown();
}

ベストプラクティス

1. コネクションプーリングを使用

// クライアントはデフォルトでコネクションプーリングを使用します
// 高スループットアプリケーションの場合、プールサイズを設定します
Client client = Client.builder()
    .apiKey(apiKey)
    .maxConnections(100)
    .build();

2. Nullable フィールドの処理

VerificationResult result = client.verify(email);

// nullable フィールドには Optional を使用
Optional.ofNullable(result.getResult().getDeliverable())
    .ifPresent(deliverable -> System.out.println("Deliverable: " + deliverable));

3. リソース管理

// Client は AutoCloseable を実装しています
try (Client client = new Client(apiKey)) {
    VerificationResult result = client.verify(email);
    // 結果を処理
}

次のステップ

API リファレンス

詳細な API ドキュメント

統合ガイド

プラットフォーム統合

PHP

PHP email checker SDK. Composer install, verify emails with PHP. Code examples included.

AI Guides

Email checker for AI agents. MCP Server, Claude Code, AI SDKs integration. Automated email verification.

On this page

インストールMavenGradle要件クイックスタート設定クライアントビルダー設定プロパティ型VerificationResultBulkJob単一検証基本的な検証オプション付き検証非同期検証一括検証ジョブの送信ステータスの確認結果の取得Webhook 付きクレジット管理エラーハンドリング例外タイプカスタム例外ハンドラーSpring Boot 統合依存関係設定自動設定REST コントローラーカスタムバリデーターアノテーション非同期サービス完全な例登録サービス並行検証ベストプラクティス1. コネクションプーリングを使用2. Nullable フィールドの処理3. リソース管理次のステップ