netty没有显式释放ByteBuf怎么没日志警告

最近在研究netty,看书(Netty in Action)资源管理,动手写了一个ChannelHandler的实现,如下

 public class EchoServerHandler extends ChannelInboundHandlerAdapter{

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {

        System.out.println("channel read handler 1......");
        ByteBuf buf = ctx.alloc().buffer();
        buf.writeBytes("hehehehehehe".getBytes());
        ctx.fireChannelRead(buf);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

        System.out.println("channelReadComplete1......"+ctx.channel().hashCode());
        super.channelReadComplete(ctx);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

已经在程序中设置了
-Dio.netty.leakDetection.level=PARANOID
最高检测级别

在channelRead()方法中对msg对象并没有做显示释放操作,也没有往下传递给其他的ChannelHandler(后边还有一个处理输入的ChannelHandler),为什么没有打印出警告内存没有释放的日志呢?

本人netty菜鸟,还望各位大神能够不吝赐教 ,感激不禁 !

net

2个回答

Netty默认会在ChannelPipline的最后添加一个tail handler帮你完成ByteBuf的release。

其释放的是channelRead传入的ByteBuf,如果在handlers传递过程中,传递了新值,老值需要你自己手动释放。

另外如果中途没有使用fireChannelRead传递下去也要自己释放。

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
小白关于netty传输byteBuf报问题!!!

小弟在使用netty传输的ByteBuf的时候报 io.netty.channel.DefaultChannelPipeline onUnhandledInboundException

netty怎么合并并分割ByteBuf?

我想要将多个ByteBuf合并到一起然后一并通过网络发送到客户端,然后客户端在进行拆解,怎么做到?

关于Netty4 的channelread的ByteBuf写回客户端信息的迷惑 。

关于Netty4 的channelread的ByteBuf写回客户端信息的迷惑 ``` @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ByteBuf buf = (ByteBuf) msg; ctx.writeAndFlush(buf); } ``` 为什么在ServerHanlder的channelread方法里,这样直接把客户端发来的消息写回客户端,客户端收不到消息 而: ``` @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ByteBuf buf = (ByteBuf) msg; byte[] reg = new byte[buf.readableBytes()]; buf.readBytes(reg); String body = new String(reg, "UTF-8"); ByteBuf respByteBuf = Unpooled.copiedBuffer(body.getBytes()); ctx.writeAndFlush(respByteBuf ); } ``` 这样转成字符串再转回来却能将客户端发来的消息写回去,客户端也能接收到。。小白很迷求解这样强制转换有什么不同吗,跪谢大佬!

netty:一个包的数据,channelRead回调的bytebuf数据不完整?

![图片说明](https://img-ask.csdn.net/upload/201904/17/1555466944_332865.png) ``` <netty.version>4.1.32.Final</netty.version> ``` 第一次channelRead读取的数据: ``` FEFCBFFFFFFFFEFFFEFFDCFFF5FFC8FFFDFFFAFFFCFBFFF8DDFFFFFFFFFFFFFFEFFFE0FFE0FFFFFFF4FFF4FFEFFFF0FFFFFEA1FFFF8AEBF246061C44B2E8493F ``` 第二次channelRead读取的数据: ``` A5540814A1 ``` 两次读取才是一个包的完整数据 一个包的数据,被分为两次读取,这个结论是通过抓包得到的 虽然问题得到解决,但是不知道为何会发生这种情况 请群里大神解答一下 因使用的是最简单的tcp文本协议, 没有包头和包长度 采用的方案是判断接收一个包的字符串长度 [使用netty4.x客户端接收较大数据量报文时发生的读取不完整bug修复记录](https://www.cnblogs.com/GoQC/p/6137160.html ) 我是通过这个文章的思路解决的问题

netty传输inputstream

netty客户端如何接收服务端传输的InputStream 服务端Handler: @Override public void channelActive(ChannelHandlerContext ctx) { try { InputStream input ...; ChunkedStream chunkedStream = new ChunkedStream(input); ChannelFuture writeFuture = ctx.write(chunkedStream); writeFuture.addListener(ChannelFutureListener.CLOSE); } catch (IOException ex) { ex.printStackTrace(); } }

netty 接收16进制数据乱码

![图片说明](https://img-ask.csdn.net/upload/201811/17/1542444076_558650.png)netty做服务器接收16进制数据出现乱码。十六进制数据:2481680000080436021007152234927306113543980E000000FBFFBBFF000000000000000001CC00286610BB00

netty 的ChannelOutboundHandler中的read()方法和write()方法什么时候调用

请教一个netty的问题,服务端注册了4个channel,2个InboundHandler,2个OutboundHandler,我在客户端的ChannelInboundHandler的channelActive方法里向服务端发了一条消息,发现这个OutboundHandler里的read会被调用两次,一次在InboundHandler的read方法之前,另一次在这个InboundHandler.channelReadComplete之后 服务端打印的结果: ``` ==========Server console: SecondOutServerHandler.read ==========Server console: FirstOutServerHandler.read ==========Server console: FirstInServerHandler.channelRead ClientInHandler -> ==========Server console:SecondInServerHandler.channelRead FirstInServerHandler -> ==========Server console: FirstInServerHandler.channelReadComplete ==========Server console: SecondInServerHandler.channelReadComplete ==========Server console: SecondOutServerHandler.read ==========Server console: FirstOutServerHandler.read Disconnected from the target VM, address: '127.0.0.1:56338', transport: 'socket' ``` 我的问题是这个OutboundHandler不是拦截出站事件的么,怎么象拦截的这个InboundHandler,一次写入怎么会调用两次服务 的OutboundHandlerread()方法?netty 的ChannelOutboundHandler中的read()方法和write()方法什么时候调用? ``` package com.bugStack.testHandle; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.util.CharsetUtil; public class ClientInHandler extends SimpleChannelInboundHandler<ByteBuf>{ @Override protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception { System.out.println("==========Client Console ClientInHandler.channelRead0: " + msg.toString(CharsetUtil.UTF_8)); } @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { ctx.writeAndFlush(Unpooled.copiedBuffer("ClientInHandler -> ", CharsetUtil.UTF_8)); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); ctx.close(); } } package com.bugStack.testHandle; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelOutboundHandlerAdapter; import io.netty.channel.ChannelPromise; import io.netty.util.CharsetUtil; public class ClientOutHandler extends ChannelOutboundHandlerAdapter { @Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { ByteBuf in = (ByteBuf) msg; System.out.println("=========ClientOutHandler.write "+ in.toString(CharsetUtil.UTF_8)); /* ctx.writeAndFlush(Unpooled.copiedBuffer(in, Unpooled.copiedBuffer("ClientOutHandler", CharsetUtil.UTF_8)));*/ super.write(ctx, msg, promise); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); ctx.close(); } } package com.bugStack.testHandle; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.util.CharsetUtil; public class FirstInServerHandler extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ByteBuf in = (ByteBuf) msg; System.out.println("==========Server console: FirstInServerHandler.channelRead " + in.toString(CharsetUtil.UTF_8)); ctx.fireChannelRead(Unpooled.copiedBuffer("FirstInServerHandler -> ", CharsetUtil.UTF_8)); } @Override public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { System.out.println("==========Server console: FirstInServerHandler.channelReadComplete "); super.channelReadComplete(ctx); } } package com.bugStack.testHandle; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelOutboundHandlerAdapter; import io.netty.channel.ChannelPromise; import io.netty.util.CharsetUtil; public class FirstOutServerHandler extends ChannelOutboundHandlerAdapter { @Override public void read(ChannelHandlerContext ctx) throws Exception { System.out.println("==========Server console: FirstOutServerHandler.read "); super.read(ctx); } @Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { ByteBuf in = (ByteBuf) msg; System.out.println("==========Server console: FirstOutServerHandler.write " + in.toString(CharsetUtil.UTF_8)); /* ctx.writeAndFlush(Unpooled.copiedBuffer(in, Unpooled.copiedBuffer("FirstOutServerHandler", CharsetUtil.UTF_8))) .addListener(ChannelFutureListener.CLOSE);*/ super.write(ctx, msg, promise); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); ctx.close(); } } package com.bugStack.testHandle; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.util.CharsetUtil; public class SecondInServerHandler extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ByteBuf in = (ByteBuf) msg; System.out.println("==========Server console:SecondInServerHandler.channelRead " + in.toString(CharsetUtil.UTF_8)); /* ctx.write(Unpooled.copiedBuffer(in, Unpooled.copiedBuffer("SecondInServerHandler -> ", CharsetUtil.UTF_8)));*/ } @Override public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { System.out.println("==========Server console: SecondInServerHandler.channelReadComplete "); ctx.flush(); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); ctx.close(); } } package com.bugStack.testHandle; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelOutboundHandlerAdapter; import io.netty.channel.ChannelPromise; import io.netty.util.CharsetUtil; public class SecondOutServerHandler extends ChannelOutboundHandlerAdapter { @Override public void read(ChannelHandlerContext ctx) throws Exception { System.out.println("==========Server console: SecondOutServerHandler.read "); super.read(ctx); } @Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { ByteBuf in = (ByteBuf) msg; System.out.println("==========Server console: SecondOutServerHandler.write" + in.toString(CharsetUtil.UTF_8)); /* ctx.writeAndFlush(Unpooled.copiedBuffer(in, Unpooled.copiedBuffer("SecondOutServerHandler -> ", CharsetUtil.UTF_8)));*/ super.write(ctx, msg, promise); } } package com.bugStack.testHandle; import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; public class HelloClientDemo { public static void main(String[] args) { HelloClientDemo client = new HelloClientDemo(); client.start("localhost", 20000); } public void start(String ip, int port) { NioEventLoopGroup workerGroup = new NioEventLoopGroup(); try { Bootstrap bootstrap = new Bootstrap(); bootstrap.group(workerGroup); bootstrap.channel(NioSocketChannel.class); bootstrap.handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast(new ClientOutHandler()); pipeline.addLast(new ClientInHandler()); } }); ChannelFuture future = bootstrap.connect(ip, port).sync(); future.channel().closeFuture().sync(); } catch (Exception e) { e.printStackTrace(); } finally { workerGroup.shutdownGracefully(); } } } package com.bugStack.testHandle; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; public class HelloServerDemo { public static void main(String[] args) { HelloServerDemo server = new HelloServerDemo(); server.start(20000); } public void start(int port) { NioEventLoopGroup bossGroup = new NioEventLoopGroup(1); NioEventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.group(bossGroup, workerGroup); bootstrap.channel(NioServerSocketChannel.class); bootstrap.childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast(new FirstOutServerHandler()); pipeline.addLast(new SecondOutServerHandler()); pipeline.addLast(new FirstInServerHandler()); pipeline.addLast(new SecondInServerHandler()); } }); ChannelFuture future = bootstrap.bind(port).sync(); future.channel().closeFuture().sync(); } catch (Exception e) { e.printStackTrace(); } finally { bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } } ```

求助大神spark1.6.2和es5.6.0集成后netty包冲突怎么破啊

io.netty.buffer.CompositeByteBuf.addComponents(ZLjava/lang/Iterable;)Lio/netty/buffer/CompositeByteBuf;

netty 开发问题,客户端发了请求后收不到响应

package org.netty_client; import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; public class Client { public void connect(String host,int port) { EventLoopGroup group = new NioEventLoopGroup(); try { Bootstrap strap = new Bootstrap(); strap.group(group); strap.channel(NioSocketChannel.class); strap.option(ChannelOption.TCP_NODELAY, true); strap.handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel arg0) throws Exception { arg0.pipeline().addLast(new ClientHandler()); } }); ChannelFuture future = strap.connect(host, port).sync(); future.channel().closeFuture().sync(); System.out.println("close"); } catch (InterruptedException e) { e.printStackTrace(); }finally { group.shutdownGracefully(); } } public static void main(String[] args) { new Client().connect("127.0.0.1", 8080); } } package org.netty_client; import java.io.UnsupportedEncodingException; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; public class ClientHandler extends ChannelHandlerAdapter{ private ByteBuf buf; public ClientHandler() { String r = "first request"; byte[] req = r.getBytes(); buf = Unpooled.buffer(req.length); buf.writeBytes(req); System.out.println("send request:" + r); } public void channelActive(ChannelHandlerContext ctx) { ctx.writeAndFlush(buf); } public void channelkRead(ChannelHandlerContext ctx,Object msg) throws UnsupportedEncodingException { System.out.println(1); ByteBuf buf = (ByteBuf)msg; byte[] req = new byte[buf.readableBytes()]; buf.readBytes(req); String body = new String(req,"UTF-8"); System.out.println("receive response:" + body); } public void exceptionCaught(ChannelHandlerContext ctx,Throwable e) { e.printStackTrace(); ctx.close(); } } package org.netty_server; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; public class Server { public void bind(int port) { EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap server = new ServerBootstrap(); server.group(bossGroup,workerGroup); server.channel(NioServerSocketChannel.class); server.option(ChannelOption.SO_BACKLOG, 1024); server.childHandler(new ChannelInitializer<SocketChannel>(){ @Override protected void initChannel(SocketChannel arg0) throws Exception { arg0.pipeline().addLast(new ServerHandler()); } }); ChannelFuture future = server.bind(port).sync(); System.out.println("启动服务端口:" + port); future.channel().closeFuture().sync(); System.out.println("close"); } catch (InterruptedException e) { e.printStackTrace(); }finally { bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } public static void main(String[] args) { new Server().bind(8080); } } package org.netty_server; import java.io.UnsupportedEncodingException; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; public class ServerHandler extends ChannelHandlerAdapter{ @Override public void channelRead(ChannelHandlerContext ctx,Object msg) throws UnsupportedEncodingException { ByteBuf buf = (ByteBuf)msg; byte[] req = new byte[buf.readableBytes()]; buf.readBytes(req); String body = new String(req,"UTF-8"); System.out.println("receive request:" + body); String r = "response"; byte[] re = r.getBytes(); ByteBuf resp = Unpooled.copiedBuffer(re); // resp.readBytes(re); System.out.println("send response:" + r); ctx.write(resp); } @Override public void channelReadComplete(ChannelHandlerContext ctx) { ctx.flush(); } public void exceptionCaught(ChannelHandlerContext ctx,Throwable e) { e.printStackTrace(); ctx.close(); } } 测试结果: send request:first request 启动服务端口:8080 receive request:first request send response:response 但是客户端没收到响应,有朋友能看下么,只是写个简单的例子而已

netty服务端接收到中文通信乱码问题

不多说 问题如题 以下是服务端代码 public void channelRead(ChannelHandlerContext ctx, Object msg) { try { ByteBuf buf = (ByteBuf) msg; byte[] req = new byte[buf.readableBytes()]; buf.readBytes(req); String body = new String(req, "UTF-8"); System.out.println("服务器接收到消息:" + body); ctx.writeAndFlush(getSendByteBuf("服务器发送的数据APPLE")); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } private ByteBuf getSendByteBuf(String message) throws UnsupportedEncodingException { byte[] req = message.getBytes("UTF-8"); ByteBuf pingMessage = Unpooled.buffer(); pingMessage.writeBytes(req); return pingMessage; } 以下是客户端代码 public void channelActive(ChannelHandlerContext ctx) throws Exception { byte[] data = "服务器,给我一个APPLE".getBytes(); firstMessage=Unpooled.buffer(); firstMessage.writeBytes(data); ctx.writeAndFlush(firstMessage); } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ByteBuf buf = (ByteBuf) msg; String rev = getMessage(buf); System.out.println("客户端收到服务器数据:" + rev); } private String getMessage(ByteBuf buf) { byte[] con = new byte[buf.readableBytes()]; buf.readBytes(con); try { return new String(con, "UTF-8"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); return null; } } 如需要更详细代码请回复跟帖 我跟帖告诉

netty5的channel写回websocket数据时候,onmessage方法接收不到

``` handler处理如下 package com.amarky.websocket; import org.apache.log4j.Logger; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.handler.codec.http.DefaultFullHttpResponse; import io.netty.handler.codec.http.FullHttpRequest; import io.netty.handler.codec.http.HttpHeaders; import io.netty.handler.codec.http.HttpResponseStatus; import io.netty.handler.codec.http.HttpVersion; import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame; import io.netty.handler.codec.http.websocketx.PingWebSocketFrame; import io.netty.handler.codec.http.websocketx.PongWebSocketFrame; import io.netty.handler.codec.http.websocketx.TextWebSocketFrame; import io.netty.handler.codec.http.websocketx.WebSocketFrame; import io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker; import io.netty.handler.codec.http.websocketx.WebSocketServerHandshakerFactory; import io.netty.util.CharsetUtil; /** * * @author AMARKY * @date 2016年9月8日 * @Desc 处理WEBSOCKET的请求 */ public class WebsocketServerHandler extends SimpleChannelInboundHandler<Object> { private static final Logger logger = Logger.getLogger(WebsocketServerHandler.class.getName()); private WebSocketServerHandshaker handsharker; /** * 接受数据 */ @Override protected void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception { // 如果是HTTP请求 if (msg instanceof FullHttpRequest) { handleHttpRequest(ctx, (FullHttpRequest) msg); } // WEBSOCKET接入 else if (msg instanceof WebSocketFrame) { handleWebSocketFrame(ctx, (WebSocketFrame) msg); } } /** * 数据处理完成后,刷新出去 */ @Override public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { ctx.flush(); } /** * 处理HTTP请求 * * @param ctx * @param msg */ private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) { // 如果解码失败,返回异常 if (!req.getDecoderResult().isSuccess() || (!"websocket".equals(req.headers().get("Upgrade")))) { sendHttpResponse(ctx, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST)); return; } // 构造握手相应 WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory( "ws://localhost:8080/websocket", null, Boolean.FALSE); handsharker = wsFactory.newHandshaker(req); if (handsharker == null) { WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel()); } else { handsharker.handshake(ctx.channel(), req); } } /** * 处理WEBSOCKET请求 * * @param ctx * @param frame */ private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) { // 判断链路是否关闭 if (frame instanceof CloseWebSocketFrame) { handsharker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain()); return; } if (frame instanceof PingWebSocketFrame) { new PongWebSocketFrame(frame.content().retain()); return; } // 只支持文本消息,不支持二进制消息 if (!(frame instanceof TextWebSocketFrame)) { throw new UnsupportedOperationException( String.format("%s frame type not supported", frame.getClass().getName())); } String request = ((TextWebSocketFrame) frame).text(); logger.info(String.format("%s received %s", ctx.channel(), request)); System.out.println(String.format("%s received %s", ctx.channel(), request)); // ctx.channel().write(new TextWebSocketFrame(request + " , 欢迎使用netty // websocket 服务,现在时刻是: ") // + new java.util.Date().toString()); ctx.channel().writeAndFlush("欢迎使用netty websocket 服务,现在时刻是: " + new java.util.Date().toString()); } /** * 返回请求 * * @param ctx * @param req * @param defaultFullHttpResponse */ private void sendHttpResponse(ChannelHandlerContext ctx, DefaultFullHttpResponse res) { // 返回应答的消息 if (res.getStatus().code() != 200) { ByteBuf byteBuf = Unpooled.copiedBuffer(res.getStatus().toString(), CharsetUtil.UTF_8); res.content().writeBytes(byteBuf); byteBuf.release(); HttpHeaders.setContentLength(res, res.content().readableBytes()); } ChannelFuture f = ctx.channel().writeAndFlush(res); if (!HttpHeaders.isKeepAlive(res) || res.getStatus().code() != 200) { f.addListener(ChannelFutureListener.CLOSE); } } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { ctx.close(); } } ``` ``` websocket如下: <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>netty 测试</title> </head> <body> <script type="text/javascript"> var socket; alert(window.WebSocket); if(!window.WebSocket){ window.WebSocket = window.MozWebSocket; } if(window.WebSocket){ socket = new WebSocket("ws://localhost:8080/websocket"); socket.onopen = function(event){ var ta = document.getElementById('responseText'); ta.value = "打开websocket服务正常,支持websocket服务"; }; socket.onmessage = function(event){ var ta = document.getElementById('responseText'); ta.value = ""; ta.value = event.data; }; socket.onclose = function(event){ var ta = document.getElementById('responseText'); ta.value = ""; ta.value = "websocket关闭"; }; } else{ alert("不支持websocket"); } function send(message){ if(!window.WebSocket){return;} if(socket.readyState == WebSocket.OPEN){ socket.send(message); }else{ alert("链接没成功"); } } </script> <form onsubmit="return false;"> <input type = "text" name = "message" value = "netty实践" /> <br><br> <input type = "button" value = "发送" onclick="send(this.form.message.value)" /> <hr color="bule" /> <h3>服务端应答消息</h3> <textarea id = "responseText" style = "width: 500px;height: 300px"></textarea> </form> </body> </html> socket.onmessage方法接受不到writeAndFlush写回的数据,不知道是什么原因​ ```

netty ssl加密传输自动断开

netty的客户端和服务端已经完成ssl认证,传输数据4-5次以后自动断开,请各位帮忙看看哪有问题,下面是代码和异常 客户端: 1. 注册client的handler部分代码: SSLEngine sse = client_context.createSSLEngine(); sse.setUseClientMode(true); sc.pipeline().addLast(new ClientOutboundHandler()) .addLast(new SslHandler(sse)) // .addLast(new IdleStateHandler(30, 30, 0, // TimeUnit.SECONDS)) // .addLast(new HeartBeatHandler()) // .addLast(new ClientCodec()) .addLast(new ClientInboundHandler()) .addLast(new ClientLogicHandler()); 2. ClientInboundHandler中发送数据代码: @Override public void userEventTriggered(ChannelHandlerContext ctx, Object evt) { if (evt instanceof SslHandshakeCompletionEvent) {// 测试ssl加密传输数据 logger.info("client's ssl connection was complated"); ClientSendHeartbeatTask csht = new ClientSendHeartbeatTask(ctx); Thread heartbeatThread = new Thread(csht); heartbeatThread.start(); ClientSendDataTask csdt = new ClientSendDataTask(ctx); Thread dataThread = new Thread(csdt); dataThread.start(); } } 3. 其中ClientSendDataTask的代码如下: @Override public void run() { while (true) { ByteBuf buff = Unpooled.buffer(); String str = JSONArray.fromObject(etlservice.getEtlTablePojos()).toString(); NioMessage nm = new NioMessage(); nm.setType(Constance.DEMODATA_MSG_TYPE); nm.setJson(str); String jsonStr = JacksonUtil.getJsonStr(nm); buff.writeInt(jsonStr.getBytes().length).writeBytes(jsonStr.getBytes()); ctx.writeAndFlush(buff); // buff.clear(); // buff.release(); logger.info("client ClientSendDataTask : send data msg to server"); try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } } } 4. server端注册handler代码: SSLEngine sse = server_context.createSSLEngine(); sse.setNeedClientAuth(true); sse.setUseClientMode(false); sc.pipeline().addLast(new ServerOutboundHandler()) .addLast(new SslHandler(sse)) // .addLast(new IdleStateHandler(30, 30, // 0,TimeUnit.SECONDS)) // .addLast(new HeartBeatHandler()) // .addLast(new ServerCodec()) .addLast(new ServerInboundHandler()) .addLast(new ServerLogicHandler()); 5. ServerInboundHandler中处理接收的数据代码: @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { NioMessage nm = NettyUtil.getNioMessage(msg); if (0 == nm.getType()) logger.warn("server channelRead : msg type is zero , throw exception"); try { if (Constance.HEARTBEAT_MSG_TYPE == nm.getType()) { logger.info("server channelRead : heartbeat msg"); HeartBeatEntity hb = JacksonUtil.getObjMapper().readValue(nm.getJson(), HeartBeatEntity.class); ctx.fireChannelRead(hb); } else if (Constance.DEMODATA_MSG_TYPE == nm.getType()) { logger.info("server channelRead : data msg"); // List<EtlTablePojo> pojoList = (List<EtlTablePojo>) // JacksonUtil.getObjMapper().readValue(nm.getJson(), // List.class); System.out.println("=====json is : " + nm.getJson()); ctx.fireChannelRead(nm.getJson()); } else if (Constance.RESULT_MSG_TYPE == nm.getType()) { logger.info("server channelRead : operation result msg"); ResultEntity re = JacksonUtil.getObjMapper().readValue(nm.getJson(), ResultEntity.class); re.toString(); } } catch (JsonParseException e) { e.printStackTrace(); } catch (JsonMappingException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } 6. 运行一段时间后出现错误如下: [nioEventLoopGroup-14-1] DEBUG io.netty.handler.ssl.SslHandler - Swallowing a harmless 'connection reset by peer / broken pipe' error that occurred while writing close_notify in response to the peer's close_notify java.io.IOException: Connection reset by peer at sun.nio.ch.FileDispatcher.read0(Native Method) ~[na:1.6.0_65] at sun.nio.ch.SocketDispatcher.read(SocketDispatcher.java:21) ~[na:1.6.0_65] at sun.nio.ch.IOUtil.readIntoNativeBuffer(IOUtil.java:198) ~[na:1.6.0_65] at sun.nio.ch.IOUtil.read(IOUtil.java:166) ~[na:1.6.0_65] at sun.nio.ch.SocketChannelImpl.read(SocketChannelImpl.java:245) ~[na:1.6.0_65] at io.netty.buffer.UnpooledUnsafeDirectByteBuf.setBytes(UnpooledUnsafeDirectByteBuf.java:436) ~[netty-all-4.0.11.Final.jar:na] at io.netty.buffer.AbstractByteBuf.writeBytes(AbstractByteBuf.java:870) ~[netty-all-4.0.11.Final.jar:na] at io.netty.channel.socket.nio.NioSocketChannel.doReadBytes(NioSocketChannel.java:208) ~[netty-all-4.0.11.Final.jar:na] at io.netty.channel.nio.AbstractNioByteChannel$NioByteUnsafe.read(AbstractNioByteChannel.java:88) ~[netty-all-4.0.11.Final.jar:na] at io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:485) [netty-all-4.0.11.Final.jar:na] at io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:452) [netty-all-4.0.11.Final.jar:na] at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:346) [netty-all-4.0.11.Final.jar:na] at io.netty.util.concurrent.SingleThreadEventExecutor$2.run(SingleThreadEventExecutor.java:101) [netty-all-4.0.11.Final.jar:na] at java.lang.Thread.run(Thread.java:695) [na:1.6.0_65]

netty 服务器周期性的进步不去,服务端没有响应

我用netty4写了个服务器(客户端是Android),服务端有两个的handler,一个是登录注册用的,另一个是处理其他请求的,因为当时做也没什么经验,所以把业务逻辑都写在了handler里,但是部署到服务器后,每隔一段时间客户端访问服务端就没响应,查看进程仍在,但就是不能用,重启之后又能用了,打印日志都是些java.io.IOException: Connection reset by peer,请问问题出在了哪里?应该向哪方面排查?

netty 心跳机制 netty 心跳机制 设备在线问题

我用的netty做的服务端,app是客户端,我这边使用一个flag标志标记设备是否在线,1在线,0不在线,app网络波动的情况下会重新连接我,上一个连接就没用了,然后netty的心跳机制在五秒内去监测这个连接五秒没读取到数据了就执行事件删除连接然后给我的在线标志弄成不在线,但是这个标志会影响到新连接,如果抖动之后新连接在五秒之内连接上来了,那上一个连接销毁的时候在新连接之后就会影响到这个标志位,有什么好方法改造嘛

netty为啥主动关闭客户端链接,求大牛指点

netty服务器启动后,客户端1600多个设备会主动连接上。 查看前几天的日志发现,时不时会有断开连接 关闭连接日志打印出来,也就是会调用netty的channelInactive 和 handlerRemoved 方法 ![图片说明](https://img-ask.csdn.net/upload/201711/02/1509593962_815809.png)![图片说明](https://img-ask.csdn.net/upload/201711/02/1509594004_151738.png) 当然也不排除是客户端主动断开的行为,但是直到昨天服务器直接挂掉了。 出现很奇怪的现象,当所有的设备连接上去的时候,过了几分钟就主动把客户端的连接T掉。![图片说明](https://img-ask.csdn.net/upload/201711/02/1509594204_993757.png)![图片说明](https://img-ask.csdn.net/upload/201711/02/1509596199_498810.png)![图片说明](https://img-ask.csdn.net/upload/201711/02/1509596465_671319.png) 在网上查了很多调优方案,但还是解决不了这个问题。服务器用的是阿里云Linux 64位,配置是双核 8G内存 5M带宽。现在就差没把服务器的配置提升了。客户端连接的时候我也监控过CPU和内存的使用都是够的,应该不会1600个socket连接承受不了吧。 已经找这个问题找了一天一夜了,不知道是哪里出了问题。求大神指导思路

netty中怎么实现无限循环给每个客户端发数据?

正在做一个netty服务端,业务是这样的:客户端发数据给服务端,服务端收到之后发一条反馈数据回去;另外服务端需要实时查询数据库,如果有数据就发送给对应客户端,5秒循环一次,我把这两个业务写在同一个channelRead中,结果后者经常出现多次发送数据的情况,好像是多个线程都在执行这个循环,执行的周期不是5秒,5秒内执行了多次,也就是一条数据发了多次且次数不定,不知道是哪里的问题,感觉是自定义线程runnable和netty线程组之间没有协调工作,不知道怎么解决 ``` public class MyHandler extends ChannelHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 01接收客户端数据,并给予反馈,代码略 //02每五秒钟自动遍历一次数据库,将策略数据发送至指定客户端 Runnable send = new Runnable() { @Override public void run() { Mysend: //for无限循环 for(;;) { try{ Convertion con=new Convertion(); gettacticsdata data=new gettacticsdata(); //读取存储在Map中已登录用户ID Map<String, SocketChannel> map = Mymap.getChannels(); Iterator<String> it = map.keySet().iterator(); //for(int m=0;m<map.size();m++) while (it.hasNext()) { System.out.println("Map集合大小为:"+map.size()); String key = it.next(); System.out.println("key:"+key); SocketChannel obj = map.get(key); //判断当前客户是否在线,如果在线就传数据,不在就删除存储在Map中的登录信息 if(obj.isActive()==true) { data.updatelwzt(key); //查询需要下发的策略B数据 ArrayList Bal=data.GetBdata(key); //判断是否有需要下发的策略 if(Bal.size()>0) { for(int i=0;i<Bal.size();i++) { tacticsBdata Bl=(tacticsBdata) Bal.get(i); byte[] Bdata=con.GetBdata(Bl); //SocketChannel obj = map.get(key); if(Bdata.length==32){ ByteBuf Bsend =Unpooled.copiedBuffer(Bdata); obj.writeAndFlush(Bsend); } } } }else { System.out.println("此ChannelID已掉线: " + obj); String resultdk=data.updatelwztdk(key); map.remove(key); obj.close(); } } } catch(Exception e) { break Mysend; } try { //线程休眠5秒钟后再次启动 Thread.sleep(5000); } catch (InterruptedException e) { //e.printStackTrace(); } } } }; new Thread(send).start(); } @Override public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { ctx.flush(); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { ctx.close(); } ```

androidStudio netty已经导入,但是运行时提示找不到netty包

项目中已经将netty的 jar包导入进去了libs文件夹中,但是运行时,还是提示找不到netty包,下面是 日志信息: 1-07 09:41:42.713 10019-10019/com.orangewealth.orangeclient D/Volley: [1] DiskBasedCache.clear: Cache cleared. 01-07 09:41:42.728 10019-10019/com.orangewealth.orangeclient W/dalvikvm: VFY: unable to find class referenced in signature (Lio/netty/channel/Channel;) 01-07 09:41:42.728 10019-10019/com.orangewealth.orangeclient W/dalvikvm: VFY: unable to find class referenced in signature (Lio/netty/channel/Channel;) 01-07 09:41:42.728 10019-10019/com.orangewealth.orangeclient W/dalvikvm: VFY: unable to find class referenced in signature (Lio/netty/channel/Channel;) 01-07 09:41:42.729 10019-10019/com.orangewealth.orangeclient W/dalvikvm: Unable to resolve superclass of Lcom/samton/ibensdk/mainSDK/IBenChatClientHandler; (8073) 01-07 09:41:42.729 10019-10019/com.orangewealth.orangeclient W/dalvikvm: Link of class 'Lcom/samton/ibensdk/mainSDK/IBenChatClientHandler;' failed 01-07 09:41:42.729 10019-10019/com.orangewealth.orangeclient W/dalvikvm: Unable to resolve superclass of Lcom/samton/ibensdk/mainSDK/IBenChatClientHandler; (8073) 01-07 09:41:42.729 10019-10019/com.orangewealth.orangeclient W/dalvikvm: Link of class 'Lcom/samton/ibensdk/mainSDK/IBenChatClientHandler;' failed 01-07 09:41:42.730 10019-10019/com.orangewealth.orangeclient I/dalvikvm: Could not find method com.samton.ibensdk.mainSDK.IBenChatClientHandler.getInstance, referenced from method com.samton.ibensdk.mainSDK.IBenChatClient.ready

Netty4.3SSL通信失败,握手失败

使用Netty4.3连接某产品服务端,但ssl通信无法正常建立,请有经验的人联系我,可提供测试代码。 QQ:31604274

我这个netty5 TimeServer为什么达不到效果?

/* * Copyright 2013-2018 Lilinfeng. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.phei.netty.basic; import java.nio.charset.Charset; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.codec.LineBasedFrameDecoder; import io.netty.handler.codec.string.StringDecoder; /** * @author lilinfeng * @date 2014年2月14日 * @version 1.0 */ public class TimeServer { public void bind(int port) throws Exception { // 配置服务端的NIO线程组 EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .option(ChannelOption.SO_BACKLOG, 1024) .childHandler(new ChildChannelHandler()); // 绑定端口,同步等待成功 ChannelFuture f = b.bind(port).sync(); // 等待服务端监听端口关闭 f.channel().closeFuture().sync(); } finally { // 优雅退出,释放线程池资源 bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } private class ChildChannelHandler extends ChannelInitializer<SocketChannel> { @Override protected void initChannel(SocketChannel arg0) throws Exception { arg0.pipeline().addLast(new LineBasedFrameDecoder(1024)); arg0.pipeline().addLast(new StringDecoder(Charset.forName("UTF-8"))); arg0.pipeline().addLast(new TimeServerHandler()); } } /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { int port = 8080; if (args != null && args.length > 0) { try { port = Integer.valueOf(args[0]); } catch (NumberFormatException e) { // 采用默认值 } } new TimeServer().bind(port); } } /* * Copyright 2012 The Netty Project * * The Netty Project licenses this file to you under the Apache License, * version 2.0 (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. */ package com.phei.netty.basic; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; /** * @author lilinfeng * @date 2014年2月14日 * @version 1.0 */ public class TimeServerHandler extends ChannelHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { String body = (String)msg; System.out.println("The time server receive order : " + body); String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new java.util.Date( System.currentTimeMillis()).toString() : "BAD ORDER"; ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes()); ctx.writeAndFlush(resp); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close(); } } /* * Copyright 2013-2018 Lilinfeng. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.phei.netty.basic; import java.nio.charset.Charset; import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; import io.netty.handler.codec.LineBasedFrameDecoder; import io.netty.handler.codec.string.StringDecoder; /** * @author lilinfeng * @date 2014年2月14日 * @version 1.0 */ public class TimeClient { public void connect(int port, String host) throws Exception { // 配置客户端NIO线程组 EventLoopGroup group = new NioEventLoopGroup(); try { Bootstrap b = new Bootstrap(); b.group(group).channel(NioSocketChannel.class) .option(ChannelOption.TCP_NODELAY, true) .handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast(new LineBasedFrameDecoder(1024)); ch.pipeline().addLast(new StringDecoder(Charset.forName("UTF-8"))); ch.pipeline().addLast(new TimeClientHandler()); } }); // 发起异步连接操作 ChannelFuture f = b.connect(host, port).sync(); // 当代客户端链路关闭 f.channel().closeFuture().sync(); } finally { // 优雅退出,释放NIO线程组 group.shutdownGracefully(); } } /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { int port = 8080; if (args != null && args.length > 0) { try { port = Integer.valueOf(args[0]); } catch (NumberFormatException e) { // 采用默认值 } } new TimeClient().connect(port, "127.0.0.1"); } } /* * Copyright 2012 The Netty Project * * The Netty Project licenses this file to you under the Apache License, * version 2.0 (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. */ package com.phei.netty.basic; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; import java.util.logging.Logger; /** * @author lilinfeng * @date 2014年2月14日 * @version 1.0 */ public class TimeClientHandler extends ChannelHandlerAdapter { private byte[] req; private static final Logger logger = Logger .getLogger(TimeClientHandler.class.getName()); /** * Creates a client-side handler. */ public TimeClientHandler() { req = ("QUERY TIME ORDER"+System.getProperty("line.seperator")).getBytes(); } @Override public void channelActive(ChannelHandlerContext ctx) { ByteBuf message = null; for(int i = 0;i<100;i++){ message = Unpooled.buffer(req.length); message.writeBytes(req); ctx.writeAndFlush(message); } } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { String body = (String) msg; System.out.println("Now is : " + body); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { // 释放资源 logger.warning("Unexpected exception from downstream : " + cause.getMessage()); cause.printStackTrace(); ctx.close(); } }

在中国程序员是青春饭吗?

今年,我也32了 ,为了不给大家误导,咨询了猎头、圈内好友,以及年过35岁的几位老程序员……舍了老脸去揭人家伤疤……希望能给大家以帮助,记得帮我点赞哦。 目录: 你以为的人生 一次又一次的伤害 猎头界的真相 如何应对互联网行业的「中年危机」 一、你以为的人生 刚入行时,拿着傲人的工资,想着好好干,以为我们的人生是这样的: 等真到了那一天,你会发现,你的人生很可能是这样的: ...

程序员请照顾好自己,周末病魔差点一套带走我。

程序员在一个周末的时间,得了重病,差点当场去世,还好及时挽救回来了。

C++(数据结构与算法)78:---分而治之

一、分而治之的思想 分而治之方法与软件设计的模块化方法非常相似 分而治之通常不用于解决问题的小实例,而要解决一个问题的大实例。一般步骤为: ①把一个大实例分为两个或多个更小的实例 ②分别解决每个小实例 ③把这些小实例的解组合成原始大实例的解 二、实际应用之找出假币 问题描述 一个袋子有16个硬币,其中只有一个是假币,这个假币比其他的真币重量轻(其他所有真币的重量都是相同的)...

springboot+jwt实现token登陆权限认证

一 前言 此篇文章的内容也是学习不久,终于到周末有时间码一篇文章分享知识追寻者的粉丝们,学完本篇文章,读者将对token类的登陆认证流程有个全面的了解,可以动态搭建自己的登陆认证过程;对小项目而已是个轻量级的认证机制,符合开发需求;更多精彩原创内容关注公主号知识追寻者,读者的肯定,就是对作者的创作的最大支持; 二 jwt实现登陆认证流程 用户使用账号和面发出post请求 服务器接受到请求后使用私...

技术大佬:我去,你写的 switch 语句也太老土了吧

昨天早上通过远程的方式 review 了两名新来同事的代码,大部分代码都写得很漂亮,严谨的同时注释也很到位,这令我非常满意。但当我看到他们当中有一个人写的 switch 语句时,还是忍不住破口大骂:“我擦,小王,你丫写的 switch 语句也太老土了吧!” 来看看小王写的代码吧,看完不要骂我装逼啊。 private static String createPlayer(PlayerTypes p...

win10暴力查看wifi密码

刚才邻居打了个电话说:喂小灰,你家wifi的密码是多少,我怎么连不上了。 我。。。 我也忘了哎,就找到了一个好办法,分享给大家: 第一种情况:已经连接上的wifi,怎么知道密码? 打开:控制面板\网络和 Internet\网络连接 然后右击wifi连接的无线网卡,选择状态 然后像下图一样: 第二种情况:前提是我不知道啊,但是我以前知道密码。 此时可以利用dos命令了 1、利用netsh wlan...

女程序员,为什么比男程序员少???

昨天看到一档综艺节目,讨论了两个话题:(1)中国学生的数学成绩,平均下来看,会比国外好?为什么?(2)男生的数学成绩,平均下来看,会比女生好?为什么?同时,我又联想到了一个技术圈经常讨...

副业收入是我做程序媛的3倍,工作外的B面人生是怎样的?

提到“程序员”,多数人脑海里首先想到的大约是:为人木讷、薪水超高、工作枯燥…… 然而,当离开工作岗位,撕去层层标签,脱下“程序员”这身外套,有的人生动又有趣,马上展现出了完全不同的A/B面人生! 不论是简单的爱好,还是正经的副业,他们都干得同样出色。偶尔,还能和程序员的特质结合,产生奇妙的“化学反应”。 @Charlotte:平日素颜示人,周末美妆博主 大家都以为程序媛也个个不修边幅,但我们也许...

MySQL数据库面试题(2020最新版)

文章目录数据库基础知识为什么要使用数据库什么是SQL?什么是MySQL?数据库三大范式是什么mysql有关权限的表都有哪几个MySQL的binlog有有几种录入格式?分别有什么区别?数据类型mysql有哪些数据类型引擎MySQL存储引擎MyISAM与InnoDB区别MyISAM索引与InnoDB索引的区别?InnoDB引擎的4大特性存储引擎选择索引什么是索引?索引有哪些优缺点?索引使用场景(重点)...

如果你是老板,你会不会踢了这样的员工?

有个好朋友ZS,是技术总监,昨天问我:“有一个老下属,跟了我很多年,做事勤勤恳恳,主动性也很好。但随着公司的发展,他的进步速度,跟不上团队的步伐了,有点...

我入职阿里后,才知道原来简历这么写

私下里,有不少读者问我:“二哥,如何才能写出一份专业的技术简历呢?我总感觉自己写的简历太烂了,所以投了无数份,都石沉大海了。”说实话,我自己好多年没有写过简历了,但我认识的一个同行,他在阿里,给我说了一些他当年写简历的方法论,我感觉太牛逼了,实在是忍不住,就分享了出来,希望能够帮助到你。 01、简历的本质 作为简历的撰写者,你必须要搞清楚一点,简历的本质是什么,它就是为了来销售你的价值主张的。往深...

程序员写出这样的代码,能不挨骂吗?

当你换槽填坑时,面对一个新的环境。能够快速熟练,上手实现业务需求是关键。但是,哪些因素会影响你快速上手呢?是原有代码写的不够好?还是注释写的不够好?昨夜...

带了6个月的徒弟当了面试官,而身为高级工程师的我天天修Bug......

即将毕业的应届毕业生一枚,现在只拿到了两家offer,但最近听到一些消息,其中一个offer,我这个组据说客户很少,很有可能整组被裁掉。 想问大家: 如果我刚入职这个组就被裁了怎么办呢? 大家都是什么时候知道自己要被裁了的? 面试软技能指导: BQ/Project/Resume 试听内容: 除了刷题,还有哪些技能是拿到offer不可或缺的要素 如何提升面试软实力:简历, 行为面试,沟通能...

优雅的替换if-else语句

场景 日常开发,if-else语句写的不少吧??当逻辑分支非常多的时候,if-else套了一层又一层,虽然业务功能倒是实现了,但是看起来是真的很不优雅,尤其是对于我这种有强迫症的程序"猿",看到这么多if-else,脑袋瓜子就嗡嗡的,总想着解锁新姿势:干掉过多的if-else!!!本文将介绍三板斧手段: 优先判断条件,条件不满足的,逻辑及时中断返回; 采用策略模式+工厂模式; 结合注解,锦...

!大部分程序员只会写3年代码

如果世界上都是这种不思进取的软件公司,那别说大部分程序员只会写 3 年代码,恐怕就没有程序员这种职业。

离职半年了,老东家又发 offer,回不回?

有小伙伴问松哥这个问题,他在上海某公司,在离职了几个月后,前公司的领导联系到他,希望他能够返聘回去,他很纠结要不要回去? 俗话说好马不吃回头草,但是这个小伙伴既然感到纠结了,我觉得至少说明了两个问题:1.曾经的公司还不错;2.现在的日子也不是很如意。否则应该就不会纠结了。 老实说,松哥之前也有过类似的经历,今天就来和小伙伴们聊聊回头草到底吃不吃。 首先一个基本观点,就是离职了也没必要和老东家弄的苦...

2020阿里全球数学大赛:3万名高手、4道题、2天2夜未交卷

阿里巴巴全球数学竞赛( Alibaba Global Mathematics Competition)由马云发起,由中国科学技术协会、阿里巴巴基金会、阿里巴巴达摩院共同举办。大赛不设报名门槛,全世界爱好数学的人都可参与,不论是否出身数学专业、是否投身数学研究。 2020年阿里巴巴达摩院邀请北京大学、剑桥大学、浙江大学等高校的顶尖数学教师组建了出题组。中科院院士、美国艺术与科学院院士、北京国际数学...

为什么你不想学习?只想玩?人是如何一步一步废掉的

不知道是不是只有我这样子,还是你们也有过类似的经历。 上学的时候总有很多光辉历史,学年名列前茅,或者单科目大佬,但是虽然慢慢地长大了,你开始懈怠了,开始废掉了。。。 什么?你说不知道具体的情况是怎么样的? 我来告诉你: 你常常潜意识里或者心理觉得,自己真正的生活或者奋斗还没有开始。总是幻想着自己还拥有大把时间,还有无限的可能,自己还能逆风翻盘,只不是自己还没开始罢了,自己以后肯定会变得特别厉害...

男生更看重女生的身材脸蛋,还是思想?

往往,我们看不进去大段大段的逻辑。深刻的哲理,往往短而精悍,一阵见血。问:产品经理挺漂亮的,有点心动,但不知道合不合得来。男生更看重女生的身材脸蛋,还是...

为什么程序员做外包会被瞧不起?

二哥,有个事想询问下您的意见,您觉得应届生值得去外包吗?公司虽然挺大的,中xx,但待遇感觉挺低,马上要报到,挺纠结的。

当HR压你价,说你只值7K,你该怎么回答?

当HR压你价,说你只值7K时,你可以流畅地回答,记住,是流畅,不能犹豫。 礼貌地说:“7K是吗?了解了。嗯~其实我对贵司的面试官印象很好。只不过,现在我的手头上已经有一份11K的offer。来面试,主要也是自己对贵司挺有兴趣的,所以过来看看……”(未完) 这段话主要是陪HR互诈的同时,从公司兴趣,公司职员印象上,都给予对方正面的肯定,既能提升HR的好感度,又能让谈判气氛融洽,为后面的发挥留足空间。...

面试:第十六章:Java中级开发

HashMap底层实现原理,红黑树,B+树,B树的结构原理 Spring的AOP和IOC是什么?它们常见的使用场景有哪些?Spring事务,事务的属性,传播行为,数据库隔离级别 Spring和SpringMVC,MyBatis以及SpringBoot的注解分别有哪些?SpringMVC的工作原理,SpringBoot框架的优点,MyBatis框架的优点 SpringCould组件有哪些,他们...

早上躺尸,晚上干活:硅谷科技公司这么流行迟到?

硅谷科技公司上班时间OPEN早已不是什么新鲜事,早九晚五是常态,但有很多企业由于不打卡,员工们10点、11点才“姗姗来迟”的情况也屡见不鲜。 这种灵活的考勤制度为人羡慕,甚至近年来,国内某些互联网企业也纷纷效仿。不过,硅谷普遍弹性的上班制度是怎么由来的呢?这种“流行性迟到”真的有那么轻松、悠哉吗? 《动态规划专题班》 课程试听内容: 动态规划的解题要领 动态规划三大类 求最值/计数/可行性 常...

面试阿里p7,被按在地上摩擦,鬼知道我经历了什么?

面试阿里p7被问到的问题(当时我只知道第一个):@Conditional是做什么的?@Conditional多个条件是什么逻辑关系?条件判断在什么时候执...

Python爬虫,高清美图我全都要(彼岸桌面壁纸)

爬取彼岸桌面网站较为简单,用到了requests、lxml、Beautiful Soup4

无代码时代来临,程序员如何保住饭碗?

编程语言层出不穷,从最初的机器语言到如今2500种以上的高级语言,程序员们大呼“学到头秃”。程序员一边面临编程语言不断推陈出新,一边面临由于许多代码已存在,程序员编写新应用程序时存在重复“搬砖”的现象。 无代码/低代码编程应运而生。无代码/低代码是一种创建应用的方法,它可以让开发者使用最少的编码知识来快速开发应用程序。开发者通过图形界面中,可视化建模来组装和配置应用程序。这样一来,开发者直...

面试了一个 31 岁程序员,让我有所触动,30岁以上的程序员该何去何从?

最近面试了一个31岁8年经验的程序猿,让我有点感慨,大龄程序猿该何去何从。

大三实习生,字节跳动面经分享,已拿Offer

说实话,自己的算法,我一个不会,太难了吧

程序员垃圾简历长什么样?

已经连续五年参加大厂校招、社招的技术面试工作,简历看的不下于万份 这篇文章会用实例告诉你,什么是差的程序员简历! 疫情快要结束了,各个公司也都开始春招了,作为即将红遍大江南北的新晋UP主,那当然要为小伙伴们做点事(手动狗头)。 就在公众号里公开征简历,义务帮大家看,并一一点评。《启舰:春招在即,义务帮大家看看简历吧》 一石激起千层浪,三天收到两百多封简历。 花光了两个星期的所有空闲时...

Java岗开发3年,公司临时抽查算法,离职后这几题我记一辈子

前几天我们公司做了一件蠢事,非常非常愚蠢的事情。我原以为从学校出来之后,除了找工作有测试外,不会有任何与考试有关的事儿。 但是,天有不测风云,公司技术总监、人事总监两位大佬突然降临到我们事业线,叫上我老大,给我们组织了一场别开生面的“考试”。 那是一个风和日丽的下午,我翘着二郎腿,左手端着一杯卡布奇诺,右手抓着我的罗技鼠标,滚动着轮轴,穿梭在头条热点之间。 “淡黄的长裙~蓬松的头发...

立即提问
相关内容推荐