heartxkl
heartxkl

参考Netty权威指南：Netty4版本的私有协议栈

1、pom文件

 
        
            io.netty
            netty-all
            4.1.19.Final
        
        
            org.msgpack
            msgpack
            0.6.7
        

        
            com.google.protobuf
            protobuf-java
            2.5.0
        
        
            org.projectlombok
            lombok
            1.14.8
        

        
            org.jibx
            jibx-bind
            1.3.1
        

        
            
            
            
        

        
            org.jboss.marshalling
            jboss-marshalling-serial
            1.4.11.Final

重点关注：jboss-marshalling-serial包，一开始我导的不是这个，是上面注释的jboss-marshalling，

结果导致Server无法向Client发送消息。

原因是下面的MarshallingCodeCFactory类，获取marshallerFactory是返回null，没获取到！

MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");


编解码工具类

package com.xkl.learn.privateprotocol.tool;

import java.io.IOException;

import org.jboss.marshalling.MarshallerFactory;
import org.jboss.marshalling.Marshalling;
import org.jboss.marshalling.MarshallingConfiguration;

import io.netty.handler.codec.marshalling.DefaultMarshallerProvider;
import io.netty.handler.codec.marshalling.DefaultUnmarshallerProvider;
import io.netty.handler.codec.marshalling.MarshallerProvider;
import io.netty.handler.codec.marshalling.UnmarshallerProvider;

/**
 * Created by xiekunliang on 2018/2/6.
 */
public class MarshallingCodeCFactory
{
    public static NettyMarshallingDecoder buildMarshallingDecoder() throws IOException
    {
        MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
        MarshallingConfiguration configuration = new MarshallingConfiguration();
        configuration.setVersion(5);
        UnmarshallerProvider provider = new DefaultUnmarshallerProvider(marshallerFactory, configuration);
        NettyMarshallingDecoder decoder = new NettyMarshallingDecoder(provider, 1024 << 2);
        return decoder;
    }

    public static NettyMarshallingEncoder buildMarshallingEncoder()
    {
        MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
        MarshallingConfiguration configuration = new MarshallingConfiguration();
        configuration.setVersion(5);

        MarshallerProvider provider = new DefaultMarshallerProvider(marshallerFactory, configuration);
        NettyMarshallingEncoder encoder = new NettyMarshallingEncoder(provider);
        return encoder;
    }
}
package com.xkl.learn.privateprotocol.tool;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.marshalling.MarshallerProvider;
import io.netty.handler.codec.marshalling.MarshallingEncoder;

/**
 * Created by xiekunliang on 2018/2/5.
 * 编码器
 */
public class NettyMarshallingEncoder extends MarshallingEncoder
{

    /**
     * Creates a new encoder.
     *
     * @param provider the {@link MarshallerProvider} to use
     */
    public NettyMarshallingEncoder(MarshallerProvider provider)
    {
        super(provider);
    }

    @Override
    public void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out)  {
        try {
            super.encode(ctx, msg, out);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


package com.xkl.learn.privateprotocol.tool;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.marshalling.MarshallingDecoder;
import io.netty.handler.codec.marshalling.UnmarshallerProvider;

/**
 * Created by xiekunliang on 2018/2/5.
 * 解码器
 */
public class NettyMarshallingDecoder extends MarshallingDecoder
{

    public NettyMarshallingDecoder(UnmarshallerProvider provider, int objectMaxSize) {
        super(provider, objectMaxSize);
    }

    public NettyMarshallingDecoder(UnmarshallerProvider provider) {
        super(provider);
    }
    @Override
    public Object decode(ChannelHandlerContext ctx, ByteBuf in)  {
        try {
            return super.decode(ctx, in);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

业务消息：编码Handler

package com.xkl.learn.privateprotocol;

import java.io.IOException;
import java.util.List;
import java.util.Map;

import com.xkl.learn.privateprotocol.tool.MarshallingCodeCFactory;
import com.xkl.learn.privateprotocol.tool.NettyMarshallingEncoder;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageEncoder;

/**
 * Created by xiekunliang on 2018/2/5.
 */
public class NettyMessageEncoder extends MessageToMessageEncoder
{

    NettyMarshallingEncoder nettyMarshallingEncoder;

    public NettyMessageEncoder() throws IOException
    {
        nettyMarshallingEncoder = MarshallingCodeCFactory.buildMarshallingEncoder();
    }

    @Override
    protected void encode(ChannelHandlerContext ctx, NettyMessage msg, List out) throws Exception
    {
        if (msg == null || msg.getHeader() == null)
        {
            throw new Exception("The encode message is null");
        }
        ByteBuf sendBuf = Unpooled.buffer();
        sendBuf.writeInt(msg.getHeader().getCrcCode());
        sendBuf.writeInt(msg.getHeader().getLength());
        sendBuf.writeLong(msg.getHeader().getSessionID());
        sendBuf.writeByte(msg.getHeader().getType());
        sendBuf.writeByte(msg.getHeader().getPriority());
        sendBuf.writeInt(msg.getHeader().getAttachment().size());
        for (Map.Entry entry : msg.getHeader().getAttachment().entrySet())
        {
            String key = entry.getKey();
            byte[] keyArray = key.getBytes("UTF-8");
            sendBuf.writeInt(keyArray.length);
            sendBuf.writeBytes(keyArray);
            Object value = entry.getValue();
            nettyMarshallingEncoder.encode(ctx, value, sendBuf);
        }

        if (msg.getBody() != null)
        {
            nettyMarshallingEncoder.encode(ctx, msg.getBody(), sendBuf);
        }
        sendBuf.setInt(4, sendBuf.readableBytes());
        out.add(sendBuf);
    }

}




业务消息：解码Handler


package com.xkl.learn.privateprotocol;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import com.xkl.learn.privateprotocol.tool.MarshallingCodeCFactory;
import com.xkl.learn.privateprotocol.tool.NettyMarshallingDecoder;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;

/**
 * Created by xiekunliang on 2018/2/7.
 */
public class NettyMessageDecoder extends LengthFieldBasedFrameDecoder
{

    NettyMarshallingDecoder marshallingDecoder;

    public NettyMessageDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength, int lengthAdjustment,
            int initialBytesToStrip) throws IOException
    {
        super(maxFrameLength, lengthFieldOffset, lengthFieldLength, lengthAdjustment, initialBytesToStrip);

        marshallingDecoder = MarshallingCodeCFactory.buildMarshallingDecoder();
    }

    @Override
    protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception
    {
        ByteBuf frame = (ByteBuf) super.decode(ctx, in);
        if (frame == null)
        {
            System.out.println("解码器返回null");
            return null;
        }

        NettyMessage message = new NettyMessage();
        Header header = new Header();
        header.setCrcCode(frame.readInt());
        header.setLength(frame.readInt());
        header.setSessionID(frame.readLong());
        header.setType(frame.readByte());
        header.setPriority(frame.readByte());

        // 得到附件个数
        int attachSize = frame.readInt();
        if (attachSize > 0)
        {
            Map attachment = new HashMap<>();
            for (int i = 0; i < attachSize; i++)
            {
                int keySize = frame.readInt();
                byte[] keyArray = new byte[keySize];
                frame.readBytes(keyArray);
                String key = new String(keyArray, "UTF-8");
                Object val = marshallingDecoder.decode(ctx, frame);
                attachment.put(key, val);
            }
            header.setAttachment(attachment);
        }
        
        if (frame.readableBytes() > 0)
        {
            message.setBody(marshallingDecoder.decode(ctx, frame));
        }
        message.setHeader(header);
        return message;

    }

}






业务消息pojo


package com.xkl.learn.privateprotocol;
import lombok.Data;

/**
 * 消息s
 */
@Data
public final class NettyMessage
{
    private Header header;

    private Object body;
}


package com.xkl.learn.privateprotocol;

import java.util.HashMap;
import java.util.Map;

import lombok.Data;

/**
 * Created by xiekunliang on 2018/2/5.
 */
@Data
public class Header
{

    private int crcCode = 0xabef0101;

    // 消息长度
    private int length;

    private long sessionID;

    /**
     * @see MessageType
     */
    private byte type;

    private byte priority;

    private Map attachment = new HashMap<>();
}



MessageType类


package com.xkl.learn.privateprotocol;


public interface MessageType
{

    Byte BUSINESS_REQ = 0;

    Byte BUSINESS_RESP = 1;

    Byte BUSINESS_ONE_WAY = 2;

    Byte LOGIN_REQ = 3;

    Byte LOGIN_RESP = 4;

    Byte HEARTBEAT_REQ = 5;

    Byte HEARTBEAT_RESP = 6;
}




Client : 握手请求 LoginAuthReqHandler


package com.xkl.learn.privateprotocol;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

/**
 * Created by xiekunliang on 2018/2/24.
 */
public class LoginAuthReqHandler extends ChannelInboundHandlerAdapter
{
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception
    {
        NettyMessage message = buildLoginReq();
        ctx.writeAndFlush(message);
        System.out.println("客户端发送握手请求：" + message);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
    {
        NettyMessage message = (NettyMessage) msg;
        // 如果是握手应答消息，需要判断是否握手成功
        if (message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_RESP)
        {
            if (message.getBody() != null)
            {
                String loginResult = message.getBody().toString();
                if (loginResult.equals("login_ok"))
                {
                    System.out.println("Login is success :" + message);
                    // 透传给后面的Handler处理
                    ctx.fireChannelRead(msg);
                }
                else
                {
                    // 握手失败，关闭连接
                    ctx.close();
                    System.out.println("握手失败，关闭连接");
                }
            }
            else
            {
                // 握手失败，关闭连接
                ctx.close();
                System.out.println("握手失败，关闭连接");
            }
        }
        else
        {
            // 如果不是握手应答消息，直接透传
            ctx.fireChannelRead(msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception
    {
        ctx.flush();
    }

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

    private NettyMessage buildLoginReq()
    {
        NettyMessage message = new NettyMessage();
        Header header = new Header();
        header.setType(MessageType.LOGIN_REQ);
        message.setHeader(header);
        return message;
    }
}




Server: 握手应答LoginAuthRespHandler


package com.xkl.learn.privateprotocol;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

/**
 * Created by xiekunliang on 2018/2/24.
 */
public class LoginAuthRespHandler extends ChannelInboundHandlerAdapter
{
    // 白名单，暂时简单处理，写死了
    private String[] writeList = { "/127.0.0.1" };

    // 已经登录的IP缓存，防止重复登录
    private Map nodeCheck = new ConcurrentHashMap<>();

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception
    {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
    {
        NettyMessage message = (NettyMessage) msg;
        // 如果是握手请求消息
        if (message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_REQ)
        {
            System.out.println("receive client login req : " + message);
            NettyMessage loginResp = null;
            String nodeIndex = ctx.channel().remoteAddress().toString().split(":")[0];
            // 判断是否重复登录
            if (nodeCheck.containsKey(nodeIndex))
            {
                loginResp = buildResponse("login_repeat");
            }
            else
            {
                // 判断是否属于白名单中的IP
                boolean tag = false;
                for (String ip : writeList)
                {
                    if (ip.equals(nodeIndex))
                    {
                        tag = true;
                        break;
                    }
                }
                if (tag)
                {
                    nodeCheck.put(nodeIndex, true);
                    loginResp = buildResponse("login_ok");
                }
                else
                {
                    loginResp = buildResponse("login_fail");
                }
                ctx.writeAndFlush(loginResp);
                System.out.println("send login resp is : " + loginResp);
            }
        }
        else
        {
            ctx.fireChannelRead(msg);
        }

    }

    private NettyMessage buildResponse(String result)
    {
        NettyMessage message = new NettyMessage();
        Header header = new Header();
        header.setType(MessageType.LOGIN_RESP);
        message.setHeader(header);
        message.setBody(result);
        return message;
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception
    {
        try
        {
            ctx.fireExceptionCaught(cause);
        }
        finally
        {
            // 异常发生时，把登录缓存清除
            nodeCheck.remove("/127.0.0.1");
        }

    }
}






Client: 心跳请求HeartBeatReqHandler


package com.xkl.learn.privateprotocol;

import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class HeartBeatReqHandler extends ChannelInboundHandlerAdapter
{

    private volatile ScheduledFuture heartBeat;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
    {
        // 如果握手成功，主动发送心跳消息
        NettyMessage message = (NettyMessage) msg;
        Header header = message.getHeader();
        if (header != null)
        {
            if (header.getType() == MessageType.LOGIN_RESP)
            {
                if (heartBeat == null)
                {
                    heartBeat = ctx.executor().scheduleAtFixedRate(new HeartBeatTask(ctx),
                            0,
                            5000,
                            TimeUnit.MILLISECONDS);
                }
            }
            else if (header.getType() == MessageType.HEARTBEAT_RESP)
            {
                System.out.println("Client receive server heart beat message :" + message);
            }
            else
            {
                ctx.fireChannelRead(msg);
            }
        }
        else
        {
            ctx.fireExceptionCaught(new Throwable("没有Header"));
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception
    {
        try
        {
            ctx.fireExceptionCaught(cause);
        }
        finally
        {
            closeHeartBeat();
        }

    }

    private void closeHeartBeat()
    {
        if (heartBeat != null)
        {
            heartBeat.cancel(true);
            heartBeat = null;
        }
    }

    private class HeartBeatTask implements Runnable
    {
        final ChannelHandlerContext ctx;

        public HeartBeatTask(final ChannelHandlerContext ctx)
        {
            this.ctx = ctx;
        }

        @Override
        public void run()
        {
            ctx.writeAndFlush(buildHeartBeat());
            System.out.println("Client send heart beat message to server : ----> " + heartBeat);
        }

    }

    private NettyMessage buildHeartBeat()
    {
        NettyMessage heartBeat = new NettyMessage();
        Header header = new Header();
        header.setType(MessageType.HEARTBEAT_REQ);
        heartBeat.setHeader(header);
        heartBeat.setBody(null);
        return heartBeat;
    }

}



Server: 心跳应答HeartBeatRespHandler


package com.xkl.learn.privateprotocol;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;


public class HeartBeatRespHandler extends ChannelInboundHandlerAdapter
{
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
    {

        NettyMessage message = (NettyMessage) msg;
        if (message.getHeader() != null && message.getHeader().getType() == MessageType.HEARTBEAT_REQ)
        {
            System.out.println("Receive client heart beat message");
            ctx.writeAndFlush(buildHeartBeat());
            System.out.println("Send heart beat message to client");
        } else {
            ctx.fireChannelRead(msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

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

    private NettyMessage buildHeartBeat()
    {
        NettyMessage heartBeat = new NettyMessage();
        Header header = new Header();
        header.setType(MessageType.HEARTBEAT_RESP);
        heartBeat.setHeader(header);
        heartBeat.setBody(null);
        return heartBeat;
    }
}



Client类


package com.xkl.learn.privateprotocol;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

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.timeout.ReadTimeoutHandler;

/**
 * Created by xiekunliang on 2018/2/24.
 */
public class NettyClient
{

    private ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

    private EventLoopGroup group = new NioEventLoopGroup();

    public static void main(String[] args) throws Exception
    {

        String host = "127.0.0.1";
        int port = 18080;
        new NettyClient().connect(host, port);
    }

    private void connect(String host, int port) throws Exception
    {
        try
        {
            Bootstrap b = new Bootstrap();
            b.group(group)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer()
                    {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception
                        {
                            // NettyMessageDecoder设置了单条消息最大值1MB,可以防止消息过大导致的内存溢出或者畸形码流，引发解码错位或内存分配失败
                            ch.pipeline().addLast(new NettyMessageDecoder(1024 * 1024, 4, 4, -8, 0));
                            ch.pipeline().addLast(new NettyMessageEncoder());
                            ch.pipeline().addLast(new ReadTimeoutHandler(50));
                            ch.pipeline().addLast(new LoginAuthReqHandler());
                            ch.pipeline().addLast(new HeartBeatReqHandler());
                        }
                    });

            ChannelFuture f = b.connect(host, port).sync();
            System.out.println("连接成功-----> " + host + ":" + port);
            f.channel().closeFuture().sync();
        }
        finally
        {

            // 发起重连操作
            executorService.execute(() -> {
                try
                {
                    TimeUnit.SECONDS.sleep(5);
                    connect(host, port);
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            });
        }

    }
}













Server类


package com.xkl.learn.privateprotocol;

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.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.timeout.ReadTimeoutHandler;

/**
 * Created by xiekunliang on 2018/2/24.
 */
public class NettyServer
{

    public static void main(String[] args) throws Exception
    {
        new NettyServer().bind();
    }

    public void bind() throws Exception
    {
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup work = new NioEventLoopGroup();
        try
        {
            ServerBootstrap b = new ServerBootstrap();
            b.group(boss, work)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer()
                    {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception
                        {
                            ch.pipeline().addLast(new NettyMessageDecoder(1024 * 1024, 4, 4, -8, 0));
                            ch.pipeline().addLast(new NettyMessageEncoder());
                            ch.pipeline().addLast(new ReadTimeoutHandler(50));
                            ch.pipeline().addLast(new LoginAuthRespHandler());
                            ch.pipeline().addLast(new HeartBeatRespHandler());
                        }
                    });

            ChannelFuture f = b.bind(18080).sync();

            System.out.println("Netty Server start ok! post is 18080");
            f.channel().closeFuture().sync();
        }
        finally
        {
            boss.shutdownGracefully();
            work.shutdownGracefully();
        }

    }

}


运行测试时要注意：


1、断开自动重连是否正常。


2、断连时，心跳是否停止？


如果没有停止可能原因是在Handler的exceptionCaught方法里关闭了ctx，而没有将异常信息透传过去。

























你可能感兴趣的:(Netty)






    

  • linux部署jar项目报错_linux jar 服务
国家级做梦冠军
linux部署jar项目报错

    关于linuxjar服务的搜索结果问题linux重启netty服务一些问题，请大神进linux上部署netty架构的服务时我一般启动的时候用下面脚本nohupjava-jarxxx-xxx.jarstart80808888&关闭的时候杀进程就可以了。今天部署的时候启动服务就报userBind，于是我查...杨冬芳2019-12-0120:26:501161浏览量回答数0问题Linux下Tomcat
    

    • 

  • Spring Cloud全解析：网关之GateWay简介
拾光师
springcloudjava

    GateWay简介由于zuul升级为zuul2时，netflix公司内部出现了分歧，所以springcloud自己研发了一套网关gateway，提供一种简单有效的方式来对API进行路由，以及提供一些强大的过滤器功能，如：熔断、限流、重试等，基于WebFlux框架实现的，底层使用了高性能的Reactor模式通信框架Netty特性基于spring5和springboot2构建动态路由：能够匹配任何请求
    

    • 

  • Netty+WebSocket实现高并发网络编程
Sunny_yiyi
Java精英阶级JavaWebSocket网络websocket网络协议

    我们来实现一个Netty+WebSocket集成案例，由于Netty+WebSocket集成代码比较麻烦，我们可以利用目前开源的项目netty-websocket-spring-boot-starter轻松实现Netty和WebSocket的集成。我们搭建一个项目，项目叫seckill-message，用于处理通知用户抢单状态。1)pom.xmlorg.yeauty</groupId
    

    • 

  • Spring Boot 一个极简且完整的后台框架
搬砖养女人
数据库架构javaspringsqltomcat

    一个完整的极简后台框架，方便做小项目的时候可以快速开发。这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。先放几张图imageimageimage项目介绍SpringBoot，实现了一个极简单的后台框架image小编提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redi
    

    • 

  • netty编程
chenjunxu

    需要导包：netty-all-4.1.25.Final或者导入依赖：io.nettynetty-all4.1.25.Final定义一个server类：publicclassHelloServer{publicstaticvoidmain(String[]args){//定义一对线程组//主线程组,用于接受客户端的连接，但是不做任何处理，跟老板一样，不做事EventLoopGroupbossGrou
    

    • 

  • Simple RPC - 05 从零开始设计一个客户端（下）_ 依赖倒置和SPI
小小工匠
【SimpleRPC】rpc网络协议网络

    文章目录Pre概述依赖倒置原则与解耦设计与实现1.定义接口来隔离调用方与实现类2.实现类`DynamicStubFactory`3.调用方与实现类的解耦依赖注入与SPI的解耦依赖注入SPI（ServiceProviderInterface）总结PreSimpleRPC-01框架原理及总体架构初探SimpleRPC-02通用高性能序列化和反序列化设计与实现SimpleRPC-03借助Netty实现异
    

    • 

  • 使用Netty实现 WebSocket至Socket的消息转发服务
Leon-aHandler
websocket服务器网络协议nettyspringboot

    业务需求场景：通过网页发送指令至硬件设备，并在连接过程中能够接收来自硬件设备的实时参数信息中转服务器逻辑：服务器内实现了一个websocket服务端和一个socket客户端，设置全局保存的ChannelGroup进行消息的转发。项目框架使用的是Springboot代码地址：https://github.com/Leon-aHandler/Netty-relayDemo
    

    • 

  • Netty Websocket
王小工
javawebsocketjavanio

    一、WebSocket协议概述WebSocket是一种在单个TCP连接上进行全双工通信的协议。它允许服务端主动向客户端推送数据，从而实现了实时通信。WebSocket建立在HTTP之上，但与HTTP的轮询（Polling）和长轮询（LongPolling）相比，WebSocket只需一次握手，即可在客户端和服务器之间建立持久的连接，并通过这个连接进行双向数据传输。二、Netty框架简介Netty是
    

    • 

  • Netty 实现 WebSocket 协议
最业余的程序猿
nettywebsocket网络协议网络

    要使用Netty框架实现WebSocket服务端与客户端通信，你需要按照以下步骤进行：1、添加依赖首先，在你的项目中引入Netty和其WebSocket支持库的依赖。如果你使用Maven构建项目，可以在pom.xml文件中添加相应的依赖项。Maven:io.nettynetty-all4.1.77.Finalorg.springframework.bootspring-boot-starter-w
    

    • 

  • 微服务Dubbo扩展点如何做
Wade_Crab
微服务dubbo架构

    在Dubbo中，协议、序列化、负载均衡等行为是可以通过扩展点来实现和定制的。下面是几个具体的例子，展示了如何使用这些扩展点来调整Dubbo的行为。1.协议（Protocol）示例：使用不同的协议Dubbo默认使用Dubbo协议，但你可以根据需求选择其他协议，如HTTP、RMI等。默认Dubbo协议：Dubbo默认使用的协议是基于Netty的自定义协议，适合高性能RPC调用。切换到HTTP协议：如果
    

    • 

  • SpringBoot 集成 Netty 作为服务端常用 TCP/UDP 通讯协议示例
Flying9001
springboottcp/ipudp

    文章目录1摘要2通讯协议3核心代码3.1Netty服务器3.2Netty服务端工具类3.3Netty服务处理器3.4协议请求头封装类4测试4.1测试工具4.2测试数据4.2测试数据1摘要在IoT物联网设备通讯领域，服务端和设备端的通讯通常基于TCP/UDP协议，在这些协议的基础上定义自己的私有通讯协议。本文将介绍SpringBoot集成Netty在服务端常用的TCP、UDP通讯协议示例。Sprin
    

    • 

  • java源码浅析之dubbo
DaHuangXiao
随笔java

    前言最近在看RPC框架，选择先看dubbo，再看netty，最后手写一个RPC的学习路线，结合雷神关于dubbo的讲解，对源码流程进行一个简单的记录原理所谓RPC就是远程服务调用的意思，那么dubbo怎么完成远程调用的呢？原理图如下[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9fEwo2Az-1623312993257)(java源码解析之dubbo.assets
    

    • 

  • Netty核心技术及源码剖析-Netty核心模块
Shaw_Young

    Bootsrap、ServerBootstrap1、Bootsrap意思是引导,一个Netty应用通常由一个Bootsrap开始,主要作用是配置整个Netty程序,串联各个组件,Netty中Bootstrap类是客户端程序的启动引导类,ServerBootstrap是服务器端启动引导类。2、常见的方法有publicServerBootstrapgroup(EventLoopGroupparentG
    

    • 

  • netty——Channl的常用方法、ChannelFuture、CloseFuture
胡尚
java笔记服务器java网络

    文章目录ChannelChannel的常用方法ChannelFutureCloseFutureChannelChannel的常用方法close()关闭channelcloseFuture()处理关闭channel后要执行的操作sync()方法是同步等待channel的关闭addListener()方法是异步等待channel的关闭pipeline()添加处理器write()将数据写入，netty里
    

    • 

  • Netty服务器结合WebSocke协议监听和接收数据
beiback
服务器问题Java服务器运维netty

    目录1.pom依赖2.配置属性3.创建netty服务器4.建立监听和响应5.创建启动器6.前端static下页面7.前端js8.注意异常问题9.创建netty服务器--使用守护线程1.pom依赖io.nettynetty-all4.1.86.Final2.配置属性application.properties#启动端口server.port=8088server.servlet.context-pa
    

    • 

  • netty入门浅析(1)
虾餃

    笔者所有文章第一时间发布于：hhbbz的个人博客Netty的简单介绍Netty是一个NIOclient-server(客户端服务器)框架，使用Netty可以快速开发网络应用，例如服务器和客户端协议。Netty提供了一种新的方式来使开发网络应用程序，这种新的方式使得它很容易使用和有很强的扩展性。Netty的内部实现时很复杂的，但是Netty提供了简单易用的api从网络处理代码中解耦业务逻辑。Nett
    

    • 

  • VPN 在Android中的通信三 （netty DNS 域名自解析）
尚思app
android

    在使用场景中会遇到需要nettysocket的域名解析到指定IP地址，怎么做到呢，在我们的netty中，提供了DNS域名解析（DefaultNameResolver）。一、自定义类MyDefaultNameResolver继承DefaultNameResolver，实现doResolve方法，解析的相关逻辑在这里面处理publicclassMyDefaultNameResolverextendsD
    

    • 

  • Netty架构详解
思静语
Netty网络通信

    文章目录概述整体结构Netty的核心组件逻辑架构BootStrap&ServerBootStrapChannelPipelineFuture、回调和ChannelHandler选择器、事件和EventLoopChannelHandler的各种ChannelInitializer类图ProtocolSupport协议支持层TransportService传输服务层Core核心层模块netty-com
    

    • 

  • netty的TCP服务端和客户端实现
nanshaws
tcp/ipudp网络netty后端服务器

    第一步：引入依赖io.nettynetty-all4.1.90.Final第二步：实现TCP服务端packageorg.cyl.tcputils;importio.netty.bootstrap.ServerBootstrap;importio.netty.channel.ChannelFuture;importio.netty.channel.ChannelInitializer;importi
    

    • 

  • Recycler对象池原理
爱健身的兔子

    1概述为了较少对象的数量，提高内存的使用率以及GC的效率，Netty对某些经常分配的对象采用了对象池技术避免了重复的实例化对象。2Recycler的使用privatestaticfinalRecycleruserRecycler=newRecycler(){@OverrideprotectedUsernewObject(Handlehandle){returnnewUser(handle);}};
    

    • 

  • 将Spring Cloud项目改造为Spring-cloud-kubernetes项目
公众号-芋道源码
中间件javalinux数据库springboot

    点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天10:33更新文章，每天掉亿点点头发...源码精品专栏原创|Java2021超神之路，很肝~中文详细注释的开源项目RPC框架Dubbo源码解析网络应用框架Netty源码解析消息中间件RocketMQ源码解析数据库中间件Sharding-JDBC和MyCAT源码解析作业调度中间件Elastic-Job源码解析分布式事务
    

    • 

  • 从零开始学习Netty - 学习笔记 - NIO基础 - ByteBuffer: 简介和基本操作
花开十里落叶无情
nettynettynioByteBuffer

    NIO基础1.三大组件1.1.Channel&BufferChannel在JavaNIO（NewI/O）中，“Channel”（通道）是一个重要的概念，用于在非阻塞I/O操作中进行数据的传输。JavaNIO提供了一种更为灵活和高效的I/O处理方式，相比于传统的I/O，它具有更好的性能和可扩展性。常见的JavaNIO中的通道类型：FileChannel（文件通道）：用于文件I/O操作的通道，可以在文
    

    • 

  • 大厂架构师带你深入了解Netty 源码，一篇带你搞懂Netty 架构设计！
丹尼爱编程

    前言本篇文章我们就来说说Netty的架构设计，解密高并发之道。学习一个框架之前，我们首先要弄懂它的设计原理，然后再进行深层次的分析。接下来我们从三个方面来分析Netty的架构设计。Selector模型JavaNIO是基于Selector模型来实现非阻塞的I/O。Netty底层是基于JavaNIO实现的，因此也使用了Selector模型。Selector模型解决了传统的阻塞I/O编程一个客户端一个线
    

    • 

  • Spring Cloud Gateway负载均衡
shun35
负载均衡运维

    一、SpringCloudGateway我们都知道SpringCloudGateway是一个基于SpringBoot、SpringWebFlux、ProjectReactor构建的高性能网关，旨在提供简单、高效的API路由。SpringCloudGateway基于Netty运行，因此在传统Servlet容器中或者打成war包是不能正常运行的。二、SpringCloudGateway两种负载均衡器2
    

    • 

  • Redisson 如何实现分布式锁
不怕天黑_0819

    针对项目中使用的分布式锁进行简单的示例配置以及源码解析，并列举源码中使用到的一些基础知识点，但是没有对redisson中使用到的netty知识进行解析。本篇主要是对以下几个方面进行了探索Maven配置RedissonLock简单示例源码中使用到的Redis命令源码中使用到的lua脚本语义源码分析Maven配置org.redissonredisson2.2.12com.fasterxml.jacks
    

    • 

  • 【高效开发工具系列】PyCharm使用
檀越剑指大厂
s0常用工具pycharmidepython

    欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术点,如集合,jvm,并发编程redis,kafka,Spring,微服务,Netty等常用开发工具系列:罗列常用的开发工具,如IDEA,M
    

    • 

  • CIM一套完善的消息推送框架
西二旗C罗
开源框架nettyjava

    一套基于Netty的完善的消息推送框架文章目录一套基于Netty的完善的消息推送框架一、背景二、快速入门三、大致流程四、框架优势五、总结一、背景公司项目有许多需要发送即时消息的场景，之前一直采用的是传统的websocket连接，它会存在掉线严重，不可重连，不支持高并发等缺点，在这样的背景下，急需一款成熟稳定的即时通讯系统。此时发现了一个优秀的开源框架–CIM。CIM是一套基于Netty框架下的推送
    

    • 

  • Netty学习------2024/02/19
客卿123
Netty学习学习服务器网络

    non-blockingio非阻塞IO1.三大组件1.1Channel&Bufferchannel有一点类似于stream，它就是读写数据的双向通道，可以从channel将数据读入buffer，也可以将buffer的数据写入channel，而之前的stream要么是输入，要么是输出，channel比stream更为底层graphLRchannel-->bufferbuffer-->channel常
    

    • 

  • redo log —— MySQL宕机时数据不丢失的原理
天堂2013
MySQLMySQLredologjava

    扫描下方二维码或者微信搜索公众号菜鸟飞呀飞，即可关注微信公众号，阅读更多Spring源码分析、Java并发编程和Netty源码系列文章。问题在开始阅读本文之前，可以先思考一下下面两个问题。众所周知，MySQL有四大特性：ACID，其中D指的是持久性（Durability），它的含义是MySQL的事务一旦提交，它对数据库的改变是永久性的，即数据不会丢失，那么MySQL究竟是如何实现的呢？MySQL数
    

    • 

  • Netty是如何解决JDK中的Selector的bug的？
coffee_babe
NettyjavabugNetty网络

    SelectorBUG:JDKNIO的BUG,例如臭名昭著的epollbug，它会导致Selector空轮询，最终导致CPU100%,官方声称在JDK1.6版本的update18修复了该问题，但是直到JDK1.7版本该问题仍旧存在，只不过该BUG发生概率降低了一些而已，它并没有被根本解决，甚至JDK1.8的131版本中仍然存在https://bugs.java.com/bugdatabase/vi
    

    • 

  • HQL之投影查询
归来朝歌
HQLHibernate查询语句投影查询

            在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？
针对上面的场景，如果需要将一个对象查出来：
HQL语句写“from 对象”即可
Session session = HibernateUtil.openSession();

    

    • 

  • Spring整合redis
bylijinnan
redis

    pom.xml
<dependencies>
<!-- Spring Data - Redis Library -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redi
    

    • 

  • org.hibernate.NonUniqueResultException: query did not return a unique result: 2
0624chenhong
Hibernate

    参考：http://blog.csdn.net/qingfeilee/article/details/7052736
org.hibernate.NonUniqueResultException: query did not return a unique result: 2
        在项目中出现了org.hiber
    

    • 

  • android动画效果
不懂事的小屁孩
android动画

    前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。
Android 平台提供了两类动画。 一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。
第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。

    

    • 

  • js delete 删除机理以及它的内存泄露问题的解决方案
换个号韩国红果果
JavaScript

    delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露  （其实还未删除）
举例：
var person={name:{firstname:'bob'}}
var p=person.name
delete person.name
p.firstname -->'bob'
// 依然可以访问p.firstname，存在内存泄露
    

    • 

  • Oracle将零干预分析加入网络即服务计划
蓝儿唯美
oracle

    由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
    

    • 

  • spring学习——springmvc（二）
a-john
springMVC

    Spring MVC提供了非常方便的文件上传功能。
1，配置Spring支持文件上传：
DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
    

    • 

  • POJ-2828-Buy Tickets
aijuans
ACM_POJ

    POJ-2828-Buy Tickets
http://poj.org/problem?id=2828
线段树，逆序插入
#include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
    

    • 

  • Java Ant build.xml详解
asia007
build.xml

    1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台   --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
    

    • 

  • android按钮监听器的四种技术
百合不是茶
androidxml配置监听器实现接口

    android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方; 
 
1,activity中使用内部类实现接口 ,创建内部类实例  使用add方法  与java类似
 
创建监听器的实例
myLis lis = new myLis();
 
使用add方法给按钮添加监听器
 
    

    • 

  • 软件架构师不等同于资深程序员
bijian1013
程序员架构师架构设计

            本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。
        如今很多的公司
    

    • 

  • TeamForge Wiki Syntax & CollabNet User Information Center
sunjing
TeamForgeHow doAttachementAnchorWiki Syntax

    the CollabNet user information center http://help.collab.net/
 
How do I create a new Wiki page?
A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
    

    • 

  • 【Redis四】Redis数据类型
bit1129
redis

    概述
Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。
Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
    

    • 

  • SSH2整合-附源码
白糖_
eclipsespringtomcatHibernateGoogle

    今天用eclipse终于整合出了struts2+hibernate+spring框架。
我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。
 
 
补充1：项目中部分jar包不是最新版的，可能导
    

    • 

  • [转]开源项目代码的学习方法
braveCS
学习方法

    转自：
http://blog.sina.com.cn/s/blog_693458530100lk5m.html
http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html
 
1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
    

    • 

  • 编程之美-子数组的最大和（二维）
bylijinnan
编程之美

    package beautyOfCoding;
import java.util.Arrays;
import java.util.Random;
public class MaxSubArraySum2 {
/**
* 编程之美 子数组之和的最大值（二维）
*/
private static final int ROW = 5;
private stat
    

    • 

  • 读书笔记-3
chengxuyuancsdn
jquery笔记resultMap配置ibatis一对多配置

    1、resultMap配置
2、ibatis一对多配置
3、jquery笔记
1、resultMap配置
当<select resultMap="topic_data">
<resultMap id="topic_data">必须一一对应。
(1)<resultMap class="tblTopic&q
    

    • 

  • [物理与天文]物理学新进展
comsci

    
      如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境
      怎么办呢?
 
    

    • 

  • Oracle 11g新特性:Automatic Diagnostic Repository
daizj
oracleADR

    Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。
FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。
在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。
这两份log文
    

    • 

  • 简单排序:选择排序
dieslrae
选择排序

    
public void selectSort(int[] array){
int select;
for(int i=0;i<array.length;i++){
select = i;
for(int k=i+1;k<array.leng
    

    • 

  • C语言学习六指针的经典程序，互换两个数字
dcj3sjt126com
c

    示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了
# include <stdio.h>
void swap_1(int, int);
void swap_2(int *, int *);
void swap_3(int *, int *);
int main(void)
{
int a = 3;
int b = 
    

    • 

  • php 5.4中php-fpm 的重启、终止操作命令
dcj3sjt126com
PHP

    php 5.4中php-fpm 的重启、终止操作命令:
查看php运行目录命令：which php/usr/bin/php
查看php-fpm进程数：ps aux | grep -c php-fpm
查看运行内存/usr/bin/php  -i|grep mem
重启php-fpm/etc/init.d/php-fpm restart
在phpinfo()输出内容可以看到php
    

    • 

  • 线程同步工具类
shuizhaosi888
同步工具类

    同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）
 
闭锁（CountDownLatch）
public class RunMain {
public long timeTasks(int nThreads, final Runnable task) throws InterruptedException {
fin
    

    • 

  • bleeding edge是什么意思
haojinghua
DI

    不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。 
我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。
 
In computer science, bleeding edge is a term that 
    

    • 

  • c中实现utf8和gbk的互转
jimmee
ciconvutf8&gbk编码

    #include <iconv.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
int code_c
    

    • 

  • 大型分布式网站架构设计与实践
lilin530
应用服务器搜索引擎

    1.大型网站软件系统的特点？
a.高并发，大流量。
b.高可用。
c.海量数据。
d.用户分布广泛，网络情况复杂。
e.安全环境恶劣。
f.需求快速变更，发布频繁。
g.渐进式发展。
2.大型网站架构演化发展历程？
a.初始阶段的网站架构。
应用程序，数据库，文件等所有的资源都在一台服务器上。
b.应用服务器和数据服务器分离。
c.使用缓存改善网站性能。
d.使用应用
    

    • 

  • 在代码中获取Android theme中的attr属性值
OliveExcel
androidtheme

    Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西.
 
在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则:
int defaultColor = 0xFF000000;
int[] attrsArray = { andorid.r.
    

    • 

  • 基于Zookeeper的分布式共享锁
roadrunners
zookeeper分布式共享锁

    首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。
 
共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。
 
官
    

    • 

  • 两个容易被忽略的MySQL知识
tomcat_oracle
mysql

    1、varchar(5)可以存储多少个汉字，多少个字母数字？ 　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。 　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
    

    • 

  • zoj 3827 Information Entropy(水题)
阿尔萨斯
format

     题目链接：zoj 3827 Information Entropy
题目大意：三种底，计算和。
解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。
#include <cstdio>
#include <cstring>
#include <cmath&
    

    •