springboot框架嵌入netty

1.pom.xml添加依赖

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>5.0.0.Alpha2</version>
</dependency>

2.application.properties集成netty

tcp.port=8081
boss.thread.count=200
worker.thread.count=200
so.keepalive=true
so.backlog=100

3.Configuration类

 package com.adc.config;
 import java.net.InetSocketAddress;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;  

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

 import com.adc.netty.StringProtocolInitalizer;

 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.handler.codec.string.StringDecoder;
 import io.netty.handler.codec.string.StringEncoder;
 @Configuration
 public class NettyConfig {
     @Value("${boss.thread.count}")
     private int bossCount;  

     @Value("${worker.thread.count}")
     private int workerCount;  

     @Value("${tcp.port}")
     private int tcpPort;  

     @Value("${so.keepalive}")
     private boolean keepAlive;  

     @Value("${so.backlog}")
     private int backlog;
     @Autowired
     @Qualifier("springProtocolInitializer")
     private StringProtocolInitalizer protocolInitalizer;  

     @SuppressWarnings("unchecked")
     @Bean(name = "serverBootstrap")
     public ServerBootstrap bootstrap() {
         ServerBootstrap b = new ServerBootstrap();
         b.group(bossGroup(), workerGroup())
                 .channel(NioServerSocketChannel.class)
                 .childHandler(protocolInitalizer);
         Map<ChannelOption<?>, Object> tcpChannelOptions = tcpChannelOptions();
         Set<ChannelOption<?>> keySet = tcpChannelOptions.keySet();
         for (@SuppressWarnings("rawtypes")
         ChannelOption option : keySet) {
             b.option(option, tcpChannelOptions.get(option));
         }
         return b;
     }  

     @Bean(name = "bossGroup", destroyMethod = "shutdownGracefully")
     public NioEventLoopGroup bossGroup() {
         return new NioEventLoopGroup(bossCount);
     }  

     @Bean(name = "workerGroup", destroyMethod = "shutdownGracefully")
     public NioEventLoopGroup workerGroup() {
         return new NioEventLoopGroup(workerCount);
     }
     @Bean(name = "tcpSocketAddress")
     public InetSocketAddress tcpPort() {
         return new InetSocketAddress(tcpPort);
     }  

     @Bean(name = "tcpChannelOptions")
     public Map<ChannelOption<?>, Object> tcpChannelOptions() {
         Map<ChannelOption<?>, Object> options = new HashMap<ChannelOption<?>, Object>();
         options.put(ChannelOption.SO_KEEPALIVE, keepAlive);
         options.put(ChannelOption.SO_BACKLOG, backlog);
         return options;
     }  

     @Bean(name = "stringEncoder")
     public StringEncoder stringEncoder() {
         return new StringEncoder();
     }  

     @Bean(name = "stringDecoder")
     public StringDecoder stringDecoder() {
         return new StringDecoder();
     }  

     /**
      * Necessary to make the Value annotations work.
      *
      * @return
      */
     @Bean
     public static PropertySourcesPlaceholderConfigurer propertyPlaceholderConfigurer() {
         return new PropertySourcesPlaceholderConfigurer();
     }
 }

4.初始化类

package com.adc.netty;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;  

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;  

/**
 * Just a dummy protocol mainly to show the ServerBootstrap being initialized.
 *
 * @author Abraham Menacherry
 *
 */
@Component
@Qualifier("springProtocolInitializer")
public class StringProtocolInitalizer extends ChannelInitializer<SocketChannel> {  

    @Autowired
    StringDecoder stringDecoder;  

    @Autowired
    StringEncoder stringEncoder;  

    @Autowired
    ServerHandler serverHandler;  

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast("decoder", stringDecoder);
        pipeline.addLast("handler", serverHandler);
        pipeline.addLast("encoder", stringEncoder);
    }  

    public StringDecoder getStringDecoder() {
        return stringDecoder;
    }  

    public void setStringDecoder(StringDecoder stringDecoder) {
        this.stringDecoder = stringDecoder;
    }  

    public StringEncoder getStringEncoder() {
        return stringEncoder;
    }  

    public void setStringEncoder(StringEncoder stringEncoder) {
        this.stringEncoder = stringEncoder;
    }  

    public ServerHandler getServerHandler() {
        return serverHandler;
    }  

    public void setServerHandler(ServerHandler serverHandler) {
        this.serverHandler = serverHandler;
    }  

}  

5.逻辑处理类

 package com.adc.netty;

 import java.util.List;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Component;

 import com.adc.pojo.TsOrder;
 import com.adc.pojo.TsStation;
 import com.adc.pojo.TsUser;
 import com.adc.service.TsCarService;
 import com.adc.service.TsOrderService;
 import com.adc.service.TsStationService;
 import com.adc.service.TsUserService;

 import io.netty.channel.ChannelHandler.Sharable;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;  

 @Component
 @Qualifier("serverHandler")
 @Sharable
 public class ServerHandler extends SimpleChannelInboundHandler<String> {  

     private static final Logger log = LoggerFactory.getLogger(ServerHandler.class);
     @Autowired
     TsCarService carService;
     @Autowired
     TsUserService userService;
     @Autowired
     TsOrderService orderService;
     @Autowired
     TsStationService stationService;

     @Override
     public void messageReceived(ChannelHandlerContext ctx, String msg)
             throws Exception {
         log.info("client msg:"+msg);
 //添加处理请求的逻辑
     }
     @Override
     public void channelActive(ChannelHandlerContext ctx) throws Exception {  

         log.info("RamoteAddress : " + ctx.channel().remoteAddress() + " active !");  

 //        ctx.channel().writeAndFlush( "Welcome to " + InetAddress.getLocalHost().getHostName() + " service!\n");
         ctx.channel().writeAndFlush("connect success");

         super.channelActive(ctx);
     }  

     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
         cause.printStackTrace();
 //        System.out.println(cause.getMessage());
         ctx.close();
     }  

     @Override
     public void channelInactive(ChannelHandlerContext ctx) throws Exception {
         log.info("\nChannel is disconnected");
         super.channelInactive(ctx);
     }  

     private double getdistance(double lat1,double lon1,double lat2,double lon2) {
         float earth_radius=6378.137f;
         double a=Math.toRadians(lat1)-Math.toRadians(lat2);
         double b=Math.toRadians(lon1)-Math.toRadians(lon2);
         double distance=2*Math.asin(Math.sqrt(Math.pow(Math.sin(a/2), 2)+Math.cos(Math.toRadians(lat1))*Math.cos(Math.toRadians(lat2))*Math.pow(Math.sin(b/2), 2)))
                 *earth_radius;
         return distance;
     }
 }