beanstalkd is a high-performance, lightweight distributed memory queue system. Personally, if you need a lightweight middleware, beanstalkd is a very good choice, and the protocol is also very simple. A detailed introduction to beanstalkd can be found at
https://wenku.baidu.com/view/b9654077f242336c1eb95e54.html .
According to the concept of message middleware, it is divided into message providers and message consumers. Combined with the concepts of beanstalkd and netty, the tube in beanstalkd corresponds to the channel in netty one by one. In order to avoid mutual influence between message providers and message consumers in the same project, the providers and consumers of tubes with the same name use different channels.
1. The encapsulation of the beanstalk protocol The encapsulation
of the protocol refers to dinstone. First, the interface is defined to represent the function of the protocol.
package com.haole.mq.beanstalk.command;
import io.netty.buffer.ByteBuf;
import java.nio.charset.Charset;
/**
* Created by shengjunzhao on 2017/5/27.
*/
public interface Command {
String getCommandLine(); // Command of splicing protocol
ByteBuf prepareRequest(ByteBuf sendBuf, Charset charset, String delimiter); // Encode command into ByteBuf
}
Extract public parts into abstract classes
package com.haole.mq.beanstalk.command;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.buffer.Unpooled;
import java.nio.charset.Charset;
/**
* Created by shengjunzhao on 2017/5/27.
*/
public class AbstractCommand implements Command {
private String commandLine;
@Override
public String getCommandLine() {
return this.commandLine;
}
@Override
public ByteBuf prepareRequest(ByteBuf sendBuf,Charset charset, String delimiter) {
sendBuf.writeBytes(this.commandLine.getBytes(charset));
sendBuf.writeBytes(delimiter.getBytes(charset));
return sendBuf;
}
public void setCommandLine(String commandLine) {
this.commandLine = commandLine;
}
}
beanstalkd each protocol for a specific class, for example: put command implementation class
package com.haole.mq.beanstalk.command;
import io.netty.buffer.ByteBuf;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.charset.Charset;
/**
* put command
* Created by shengjunzhao on 2017/5/27.
*/
public class PutCommand extends AbstractCommand {
private final static Logger log = LoggerFactory.getLogger(PutCommand.class);
private byte[] data;
public PutCommand(int priority, int delay, int ttr, byte[] data) {
if (data == null) {
throw new IllegalArgumentException("data is null");
}
if (data.length > 65536) {
throw new IllegalArgumentException("data is too long than 65536");
}
setCommandLine("put " + priority + " " + delay + " " + ttr + " " + data.length);
this.data = data;
}
@Override
public ByteBuf prepareRequest(ByteBuf sendBuf,Charset charset, String delimiter) {
sendBuf = super.prepareRequest(sendBuf,charset,delimiter);
sendBuf.writeBytes(data);
sendBuf.writeBytes(delimiter.getBytes(charset));
return sendBuf;
}
}
Consumer reserve implementation
package com.haole.mq.beanstalk.command;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Created by shengjunzhao on 2017/5/29.
*/
public class ReserveCommand extends AbstractCommand {
private final static Logger log = LoggerFactory.getLogger(ReserveCommand.class);
public ReserveCommand(long timeout) {
if (timeout > 0)
setCommandLine("reserve-with-timeout " + timeout);
else
setCommandLine("reserve");
}
}
2. Implementation of encoding and decoding
Encoding is used to convert each protocol of beanstalkd into ByteBuf of netty
package com.haole.mq.beanstalk.codec;
import com.haole.mq.beanstalk.command.Command;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.charset.Charset;
/**
* Created by shengjunzhao on 2017/5/28.
*/
public class CommandEncode extends MessageToByteEncoder<Command> {
private static final Logger log = LoggerFactory.getLogger(CommandEncode.class);
private Charset charset;
private String delimiter;
public CommandEncode(Charset charset) {
this(charset, "\r\n");
}
public CommandEncode(Charset charset, String delimiter) {
this.charset = charset;
this.delimiter = delimiter;
}
@Override
protected void encode(ChannelHandlerContext ctx, Command msg, ByteBuf out) throws Exception {
if (null == msg) {
throw new Exception("The encode message is null");
}
ByteBuf sendBuf = ctx.channel().alloc().buffer(512);
log.debug("&&&&& command={}", msg.getCommandLine());
sendBuf = msg.prepareRequest(sendBuf, charset, delimiter);
out.writeBytes(sendBuf);
}
}
Decode the response used to convert netty's ByteBuf to beanstalkd protocol. The response structure of the beanstalkd protocol is the same, defining a column to represent
package com.haole.mq.beanstalk.command;
/**
* Created by shengjunzhao on 2017/5/27.
*/
public class Response {
private String statusLine;
private byte[] data;
public String getStatusLine() {
return statusLine;
}
public void setStatusLine(String statusLine) {
this.statusLine = statusLine;
}
public byte[] getData() {
return data;
}
public void setData(byte[] data) {
this.data = data;
}
}
decoder
package com.haole.mq.beanstalk.codec;
import com.haole.mq.beanstalk.command.Response;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.charset.Charset;
import java.util.List;
/**
* Created by shengjunzhao on 2017/5/28.
*/
public class CommandDecode extends ByteToMessageDecoder {
private final static Logger log = LoggerFactory.getLogger(CommandDecode.class);
private Charset charset;
private String delimiter;
public CommandDecode(Charset charset) {
this(charset, "\r\n");
}
public CommandDecode(Charset charset, String delimiter) {
this.charset = charset;
this.delimiter = delimiter;
}
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
in.markReaderIndex();
int readableBytes = in.readableBytes();
Response response = new Response();
byte[] resp = new byte[readableBytes];
in.readBytes(resp);
log.debug("bytebuf in {}",resp);
byte previous = 0;
boolean isReset = true;
for (int i = 0; i < readableBytes; i++) {
byte current = resp[i];
if (previous == 13 && current == 10) {
String commandLine = new String(resp, 0, i - 1, charset);
String[] spilts = commandLine.split(" ");
String result = played [0];
if ("RESERVED".equals(result) || "FOUND".equals(result) || "OK".equals(result)) {
String bytesStr = played [played.length - 1];
if (bytesStr.matches("\\d+")) {
int bytes = Integer.valueOf(bytesStr);
if (bytes == readableBytes - i - 1 - 2) {
byte[] data = new byte[bytes];
System.arraycopy(resp, i + 1, data, 0, bytes);
response.setData(data);
isReset = false;
}
} else
isReset = false;
} else
isReset = false;
response.setStatusLine(commandLine);
break;
}
previous = current;
}
if (isReset)
in.resetReaderIndex();
else {
out.add(response);
}
}
}
3. netty processor The
processor receives the response decoded by netty and stores it in the blocking queue
package com.haole.mq.beanstalk.handler;
import com.haole.mq.beanstalk.command.Command;
import com.haole.mq.beanstalk.command.Response;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.LinkedBlockingQueue;
/**
* Created by shengjunzhao on 2017/5/28.
*/
public class BeanstalkHandler extends ChannelInboundHandlerAdapter {
private static final Logger log = LoggerFactory.getLogger(BeanstalkHandler.class);
private LinkedBlockingQueue<Response> queue = new LinkedBlockingQueue<>();
private Channel channel;
public BeanstalkHandler() {}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
super.channelActive(ctx);
this.channel=ctx.channel();
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
Response response = (Response) msg;
queue.put(response);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
super.exceptionCaught(ctx, cause);
}
public Response sendMessage(Command command) throws InterruptedException {
this.channel.writeAndFlush(command);
return queue.take();
}
}
Here, a blocking queue is used to save the response to the sent command. beanstalkd guarantees that commands are received in order and processed in order. There is no situation where the response to the command is inconsistent with the command. However, netty cannot guarantee a one-to-one correspondence between requests and responses, and depends on the implementation of the server. If the implementation of the server is a third-party, such as beanstalkd, one-to-one correspondence is guaranteed; but if the server uses multiple threads to implement requests connected to its own client channel, there is no guarantee that the one-to-one correspondence will be implemented in order, possibly A special message protocol needs to be defined to ensure this.
4. Initialization of netty
private void init() {
b.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast("beanstalk decode", new CommandDecode(Charset.forName("UTF-8")));
pipeline.addLast("beanstalk encode", new CommandEncode(Charset.forName("UTF-8")));
pipeline.addLast("beanstalk client handler", new BeanstalkHandler());
}
});
}
5. beanstalkd
command There are more than 10 commands sent by beanstalkd, take put as an example
/**
* Insert a job into the queue
*
* @param channel
* @param priority priority 0~2**32 integer, the highest priority is 0
* @param delay is an integer indicating the number of seconds to wait to put the job into the ready queue
* @param ttr time to run - is an integer indicating the number of seconds a worker is allowed to execute the job. This time will be counted from when a worker gets a job.
* If the worker fails to delete, release or sleep the job within <ttr> seconds, the job will time out and the server will actively release the job.
* Minimum ttr is 1. If the client sets 0, the server will increase it to 1 by default.
* @param data and job body, is a character sequence of length <byetes>
* @return If it is greater than 0, it is the number of the new job, if less than 0, error, -1; unknown;-2:BURIED;-3:EXPECTED_CRLF;-4:JOB_TOO_BIG;-5:DRAINING
* @throws InterruptedException
*/
public long put(Channel channel, int priority, int delay, int ttr, byte[] data) throws InterruptedException {
Command putCommand = new PutCommand(priority, delay, ttr, data);
Response response = channel.pipeline().get(BeanstalkHandler.class).sendMessage(putCommand);
log.debug("response status {}", response.getStatusLine());
String[] spilts = response.getStatusLine().split(" ");
if ("INSERTED".equals(spilts[0])) {
return Long.valueOf(spilts[1]).longValue();
} else if ("BURIED".equals(spilts[0])) {
return -2;
} else if ("EXPECTED_CRLF".equals(spilts[0])) {
return -3;
} else if ("JOB_TOO_BIG".equals(spilts[0])) {
return -4;
} else if ("DRAINING".equals(spilts[0])) {
return -5;
} else
return -1;
}
6. Initialization and exit of message providers and consumers
In a project, providers or consumers can be used alone or at the same time. This client supports a simple beanstalkd cluster, deploys multiple beanstalkd servers at the same time, specifies the addresses of multiple servers during initialization, and selects a specific server according to the tube for connection.
Set<String> servers = new HashSet<>();
servers.add("192.168.209.132:11300");
servers.add("192.168.209.133:11300");
servers.add("192.168.209.134:11300");
BeanstalkProvider provider1 = new DefaultBeanstalkProvider(servers, "beanstalks1");
BeanstalkConsumer consumer1 = new DefaultBeanstalkConsumer(servers, "beanstalks1");
After initialization, you can use the provider or consumer to execute beanstalkd commands.
Finally, you need to call quit() to exit the connection to the server
provider1.quit(); consumer1.quit();
The specific implementation has been uploaded to GitHub, https://github.com/shengjunzhao/beanstalk4j
, please correct me for the deficiencies in the article.