tencent cloud

Tencent Cloud Distributed Cache (Redis OSS-Compatible)

DokumentasiTencent Cloud Distributed Cache (Redis OSS-Compatible)操作ガイドデータベースインスタンスへの接続Java Connection Sample

Java接続例

Unduh
Mode fokus
Ukuran font
Terakhir diperbarui: 2026-10-20 17:45:34
Diterjemahkan oleh AI
本文では、Javaクライアントを使用してDistributed Cacheインスタンスに接続する例を紹介します。

事前準備

環境要件

JDK 8以降のバージョン。
MavenまたはGradleビルドツール。

依存関係の追加

Mavenの依存関係。
<!-- Jedisクライアント（5.1.2以降のバージョンを推奨） -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.1.2</version>
</dependency>

<!-- Lettuceクライアント（6.3.0以降のバージョンを推奨） -->
<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.3.0.RELEASE</version>
</dependency>
Gradleの依存関係。
implementation 'redis.clients:jedis:5.1.2'
implementation 'io.lettuce:lettuce-core:6.3.0.RELEASE'

接続情報の取得

1. Distributed Cacheコンソールにログインします。
2. インスタンスリストで、対象インスタンスIDをクリックし、インスタンス詳細ページに移動します。
3. ネットワーク情報エリアで、インスタンスのVIPアドレスとポート（デフォルトは6379）を取得します。
4. 構成情報エリアで、インスタンスの接続パスワードを取得します。
デフォルトアカウントはインスタンスID:パスワード形式を使用し、カスタムアカウントはユーザー名@パスワード形式を使用します。パスワード不要の認証インスタンスはパスワードが不要です。

接続例

プロキシモードでは、クライアントはProxyプロキシレイヤーが提供する統一VIPアドレスを介してインスタンスに接続し、Proxyはリクエストルーティングとフェイルオーバーを自動的に処理し、クライアントはバックエンドのトポロジー変更を意識する必要がありません。
説明：
マルチDB使用説明：プロキシモードサーバーはマルチDBをサポートしています（デフォルトで256個のDBを割り当てます）。ただし、Jedisは自身の実装制限によりSELECTコマンドを使用してデータベースを切り替えられない可能性があります。この場合、DB0のみ使用できます。業務がマルチDBに依存している場合は、SELECTコマンドをサポートするクライアントに変更してください。

Jedis接続プール例（推奨）

JedisPoolコネクションプールを使用して接続を管理し、負荷の偏りを避けるためにFIFOモードの設定を推奨します。
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Jedis;

public class JedisProxyExample {
    public static void main(String[] args) {
        // 接続パラメータ
        String host = "192.xx.xx.2";          // インスタンスVIPアドレス
        int port = 6379;                       // インスタンスポート
        String password = "crs-xxxx:パスワード";     // デフォルトアカウントのパスワード形式：インスタンスID:パスワード

        // 接続プール設定
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(200);           // 最大接続数
        poolConfig.setMaxIdle(200);            // 最大アイドル接続数
        poolConfig.setMinIdle(50);             // 最小アイドル接続数
        poolConfig.setMaxWaitMillis(3000);     // 接続取得の最大待機時間（ミリ秒）
        poolConfig.setTestOnBorrow(false);     // 接続取得時にテストを行いません。
        poolConfig.setTestOnReturn(false);     // 接続返却時にテストを行いません。
        poolConfig.setTestWhileIdle(true);     // アイドル時に接続の有効性をテストします。
        poolConfig.setLifo(false);             // LIFOを無効にし、FIFOを使用して負荷の偏りを回避します。

        // 接続プールを作成します。
        JedisPool jedisPool = new JedisPool(
            poolConfig,
            host,
            port,
            2000,       // 接続タイムアウト（ミリ秒）
            2000,       // 読み取りタイムアウト（ミリ秒）
            password
        );

        // 接続プールを使用して操作を実行します。
        try (Jedis jedis = jedisPool.getResource()) {
            // データを書き込みます。
            jedis.set("name", "Tencent Cloud分散キャッシュデータベース");
            
            // データを読み取ります。
            String value = jedis.get("name");
            System.out.println("get name: " + value);

            // 有効期限付きのKeyを設定します。
            jedis.setex("session:user123", 3600, "session_data");

            // ハッシュ操作
            jedis.hset("user:1001", "name", "張三");
            jedis.hset("user:1001", "age", "28");
            System.out.println("user name: " + jedis.hget("user:1001", "name"));

            // リスト操作
            jedis.lpush("queue:tasks", "task1", "task2", "task3");
            String task = jedis.rpop("queue:tasks");
            System.out.println("dequeued task: " + task);
        }

        // アプリケーション終了時に接続プールを破棄します。
        jedisPool.close();
    }
}

Jedisカスタムアカウント接続例

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Jedis;

public class JedisCustomAccountExample {
    public static void main(String[] args) {
        String host = "192.xx.xx.2";
        int port = 6379;
        String password = "myuser@MyPassword";  // プロキシモードのカスタムアカウント：ユーザー名@パスワード全体をパスワードとして渡します。

        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(200);
        poolConfig.setMaxIdle(200);
        poolConfig.setMinIdle(50);
        poolConfig.setLifo(false);

        // プロキシモードのカスタムアカウント：「ユーザー名@パスワード」を全体パスワードとして渡し、ユーザー名は個別に設定しません。
        JedisPool jedisPool = new JedisPool(
            poolConfig,
            host,
            port,
            2000,
            2000,
            password    // ユーザー名@パスワード
        );

        try (Jedis jedis = jedisPool.getResource()) {
            jedis.set("key", "value");
            System.out.println(jedis.get("key"));
        }

        jedisPool.close();
    }
}

Spring Boot + Jedis統合例

application.yml 設定
spring:
  redis:
    host: 192.xx.xx.2
    port: 6379
    password: crs-xxxx:パスワード
    timeout: 2000ms
    jedis:
      pool:
        max-active: 200
        max-idle: 200
        min-idle: 50
        max-wait: 3000ms
設定クラス
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.time.Duration;

@Configuration
public class RedisConfig {

    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        // スタンドアロン設定
        RedisStandaloneConfiguration standaloneConfig = new RedisStandaloneConfiguration();
        standaloneConfig.setHostName("192.xx.xx.2");
        standaloneConfig.setPort(6379);
        standaloneConfig.setPassword("crs-xxxx:パスワード");

        // 接続プール設定
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(200);
        poolConfig.setMaxIdle(200);
        poolConfig.setMinIdle(50);
        poolConfig.setMaxWaitMillis(3000);
        poolConfig.setLifo(false);  // FIFO モード

        // クライアント設定
        JedisClientConfiguration clientConfig = JedisClientConfiguration.builder()
            .connectTimeout(Duration.ofMillis(2000))
            .readTimeout(Duration.ofMillis(2000))
            .usePooling()
            .poolConfig(poolConfig)
            .build();

        return new JedisConnectionFactory(standaloneConfig, clientConfig);
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        return template;
    }
}

Lettuce接続例（推奨）

LettuceはNettyベースの非同期Redisクライアントです。バージョン6.3.0以降の使用を推奨し、TCP KeepaliveおよびtcpUserTimeoutパラメータを設定してください。
import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.SocketOptions;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.support.ConnectionPoolSupport;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import java.time.Duration;

public class LettuceProxyExample {
    public static void main(String[] args) {
        // RedisURIを構築します。
        RedisURI redisUri = RedisURI.builder()
            .withHost("192.xx.xx.2")
            .withPort(6379)
            .withPassword("crs-xxxx:パスワード".toCharArray())
            .withTimeout(Duration.ofSeconds(2))
            .build();

        // Socket設定（主要パラメータ）
        SocketOptions socketOptions = SocketOptions.builder()
            .connectTimeout(Duration.ofSeconds(2))      // 接続タイムアウト
            .keepAlive(SocketOptions.KeepAliveOptions.builder()
                .enable()                                // TCP Keepaliveを有効にします。
                .idle(Duration.ofSeconds(30))            // アイドル状態が30秒間続いた場合に検出を開始します。
                .interval(Duration.ofSeconds(10))        // 検出間隔10秒
                .count(3)                                // 検出回数3回
                .build())
            .tcpUserTimeout(SocketOptions.TcpUserTimeoutOptions.builder()
                .enable()                                // tcpUserTimeoutを有効にします。
                .tcpUserTimeout(Duration.ofSeconds(30))  // 30秒でタイムアウト
                .build())
            .build();

        // RedisClientを作成します。
        RedisClient redisClient = RedisClient.create();
        redisClient.setOptions(io.lettuce.core.ClientOptions.builder()
            .socketOptions(socketOptions)
            .build());

        // 接続プール設定
        GenericObjectPoolConfig<StatefulRedisConnection<String, String>> poolConfig = 
            new GenericObjectPoolConfig<>();
        poolConfig.setMaxTotal(200);
        poolConfig.setMaxIdle(200);
        poolConfig.setMinIdle(50);
        poolConfig.setMaxWaitMillis(3000);
        poolConfig.setLifo(false);  // FIFO モード

        // 接続プールを作成します。
        GenericObjectPool<StatefulRedisConnection<String, String>> pool =
            ConnectionPoolSupport.createGenericObjectPool(
                () -> redisClient.connect(redisUri),
                poolConfig
            );

        // 接続プールを使用して操作を実行します。
        try (StatefulRedisConnection<String, String> connection = pool.borrowObject()) {
            RedisCommands<String, String> sync = connection.sync();
            
            sync.set("name", "Distributed Cache");
            String value = sync.get("name");
            System.out.println("get name: " + value);

            sync.hset("user:1001", "name", "張三");
            sync.hset("user:1001", "age", "28");
            System.out.println("user name: " + sync.hget("user:1001", "name"));
        } catch (Exception e) {
            e.printStackTrace();
        }

        // アプリケーション終了時にリソースをクリーンアップします。
        pool.close();
        redisClient.shutdown();
    }
}

Spring Boot + Lettuce統合例

application.yml 設定
spring:
  redis:
    host: 192.xx.xx.2
    port: 6379
    password: crs-xxxx:パスワード
    timeout: 2000ms
    lettuce:
      pool:
        max-active: 200
        max-idle: 200
        min-idle: 50
        max-wait: 3000ms
設定クラス（TCP KeepaliveおよびtcpUserTimeoutを含む）
import io.lettuce.core.ClientOptions;
import io.lettuce.core.SocketOptions;
import io.lettuce.core.resource.ClientResources;
import io.lettuce.core.resource.DefaultClientResources;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import java.time.Duration;

@Configuration
public class LettuceRedisConfig {

    @Bean(destroyMethod = "shutdown")
    public ClientResources clientResources() {
        return DefaultClientResources.create();
    }

    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory(ClientResources clientResources) {
        // Socket設定
        SocketOptions socketOptions = SocketOptions.builder()
            .connectTimeout(Duration.ofSeconds(2))
            .keepAlive(SocketOptions.KeepAliveOptions.builder()
                .enable()
                .idle(Duration.ofSeconds(30))
                .interval(Duration.ofSeconds(10))
                .count(3)
                .build())
            .tcpUserTimeout(SocketOptions.TcpUserTimeoutOptions.builder()
                .enable()
                .tcpUserTimeout(Duration.ofSeconds(30))
                .build())
            .build();

        ClientOptions clientOptions = ClientOptions.builder()
            .socketOptions(socketOptions)
            .build();

        // 接続プール設定
        GenericObjectPoolConfig<?> poolConfig = new GenericObjectPoolConfig<>();
        poolConfig.setMaxTotal(200);
        poolConfig.setMaxIdle(200);
        poolConfig.setMinIdle(50);
        poolConfig.setMaxWaitMillis(3000);
        poolConfig.setLifo(false);

        // Lettuceクライアント設定
        LettucePoolingClientConfiguration lettuceConfig = 
            LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofSeconds(2))
                .clientOptions(clientOptions)
                .clientResources(clientResources)
                .poolConfig(poolConfig)
                .build();

        // 接続ファクトリを作成します。
        org.springframework.data.redis.connection.RedisStandaloneConfiguration standaloneConfig =
            new org.springframework.data.redis.connection.RedisStandaloneConfiguration();
        standaloneConfig.setHostName("192.xx.xx.2");
        standaloneConfig.setPort(6379);
        standaloneConfig.setPassword("crs-xxxx:パスワード");

        return new LettuceConnectionFactory(standaloneConfig, lettuceConfig);
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        return template;
    }
}

SSL暗号化接続例（Jedis）

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Jedis;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import java.io.FileInputStream;
import java.security.KeyStore;

public class JedisSSLExample {
    public static void main(String[] args) throws Exception {
        String host = "192.xx.xx.2";
        int port = 6379;
        String password = "crs-xxxx:パスワード";

        // CA証明書（JKS形式）を読み込みます。
        KeyStore trustStore = KeyStore.getInstance("JKS");
        try (FileInputStream fis = new FileInputStream("/path/to/ca.jks")) {
            trustStore.load(fis, "password".toCharArray());
        }

        TrustManagerFactory tmf = TrustManagerFactory.getInstance(
            TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(trustStore);

        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, tmf.getTrustManagers(), null);

        // 接続プール設定
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(200);
        poolConfig.setMaxIdle(200);
        poolConfig.setMinIdle(50);
        poolConfig.setLifo(false);

        // SSL接続プールを作成します。
        JedisPool jedisPool = new JedisPool(
            poolConfig,
            host,
            port,
            2000,
            2000,
            password,
            true,           // SSLを有効にします。
            sslContext.getSocketFactory(),
            null,           // SSLパラメータ
            null            // ホスト名検証ツール
        );

        try (Jedis jedis = jedisPool.getResource()) {
            jedis.set("ssl_test", "encrypted");
            System.out.println(jedis.get("ssl_test"));
        }

        jedisPool.close();
    }
}

主要パラメータの説明

Jedis接続プールパラメータ

パラメータ
説明
推奨値
maxTotal
最大接続数
200
maxIdle
最大アイドル接続数
200
minIdle
最小アイドル接続数
50
maxWaitMillis
接続取得の最大待機時間（ミリ秒）
3000
lifo
接続取得ポリシー
false（FIFO、負荷分散の不均一を回避）
connectTimeout
接続タイムアウト（ミリ秒）
2000
readTimeout
読み取りタイムアウト（ミリ秒）
2000

Lettuce TCP Keepaliveパラメータ

パラメータ
説明
推奨値
keepAlive.idle
アイドル状態がどれくらい続いたら検出を開始するか
30秒
keepAlive.interval
検出間隔
10秒
keepAlive.count
検出回数
3回
tcpUserTimeout
TCPユーザータイムアウト
30秒
説明：
TCP KeepaliveおよびtcpUserTimeoutは、Distributed Cacheへの接続に必要な設定です：
TCP Keepalive：主系切り替え時、VIPが漂移し、古い接続はデッド接続になります。Keepaliveを有効にしない場合、クライアントは接続の切断を検知できず、リクエストがタイムアウトします。
tcpUserTimeout：ノードが受動的にダウンした場合、TCP接続を正常に閉じることができません。tcpUserTimeoutを設定しない場合、ゾンビ接続が30分以上にわたってリソースを占有し続けます。

よくあるご質問

接続タイムアウト

クライアントが存在するCVMと分散キャッシュデータベースインスタンスが同一VPC内にあることを確認してください。
セキュリティグループルールで該当ポートが開放されていることを確認してください。
接続アドレスとポートが正しいことを確認してください。

Lettuce接続プールからの接続取得タイムアウト

maxTotalとmaxIdleが適切に設定されているかどうかを確認してください。
lifoがfalse（FIFOモード）に設定されていることを確認してください。
minIdleが適切に設定されていることを確認し、コールド接続確立のオーバーヘッドを回避してください。
Topik sebelumnya: PHP Connection SampleTopik selanjutnya: Node.JS Connection Sample

Bantuan dan Dukungan

Apakah halaman ini membantu?

masukan

Search
    Enter keywords to search documentation