springboot+netty实现socket编程
Java socket网络编程一直没有怎么接触到，虽然以前也自学过netty，但未在实际项目中使用过，始终感觉肤浅。最近看到lcnV4.0.2版本时，才算明白如何在实际springboot项目中如何使用netty实现socket编程。（注意：lcn5.+，代码比较晦涩难懂，如果只是想学习如何在springboot环境下使用netty实现socket编程，建议阅读lcn4.+）
服务端和客户端交互的数据报文约定
但lcnV4.x是直接使用的Json，但还是约定了相关的参数
# json 格式
public class TcpRequest {
// 请求的URI
private String action;
// 唯一确定一个请求，类似requestID
private String uuid;
// 请求时的时间戳
private Long requestTime;
// 请求头信息，类似http请求的请求头
private Map<String,String> header;
// 请求具体的数据
private Object requestBody;
}
socket server
在springboot启动时启动socket server，有很多种方式，如下方式是lcn事务协调器的使用方式，可以借鉴。
/**
* 自定义listener实现ServletContextListener V4.+
* 执行时机：在springboot启动时，会根据不同的启动阶段，执行不同的监听器，而ServletContextListener也是监听器的一种
*/
@Component
public class ServerListener implements ServletContextListener {
private WebApplicationContext springContext;
private InitService initService;
@Override
public void contextInitialized(ServletContextEvent event) {
//这里为什么要从WebApplicationContextUtils中获取springcontext，然后获取某个springbean？
//直接使用@Resouce注解也能注入进来啊？
springContext = WebApplicationContextUtils
.getWebApplicationContext(event.getServletContext());
initService = springContext.getBean(InitService.class);
//initService 也只是一个空壳类，真正的创建服务的类是NettyServerServiceImpl
initService.start();
}
@Override
public void contextDestroyed(ServletContextEvent event) {
initService.close();
}
}
@Service
public class NettyServerServiceImpl implements NettyServerService {
@Autowired
private NettyService nettyService;
private Logger logger = LoggerFactory.getLogger(NettyServerServiceImpl.class);
private EventLoopGroup bossGroup;
private EventLoopGroup workerGroup;
private TxCoreServerHandler txCoreServerHandler;
@Autowired
private ConfigReader configReader;
//启动netty服务，3句代码
@Override
public void start() {
int heartTime = configReader.getTransactionNettyHeartTime()+10;
//我试了下 这里直接注入也可以
txCoreServerHandler = new TxCoreServerHandler(nettyService);
bossGroup = new NioEventLoopGroup(50); // (1)
workerGroup = new NioEventLoopGroup();
try {
//1. 创建一个ServerBootstrap，可以理解为创建一个服务
ServerBootstrap b = new ServerBootstrap();
//2. 为服务设置相关参数
//2.1 为netty服务绑定2个NioEventLoopGroup（可以理解为2个线程池）
// bossGroup线程池负责和客户端建立连接，workerGroup负责读写数据（主从reactor模式），
// 每个线程池里的线程都可以处理多个连接的建立或者数据的读写，
// 每个线程都有一个对应的selector，该线程处理的channel都会注册到这个selector里
b.group(bossGroup, workerGroup)
//2.2 让bossGroup处理NioServerSocketChannel，
// 创建NioServerSocketChannel实例，设置实例为非阻塞模式，创建selector，并将实例的accept事件注册到selector里
// bossGroup里的线程死循环，执行selector.select()，当有连接到来时，获取到客户端连接，并将客户端连接转给workerGroup池里的线程处理
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 100)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast("timeout", new IdleStateHandler(heartTime, heartTime, heartTime, TimeUnit.SECONDS));
ch.pipeline().addLast(new LengthFieldPrepender(4, false));
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));
//这里之所以只有这一个处理器，是因为有工具类直接将ByteBuf转换成字符串
ch.pipeline().addLast(txCoreServerHandler);
}
});
// 3. 使用netty创建socket服务
b.bind(Constants.socketPort);
logger.info("Socket started on port(s): " + Constants.socketPort + " (socket)");
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void close() {
if (workerGroup != null) {
workerGroup.shutdownGracefully();
}
if (bossGroup != null) {
bossGroup.shutdownGracefully();
}
}
}
@ChannelHandler.Sharable
public class TxCoreServerHandler extends ChannelInboundHandlerAdapter { // (1)
private NettyService nettyService;
private Logger logger = LoggerFactory.getLogger(TxCoreServerHandler.class);
private final static int max_size = 100;
private Executor threadPool = Executors.newFixedThreadPool(max_size);
public TxCoreServerHandler(NettyService nettyService) {
this.nettyService = nettyService;
}
//服务端读取数据，可能是业务数据，也可能是心跳数据，一般来说对于心跳数据，打印个日志就可以了，有任务数据才需要具体的业务逻辑处理
@Override
public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {
//将ByteBuf转换成字符串
final String json = SocketUtils.getJson(msg);
logger.info("接受->"+json);
//子线程执行具体业务逻辑
threadPool.execute(new Runnable() {
@Override
public void run() {
service(json,ctx);
}
});
}
private void service(String json,ChannelHandlerContext ctx){
if (StringUtils.isNotEmpty(json)) {
JSONObject jsonObject = JSONObject.parseObject(json);
//socket编程里。客户端请求服务端，需要服务端根据客户端请求参数进行路由到某个业务逻辑进行处理
String uri = jsonObject.getString("uri");
//类似http请求里的requestID，用于辨别是哪个请求，一般服务端会将这个字段的值原封不动的返回
String uuid = jsonObject.getString("uuid");
JSONObject params = JSONObject.parseObject(jsonObject.getString("paremeter"));
String modelName = ctx.channel().remoteAddress().toString();
//根据某个参数，类似http请求的URI获取具体的处理类
IActionService actionService = nettyService.getActionService(uri);
//根据处理类进行业务逻辑的处理
String res = actionService.execute(modelName,key,params);
JSONObject resObj = new JSONObject();
resObj.put("uuid", uuid);
resObj.put("result", res);
//将处理结果发生给客户端
SocketUtils.sendMsg(ctx,resObj.toString());
}
}
@Override
public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
//是否到达最大上线连接数
if (SocketManager.getInstance().isAllowConnection()) {
SocketManager.getInstance().addClient(ctx.channel());
} else {
ctx.close();
}
super.channelRegistered(ctx);
}
@Override
public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
SocketManager.getInstance().removeClient(ctx.channel());
String modelName = ctx.channel().remoteAddress().toString();
SocketManager.getInstance().outLine(modelName);
ModelInfoManager.getInstance().removeModelInfo(modelName);
super.channelUnregistered(ctx);
}
//channelRead执行后触发
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
//出错是会触发，做一些错误处理
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
//ctx.close();
}
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
//心跳配置，一般服务端在心跳配置的时间到达时，如果还没收到客户端的心跳数据，则断开通道。注意：服务端的心跳时间应该比客户端的心跳时间要长
if (IdleStateEvent.class.isAssignableFrom(evt.getClass())) {
IdleStateEvent event = (IdleStateEvent) evt;
if (event.state() == IdleState.READER_IDLE) {
ctx.close();
}
}
}
}
ChannelInboundHandlerAdapter类相关方法的含义：
- handlerAdded () ：handler被加入到pipeline时触发（只触发一次，channel和pipeline一一对应） ch.pipeline().addLast(new TxCoreServerHandler());
- channelRegistered ()：Channel 在创建时，需要绑定 ChannelPipeline 和 EventLoop 等操作，完成这些操作后触发。
- channelActive ()：channel连接就绪后（即可以使用channel进行读写数据）触发。
- channelRead ()：有数据可读时触发。
- channelReadComplete ()：数据读取完毕时触发。
- channelInactive (): channel连接关闭后触发。
- channelUnregistered (): 解绑channelPipeline和eventloop后触发。
- handlerRemoved ()：移除pipeline上对应的handler。
ChannelHandler 回调方法的执行顺序为
- 连接请求，handlerAdded () -> channelRegistered () -> channelActive () ；
- 数据请求，channelRead () -> channelReadComplete ()；
- 通道被关闭，channelInactive () -> channelUnregistered () -> handlerRemoved ()。
public class SocketUtils {
//将ByteBuf消息转换成字符串
public static String getJson(Object msg) {
String json;
try {
ByteBuf buf = (ByteBuf) msg;
byte[] bytes = new byte[buf.readableBytes()];
buf.readBytes(bytes);
json = new String(bytes);
} finally {
ReferenceCountUtil.release(msg);
}
return json;
}
//当收到消息后，进行相关业务逻辑的处理，处理完后将结果发生给对方
public static void sendMsg(ChannelHandlerContext ctx, String msg){
ctx.writeAndFlush(Unpooled.buffer().writeBytes(msg.getBytes()));
}
//服务端或客户端，主动向对方发生消息，如果是服务端，则需要将客户端注册成功后的channel保存下来
//如服务端需要向所有客户端广播某个消息时
public static void sendMsg(Channel ctx,String msg){
ctx.writeAndFlush(Unpooled.buffer().writeBytes(msg.getBytes()));
}
}
socket client
其实和server端比较类似
@Component
public class TransactionSocketListener implements ApplicationContextAware {
@Autowired
private InitService initService;
@Override
public void setApplicationContext(ApplicationContext event) throws BeansException {
//initService没有实际代码，实际代码在NettyServiceImpl里
initService.start();
}
}
@Service
public class NettyServiceImpl implements NettyService {
@Autowired
private NettyDistributeService nettyDistributeService;
@Autowired
private NettyControlService nettyControlService;
@Autowired
private TimeOutService timeOutService;
private EventLoopGroup workerGroup;
private static volatile boolean isStarting = false;
private Logger logger = LoggerFactory.getLogger(NettyServiceImpl.class);
@Override
public synchronized void start() {
if (isStarting) {
return;
}
isStarting = true;
//获取服务端地址
nettyDistributeService.loadTxServer();
//一般来说服务端应该是集群，这里应该是集群地址，并且应该是连接池比较合理
//而这里只连接了一台，也不是连接池，因此这块的代码其实需要进行优化
String host = Constants.txServer.getHost();
int port = Constants.txServer.getPort();
final int heart = Constants.txServer.getHeart();
int delay = Constants.txServer.getDelay();
int autoCompensateLimit = Constants.txServer.getAutoCompensateLimit();
final TransactionHandler transactionHandler = new TransactionHandler(nettyControlService, delay);
timeOutService.loadOutTime(autoCompensateLimit);
workerGroup = new NioEventLoopGroup();
try {
Bootstrap b = new Bootstrap(); // (1)
b.group(workerGroup); // (2)
b.channel(NioSocketChannel.class); // (3)
b.option(ChannelOption.SO_KEEPALIVE, true); // (4)
b.handler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast("timeout", new IdleStateHandler(heart, heart, heart, TimeUnit.SECONDS));
ch.pipeline().addLast(new LengthFieldPrepender(4, false));
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));
ch.pipeline().addLast(transactionHandler);
}
});
// Start the client.
logger.info("连接manager-socket服务-> host:" + host + ",port:" + port);
ChannelFuture future = b.connect(host, port); // (5)
future.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture channelFuture) throws Exception {
if (!channelFuture.isSuccess()) {
channelFuture.channel().eventLoop().schedule(new Runnable() {
@Override
public void run() {
isStarting = false;
//连接失败，则5秒后再连接一次
start();
}
}, 5, TimeUnit.SECONDS);
}
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public synchronized void close() {
if (workerGroup != null) {
workerGroup.shutdownGracefully();
workerGroup = null;
SocketManager.getInstance().setNetState(false);
isStarting = false;
}
}
@Override
public boolean checkState() {
if (!SocketManager.getInstance().isNetState()) {
logger.error("socket服务尚未建立连接成功,将在此等待2秒.");
try {
Thread.sleep(1000 * 2);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (!SocketManager.getInstance().isNetState()) {
logger.error("socket还未连接成功,请检查TxManager服务后再试.");
return false;
}
}
return true;
}
}
@ChannelHandler.Sharable
public class TransactionHandler extends ChannelInboundHandlerAdapter {
private Logger logger = LoggerFactory.getLogger(TransactionHandler.class);
private NettyControlService nettyControlService;
private String heartJson;
public TransactionHandler(NettyControlService nettyControlService, int delay) {
this.nettyControlService = nettyControlService;
SocketManager.getInstance().setDelay(delay);
//心跳包
JSONObject heartJo = new JSONObject();
heartJo.put("a", "h");
heartJo.put("k", "h");
heartJo.put("p", "{}");
heartJson = heartJo.toString();
}
@Override
public void channelRead(final ChannelHandlerContext ctx, final Object msg) throws Exception {
String json = SocketUtils.getJson(msg);
logger.info("TxManager-response->" + json);
nettyControlService.executeService(ctx, json);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
}
@Override
public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
super.channelUnregistered(ctx);
SocketManager.getInstance().setNetState(false);
//链接断开,重新连接
restart();
}
private void restart() {
nettyService.close();
try {
Thread.sleep(1000 * 3);
} catch (InterruptedException e) {
e.printStackTrace();
}
nettyService.start();
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
super.channelActive(ctx);
SocketManager.getInstance().setCtx(ctx);
logger.info("try connection -->" + ctx);
nettyControlService.uploadModelInfo();
//通道激活后发送心跳信息
SocketUtils.sendMsg(ctx, heartJson);
}
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
//心跳配置
if (IdleStateEvent.class.isAssignableFrom(evt.getClass())) {
IdleStateEvent event = (IdleStateEvent) evt;
if (event.state() == IdleState.READER_IDLE) {
//表示已经多久没有收到数据了
//ctx.close();
} else if (event.state() == IdleState.WRITER_IDLE) {
//表示已经多久没有发送数据了
//对客户端而言，定时发送心跳数据即可，如果服务端在一定的时间内（一般比心跳时间长点）没有收到心跳信息，服务端就会断开连接
SocketUtils.sendMsg(ctx, heartJson);
logger.info("hart data --->" + heartJson);
} else if (event.state() == IdleState.ALL_IDLE) {
//表示已经多久既没有收到也没有发送数据了
}
}
}
}
带连接池的netty客户端
上述lcnV4.X的客户端没有使用连接池，对于并发大的场景，一个channel可能不能满足需求，需要使用到连接池，下面的代码就是使用了netty自带的连接池的demo。
public class NettyPoolClient {
private static ChannelPoolMap<InetSocketAddress, SimpleChannelPool> poolMap = null;
public static void main(String[] args) throws Exception {
final EventLoopGroup group = new NioEventLoopGroup();
final Bootstrap strap = new Bootstrap();
//一个客户端可能会连接多个服务端
InetSocketAddress addr1 = new InetSocketAddress("127.0.0.1", 9999);
InetSocketAddress addr2 = new InetSocketAddress("127.0.0.1", 8888);
strap.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.option(ChannelOption.SO_KEEPALIVE, true);
poolMap = new AbstractChannelPoolMap<InetSocketAddress, SimpleChannelPool>() {
@Override
protected SimpleChannelPool newPool(InetSocketAddress key) {
//最后一个参数为连接池大小
return new FixedChannelPool(strap.remoteAddress(key), new NettyChannelPoolHandler(), 5);
}
};
final String ECHO_REQ = "Hello Netty.$_";
//请求第一个server
for (int i = 0; i < 10; i++) {
//从连接池里获取连接，并发送消息到服务器端
sendMessageToServer(addr1,ECHO_REQ);
}
//请求第二个server
for (int i = 0; i < 10; i++) {
//从连接池里获取连接，并发送消息到服务器端
sendMessageToServer(addr2,ECHO_REQ);
}
}
private static void sendMessageToServer(InetSocketAddress addr,String message){
// 根据地址获取连接池，如果连接池还未创建，则调用AbstractChannelPoolMap的newPool方法创建连接池，并缓存下来
final SimpleChannelPool pool = poolMap.get(addr);
Future<Channel> f = pool.acquire();
f.addListener((FutureListener<Channel>) f1 -> {
Channel ch = null;
try {
if (f1.isSuccess()) {
ch = f1.getNow();
System.out.println("【客户端获取到连接，准备发送数据到服务器端】："+message);
ch.writeAndFlush(message);
}
}catch (Exception e){
e.printStackTrace();
}finally {
if(ch!=null) {
pool.release(ch);
}
}
});
}
}
//连接池
public class NettyChannelPoolHandler implements ChannelPoolHandler {
@Override
public void channelReleased(Channel ch) throws Exception {
System.out.println("【客户端将连接还回连接池】: " + ch.id());
}
@Override
public void channelAcquired(Channel ch) throws Exception {
System.out.println("【客户端申请连接池里的链接】: " + ch.id());
}
@Override
public void channelCreated(Channel ch) throws Exception {
ByteBuf delimiter = Unpooled.copiedBuffer("$_".getBytes());
System.out.println("【创建连接】: " + ch.id());
SocketChannel channel = (SocketChannel) ch;
channel.config().setKeepAlive(true);
channel.config().setTcpNoDelay(true);
//添加handler
channel.pipeline()
.addLast(new DelimiterBasedFrameDecoder(1024, delimiter))
.addLast(new StringDecoder())
.addLast(new StringEncoder())
.addLast(new NettyClientHander());
}
}
//handler
public class NettyClientHander extends ChannelInboundHandlerAdapter {
static AtomicInteger count = new AtomicInteger(1);
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// System.out.println("【客户端读取到服务端的数据】"+count.getAndIncrement() + ":" + msg+"-----"+ctx.channel().id());
}
}
9149
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
