Redis的Java客户端
Redis不仅使用命令客户端来操作，而且可以使用程序客户端操作，其实配置和实现起来也非常容易。
现在基本上主流的语言都有客户端支持，比如Java、C、C#、C++、php、Node.js、Go等。在官方网站里列一些Java的客户端，有Jedis、Redisson、Jredis、JDBC-Redis等，其中官方推荐使用Jedis和Redisson，在企业中用的最多的就是Jedis。
开启远程连接
Redis 默认是不支持远程连接的，需要手动开启。
一共修改两个地方：
- 注释掉 bind: 127.0.0.1
- 开启密码校验，去掉 requirepass 的注释
改完之后，保存退出，启动 Redis。
Jedis
1.基本使用
Jedis 的 GitHub 地址：https://github.com/xetorthio/jedis
首先创建一个普通的 Maven 项目，项目创建成功后，添加 Jedis 依赖:
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.5.2</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
</dependencies>
创建测试类：
import redis.clients.jedis.Jedis;
/**
* @author taoguoguo
* @description MyJedis
* @website https://www.cnblogs.com/doondo
* @create 2021-04-09 15:21
*/
public class MyJedis {
public static void main(String[] args) {
//1.构造一个Jedis对象 默认端口6379也可省略
Jedis jedis = new Jedis("192.168.199.229", 6379);
//2.密码认证
jedis.auth("123456");
//3.测试是否连接成功
String ping = jedis.ping();
//4.返回pong表示连接成功
System.out.println(ping);
}
}
对于 Jedis 而言，一旦连接上 Redis 服务端，剩下的操作都很容易了。
在 Jedis 中，由于方法的 API 和 Redis 的命令高度一致，所以，Jedis 中的方法见名知意，直接使用即可。
2.连接池
在实际应用中，Jedis 实例我们一般都是通过连接池来获取，由于 Jedis 对象不是线城安全的，所以，当
我们使用 Jedis 对象时，从连接池获取 Jedis，使用完成之后，再还给连接池。
package org.taoguoguo.redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
/**
* @author taoguoguo
* @description JedisPoolTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-09 15:44
*/
public class JedisPoolTest {
public static void main(String[] args) {
//1.构造一个Jedis连接池
JedisPool pool = new JedisPool("192.168.199.229", 6379);
//2.从连接池中
Jedis jedis = pool.getResource();
//3.Jedis操作
String ping = jedis.ping();
System.out.println(ping);
//4.归还连接
jedis.close();
}
}
如果第三步抛出异常的话，会导致第四步无法执行，所以，我们要对代码进行改进，确保第四步能够执行。
package org.taoguoguo.redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
/**
* @author taoguoguo
* @description JedisPoolTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-09 15:44
*/
public class JedisPoolTest {
public static void main(String[] args) {
//1.构造一个Jedis连接池
JedisPool pool = new JedisPool("192.168.199.229", 6379);
//2.从连接池中
Jedis jedis = pool.getResource();
try {
//3.Jedis操作
String ping = jedis.ping();
System.out.println(ping);
} catch (Exception e) {
e.printStackTrace();
} finally {
//4.归还连接
if (jedis!=null) {
jedis.close();
}
}
}
}
通过 finally 我们可以确保 jedis 一定被关闭。
利用 JDK1.7 中的 try-with-resource 特性，可以对上面的代码进行改造
package org.taoguoguo.redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
/**
* @author taoguoguo
* @description JedisPoolTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-09 15:44
*/
public class JedisPoolTest {
public static void main(String[] args) {
//1.构造一个Jedis连接池
JedisPool pool = new JedisPool("192.168.199.229", 6379);
try(Jedis jedis = pool.getResource()){
//3.Jedis操作
jedis.auth("123456");
String ping = jedis.ping();
System.out.println(ping);
}
}
}
这段代码的作用和上面的是一致的。
但是，上面这段代码无法实现强约束。我们可以做进一步的改进，通过接口约定规范调用：
package org.taoguoguo.redis;
import redis.clients.jedis.Jedis;
/**
* @author taoguoguo
* @description CallWithRedis
* @website https://www.cnblogs.com/doondo
* @create 2021-04-09 16:51
*/
public interface CallWithRedis {
void call(Jedis jedis);
}
package org.taoguoguo.redis;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
/**
* @author taoguoguo
* @description Redis
* @website https://www.cnblogs.com/doondo
* @create 2021-04-09 16:52
*/
public class Redis {
private JedisPool pool;
//无参构造方法中初始化
public Redis() {
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
//连接池最大空闲数
config.setMaxIdle(300);
//最大连接数
config.setMaxTotal(1000);
//连接最大等待时间，如果是 -1 表示没有限制
config.setMaxWaitMillis(30000);
//在空闲时检查有效性
config.setTestOnBorrow(true);
/**
* 1. Redis 地址
* 2. Redis 端口
* 3. 连接超时时间
* 4. 密码
*/
pool = new JedisPool(config,"192.168.199.229",6379,30000,"123456");
}
public void execute(CallWithRedis callWithRedis){
try(Jedis jedis = pool.getResource()){
callWithRedis.call(jedis);
}
}
}
package org.taoguoguo.redis;
/**
* @author taoguoguo
* @description JedisPoolTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-09 15:44
*/
public class JedisPoolTest {
public static void main(String[] args) {
//1.构造一个Jedis连接池
/*JedisPool pool = new JedisPool("192.168.199.229", 6379);
try(Jedis jedis = pool.getResource()){
//2.认证
jedis.auth("123456");
//3.Jedis操作
String ping = jedis.ping();
System.out.println(ping);
}*/
Redis redis = new Redis();
redis.execute(jedis -> {
System.out.println(jedis.ping());
});
}
}
Lettuce
GitHub：https://github.com/lettuce-io/lettuce-core
Lettuce 和 Jedis 的一个比较：
- Jedis 在实现的过程中是直接连接 Redis 的，在多个线程之间共享一个 Jedis 实例，这是线城不安
全的，如果想在多线程场景下使用 Jedis，就得使用连接池，这样，每个线城都有自己的 Jedis 实
例，但这样也会带来不好的一点会消耗更多的物理资源。 - Lettuce 基于目前很火的 Netty NIO 框架来构建，所以克服了 Jedis 中线程不安全的问题，Lettuce
支持同步、异步 以及 响应式调用，多个线程可以共享一个连接实例。
使用 Lettuce，首先创建一个普通的 Maven 项目，添加 Lettuce 依赖：
1.基本使用
使用 Lettuce，首先创建一个普通的 Maven 项目，添加 Lettuce 依赖：
<dependencies>
<dependency>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
<version>5.2.2.RELEASE</version>
</dependency>
</dependencies>
然后来一个简单的测试案例：
package org.taoguoguo;
import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;
/**
* @author taoguoguo
* @description LettuceTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-11 16:00
*/
public class LettuceTest {
public static void main(String[] args) {
RedisClient redisClient = RedisClient.create("redis://123456@192.168.0.104");
//2.获取连接对象
StatefulRedisConnection<String, String> connect = redisClient.connect();
//3.获取redis同步调用对象
RedisCommands<String, String> sync = connect.sync();
//4.操作redis
sync.set("name", "taoguoguo");
String name = sync.get("name");
System.out.println(name);
}
}