netty+mqtt
2015-04-28 17:10 辣椒酱 阅读(13587) 评论(1) 编辑 收藏 举报package io.mqtt.server;
import io.mqtt.tool.ConfigService;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import io.netty.util.internal.logging.Log4JLoggerFactory;
import java.util.ArrayList;
import java.util.List;
public class Server {
private static final InternalLogger logger = InternalLoggerFactory
.getInstance(Server.class);
private int port;
// private final int port = ConfigService.getIntProperty("tcp.port", 1883);
private final int httpPort = ConfigService
.getIntProperty("http.port", 8080);
private List<Channel> channels = new ArrayList<Channel>();
private EventLoopGroup bossGroup = new NioEventLoopGroup(1);
private EventLoopGroup workerGroup = new NioEventLoopGroup();
public Server(int port) {
this.port = port;
}
private ServerBootstrap getDefaultServerBootstrap() {
ServerBootstrap server = new ServerBootstrap();
server.group(bossGroup, workerGroup)
.option(ChannelOption.SO_BACKLOG, 1000)
.option(ChannelOption.TCP_NODELAY, true)
.channel(NioServerSocketChannel.class)
.childOption(ChannelOption.SO_KEEPALIVE, true);
return server;
}
public ChannelFuture run() throws Exception {
InternalLoggerFactory.setDefaultFactory(new Log4JLoggerFactory());
Channel channle = getDefaultServerBootstrap()
.childHandler(new TcpChannelInitializer()).bind(port).sync()
.channel();
channels.add(channle);
logger.info("mqtt.io tcp server started at port " + port + '.');
ChannelFuture future = getDefaultServerBootstrap().childHandler(
new HttpChannelInitializer()).bind(httpPort);
Channel httpChannel = future.sync().channel();
channels.add(httpChannel);
logger.info("mqtt.io websocket server started at port " + httpPort
+ '.');
return future;
}
public void destroy() {
logger.info("destroy mqtt.io server ...");
for (Channel channel : channels) {
channel.close();
}
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
public static void main(String[] args) throws Exception {
// for (int i = 0; i < 5; i++) {
new ServerThread(65432 + (0 * 2)).start();
// }
}
}
package io.mqtt.handler;
import io.mqtt.processer.ConnectProcesser;
import io.mqtt.processer.DisConnectProcesser;
import io.mqtt.processer.PingReqProcesser;
import io.mqtt.processer.PublishProcesser;
import io.mqtt.processer.SubscribeProcesser;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.ReadTimeoutException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import io.mqtt.processer.*;
import org.meqantt.message.ConnAckMessage;
import org.meqantt.message.ConnAckMessage.ConnectionStatus;
import org.meqantt.message.DisconnectMessage;
import org.meqantt.message.Message;
import org.meqantt.message.Message.Type;
import org.meqantt.message.PingRespMessage;
public class MqttMessageHandler extends ChannelInboundHandlerAdapter {
private static PingRespMessage PINGRESP = new PingRespMessage();
private static final Map<Message.Type, Processer> processers;
static {
Map<Message.Type, Processer> map = new HashMap<Message.Type, Processer>(
6);
map.put(Type.CONNECT, new ConnectProcesser());
map.put(Type.PUBLISH, new PublishProcesser());
map.put(Type.SUBSCRIBE, (Processer) new SubscribeProcesser());
map.put(Type.UNSUBSCRIBE, (Processer) new UnsubscribeProcesser());
map.put(Type.PINGREQ, new PingReqProcesser());
map.put(Type.DISCONNECT, (Processer) new DisConnectProcesser());
processers = Collections.unmodifiableMap(map);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable e)
throws Exception {
try {
if (e.getCause() instanceof ReadTimeoutException) {
ctx.write(PINGRESP).addListener(
ChannelFutureListener.CLOSE_ON_FAILURE);
} else {
ctx.channel().close();
}
} catch (Throwable t) {
t.printStackTrace();
ctx.channel().close();
}
e.printStackTrace();
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object obj)
throws Exception {
//MQTT MESSAGE
Message msg = (Message) obj;
// server收到clinet 的MQTT数据包,并获取MQTT的消息类型
Processer p = processers.get(msg.getType());
if (p == null) {
return;
}
//根据特定消息类型解析消息包
Message rmsg = p.proc(msg, ctx);
if (rmsg == null) {
return;
}
//根据消息处理结果,向clinet做出回应
if (rmsg instanceof ConnAckMessage
&& ((ConnAckMessage) rmsg).getStatus() != ConnectionStatus.ACCEPTED) {
ctx.write(rmsg).addListener(ChannelFutureListener.CLOSE);
} else if (rmsg instanceof DisconnectMessage) {
ctx.write(rmsg).addListener(ChannelFutureListener.CLOSE);
} else {
ctx.write(rmsg).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
}
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
}
//client
package com.test.client;
import org.eclipse.paho.client.mqttv3.*;
public class SubscribeMessage implements MqttCallback {
private MqttClient client;
public SubscribeMessage() {
}
public static void main(String[] args) {
// String tcpUrl = "tcp://127.0.0.1:1883";
// String clientId = "sub-msg/client1";
// String topicName = "sub/client1";
//
// new SubscribeMessage().doDemo(tcpUrl, clientId, topicName);
// for (int j = 0; j < 5; j++) {
for (int i = 0; i < 10000; i++) {
new SubscribeThread("client_" + 0 + i, "tcp://127.0.0.1:" + (65432 + 0 * 2)).start();
}
// }
}
public void doDemo(String tcpUrl, String clientId, String topicName) {
try {
client = new MqttClient(tcpUrl, clientId);
MqttConnectOptions mqcConf = new MqttConnectOptions();
mqcConf.setConnectionTimeout(300);
mqcConf.setKeepAliveInterval(1000);
client.connect(mqcConf);
client.setCallback(this);
client.subscribe(topicName);
} catch (MqttException e) {
e.printStackTrace();
}
}
public void connectionLost(Throwable cause) {
cause.printStackTrace();
}
public void messageArrived(String topic, MqttMessage message)
throws Exception {
System.out.println("[GOT PUBLISH MESSAGE] : " + message);
}
public void deliveryComplete(IMqttDeliveryToken token) {
}
}