Spring和Netty整合详解

柔光的暖阳◎ 2022-01-26 06:37 523阅读 0赞

## Spring和Netty整合详解 ##

本篇主要介绍netty如何跟Spring配合，其实真的很没必要将netty和Spring牵扯在一起，我们完全可以用netty做出一个spring的；然而在[《Spring环境下使用Netty写Socket和Http详解》][Spring_Netty_Socket_Http]一篇中，因为没怎么用到Spring，遭到部分网友质疑，因此这一篇着重介绍如何跟Spring做配合。

### 官方主页 ###

[Spring][]

[Netty][]

### 一、概述 ###

Netty是目前最流行的由JBOSS提供的一个Java开源框架NIO框架，Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。

相比JDK原生NIO，Netty提供了相对十分简单易用的API，非常适合网络编程。Netty是完全基于NIO实现的，所以Netty是异步的。

Mina同样也是一款优秀的NIO框架，而且跟Netty是出自同一个人之手，但是Netty要晚一点，优点更多一些，想了解更多可以直接搜索mina和netty比较。

使用Netty，我们可以作为Socket服务器，也可以用来做Http服务器，这里，我们将这两种方式都详细介绍一下。

Git地址：  
[Gitee][]

首发地址：  
[品茗IT-首发][IT-]

[品茗IT][IT] 提供在线支持：

[一键快速构建Spring项目工具][Spring 1]

[一键快速构建SpringBoot项目工具][SpringBoot]

[一键快速构建SpringCloud项目工具][SpringCloud]

[一站式Springboot项目生成][Springboot]

**如果大家正在寻找一个java的学习环境，或者在开发中遇到困难，可以[加入我们的java学习圈，点击即可加入][java]，共同学习，节约学习时间，减少很多在学习中遇到的难题。**

### 二、依赖Jar包 ###

本文假设你已经引入Spring必备的一切了，已经是个Spring mvc项目了,如果不会搭建，可以打开这篇文章看一看[《Spring和Spring Mvc 5整合详解》][Spring_Spring Mvc 5]。

我们假定你已经建好了Spring环境。这里只引入Netty的jar包。

<dependency>
    	<groupId>io.netty</groupId>
    	<artifactId>netty-all</artifactId>
    	<version>4.1.17.Final</version>
    </dependency>

完整依赖：

<?xml version="1.0"?>
    <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>cn.pomit</groupId>
    		<artifactId>SpringWork</artifactId>
    		<version>0.0.1-SNAPSHOT</version>
    	</parent>
    	<artifactId>Netty</artifactId>
    	<packaging>jar</packaging>
    	<name>Netty</name>
    	<url>http://maven.apache.org</url>
    	<dependencies>
    		<dependency>
    			<groupId>io.netty</groupId>
    			<artifactId>netty-all</artifactId>
    			<version>4.1.17.Final</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    		</dependency>
    	</dependencies>
    	<build>
    		<finalName>Netty</finalName>
    	</build>
    </project>

父pom管理了所有依赖jar包的版本，地址：  
[https://www.pomit.cn/spring/SpringWork/pom.xml][https_www.pomit.cn_spring_SpringWork_pom.xml]

### 三、Netty服务器配置 ###

我们写一个tcp的server，作为线程运行。

NettyServer ：

package cn.pomit.springwork.netty.server;
    
    
    import org.springframework.beans.factory.annotation.Autowired;
    
    import cn.pomit.springwork.netty.config.NettyServerInitializer;
    import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.Channel;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.nio.NioServerSocketChannel;
    
    public class NettyServer implements Runnable { 
    	private int port;
    	private Channel channel;
    	private EventLoopGroup bossGroup;
    	private EventLoopGroup workerGroup;
    	private Thread nserver;
    	@Autowired
    	NettyServerInitializer nettyServerInitializer;
    
    	public void init() { 
    		nserver = new Thread(this);
        	nserver.start();
    	}
    
    	public void destory() { 
    		System.out.println("destroy server resources");
    		if (null == channel) { 
    			System.out.println("server channel is null");
    		}
    		bossGroup.shutdownGracefully();
    		workerGroup.shutdownGracefully();
    		channel.closeFuture().syncUninterruptibly();
    		bossGroup = null;
    		workerGroup = null;
    		channel = null;
    	}
    
    	public int getPort() { 
    		return port;
    	}
    
    	public void setPort(int port) { 
    		this.port = port;
    	}
    
    	@Override
    	public void run() { 
    		bossGroup = new NioEventLoopGroup();
    		workerGroup = new NioEventLoopGroup();
    		System.out.println(Thread.currentThread().getName() + "----位置4");
    		try { 
    			ServerBootstrap b = new ServerBootstrap();
    			b.group(bossGroup, workerGroup);
    			b.channel(NioServerSocketChannel.class);
    			b.childHandler(nettyServerInitializer);
    
    			// 服务器绑定端口监听
    			ChannelFuture f = b.bind(port).sync();
    			// 监听服务器关闭监听
    			f.channel().closeFuture().sync();
    			channel = f.channel();
    			// 可以简写为
    			/* b.bind(portNumber).sync().channel().closeFuture().sync(); */
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		} finally { 
    			bossGroup.shutdownGracefully();
    			workerGroup.shutdownGracefully();
    		}
    	}
    
    }

代码贴出来之后，我们还是要讲下里面的一些重点：

bossGroup和workerGroup就是为了建立线程池，这个自行百度。

以上使用了

f.channel().closeFuture().sync();

这部分代码是阻塞了当前主线程一直等待结束，后面的代码就不能执行了。

两次sync的不同：两次sync虽然都是针对ChannelFuture的，但是两次的ChannelFuture不一样，  
原理就不细说了，我也不知道，毕竟不是专精这方面的。sync换成await是一样的。

这里面NettyServerInitializer使用Spring的bean注入功能。

### 四、启动Server ###

启动NettyServer。

#### 4.1 Spring的xml配置 ####

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p" xmlns:cache="http://www.springframework.org/schema/cache" xmlns:jms="http://www.springframework.org/schema/jms" xmlns:jaxws="http://cxf.apache.org/jaxws" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.0.xsd http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-4.0.xsd http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd ">
    
    	<context:annotation-config />
    	<context:component-scan base-package="cn.pomit.springwork">
    	</context:component-scan>
    	
    	<bean id="annotationPropertyConfigurerNetty" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    		<property name="order" value="1" />
    		<property name="ignoreUnresolvablePlaceholders" value="true" />
    		<property name="locations">
    			<list>
    				<value>classpath:netty.properties</value>
    			</list>
    		</property>
    	</bean>
    	
    	<bean id="nettyDemoServer" class="cn.pomit.springwork.netty.server.NettyServer" init-method="init" destroy-method="destory">
    		<property name="port" value="${netty_port}" />
    	</bean>
    	
    	<bean id="closeFutureHandler" class="cn.pomit.springwork.netty.handler.CloseFutureHandler">
    		<property name="nextHandler"><null/></property>
    	</bean>
    	
    	<bean id="exceptionFutureHandler" class="cn.pomit.springwork.netty.handler.ExceptionFutureHandler">
    		<property name="nextHandler"><null/></property>
    	</bean>
    	
    	<bean id="bussinessFutureHandler" class="cn.pomit.springwork.netty.handler.BussinessFutureHandler">
    		<property name="nextHandler"><null/></property>
    	</bean>
    
    </beans>

配置文件netty.properties：

netty_port=4444

#### 4.2 注解启动 ####

只是@Service注解和@PostConstruct注解的运用而已。

package cn.pomit.springwork.netty.server;
    
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import cn.pomit.springwork.netty.config.NettyServerInitializer;
    import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.Channel;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.nio.NioServerSocketChannel;
    
    @Service
    public class NettyServer implements Runnable { 
    	private int port;
    	private Channel channel;
    	private EventLoopGroup bossGroup;
    	private EventLoopGroup workerGroup;
    	private Thread nserver;
    	@Autowired
    	NettyServerInitializer nettyServerInitializer;
    
    	@PostConstruct
    	public void init() { 
    		nserver = new Thread(this);
        	nserver.start();
    	}
    
    	@PreDestroy
    	public void destory() { 
    		System.out.println("destroy server resources");
    		if (null == channel) { 
    			System.out.println("server channel is null");
    		}
    		bossGroup.shutdownGracefully();
    		workerGroup.shutdownGracefully();
    		channel.closeFuture().syncUninterruptibly();
    		bossGroup = null;
    		workerGroup = null;
    		channel = null;
    	}
    
    	public int getPort() { 
    		return port;
    	}
    
    	public void setPort(int port) { 
    		this.port = port;
    	}
    
    	@Override
    	public void run() { 
    		bossGroup = new NioEventLoopGroup();
    		workerGroup = new NioEventLoopGroup();
    		System.out.println(Thread.currentThread().getName() + "----位置4");
    		try { 
    			ServerBootstrap b = new ServerBootstrap();
    			b.group(bossGroup, workerGroup);
    			b.channel(NioServerSocketChannel.class);
    			b.childHandler(nettyServerInitializer);
    
    			// 服务器绑定端口监听
    			ChannelFuture f = b.bind(port).sync();
    			// 监听服务器关闭监听
    			f.channel().closeFuture().sync();
    			channel = f.channel();
    			// 可以简写为
    			/* b.bind(portNumber).sync().channel().closeFuture().sync(); */
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		} finally { 
    			bossGroup.shutdownGracefully();
    			workerGroup.shutdownGracefully();
    		}
    	}
    
    }

### 五、NettyServerInitializer ###

NettyServerInitializer是对NettyServer的handler初始化配置。可以作为Spring的bean处理，所以这里用了@Component将NettyServerInitializer声明为Spring的bean.

NettyServerInitializer:

package cn.pomit.springwork.netty.config;
    
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelPipeline;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.handler.codec.DelimiterBasedFrameDecoder;
    import io.netty.handler.codec.Delimiters;
    import io.netty.handler.codec.string.StringDecoder;
    import io.netty.handler.codec.string.StringEncoder;
    
    @Component
    public class NettyServerInitializer extends ChannelInitializer<SocketChannel> { 
    	@Autowired
    	NettyServerHandler nettyServerHandler;
    
    	@Override
    	protected void initChannel(SocketChannel ch) throws Exception { 
    		ChannelPipeline pipeline = ch.pipeline();
    
    		// 以("\n")为结尾分割的 解码器
    		pipeline.addLast("framer", new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
    
    		// 字符串解码 和 编码
    		pipeline.addLast("decoder", new StringDecoder());
    		pipeline.addLast("encoder", new StringEncoder());
    		System.out.println(Thread.currentThread().getName() + "----位置5");
    		// 自己的逻辑Handler
    		pipeline.addLast("handler", nettyServerHandler);
    	}
    }

### 六、Netty的共享ChannelHandler ###

netty的ChannelHandler是不能共享的。是一个线程一个的，如果之间将ChannelHandler作为Spring的bean管理，是会报错的。

因此，需要用@Sharable注解对ChannelHandler做声明，然后再由Spring进行管理。

NettyServerHandler：

package cn.pomit.springwork.netty.config;
    
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Component;
    
    import cn.pomit.springwork.netty.handler.Handler;
    import io.netty.channel.ChannelHandler.Sharable;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.SimpleChannelInboundHandler;
    
    @Component
    @Sharable
    public class NettyServerHandler extends SimpleChannelInboundHandler<String>{ 
    	@Autowired(required = false)
    	@Qualifier("closeFutureHandler")
    	public Handler closeFutureHandler;
    	@Autowired(required = false)
    	@Qualifier("exceptionFutureHandler")
    	public Handler exceptionFutureHandler;
    	@Autowired
    	@Qualifier("bussinessFutureHandler")
    	public Handler bussinessFutureHandler;
    	
    	@Override
    	protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception { 		
    // System.out.println(((HandlerServiceImp) exportServiceMap.get("helloWorldService")).test());
    // // 返回客户端消息 - 我已经接收到了你的消息
    		System.out.println(Thread.currentThread().getName()+"----位置6");
    // handlerService.handle(msg);
    		String retMsg = bussinessFutureHandler.hander(msg);
    		ctx.writeAndFlush(retMsg);
    
    	}
    
    	@Override
    	public void channelRegistered(ChannelHandlerContext ctx) throws Exception { 
    		System.out.println(ctx.channel().remoteAddress() + " channelRegistered " );
    		super.channelRegistered(ctx);
    	}
    
    	@Override
    	public void channelUnregistered(ChannelHandlerContext ctx) throws Exception { 
    		System.out.println(ctx.channel().remoteAddress() + " channelUnregistered " );
    		super.channelUnregistered(ctx);
    		if(closeFutureHandler !=null){ 
    			closeFutureHandler.hander(ctx.name());
    		}
    	}
    
    	@Override
    	public void channelActive(ChannelHandlerContext ctx) throws Exception { 
    		System.out.println(ctx.channel().remoteAddress() + " channelActive " );
    		super.channelActive(ctx);
    	}
    
    	@Override
    	public void channelInactive(ChannelHandlerContext ctx) throws Exception { 
    		System.out.println(ctx.channel().remoteAddress() + " channelInactive " );
    		super.channelInactive(ctx);
    	}
    
    	@Override
    	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
    		System.out.println(ctx.channel().remoteAddress() + " exceptionCaught :" + cause.getMessage() );
    		super.exceptionCaught(ctx, cause);
    		if(exceptionFutureHandler !=null){ 
    			exceptionFutureHandler.hander(cause.getMessage());
    		}
    	}
    
    }

这里面使用了上面xml中定义的三个业务处理Handler。

### 七、业务Handler ###

#### 7.1 Handler接口 ####

Handler ：

package cn.pomit.springwork.netty.handler;
    
    
    public interface Handler { 
    	public static String COMMONRET="200";
    	public String hander(String msg);
    }

#### 7.2 BussinessFutureHandler ####

BussinessFutureHandler：

package cn.pomit.springwork.netty.handler;
    
    public class BussinessFutureHandler implements Handler { 
    	private Handler nextHandler;
    
    	public Handler getNextHandler() { 
    		return nextHandler;
    	}
    
    	public void setNextHandler(Handler nextHandler) { 
    		this.nextHandler = nextHandler;
    	}
    
    	@Override
    	public String hander(String msg) { 
    		System.out.println("接收到信息：" + msg);
    		if (nextHandler != null) { 
    			nextHandler.hander(msg);
    		}
    		return msg;
    	}
    
    }

#### 7.3 CloseFutureHandler ####

CloseFutureHandler：

package cn.pomit.springwork.netty.handler;
    
    public class CloseFutureHandler implements Handler { 
    	private Handler nextHandler;
    
    	public Handler getNextHandler() { 
    		return nextHandler;
    	}
    
    	public void setNextHandler(Handler nextHandler) { 
    		this.nextHandler = nextHandler;
    	}
    
    	@Override
    	public String hander(String msg) { 
    		System.out.println(msg + "正在关闭。");
    		if (nextHandler != null) { 
    			nextHandler.hander(msg);
    		}
    		return COMMONRET;
    	}
    
    }

#### 7.4 ExceptionFutureHandler ####

ExceptionFutureHandler：

package cn.pomit.springwork.netty.handler;
    
    public class ExceptionFutureHandler implements Handler { 
    	private Handler nextHandler;
    
    	public Handler getNextHandler() { 
    		return nextHandler;
    	}
    
    	public void setNextHandler(Handler nextHandler) { 
    		this.nextHandler = nextHandler;
    	}
    
    	@Override
    	public String hander(String msg) { 
    		System.out.println("出现异常，异常信息：" + msg);
    		if (nextHandler != null) { 
    			nextHandler.hander(msg);
    		}
    		
    		return COMMONRET;
    	}
    
    }

至此，Spring整合netty简单的处理方式就完成了。

### 快速构建项目 ###

[Spring组件化构建][Spring 1]

喜欢这篇文章么，喜欢就加入我们一起讨论Spring技术吧！  
![品茗IT交流群][IT 1]

[Spring_Netty_Socket_Http]: https://www.pomit.cn/p/178578591678720
[Spring]: https://docs.spring.io/spring/docs/5.0.12.RELEASE/spring-framework-reference/core.html#spring-core
[Netty]: https://netty.io/wiki/index.html
[Gitee]: https://gitee.com/ffch/SpringMvcWork/tree/master/Netty
[IT-]: https://www.pomit.cn/p/181396574224640
[IT]: https://www.pomit.cn
[Spring 1]: https://www.pomit.cn/java/spring/spring.html
[SpringBoot]: https://www.pomit.cn/java/spring/springboot.html
[SpringCloud]: https://www.pomit.cn/java/spring/springcloud.html
[Springboot]: https://www.pomit.cn/java/java/sqlToSpringboot.html
[java]: https://jq.qq.com/?_wv=1027&k=52sgH1J
[Spring_Spring Mvc 5]: https://www.pomit.cn/p/181499739820288
[https_www.pomit.cn_spring_SpringWork_pom.xml]: https://www.pomit.cn/spring/SpringWork/pom.xml
[IT 1]: /images/20220126/1b68d78a7e214ed59079bc2643c8de72.png