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;
    }
}