基于netty的tcp框架搭建-面向接口编程之多类型netty服务

面向接口编程之多类型netty服务

面向接口编程

面向接口编程有不少优点
1、降低耦合度，不同的实现类之间基本没有关联
2、利于扩展，在不改变原有代码情况下，扩展只需实现新的实现类
3、便于程序维护
4、遵循设计模式开闭原则，即，面向扩展开放，面向修改关闭

业务说明

netty提供多种不同服务启动类型，比如基于nio的服务，linux系统下基于Epoll的服务，基于http协议的服务等，根据使用场景的不同，需要选择不同的服务，才能取得最佳效果。

代码

首先，先看下接口 NettyServer
抽象出三个方法，分别是初始化，启动，关闭

package com.commuli.tcp.netty.server;

/**
 * @author commuli
 * @date 2019/4/24
 */

public interface NettyServer {


    void init() throws Exception;

    void start() throws Exception;

    void close();


}

抽象父类，AbstractNettyServer 实现接口 NettyServer
使用抽象父类，实现各子类冗余的方法

package com.commuli.tcp.netty.server;

import com.commuli.core.common.utils.ClassUtil;
import com.commuli.tcp.netty.annotation.InHandler;
import com.commuli.tcp.netty.annotation.OutHandler;
import com.commuli.tcp.netty.config.NettyServerConfig;
import com.commuli.tcp.netty.constant.NettyConstant;
import com.commuli.tcp.netty.handler.TimeoutHandler;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.handler.timeout.IdleStateHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

/**
 * @author commuli
 * @date 2019/4/24
 */
public abstract class AbstractNettyServer implements NettyServer {
    private static final Logger LOGGER = LoggerFactory.getLogger(AbstractNettyServer.class);
    public EventLoopGroup bossGroup;
    public EventLoopGroup workerGroup;
    private final List<Map<String, Object>> inHandlers = new ArrayList<>();
    private final List<Map<String, Object>> outHandlers = new ArrayList<>();
    /**
     * 服务关闭后释放资源
     *
     * @param
     * @return void
     * @author commuli
     * @date 2019/4/24
     */
    abstract void release();


    @Override
    public void start() throws Exception {
        init();
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                LOGGER.info("server be stoped, version 0.1-SNAPSHOT");
                close();
            }
        });
    }

    @Override
    public void close() {
        if (workerGroup == null) {
            throw new IllegalStateException("Invoked close on an Acceptor that wasn't initialized");
        }
        if (bossGroup == null) {
            throw new IllegalStateException("Invoked close on an Acceptor that wasn't initialized");
        }
        workerGroup.shutdownGracefully();
        bossGroup.shutdownGracefully();
        release();
    }

    /**
     * 自定义注解实现自动绑定handler
     *
     * @param pipeline
     * @return void
     * @author commuli
     * @date 2019/4/24
     */
    public void bindChildHandler(final ChannelPipeline pipeline) {
        pipeline.addFirst("idleStateHandler", new IdleStateHandler(0, 0, NettyServerConfig.getNettyServerSocketTimeout()));
        pipeline.addAfter("idleStateHandler", "idleEventHandler", new TimeoutHandler());
        if (inHandlers.isEmpty() && outHandlers.isEmpty()) {
            //直接添加
            try {
                //通过注解获取所有的handle
                List<Class<?>> classes = ClassUtil.getClasses(NettyConstant.HANDLER_PACKAGE_NAME + "." + NettyServerConfig.getNettyServerHandler());
                //遍历获取所有Inhandle
                if (classes != null && !classes.isEmpty()) {
                    for (Class<?> cls : classes) {
                        boolean isSharable = false;
                        ChannelHandler.Sharable sharable = cls.getAnnotation(ChannelHandler.Sharable.class);
                        if (sharable != null) {
                            isSharable = true;
                        }
                        InHandler inAnnotation = cls.getAnnotation(InHandler.class);
                        if (inAnnotation != null) {
                            Map<String, Object> inMap = new HashMap<>();
                            //判断当前类是否携带注解
                            inMap.put("name", inAnnotation.name());
                            inMap.put("order", inAnnotation.order());
                            inMap.put("obj", cls.newInstance());
                            inMap.put("cls", cls);
                            if (isSharable) {
                                inMap.put("sharable", true);
                            } else {
                                inMap.put("sharable", false);
                            }
                            inHandlers.add(inMap);
                            continue;
                        }
                        OutHandler outAnnotation = cls.getAnnotation(OutHandler.class);
                        if (outAnnotation != null) {
                            Map<String, Object> outMap = new HashMap<>();
                            outMap.put("name", outAnnotation.name());
                            outMap.put("order", outAnnotation.order());
                            outMap.put("obj", cls.newInstance());
                            outMap.put("cls", cls);
                            if (isSharable) {
                                outMap.put("sharable", true);
                            } else {
                                outMap.put("sharable", false);
                            }
                            outHandlers.add(outMap);
                            continue;
                        }


                    }
                    listSort(inHandlers, 1);
                    listSort(outHandlers, 2);
                    //根据order排序
                }
            } catch (Exception e) {
                LOGGER.error("pipeline add  handler error {}", e);
            }
        }
        pipelineAddHandler(inHandlers, pipeline);
        pipelineAddHandler(outHandlers, pipeline);
    }

    private void pipelineAddHandler(List<Map<String, Object>> list, ChannelPipeline pipeline) {
        if (!list.isEmpty()) {
            // 遍历
            for (Map<String, Object> m : list) {
                if ((boolean) m.get("sharable")) {
                    //绑定到
                    pipeline.addLast(m.get("name").toString(), (ChannelHandler) m.get("obj"));
                } else {
                    try {
                        pipeline.addLast(m.get("name").toString(), ((Class<ChannelHandler>) m.get("cls")).newInstance());
                    } catch (Exception e) {
                        LOGGER.error("初始化handler异常：{}", e);
                    }
                }

            }
        }
    }


    private void listSort(List<Map<String, Object>> list, final int type) {
        Collections.sort(list, (Map<String, Object> o1, Map<String, Object> o2) -> {
            try {
                int order1 = Integer.parseInt(o1.get("order").toString());
                int order2 = Integer.parseInt(o2.get("order").toString());
                if (type == 1) {

                    if (order1 > order2) {
                        return 1;
                    } else if (order1 < order2) {
                        return -1;
                    } else {
                        return 0;
                    }
                } else {
                    if (order1 > order2) {
                        return -1;
                    } else if (order1 < order2) {
                        return 1;
                    } else {
                        return 0;
                    }
                }
            } catch (Exception e) {
                LOGGER.error("注解数据排序error{}", e);
            }
            return 0;
        });
    }

}

基于Nio的netty服务 NettyNioServer

package com.commuli.tcp.netty.server;

import com.commuli.core.common.thread.NamedThreadFactory;
import com.commuli.tcp.netty.config.NettyServerConfig;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author commuli
 * @date 2019/4/24
 */
public class NettyNioServer extends AbstractNettyServer {
    private static final Logger LOGGER = LoggerFactory.getLogger(NettyNioServer.class);

    @Override
    public void init() throws Exception {
        LOGGER.info("init nio netty server");
        bossGroup = new NioEventLoopGroup(NettyServerConfig.getBossGroupSize(), new NamedThreadFactory("netty_boss"));
        workerGroup = new NioEventLoopGroup(NettyServerConfig.getWorkGroupSize(), new NamedThreadFactory("netty_worker"));
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup);
        b.channel(NioServerSocketChannel.class);
        b.childHandler(new ChannelInitializer<NioSocketChannel>() {
            @Override
            public void initChannel(NioSocketChannel ch) {
                bindChildHandler(ch.pipeline());
            }
        });
        b.option(ChannelOption.SO_BACKLOG, NettyServerConfig.getChannelOptionSoBacklog());
        b.option(ChannelOption.SO_REUSEADDR, NettyServerConfig.getChannelOptionSoReuseaddr());
        b.childOption(ChannelOption.SO_KEEPALIVE, NettyServerConfig.getChannelOptionSoKeepalive());
        try {
            ChannelFuture f = b.bind(NettyServerConfig.getNettyServerHost(), NettyServerConfig.getNettyServerPort());
            f.sync();
        } catch (Exception e) {
            LOGGER.error("init nio netty server error", e);
        }
    }

    @Override
    void release() {

    }
}

基于Epoll的netty服务

package com.commuli.tcp.netty.server;

import com.commuli.core.common.thread.NamedThreadFactory;
import com.commuli.tcp.netty.config.NettyServerConfig;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.epoll.EpollChannelOption;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.epoll.EpollServerSocketChannel;
import io.netty.channel.epoll.EpollSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author commuli
 * @date 2019/4/24
 */
public class NettyEpollServer extends AbstractNettyServer {
    private static final Logger LOGGER = LoggerFactory.getLogger(NettyEpollServer.class);

    @Override
    public void init() throws Exception {
        LOGGER.info("init epoll netty server");
        bossGroup = new EpollEventLoopGroup(NettyServerConfig.getBossGroupSize(), new NamedThreadFactory("netty_boss"));
        workerGroup = new EpollEventLoopGroup(NettyServerConfig.getWorkGroupSize(), new NamedThreadFactory("netty_worker"));
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup);
        b.channel(EpollServerSocketChannel.class);
        b.childHandler(new ChannelInitializer<EpollSocketChannel>() {
            @Override
            public void initChannel(EpollSocketChannel ch) {
                bindChildHandler(ch.pipeline());
            }
        });
        b.option(EpollChannelOption.SO_BACKLOG, NettyServerConfig.getChannelOptionSoBacklog());
        b.option(EpollChannelOption.SO_REUSEADDR, NettyServerConfig.getChannelOptionSoReuseaddr());
        b.childOption(EpollChannelOption.SO_KEEPALIVE, NettyServerConfig.getChannelOptionSoKeepalive());
        try {
            ChannelFuture f = b.bind(NettyServerConfig.getNettyServerHost(), NettyServerConfig.getNettyServerPort());
            f.sync();
        } catch (Exception e) {
            LOGGER.error("init epoll netty server error", e);
        }
    }

    @Override
    void release() {

    }


}

netty还支持多种类型服务，有兴趣的可以查阅资料自己尝试。