您的位置:首页 > 数据库 > Redis

盘点一下Redis中常用的Java客户端,或者咱们手写一个?

2021-10-21 09:20 190 查看 https://www.cnblogs.com/mic112

Java中那些Redis的客户端

前面我们的所有操作都是基于redis-cli来完成的,那么我们要在Java中操作Redis,怎么做呢?首先我们先来了解一下Redis Serialization Protocol(Redis序列化协议),这个是Redis提供的一种,客户端和Redis服务端通信传输的编码协议,服务端收到罅隙ihou,会基于这个约定编码进行解码。

  • 打开Wireshark工具,对VMnet8这个网络进行抓包

  • 增加过滤条件

    ip.dst_host==192.168.221.128 and tcp.port in {6379}
  • 使用RDM工具连接到Redis Server进行key-value操作,比如执行 set name mic

  • 通过Wireshark工具监控数据包内容,如图3-3所示,可以看到实际发出的数据包是:

    *3\r\n$3\r\nSET\r\n$4\r\nname\r\n$3\r\nmic

    其中

    *3*
    代表参数个数,set name mic, 表示三个参数。

  • $3
    表示属性长度,
    $
    表示包含3个字符。

客户端和服务器发送的命令或数据一律以 \r\n (CRLF回车+换行)结尾。

图3-3

基于这样一个特性,我们可以自己实现一个Java客户端。

自定义Redis客户端

下面我们通过抓包相关的命令,了解Redis客户端的工作机制。

定义常量池。

public class CommandConstant {
/**
* 开始符
*/
public static final String START = "*";
/**
* 指令长度符
*/
public static final String LENGTH = "$";
/**
* 换行符
*/
public static final String LINE = "\r\n";
public enum CommandEnum {
SET,
GET,
INCR
}
}

CustomClientSocket

CustomClientSocket用来建立网络通信连接,并且发送数据指定到RedisServer。

public class CustomClientSocket {
private Socket socket;
private InputStream inputStream;
private OutputStream outputStream;

public CustomClientSocket(String ip,int port) {
try {
socket=new Socket(ip,port);
inputStream=socket.getInputStream();
outputStream=socket.getOutputStream();
} catch (IOException e) {
e.printStackTrace();
}
}
public void send(String cmd){
try {
outputStream.write(cmd.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
public String read(){
byte[] bytes = new byte[1024];
int count = 0;
try {
count = inputStream.read(bytes);
} catch (IOException e) {
e.printStackTrace();
}
return new String(bytes, 0, count);
}
}

封装客户端

public class CustomRedisClient {

private CustomClientSocket customClientSocket;

public CustomRedisClient(String host,int port) {
customClientSocket=new CustomClientSocket(host,port);
}
public String set(String key, String value) {
customClientSocket.send(convertToCommand(CommandConstant.CommandEnum.SET, key.getBytes(), value.getBytes()));
return customClientSocket.read();
}

public String get(String key) {
customClientSocket.send(convertToCommand(CommandConstant.CommandEnum.GET, key.getBytes()));
return customClientSocket.read();
}

public static String convertToCommand(CommandConstant.CommandEnum command, byte[]... bytes) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(CommandConstant.START).append(bytes.length + 1).append(CommandConstant.LINE);
stringBuilder.append(CommandConstant.LENGTH).append(command.toString().length()).append(CommandConstant.LINE);
stringBuilder.append(command.toString()).append(CommandConstant.LINE);

for (byte[] aByte : bytes) {
stringBuilder.append(CommandConstant.LENGTH).append(aByte.length).append(CommandConstant.LINE);
stringBuilder.append(new String(aByte)).append(CommandConstant.LINE);
}
return stringBuilder.toString();
}
}

测试方法

public static void main(String[] args) {
CustomRedisClient redisClient=new CustomRedisClient("192.168.221.128",6379);
System.out.println(redisClient.set("name","mic"));
System.out.println(redisClient.get("name"));
}

总结

你看,理解了原理之后,自己去实现起来发现并不难。

但是实际开发过程中,我们难倒也需要开发自己开发客户端吗?当然不用,官方推荐了以下三种客户端

配置 作用
Jedis A blazingly small and sane redis java client
lettuce Advanced Redis client for thread-safe sync, async, and reactive usage. Supports Cluster, Sentinel, Pipelining, and codecs.
Redisson distributed and scalable Java data structures on top of Redis server

Jedis

Jedis是我们最熟悉和最常用的客户端。轻量,简洁,便于集成和改造。

简单使用方法

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.6.1</version>
</dependency>
public static void main(String[] args) {
Jedis jedis = new Jedis("127.0.0.1", 6379);
jedis.set("qingshan", "2673");
System.out.println(jedis.get("qingshan"));
jedis.close();
}

一般来说,我们不会使用单个Jedis连接,而是会使用连接池,Jedis提供了连接池的功能。

public static void main(String[] args) {
JedisPool pool = new JedisPool(ip, port);
Jedis jedis = jedisPool.getResource();
}

Luttece

Lettuce
是一个
Redis
Java
驱动包,大家常用的spring-boot-starter-data-redis中默认就采用的Lettuce。
Lettuce
是一个高性能基于
Java
编写的
Redis
驱动框架,底层集成了
Project Reactor
提供天然的反应式编程,通信框架集成了
Netty
使用了非阻塞
IO
5.x
版本之后融合了
JDK1.8
的异步编程特性,在保证高性能的同时提供了十分丰富易用的
API

简单使用方法

<dependency>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
<version>5.1.8.RELEASE</version>
</dependency>

Lettuce
使用的时候依赖于四个主要组件:

  • RedisURI
    :连接信息。
  • RedisClient
    Redis
    客户端,特殊地,集群连接有一个定制的
    RedisClusterClient
  • Connection
    Redis
    连接,主要是
    StatefulConnection
    或者
    StatefulRedisConnection
    的子类,连接的类型主要由连接的具体方式(单机、哨兵、集群、订阅发布等等)选定,比较重要。
  • RedisCommands
    Redis
    命令
    API
    接口,基本上覆盖了
    Redis
    发行版本的所有命令
    ,提供了同步(
    sync
    )、异步(
    async
    )、反应式(
    reative
    )的调用方式,对于使用者而言,会经常跟
    RedisCommands
    系列接口打交道。
public static void main(String[] args) {
RedisURI redisUri = RedisURI.builder()                    // <1> 创建单机连接的连接信息
.withHost("192.168.221.128")
.withPort(6379)
.withTimeout(Duration.of(10, ChronoUnit.SECONDS))
.build();
RedisClient redisClient = RedisClient.create(redisUri);   // <2> 创建客户端
StatefulRedisConnection<String, String> connection = redisClient.connect();     // <3> 创建线程安全的连接
RedisCommands<String, String> redisCommands = connection.sync();                // <4> 创建同步命令
SetArgs setArgs = SetArgs.Builder.nx().ex(5);
String result = redisCommands.set("name", "throwable", setArgs);
System.out.println(result);
result = redisCommands.get("name");
System.out.println(result);
// ... 其他操作
connection.close();   // <5> 关闭连接
redisClient.shutdown();  // <6> 关闭客户端
}

和Spring Boot集成使用

Lettuce是Spring Boot 2.x 默认的客户端,替换了Jedis。集成之后我们不需要单独使用它,直接调用Spring的RedisTemplate操作,连接和创建和关闭也不需要我们操心。

引入依赖jar包

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

application.yml配置文件如下

redis:
port: 6379
host: 192.168.221.128
lettuce:
pool:
max-active: -1
max-idle: 2000
max-wait: -1
min-idle: 1
time-between-eviction-runs: 5000

使用方法

@RestController
@RequestMapping("/")
public class LutteceController {
@Autowired
RedisTemplate redisTemplate;

@GetMapping
public ResponseEntity get(){
String name=(String)redisTemplate.opsForValue().get("name");
return ResponseEntity.ok(name);
}
}

Redisson

https://redisson.org/

https://github.com/redisson/redisson/wiki/目录

Redisson是一个在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid)。它不仅提供了一系列的分布式的Java常用对象,还提供了许多分布式服务。其中包括(

BitSet
,
Set
,
Multimap
,
SortedSet
,
Map
,
List
,
Queue
,
BlockingQueue
,
Deque
,
BlockingDeque
,
Semaphore
,
Lock
,
AtomicLong
,
CountDownLatch
,
Publish / Subscribe
,
Bloom filter
,
Remote service
,
Spring cache
,
Executor service
,
Live Object service
,
Scheduler service
) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离(Separation of Concern),从而让使用者能够将精力更集中地放在处理业务逻辑上。

简单使用方法

  • 引入依赖Jar包

    <dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.16.0</version>
    </dependency>
  • 时间单节点连接和操作

    public static void main(String[] args) {
    Config config=new Config();
    config.useSingleServer().setAddress("redis://192.168.221.128:6379");
    RedissonClient redissonClient= Redisson.create(config);
    redissonClient.getBucket("test").set("mic");
    System.out.println(redissonClient.getBucket("test").get());
    }

和Spring Boot集成

Spring Boot的集成方式。

<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.16.0</version>
</dependency>

application.yml中的配置。

spring:
redis:
timeout: 2000
host: 192.168.221.128
port: 6379

使用方法。

@RestController
public class RedissonController {
@Autowired
RedissonClient redissonClient;

@GetMapping("/")
public String get(){
return redissonClient.getBucket("test").get().toString();
}
}

另外一种配置方式如下

  • 修改application.yml

    spring:
    redis:
    redisson:
    file: classpath:redisson.yml
  • 创建一个redisson.yml文件,内容如下

    singleServerConfig:
    address: redis://192.168.221.128:6379
    #---------------------------------------------
    # 连接空闲超时,单位:毫秒
    idleConnectionTimeout: 10000
    # 连接超时,单位:毫秒
    connectTimeout: 10000
    # 命令等待超时,单位:毫秒
    timeout: 3000
    # 命令失败重试次数,如果尝试达到 retryAttempts(命令失败重试次数) 仍然不能将命令发送至某个指定的节点时,将抛出错误。
    # 如果尝试在此限制之内发送成功,则开始启用 timeout(命令等待超时) 计时。
    retryAttempts: 3
    # 命令重试发送时间间隔,单位:毫秒
    retryInterval: 1500

关注[跟着Mic学架构]公众号,获取更多精品原创

内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: 
相关文章推荐