前言
netty 是一个高性能的 nio 网络框架,本文主要给大家介绍了关于springboot集成netty实现客户端服务端交互的相关内容,下面来一起看看详细的介绍吧
看了好几天的netty实战,慢慢摸索,虽然还没有摸着很多门道,但今天还是把之前想加入到项目里的
一些想法实现了,算是有点信心了吧(讲真netty对初学者还真的不是很友好......)
首先,当然是在springboot项目里添加netty的依赖了,注意不要用netty5的依赖,因为已经废弃了
1
2
3
4
5
6
|
<!--netty--> <dependency> <groupid>io.netty</groupid> <artifactid>netty-all</artifactid> <version> 4.1 . 32 . final </version> </dependency> |
将端口和ip写入application.yml文件里,我这里是我云服务器的内网ip,如果是本机测试,用127.0.0.1就ok
1
2
3
|
netty: port: 7000 url: 172.16 . 0.7 |
在这之后,开始写netty的服务器,这里服务端的逻辑就是将客户端发来的信息返回回去
因为采用依赖注入的方法实例化netty,所以加上@component注释
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
package com.safelocate.app.nettyserver; import io.netty.bootstrap.serverbootstrap; import io.netty.channel.*; import io.netty.channel.nio.nioeventloopgroup; import io.netty.channel.socket.nio.nioserversocketchannel; import org.apache.log4j.logger; import org.springframework.stereotype.component; import java.net.inetsocketaddress; @component public class nettyserver { //logger private static final logger logger = logger.getlogger(nettyserver. class ); public void start(inetsocketaddress address){ eventloopgroup bossgroup = new nioeventloopgroup( 1 ); eventloopgroup workergroup = new nioeventloopgroup(); try { serverbootstrap bootstrap = new serverbootstrap() .group(bossgroup,workergroup) .channel(nioserversocketchannel. class ) .localaddress(address) .childhandler( new serverchannelinitializer()) .option(channeloption.so_backlog, 128 ) .childoption(channeloption.so_keepalive, true ); // 绑定端口,开始接收进来的连接 channelfuture future = bootstrap.bind(address).sync(); logger.info( "server start listen at " + address.getport()); future.channel().closefuture().sync(); } catch (exception e) { e.printstacktrace(); bossgroup.shutdowngracefully(); workergroup.shutdowngracefully(); } } } |
当然,这里的serverchannelinitializer是我自己定义的类,这个类是继承channelinitializer<socketchannel>的,里面设置出站和入站的编码器和解码器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package com.safelocate.app.nettyserver; import io.netty.channel.channelinitializer; import io.netty.channel.socket.socketchannel; import io.netty.handler.codec.string.stringdecoder; import io.netty.handler.codec.string.stringencoder; import io.netty.util.charsetutil; public class serverchannelinitializer extends channelinitializer<socketchannel> { @override protected void initchannel(socketchannel channel) throws exception { channel.pipeline().addlast( "decoder" , new stringdecoder(charsetutil.utf_8)); channel.pipeline().addlast( "encoder" , new stringencoder(charsetutil.utf_8)); channel.pipeline().addlast( new serverhandler()); } } |
最好注意被别decoder和encoder写成了一样的,不然会出问题(我之前就是不小心都写成了stringdecoder...)
在这之后就是设置serverhandler来处理一些简单的逻辑了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
package com.safelocate.app.nettyserver; import io.netty.channel.channelhandlercontext; import io.netty.channel.channelinboundhandleradapter; import io.netty.channel.simplechannelinboundhandler; import java.io.ioexception; import java.io.outputstream; import java.io.printwriter; import java.net.inetaddress; import java.net.socket; public class serverhandler extends channelinboundhandleradapter { @override public void channelactive(channelhandlercontext ctx) { system.out.println( "channelactive----->" ); } @override public void channelread(channelhandlercontext ctx, object msg) throws exception { system.out.println( "server channelread......" ); system.out.println(ctx.channel().remoteaddress()+ "----->server :" + msg.tostring()); //将客户端的信息直接返回写入ctx ctx.write( "server say :" +msg); //刷新缓存区 ctx.flush(); } @override public void exceptioncaught(channelhandlercontext ctx, throwable cause) throws exception { cause.printstacktrace(); ctx.close(); } } |
准备工作到这里,现在要做到就是去启动这个程序
将appapplication实现commandlinerunner这个接口,这个接口可以用来再启动springboot时同时启动其他功能,比如配置,数据库连接等等
然后重写run方法,在run方法里启动netty服务器,server类用@autowired直接实例化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
package com.safelocate.app; import com.safelocate.app.nettyserver.nettyserver; import io.netty.channel.channelfuture; import org.springframework.beans.factory.annotation.autowired; import org.springframework.beans.factory.annotation.value; import org.springframework.boot.commandlinerunner; import org.springframework.boot.springapplication; import org.springframework.boot.autoconfigure.springbootapplication; import java.net.inetaddress; import java.net.inetsocketaddress; @springbootapplication public class appapplication implements commandlinerunner { @value ( "${netty.port}" ) private int port; @value ( "${netty.url}" ) private string url; @autowired private nettyserver server; public static void main(string[] args) { springapplication.run(appapplication. class , args); } @override public void run(string... args) throws exception { inetsocketaddress address = new inetsocketaddress(url,port); system.out.println( "run .... . ... " +url); server.start(address); } } |
ok,到这里服务端已经写完,本地我也已经测试完,现在需要打包部署服务器,当然这个程序只为练手...
控制台输入mvn clean package -d skiptests 然后将jar包上传服务器,在这之后,需要在腾讯云/阿里云那边配置好安全组,将之前yml文件里设定的端口的入站
规则设置好,不然访问会被拒绝
之后java -jar命令运行,如果需保持后台一直运行 就用nohup命令,可以看到程序已经跑起来了,等待客户端连接交互
之后就是写客户端了,客户端其实是依葫芦画瓢,跟上面类似
handler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package client; import io.netty.channel.channelhandlercontext; import io.netty.channel.channelinboundhandleradapter; public class clienthandler extends channelinboundhandleradapter { @override public void channelactive(channelhandlercontext ctx) { system.out.println( "clienthandler active" ); } @override public void channelread(channelhandlercontext ctx, object msg) { system.out.println( "--------" ); system.out.println( "clienthandler read message:" +msg); } @override public void exceptioncaught(channelhandlercontext ctx, throwable cause) { cause.printstacktrace(); ctx.close(); } } |
channelinitializer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package client; 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 io.netty.util.charsetutil; public class clientchannelinitializer extends channelinitializer<socketchannel> { protected void initchannel(socketchannel channel) throws exception { channelpipeline p = channel.pipeline(); p.addlast( "decoder" , new stringdecoder(charsetutil.utf_8)); p.addlast( "encoder" , new stringencoder(charsetutil.utf_8)); p.addlast( new clienthandler()); } } |
主函数所在类,即客户端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
package client; import io.netty.bootstrap.bootstrap; import io.netty.channel.*; import io.netty.channel.nio.nioeventloopgroup; import io.netty.channel.socket.socketchannel; import io.netty.channel.socket.nio.niosocketchannel; import io.netty.handler.codec.string.stringdecoder; import io.netty.handler.codec.string.stringencoder; public class client { static final string host = system.getproperty( "host" , "服务器的ip地址" ); static final int port = integer.parseint(system.getproperty( "port" , "7000" )); static final int size = integer.parseint(system.getproperty( "size" , "256" )); public static void main(string[] args) throws exception { sendmessage( "hhhh" ); } public static void sendmessage(string content) throws interruptedexception{ // configure the client. eventloopgroup group = new nioeventloopgroup(); try { bootstrap b = new bootstrap(); b.group(group) .channel(niosocketchannel. class ) .option(channeloption.tcp_nodelay, true ) .handler( new channelinitializer<socketchannel>() { @override public void initchannel(socketchannel ch) throws exception { channelpipeline p = ch.pipeline(); p.addlast( "decoder" , new stringdecoder()); p.addlast( "encoder" , new stringencoder()); p.addlast( new clienthandler()); } }); channelfuture future = b.connect(host, port).sync(); future.channel().writeandflush(content); future.channel().closefuture().sync(); } finally { group.shutdowngracefully(); } } } |
启动客户端,这里就是简单发送一条"hhhh",可以看到客户端已经收到服务器发来的信息
|
然后再看服务端,也有相应的信息打印
总结
以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对服务器之家的支持。
原文链接:https://www.cnblogs.com/Yintianhao/p/10181245.html