Java RedisClient类代码示例

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
@Override
public void start() {
	try {

		if ( config.isCluster() ) {
			RedisClusterClient clusterClient = createClusterClient( config.getHosts() );
			this.redisClient = clusterClient;
			log.connectingToRedis( config.getHosts().toString(), config.getTimeout() );
			connection = clusterClient.connect( new Utf8StringCodec() );
		}
		else {
			RedisClient client = createClient( config.getHosts().getFirst() );
			this.redisClient = client;
			log.connectingToRedis( config.getHosts().toString(), config.getTimeout() );
			connection = client.connect( new Utf8StringCodec() );
		}
	}
	catch (RuntimeException e) {
		// return a ServiceException to be stack trace friendly
		throw log.unableToInitializeRedis( e );
	}
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
@Override
public void init(AbstractConfiguration config) {
    if (!config.getString("redis.type").equals("master_slave")) {
        throw new IllegalStateException("RedisSyncSingleStorageImpl class can only be used with master slave redis setup, but redis.type value is " + config.getString("redis.type"));
    }

    List<String> address = parseRedisAddress(config.getString("redis.address"), 6379);
    int databaseNumber = config.getInt("redis.database", 0);
    String password = StringUtils.isNotEmpty(config.getString("redis.password")) ? config.getString("redis.password") + "@" : "";

    // lettuce
    RedisURI lettuceURI = RedisURI.create("redis://" + password + address.get(0) + "/" + databaseNumber);
    this.lettuceMasterSlave = RedisClient.create(lettuceURI);
    this.lettuceMasterSlaveConn = MasterSlave.connect(this.lettuceMasterSlave, new Utf8StringCodec(), lettuceURI);
    this.lettuceMasterSlaveConn.setReadFrom(ReadFrom.valueOf(config.getString("redis.read")));

    // params
    initParams(config);
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
@Override
protected RedisClient createClient(Hosts.HostAndPort hostAndPort) {
	if ( staticInstance == null ) {
		final RedisClient redisClient = super.createClient( hostAndPort );

		Runtime.getRuntime().addShutdownHook(
				new Thread( "RedisClient shutdown hook" ) {
					@Override
					public void run() {
						redisClient.shutdown( 0, 0, TimeUnit.MILLISECONDS );
					}
				}
		);
		staticInstance = redisClient;
	}

	return (RedisClient) staticInstance;
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
private static void testAsync() {

        System.out.println("TEST Lettuce async ======================================================");
        RedisClient client = RedisClient.create("redis://localhost:6379/0");
        RedisAsyncConnection<String, String> conn = client.connectAsync();
        conn.set("foo", "bar");

        conn.get("foo");

        conn.lpush("lll", "a");
        conn.lpush("lll", "b");
        conn.lpush("lll", "c");
        conn.lpop("lll");
        conn.lpop("lll");
        conn.lpop("lll");

        conn.hset("mmm", "abc", "123");
        conn.hset("mmm", "def", "456");
        conn.hgetall("mmm");

        conn.del("foo", "lll", "mmm");

        conn.close();
        client.shutdown();
    }
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
/**
 * Connects to the Redis server.
 * @param configuration The configuration object.
 * @throws Exception If an error occurs.
 */
public void connect(Configuration configuration) throws Exception {
    if(sync != null) {
        return;
    }
    RedisURI.Builder uri = RedisURI.Builder.redis(configuration.getRedisHost(), configuration.getRedisPort())
            .withDatabase(configuration.getRedisIndex());
    if(!configuration.getRedisAuth().isEmpty()) {
        uri.withPassword(configuration.getRedisAuth());
    }
    RedisClient client = RedisClient.create(uri.build());
    StatefulRedisConnection<String, String> connection = client.connect();
    sync = connection.sync();
    for(Category category : Category.values()) {
        logger.info("Registered the category {} with the type {}.", category, category.getEntry().getType());
        category.getEntry().setCategory(category);
    }
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
@Test
public void insertionRemoval() throws NumberFormatException, InterruptedException, ExecutionException {
	RedisClient redis = RedisClient.create("redis://127.0.0.1:6379");
	StatefulRedisConnection<String, String> redisConn = redis.connect();
	RedisAsyncCommands<String, String> redisCmd = redisConn.async();
	
	long iterations = 1000;
	
	for (long i = 0; i < iterations; i++) {
		redisCmd.set(String.valueOf(i), String.valueOf(i + 1));
	}
	
	for (long i = 0; i < iterations; i++) {
		long v = Long.valueOf(redisCmd.get(String.valueOf(i)).get());
		assertEquals(i + 1, v);
	}
	
	for (long i = 0; i < iterations; i++) {
		redisCmd.del(String.valueOf(i));
	}
	
	redisConn.close();
	redis.shutdown();
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
private void startUp() {
    logger.info("Starting RedisLettuceService");
    {
        logger.debug("Redis settings:");
        logger.debug("* host={}", cfgHost);
        logger.debug("* port={}", cfgPort);
        logger.debug("* db={}", cfgDb);
    }

    RedisURI redisURI = new RedisURI();
    redisURI.setHost(cfgHost);
    redisURI.setPort(cfgPort);
    redisURI.setDatabase(cfgDb);
    client = RedisClient.create(redisURI);
    connection = client.connect();
    asyncConnection = client.connect();
    syncCommands = connection.sync();
    asyncCommands = asyncConnection.async();
    asyncConnection.setAutoFlushCommands(false);

    logger.info("Connected to a redis client");
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
private static RedisClient findRedisConnection(String host, int port) {
	ClientResources clientResources = DefaultClientResources.builder()//
			.reconnectDelay(Delay.constant(10, TimeUnit.SECONDS))//
			.build();

	RedisURI redisUri = new RedisURI(host, port, 2, TimeUnit.SECONDS);

	ClientOptions clientOptions = ClientOptions.builder() //
			.disconnectedBehavior(DisconnectedBehavior.REJECT_COMMANDS)//
			.build();

	RedisClient redis = RedisClient.create(clientResources, redisUri);
	redis.setOptions(clientOptions);

	return redis;
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
private RedisClient createRedisClient(String host, int port) {
    RedisURI redisUri = new RedisURI(host, port, 2, TimeUnit.SECONDS);
    SocketOptions socketOptions = SocketOptions.builder()
            .connectTimeout(XPipeConsoleConstant.SOCKET_TIMEOUT, TimeUnit.SECONDS)
            .build();
    ClientOptions clientOptions = ClientOptions.builder() //
            .socketOptions(socketOptions)
            .disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)//
            .build();

    DefaultClientResources clientResources = DefaultClientResources.builder()//
            .reconnectDelay(Delay.constant(1, TimeUnit.SECONDS))//
            .build();
    RedisClient redis = RedisClient.create(clientResources, redisUri);
    redis.setOptions(clientOptions);
    return redis;
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
@Override
public void init(AbstractConfiguration config) {
    if (!config.getString("redis.type").equals("single")) {
        throw new IllegalStateException("RedisSyncSingleStorageImpl class can only be used with single redis setup, but redis.type value is " + config.getString("redis.type"));
    }

    List<String> address = parseRedisAddress(config.getString("redis.address"), 6379);
    int databaseNumber = config.getInt("redis.database", 0);
    String password = StringUtils.isNotEmpty(config.getString("redis.password")) ? config.getString("redis.password") + "@" : "";

    // lettuce
    RedisURI lettuceURI = RedisURI.create("redis://" + password + address.get(0) + "/" + databaseNumber);
    this.lettuce = RedisClient.create(lettuceURI);
    this.lettuceConn = this.lettuce.connect();

    // params
    initParams(config);
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
@Override
public void init(AbstractConfiguration config) {
    if (!config.getString("redis.type").equals("sentinel")) {
        throw new IllegalStateException("RedisSyncSingleStorageImpl class can only be used with sentinel redis setup, but redis.type value is " + config.getString("redis.type"));
    }

    List<String> address = parseRedisAddress(config.getString("redis.address"), 26379);
    int databaseNumber = config.getInt("redis.database", 0);
    String password = StringUtils.isNotEmpty(config.getString("redis.password")) ? config.getString("redis.password") + "@" : "";
    String masterId = config.getString("redis.master");

    // lettuce
    RedisURI lettuceURI = RedisURI.create("redis-sentinel://" + password + String.join(",", address) + "/" + databaseNumber + "#" + masterId);
    this.lettuceSentinel = RedisClient.create(lettuceURI);
    this.lettuceSentinelConn = MasterSlave.connect(this.lettuceSentinel, new Utf8StringCodec(), lettuceURI);
    this.lettuceSentinelConn.setReadFrom(ReadFrom.valueOf(config.getString("redis.read")));

    // params
    initParams(config);
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
/**
 * Open a new connection to a Redis Master-Slave server/servers using the supplied {@link RedisURI} and the supplied
 * {@link RedisCodec codec} to encode/decode keys.
 * <p>
 * This {@link MasterSlave} performs auto-discovery of nodes if the URI is a Redis Sentinel URI. Master/Slave URIs will be
 * treated as static topology and no additional hosts are discovered in such case. Redis Standalone Master/Slave will
 * discover the roles of the supplied {@link RedisURI URIs} and issue commands to the appropriate node.
 * </p>
 *
 * @param redisClient the Redis client
 * @param codec Use this codec to encode/decode keys and values, must not be {@literal null}
 * @param redisURIs the Redis server to connect to, must not be {@literal null}
 * @param <K> Key type
 * @param <V> Value type
 * @return A new connection
 */
public static <K, V> StatefulRedisMasterSlaveConnection<K, V> connect(RedisClient redisClient, RedisCodec<K, V> codec,
        Iterable<RedisURI> redisURIs) {

    LettuceAssert.notNull(redisClient, "RedisClient must not be null");
    LettuceAssert.notNull(codec, "RedisCodec must not be null");
    LettuceAssert.notNull(redisURIs, "RedisURIs must not be null");

    List<RedisURI> uriList = LettuceLists.newList(redisURIs);
    LettuceAssert.isTrue(!uriList.isEmpty(), "RedisURIs must not be empty");

    if (isSentinel(uriList.get(0))) {
        return connectSentinel(redisClient, codec, uriList.get(0));
    } else {
        return connectStaticMasterSlave(redisClient, codec, uriList);
    }
}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
public static void main(String[] args) {

        // Syntax: redis://[[email protected]]host[:port][/databaseNumber]
        RedisClient redisClient = RedisClient.create();

        List<RedisURI> nodes = Arrays.asList(RedisURI.create("redis://host1"),
                RedisURI.create("redis://host2"),
                RedisURI.create("redis://host3"));

        StatefulRedisMasterSlaveConnection<String, String> connection = MasterSlave
                .connect(redisClient, new Utf8StringCodec(), nodes);
        connection.setReadFrom(ReadFrom.MASTER_PREFERRED);

        System.out.println("Connected to Redis");

        connection.close();
        redisClient.shutdown();
    }
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
private void initialize() {
	redisClient = new RedisClient(
			plugin.getConfig().getString("redishost"), plugin.getConfig()
					.getInt("redisport"));
	redisPubSubConnection = redisClient.connectPubSub();
	redisPubSubConnection.addListener(redisListener);
	redisPubSubConnection.auth(plugin.getConfig().getString("redispass"));

	redisPubSubConnection.subscribe(channels);

	redisSendClient = new RedisClient(plugin.getConfig().getString(
			"redishost"), plugin.getConfig().getInt("redisport"));
	redis = redisSendClient.connect();
	redis.auth(plugin.getConfig().getString("redispass"));

	plugin.getServer().getScheduler()
			.runTaskTimerAsynchronously(plugin, new Heartbeat(), 600, 1200);

	System.out.println("Redis: Connection completed.");

}
 

import com.lambdaworks.redis.RedisClient; //导入依赖的package包/类
@Override
public void init(AbstractConfiguration config) {
    if (!config.getString("redis.type").equals("master_slave")) {
        throw new IllegalStateException("RedisSyncSingleStorage class can only be used with master slave redis setup, but redis.type value is " + config.getString("redis.type"));
    }

    List<String> address = parseRedisAddress(config.getString("redis.address"), 6379);
    int databaseNumber = config.getInt("redis.database", 0);
    String password = StringUtils.isNotEmpty(config.getString("redis.password")) ? config.getString("redis.password") + "@" : "";

    // lettuce
    RedisURI lettuceURI = RedisURI.create("redis://" + password + address.get(0) + "/" + databaseNumber);
    this.lettuceMasterSlave = RedisClient.create(lettuceURI);
    this.lettuceMasterSlaveConn = MasterSlave.connect(this.lettuceMasterSlave, new Utf8StringCodec(), lettuceURI);
    this.lettuceMasterSlaveConn.setReadFrom(ReadFrom.valueOf(config.getString("redis.read")));

    // redisson
    String masterNode = address.get(0);
    String[] slaveNodes = address.subList(1, address.size()).toArray(new String[address.size() - 1]);
    Config redissonConfig = new Config();
    redissonConfig.useMasterSlaveServers()
            .setMasterAddress(masterNode)
            .setLoadBalancer(new RoundRobinLoadBalancer())
            .addSlaveAddress(slaveNodes)
            .setReadMode(ReadMode.MASTER)
            .setDatabase(databaseNumber)
            .setPassword(StringUtils.isNotEmpty(password) ? password : null);
    this.redisson = Redisson.create(redissonConfig);

    // params
    initParams(config);
}